1 2#line 3 "lex.null_.c" 3 4#define YY_INT_ALIGNED short int 5 6/* A lexical scanner generated by flex */ 7 8#define yy_create_buffer null__create_buffer 9#define yy_delete_buffer null__delete_buffer 10#define yy_flex_debug null__flex_debug 11#define yy_init_buffer null__init_buffer 12#define yy_flush_buffer null__flush_buffer 13#define yy_load_buffer_state null__load_buffer_state 14#define yy_switch_to_buffer null__switch_to_buffer 15#define yyin null_in 16#define yyleng null_leng 17#define yylex null_lex 18#define yylineno null_lineno 19#define yyout null_out 20#define yyrestart null_restart 21#define yytext null_text 22#define yywrap null_wrap 23#define yyalloc null_alloc 24#define yyrealloc null_realloc 25#define yyfree null_free 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 null_restart(null_in ) 158 159#define YY_END_OF_BUFFER_CHAR 0 160 161/* Size of default input buffer. */ 162#ifndef YY_BUF_SIZE 163#ifdef __ia64__ 164/* On IA-64, the buffer size is 16k, not 8k. 165 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. 166 * Ditto for the __ia64__ case accordingly. 167 */ 168#define YY_BUF_SIZE 32768 169#else 170#define YY_BUF_SIZE 16384 171#endif /* __ia64__ */ 172#endif 173 174/* The state buf must be large enough to hold one state per character in the main buffer. 175 */ 176#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 177 178#ifndef YY_TYPEDEF_YY_BUFFER_STATE 179#define YY_TYPEDEF_YY_BUFFER_STATE 180typedef struct yy_buffer_state *YY_BUFFER_STATE; 181#endif 182 183extern int null_leng; 184 185extern FILE *null_in, *null_out; 186 187#define EOB_ACT_CONTINUE_SCAN 0 188#define EOB_ACT_END_OF_FILE 1 189#define EOB_ACT_LAST_MATCH 2 190 191 #define YY_LESS_LINENO(n) 192 193/* Return all but the first "n" matched characters back to the input stream. */ 194#define yyless(n) \ 195 do \ 196 { \ 197 /* Undo effects of setting up null_text. */ \ 198 int yyless_macro_arg = (n); \ 199 YY_LESS_LINENO(yyless_macro_arg);\ 200 *yy_cp = (yy_hold_char); \ 201 YY_RESTORE_YY_MORE_OFFSET \ 202 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 203 YY_DO_BEFORE_ACTION; /* set up null_text again */ \ 204 } \ 205 while ( 0 ) 206 207#define unput(c) yyunput( c, (yytext_ptr) ) 208 209#ifndef YY_TYPEDEF_YY_SIZE_T 210#define YY_TYPEDEF_YY_SIZE_T 211typedef size_t yy_size_t; 212#endif 213 214#ifndef YY_STRUCT_YY_BUFFER_STATE 215#define YY_STRUCT_YY_BUFFER_STATE 216struct yy_buffer_state 217 { 218 FILE *yy_input_file; 219 220 char *yy_ch_buf; /* input buffer */ 221 char *yy_buf_pos; /* current position in input buffer */ 222 223 /* Size of input buffer in bytes, not including room for EOB 224 * characters. 225 */ 226 yy_size_t yy_buf_size; 227 228 /* Number of characters read into yy_ch_buf, not including EOB 229 * characters. 230 */ 231 int yy_n_chars; 232 233 /* Whether we "own" the buffer - i.e., we know we created it, 234 * and can realloc() it to grow it, and should free() it to 235 * delete it. 236 */ 237 int yy_is_our_buffer; 238 239 /* Whether this is an "interactive" input source; if so, and 240 * if we're using stdio for input, then we want to use getc() 241 * instead of fread(), to make sure we stop fetching input after 242 * each newline. 243 */ 244 int yy_is_interactive; 245 246 /* Whether we're considered to be at the beginning of a line. 247 * If so, '^' rules will be active on the next match, otherwise 248 * not. 249 */ 250 int yy_at_bol; 251 252 int yy_bs_lineno; /**< The line count. */ 253 int yy_bs_column; /**< The column count. */ 254 255 /* Whether to try to fill the input buffer when we reach the 256 * end of it. 257 */ 258 int yy_fill_buffer; 259 260 int yy_buffer_status; 261 262#define YY_BUFFER_NEW 0 263#define YY_BUFFER_NORMAL 1 264 /* When an EOF's been seen but there's still some text to process 265 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 266 * shouldn't try reading from the input source any more. We might 267 * still have a bunch of tokens to match, though, because of 268 * possible backing-up. 269 * 270 * When we actually see the EOF, we change the status to "new" 271 * (via null_restart()), so that the user can continue scanning by 272 * just pointing null_in at a new input file. 273 */ 274#define YY_BUFFER_EOF_PENDING 2 275 276 }; 277#endif /* !YY_STRUCT_YY_BUFFER_STATE */ 278 279/* Stack of input buffers. */ 280static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 281static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 282static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ 283 284/* We provide macros for accessing buffer states in case in the 285 * future we want to put the buffer states in a more general 286 * "scanner state". 287 * 288 * Returns the top of the stack, or NULL. 289 */ 290#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 291 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 292 : NULL) 293 294/* Same as previous macro, but useful when we know that the buffer stack is not 295 * NULL or when we need an lvalue. For internal use only. 296 */ 297#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 298 299/* yy_hold_char holds the character lost when null_text is formed. */ 300static char yy_hold_char; 301static int yy_n_chars; /* number of characters read into yy_ch_buf */ 302int null_leng; 303 304/* Points to current character in buffer. */ 305static char *yy_c_buf_p = (char *) 0; 306static int yy_init = 0; /* whether we need to initialize */ 307static int yy_start = 0; /* start state number */ 308 309/* Flag which is used to allow null_wrap()'s to do buffer switches 310 * instead of setting up a fresh null_in. A bit of a hack ... 311 */ 312static int yy_did_buffer_switch_on_eof; 313 314void null_restart (FILE *input_file ); 315void null__switch_to_buffer (YY_BUFFER_STATE new_buffer ); 316YY_BUFFER_STATE null__create_buffer (FILE *file,int size ); 317void null__delete_buffer (YY_BUFFER_STATE b ); 318void null__flush_buffer (YY_BUFFER_STATE b ); 319void null_push_buffer_state (YY_BUFFER_STATE new_buffer ); 320void null_pop_buffer_state (void ); 321 322static void null_ensure_buffer_stack (void ); 323static void null__load_buffer_state (void ); 324static void null__init_buffer (YY_BUFFER_STATE b,FILE *file ); 325 326#define YY_FLUSH_BUFFER null__flush_buffer(YY_CURRENT_BUFFER ) 327 328YY_BUFFER_STATE null__scan_buffer (char *base,yy_size_t size ); 329YY_BUFFER_STATE null__scan_string (yyconst char *yy_str ); 330YY_BUFFER_STATE null__scan_bytes (yyconst char *bytes,int len ); 331 332void *null_alloc (yy_size_t ); 333void *null_realloc (void *,yy_size_t ); 334void null_free (void * ); 335 336#define yy_new_buffer null__create_buffer 337 338#define yy_set_interactive(is_interactive) \ 339 { \ 340 if ( ! YY_CURRENT_BUFFER ){ \ 341 null_ensure_buffer_stack (); \ 342 YY_CURRENT_BUFFER_LVALUE = \ 343 null__create_buffer(null_in,YY_BUF_SIZE ); \ 344 } \ 345 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 346 } 347 348#define yy_set_bol(at_bol) \ 349 { \ 350 if ( ! YY_CURRENT_BUFFER ){\ 351 null_ensure_buffer_stack (); \ 352 YY_CURRENT_BUFFER_LVALUE = \ 353 null__create_buffer(null_in,YY_BUF_SIZE ); \ 354 } \ 355 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 356 } 357 358#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 359 360typedef unsigned char YY_CHAR; 361 362FILE *null_in = (FILE *) 0, *null_out = (FILE *) 0; 363 364typedef int yy_state_type; 365 366extern int null_lineno; 367 368int null_lineno = 1; 369 370extern char *null_text; 371#define yytext_ptr null_text 372 373static yy_state_type yy_get_previous_state (void ); 374static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 375static int yy_get_next_buffer (void ); 376static void yy_fatal_error (yyconst char msg[] ); 377 378/* Done after the current pattern has been matched and before the 379 * corresponding action - sets up null_text. 380 */ 381#define YY_DO_BEFORE_ACTION \ 382 (yytext_ptr) = yy_bp; \ 383 null_leng = (size_t) (yy_cp - yy_bp); \ 384 (yy_hold_char) = *yy_cp; \ 385 *yy_cp = '\0'; \ 386 (yy_c_buf_p) = yy_cp; 387 388#define YY_NUM_RULES 1 389#define YY_END_OF_BUFFER 2 390/* This struct is not used in this scanner, 391 but its presence is necessary. */ 392struct yy_trans_info 393 { 394 flex_int32_t yy_verify; 395 flex_int32_t yy_nxt; 396 }; 397static yyconst flex_int16_t yy_accept[6] = 398 { 0, 399 0, 0, 2, 1, 0 400 } ; 401 402static yyconst flex_int32_t yy_ec[256] = 403 { 0, 404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 414 415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 425 426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 431 1, 1, 1, 1, 1 432 } ; 433 434static yyconst flex_int32_t yy_meta[2] = 435 { 0, 436 1 437 } ; 438 439static yyconst flex_int16_t yy_base[7] = 440 { 0, 441 0, 0, 2, 3, 3, 0 442 } ; 443 444static yyconst flex_int16_t yy_def[7] = 445 { 0, 446 6, 6, 5, 5, 0, 5 447 } ; 448 449static yyconst flex_int16_t yy_nxt[5] = 450 { 0, 451 4, 5, 3, 5 452 } ; 453 454static yyconst flex_int16_t yy_chk[5] = 455 { 0, 456 6, 3, 5, 5 457 } ; 458 459static yy_state_type yy_last_accepting_state; 460static char *yy_last_accepting_cpos; 461 462extern int null__flex_debug; 463int null__flex_debug = 0; 464 465/* The intent behind this definition is that it'll catch 466 * any uses of REJECT which flex missed. 467 */ 468#define REJECT reject_used_but_not_detected 469#define yymore() yymore_used_but_not_detected 470#define YY_MORE_ADJ 0 471#define YY_RESTORE_YY_MORE_OFFSET 472char *null_text; 473#line 1 "../../fsinfo/null_lex.l" 474#line 2 "../../fsinfo/null_lex.l" 475#include "null_gram.h" 476 477void null_error(const char *fmt, ...) {} 478int null_wrap(void) { return 0; } 479#define YY_NO_INPUT 1 480#line 481 "lex.null_.c" 481 482#define INITIAL 0 483 484#ifndef YY_NO_UNISTD_H 485/* Special case for "unistd.h", since it is non-ANSI. We include it way 486 * down here because we want the user's section 1 to have been scanned first. 487 * The user has a chance to override it with an option. 488 */ 489#include <unistd.h> 490#endif 491 492#ifndef YY_EXTRA_TYPE 493#define YY_EXTRA_TYPE void * 494#endif 495 496static int yy_init_globals (void ); 497 498/* Accessor methods to globals. 499 These are made visible to non-reentrant scanners for convenience. */ 500 501int null_lex_destroy (void ); 502 503int null_get_debug (void ); 504 505void null_set_debug (int debug_flag ); 506 507YY_EXTRA_TYPE null_get_extra (void ); 508 509void null_set_extra (YY_EXTRA_TYPE user_defined ); 510 511FILE *null_get_in (void ); 512 513void null_set_in (FILE * in_str ); 514 515FILE *null_get_out (void ); 516 517void null_set_out (FILE * out_str ); 518 519int null_get_leng (void ); 520 521char *null_get_text (void ); 522 523int null_get_lineno (void ); 524 525void null_set_lineno (int line_number ); 526 527/* Macros after this point can all be overridden by user definitions in 528 * section 1. 529 */ 530 531#ifndef YY_SKIP_YYWRAP 532#ifdef __cplusplus 533extern "C" int null_wrap (void ); 534#else 535extern int null_wrap (void ); 536#endif 537#endif 538 539#ifndef yytext_ptr 540static void yy_flex_strncpy (char *,yyconst char *,int ); 541#endif 542 543#ifdef YY_NEED_STRLEN 544static int yy_flex_strlen (yyconst char * ); 545#endif 546 547#ifndef YY_NO_INPUT 548 549#ifdef __cplusplus 550static int yyinput (void ); 551#else 552static int input (void ); 553#endif 554 555#endif 556 557/* Amount of stuff to slurp up with each read. */ 558#ifndef YY_READ_BUF_SIZE 559#ifdef __ia64__ 560/* On IA-64, the buffer size is 16k, not 8k */ 561#define YY_READ_BUF_SIZE 16384 562#else 563#define YY_READ_BUF_SIZE 8192 564#endif /* __ia64__ */ 565#endif 566 567/* Copy whatever the last rule matched to the standard output. */ 568#ifndef ECHO 569/* This used to be an fputs(), but since the string might contain NUL's, 570 * we now use fwrite(). 571 */ 572#define ECHO do { if (fwrite( null_text, null_leng, 1, null_out )) {} } while (0) 573#endif 574 575/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 576 * is returned in "result". 577 */ 578#ifndef YY_INPUT 579#define YY_INPUT(buf,result,max_size) \ 580 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 581 { \ 582 int c = '*'; \ 583 size_t n; \ 584 for ( n = 0; n < max_size && \ 585 (c = getc( null_in )) != EOF && c != '\n'; ++n ) \ 586 buf[n] = (char) c; \ 587 if ( c == '\n' ) \ 588 buf[n++] = (char) c; \ 589 if ( c == EOF && ferror( null_in ) ) \ 590 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 591 result = n; \ 592 } \ 593 else \ 594 { \ 595 errno=0; \ 596 while ( (result = fread(buf, 1, max_size, null_in))==0 && ferror(null_in)) \ 597 { \ 598 if( errno != EINTR) \ 599 { \ 600 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 601 break; \ 602 } \ 603 errno=0; \ 604 clearerr(null_in); \ 605 } \ 606 }\ 607\ 608 609#endif 610 611/* No semi-colon after return; correct usage is to write "yyterminate();" - 612 * we don't want an extra ';' after the "return" because that will cause 613 * some compilers to complain about unreachable statements. 614 */ 615#ifndef yyterminate 616#define yyterminate() return YY_NULL 617#endif 618 619/* Number of entries by which start-condition stack grows. */ 620#ifndef YY_START_STACK_INCR 621#define YY_START_STACK_INCR 25 622#endif 623 624/* Report a fatal error. */ 625#ifndef YY_FATAL_ERROR 626#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 627#endif 628 629/* end tables serialization structures and prototypes */ 630 631/* Default declaration of generated scanner - a define so the user can 632 * easily add parameters. 633 */ 634#ifndef YY_DECL 635#define YY_DECL_IS_OURS 1 636 637extern int null_lex (void); 638 639#define YY_DECL int null_lex (void) 640#endif /* !YY_DECL */ 641 642/* Code executed at the beginning of each rule, after null_text and null_leng 643 * have been set up. 644 */ 645#ifndef YY_USER_ACTION 646#define YY_USER_ACTION 647#endif 648 649/* Code executed at the end of each rule. */ 650#ifndef YY_BREAK 651#define YY_BREAK break; 652#endif 653 654#define YY_RULE_SETUP \ 655 YY_USER_ACTION 656 657/** The main scanner function which does all the work. 658 */ 659YY_DECL 660{ 661 register yy_state_type yy_current_state; 662 register char *yy_cp, *yy_bp; 663 register int yy_act; 664 665#line 9 "../../fsinfo/null_lex.l" 666 667#line 668 "lex.null_.c" 668 669 if ( !(yy_init) ) 670 { 671 (yy_init) = 1; 672 673#ifdef YY_USER_INIT 674 YY_USER_INIT; 675#endif 676 677 if ( ! (yy_start) ) 678 (yy_start) = 1; /* first start state */ 679 680 if ( ! null_in ) 681 null_in = stdin; 682 683 if ( ! null_out ) 684 null_out = stdout; 685 686 if ( ! YY_CURRENT_BUFFER ) { 687 null_ensure_buffer_stack (); 688 YY_CURRENT_BUFFER_LVALUE = 689 null__create_buffer(null_in,YY_BUF_SIZE ); 690 } 691 692 null__load_buffer_state( ); 693 } 694 695 while ( 1 ) /* loops until end-of-file is reached */ 696 { 697 yy_cp = (yy_c_buf_p); 698 699 /* Support of null_text. */ 700 *yy_cp = (yy_hold_char); 701 702 /* yy_bp points to the position in yy_ch_buf of the start of 703 * the current run. 704 */ 705 yy_bp = yy_cp; 706 707 yy_current_state = (yy_start); 708yy_match: 709 do 710 { 711 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 712 if ( yy_accept[yy_current_state] ) 713 { 714 (yy_last_accepting_state) = yy_current_state; 715 (yy_last_accepting_cpos) = yy_cp; 716 } 717 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 718 { 719 yy_current_state = (int) yy_def[yy_current_state]; 720 if ( yy_current_state >= 6 ) 721 yy_c = yy_meta[(unsigned int) yy_c]; 722 } 723 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 724 ++yy_cp; 725 } 726 while ( yy_base[yy_current_state] != 3 ); 727 728yy_find_action: 729 yy_act = yy_accept[yy_current_state]; 730 if ( yy_act == 0 ) 731 { /* have to back up */ 732 yy_cp = (yy_last_accepting_cpos); 733 yy_current_state = (yy_last_accepting_state); 734 yy_act = yy_accept[yy_current_state]; 735 } 736 737 YY_DO_BEFORE_ACTION; 738 739do_action: /* This label is used only to access EOF actions. */ 740 741 switch ( yy_act ) 742 { /* beginning of action switch */ 743 case 0: /* must back up */ 744 /* undo the effects of YY_DO_BEFORE_ACTION */ 745 *yy_cp = (yy_hold_char); 746 yy_cp = (yy_last_accepting_cpos); 747 yy_current_state = (yy_last_accepting_state); 748 goto yy_find_action; 749 750case 1: 751YY_RULE_SETUP 752#line 10 "../../fsinfo/null_lex.l" 753ECHO; 754 YY_BREAK 755#line 756 "lex.null_.c" 756case YY_STATE_EOF(INITIAL): 757 yyterminate(); 758 759 case YY_END_OF_BUFFER: 760 { 761 /* Amount of text matched not including the EOB char. */ 762 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 763 764 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 765 *yy_cp = (yy_hold_char); 766 YY_RESTORE_YY_MORE_OFFSET 767 768 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 769 { 770 /* We're scanning a new file or input source. It's 771 * possible that this happened because the user 772 * just pointed null_in at a new source and called 773 * null_lex(). If so, then we have to assure 774 * consistency between YY_CURRENT_BUFFER and our 775 * globals. Here is the right place to do so, because 776 * this is the first action (other than possibly a 777 * back-up) that will match for the new input source. 778 */ 779 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 780 YY_CURRENT_BUFFER_LVALUE->yy_input_file = null_in; 781 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 782 } 783 784 /* Note that here we test for yy_c_buf_p "<=" to the position 785 * of the first EOB in the buffer, since yy_c_buf_p will 786 * already have been incremented past the NUL character 787 * (since all states make transitions on EOB to the 788 * end-of-buffer state). Contrast this with the test 789 * in input(). 790 */ 791 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 792 { /* This was really a NUL. */ 793 yy_state_type yy_next_state; 794 795 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 796 797 yy_current_state = yy_get_previous_state( ); 798 799 /* Okay, we're now positioned to make the NUL 800 * transition. We couldn't have 801 * yy_get_previous_state() go ahead and do it 802 * for us because it doesn't know how to deal 803 * with the possibility of jamming (and we don't 804 * want to build jamming into it because then it 805 * will run more slowly). 806 */ 807 808 yy_next_state = yy_try_NUL_trans( yy_current_state ); 809 810 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 811 812 if ( yy_next_state ) 813 { 814 /* Consume the NUL. */ 815 yy_cp = ++(yy_c_buf_p); 816 yy_current_state = yy_next_state; 817 goto yy_match; 818 } 819 820 else 821 { 822 yy_cp = (yy_c_buf_p); 823 goto yy_find_action; 824 } 825 } 826 827 else switch ( yy_get_next_buffer( ) ) 828 { 829 case EOB_ACT_END_OF_FILE: 830 { 831 (yy_did_buffer_switch_on_eof) = 0; 832 833 if ( null_wrap( ) ) 834 { 835 /* Note: because we've taken care in 836 * yy_get_next_buffer() to have set up 837 * null_text, we can now set up 838 * yy_c_buf_p so that if some total 839 * hoser (like flex itself) wants to 840 * call the scanner after we return the 841 * YY_NULL, it'll still work - another 842 * YY_NULL will get returned. 843 */ 844 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 845 846 yy_act = YY_STATE_EOF(YY_START); 847 goto do_action; 848 } 849 850 else 851 { 852 if ( ! (yy_did_buffer_switch_on_eof) ) 853 YY_NEW_FILE; 854 } 855 break; 856 } 857 858 case EOB_ACT_CONTINUE_SCAN: 859 (yy_c_buf_p) = 860 (yytext_ptr) + yy_amount_of_matched_text; 861 862 yy_current_state = yy_get_previous_state( ); 863 864 yy_cp = (yy_c_buf_p); 865 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 866 goto yy_match; 867 868 case EOB_ACT_LAST_MATCH: 869 (yy_c_buf_p) = 870 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 871 872 yy_current_state = yy_get_previous_state( ); 873 874 yy_cp = (yy_c_buf_p); 875 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 876 goto yy_find_action; 877 } 878 break; 879 } 880 881 default: 882 YY_FATAL_ERROR( 883 "fatal flex scanner internal error--no action found" ); 884 } /* end of action switch */ 885 } /* end of scanning one token */ 886} /* end of null_lex */ 887 888/* yy_get_next_buffer - try to read in a new buffer 889 * 890 * Returns a code representing an action: 891 * EOB_ACT_LAST_MATCH - 892 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 893 * EOB_ACT_END_OF_FILE - end of file 894 */ 895static int yy_get_next_buffer (void) 896{ 897 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 898 register char *source = (yytext_ptr); 899 register int number_to_move, i; 900 int ret_val; 901 902 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 903 YY_FATAL_ERROR( 904 "fatal flex scanner internal error--end of buffer missed" ); 905 906 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 907 { /* Don't try to fill the buffer, so this is an EOF. */ 908 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 909 { 910 /* We matched a single character, the EOB, so 911 * treat this as a final EOF. 912 */ 913 return EOB_ACT_END_OF_FILE; 914 } 915 916 else 917 { 918 /* We matched some text prior to the EOB, first 919 * process it. 920 */ 921 return EOB_ACT_LAST_MATCH; 922 } 923 } 924 925 /* Try to read more data. */ 926 927 /* First move last chars to start of buffer. */ 928 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 929 930 for ( i = 0; i < number_to_move; ++i ) 931 *(dest++) = *(source++); 932 933 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 934 /* don't do the read, it's not guaranteed to return an EOF, 935 * just force an EOF 936 */ 937 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 938 939 else 940 { 941 int num_to_read = 942 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 943 944 while ( num_to_read <= 0 ) 945 { /* Not enough room in the buffer - grow it. */ 946 947 /* just a shorter name for the current buffer */ 948 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 949 950 int yy_c_buf_p_offset = 951 (int) ((yy_c_buf_p) - b->yy_ch_buf); 952 953 if ( b->yy_is_our_buffer ) 954 { 955 int new_size = b->yy_buf_size * 2; 956 957 if ( new_size <= 0 ) 958 b->yy_buf_size += b->yy_buf_size / 8; 959 else 960 b->yy_buf_size *= 2; 961 962 b->yy_ch_buf = (char *) 963 /* Include room in for 2 EOB chars. */ 964 null_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 965 } 966 else 967 /* Can't grow it, we don't own it. */ 968 b->yy_ch_buf = 0; 969 970 if ( ! b->yy_ch_buf ) 971 YY_FATAL_ERROR( 972 "fatal error - scanner input buffer overflow" ); 973 974 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 975 976 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 977 number_to_move - 1; 978 979 } 980 981 if ( num_to_read > YY_READ_BUF_SIZE ) 982 num_to_read = YY_READ_BUF_SIZE; 983 984 /* Read in more data. */ 985 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 986 (yy_n_chars), (size_t) num_to_read ); 987 988 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 989 } 990 991 if ( (yy_n_chars) == 0 ) 992 { 993 if ( number_to_move == YY_MORE_ADJ ) 994 { 995 ret_val = EOB_ACT_END_OF_FILE; 996 null_restart(null_in ); 997 } 998 999 else 1000 { 1001 ret_val = EOB_ACT_LAST_MATCH; 1002 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1003 YY_BUFFER_EOF_PENDING; 1004 } 1005 } 1006 1007 else 1008 ret_val = EOB_ACT_CONTINUE_SCAN; 1009 1010 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1011 /* Extend the array by 50%, plus the number we really need. */ 1012 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 1013 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) null_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); 1014 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1015 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1016 } 1017 1018 (yy_n_chars) += number_to_move; 1019 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 1020 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 1021 1022 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1023 1024 return ret_val; 1025} 1026 1027/* yy_get_previous_state - get the state just before the EOB char was reached */ 1028 1029 static yy_state_type yy_get_previous_state (void) 1030{ 1031 register yy_state_type yy_current_state; 1032 register char *yy_cp; 1033 1034 yy_current_state = (yy_start); 1035 1036 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 1037 { 1038 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1039 if ( yy_accept[yy_current_state] ) 1040 { 1041 (yy_last_accepting_state) = yy_current_state; 1042 (yy_last_accepting_cpos) = yy_cp; 1043 } 1044 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1045 { 1046 yy_current_state = (int) yy_def[yy_current_state]; 1047 if ( yy_current_state >= 6 ) 1048 yy_c = yy_meta[(unsigned int) yy_c]; 1049 } 1050 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1051 } 1052 1053 return yy_current_state; 1054} 1055 1056/* yy_try_NUL_trans - try to make a transition on the NUL character 1057 * 1058 * synopsis 1059 * next_state = yy_try_NUL_trans( current_state ); 1060 */ 1061 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 1062{ 1063 register int yy_is_jam; 1064 register char *yy_cp = (yy_c_buf_p); 1065 1066 register YY_CHAR yy_c = 1; 1067 if ( yy_accept[yy_current_state] ) 1068 { 1069 (yy_last_accepting_state) = yy_current_state; 1070 (yy_last_accepting_cpos) = yy_cp; 1071 } 1072 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1073 { 1074 yy_current_state = (int) yy_def[yy_current_state]; 1075 if ( yy_current_state >= 6 ) 1076 yy_c = yy_meta[(unsigned int) yy_c]; 1077 } 1078 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1079 yy_is_jam = (yy_current_state == 5); 1080 1081 return yy_is_jam ? 0 : yy_current_state; 1082} 1083 1084#ifndef YY_NO_INPUT 1085#ifdef __cplusplus 1086 static int yyinput (void) 1087#else 1088 static int input (void) 1089#endif 1090 1091{ 1092 int c; 1093 1094 *(yy_c_buf_p) = (yy_hold_char); 1095 1096 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1097 { 1098 /* yy_c_buf_p now points to the character we want to return. 1099 * If this occurs *before* the EOB characters, then it's a 1100 * valid NUL; if not, then we've hit the end of the buffer. 1101 */ 1102 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1103 /* This was really a NUL. */ 1104 *(yy_c_buf_p) = '\0'; 1105 1106 else 1107 { /* need more input */ 1108 int offset = (yy_c_buf_p) - (yytext_ptr); 1109 ++(yy_c_buf_p); 1110 1111 switch ( yy_get_next_buffer( ) ) 1112 { 1113 case EOB_ACT_LAST_MATCH: 1114 /* This happens because yy_g_n_b() 1115 * sees that we've accumulated a 1116 * token and flags that we need to 1117 * try matching the token before 1118 * proceeding. But for input(), 1119 * there's no matching to consider. 1120 * So convert the EOB_ACT_LAST_MATCH 1121 * to EOB_ACT_END_OF_FILE. 1122 */ 1123 1124 /* Reset buffer status. */ 1125 null_restart(null_in ); 1126 1127 /*FALLTHROUGH*/ 1128 1129 case EOB_ACT_END_OF_FILE: 1130 { 1131 if ( null_wrap( ) ) 1132 return EOF; 1133 1134 if ( ! (yy_did_buffer_switch_on_eof) ) 1135 YY_NEW_FILE; 1136#ifdef __cplusplus 1137 return yyinput(); 1138#else 1139 return input(); 1140#endif 1141 } 1142 1143 case EOB_ACT_CONTINUE_SCAN: 1144 (yy_c_buf_p) = (yytext_ptr) + offset; 1145 break; 1146 } 1147 } 1148 } 1149 1150 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 1151 *(yy_c_buf_p) = '\0'; /* preserve null_text */ 1152 (yy_hold_char) = *++(yy_c_buf_p); 1153 1154 return c; 1155} 1156#endif /* ifndef YY_NO_INPUT */ 1157 1158/** Immediately switch to a different input stream. 1159 * @param input_file A readable stream. 1160 * 1161 * @note This function does not reset the start condition to @c INITIAL . 1162 */ 1163 void null_restart (FILE * input_file ) 1164{ 1165 1166 if ( ! YY_CURRENT_BUFFER ){ 1167 null_ensure_buffer_stack (); 1168 YY_CURRENT_BUFFER_LVALUE = 1169 null__create_buffer(null_in,YY_BUF_SIZE ); 1170 } 1171 1172 null__init_buffer(YY_CURRENT_BUFFER,input_file ); 1173 null__load_buffer_state( ); 1174} 1175 1176/** Switch to a different input buffer. 1177 * @param new_buffer The new input buffer. 1178 * 1179 */ 1180 void null__switch_to_buffer (YY_BUFFER_STATE new_buffer ) 1181{ 1182 1183 /* TODO. We should be able to replace this entire function body 1184 * with 1185 * null_pop_buffer_state(); 1186 * null_push_buffer_state(new_buffer); 1187 */ 1188 null_ensure_buffer_stack (); 1189 if ( YY_CURRENT_BUFFER == new_buffer ) 1190 return; 1191 1192 if ( YY_CURRENT_BUFFER ) 1193 { 1194 /* Flush out information for old buffer. */ 1195 *(yy_c_buf_p) = (yy_hold_char); 1196 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1197 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1198 } 1199 1200 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1201 null__load_buffer_state( ); 1202 1203 /* We don't actually know whether we did this switch during 1204 * EOF (null_wrap()) processing, but the only time this flag 1205 * is looked at is after null_wrap() is called, so it's safe 1206 * to go ahead and always set it. 1207 */ 1208 (yy_did_buffer_switch_on_eof) = 1; 1209} 1210 1211static void null__load_buffer_state (void) 1212{ 1213 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1214 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 1215 null_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 1216 (yy_hold_char) = *(yy_c_buf_p); 1217} 1218 1219/** Allocate and initialize an input buffer state. 1220 * @param file A readable stream. 1221 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 1222 * 1223 * @return the allocated buffer state. 1224 */ 1225 YY_BUFFER_STATE null__create_buffer (FILE * file, int size ) 1226{ 1227 YY_BUFFER_STATE b; 1228 1229 b = (YY_BUFFER_STATE) null_alloc(sizeof( struct yy_buffer_state ) ); 1230 if ( ! b ) 1231 YY_FATAL_ERROR( "out of dynamic memory in null__create_buffer()" ); 1232 1233 b->yy_buf_size = size; 1234 1235 /* yy_ch_buf has to be 2 characters longer than the size given because 1236 * we need to put in 2 end-of-buffer characters. 1237 */ 1238 b->yy_ch_buf = (char *) null_alloc(b->yy_buf_size + 2 ); 1239 if ( ! b->yy_ch_buf ) 1240 YY_FATAL_ERROR( "out of dynamic memory in null__create_buffer()" ); 1241 1242 b->yy_is_our_buffer = 1; 1243 1244 null__init_buffer(b,file ); 1245 1246 return b; 1247} 1248 1249/** Destroy the buffer. 1250 * @param b a buffer created with null__create_buffer() 1251 * 1252 */ 1253 void null__delete_buffer (YY_BUFFER_STATE b ) 1254{ 1255 1256 if ( ! b ) 1257 return; 1258 1259 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 1260 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 1261 1262 if ( b->yy_is_our_buffer ) 1263 null_free((void *) b->yy_ch_buf ); 1264 1265 null_free((void *) b ); 1266} 1267 1268#ifndef __cplusplus 1269extern int isatty (int ); 1270#endif /* __cplusplus */ 1271 1272/* Initializes or reinitializes a buffer. 1273 * This function is sometimes called more than once on the same buffer, 1274 * such as during a null_restart() or at EOF. 1275 */ 1276 static void null__init_buffer (YY_BUFFER_STATE b, FILE * file ) 1277 1278{ 1279 int oerrno = errno; 1280 1281 null__flush_buffer(b ); 1282 1283 b->yy_input_file = file; 1284 b->yy_fill_buffer = 1; 1285 1286 /* If b is the current buffer, then null__init_buffer was _probably_ 1287 * called from null_restart() or through yy_get_next_buffer. 1288 * In that case, we don't want to reset the lineno or column. 1289 */ 1290 if (b != YY_CURRENT_BUFFER){ 1291 b->yy_bs_lineno = 1; 1292 b->yy_bs_column = 0; 1293 } 1294 1295 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1296 1297 errno = oerrno; 1298} 1299 1300/** Discard all buffered characters. On the next scan, YY_INPUT will be called. 1301 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 1302 * 1303 */ 1304 void null__flush_buffer (YY_BUFFER_STATE b ) 1305{ 1306 if ( ! b ) 1307 return; 1308 1309 b->yy_n_chars = 0; 1310 1311 /* We always need two end-of-buffer characters. The first causes 1312 * a transition to the end-of-buffer state. The second causes 1313 * a jam in that state. 1314 */ 1315 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1316 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1317 1318 b->yy_buf_pos = &b->yy_ch_buf[0]; 1319 1320 b->yy_at_bol = 1; 1321 b->yy_buffer_status = YY_BUFFER_NEW; 1322 1323 if ( b == YY_CURRENT_BUFFER ) 1324 null__load_buffer_state( ); 1325} 1326 1327/** Pushes the new state onto the stack. The new state becomes 1328 * the current state. This function will allocate the stack 1329 * if necessary. 1330 * @param new_buffer The new state. 1331 * 1332 */ 1333void null_push_buffer_state (YY_BUFFER_STATE new_buffer ) 1334{ 1335 if (new_buffer == NULL) 1336 return; 1337 1338 null_ensure_buffer_stack(); 1339 1340 /* This block is copied from null__switch_to_buffer. */ 1341 if ( YY_CURRENT_BUFFER ) 1342 { 1343 /* Flush out information for old buffer. */ 1344 *(yy_c_buf_p) = (yy_hold_char); 1345 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1346 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1347 } 1348 1349 /* Only push if top exists. Otherwise, replace top. */ 1350 if (YY_CURRENT_BUFFER) 1351 (yy_buffer_stack_top)++; 1352 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1353 1354 /* copied from null__switch_to_buffer. */ 1355 null__load_buffer_state( ); 1356 (yy_did_buffer_switch_on_eof) = 1; 1357} 1358 1359/** Removes and deletes the top of the stack, if present. 1360 * The next element becomes the new top. 1361 * 1362 */ 1363void null_pop_buffer_state (void) 1364{ 1365 if (!YY_CURRENT_BUFFER) 1366 return; 1367 1368 null__delete_buffer(YY_CURRENT_BUFFER ); 1369 YY_CURRENT_BUFFER_LVALUE = NULL; 1370 if ((yy_buffer_stack_top) > 0) 1371 --(yy_buffer_stack_top); 1372 1373 if (YY_CURRENT_BUFFER) { 1374 null__load_buffer_state( ); 1375 (yy_did_buffer_switch_on_eof) = 1; 1376 } 1377} 1378 1379/* Allocates the stack if it does not exist. 1380 * Guarantees space for at least one push. 1381 */ 1382static void null_ensure_buffer_stack (void) 1383{ 1384 int num_to_alloc; 1385 1386 if (!(yy_buffer_stack)) { 1387 1388 /* First allocation is just for 2 elements, since we don't know if this 1389 * scanner will even need a stack. We use 2 instead of 1 to avoid an 1390 * immediate realloc on the next call. 1391 */ 1392 num_to_alloc = 1; 1393 (yy_buffer_stack) = (struct yy_buffer_state**)null_alloc 1394 (num_to_alloc * sizeof(struct yy_buffer_state*) 1395 ); 1396 if ( ! (yy_buffer_stack) ) 1397 YY_FATAL_ERROR( "out of dynamic memory in null_ensure_buffer_stack()" ); 1398 1399 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1400 1401 (yy_buffer_stack_max) = num_to_alloc; 1402 (yy_buffer_stack_top) = 0; 1403 return; 1404 } 1405 1406 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 1407 1408 /* Increase the buffer to prepare for a possible push. */ 1409 int grow_size = 8 /* arbitrary grow size */; 1410 1411 num_to_alloc = (yy_buffer_stack_max) + grow_size; 1412 (yy_buffer_stack) = (struct yy_buffer_state**)null_realloc 1413 ((yy_buffer_stack), 1414 num_to_alloc * sizeof(struct yy_buffer_state*) 1415 ); 1416 if ( ! (yy_buffer_stack) ) 1417 YY_FATAL_ERROR( "out of dynamic memory in null_ensure_buffer_stack()" ); 1418 1419 /* zero only the new slots.*/ 1420 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 1421 (yy_buffer_stack_max) = num_to_alloc; 1422 } 1423} 1424 1425/** Setup the input buffer state to scan directly from a user-specified character buffer. 1426 * @param base the character buffer 1427 * @param size the size in bytes of the character buffer 1428 * 1429 * @return the newly allocated buffer state object. 1430 */ 1431YY_BUFFER_STATE null__scan_buffer (char * base, yy_size_t size ) 1432{ 1433 YY_BUFFER_STATE b; 1434 1435 if ( size < 2 || 1436 base[size-2] != YY_END_OF_BUFFER_CHAR || 1437 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1438 /* They forgot to leave room for the EOB's. */ 1439 return 0; 1440 1441 b = (YY_BUFFER_STATE) null_alloc(sizeof( struct yy_buffer_state ) ); 1442 if ( ! b ) 1443 YY_FATAL_ERROR( "out of dynamic memory in null__scan_buffer()" ); 1444 1445 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1446 b->yy_buf_pos = b->yy_ch_buf = base; 1447 b->yy_is_our_buffer = 0; 1448 b->yy_input_file = 0; 1449 b->yy_n_chars = b->yy_buf_size; 1450 b->yy_is_interactive = 0; 1451 b->yy_at_bol = 1; 1452 b->yy_fill_buffer = 0; 1453 b->yy_buffer_status = YY_BUFFER_NEW; 1454 1455 null__switch_to_buffer(b ); 1456 1457 return b; 1458} 1459 1460/** Setup the input buffer state to scan a string. The next call to null_lex() will 1461 * scan from a @e copy of @a str. 1462 * @param yystr a NUL-terminated string to scan 1463 * 1464 * @return the newly allocated buffer state object. 1465 * @note If you want to scan bytes that may contain NUL values, then use 1466 * null__scan_bytes() instead. 1467 */ 1468YY_BUFFER_STATE null__scan_string (yyconst char * yystr ) 1469{ 1470 1471 return null__scan_bytes(yystr,strlen(yystr) ); 1472} 1473 1474/** Setup the input buffer state to scan the given bytes. The next call to null_lex() will 1475 * scan from a @e copy of @a bytes. 1476 * @param yybytes the byte buffer to scan 1477 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. 1478 * 1479 * @return the newly allocated buffer state object. 1480 */ 1481YY_BUFFER_STATE null__scan_bytes (yyconst char * yybytes, int _yybytes_len ) 1482{ 1483 YY_BUFFER_STATE b; 1484 char *buf; 1485 yy_size_t n; 1486 int i; 1487 1488 /* Get memory for full buffer, including space for trailing EOB's. */ 1489 n = _yybytes_len + 2; 1490 buf = (char *) null_alloc(n ); 1491 if ( ! buf ) 1492 YY_FATAL_ERROR( "out of dynamic memory in null__scan_bytes()" ); 1493 1494 for ( i = 0; i < _yybytes_len; ++i ) 1495 buf[i] = yybytes[i]; 1496 1497 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 1498 1499 b = null__scan_buffer(buf,n ); 1500 if ( ! b ) 1501 YY_FATAL_ERROR( "bad buffer in null__scan_bytes()" ); 1502 1503 /* It's okay to grow etc. this buffer, and we should throw it 1504 * away when we're done. 1505 */ 1506 b->yy_is_our_buffer = 1; 1507 1508 return b; 1509} 1510 1511#ifndef YY_EXIT_FAILURE 1512#define YY_EXIT_FAILURE 2 1513#endif 1514 1515static void yy_fatal_error (yyconst char* msg ) 1516{ 1517 (void) fprintf( stderr, "%s\n", msg ); 1518 exit( YY_EXIT_FAILURE ); 1519} 1520 1521/* Redefine yyless() so it works in section 3 code. */ 1522 1523#undef yyless 1524#define yyless(n) \ 1525 do \ 1526 { \ 1527 /* Undo effects of setting up null_text. */ \ 1528 int yyless_macro_arg = (n); \ 1529 YY_LESS_LINENO(yyless_macro_arg);\ 1530 null_text[null_leng] = (yy_hold_char); \ 1531 (yy_c_buf_p) = null_text + yyless_macro_arg; \ 1532 (yy_hold_char) = *(yy_c_buf_p); \ 1533 *(yy_c_buf_p) = '\0'; \ 1534 null_leng = yyless_macro_arg; \ 1535 } \ 1536 while ( 0 ) 1537 1538/* Accessor methods (get/set functions) to struct members. */ 1539 1540/** Get the current line number. 1541 * 1542 */ 1543int null_get_lineno (void) 1544{ 1545 1546 return null_lineno; 1547} 1548 1549/** Get the input stream. 1550 * 1551 */ 1552FILE *null_get_in (void) 1553{ 1554 return null_in; 1555} 1556 1557/** Get the output stream. 1558 * 1559 */ 1560FILE *null_get_out (void) 1561{ 1562 return null_out; 1563} 1564 1565/** Get the length of the current token. 1566 * 1567 */ 1568int null_get_leng (void) 1569{ 1570 return null_leng; 1571} 1572 1573/** Get the current token. 1574 * 1575 */ 1576 1577char *null_get_text (void) 1578{ 1579 return null_text; 1580} 1581 1582/** Set the current line number. 1583 * @param line_number 1584 * 1585 */ 1586void null_set_lineno (int line_number ) 1587{ 1588 1589 null_lineno = line_number; 1590} 1591 1592/** Set the input stream. This does not discard the current 1593 * input buffer. 1594 * @param in_str A readable stream. 1595 * 1596 * @see null__switch_to_buffer 1597 */ 1598void null_set_in (FILE * in_str ) 1599{ 1600 null_in = in_str ; 1601} 1602 1603void null_set_out (FILE * out_str ) 1604{ 1605 null_out = out_str ; 1606} 1607 1608int null_get_debug (void) 1609{ 1610 return null__flex_debug; 1611} 1612 1613void null_set_debug (int bdebug ) 1614{ 1615 null__flex_debug = bdebug ; 1616} 1617 1618static int yy_init_globals (void) 1619{ 1620 /* Initialization is the same as for the non-reentrant scanner. 1621 * This function is called from null_lex_destroy(), so don't allocate here. 1622 */ 1623 1624 (yy_buffer_stack) = 0; 1625 (yy_buffer_stack_top) = 0; 1626 (yy_buffer_stack_max) = 0; 1627 (yy_c_buf_p) = (char *) 0; 1628 (yy_init) = 0; 1629 (yy_start) = 0; 1630 1631/* Defined in main.c */ 1632#ifdef YY_STDINIT 1633 null_in = stdin; 1634 null_out = stdout; 1635#else 1636 null_in = (FILE *) 0; 1637 null_out = (FILE *) 0; 1638#endif 1639 1640 /* For future reference: Set errno on error, since we are called by 1641 * null_lex_init() 1642 */ 1643 return 0; 1644} 1645 1646/* null_lex_destroy is for both reentrant and non-reentrant scanners. */ 1647int null_lex_destroy (void) 1648{ 1649 1650 /* Pop the buffer stack, destroying each element. */ 1651 while(YY_CURRENT_BUFFER){ 1652 null__delete_buffer(YY_CURRENT_BUFFER ); 1653 YY_CURRENT_BUFFER_LVALUE = NULL; 1654 null_pop_buffer_state(); 1655 } 1656 1657 /* Destroy the stack itself. */ 1658 null_free((yy_buffer_stack) ); 1659 (yy_buffer_stack) = NULL; 1660 1661 /* Reset the globals. This is important in a non-reentrant scanner so the next time 1662 * null_lex() is called, initialization will occur. */ 1663 yy_init_globals( ); 1664 1665 return 0; 1666} 1667 1668/* 1669 * Internal utility routines. 1670 */ 1671 1672#ifndef yytext_ptr 1673static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 1674{ 1675 register int i; 1676 for ( i = 0; i < n; ++i ) 1677 s1[i] = s2[i]; 1678} 1679#endif 1680 1681#ifdef YY_NEED_STRLEN 1682static int yy_flex_strlen (yyconst char * s ) 1683{ 1684 register int n; 1685 for ( n = 0; s[n]; ++n ) 1686 ; 1687 1688 return n; 1689} 1690#endif 1691 1692void *null_alloc (yy_size_t size ) 1693{ 1694 return (void *) malloc( size ); 1695} 1696 1697void *null_realloc (void * ptr, yy_size_t size ) 1698{ 1699 /* The cast to (char *) in the following accommodates both 1700 * implementations that use char* generic pointers, and those 1701 * that use void* generic pointers. It works with the latter 1702 * because both ANSI C and C++ allow castless assignment from 1703 * any pointer type to void*, and deal with argument conversions 1704 * as though doing an assignment. 1705 */ 1706 return (void *) realloc( (char *) ptr, size ); 1707} 1708 1709void null_free (void * ptr ) 1710{ 1711 free( (char *) ptr ); /* see null_realloc() for (char *) cast */ 1712} 1713 1714#define YYTABLES_NAME "yytables" 1715 1716#line 10 "../../fsinfo/null_lex.l" 1717