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 #include "lkc.h"
 780
 781 #define START_STRSIZE   16
 782
 783 static struct {
 784         struct file *file;
 785         int lineno;
 786 } current_pos;
 787
 788 static char *text;
 789 static int text_size, text_asize;
 790
 791 struct buffer {
 792         struct buffer *parent;
 793         YY_BUFFER_STATE state;
 794 };
 795
 796 struct buffer *current_buf;
 797
 798 static int last_ts, first_ts;
 799
 800 static void zconf_endhelp(void);
 801 static void zconf_endfile(void);
 802
 803 static void new_string(void)
 804 {
 805         text = xmalloc(START_STRSIZE);
 806         text_asize = START_STRSIZE;
 807         text_size = 0;
 808         *text = 0;
 809 }
 810
 811 static 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
 825 static void alloc_string(const char *str, int size)
 826 {
 827         text = xmalloc(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
 850 static int yy_init_globals (void );
 851
 852 /* Accessor methods to globals.
 853    These are made visible to non-reentrant scanners for convenience. */
 854
 855 int zconflex_destroy (void );
 856
 857 int zconfget_debug (void );
 858
 859 void zconfset_debug (int debug_flag  );
 860
 861 YY_EXTRA_TYPE zconfget_extra (void );
 862
 863 void zconfset_extra (YY_EXTRA_TYPE user_defined  );
 864
 865 FILE *zconfget_in (void );
 866
 867 void zconfset_in  (FILE * in_str  );
 868
 869 FILE *zconfget_out (void );
 870
 871 void zconfset_out  (FILE * out_str  );
 872
 873 int zconfget_leng (void );
 874
 875 char *zconfget_text (void );
 876
 877 int zconfget_lineno (void );
 878
 879 void 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
 887 extern "C" int zconfwrap (void );
 888 #else
 889 extern int zconfwrap (void );
 890 #endif
 891 #endif
 892
 893     static void yyunput (int c,char *buf_ptr  );
 894
 895 #ifndef yytext_ptr
 896 static void yy_flex_strncpy (char *,yyconst char *,int );
 897 #endif
 898
 899 #ifdef YY_NEED_STRLEN
 900 static int yy_flex_strlen (yyconst char * );
 901 #endif
 902
 903 #ifndef YY_NO_INPUT
 904
 905 #ifdef __cplusplus
 906 static int yyinput (void );
 907 #else
 908 static 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
 972 extern 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  */
 994 YY_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);
1042 yy_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
1048 yy_find_action:
1049                 yy_act = yy_accept[yy_current_state];
1050
1051                 YY_DO_BEFORE_ACTION;
1052
1053 do_action:      /* This label is used only to access EOF actions. */
1054
1055                 switch ( yy_act )
1056         { /* beginning of action switch */
1057 case 1:
1058 /* rule 1 can match eol */
1059 case 2:
1060 /* rule 2 can match eol */
1061 YY_RULE_SETUP
1062 {
1063         current_file->lineno++;
1064         return T_EOL;
1065 }
1066         YY_BREAK
1067 case 3:
1068 YY_RULE_SETUP
1069
1070         YY_BREAK
1071 case 4:
1072 YY_RULE_SETUP
1073 {
1074         BEGIN(COMMAND);
1075 }
1076         YY_BREAK
1077 case 5:
1078 YY_RULE_SETUP
1079 {
1080         unput(zconftext[0]);
1081         BEGIN(COMMAND);
1082 }
1083         YY_BREAK
1084
1085 case 6:
1086 YY_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
1101 case 7:
1102 YY_RULE_SETUP
1103
1104         YY_BREAK
1105 case 8:
1106 /* rule 8 can match eol */
1107 YY_RULE_SETUP
1108 {
1109                 BEGIN(INITIAL);
1110                 current_file->lineno++;
1111                 return T_EOL;
1112         }
1113         YY_BREAK
1114
1115 case 9:
1116 YY_RULE_SETUP
1117 return T_AND;
1118         YY_BREAK
1119 case 10:
1120 YY_RULE_SETUP
1121 return T_OR;
1122         YY_BREAK
1123 case 11:
1124 YY_RULE_SETUP
1125 return T_OPEN_PAREN;
1126         YY_BREAK
1127 case 12:
1128 YY_RULE_SETUP
1129 return T_CLOSE_PAREN;
1130         YY_BREAK
1131 case 13:
1132 YY_RULE_SETUP
1133 return T_NOT;
1134         YY_BREAK
1135 case 14:
1136 YY_RULE_SETUP
1137 return T_EQUAL;
1138         YY_BREAK
1139 case 15:
1140 YY_RULE_SETUP
1141 return T_UNEQUAL;
1142         YY_BREAK
1143 case 16:
1144 YY_RULE_SETUP
1145 {
1146                 str = zconftext[0];
1147                 new_string();
1148                 BEGIN(STRING);
1149         }
1150         YY_BREAK
1151 case 17:
1152 /* rule 17 can match eol */
1153 YY_RULE_SETUP
1154 BEGIN(INITIAL); current_file->lineno++; return T_EOL;
1155         YY_BREAK
1156 case 18:
1157 YY_RULE_SETUP
1158 /* ignore */
1159         YY_BREAK
1160 case 19:
1161 YY_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
1173 case 20:
1174 YY_RULE_SETUP
1175 /* comment */
1176         YY_BREAK
1177 case 21:
1178 /* rule 21 can match eol */
1179 YY_RULE_SETUP
1180 current_file->lineno++;
1181         YY_BREAK
1182 case 22:
1183 YY_RULE_SETUP
1184
1185         YY_BREAK
1186 case YY_STATE_EOF(PARAM):
1187 {
1188                 BEGIN(INITIAL);
1189         }
1190         YY_BREAK
1191
1192 case 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;
1196 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1197 YY_RULE_SETUP
1198 {
1199                 append_string(zconftext, zconfleng);
1200                 zconflval.string = text;
1201                 return T_WORD_QUOTE;
1202         }
1203         YY_BREAK
1204 case 24:
1205 YY_RULE_SETUP
1206 {
1207                 append_string(zconftext, zconfleng);
1208         }
1209         YY_BREAK
1210 case 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;
1214 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1215 YY_RULE_SETUP
1216 {
1217                 append_string(zconftext + 1, zconfleng - 1);
1218                 zconflval.string = text;
1219                 return T_WORD_QUOTE;
1220         }
1221         YY_BREAK
1222 case 26:
1223 YY_RULE_SETUP
1224 {
1225                 append_string(zconftext + 1, zconfleng - 1);
1226         }
1227         YY_BREAK
1228 case 27:
1229 YY_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
1239 case 28:
1240 /* rule 28 can match eol */
1241 YY_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
1249 case YY_STATE_EOF(STRING):
1250 {
1251                 BEGIN(INITIAL);
1252         }
1253         YY_BREAK
1254
1255 case 29:
1256 YY_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
1280 case 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;
1284 YY_DO_BEFORE_ACTION; /* set up zconftext again */
1285 YY_RULE_SETUP
1286 {
1287                 current_file->lineno++;
1288                 zconf_endhelp();
1289                 return T_HELPTEXT;
1290         }
1291         YY_BREAK
1292 case 31:
1293 /* rule 31 can match eol */
1294 YY_RULE_SETUP
1295 {
1296                 current_file->lineno++;
1297                 append_string("\n", 1);
1298         }
1299         YY_BREAK
1300 case 32:
1301 YY_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
1313 case YY_STATE_EOF(HELP):
1314 {
1315                 zconf_endhelp();
1316                 return T_HELPTEXT;
1317         }
1318         YY_BREAK
1319
1320 case YY_STATE_EOF(INITIAL):
1321 case 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
1331 case 33:
1332 YY_RULE_SETUP
1333 YY_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  */
1472 static 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
1800 static 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  */
1918 void 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  */
1948 void 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  */
1967 static 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  */
2016 YY_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  */
2053 YY_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  */
2066 YY_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
2100 static 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  */
2128 int zconfget_lineno  (void)
2129 {
2130
2131     return zconflineno;
2132 }
2133
2134 /** Get the input stream.
2135  *
2136  */
2137 FILE *zconfget_in  (void)
2138 {
2139         return zconfin;
2140 }
2141
2142 /** Get the output stream.
2143  *
2144  */
2145 FILE *zconfget_out  (void)
2146 {
2147         return zconfout;
2148 }
2149
2150 /** Get the length of the current token.
2151  *
2152  */
2153 int zconfget_leng  (void)
2154 {
2155         return zconfleng;
2156 }
2157
2158 /** Get the current token.
2159  *
2160  */
2161
2162 char *zconfget_text  (void)
2163 {
2164         return zconftext;
2165 }
2166
2167 /** Set the current line number.
2168  * @param line_number
2169  *
2170  */
2171 void 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  */
2183 void zconfset_in (FILE *  in_str )
2184 {
2185         zconfin = in_str ;
2186 }
2187
2188 void zconfset_out (FILE *  out_str )
2189 {
2190         zconfout = out_str ;
2191 }
2192
2193 int zconfget_debug  (void)
2194 {
2195         return zconf_flex_debug;
2196 }
2197
2198 void zconfset_debug (int  bdebug )
2199 {
2200         zconf_flex_debug = bdebug ;
2201 }
2202
2203 static 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. */
2232 int 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
2258 static 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
2267 static 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
2277 void *zconfalloc (yy_size_t  size )
2278 {
2279         return (void *) malloc( size );
2280 }
2281
2282 void *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
2294 void zconffree (void * ptr )
2295 {
2296         free( (char *) ptr );   /* see zconfrealloc() for (char *) cast */
2297 }
2298
2299 #define YYTABLES_NAME "yytables"
2300
2301 void zconf_starthelp(void)
2302 {
2303         new_string();
2304         last_ts = first_ts = 0;
2305         BEGIN(HELP);
2306 }
2307
2308 static 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  */
2322 FILE *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
2338 void 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 = xmalloc(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
2353 void zconf_nextfile(const char *name)
2354 {
2355         struct file *iter;
2356         struct file *file = file_lookup(name);
2357         struct buffer *buf = xmalloc(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
2395 static 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
2411 int zconf_lineno(void)
2412 {
2413         return current_pos.lineno;
2414 }
2415
2416 const char *zconf_curname(void)
2417 {
2418         return current_pos.file ? current_pos.file->name : "<none>";
2419 }
2420