scripts/kconfig/zconf.lex.c_shipped

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