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