scripts/kconfig/zconf.lex.c_shipped

   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>
  62 typedef int8_t flex_int8_t;
  63 typedef uint8_t flex_uint8_t;
  64 typedef int16_t flex_int16_t;
  65 typedef uint16_t flex_uint16_t;
  66 typedef int32_t flex_int32_t;
  67 typedef uint32_t flex_uint32_t;
  68 #else
  69 typedef signed char flex_int8_t;
  70 typedef short int flex_int16_t;
  71 typedef int flex_int32_t;
  72 typedef unsigned char flex_uint8_t;
  73 typedef unsigned short int flex_uint16_t;
  74 typedef 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
 171 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 172 #endif
 173
 174 extern int zconfleng;
 175
 176 extern 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
 202 typedef size_t yy_size_t;
 203 #endif
 204
 205 #ifndef YY_STRUCT_YY_BUFFER_STATE
 206 #define YY_STRUCT_YY_BUFFER_STATE
 207 struct 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. */
 271 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 272 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 273 static 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. */
 291 static char yy_hold_char;
 292 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 293 int zconfleng;
 294
 295 /* Points to current character in buffer. */
 296 static char *yy_c_buf_p = (char *) 0;
 297 static int yy_init = 0;         /* whether we need to initialize */
 298 static 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  */
 303 static int yy_did_buffer_switch_on_eof;
 304
 305 void zconfrestart (FILE *input_file  );
 306 void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 307 YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size  );
 308 void zconf_delete_buffer (YY_BUFFER_STATE b  );
 309 void zconf_flush_buffer (YY_BUFFER_STATE b  );
 310 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer  );
 311 void zconfpop_buffer_state (void );
 312
 313 static void zconfensure_buffer_stack (void );
 314 static void zconf_load_buffer_state (void );
 315 static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 316
 317 #define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
 318
 319 YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size  );
 320 YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str  );
 321 YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len  );
 322
 323 void *zconfalloc (yy_size_t  );
 324 void *zconfrealloc (void *,yy_size_t  );
 325 void 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
 356 typedef unsigned char YY_CHAR;
 357
 358 FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
 359
 360 typedef int yy_state_type;
 361
 362 extern int zconflineno;
 363
 364 int zconflineno = 1;
 365
 366 extern char *zconftext;
 367 #define yytext_ptr zconftext
 368 static 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
 689 static yy_state_type yy_get_previous_state (void );
 690 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 691 static int yy_get_next_buffer (void );
 692 static 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. */
 708 struct yy_trans_info
 709         {
 710         flex_int32_t yy_verify;
 711         flex_int32_t yy_nxt;
 712         };
 713 static 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
 723 static 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
 755 extern int zconf_flex_debug;
 756 int 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
 765 char *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 #define LKC_DIRECT_LINK
 780 #include "lkc.h"
 781
 782 #define START_STRSIZE   16
 783
 784 static struct {
 785         struct file *file;
 786         int lineno;
 787 } current_pos;
 788
 789 static char *text;
 790 static int text_size, text_asize;
 791
 792 struct buffer {
 793         struct buffer *parent;
 794         YY_BUFFER_STATE state;
 795 };
 796
 797 struct buffer *current_buf;
 798
 799 static int last_ts, first_ts;
 800
 801 static void zconf_endhelp(void);
 802 static void zconf_endfile(void);
 803
 804 static void new_string(void)
 805 {
 806         text = malloc(START_STRSIZE);
 807         text_asize = START_STRSIZE;
 808         text_size = 0;
 809         *text = 0;
 810 }
 811
 812 static void append_string(const char *str, int size)
 813 {
 814         int new_size = text_size + size + 1;
 815         if (new_size > text_asize) {
 816                 new_size += START_STRSIZE - 1;
 817                 new_size &= -START_STRSIZE;
 818                 text = realloc(text, new_size);
 819                 text_asize = new_size;
 820         }
 821         memcpy(text + text_size, str, size);
 822         text_size += size;
 823         text[text_size] = 0;
 824 }
 825
 826 static void alloc_string(const char *str, int size)
 827 {
 828         text = malloc(size + 1);
 829         memcpy(text, str, size);
 830         text[size] = 0;
 831 }
 832
 833 #define INITIAL 0
 834 #define COMMAND 1
 835 #define HELP 2
 836 #define STRING 3
 837 #define PARAM 4
 838
 839 #ifndef YY_NO_UNISTD_H
 840 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 841  * down here because we want the user's section 1 to have been scanned first.
 842  * The user has a chance to override it with an option.
 843  */
 844 #include <unistd.h>
 845 #endif
 846
 847 #ifndef YY_EXTRA_TYPE
 848 #define YY_EXTRA_TYPE void *
 849 #endif
 850
 851 static int yy_init_globals (void );
 852
 853 /* Accessor methods to globals.
 854    These are made visible to non-reentrant scanners for convenience. */
 855
 856 int zconflex_destroy (void );
 857
 858 int zconfget_debug (void );
 859
 860 void zconfset_debug (int debug_flag  );
 861
 862 YY_EXTRA_TYPE zconfget_extra (void );
 863
 864 void zconfset_extra (YY_EXTRA_TYPE user_defined  );
 865
 866 FILE *zconfget_in (void );
 867
 868 void zconfset_in  (FILE * in_str  );
 869
 870 FILE *zconfget_out (void );
 871
 872 void zconfset_out  (FILE * out_str  );
 873
 874 int zconfget_leng (void );
 875
 876 char *zconfget_text (void );
 877
 878 int zconfget_lineno (void );
 879
 880 void zconfset_lineno (int line_number  );
 881
 882 /* Macros after this point can all be overridden by user definitions in
 883  * section 1.
 884  */
 885
 886 #ifndef YY_SKIP_YYWRAP
 887 #ifdef __cplusplus
 888 extern "C" int zconfwrap (void );
 889 #else
 890 extern int zconfwrap (void );
 891 #endif
 892 #endif
 893
 894     static void yyunput (int c,char *buf_ptr  );
 895
 896 #ifndef yytext_ptr
 897 static void yy_flex_strncpy (char *,yyconst char *,int );
 898 #endif
 899
 900 #ifdef YY_NEED_STRLEN
 901 static int yy_flex_strlen (yyconst char * );
 902 #endif
 903
 904 #ifndef YY_NO_INPUT
 905
 906 #ifdef __cplusplus
 907 static int yyinput (void );
 908 #else
 909 static int input (void );
 910 #endif
 911
 912 #endif
 913
 914 /* Amount of stuff to slurp up with each read. */
 915 #ifndef YY_READ_BUF_SIZE
 916 #define YY_READ_BUF_SIZE 8192
 917 #endif
 918
 919 /* Copy whatever the last rule matched to the standard output. */
 920 #ifndef ECHO
 921 /* This used to be an fputs(), but since the string might contain NUL's,
 922  * we now use fwrite().
 923  */
 924 #define ECHO do { if (fwrite( zconftext, zconfleng, 1, zconfout )) {} } while (0)
 925 #endif
 926
 927 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 928  * is returned in "result".
 929  */
 930 #ifndef YY_INPUT
 931 #define YY_INPUT(buf,result,max_size) \
 932         errno=0; \
 933         while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
 934         { \
 935                 if( errno != EINTR) \
 936                 { \
 937                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 938                         break; \
 939                 } \
 940                 errno=0; \
 941                 clearerr(zconfin); \
 942         }\
 943 \
 944
 945 #endif
 946
 947 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 948  * we don't want an extra ';' after the "return" because that will cause
 949  * some compilers to complain about unreachable statements.
 950  */
 951 #ifndef yyterminate
 952 #define yyterminate() return YY_NULL
 953 #endif
 954
 955 /* Number of entries by which start-condition stack grows. */
 956 #ifndef YY_START_STACK_INCR
 957 #define YY_START_STACK_INCR 25
 958 #endif
 959
 960 /* Report a fatal error. */
 961 #ifndef YY_FATAL_ERROR
 962 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 963 #endif
 964
 965 /* end tables serialization structures and prototypes */
 966
 967 /* Default declaration of generated scanner - a define so the user can
 968  * easily add parameters.
 969  */
 970 #ifndef YY_DECL
 971 #define YY_DECL_IS_OURS 1
 972
 973 extern int zconflex (void);
 974
 975 #define YY_DECL int zconflex (void)
 976 #endif /* !YY_DECL */
 977
 978 /* Code executed at the beginning of each rule, after zconftext and zconfleng
 979  * have been set up.
 980  */
 981 #ifndef YY_USER_ACTION
 982 #define YY_USER_ACTION
 983 #endif
 984
 985 /* Code executed at the end of each rule. */
 986 #ifndef YY_BREAK
 987 #define YY_BREAK break;
 988 #endif
 989
 990 #define YY_RULE_SETUP \
 991         YY_USER_ACTION
 992
 993 /** The main scanner function which does all the work.
 994  */
 995 YY_DECL
 996 {
 997         register yy_state_type yy_current_state;
 998         register char *yy_cp, *yy_bp;
 999         register int yy_act;
1000
1001         int str = 0;
1002         int ts, i;
1003
1004         if ( !(yy_init) )
1005                 {
1006                 (yy_init) = 1;
1007
1008 #ifdef YY_USER_INIT
1009                 YY_USER_INIT;
1010 #endif
1011
1012                 if ( ! (yy_start) )
1013                         (yy_start) = 1; /* first start state */
1014
1015                 if ( ! zconfin )
1016                         zconfin = stdin;
1017
1018                 if ( ! zconfout )
1019                         zconfout = stdout;
1020
1021                 if ( ! YY_CURRENT_BUFFER ) {
1022                         zconfensure_buffer_stack ();
1023                         YY_CURRENT_BUFFER_LVALUE =
1024                                 zconf_create_buffer(zconfin,YY_BUF_SIZE );
1025                 }
1026
1027                 zconf_load_buffer_state( );
1028                 }
1029
1030         while ( 1 )             /* loops until end-of-file is reached */
1031                 {
1032                 yy_cp = (yy_c_buf_p);
1033
1034                 /* Support of zconftext. */
1035                 *yy_cp = (yy_hold_char);
1036
1037                 /* yy_bp points to the position in yy_ch_buf of the start of
1038                  * the current run.
1039                  */
1040                 yy_bp = yy_cp;
1041
1042                 yy_current_state = (yy_start);
1043 yy_match:
1044                 while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)]  ]) > 0 )
1045                         ++yy_cp;
1046
1047                 yy_current_state = -yy_current_state;
1048
1049 yy_find_action:
1050                 yy_act = yy_accept[yy_current_state];
1051
1052                 YY_DO_BEFORE_ACTION;
1053
1054 do_action:      /* This label is used only to access EOF actions. */
1055
1056                 switch ( yy_act )
1057         { /* beginning of action switch */
1058 case 1:
1059 /* rule 1 can match eol */
1060 case 2:
1061 /* rule 2 can match eol */
1062 YY_RULE_SETUP
1063 {
1064         current_file->lineno++;
1065         return T_EOL;
1066 }
1067         YY_BREAK
1068 case 3:
1069 YY_RULE_SETUP
1070
1071         YY_BREAK
1072 case 4:
1073 YY_RULE_SETUP
1074 {
1075         BEGIN(COMMAND);
1076 }
1077         YY_BREAK
1078 case 5:
1079 YY_RULE_SETUP
1080 {
1081         unput(zconftext[0]);
1082         BEGIN(COMMAND);
1083 }
1084         YY_BREAK
1085
1086 case 6:
1087 YY_RULE_SETUP
1088 {
1089                 const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1090                 BEGIN(PARAM);
1091                 current_pos.file = current_file;
1092                 current_pos.lineno = current_file->lineno;
1093                 if (id && id->flags & TF_COMMAND) {
1094                         zconflval.id = id;
1095                         return id->token;
1096                 }
1097                 alloc_string(zconftext, zconfleng);
1098                 zconflval.string = text;
1099                 return T_WORD;
1100         }
1101         YY_BREAK
1102 case 7:
1103 YY_RULE_SETUP
1104
1105         YY_BREAK
1106 case 8:
1107 /* rule 8 can match eol */
1108 YY_RULE_SETUP
1109 {
1110                 BEGIN(INITIAL);
1111                 current_file->lineno++;
1112                 return T_EOL;
1113         }
1114         YY_BREAK
1115
1116 case 9:
1117 YY_RULE_SETUP
1118 return T_AND;
1119         YY_BREAK
1120 case 10:
1121 YY_RULE_SETUP
1122 return T_OR;
1123         YY_BREAK
1124 case 11:
1125 YY_RULE_SETUP
1126 return T_OPEN_PAREN;
1127         YY_BREAK
1128 case 12:
1129 YY_RULE_SETUP
1130 return T_CLOSE_PAREN;
1131         YY_BREAK
1132 case 13:
1133 YY_RULE_SETUP
1134 return T_NOT;
1135         YY_BREAK
1136 case 14:
1137 YY_RULE_SETUP
1138 return T_EQUAL;
1139         YY_BREAK
1140 case 15:
1141 YY_RULE_SETUP
1142 return T_UNEQUAL;
1143         YY_BREAK
1144 case 16:
1145 YY_RULE_SETUP
1146 {
1147                 str = zconftext[0];
1148                 new_string();
1149                 BEGIN(STRING);
1150         }
1151         YY_BREAK
1152 case 17:
1153 /* rule 17 can match eol */
1154 YY_RULE_SETUP
1155 BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1156         YY_BREAK
1157 case 18:
1158 YY_RULE_SETUP
1159 /* ignore */
1160         YY_BREAK
1161 case 19:
1162 YY_RULE_SETUP
1163 {
1164                 const struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
1165                 if (id && id->flags & TF_PARAM) {
1166                         zconflval.id = id;
1167                         return id->token;
1168                 }
1169                 alloc_string(zconftext, zconfleng);
1170                 zconflval.string = text;
1171                 return T_WORD;
1172         }
1173         YY_BREAK
1174 case 20:
1175 YY_RULE_SETUP
1176 /* comment */
1177         YY_BREAK
1178 case 21:
1179 /* rule 21 can match eol */
1180 YY_RULE_SETUP
1181 current_file->lineno++;
1182         YY_BREAK
1183 case 22:
1184 YY_RULE_SETUP
1185
1186         YY_BREAK
1187 case YY_STATE_EOF(PARAM):
1188 {
1189                 BEGIN(INITIAL);
1190         }
1191         YY_BREAK
1192
1193 case 23:
1194 /* rule 23 can match eol */
1195 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1196 (yy_c_buf_p) = yy_cp -= 1;
1197 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1198 YY_RULE_SETUP
1199 {
1200                 append_string(zconftext, zconfleng);
1201                 zconflval.string = text;
1202                 return T_WORD_QUOTE;
1203         }
1204         YY_BREAK
1205 case 24:
1206 YY_RULE_SETUP
1207 {
1208                 append_string(zconftext, zconfleng);
1209         }
1210         YY_BREAK
1211 case 25:
1212 /* rule 25 can match eol */
1213 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1214 (yy_c_buf_p) = yy_cp -= 1;
1215 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1216 YY_RULE_SETUP
1217 {
1218                 append_string(zconftext + 1, zconfleng - 1);
1219                 zconflval.string = text;
1220                 return T_WORD_QUOTE;
1221         }
1222         YY_BREAK
1223 case 26:
1224 YY_RULE_SETUP
1225 {
1226                 append_string(zconftext + 1, zconfleng - 1);
1227         }
1228         YY_BREAK
1229 case 27:
1230 YY_RULE_SETUP
1231 {
1232                 if (str == zconftext[0]) {
1233                         BEGIN(PARAM);
1234                         zconflval.string = text;
1235                         return T_WORD_QUOTE;
1236                 } else
1237                         append_string(zconftext, 1);
1238         }
1239         YY_BREAK
1240 case 28:
1241 /* rule 28 can match eol */
1242 YY_RULE_SETUP
1243 {
1244                 printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
1245                 current_file->lineno++;
1246                 BEGIN(INITIAL);
1247                 return T_EOL;
1248         }
1249         YY_BREAK
1250 case YY_STATE_EOF(STRING):
1251 {
1252                 BEGIN(INITIAL);
1253         }
1254         YY_BREAK
1255
1256 case 29:
1257 YY_RULE_SETUP
1258 {
1259                 ts = 0;
1260                 for (i = 0; i < zconfleng; i++) {
1261                         if (zconftext[i] == '\t')
1262                                 ts = (ts & ~7) + 8;
1263                         else
1264                                 ts++;
1265                 }
1266                 last_ts = ts;
1267                 if (first_ts) {
1268                         if (ts < first_ts) {
1269                                 zconf_endhelp();
1270                                 return T_HELPTEXT;
1271                         }
1272                         ts -= first_ts;
1273                         while (ts > 8) {
1274                                 append_string("        ", 8);
1275                                 ts -= 8;
1276                         }
1277                         append_string("        ", ts);
1278                 }
1279         }
1280         YY_BREAK
1281 case 30:
1282 /* rule 30 can match eol */
1283 *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
1284 (yy_c_buf_p) = yy_cp -= 1;
1285 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1286 YY_RULE_SETUP
1287 {
1288                 current_file->lineno++;
1289                 zconf_endhelp();
1290                 return T_HELPTEXT;
1291         }
1292         YY_BREAK
1293 case 31:
1294 /* rule 31 can match eol */
1295 YY_RULE_SETUP
1296 {
1297                 current_file->lineno++;
1298                 append_string("\n", 1);
1299         }
1300         YY_BREAK
1301 case 32:
1302 YY_RULE_SETUP
1303 {
1304                 while (zconfleng) {
1305                         if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
1306                                 break;
1307                         zconfleng--;
1308                 }
1309                 append_string(zconftext, zconfleng);
1310                 if (!first_ts)
1311                         first_ts = last_ts;
1312         }
1313         YY_BREAK
1314 case YY_STATE_EOF(HELP):
1315 {
1316                 zconf_endhelp();
1317                 return T_HELPTEXT;
1318         }
1319         YY_BREAK
1320
1321 case YY_STATE_EOF(INITIAL):
1322 case YY_STATE_EOF(COMMAND):
1323 {
1324         if (current_file) {
1325                 zconf_endfile();
1326                 return T_EOL;
1327         }
1328         fclose(zconfin);
1329         yyterminate();
1330 }
1331         YY_BREAK
1332 case 33:
1333 YY_RULE_SETUP
1334 YY_FATAL_ERROR( "flex scanner jammed" );
1335         YY_BREAK
1336
1337         case YY_END_OF_BUFFER:
1338                 {
1339                 /* Amount of text matched not including the EOB char. */
1340                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1341
1342                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1343                 *yy_cp = (yy_hold_char);
1344                 YY_RESTORE_YY_MORE_OFFSET
1345
1346                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1347                         {
1348                         /* We're scanning a new file or input source.  It's
1349                          * possible that this happened because the user
1350                          * just pointed zconfin at a new source and called
1351                          * zconflex().  If so, then we have to assure
1352                          * consistency between YY_CURRENT_BUFFER and our
1353                          * globals.  Here is the right place to do so, because
1354                          * this is the first action (other than possibly a
1355                          * back-up) that will match for the new input source.
1356                          */
1357                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1358                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
1359                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1360                         }
1361
1362                 /* Note that here we test for yy_c_buf_p "<=" to the position
1363                  * of the first EOB in the buffer, since yy_c_buf_p will
1364                  * already have been incremented past the NUL character
1365                  * (since all states make transitions on EOB to the
1366                  * end-of-buffer state).  Contrast this with the test
1367                  * in input().
1368                  */
1369                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1370                         { /* This was really a NUL. */
1371                         yy_state_type yy_next_state;
1372
1373                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1374
1375                         yy_current_state = yy_get_previous_state(  );
1376
1377                         /* Okay, we're now positioned to make the NUL
1378                          * transition.  We couldn't have
1379                          * yy_get_previous_state() go ahead and do it
1380                          * for us because it doesn't know how to deal
1381                          * with the possibility of jamming (and we don't
1382                          * want to build jamming into it because then it
1383                          * will run more slowly).
1384                          */
1385
1386                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1387
1388                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1389
1390                         if ( yy_next_state )
1391                                 {
1392                                 /* Consume the NUL. */
1393                                 yy_cp = ++(yy_c_buf_p);
1394                                 yy_current_state = yy_next_state;
1395                                 goto yy_match;
1396                                 }
1397
1398                         else
1399                                 {
1400                                 yy_cp = (yy_c_buf_p);
1401                                 goto yy_find_action;
1402                                 }
1403                         }
1404
1405                 else switch ( yy_get_next_buffer(  ) )
1406                         {
1407                         case EOB_ACT_END_OF_FILE:
1408                                 {
1409                                 (yy_did_buffer_switch_on_eof) = 0;
1410
1411                                 if ( zconfwrap( ) )
1412                                         {
1413                                         /* Note: because we've taken care in
1414                                          * yy_get_next_buffer() to have set up
1415                                          * zconftext, we can now set up
1416                                          * yy_c_buf_p so that if some total
1417                                          * hoser (like flex itself) wants to
1418                                          * call the scanner after we return the
1419                                          * YY_NULL, it'll still work - another
1420                                          * YY_NULL will get returned.
1421                                          */
1422                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1423
1424                                         yy_act = YY_STATE_EOF(YY_START);
1425                                         goto do_action;
1426                                         }
1427
1428                                 else
1429                                         {
1430                                         if ( ! (yy_did_buffer_switch_on_eof) )
1431                                                 YY_NEW_FILE;
1432                                         }
1433                                 break;
1434                                 }
1435
1436                         case EOB_ACT_CONTINUE_SCAN:
1437                                 (yy_c_buf_p) =
1438                                         (yytext_ptr) + yy_amount_of_matched_text;
1439
1440                                 yy_current_state = yy_get_previous_state(  );
1441
1442                                 yy_cp = (yy_c_buf_p);
1443                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1444                                 goto yy_match;
1445
1446                         case EOB_ACT_LAST_MATCH:
1447                                 (yy_c_buf_p) =
1448                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1449
1450                                 yy_current_state = yy_get_previous_state(  );
1451
1452                                 yy_cp = (yy_c_buf_p);
1453                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1454                                 goto yy_find_action;
1455                         }
1456                 break;
1457                 }
1458
1459         default:
1460                 YY_FATAL_ERROR(
1461                         "fatal flex scanner internal error--no action found" );
1462         } /* end of action switch */
1463                 } /* end of scanning one token */
1464 } /* end of zconflex */
1465
1466 /* yy_get_next_buffer - try to read in a new buffer
1467  *
1468  * Returns a code representing an action:
1469  *      EOB_ACT_LAST_MATCH -
1470  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1471  *      EOB_ACT_END_OF_FILE - end of file
1472  */
1473 static int yy_get_next_buffer (void)
1474 {
1475         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1476         register char *source = (yytext_ptr);
1477         register int number_to_move, i;
1478         int ret_val;
1479
1480         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1481                 YY_FATAL_ERROR(
1482                 "fatal flex scanner internal error--end of buffer missed" );
1483
1484         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1485                 { /* Don't try to fill the buffer, so this is an EOF. */
1486                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1487                         {
1488                         /* We matched a single character, the EOB, so
1489                          * treat this as a final EOF.
1490                          */
1491                         return EOB_ACT_END_OF_FILE;
1492                         }
1493
1494                 else
1495                         {
1496                         /* We matched some text prior to the EOB, first
1497                          * process it.
1498                          */
1499                         return EOB_ACT_LAST_MATCH;
1500                         }
1501                 }
1502
1503         /* Try to read more data. */
1504
1505         /* First move last chars to start of buffer. */
1506         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1507
1508         for ( i = 0; i < number_to_move; ++i )
1509                 *(dest++) = *(source++);
1510
1511         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1512                 /* don't do the read, it's not guaranteed to return an EOF,
1513                  * just force an EOF
1514                  */
1515                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1516
1517         else
1518                 {
1519                         int num_to_read =
1520                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1521
1522                 while ( num_to_read <= 0 )
1523                         { /* Not enough room in the buffer - grow it. */
1524
1525                         /* just a shorter name for the current buffer */
1526                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1527
1528                         int yy_c_buf_p_offset =
1529                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1530
1531                         if ( b->yy_is_our_buffer )
1532                                 {
1533                                 int new_size = b->yy_buf_size * 2;
1534
1535                                 if ( new_size <= 0 )
1536                                         b->yy_buf_size += b->yy_buf_size / 8;
1537                                 else
1538                                         b->yy_buf_size *= 2;
1539
1540                                 b->yy_ch_buf = (char *)
1541                                         /* Include room in for 2 EOB chars. */
1542                                         zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1543                                 }
1544                         else
1545                                 /* Can't grow it, we don't own it. */
1546                                 b->yy_ch_buf = 0;
1547
1548                         if ( ! b->yy_ch_buf )
1549                                 YY_FATAL_ERROR(
1550                                 "fatal error - scanner input buffer overflow" );
1551
1552                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1553
1554                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1555                                                 number_to_move - 1;
1556
1557                         }
1558
1559                 if ( num_to_read > YY_READ_BUF_SIZE )
1560                         num_to_read = YY_READ_BUF_SIZE;
1561
1562                 /* Read in more data. */
1563                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1564                         (yy_n_chars), (size_t) num_to_read );
1565
1566                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1567                 }
1568
1569         if ( (yy_n_chars) == 0 )
1570                 {
1571                 if ( number_to_move == YY_MORE_ADJ )
1572                         {
1573                         ret_val = EOB_ACT_END_OF_FILE;
1574                         zconfrestart(zconfin  );
1575                         }
1576
1577                 else
1578                         {
1579                         ret_val = EOB_ACT_LAST_MATCH;
1580                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1581                                 YY_BUFFER_EOF_PENDING;
1582                         }
1583                 }
1584
1585         else
1586                 ret_val = EOB_ACT_CONTINUE_SCAN;
1587
1588         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1589                 /* Extend the array by 50%, plus the number we really need. */
1590                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1591                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1592                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1593                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1594         }
1595
1596         (yy_n_chars) += number_to_move;
1597         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1598         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1599
1600         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1601
1602         return ret_val;
1603 }
1604
1605 /* yy_get_previous_state - get the state just before the EOB char was reached */
1606
1607     static yy_state_type yy_get_previous_state (void)
1608 {
1609         register yy_state_type yy_current_state;
1610         register char *yy_cp;
1611
1612         yy_current_state = (yy_start);
1613
1614         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1615                 {
1616                 yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
1617                 }
1618
1619         return yy_current_state;
1620 }
1621
1622 /* yy_try_NUL_trans - try to make a transition on the NUL character
1623  *
1624  * synopsis
1625  *      next_state = yy_try_NUL_trans( current_state );
1626  */
1627     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1628 {
1629         register int yy_is_jam;
1630
1631         yy_current_state = yy_nxt[yy_current_state][1];
1632         yy_is_jam = (yy_current_state <= 0);
1633
1634         return yy_is_jam ? 0 : yy_current_state;
1635 }
1636
1637     static void yyunput (int c, register char * yy_bp )
1638 {
1639         register char *yy_cp;
1640
1641     yy_cp = (yy_c_buf_p);
1642
1643         /* undo effects of setting up zconftext */
1644         *yy_cp = (yy_hold_char);
1645
1646         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1647                 { /* need to shift things up to make room */
1648                 /* +2 for EOB chars. */
1649                 register int number_to_move = (yy_n_chars) + 2;
1650                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1651                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1652                 register char *source =
1653                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1654
1655                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1656                         *--dest = *--source;
1657
1658                 yy_cp += (int) (dest - source);
1659                 yy_bp += (int) (dest - source);
1660                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1661                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1662
1663                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1664                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1665                 }
1666
1667         *--yy_cp = (char) c;
1668
1669         (yytext_ptr) = yy_bp;
1670         (yy_hold_char) = *yy_cp;
1671         (yy_c_buf_p) = yy_cp;
1672 }
1673
1674 #ifndef YY_NO_INPUT
1675 #ifdef __cplusplus
1676     static int yyinput (void)
1677 #else
1678     static int input  (void)
1679 #endif
1680
1681 {
1682         int c;
1683
1684         *(yy_c_buf_p) = (yy_hold_char);
1685
1686         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1687                 {
1688                 /* yy_c_buf_p now points to the character we want to return.
1689                  * If this occurs *before* the EOB characters, then it's a
1690                  * valid NUL; if not, then we've hit the end of the buffer.
1691                  */
1692                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1693                         /* This was really a NUL. */
1694                         *(yy_c_buf_p) = '\0';
1695
1696                 else
1697                         { /* need more input */
1698                         int offset = (yy_c_buf_p) - (yytext_ptr);
1699                         ++(yy_c_buf_p);
1700
1701                         switch ( yy_get_next_buffer(  ) )
1702                                 {
1703                                 case EOB_ACT_LAST_MATCH:
1704                                         /* This happens because yy_g_n_b()
1705                                          * sees that we've accumulated a
1706                                          * token and flags that we need to
1707                                          * try matching the token before
1708                                          * proceeding.  But for input(),
1709                                          * there's no matching to consider.
1710                                          * So convert the EOB_ACT_LAST_MATCH
1711                                          * to EOB_ACT_END_OF_FILE.
1712                                          */
1713
1714                                         /* Reset buffer status. */
1715                                         zconfrestart(zconfin );
1716
1717                                         /*FALLTHROUGH*/
1718
1719                                 case EOB_ACT_END_OF_FILE:
1720                                         {
1721                                         if ( zconfwrap( ) )
1722                                                 return EOF;
1723
1724                                         if ( ! (yy_did_buffer_switch_on_eof) )
1725                                                 YY_NEW_FILE;
1726 #ifdef __cplusplus
1727                                         return yyinput();
1728 #else
1729                                         return input();
1730 #endif
1731                                         }
1732
1733                                 case EOB_ACT_CONTINUE_SCAN:
1734                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1735                                         break;
1736                                 }
1737                         }
1738                 }
1739
1740         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1741         *(yy_c_buf_p) = '\0';   /* preserve zconftext */
1742         (yy_hold_char) = *++(yy_c_buf_p);
1743
1744         return c;
1745 }
1746 #endif  /* ifndef YY_NO_INPUT */
1747
1748 /** Immediately switch to a different input stream.
1749  * @param input_file A readable stream.
1750  *
1751  * @note This function does not reset the start condition to @c INITIAL .
1752  */
1753     void zconfrestart  (FILE * input_file )
1754 {
1755
1756         if ( ! YY_CURRENT_BUFFER ){
1757         zconfensure_buffer_stack ();
1758                 YY_CURRENT_BUFFER_LVALUE =
1759             zconf_create_buffer(zconfin,YY_BUF_SIZE );
1760         }
1761
1762         zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
1763         zconf_load_buffer_state( );
1764 }
1765
1766 /** Switch to a different input buffer.
1767  * @param new_buffer The new input buffer.
1768  *
1769  */
1770     void zconf_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1771 {
1772
1773         /* TODO. We should be able to replace this entire function body
1774          * with
1775          *              zconfpop_buffer_state();
1776          *              zconfpush_buffer_state(new_buffer);
1777      */
1778         zconfensure_buffer_stack ();
1779         if ( YY_CURRENT_BUFFER == new_buffer )
1780                 return;
1781
1782         if ( YY_CURRENT_BUFFER )
1783                 {
1784                 /* Flush out information for old buffer. */
1785                 *(yy_c_buf_p) = (yy_hold_char);
1786                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1787                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1788                 }
1789
1790         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1791         zconf_load_buffer_state( );
1792
1793         /* We don't actually know whether we did this switch during
1794          * EOF (zconfwrap()) processing, but the only time this flag
1795          * is looked at is after zconfwrap() is called, so it's safe
1796          * to go ahead and always set it.
1797          */
1798         (yy_did_buffer_switch_on_eof) = 1;
1799 }
1800
1801 static void zconf_load_buffer_state  (void)
1802 {
1803         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1804         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1805         zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1806         (yy_hold_char) = *(yy_c_buf_p);
1807 }
1808
1809 /** Allocate and initialize an input buffer state.
1810  * @param file A readable stream.
1811  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1812  *
1813  * @return the allocated buffer state.
1814  */
1815     YY_BUFFER_STATE zconf_create_buffer  (FILE * file, int  size )
1816 {
1817         YY_BUFFER_STATE b;
1818
1819         b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
1820         if ( ! b )
1821                 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1822
1823         b->yy_buf_size = size;
1824
1825         /* yy_ch_buf has to be 2 characters longer than the size given because
1826          * we need to put in 2 end-of-buffer characters.
1827          */
1828         b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2  );
1829         if ( ! b->yy_ch_buf )
1830                 YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
1831
1832         b->yy_is_our_buffer = 1;
1833
1834         zconf_init_buffer(b,file );
1835
1836         return b;
1837 }
1838
1839 /** Destroy the buffer.
1840  * @param b a buffer created with zconf_create_buffer()
1841  *
1842  */
1843     void zconf_delete_buffer (YY_BUFFER_STATE  b )
1844 {
1845
1846         if ( ! b )
1847                 return;
1848
1849         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1850                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1851
1852         if ( b->yy_is_our_buffer )
1853                 zconffree((void *) b->yy_ch_buf  );
1854
1855         zconffree((void *) b  );
1856 }
1857
1858 /* Initializes or reinitializes a buffer.
1859  * This function is sometimes called more than once on the same buffer,
1860  * such as during a zconfrestart() or at EOF.
1861  */
1862     static void zconf_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1863
1864 {
1865         int oerrno = errno;
1866
1867         zconf_flush_buffer(b );
1868
1869         b->yy_input_file = file;
1870         b->yy_fill_buffer = 1;
1871
1872     /* If b is the current buffer, then zconf_init_buffer was _probably_
1873      * called from zconfrestart() or through yy_get_next_buffer.
1874      * In that case, we don't want to reset the lineno or column.
1875      */
1876     if (b != YY_CURRENT_BUFFER){
1877         b->yy_bs_lineno = 1;
1878         b->yy_bs_column = 0;
1879     }
1880
1881         b->yy_is_interactive = 0;
1882
1883         errno = oerrno;
1884 }
1885
1886 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1887  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1888  *
1889  */
1890     void zconf_flush_buffer (YY_BUFFER_STATE  b )
1891 {
1892         if ( ! b )
1893                 return;
1894
1895         b->yy_n_chars = 0;
1896
1897         /* We always need two end-of-buffer characters.  The first causes
1898          * a transition to the end-of-buffer state.  The second causes
1899          * a jam in that state.
1900          */
1901         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1902         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1903
1904         b->yy_buf_pos = &b->yy_ch_buf[0];
1905
1906         b->yy_at_bol = 1;
1907         b->yy_buffer_status = YY_BUFFER_NEW;
1908
1909         if ( b == YY_CURRENT_BUFFER )
1910                 zconf_load_buffer_state( );
1911 }
1912
1913 /** Pushes the new state onto the stack. The new state becomes
1914  *  the current state. This function will allocate the stack
1915  *  if necessary.
1916  *  @param new_buffer The new state.
1917  *
1918  */
1919 void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1920 {
1921         if (new_buffer == NULL)
1922                 return;
1923
1924         zconfensure_buffer_stack();
1925
1926         /* This block is copied from zconf_switch_to_buffer. */
1927         if ( YY_CURRENT_BUFFER )
1928                 {
1929                 /* Flush out information for old buffer. */
1930                 *(yy_c_buf_p) = (yy_hold_char);
1931                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1932                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1933                 }
1934
1935         /* Only push if top exists. Otherwise, replace top. */
1936         if (YY_CURRENT_BUFFER)
1937                 (yy_buffer_stack_top)++;
1938         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1939
1940         /* copied from zconf_switch_to_buffer. */
1941         zconf_load_buffer_state( );
1942         (yy_did_buffer_switch_on_eof) = 1;
1943 }
1944
1945 /** Removes and deletes the top of the stack, if present.
1946  *  The next element becomes the new top.
1947  *
1948  */
1949 void zconfpop_buffer_state (void)
1950 {
1951         if (!YY_CURRENT_BUFFER)
1952                 return;
1953
1954         zconf_delete_buffer(YY_CURRENT_BUFFER );
1955         YY_CURRENT_BUFFER_LVALUE = NULL;
1956         if ((yy_buffer_stack_top) > 0)
1957                 --(yy_buffer_stack_top);
1958
1959         if (YY_CURRENT_BUFFER) {
1960                 zconf_load_buffer_state( );
1961                 (yy_did_buffer_switch_on_eof) = 1;
1962         }
1963 }
1964
1965 /* Allocates the stack if it does not exist.
1966  *  Guarantees space for at least one push.
1967  */
1968 static void zconfensure_buffer_stack (void)
1969 {
1970         int num_to_alloc;
1971
1972         if (!(yy_buffer_stack)) {
1973
1974                 /* First allocation is just for 2 elements, since we don't know if this
1975                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1976                  * immediate realloc on the next call.
1977          */
1978                 num_to_alloc = 1;
1979                 (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
1980                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1981                                                                 );
1982                 if ( ! (yy_buffer_stack) )
1983                         YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
1984
1985                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1986
1987                 (yy_buffer_stack_max) = num_to_alloc;
1988                 (yy_buffer_stack_top) = 0;
1989                 return;
1990         }
1991
1992         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1993
1994                 /* Increase the buffer to prepare for a possible push. */
1995                 int grow_size = 8 /* arbitrary grow size */;
1996
1997                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1998                 (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
1999                                                                 ((yy_buffer_stack),
2000                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2001                                                                 );
2002                 if ( ! (yy_buffer_stack) )
2003                         YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
2004
2005                 /* zero only the new slots.*/
2006                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2007                 (yy_buffer_stack_max) = num_to_alloc;
2008         }
2009 }
2010
2011 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2012  * @param base the character buffer
2013  * @param size the size in bytes of the character buffer
2014  *
2015  * @return the newly allocated buffer state object.
2016  */
2017 YY_BUFFER_STATE zconf_scan_buffer  (char * base, yy_size_t  size )
2018 {
2019         YY_BUFFER_STATE b;
2020
2021         if ( size < 2 ||
2022              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2023              base[size-1] != YY_END_OF_BUFFER_CHAR )
2024                 /* They forgot to leave room for the EOB's. */
2025                 return 0;
2026
2027         b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
2028         if ( ! b )
2029                 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
2030
2031         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2032         b->yy_buf_pos = b->yy_ch_buf = base;
2033         b->yy_is_our_buffer = 0;
2034         b->yy_input_file = 0;
2035         b->yy_n_chars = b->yy_buf_size;
2036         b->yy_is_interactive = 0;
2037         b->yy_at_bol = 1;
2038         b->yy_fill_buffer = 0;
2039         b->yy_buffer_status = YY_BUFFER_NEW;
2040
2041         zconf_switch_to_buffer(b  );
2042
2043         return b;
2044 }
2045
2046 /** Setup the input buffer state to scan a string. The next call to zconflex() will
2047  * scan from a @e copy of @a str.
2048  * @param yystr a NUL-terminated string to scan
2049  *
2050  * @return the newly allocated buffer state object.
2051  * @note If you want to scan bytes that may contain NUL values, then use
2052  *       zconf_scan_bytes() instead.
2053  */
2054 YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
2055 {
2056
2057         return zconf_scan_bytes(yystr,strlen(yystr) );
2058 }
2059
2060 /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
2061  * scan from a @e copy of @a bytes.
2062  * @param bytes the byte buffer to scan
2063  * @param len the number of bytes in the buffer pointed to by @a bytes.
2064  *
2065  * @return the newly allocated buffer state object.
2066  */
2067 YY_BUFFER_STATE zconf_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2068 {
2069         YY_BUFFER_STATE b;
2070         char *buf;
2071         yy_size_t n;
2072         int i;
2073
2074         /* Get memory for full buffer, including space for trailing EOB's. */
2075         n = _yybytes_len + 2;
2076         buf = (char *) zconfalloc(n  );
2077         if ( ! buf )
2078                 YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
2079
2080         for ( i = 0; i < _yybytes_len; ++i )
2081                 buf[i] = yybytes[i];
2082
2083         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2084
2085         b = zconf_scan_buffer(buf,n );
2086         if ( ! b )
2087                 YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
2088
2089         /* It's okay to grow etc. this buffer, and we should throw it
2090          * away when we're done.
2091          */
2092         b->yy_is_our_buffer = 1;
2093
2094         return b;
2095 }
2096
2097 #ifndef YY_EXIT_FAILURE
2098 #define YY_EXIT_FAILURE 2
2099 #endif
2100
2101 static void yy_fatal_error (yyconst char* msg )
2102 {
2103         (void) fprintf( stderr, "%s\n", msg );
2104         exit( YY_EXIT_FAILURE );
2105 }
2106
2107 /* Redefine yyless() so it works in section 3 code. */
2108
2109 #undef yyless
2110 #define yyless(n) \
2111         do \
2112                 { \
2113                 /* Undo effects of setting up zconftext. */ \
2114         int yyless_macro_arg = (n); \
2115         YY_LESS_LINENO(yyless_macro_arg);\
2116                 zconftext[zconfleng] = (yy_hold_char); \
2117                 (yy_c_buf_p) = zconftext + yyless_macro_arg; \
2118                 (yy_hold_char) = *(yy_c_buf_p); \
2119                 *(yy_c_buf_p) = '\0'; \
2120                 zconfleng = yyless_macro_arg; \
2121                 } \
2122         while ( 0 )
2123
2124 /* Accessor  methods (get/set functions) to struct members. */
2125
2126 /** Get the current line number.
2127  *
2128  */
2129 int zconfget_lineno  (void)
2130 {
2131
2132     return zconflineno;
2133 }
2134
2135 /** Get the input stream.
2136  *
2137  */
2138 FILE *zconfget_in  (void)
2139 {
2140         return zconfin;
2141 }
2142
2143 /** Get the output stream.
2144  *
2145  */
2146 FILE *zconfget_out  (void)
2147 {
2148         return zconfout;
2149 }
2150
2151 /** Get the length of the current token.
2152  *
2153  */
2154 int zconfget_leng  (void)
2155 {
2156         return zconfleng;
2157 }
2158
2159 /** Get the current token.
2160  *
2161  */
2162
2163 char *zconfget_text  (void)
2164 {
2165         return zconftext;
2166 }
2167
2168 /** Set the current line number.
2169  * @param line_number
2170  *
2171  */
2172 void zconfset_lineno (int  line_number )
2173 {
2174
2175     zconflineno = line_number;
2176 }
2177
2178 /** Set the input stream. This does not discard the current
2179  * input buffer.
2180  * @param in_str A readable stream.
2181  *
2182  * @see zconf_switch_to_buffer
2183  */
2184 void zconfset_in (FILE *  in_str )
2185 {
2186         zconfin = in_str ;
2187 }
2188
2189 void zconfset_out (FILE *  out_str )
2190 {
2191         zconfout = out_str ;
2192 }
2193
2194 int zconfget_debug  (void)
2195 {
2196         return zconf_flex_debug;
2197 }
2198
2199 void zconfset_debug (int  bdebug )
2200 {
2201         zconf_flex_debug = bdebug ;
2202 }
2203
2204 static int yy_init_globals (void)
2205 {
2206         /* Initialization is the same as for the non-reentrant scanner.
2207      * This function is called from zconflex_destroy(), so don't allocate here.
2208      */
2209
2210     (yy_buffer_stack) = 0;
2211     (yy_buffer_stack_top) = 0;
2212     (yy_buffer_stack_max) = 0;
2213     (yy_c_buf_p) = (char *) 0;
2214     (yy_init) = 0;
2215     (yy_start) = 0;
2216
2217 /* Defined in main.c */
2218 #ifdef YY_STDINIT
2219     zconfin = stdin;
2220     zconfout = stdout;
2221 #else
2222     zconfin = (FILE *) 0;
2223     zconfout = (FILE *) 0;
2224 #endif
2225
2226     /* For future reference: Set errno on error, since we are called by
2227      * zconflex_init()
2228      */
2229     return 0;
2230 }
2231
2232 /* zconflex_destroy is for both reentrant and non-reentrant scanners. */
2233 int zconflex_destroy  (void)
2234 {
2235
2236     /* Pop the buffer stack, destroying each element. */
2237         while(YY_CURRENT_BUFFER){
2238                 zconf_delete_buffer(YY_CURRENT_BUFFER  );
2239                 YY_CURRENT_BUFFER_LVALUE = NULL;
2240                 zconfpop_buffer_state();
2241         }
2242
2243         /* Destroy the stack itself. */
2244         zconffree((yy_buffer_stack) );
2245         (yy_buffer_stack) = NULL;
2246
2247     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2248      * zconflex() is called, initialization will occur. */
2249     yy_init_globals( );
2250
2251     return 0;
2252 }
2253
2254 /*
2255  * Internal utility routines.
2256  */
2257
2258 #ifndef yytext_ptr
2259 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2260 {
2261         register int i;
2262         for ( i = 0; i < n; ++i )
2263                 s1[i] = s2[i];
2264 }
2265 #endif
2266
2267 #ifdef YY_NEED_STRLEN
2268 static int yy_flex_strlen (yyconst char * s )
2269 {
2270         register int n;
2271         for ( n = 0; s[n]; ++n )
2272                 ;
2273
2274         return n;
2275 }
2276 #endif
2277
2278 void *zconfalloc (yy_size_t  size )
2279 {
2280         return (void *) malloc( size );
2281 }
2282
2283 void *zconfrealloc  (void * ptr, yy_size_t  size )
2284 {
2285         /* The cast to (char *) in the following accommodates both
2286          * implementations that use char* generic pointers, and those
2287          * that use void* generic pointers.  It works with the latter
2288          * because both ANSI C and C++ allow castless assignment from
2289          * any pointer type to void*, and deal with argument conversions
2290          * as though doing an assignment.
2291          */
2292         return (void *) realloc( (char *) ptr, size );
2293 }
2294
2295 void zconffree (void * ptr )
2296 {
2297         free( (char *) ptr );   /* see zconfrealloc() for (char *) cast */
2298 }
2299
2300 #define YYTABLES_NAME "yytables"
2301
2302 void zconf_starthelp(void)
2303 {
2304         new_string();
2305         last_ts = first_ts = 0;
2306         BEGIN(HELP);
2307 }
2308
2309 static void zconf_endhelp(void)
2310 {
2311         zconflval.string = text;
2312         BEGIN(INITIAL);
2313 }
2314
2315 /*
2316  * Try to open specified file with following names:
2317  * ./name
2318  * $(srctree)/name
2319  * The latter is used when srctree is separate from objtree
2320  * when compiling the kernel.
2321  * Return NULL if file is not found.
2322  */
2323 FILE *zconf_fopen(const char *name)
2324 {
2325         char *env, fullname[PATH_MAX+1];
2326         FILE *f;
2327
2328         f = fopen(name, "r");
2329         if (!f && name != NULL && name[0] != '/') {
2330                 env = getenv(SRCTREE);
2331                 if (env) {
2332                         sprintf(fullname, "%s/%s", env, name);
2333                         f = fopen(fullname, "r");
2334                 }
2335         }
2336         return f;
2337 }
2338
2339 void zconf_initscan(const char *name)
2340 {
2341         zconfin = zconf_fopen(name);
2342         if (!zconfin) {
2343                 printf("can't find file %s\n", name);
2344                 exit(1);
2345         }
2346
2347         current_buf = malloc(sizeof(*current_buf));
2348         memset(current_buf, 0, sizeof(*current_buf));
2349
2350         current_file = file_lookup(name);
2351         current_file->lineno = 1;
2352 }
2353
2354 void zconf_nextfile(const char *name)
2355 {
2356         struct file *iter;
2357         struct file *file = file_lookup(name);
2358         struct buffer *buf = malloc(sizeof(*buf));
2359         memset(buf, 0, sizeof(*buf));
2360
2361         current_buf->state = YY_CURRENT_BUFFER;
2362         zconfin = zconf_fopen(file->name);
2363         if (!zconfin) {
2364                 printf("%s:%d: can't open file \"%s\"\n",
2365                     zconf_curname(), zconf_lineno(), file->name);
2366                 exit(1);
2367         }
2368         zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
2369         buf->parent = current_buf;
2370         current_buf = buf;
2371
2372         for (iter = current_file->parent; iter; iter = iter->parent ) {
2373                 if (!strcmp(current_file->name,iter->name) ) {
2374                         printf("%s:%d: recursive inclusion detected. "
2375                                "Inclusion path:\n  current file : '%s'\n",
2376                                zconf_curname(), zconf_lineno(),
2377                                zconf_curname());
2378                         iter = current_file->parent;
2379                         while (iter && \
2380                                strcmp(iter->name,current_file->name)) {
2381                                 printf("  included from: '%s:%d'\n",
2382                                        iter->name, iter->lineno-1);
2383                                 iter = iter->parent;
2384                         }
2385                         if (iter)
2386                                 printf("  included from: '%s:%d'\n",
2387                                        iter->name, iter->lineno+1);
2388                         exit(1);
2389                 }
2390         }
2391         file->lineno = 1;
2392         file->parent = current_file;
2393         current_file = file;
2394 }
2395
2396 static void zconf_endfile(void)
2397 {
2398         struct buffer *parent;
2399
2400         current_file = current_file->parent;
2401
2402         parent = current_buf->parent;
2403         if (parent) {
2404                 fclose(zconfin);
2405                 zconf_delete_buffer(YY_CURRENT_BUFFER);
2406                 zconf_switch_to_buffer(parent->state);
2407         }
2408         free(current_buf);
2409         current_buf = parent;
2410 }
2411
2412 int zconf_lineno(void)
2413 {
2414         return current_pos.lineno;
2415 }
2416
2417 const char *zconf_curname(void)
2418 {
2419         return current_pos.file ? current_pos.file->name : "<none>";
2420 }
2421