scripts/config/zconf.lex.c_shipped

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