linux/scripts/kconfig/zconf.lex.c_shipped
<<
>>
Prefs
   1
   2#line 3 "scripts/kconfig/zconf.lex.c_shipped"
   3
   4#define  YY_INT_ALIGNED short int
   5
   6/* A lexical scanner generated by flex */
   7
   8#define yy_create_buffer zconf_create_buffer
   9#define yy_delete_buffer zconf_delete_buffer
  10#define yy_flex_debug zconf_flex_debug
  11#define yy_init_buffer zconf_init_buffer
  12#define yy_flush_buffer zconf_flush_buffer
  13#define yy_load_buffer_state zconf_load_buffer_state
  14#define yy_switch_to_buffer zconf_switch_to_buffer
  15#define yyin zconfin
  16#define yyleng zconfleng
  17#define yylex zconflex
  18#define yylineno zconflineno
  19#define yyout zconfout
  20#define yyrestart zconfrestart
  21#define yytext zconftext
  22#define yywrap zconfwrap
  23#define yyalloc zconfalloc
  24#define yyrealloc zconfrealloc
  25#define yyfree zconffree
  26
  27#define FLEX_SCANNER
  28#define YY_FLEX_MAJOR_VERSION 2
  29#define YY_FLEX_MINOR_VERSION 5
  30#define YY_FLEX_SUBMINOR_VERSION 35
  31#if YY_FLEX_SUBMINOR_VERSION > 0
  32#define FLEX_BETA
  33#endif
  34
  35/* First, we deal with  platform-specific or compiler-specific issues. */
  36
  37/* begin standard C headers. */
  38#include <stdio.h>
  39#include <string.h>
  40#include <errno.h>
  41#include <stdlib.h>
  42
  43/* end standard C headers. */
  44
  45/* flex integer type definitions */
  46
  47#ifndef FLEXINT_H
  48#define FLEXINT_H
  49
  50/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  51
  52#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  53
  54/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  55 * if you want the limit (max/min) macros for int types. 
  56 */
  57#ifndef __STDC_LIMIT_MACROS
  58#define __STDC_LIMIT_MACROS 1
  59#endif
  60
  61#include <inttypes.h>
  62typedef int8_t flex_int8_t;
  63typedef uint8_t flex_uint8_t;
  64typedef int16_t flex_int16_t;
  65typedef uint16_t flex_uint16_t;
  66typedef int32_t flex_int32_t;
  67typedef uint32_t flex_uint32_t;
  68#else
  69typedef signed char flex_int8_t;
  70typedef short int flex_int16_t;
  71typedef int flex_int32_t;
  72typedef unsigned char flex_uint8_t; 
  73typedef unsigned short int flex_uint16_t;
  74typedef unsigned int flex_uint32_t;
  75#endif /* ! C99 */
  76
  77/* Limits of integral types. */
  78#ifndef INT8_MIN
  79#define INT8_MIN               (-128)
  80#endif
  81#ifndef INT16_MIN
  82#define INT16_MIN              (-32767-1)
  83#endif
  84#ifndef INT32_MIN
  85#define INT32_MIN              (-2147483647-1)
  86#endif
  87#ifndef INT8_MAX
  88#define INT8_MAX               (127)
  89#endif
  90#ifndef INT16_MAX
  91#define INT16_MAX              (32767)
  92#endif
  93#ifndef INT32_MAX
  94#define INT32_MAX              (2147483647)
  95#endif
  96#ifndef UINT8_MAX
  97#define UINT8_MAX              (255U)
  98#endif
  99#ifndef UINT16_MAX
 100#define UINT16_MAX             (65535U)
 101#endif
 102#ifndef UINT32_MAX
 103#define UINT32_MAX             (4294967295U)
 104#endif
 105
 106#endif /* ! FLEXINT_H */
 107
 108#ifdef __cplusplus
 109
 110/* The "const" storage-class-modifier is valid. */
 111#define YY_USE_CONST
 112
 113#else   /* ! __cplusplus */
 114
 115/* C99 requires __STDC__ to be defined as 1. */
 116#if defined (__STDC__)
 117
 118#define YY_USE_CONST
 119
 120#endif  /* defined (__STDC__) */
 121#endif  /* ! __cplusplus */
 122
 123#ifdef YY_USE_CONST
 124#define yyconst const
 125#else
 126#define yyconst
 127#endif
 128
 129/* Returned upon end-of-file. */
 130#define YY_NULL 0
 131
 132/* Promotes a possibly negative, possibly signed char to an unsigned
 133 * integer for use as an array index.  If the signed char is negative,
 134 * we want to instead treat it as an 8-bit unsigned char, hence the
 135 * double cast.
 136 */
 137#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 138
 139/* Enter a start condition.  This macro really ought to take a parameter,
 140 * but we do it the disgusting crufty way forced on us by the ()-less
 141 * definition of BEGIN.
 142 */
 143#define BEGIN (yy_start) = 1 + 2 *
 144
 145/* Translate the current start state into a value that can be later handed
 146 * to BEGIN to return to the state.  The YYSTATE alias is for lex
 147 * compatibility.
 148 */
 149#define YY_START (((yy_start) - 1) / 2)
 150#define YYSTATE YY_START
 151
 152/* Action number for EOF rule of a given start state. */
 153#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 154
 155/* Special action meaning "start processing a new file". */
 156#define YY_NEW_FILE zconfrestart(zconfin  )
 157
 158#define YY_END_OF_BUFFER_CHAR 0
 159
 160/* Size of default input buffer. */
 161#ifndef YY_BUF_SIZE
 162#define YY_BUF_SIZE 16384
 163#endif
 164
 165/* The state buf must be large enough to hold one state per character in the main buffer.
 166 */
 167#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 168
 169#ifndef YY_TYPEDEF_YY_BUFFER_STATE
 170#define YY_TYPEDEF_YY_BUFFER_STATE
 171typedef struct yy_buffer_state *YY_BUFFER_STATE;
 172#endif
 173
 174extern int zconfleng;
 175
 176extern FILE *zconfin, *zconfout;
 177
 178#define EOB_ACT_CONTINUE_SCAN 0
 179#define EOB_ACT_END_OF_FILE 1
 180#define EOB_ACT_LAST_MATCH 2
 181
 182    #define YY_LESS_LINENO(n)
 183    
 184/* Return all but the first "n" matched characters back to the input stream. */
 185#define yyless(n) \
 186        do \
 187                { \
 188                /* Undo effects of setting up zconftext. */ \
 189        int yyless_macro_arg = (n); \
 190        YY_LESS_LINENO(yyless_macro_arg);\
 191                *yy_cp = (yy_hold_char); \
 192                YY_RESTORE_YY_MORE_OFFSET \
 193                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 194                YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
 195                } \
 196        while ( 0 )
 197
 198#define unput(c) yyunput( c, (yytext_ptr)  )
 199
 200#ifndef YY_TYPEDEF_YY_SIZE_T
 201#define YY_TYPEDEF_YY_SIZE_T
 202typedef size_t yy_size_t;
 203#endif
 204
 205#ifndef YY_STRUCT_YY_BUFFER_STATE
 206#define YY_STRUCT_YY_BUFFER_STATE
 207struct yy_buffer_state
 208        {
 209        FILE *yy_input_file;
 210
 211        char *yy_ch_buf;                /* input buffer */
 212        char *yy_buf_pos;               /* current position in input buffer */
 213
 214        /* Size of input buffer in bytes, not including room for EOB
 215         * characters.
 216         */
 217        yy_size_t yy_buf_size;
 218
 219        /* Number of characters read into yy_ch_buf, not including EOB
 220         * characters.
 221         */
 222        int yy_n_chars;
 223
 224        /* Whether we "own" the buffer - i.e., we know we created it,
 225         * and can realloc() it to grow it, and should free() it to
 226         * delete it.
 227         */
 228        int yy_is_our_buffer;
 229
 230        /* Whether this is an "interactive" input source; if so, and
 231         * if we're using stdio for input, then we want to use getc()
 232         * instead of fread(), to make sure we stop fetching input after
 233         * each newline.
 234         */
 235        int yy_is_interactive;
 236
 237        /* Whether we're considered to be at the beginning of a line.
 238         * If so, '^' rules will be active on the next match, otherwise
 239         * not.
 240         */
 241        int yy_at_bol;
 242
 243    int yy_bs_lineno; /**< The line count. */
 244    int yy_bs_column; /**< The column count. */
 245    
 246        /* Whether to try to fill the input buffer when we reach the
 247         * end of it.
 248         */
 249        int yy_fill_buffer;
 250
 251        int yy_buffer_status;
 252
 253#define YY_BUFFER_NEW 0
 254#define YY_BUFFER_NORMAL 1
 255        /* When an EOF's been seen but there's still some text to process
 256         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 257         * shouldn't try reading from the input source any more.  We might
 258         * still have a bunch of tokens to match, though, because of
 259         * possible backing-up.
 260         *
 261         * When we actually see the EOF, we change the status to "new"
 262         * (via zconfrestart()), so that the user can continue scanning by
 263         * just pointing zconfin at a new input file.
 264         */
 265#define YY_BUFFER_EOF_PENDING 2
 266
 267        };
 268#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 269
 270/* Stack of input buffers. */
 271static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 272static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 273static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 274
 275/* We provide macros for accessing buffer states in case in the
 276 * future we want to put the buffer states in a more general
 277 * "scanner state".
 278 *
 279 * Returns the top of the stack, or NULL.
 280 */
 281#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 282                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 283                          : NULL)
 284
 285/* Same as previous macro, but useful when we know that the buffer stack is not
 286 * NULL or when we need an lvalue. For internal use only.
 287 */
 288#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 289
 290/* yy_hold_char holds the character lost when zconftext is formed. */
 291static char yy_hold_char;
 292static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 293int zconfleng;
 294
 295/* Points to current character in buffer. */
 296static char *yy_c_buf_p = (char *) 0;
 297static int yy_init = 0;         /* whether we need to initialize */
 298static int yy_start = 0;        /* start state number */
 299
 300/* Flag which is used to allow zconfwrap()'s to do buffer switches
 301 * instead of setting up a fresh zconfin.  A bit of a hack ...
 302 */
 303static int yy_did_buffer_switch_on_eof;
 304
 305void zconfrestart (FILE *input_file  );
 306void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 307YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size  );
 308void zconf_delete_buffer (YY_BUFFER_STATE b  );
 309void zconf_flush_buffer (YY_BUFFER_STATE b  );
 310void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer  );
 311void zconfpop_buffer_state (void );
 312
 313static void zconfensure_buffer_stack (void );
 314static void zconf_load_buffer_state (void );
 315static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 316
 317#define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
 318
 319YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size  );
 320YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str  );
 321YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len  );
 322
 323void *zconfalloc (yy_size_t  );
 324void *zconfrealloc (void *,yy_size_t  );
 325void zconffree (void *  );
 326
 327#define yy_new_buffer zconf_create_buffer
 328
 329#define yy_set_interactive(is_interactive) \
 330        { \
 331        if ( ! YY_CURRENT_BUFFER ){ \
 332        zconfensure_buffer_stack (); \
 333                YY_CURRENT_BUFFER_LVALUE =    \
 334            zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
 335        } \
 336        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 337        }
 338
 339#define yy_set_bol(at_bol) \
 340        { \
 341        if ( ! YY_CURRENT_BUFFER ){\
 342        zconfensure_buffer_stack (); \
 343                YY_CURRENT_BUFFER_LVALUE =    \
 344            zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
 345        } \
 346        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 347        }
 348
 349#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 350
 351/* Begin user sect3 */
 352
 353#define zconfwrap(n) 1
 354#define YY_SKIP_YYWRAP
 355
 356typedef unsigned char YY_CHAR;
 357
 358FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
 359
 360typedef int yy_state_type;
 361
 362extern int zconflineno;
 363
 364int zconflineno = 1;
 365
 366extern char *zconftext;
 367#define yytext_ptr zconftext
 368static yyconst flex_int16_t yy_nxt[][17] =
 369    {
 370    {
 371        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 372        0,    0,    0,    0,    0,    0,    0
 373    },
 374
 375    {
 376       11,   12,   13,   14,   12,   12,   15,   12,   12,   12,
 377       12,   12,   12,   12,   12,   12,   12
 378    },
 379
 380    {
 381       11,   12,   13,   14,   12,   12,   15,   12,   12,   12,
 382       12,   12,   12,   12,   12,   12,   12
 383    },
 384
 385    {
 386       11,   16,   16,   17,   16,   16,   16,   16,   16,   16,
 387       16,   16,   16,   18,   16,   16,   16
 388    },
 389
 390    {
 391       11,   16,   16,   17,   16,   16,   16,   16,   16,   16,
 392       16,   16,   16,   18,   16,   16,   16
 393
 394    },
 395
 396    {
 397       11,   19,   20,   21,   19,   19,   19,   19,   19,   19,
 398       19,   19,   19,   19,   19,   19,   19
 399    },
 400
 401    {
 402       11,   19,   20,   21,   19,   19,   19,   19,   19,   19,
 403       19,   19,   19,   19,   19,   19,   19
 404    },
 405
 406    {
 407       11,   22,   22,   23,   22,   24,   22,   22,   24,   22,
 408       22,   22,   22,   22,   22,   25,   22
 409    },
 410
 411    {
 412       11,   22,   22,   23,   22,   24,   22,   22,   24,   22,
 413       22,   22,   22,   22,   22,   25,   22
 414    },
 415
 416    {
 417       11,   26,   26,   27,   28,   29,   30,   31,   29,   32,
 418       33,   34,   35,   35,   36,   37,   38
 419
 420    },
 421
 422    {
 423       11,   26,   26,   27,   28,   29,   30,   31,   29,   32,
 424       33,   34,   35,   35,   36,   37,   38
 425    },
 426
 427    {
 428      -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
 429      -11,  -11,  -11,  -11,  -11,  -11,  -11
 430    },
 431
 432    {
 433       11,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
 434      -12,  -12,  -12,  -12,  -12,  -12,  -12
 435    },
 436
 437    {
 438       11,  -13,   39,   40,  -13,  -13,   41,  -13,  -13,  -13,
 439      -13,  -13,  -13,  -13,  -13,  -13,  -13
 440    },
 441
 442    {
 443       11,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
 444      -14,  -14,  -14,  -14,  -14,  -14,  -14
 445
 446    },
 447
 448    {
 449       11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
 450       42,   42,   42,   42,   42,   42,   42
 451    },
 452
 453    {
 454       11,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
 455      -16,  -16,  -16,  -16,  -16,  -16,  -16
 456    },
 457
 458    {
 459       11,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
 460      -17,  -17,  -17,  -17,  -17,  -17,  -17
 461    },
 462
 463    {
 464       11,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
 465      -18,  -18,  -18,   44,  -18,  -18,  -18
 466    },
 467
 468    {
 469       11,   45,   45,  -19,   45,   45,   45,   45,   45,   45,
 470       45,   45,   45,   45,   45,   45,   45
 471
 472    },
 473
 474    {
 475       11,  -20,   46,   47,  -20,  -20,  -20,  -20,  -20,  -20,
 476      -20,  -20,  -20,  -20,  -20,  -20,  -20
 477    },
 478
 479    {
 480       11,   48,  -21,  -21,   48,   48,   48,   48,   48,   48,
 481       48,   48,   48,   48,   48,   48,   48
 482    },
 483
 484    {
 485       11,   49,   49,   50,   49,  -22,   49,   49,  -22,   49,
 486       49,   49,   49,   49,   49,  -22,   49
 487    },
 488
 489    {
 490       11,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
 491      -23,  -23,  -23,  -23,  -23,  -23,  -23
 492    },
 493
 494    {
 495       11,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
 496      -24,  -24,  -24,  -24,  -24,  -24,  -24
 497
 498    },
 499
 500    {
 501       11,   51,   51,   52,   51,   51,   51,   51,   51,   51,
 502       51,   51,   51,   51,   51,   51,   51
 503    },
 504
 505    {
 506       11,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
 507      -26,  -26,  -26,  -26,  -26,  -26,  -26
 508    },
 509
 510    {
 511       11,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
 512      -27,  -27,  -27,  -27,  -27,  -27,  -27
 513    },
 514
 515    {
 516       11,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
 517      -28,  -28,  -28,  -28,   53,  -28,  -28
 518    },
 519
 520    {
 521       11,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
 522      -29,  -29,  -29,  -29,  -29,  -29,  -29
 523
 524    },
 525
 526    {
 527       11,   54,   54,  -30,   54,   54,   54,   54,   54,   54,
 528       54,   54,   54,   54,   54,   54,   54
 529    },
 530
 531    {
 532       11,  -31,  -31,  -31,  -31,  -31,  -31,   55,  -31,  -31,
 533      -31,  -31,  -31,  -31,  -31,  -31,  -31
 534    },
 535
 536    {
 537       11,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
 538      -32,  -32,  -32,  -32,  -32,  -32,  -32
 539    },
 540
 541    {
 542       11,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
 543      -33,  -33,  -33,  -33,  -33,  -33,  -33
 544    },
 545
 546    {
 547       11,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
 548      -34,   56,   57,   57,  -34,  -34,  -34
 549
 550    },
 551
 552    {
 553       11,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
 554      -35,   57,   57,   57,  -35,  -35,  -35
 555    },
 556
 557    {
 558       11,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
 559      -36,  -36,  -36,  -36,  -36,  -36,  -36
 560    },
 561
 562    {
 563       11,  -37,  -37,   58,  -37,  -37,  -37,  -37,  -37,  -37,
 564      -37,  -37,  -37,  -37,  -37,  -37,  -37
 565    },
 566
 567    {
 568       11,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
 569      -38,  -38,  -38,  -38,  -38,  -38,   59
 570    },
 571
 572    {
 573       11,  -39,   39,   40,  -39,  -39,   41,  -39,  -39,  -39,
 574      -39,  -39,  -39,  -39,  -39,  -39,  -39
 575
 576    },
 577
 578    {
 579       11,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
 580      -40,  -40,  -40,  -40,  -40,  -40,  -40
 581    },
 582
 583    {
 584       11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
 585       42,   42,   42,   42,   42,   42,   42
 586    },
 587
 588    {
 589       11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
 590       42,   42,   42,   42,   42,   42,   42
 591    },
 592
 593    {
 594       11,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
 595      -43,  -43,  -43,  -43,  -43,  -43,  -43
 596    },
 597
 598    {
 599       11,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
 600      -44,  -44,  -44,   44,  -44,  -44,  -44
 601
 602    },
 603
 604    {
 605       11,   45,   45,  -45,   45,   45,   45,   45,   45,   45,
 606       45,   45,   45,   45,   45,   45,   45
 607    },
 608
 609    {
 610       11,  -46,   46,   47,  -46,  -46,  -46,  -46,  -46,  -46,
 611      -46,  -46,  -46,  -46,  -46,  -46,  -46
 612    },
 613
 614    {
 615       11,   48,  -47,  -47,   48,   48,   48,   48,   48,   48,
 616       48,   48,   48,   48,   48,   48,   48
 617    },
 618
 619    {
 620       11,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
 621      -48,  -48,  -48,  -48,  -48,  -48,  -48
 622    },
 623
 624    {
 625       11,   49,   49,   50,   49,  -49,   49,   49,  -49,   49,
 626       49,   49,   49,   49,   49,  -49,   49
 627
 628    },
 629
 630    {
 631       11,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
 632      -50,  -50,  -50,  -50,  -50,  -50,  -50
 633    },
 634
 635    {
 636       11,  -51,  -51,   52,  -51,  -51,  -51,  -51,  -51,  -51,
 637      -51,  -51,  -51,  -51,  -51,  -51,  -51
 638    },
 639
 640    {
 641       11,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
 642      -52,  -52,  -52,  -52,  -52,  -52,  -52
 643    },
 644
 645    {
 646       11,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
 647      -53,  -53,  -53,  -53,  -53,  -53,  -53
 648    },
 649
 650    {
 651       11,   54,   54,  -54,   54,   54,   54,   54,   54,   54,
 652       54,   54,   54,   54,   54,   54,   54
 653
 654    },
 655
 656    {
 657       11,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
 658      -55,  -55,  -55,  -55,  -55,  -55,  -55
 659    },
 660
 661    {
 662       11,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
 663      -56,   60,   57,   57,  -56,  -56,  -56
 664    },
 665
 666    {
 667       11,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
 668      -57,   57,   57,   57,  -57,  -57,  -57
 669    },
 670
 671    {
 672       11,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
 673      -58,  -58,  -58,  -58,  -58,  -58,  -58
 674    },
 675
 676    {
 677       11,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
 678      -59,  -59,  -59,  -59,  -59,  -59,  -59
 679
 680    },
 681
 682    {
 683       11,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
 684      -60,   57,   57,   57,  -60,  -60,  -60
 685    },
 686
 687    } ;
 688
 689static yy_state_type yy_get_previous_state (void );
 690static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 691static int yy_get_next_buffer (void );
 692static void yy_fatal_error (yyconst char msg[]  );
 693
 694/* Done after the current pattern has been matched and before the
 695 * corresponding action - sets up zconftext.
 696 */
 697#define YY_DO_BEFORE_ACTION \
 698        (yytext_ptr) = yy_bp; \
 699        zconfleng = (size_t) (yy_cp - yy_bp); \
 700        (yy_hold_char) = *yy_cp; \
 701        *yy_cp = '\0'; \
 702        (yy_c_buf_p) = yy_cp;
 703
 704#define YY_NUM_RULES 33
 705#define YY_END_OF_BUFFER 34
 706/* This struct is not used in this scanner,
 707   but its presence is necessary. */
 708struct yy_trans_info
 709        {
 710        flex_int32_t yy_verify;
 711        flex_int32_t yy_nxt;
 712        };
 713static yyconst flex_int16_t yy_accept[61] =
 714    {   0,
 715        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 716       34,    5,    4,    2,    3,    7,    8,    6,   32,   29,
 717       31,   24,   28,   27,   26,   22,   17,   13,   16,   20,
 718       22,   11,   12,   19,   19,   14,   22,   22,    4,    2,
 719        3,    3,    1,    6,   32,   29,   31,   30,   24,   23,
 720       26,   25,   15,   20,    9,   19,   19,   21,   10,   18
 721    } ;
 722
 723static yyconst flex_int32_t yy_ec[256] =
 724    {   0,
 725        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 726        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 727        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 728        1,    2,    4,    5,    6,    1,    1,    7,    8,    9,
 729       10,    1,    1,    1,   11,   12,   12,   13,   13,   13,
 730       13,   13,   13,   13,   13,   13,   13,    1,    1,    1,
 731       14,    1,    1,    1,   13,   13,   13,   13,   13,   13,
 732       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
 733       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
 734        1,   15,    1,    1,   13,    1,   13,   13,   13,   13,
 735
 736       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
 737       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
 738       13,   13,    1,   16,    1,    1,    1,    1,    1,    1,
 739        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 740        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 741        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 742        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 743        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 744        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 745        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 746
 747        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 748        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 749        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 750        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 751        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 752        1,    1,    1,    1,    1
 753    } ;
 754
 755extern int zconf_flex_debug;
 756int zconf_flex_debug = 0;
 757
 758/* The intent behind this definition is that it'll catch
 759 * any uses of REJECT which flex missed.
 760 */
 761#define REJECT reject_used_but_not_detected
 762#define yymore() yymore_used_but_not_detected
 763#define YY_MORE_ADJ 0
 764#define YY_RESTORE_YY_MORE_OFFSET
 765char *zconftext;
 766#define YY_NO_INPUT 1
 767
 768/*
 769 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
 770 * Released under the terms of the GNU GPL v2.0.
 771 */
 772
 773#include <limits.h>
 774#include <stdio.h>
 775#include <stdlib.h>
 776#include <string.h>
 777#include <unistd.h>
 778
 779#include "lkc.h"
 780
 781#define START_STRSIZE   16
 782
 783static struct {
 784        struct file *file;
 785        int lineno;
 786} current_pos;
 787
 788static char *text;
 789static int text_size, text_asize;
 790
 791struct buffer {
 792        struct buffer *parent;
 793        YY_BUFFER_STATE state;
 794};
 795
 796struct buffer *current_buf;
 797
 798static int last_ts, first_ts;
 799
 800static void zconf_endhelp(void);
 801static void zconf_endfile(void);
 802
 803static void new_string(void)
 804{
 805        text = malloc(START_STRSIZE);
 806        text_asize = START_STRSIZE;
 807        text_size = 0;
 808        *text = 0;
 809}
 810
 811static void append_string(const char *str, int size)
 812{
 813        int new_size = text_size + size + 1;
 814        if (new_size > text_asize) {
 815                new_size += START_STRSIZE - 1;
 816                new_size &= -START_STRSIZE;
 817                text = realloc(text, new_size);
 818                text_asize = new_size;
 819        }
 820        memcpy(text + text_size, str, size);
 821        text_size += size;
 822        text[text_size] = 0;
 823}
 824
 825static void alloc_string(const char *str, int size)
 826{
 827        text = malloc(size + 1);
 828        memcpy(text, str, size);
 829        text[size] = 0;
 830}
 831
 832#define INITIAL 0
 833#define COMMAND 1
 834#define HELP 2
 835#define STRING 3
 836#define PARAM 4
 837
 838#ifndef YY_NO_UNISTD_H
 839/* Special case for "unistd.h", since it is non-ANSI. We include it way
 840 * down here because we want the user's section 1 to have been scanned first.
 841 * The user has a chance to override it with an option.
 842 */
 843#include <unistd.h>
 844#endif
 845
 846#ifndef YY_EXTRA_TYPE
 847#define YY_EXTRA_TYPE void *
 848#endif
 849
 850static int yy_init_globals (void );
 851
 852/* Accessor methods to globals.
 853   These are made visible to non-reentrant scanners for convenience. */
 854
 855int zconflex_destroy (void );
 856
 857int zconfget_debug (void );
 858
 859void zconfset_debug (int debug_flag  );
 860
 861YY_EXTRA_TYPE zconfget_extra (void );
 862
 863void zconfset_extra (YY_EXTRA_TYPE user_defined  );
 864
 865FILE *zconfget_in (void );
 866
 867void zconfset_in  (FILE * in_str  );
 868
 869FILE *zconfget_out (void );
 870
 871void zconfset_out  (FILE * out_str  );
 872
 873int zconfget_leng (void );
 874
 875char *zconfget_text (void );
 876
 877int zconfget_lineno (void );
 878
 879void zconfset_lineno (int line_number  );
 880
 881/* Macros after this point can all be overridden by user definitions in
 882 * section 1.
 883 */
 884
 885#ifndef YY_SKIP_YYWRAP
 886#ifdef __cplusplus
 887extern "C" int zconfwrap (void );
 888#else
 889extern int zconfwrap (void );
 890#endif
 891#endif
 892
 893    static void yyunput (int c,char *buf_ptr  );
 894    
 895#ifndef yytext_ptr
 896static void yy_flex_strncpy (char *,yyconst char *,int );
 897#endif
 898
 899#ifdef YY_NEED_STRLEN
 900static int yy_flex_strlen (yyconst char * );
 901#endif
 902
 903#ifndef YY_NO_INPUT
 904
 905#ifdef __cplusplus
 906static int yyinput (void );
 907#else
 908static int input (void );
 909#endif
 910
 911#endif
 912
 913/* Amount of stuff to slurp up with each read. */
 914#ifndef YY_READ_BUF_SIZE
 915#define YY_READ_BUF_SIZE 8192
 916#endif
 917
 918/* Copy whatever the last rule matched to the standard output. */
 919#ifndef ECHO
 920/* This used to be an fputs(), but since the string might contain NUL's,
 921 * we now use fwrite().
 922 */
 923#define ECHO do { if (fwrite( zconftext, zconfleng, 1, zconfout )) {} } while (0)
 924#endif
 925
 926/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 927 * is returned in "result".
 928 */
 929#ifndef YY_INPUT
 930#define YY_INPUT(buf,result,max_size) \
 931        errno=0; \
 932        while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
 933        { \
 934                if( errno != EINTR) \
 935                { \
 936                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
 937                        break; \
 938                } \
 939                errno=0; \
 940                clearerr(zconfin); \
 941        }\
 942\
 943
 944#endif
 945
 946/* No semi-colon after return; correct usage is to write "yyterminate();" -
 947 * we don't want an extra ';' after the "return" because that will cause
 948 * some compilers to complain about unreachable statements.
 949 */
 950#ifndef yyterminate
 951#define yyterminate() return YY_NULL
 952#endif
 953
 954/* Number of entries by which start-condition stack grows. */
 955#ifndef YY_START_STACK_INCR
 956#define YY_START_STACK_INCR 25
 957#endif
 958
 959/* Report a fatal error. */
 960#ifndef YY_FATAL_ERROR
 961#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 962#endif
 963
 964/* end tables serialization structures and prototypes */
 965
 966/* Default declaration of generated scanner - a define so the user can
 967 * easily add parameters.
 968 */
 969#ifndef YY_DECL
 970#define YY_DECL_IS_OURS 1
 971
 972extern int zconflex (void);
 973
 974#define YY_DECL int zconflex (void)
 975#endif /* !YY_DECL */
 976
 977/* Code executed at the beginning of each rule, after zconftext and zconfleng
 978 * have been set up.
 979 */
 980#ifndef YY_USER_ACTION
 981#define YY_USER_ACTION
 982#endif
 983
 984/* Code executed at the end of each rule. */
 985#ifndef YY_BREAK
 986#define YY_BREAK break;
 987#endif
 988
 989#define YY_RULE_SETUP \
 990        YY_USER_ACTION
 991
 992/** The main scanner function which does all the work.
 993 */
 994YY_DECL
 995{
 996        register yy_state_type yy_current_state;
 997        register char *yy_cp, *yy_bp;
 998        register int yy_act;
 999    
1000        int str = 0;
1001        int ts, i;
1002
1003        if ( !(yy_init) )
1004                {
1005                (yy_init) = 1;
1006
1007#ifdef YY_USER_INIT
1008                YY_USER_INIT;
1009#endif
1010
1011                if ( ! (yy_start) )
1012                        (yy_start) = 1; /* first start state */
1013
1014                if ( ! zconfin )
1015                        zconfin = stdin;
1016
1017                if ( ! zconfout )
1018                        zconfout = stdout;
1019
1020                if ( ! YY_CURRENT_BUFFER ) {
1021                        zconfensure_buffer_stack ();
1022                        YY_CURRENT_BUFFER_LVALUE =
1023                                zconf_create_buffer(zconfin,YY_BUF_SIZE );
1024                }
1025
1026                zconf_load_buffer_state( );
1027                }
1028
1029        while ( 1 )             /* loops until end-of-file is reached */
1030                {
1031                yy_cp = (yy_c_buf_p);
1032
1033                /* Support of zconftext. */
1034                *yy_cp = (yy_hold_char);
1035
1036                /* yy_bp points to the position in yy_ch_buf of the start of
1037                 * the current run.
1038                 */
1039                yy_bp = yy_cp;
1040
1041                yy_current_state = (yy_start);
1042yy_match:
1043                while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)]  ]) > 0 )
1044                        ++yy_cp;
1045
1046                yy_current_state = -yy_current_state;
1047
1048yy_find_action:
1049                yy_act = yy_accept[yy_current_state];
1050
1051                YY_DO_BEFORE_ACTION;
1052
1053do_action:      /* This label is used only to access EOF actions. */
1054
1055                switch ( yy_act )
1056        { /* beginning of action switch */
1057case 1:
1058/* rule 1 can match eol */
1059case 2:
1060/* rule 2 can match eol */
1061YY_RULE_SETUP
1062{
1063        current_file->lineno++;
1064        return T_EOL;
1065}
1066        YY_BREAK
1067case 3:
1068YY_RULE_SETUP
1069
1070        YY_BREAK
1071case 4:
1072YY_RULE_SETUP
1073{
1074        BEGIN(COMMAND);
1075}
1076        YY_BREAK
1077case 5:
1078YY_RULE_SETUP
1079{
1080        unput(zconftext[0]);
1081        BEGIN(COMMAND);
1082}
1083        YY_BREAK
1084
1085case 6:
1086YY_RULE_SETUP
1087{
1088                const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1089                BEGIN(PARAM);
1090                current_pos.file = current_file;
1091                current_pos.lineno = current_file->lineno;
1092                if (id && id->flags & TF_COMMAND) {
1093                        zconflval.id = id;
1094                        return id->token;
1095                }
1096                alloc_string(zconftext, zconfleng);
1097                zconflval.string = text;
1098                return T_WORD;
1099        }
1100        YY_BREAK
1101case 7:
1102YY_RULE_SETUP
1103
1104        YY_BREAK
1105case 8:
1106/* rule 8 can match eol */
1107YY_RULE_SETUP
1108{
1109                BEGIN(INITIAL);
1110                current_file->lineno++;
1111                return T_EOL;
1112        }
1113        YY_BREAK
1114
1115case 9:
1116YY_RULE_SETUP
1117return T_AND;
1118        YY_BREAK
1119case 10:
1120YY_RULE_SETUP
1121return T_OR;
1122        YY_BREAK
1123case 11:
1124YY_RULE_SETUP
1125return T_OPEN_PAREN;
1126        YY_BREAK
1127case 12:
1128YY_RULE_SETUP
1129return T_CLOSE_PAREN;
1130        YY_BREAK
1131case 13:
1132YY_RULE_SETUP
1133return T_NOT;
1134        YY_BREAK
1135case 14:
1136YY_RULE_SETUP
1137return T_EQUAL;
1138        YY_BREAK
1139case 15:
1140YY_RULE_SETUP
1141return T_UNEQUAL;
1142        YY_BREAK
1143case 16:
1144YY_RULE_SETUP
1145{
1146                str = zconftext[0];
1147                new_string();
1148                BEGIN(STRING);
1149        }
1150        YY_BREAK
1151case 17:
1152/* rule 17 can match eol */
1153YY_RULE_SETUP
1154BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1155        YY_BREAK
1156case 18:
1157YY_RULE_SETUP
1158/* ignore */
1159        YY_BREAK
1160case 19:
1161YY_RULE_SETUP
1162{
1163                const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1164                if (id && id->flags & TF_PARAM) {
1165                        zconflval.id = id;
1166                        return id->token;
1167                }
1168                alloc_string(zconftext, zconfleng);
1169                zconflval.string = text;
1170                return T_WORD;
1171        }
1172        YY_BREAK
1173case 20:
1174YY_RULE_SETUP
1175/* comment */
1176        YY_BREAK
1177case 21:
1178/* rule 21 can match eol */
1179YY_RULE_SETUP
1180current_file->lineno++;
1181        YY_BREAK
1182case 22:
1183YY_RULE_SETUP
1184
1185        YY_BREAK
1186case YY_STATE_EOF(PARAM):
1187{
1188                BEGIN(INITIAL);
1189        }
1190        YY_BREAK
1191
1192case 23:
1193/* rule 23 can match eol */
1194*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1195(yy_c_buf_p) = yy_cp -= 1;
1196YY_DO_BEFORE_ACTION; /* set up zconftext again */
1197YY_RULE_SETUP
1198{
1199                append_string(zconftext, zconfleng);
1200                zconflval.string = text;
1201                return T_WORD_QUOTE;
1202        }
1203        YY_BREAK
1204case 24:
1205YY_RULE_SETUP
1206{
1207                append_string(zconftext, zconfleng);
1208        }
1209        YY_BREAK
1210case 25:
1211/* rule 25 can match eol */
1212*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1213(yy_c_buf_p) = yy_cp -= 1;
1214YY_DO_BEFORE_ACTION; /* set up zconftext again */
1215YY_RULE_SETUP
1216{
1217                append_string(zconftext + 1, zconfleng - 1);
1218                zconflval.string = text;
1219                return T_WORD_QUOTE;
1220        }
1221        YY_BREAK
1222case 26:
1223YY_RULE_SETUP
1224{
1225                append_string(zconftext + 1, zconfleng - 1);
1226        }
1227        YY_BREAK
1228case 27:
1229YY_RULE_SETUP
1230{
1231                if (str == zconftext[0]) {
1232                        BEGIN(PARAM);
1233                        zconflval.string = text;
1234                        return T_WORD_QUOTE;
1235                } else
1236                        append_string(zconftext, 1);
1237        }
1238        YY_BREAK
1239case 28:
1240/* rule 28 can match eol */
1241YY_RULE_SETUP
1242{
1243                printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
1244                current_file->lineno++;
1245                BEGIN(INITIAL);
1246                return T_EOL;
1247        }
1248        YY_BREAK
1249case YY_STATE_EOF(STRING):
1250{
1251                BEGIN(INITIAL);
1252        }
1253        YY_BREAK
1254
1255case 29:
1256YY_RULE_SETUP
1257{
1258                ts = 0;
1259                for (i = 0; i < zconfleng; i++) {
1260                        if (zconftext[i] == '\t')
1261                                ts = (ts & ~7) + 8;
1262                        else
1263                                ts++;
1264                }
1265                last_ts = ts;
1266                if (first_ts) {
1267                        if (ts < first_ts) {
1268                                zconf_endhelp();
1269                                return T_HELPTEXT;
1270                        }
1271                        ts -= first_ts;
1272                        while (ts > 8) {
1273                                append_string("        ", 8);
1274                                ts -= 8;
1275                        }
1276                        append_string("        ", ts);
1277                }
1278        }
1279        YY_BREAK
1280case 30:
1281/* rule 30 can match eol */
1282*yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1283(yy_c_buf_p) = yy_cp -= 1;
1284YY_DO_BEFORE_ACTION; /* set up zconftext again */
1285YY_RULE_SETUP
1286{
1287                current_file->lineno++;
1288                zconf_endhelp();
1289                return T_HELPTEXT;
1290        }
1291        YY_BREAK
1292case 31:
1293/* rule 31 can match eol */
1294YY_RULE_SETUP
1295{
1296                current_file->lineno++;
1297                append_string("\n", 1);
1298        }
1299        YY_BREAK
1300case 32:
1301YY_RULE_SETUP
1302{
1303                while (zconfleng) {
1304                        if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
1305                                break;
1306                        zconfleng--;
1307                }
1308                append_string(zconftext, zconfleng);
1309                if (!first_ts)
1310                        first_ts = last_ts;
1311        }
1312        YY_BREAK
1313case YY_STATE_EOF(HELP):
1314{
1315                zconf_endhelp();
1316                return T_HELPTEXT;
1317        }
1318        YY_BREAK
1319
1320case YY_STATE_EOF(INITIAL):
1321case YY_STATE_EOF(COMMAND):
1322{
1323        if (current_file) {
1324                zconf_endfile();
1325                return T_EOL;
1326        }
1327        fclose(zconfin);
1328        yyterminate();
1329}
1330        YY_BREAK
1331case 33:
1332YY_RULE_SETUP
1333YY_FATAL_ERROR( "flex scanner jammed" );
1334        YY_BREAK
1335
1336        case YY_END_OF_BUFFER:
1337                {
1338                /* Amount of text matched not including the EOB char. */
1339                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1340
1341                /* Undo the effects of YY_DO_BEFORE_ACTION. */
1342                *yy_cp = (yy_hold_char);
1343                YY_RESTORE_YY_MORE_OFFSET
1344
1345                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1346                        {
1347                        /* We're scanning a new file or input source.  It's
1348                         * possible that this happened because the user
1349                         * just pointed zconfin at a new source and called
1350                         * zconflex().  If so, then we have to assure
1351                         * consistency between YY_CURRENT_BUFFER and our
1352                         * globals.  Here is the right place to do so, because
1353                         * this is the first action (other than possibly a
1354                         * back-up) that will match for the new input source.
1355                         */
1356                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1357                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
1358                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1359                        }
1360
1361                /* Note that here we test for yy_c_buf_p "<=" to the position
1362                 * of the first EOB in the buffer, since yy_c_buf_p will
1363                 * already have been incremented past the NUL character
1364                 * (since all states make transitions on EOB to the
1365                 * end-of-buffer state).  Contrast this with the test
1366                 * in input().
1367                 */
1368                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1369                        { /* This was really a NUL. */
1370                        yy_state_type yy_next_state;
1371
1372                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1373
1374                        yy_current_state = yy_get_previous_state(  );
1375
1376                        /* Okay, we're now positioned to make the NUL
1377                         * transition.  We couldn't have
1378                         * yy_get_previous_state() go ahead and do it
1379                         * for us because it doesn't know how to deal
1380                         * with the possibility of jamming (and we don't
1381                         * want to build jamming into it because then it
1382                         * will run more slowly).
1383                         */
1384
1385                        yy_next_state = yy_try_NUL_trans( yy_current_state );
1386
1387                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1388
1389                        if ( yy_next_state )
1390                                {
1391                                /* Consume the NUL. */
1392                                yy_cp = ++(yy_c_buf_p);
1393                                yy_current_state = yy_next_state;
1394                                goto yy_match;
1395                                }
1396
1397                        else
1398                                {
1399                                yy_cp = (yy_c_buf_p);
1400                                goto yy_find_action;
1401                                }
1402                        }
1403
1404                else switch ( yy_get_next_buffer(  ) )
1405                        {
1406                        case EOB_ACT_END_OF_FILE:
1407                                {
1408                                (yy_did_buffer_switch_on_eof) = 0;
1409
1410                                if ( zconfwrap( ) )
1411                                        {
1412                                        /* Note: because we've taken care in
1413                                         * yy_get_next_buffer() to have set up
1414                                         * zconftext, we can now set up
1415                                         * yy_c_buf_p so that if some total
1416                                         * hoser (like flex itself) wants to
1417                                         * call the scanner after we return the
1418                                         * YY_NULL, it'll still work - another
1419                                         * YY_NULL will get returned.
1420                                         */
1421                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1422
1423                                        yy_act = YY_STATE_EOF(YY_START);
1424                                        goto do_action;
1425                                        }
1426
1427                                else
1428                                        {
1429                                        if ( ! (yy_did_buffer_switch_on_eof) )
1430                                                YY_NEW_FILE;
1431                                        }
1432                                break;
1433                                }
1434
1435                        case EOB_ACT_CONTINUE_SCAN:
1436                                (yy_c_buf_p) =
1437                                        (yytext_ptr) + yy_amount_of_matched_text;
1438
1439                                yy_current_state = yy_get_previous_state(  );
1440
1441                                yy_cp = (yy_c_buf_p);
1442                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1443                                goto yy_match;
1444
1445                        case EOB_ACT_LAST_MATCH:
1446                                (yy_c_buf_p) =
1447                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1448
1449                                yy_current_state = yy_get_previous_state(  );
1450
1451                                yy_cp = (yy_c_buf_p);
1452                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1453                                goto yy_find_action;
1454                        }
1455                break;
1456                }
1457
1458        default:
1459                YY_FATAL_ERROR(
1460                        "fatal flex scanner internal error--no action found" );
1461        } /* end of action switch */
1462                } /* end of scanning one token */
1463} /* end of zconflex */
1464
1465/* yy_get_next_buffer - try to read in a new buffer
1466 *
1467 * Returns a code representing an action:
1468 *      EOB_ACT_LAST_MATCH -
1469 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1470 *      EOB_ACT_END_OF_FILE - end of file
1471 */
1472static int yy_get_next_buffer (void)
1473{
1474        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1475        register char *source = (yytext_ptr);
1476        register int number_to_move, i;
1477        int ret_val;
1478
1479        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1480                YY_FATAL_ERROR(
1481                "fatal flex scanner internal error--end of buffer missed" );
1482
1483        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1484                { /* Don't try to fill the buffer, so this is an EOF. */
1485                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1486                        {
1487                        /* We matched a single character, the EOB, so
1488                         * treat this as a final EOF.
1489                         */
1490                        return EOB_ACT_END_OF_FILE;
1491                        }
1492
1493                else
1494                        {
1495                        /* We matched some text prior to the EOB, first
1496                         * process it.
1497                         */
1498                        return EOB_ACT_LAST_MATCH;
1499                        }
1500                }
1501
1502        /* Try to read more data. */
1503
1504        /* First move last chars to start of buffer. */
1505        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1506
1507        for ( i = 0; i < number_to_move; ++i )
1508                *(dest++) = *(source++);
1509
1510        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1511                /* don't do the read, it's not guaranteed to return an EOF,
1512                 * just force an EOF
1513                 */
1514                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1515
1516        else
1517                {
1518                        int num_to_read =
1519                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1520
1521                while ( num_to_read <= 0 )
1522                        { /* Not enough room in the buffer - grow it. */
1523
1524                        /* just a shorter name for the current buffer */
1525                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1526
1527                        int yy_c_buf_p_offset =
1528                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1529
1530                        if ( b->yy_is_our_buffer )
1531                                {
1532                                int new_size = b->yy_buf_size * 2;
1533
1534                                if ( new_size <= 0 )
1535                                        b->yy_buf_size += b->yy_buf_size / 8;
1536                                else
1537                                        b->yy_buf_size *= 2;
1538
1539                                b->yy_ch_buf = (char *)
1540                                        /* Include room in for 2 EOB chars. */
1541                                        zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1542                                }
1543                        else
1544                                /* Can't grow it, we don't own it. */
1545                                b->yy_ch_buf = 0;
1546
1547                        if ( ! b->yy_ch_buf )
1548                                YY_FATAL_ERROR(
1549                                "fatal error - scanner input buffer overflow" );
1550
1551                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1552
1553                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1554                                                number_to_move - 1;
1555
1556                        }
1557
1558                if ( num_to_read > YY_READ_BUF_SIZE )
1559                        num_to_read = YY_READ_BUF_SIZE;
1560
1561                /* Read in more data. */
1562                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1563                        (yy_n_chars), (size_t) num_to_read );
1564
1565                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1566                }
1567
1568        if ( (yy_n_chars) == 0 )
1569                {
1570                if ( number_to_move == YY_MORE_ADJ )
1571                        {
1572                        ret_val = EOB_ACT_END_OF_FILE;
1573                        zconfrestart(zconfin  );
1574                        }
1575
1576                else
1577                        {
1578                        ret_val = EOB_ACT_LAST_MATCH;
1579                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1580                                YY_BUFFER_EOF_PENDING;
1581                        }
1582                }
1583
1584        else
1585                ret_val = EOB_ACT_CONTINUE_SCAN;
1586
1587        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1588                /* Extend the array by 50%, plus the number we really need. */
1589                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1590                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1591                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1592                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1593        }
1594
1595        (yy_n_chars) += number_to_move;
1596        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1597        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1598
1599        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1600
1601        return ret_val;
1602}
1603
1604/* yy_get_previous_state - get the state just before the EOB char was reached */
1605
1606    static yy_state_type yy_get_previous_state (void)
1607{
1608        register yy_state_type yy_current_state;
1609        register char *yy_cp;
1610    
1611        yy_current_state = (yy_start);
1612
1613        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1614                {
1615                yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
1616                }
1617
1618        return yy_current_state;
1619}
1620
1621/* yy_try_NUL_trans - try to make a transition on the NUL character
1622 *
1623 * synopsis
1624 *      next_state = yy_try_NUL_trans( current_state );
1625 */
1626    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1627{
1628        register int yy_is_jam;
1629    
1630        yy_current_state = yy_nxt[yy_current_state][1];
1631        yy_is_jam = (yy_current_state <= 0);
1632
1633        return yy_is_jam ? 0 : yy_current_state;
1634}
1635
1636    static void yyunput (int c, register char * yy_bp )
1637{
1638        register char *yy_cp;
1639    
1640    yy_cp = (yy_c_buf_p);
1641
1642        /* undo effects of setting up zconftext */
1643        *yy_cp = (yy_hold_char);
1644
1645        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1646                { /* need to shift things up to make room */
1647                /* +2 for EOB chars. */
1648                register int number_to_move = (yy_n_chars) + 2;
1649                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1650                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1651                register char *source =
1652                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1653
1654                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1655                        *--dest = *--source;
1656
1657                yy_cp += (int) (dest - source);
1658                yy_bp += (int) (dest - source);
1659                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1660                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1661
1662                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1663                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1664                }
1665
1666        *--yy_cp = (char) c;
1667
1668        (yytext_ptr) = yy_bp;
1669        (yy_hold_char) = *yy_cp;
1670        (yy_c_buf_p) = yy_cp;
1671}
1672
1673#ifndef YY_NO_INPUT
1674#ifdef __cplusplus
1675    static int yyinput (void)
1676#else
1677    static int input  (void)
1678#endif
1679
1680{
1681        int c;
1682    
1683        *(yy_c_buf_p) = (yy_hold_char);
1684
1685        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1686                {
1687                /* yy_c_buf_p now points to the character we want to return.
1688                 * If this occurs *before* the EOB characters, then it's a
1689                 * valid NUL; if not, then we've hit the end of the buffer.
1690                 */
1691                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1692                        /* This was really a NUL. */
1693                        *(yy_c_buf_p) = '\0';
1694
1695                else
1696                        { /* need more input */
1697                        int offset = (yy_c_buf_p) - (yytext_ptr);
1698                        ++(yy_c_buf_p);
1699
1700                        switch ( yy_get_next_buffer(  ) )
1701                                {
1702                                case EOB_ACT_LAST_MATCH:
1703                                        /* This happens because yy_g_n_b()
1704                                         * sees that we've accumulated a
1705                                         * token and flags that we need to
1706                                         * try matching the token before
1707                                         * proceeding.  But for input(),
1708                                         * there's no matching to consider.
1709                                         * So convert the EOB_ACT_LAST_MATCH
1710                                         * to EOB_ACT_END_OF_FILE.
1711                                         */
1712
1713                                        /* Reset buffer status. */
1714                                        zconfrestart(zconfin );
1715
1716                                        /*FALLTHROUGH*/
1717
1718                                case EOB_ACT_END_OF_FILE:
1719                                        {
1720                                        if ( zconfwrap( ) )
1721                                                return EOF;
1722
1723                                        if ( ! (yy_did_buffer_switch_on_eof) )
1724                                                YY_NEW_FILE;
1725#ifdef __cplusplus
1726                                        return yyinput();
1727#else
1728                                        return input();
1729#endif
1730                                        }
1731
1732                                case EOB_ACT_CONTINUE_SCAN:
1733                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1734                                        break;
1735                                }
1736                        }
1737                }
1738
1739        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1740        *(yy_c_buf_p) = '\0';   /* preserve zconftext */
1741        (yy_hold_char) = *++(yy_c_buf_p);
1742
1743        return c;
1744}
1745#endif  /* ifndef YY_NO_INPUT */
1746
1747/** Immediately switch to a different input stream.
1748 * @param input_file A readable stream.
1749 * 
1750 * @note This function does not reset the start condition to @c INITIAL .
1751 */
1752    void zconfrestart  (FILE * input_file )
1753{
1754    
1755        if ( ! YY_CURRENT_BUFFER ){
1756        zconfensure_buffer_stack ();
1757                YY_CURRENT_BUFFER_LVALUE =
1758            zconf_create_buffer(zconfin,YY_BUF_SIZE );
1759        }
1760
1761        zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
1762        zconf_load_buffer_state( );
1763}
1764
1765/** Switch to a different input buffer.
1766 * @param new_buffer The new input buffer.
1767 * 
1768 */
1769    void zconf_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1770{
1771    
1772        /* TODO. We should be able to replace this entire function body
1773         * with
1774         *              zconfpop_buffer_state();
1775         *              zconfpush_buffer_state(new_buffer);
1776     */
1777        zconfensure_buffer_stack ();
1778        if ( YY_CURRENT_BUFFER == new_buffer )
1779                return;
1780
1781        if ( YY_CURRENT_BUFFER )
1782                {
1783                /* Flush out information for old buffer. */
1784                *(yy_c_buf_p) = (yy_hold_char);
1785                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1786                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1787                }
1788
1789        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1790        zconf_load_buffer_state( );
1791
1792        /* We don't actually know whether we did this switch during
1793         * EOF (zconfwrap()) processing, but the only time this flag
1794         * is looked at is after zconfwrap() is called, so it's safe
1795         * to go ahead and always set it.
1796         */
1797        (yy_did_buffer_switch_on_eof) = 1;
1798}
1799
1800static void zconf_load_buffer_state  (void)
1801{
1802        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1803        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1804        zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1805        (yy_hold_char) = *(yy_c_buf_p);
1806}
1807
1808/** Allocate and initialize an input buffer state.
1809 * @param file A readable stream.
1810 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1811 * 
1812 * @return the allocated buffer state.
1813 */
1814    YY_BUFFER_STATE zconf_create_buffer  (FILE * file, int  size )
1815{
1816        YY_BUFFER_STATE b;
1817    
1818        b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
1819        if ( ! b )
1820                YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1821
1822        b->yy_buf_size = size;
1823
1824        /* yy_ch_buf has to be 2 characters longer than the size given because
1825         * we need to put in 2 end-of-buffer characters.
1826         */
1827        b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2  );
1828        if ( ! b->yy_ch_buf )
1829                YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1830
1831        b->yy_is_our_buffer = 1;
1832
1833        zconf_init_buffer(b,file );
1834
1835        return b;
1836}
1837
1838/** Destroy the buffer.
1839 * @param b a buffer created with zconf_create_buffer()
1840 * 
1841 */
1842    void zconf_delete_buffer (YY_BUFFER_STATE  b )
1843{
1844    
1845        if ( ! b )
1846                return;
1847
1848        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1849                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1850
1851        if ( b->yy_is_our_buffer )
1852                zconffree((void *) b->yy_ch_buf  );
1853
1854        zconffree((void *) b  );
1855}
1856
1857/* Initializes or reinitializes a buffer.
1858 * This function is sometimes called more than once on the same buffer,
1859 * such as during a zconfrestart() or at EOF.
1860 */
1861    static void zconf_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1862
1863{
1864        int oerrno = errno;
1865    
1866        zconf_flush_buffer(b );
1867
1868        b->yy_input_file = file;
1869        b->yy_fill_buffer = 1;
1870
1871    /* If b is the current buffer, then zconf_init_buffer was _probably_
1872     * called from zconfrestart() or through yy_get_next_buffer.
1873     * In that case, we don't want to reset the lineno or column.
1874     */
1875    if (b != YY_CURRENT_BUFFER){
1876        b->yy_bs_lineno = 1;
1877        b->yy_bs_column = 0;
1878    }
1879
1880        b->yy_is_interactive = 0;
1881    
1882        errno = oerrno;
1883}
1884
1885/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1886 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1887 * 
1888 */
1889    void zconf_flush_buffer (YY_BUFFER_STATE  b )
1890{
1891        if ( ! b )
1892                return;
1893
1894        b->yy_n_chars = 0;
1895
1896        /* We always need two end-of-buffer characters.  The first causes
1897         * a transition to the end-of-buffer state.  The second causes
1898         * a jam in that state.
1899         */
1900        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1901        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1902
1903        b->yy_buf_pos = &b->yy_ch_buf[0];
1904
1905        b->yy_at_bol = 1;
1906        b->yy_buffer_status = YY_BUFFER_NEW;
1907
1908        if ( b == YY_CURRENT_BUFFER )
1909                zconf_load_buffer_state( );
1910}
1911
1912/** Pushes the new state onto the stack. The new state becomes
1913 *  the current state. This function will allocate the stack
1914 *  if necessary.
1915 *  @param new_buffer The new state.
1916 *  
1917 */
1918void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1919{
1920        if (new_buffer == NULL)
1921                return;
1922
1923        zconfensure_buffer_stack();
1924
1925        /* This block is copied from zconf_switch_to_buffer. */
1926        if ( YY_CURRENT_BUFFER )
1927                {
1928                /* Flush out information for old buffer. */
1929                *(yy_c_buf_p) = (yy_hold_char);
1930                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1931                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1932                }
1933
1934        /* Only push if top exists. Otherwise, replace top. */
1935        if (YY_CURRENT_BUFFER)
1936                (yy_buffer_stack_top)++;
1937        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1938
1939        /* copied from zconf_switch_to_buffer. */
1940        zconf_load_buffer_state( );
1941        (yy_did_buffer_switch_on_eof) = 1;
1942}
1943
1944/** Removes and deletes the top of the stack, if present.
1945 *  The next element becomes the new top.
1946 *  
1947 */
1948void zconfpop_buffer_state (void)
1949{
1950        if (!YY_CURRENT_BUFFER)
1951                return;
1952
1953        zconf_delete_buffer(YY_CURRENT_BUFFER );
1954        YY_CURRENT_BUFFER_LVALUE = NULL;
1955        if ((yy_buffer_stack_top) > 0)
1956                --(yy_buffer_stack_top);
1957
1958        if (YY_CURRENT_BUFFER) {
1959                zconf_load_buffer_state( );
1960                (yy_did_buffer_switch_on_eof) = 1;
1961        }
1962}
1963
1964/* Allocates the stack if it does not exist.
1965 *  Guarantees space for at least one push.
1966 */
1967static void zconfensure_buffer_stack (void)
1968{
1969        int num_to_alloc;
1970    
1971        if (!(yy_buffer_stack)) {
1972
1973                /* First allocation is just for 2 elements, since we don't know if this
1974                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1975                 * immediate realloc on the next call.
1976         */
1977                num_to_alloc = 1;
1978                (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
1979                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
1980                                                                );
1981                if ( ! (yy_buffer_stack) )
1982                        YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
1983                                                                  
1984                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1985                                
1986                (yy_buffer_stack_max) = num_to_alloc;
1987                (yy_buffer_stack_top) = 0;
1988                return;
1989        }
1990
1991        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1992
1993                /* Increase the buffer to prepare for a possible push. */
1994                int grow_size = 8 /* arbitrary grow size */;
1995
1996                num_to_alloc = (yy_buffer_stack_max) + grow_size;
1997                (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
1998                                                                ((yy_buffer_stack),
1999                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
2000                                                                );
2001                if ( ! (yy_buffer_stack) )
2002                        YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
2003
2004                /* zero only the new slots.*/
2005                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2006                (yy_buffer_stack_max) = num_to_alloc;
2007        }
2008}
2009
2010/** Setup the input buffer state to scan directly from a user-specified character buffer.
2011 * @param base the character buffer
2012 * @param size the size in bytes of the character buffer
2013 * 
2014 * @return the newly allocated buffer state object. 
2015 */
2016YY_BUFFER_STATE zconf_scan_buffer  (char * base, yy_size_t  size )
2017{
2018        YY_BUFFER_STATE b;
2019    
2020        if ( size < 2 ||
2021             base[size-2] != YY_END_OF_BUFFER_CHAR ||
2022             base[size-1] != YY_END_OF_BUFFER_CHAR )
2023                /* They forgot to leave room for the EOB's. */
2024                return 0;
2025
2026        b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
2027        if ( ! b )
2028                YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2029
2030        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2031        b->yy_buf_pos = b->yy_ch_buf = base;
2032        b->yy_is_our_buffer = 0;
2033        b->yy_input_file = 0;
2034        b->yy_n_chars = b->yy_buf_size;
2035        b->yy_is_interactive = 0;
2036        b->yy_at_bol = 1;
2037        b->yy_fill_buffer = 0;
2038        b->yy_buffer_status = YY_BUFFER_NEW;
2039
2040        zconf_switch_to_buffer(b  );
2041
2042        return b;
2043}
2044
2045/** Setup the input buffer state to scan a string. The next call to zconflex() will
2046 * scan from a @e copy of @a str.
2047 * @param yystr a NUL-terminated string to scan
2048 * 
2049 * @return the newly allocated buffer state object.
2050 * @note If you want to scan bytes that may contain NUL values, then use
2051 *       zconf_scan_bytes() instead.
2052 */
2053YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
2054{
2055    
2056        return zconf_scan_bytes(yystr,strlen(yystr) );
2057}
2058
2059/** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2060 * scan from a @e copy of @a bytes.
2061 * @param bytes the byte buffer to scan
2062 * @param len the number of bytes in the buffer pointed to by @a bytes.
2063 * 
2064 * @return the newly allocated buffer state object.
2065 */
2066YY_BUFFER_STATE zconf_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2067{
2068        YY_BUFFER_STATE b;
2069        char *buf;
2070        yy_size_t n;
2071        int i;
2072    
2073        /* Get memory for full buffer, including space for trailing EOB's. */
2074        n = _yybytes_len + 2;
2075        buf = (char *) zconfalloc(n  );
2076        if ( ! buf )
2077                YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2078
2079        for ( i = 0; i < _yybytes_len; ++i )
2080                buf[i] = yybytes[i];
2081
2082        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2083
2084        b = zconf_scan_buffer(buf,n );
2085        if ( ! b )
2086                YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2087
2088        /* It's okay to grow etc. this buffer, and we should throw it
2089         * away when we're done.
2090         */
2091        b->yy_is_our_buffer = 1;
2092
2093        return b;
2094}
2095
2096#ifndef YY_EXIT_FAILURE
2097#define YY_EXIT_FAILURE 2
2098#endif
2099
2100static void yy_fatal_error (yyconst char* msg )
2101{
2102        (void) fprintf( stderr, "%s\n", msg );
2103        exit( YY_EXIT_FAILURE );
2104}
2105
2106/* Redefine yyless() so it works in section 3 code. */
2107
2108#undef yyless
2109#define yyless(n) \
2110        do \
2111                { \
2112                /* Undo effects of setting up zconftext. */ \
2113        int yyless_macro_arg = (n); \
2114        YY_LESS_LINENO(yyless_macro_arg);\
2115                zconftext[zconfleng] = (yy_hold_char); \
2116                (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2117                (yy_hold_char) = *(yy_c_buf_p); \
2118                *(yy_c_buf_p) = '\0'; \
2119                zconfleng = yyless_macro_arg; \
2120                } \
2121        while ( 0 )
2122
2123/* Accessor  methods (get/set functions) to struct members. */
2124
2125/** Get the current line number.
2126 * 
2127 */
2128int zconfget_lineno  (void)
2129{
2130        
2131    return zconflineno;
2132}
2133
2134/** Get the input stream.
2135 * 
2136 */
2137FILE *zconfget_in  (void)
2138{
2139        return zconfin;
2140}
2141
2142/** Get the output stream.
2143 * 
2144 */
2145FILE *zconfget_out  (void)
2146{
2147        return zconfout;
2148}
2149
2150/** Get the length of the current token.
2151 * 
2152 */
2153int zconfget_leng  (void)
2154{
2155        return zconfleng;
2156}
2157
2158/** Get the current token.
2159 * 
2160 */
2161
2162char *zconfget_text  (void)
2163{
2164        return zconftext;
2165}
2166
2167/** Set the current line number.
2168 * @param line_number
2169 * 
2170 */
2171void zconfset_lineno (int  line_number )
2172{
2173    
2174    zconflineno = line_number;
2175}
2176
2177/** Set the input stream. This does not discard the current
2178 * input buffer.
2179 * @param in_str A readable stream.
2180 * 
2181 * @see zconf_switch_to_buffer
2182 */
2183void zconfset_in (FILE *  in_str )
2184{
2185        zconfin = in_str ;
2186}
2187
2188void zconfset_out (FILE *  out_str )
2189{
2190        zconfout = out_str ;
2191}
2192
2193int zconfget_debug  (void)
2194{
2195        return zconf_flex_debug;
2196}
2197
2198void zconfset_debug (int  bdebug )
2199{
2200        zconf_flex_debug = bdebug ;
2201}
2202
2203static int yy_init_globals (void)
2204{
2205        /* Initialization is the same as for the non-reentrant scanner.
2206     * This function is called from zconflex_destroy(), so don't allocate here.
2207     */
2208
2209    (yy_buffer_stack) = 0;
2210    (yy_buffer_stack_top) = 0;
2211    (yy_buffer_stack_max) = 0;
2212    (yy_c_buf_p) = (char *) 0;
2213    (yy_init) = 0;
2214    (yy_start) = 0;
2215
2216/* Defined in main.c */
2217#ifdef YY_STDINIT
2218    zconfin = stdin;
2219    zconfout = stdout;
2220#else
2221    zconfin = (FILE *) 0;
2222    zconfout = (FILE *) 0;
2223#endif
2224
2225    /* For future reference: Set errno on error, since we are called by
2226     * zconflex_init()
2227     */
2228    return 0;
2229}
2230
2231/* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2232int zconflex_destroy  (void)
2233{
2234    
2235    /* Pop the buffer stack, destroying each element. */
2236        while(YY_CURRENT_BUFFER){
2237                zconf_delete_buffer(YY_CURRENT_BUFFER  );
2238                YY_CURRENT_BUFFER_LVALUE = NULL;
2239                zconfpop_buffer_state();
2240        }
2241
2242        /* Destroy the stack itself. */
2243        zconffree((yy_buffer_stack) );
2244        (yy_buffer_stack) = NULL;
2245
2246    /* Reset the globals. This is important in a non-reentrant scanner so the next time
2247     * zconflex() is called, initialization will occur. */
2248    yy_init_globals( );
2249
2250    return 0;
2251}
2252
2253/*
2254 * Internal utility routines.
2255 */
2256
2257#ifndef yytext_ptr
2258static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2259{
2260        register int i;
2261        for ( i = 0; i < n; ++i )
2262                s1[i] = s2[i];
2263}
2264#endif
2265
2266#ifdef YY_NEED_STRLEN
2267static int yy_flex_strlen (yyconst char * s )
2268{
2269        register int n;
2270        for ( n = 0; s[n]; ++n )
2271                ;
2272
2273        return n;
2274}
2275#endif
2276
2277void *zconfalloc (yy_size_t  size )
2278{
2279        return (void *) malloc( size );
2280}
2281
2282void *zconfrealloc  (void * ptr, yy_size_t  size )
2283{
2284        /* The cast to (char *) in the following accommodates both
2285         * implementations that use char* generic pointers, and those
2286         * that use void* generic pointers.  It works with the latter
2287         * because both ANSI C and C++ allow castless assignment from
2288         * any pointer type to void*, and deal with argument conversions
2289         * as though doing an assignment.
2290         */
2291        return (void *) realloc( (char *) ptr, size );
2292}
2293
2294void zconffree (void * ptr )
2295{
2296        free( (char *) ptr );   /* see zconfrealloc() for (char *) cast */
2297}
2298
2299#define YYTABLES_NAME "yytables"
2300
2301void zconf_starthelp(void)
2302{
2303        new_string();
2304        last_ts = first_ts = 0;
2305        BEGIN(HELP);
2306}
2307
2308static void zconf_endhelp(void)
2309{
2310        zconflval.string = text;
2311        BEGIN(INITIAL);
2312}
2313
2314/*
2315 * Try to open specified file with following names:
2316 * ./name
2317 * $(srctree)/name
2318 * The latter is used when srctree is separate from objtree
2319 * when compiling the kernel.
2320 * Return NULL if file is not found.
2321 */
2322FILE *zconf_fopen(const char *name)
2323{
2324        char *env, fullname[PATH_MAX+1];
2325        FILE *f;
2326
2327        f = fopen(name, "r");
2328        if (!f && name != NULL && name[0] != '/') {
2329                env = getenv(SRCTREE);
2330                if (env) {
2331                        sprintf(fullname, "%s/%s", env, name);
2332                        f = fopen(fullname, "r");
2333                }
2334        }
2335        return f;
2336}
2337
2338void zconf_initscan(const char *name)
2339{
2340        zconfin = zconf_fopen(name);
2341        if (!zconfin) {
2342                printf("can't find file %s\n", name);
2343                exit(1);
2344        }
2345
2346        current_buf = malloc(sizeof(*current_buf));
2347        memset(current_buf, 0, sizeof(*current_buf));
2348
2349        current_file = file_lookup(name);
2350        current_file->lineno = 1;
2351}
2352
2353void zconf_nextfile(const char *name)
2354{
2355        struct file *iter;
2356        struct file *file = file_lookup(name);
2357        struct buffer *buf = malloc(sizeof(*buf));
2358        memset(buf, 0, sizeof(*buf));
2359
2360        current_buf->state = YY_CURRENT_BUFFER;
2361        zconfin = zconf_fopen(file->name);
2362        if (!zconfin) {
2363                printf("%s:%d: can't open file \"%s\"\n",
2364                    zconf_curname(), zconf_lineno(), file->name);
2365                exit(1);
2366        }
2367        zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2368        buf->parent = current_buf;
2369        current_buf = buf;
2370
2371        for (iter = current_file->parent; iter; iter = iter->parent ) {
2372                if (!strcmp(current_file->name,iter->name) ) {
2373                        printf("%s:%d: recursive inclusion detected. "
2374                               "Inclusion path:\n  current file : '%s'\n",
2375                               zconf_curname(), zconf_lineno(),
2376                               zconf_curname());
2377                        iter = current_file->parent;
2378                        while (iter && \
2379                               strcmp(iter->name,current_file->name)) {
2380                                printf("  included from: '%s:%d'\n",
2381                                       iter->name, iter->lineno-1);
2382                                iter = iter->parent;
2383                        }
2384                        if (iter)
2385                                printf("  included from: '%s:%d'\n",
2386                                       iter->name, iter->lineno+1);
2387                        exit(1);
2388                }
2389        }
2390        file->lineno = 1;
2391        file->parent = current_file;
2392        current_file = file;
2393}
2394
2395static void zconf_endfile(void)
2396{
2397        struct buffer *parent;
2398
2399        current_file = current_file->parent;
2400
2401        parent = current_buf->parent;
2402        if (parent) {
2403                fclose(zconfin);
2404                zconf_delete_buffer(YY_CURRENT_BUFFER);
2405                zconf_switch_to_buffer(parent->state);
2406        }
2407        free(current_buf);
2408        current_buf = parent;
2409}
2410
2411int zconf_lineno(void)
2412{
2413        return current_pos.lineno;
2414}
2415
2416const char *zconf_curname(void)
2417{
2418        return current_pos.file ? current_pos.file->name : "<none>";
2419}
2420
2421
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.