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