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