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