Annotation of embedaddon/strongswan/src/libstrongswan/settings/settings_lexer.c, revision 1.1
1.1 ! misho 1: #line 2 "settings/settings_lexer.c"
! 2:
! 3: #line 4 "settings/settings_lexer.c"
! 4:
! 5: #define YY_INT_ALIGNED short int
! 6:
! 7: /* A lexical scanner generated by flex */
! 8:
! 9: /* %not-for-header */
! 10: /* %if-c-only */
! 11: /* %if-not-reentrant */
! 12: /* %endif */
! 13: /* %endif */
! 14: /* %ok-for-header */
! 15:
! 16: #define FLEX_SCANNER
! 17: #define YY_FLEX_MAJOR_VERSION 2
! 18: #define YY_FLEX_MINOR_VERSION 6
! 19: #define YY_FLEX_SUBMINOR_VERSION 4
! 20: #if YY_FLEX_SUBMINOR_VERSION > 0
! 21: #define FLEX_BETA
! 22: #endif
! 23:
! 24: /* %if-c++-only */
! 25: /* %endif */
! 26:
! 27: /* %if-c-only */
! 28: #ifdef yy_create_buffer
! 29: #define settings_parser__create_buffer_ALREADY_DEFINED
! 30: #else
! 31: #define yy_create_buffer settings_parser__create_buffer
! 32: #endif
! 33:
! 34: #ifdef yy_delete_buffer
! 35: #define settings_parser__delete_buffer_ALREADY_DEFINED
! 36: #else
! 37: #define yy_delete_buffer settings_parser__delete_buffer
! 38: #endif
! 39:
! 40: #ifdef yy_scan_buffer
! 41: #define settings_parser__scan_buffer_ALREADY_DEFINED
! 42: #else
! 43: #define yy_scan_buffer settings_parser__scan_buffer
! 44: #endif
! 45:
! 46: #ifdef yy_scan_string
! 47: #define settings_parser__scan_string_ALREADY_DEFINED
! 48: #else
! 49: #define yy_scan_string settings_parser__scan_string
! 50: #endif
! 51:
! 52: #ifdef yy_scan_bytes
! 53: #define settings_parser__scan_bytes_ALREADY_DEFINED
! 54: #else
! 55: #define yy_scan_bytes settings_parser__scan_bytes
! 56: #endif
! 57:
! 58: #ifdef yy_init_buffer
! 59: #define settings_parser__init_buffer_ALREADY_DEFINED
! 60: #else
! 61: #define yy_init_buffer settings_parser__init_buffer
! 62: #endif
! 63:
! 64: #ifdef yy_flush_buffer
! 65: #define settings_parser__flush_buffer_ALREADY_DEFINED
! 66: #else
! 67: #define yy_flush_buffer settings_parser__flush_buffer
! 68: #endif
! 69:
! 70: #ifdef yy_load_buffer_state
! 71: #define settings_parser__load_buffer_state_ALREADY_DEFINED
! 72: #else
! 73: #define yy_load_buffer_state settings_parser__load_buffer_state
! 74: #endif
! 75:
! 76: #ifdef yy_switch_to_buffer
! 77: #define settings_parser__switch_to_buffer_ALREADY_DEFINED
! 78: #else
! 79: #define yy_switch_to_buffer settings_parser__switch_to_buffer
! 80: #endif
! 81:
! 82: #ifdef yypush_buffer_state
! 83: #define settings_parser_push_buffer_state_ALREADY_DEFINED
! 84: #else
! 85: #define yypush_buffer_state settings_parser_push_buffer_state
! 86: #endif
! 87:
! 88: #ifdef yypop_buffer_state
! 89: #define settings_parser_pop_buffer_state_ALREADY_DEFINED
! 90: #else
! 91: #define yypop_buffer_state settings_parser_pop_buffer_state
! 92: #endif
! 93:
! 94: #ifdef yyensure_buffer_stack
! 95: #define settings_parser_ensure_buffer_stack_ALREADY_DEFINED
! 96: #else
! 97: #define yyensure_buffer_stack settings_parser_ensure_buffer_stack
! 98: #endif
! 99:
! 100: #ifdef yylex
! 101: #define settings_parser_lex_ALREADY_DEFINED
! 102: #else
! 103: #define yylex settings_parser_lex
! 104: #endif
! 105:
! 106: #ifdef yyrestart
! 107: #define settings_parser_restart_ALREADY_DEFINED
! 108: #else
! 109: #define yyrestart settings_parser_restart
! 110: #endif
! 111:
! 112: #ifdef yylex_init
! 113: #define settings_parser_lex_init_ALREADY_DEFINED
! 114: #else
! 115: #define yylex_init settings_parser_lex_init
! 116: #endif
! 117:
! 118: #ifdef yylex_init_extra
! 119: #define settings_parser_lex_init_extra_ALREADY_DEFINED
! 120: #else
! 121: #define yylex_init_extra settings_parser_lex_init_extra
! 122: #endif
! 123:
! 124: #ifdef yylex_destroy
! 125: #define settings_parser_lex_destroy_ALREADY_DEFINED
! 126: #else
! 127: #define yylex_destroy settings_parser_lex_destroy
! 128: #endif
! 129:
! 130: #ifdef yyget_debug
! 131: #define settings_parser_get_debug_ALREADY_DEFINED
! 132: #else
! 133: #define yyget_debug settings_parser_get_debug
! 134: #endif
! 135:
! 136: #ifdef yyset_debug
! 137: #define settings_parser_set_debug_ALREADY_DEFINED
! 138: #else
! 139: #define yyset_debug settings_parser_set_debug
! 140: #endif
! 141:
! 142: #ifdef yyget_extra
! 143: #define settings_parser_get_extra_ALREADY_DEFINED
! 144: #else
! 145: #define yyget_extra settings_parser_get_extra
! 146: #endif
! 147:
! 148: #ifdef yyset_extra
! 149: #define settings_parser_set_extra_ALREADY_DEFINED
! 150: #else
! 151: #define yyset_extra settings_parser_set_extra
! 152: #endif
! 153:
! 154: #ifdef yyget_in
! 155: #define settings_parser_get_in_ALREADY_DEFINED
! 156: #else
! 157: #define yyget_in settings_parser_get_in
! 158: #endif
! 159:
! 160: #ifdef yyset_in
! 161: #define settings_parser_set_in_ALREADY_DEFINED
! 162: #else
! 163: #define yyset_in settings_parser_set_in
! 164: #endif
! 165:
! 166: #ifdef yyget_out
! 167: #define settings_parser_get_out_ALREADY_DEFINED
! 168: #else
! 169: #define yyget_out settings_parser_get_out
! 170: #endif
! 171:
! 172: #ifdef yyset_out
! 173: #define settings_parser_set_out_ALREADY_DEFINED
! 174: #else
! 175: #define yyset_out settings_parser_set_out
! 176: #endif
! 177:
! 178: #ifdef yyget_leng
! 179: #define settings_parser_get_leng_ALREADY_DEFINED
! 180: #else
! 181: #define yyget_leng settings_parser_get_leng
! 182: #endif
! 183:
! 184: #ifdef yyget_text
! 185: #define settings_parser_get_text_ALREADY_DEFINED
! 186: #else
! 187: #define yyget_text settings_parser_get_text
! 188: #endif
! 189:
! 190: #ifdef yyget_lineno
! 191: #define settings_parser_get_lineno_ALREADY_DEFINED
! 192: #else
! 193: #define yyget_lineno settings_parser_get_lineno
! 194: #endif
! 195:
! 196: #ifdef yyset_lineno
! 197: #define settings_parser_set_lineno_ALREADY_DEFINED
! 198: #else
! 199: #define yyset_lineno settings_parser_set_lineno
! 200: #endif
! 201:
! 202: #ifdef yyget_column
! 203: #define settings_parser_get_column_ALREADY_DEFINED
! 204: #else
! 205: #define yyget_column settings_parser_get_column
! 206: #endif
! 207:
! 208: #ifdef yyset_column
! 209: #define settings_parser_set_column_ALREADY_DEFINED
! 210: #else
! 211: #define yyset_column settings_parser_set_column
! 212: #endif
! 213:
! 214: #ifdef yywrap
! 215: #define settings_parser_wrap_ALREADY_DEFINED
! 216: #else
! 217: #define yywrap settings_parser_wrap
! 218: #endif
! 219:
! 220: /* %endif */
! 221:
! 222: #ifdef yyget_lval
! 223: #define settings_parser_get_lval_ALREADY_DEFINED
! 224: #else
! 225: #define yyget_lval settings_parser_get_lval
! 226: #endif
! 227:
! 228: #ifdef yyset_lval
! 229: #define settings_parser_set_lval_ALREADY_DEFINED
! 230: #else
! 231: #define yyset_lval settings_parser_set_lval
! 232: #endif
! 233:
! 234: #ifdef yyalloc
! 235: #define settings_parser_alloc_ALREADY_DEFINED
! 236: #else
! 237: #define yyalloc settings_parser_alloc
! 238: #endif
! 239:
! 240: #ifdef yyrealloc
! 241: #define settings_parser_realloc_ALREADY_DEFINED
! 242: #else
! 243: #define yyrealloc settings_parser_realloc
! 244: #endif
! 245:
! 246: #ifdef yyfree
! 247: #define settings_parser_free_ALREADY_DEFINED
! 248: #else
! 249: #define yyfree settings_parser_free
! 250: #endif
! 251:
! 252: /* %if-c-only */
! 253:
! 254: /* %endif */
! 255:
! 256: /* First, we deal with platform-specific or compiler-specific issues. */
! 257:
! 258: /* begin standard C headers. */
! 259: /* %if-c-only */
! 260: #include <stdio.h>
! 261: #include <string.h>
! 262: #include <errno.h>
! 263: #include <stdlib.h>
! 264: /* %endif */
! 265:
! 266: /* %if-tables-serialization */
! 267: /* %endif */
! 268: /* end standard C headers. */
! 269:
! 270: /* %if-c-or-c++ */
! 271: /* flex integer type definitions */
! 272:
! 273: #ifndef FLEXINT_H
! 274: #define FLEXINT_H
! 275:
! 276: /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
! 277:
! 278: #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
! 279:
! 280: /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
! 281: * if you want the limit (max/min) macros for int types.
! 282: */
! 283: #ifndef __STDC_LIMIT_MACROS
! 284: #define __STDC_LIMIT_MACROS 1
! 285: #endif
! 286:
! 287: #include <inttypes.h>
! 288: typedef int8_t flex_int8_t;
! 289: typedef uint8_t flex_uint8_t;
! 290: typedef int16_t flex_int16_t;
! 291: typedef uint16_t flex_uint16_t;
! 292: typedef int32_t flex_int32_t;
! 293: typedef uint32_t flex_uint32_t;
! 294: #else
! 295: typedef signed char flex_int8_t;
! 296: typedef short int flex_int16_t;
! 297: typedef int flex_int32_t;
! 298: typedef unsigned char flex_uint8_t;
! 299: typedef unsigned short int flex_uint16_t;
! 300: typedef unsigned int flex_uint32_t;
! 301:
! 302: /* Limits of integral types. */
! 303: #ifndef INT8_MIN
! 304: #define INT8_MIN (-128)
! 305: #endif
! 306: #ifndef INT16_MIN
! 307: #define INT16_MIN (-32767-1)
! 308: #endif
! 309: #ifndef INT32_MIN
! 310: #define INT32_MIN (-2147483647-1)
! 311: #endif
! 312: #ifndef INT8_MAX
! 313: #define INT8_MAX (127)
! 314: #endif
! 315: #ifndef INT16_MAX
! 316: #define INT16_MAX (32767)
! 317: #endif
! 318: #ifndef INT32_MAX
! 319: #define INT32_MAX (2147483647)
! 320: #endif
! 321: #ifndef UINT8_MAX
! 322: #define UINT8_MAX (255U)
! 323: #endif
! 324: #ifndef UINT16_MAX
! 325: #define UINT16_MAX (65535U)
! 326: #endif
! 327: #ifndef UINT32_MAX
! 328: #define UINT32_MAX (4294967295U)
! 329: #endif
! 330:
! 331: #ifndef SIZE_MAX
! 332: #define SIZE_MAX (~(size_t)0)
! 333: #endif
! 334:
! 335: #endif /* ! C99 */
! 336:
! 337: #endif /* ! FLEXINT_H */
! 338:
! 339: /* %endif */
! 340:
! 341: /* begin standard C++ headers. */
! 342: /* %if-c++-only */
! 343: /* %endif */
! 344:
! 345: /* TODO: this is always defined, so inline it */
! 346: #define yyconst const
! 347:
! 348: #if defined(__GNUC__) && __GNUC__ >= 3
! 349: #define yynoreturn __attribute__((__noreturn__))
! 350: #else
! 351: #define yynoreturn
! 352: #endif
! 353:
! 354: /* %not-for-header */
! 355: /* Returned upon end-of-file. */
! 356: #define YY_NULL 0
! 357: /* %ok-for-header */
! 358:
! 359: /* %not-for-header */
! 360: /* Promotes a possibly negative, possibly signed char to an
! 361: * integer in range [0..255] for use as an array index.
! 362: */
! 363: #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
! 364: /* %ok-for-header */
! 365:
! 366: /* %if-reentrant */
! 367:
! 368: /* An opaque pointer. */
! 369: #ifndef YY_TYPEDEF_YY_SCANNER_T
! 370: #define YY_TYPEDEF_YY_SCANNER_T
! 371: typedef void* yyscan_t;
! 372: #endif
! 373:
! 374: /* For convenience, these vars (plus the bison vars far below)
! 375: are macros in the reentrant scanner. */
! 376: #define yyin yyg->yyin_r
! 377: #define yyout yyg->yyout_r
! 378: #define yyextra yyg->yyextra_r
! 379: #define yyleng yyg->yyleng_r
! 380: #define yytext yyg->yytext_r
! 381: #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
! 382: #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
! 383: #define yy_flex_debug yyg->yy_flex_debug_r
! 384:
! 385: /* %endif */
! 386:
! 387: /* %if-not-reentrant */
! 388: /* %endif */
! 389:
! 390: /* Enter a start condition. This macro really ought to take a parameter,
! 391: * but we do it the disgusting crufty way forced on us by the ()-less
! 392: * definition of BEGIN.
! 393: */
! 394: #define BEGIN yyg->yy_start = 1 + 2 *
! 395: /* Translate the current start state into a value that can be later handed
! 396: * to BEGIN to return to the state. The YYSTATE alias is for lex
! 397: * compatibility.
! 398: */
! 399: #define YY_START ((yyg->yy_start - 1) / 2)
! 400: #define YYSTATE YY_START
! 401: /* Action number for EOF rule of a given start state. */
! 402: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
! 403: /* Special action meaning "start processing a new file". */
! 404: #define YY_NEW_FILE yyrestart( yyin , yyscanner )
! 405: #define YY_END_OF_BUFFER_CHAR 0
! 406:
! 407: /* Size of default input buffer. */
! 408: #ifndef YY_BUF_SIZE
! 409: #ifdef __ia64__
! 410: /* On IA-64, the buffer size is 16k, not 8k.
! 411: * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
! 412: * Ditto for the __ia64__ case accordingly.
! 413: */
! 414: #define YY_BUF_SIZE 32768
! 415: #else
! 416: #define YY_BUF_SIZE 16384
! 417: #endif /* __ia64__ */
! 418: #endif
! 419:
! 420: /* The state buf must be large enough to hold one state per character in the main buffer.
! 421: */
! 422: #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
! 423:
! 424: #ifndef YY_TYPEDEF_YY_BUFFER_STATE
! 425: #define YY_TYPEDEF_YY_BUFFER_STATE
! 426: typedef struct yy_buffer_state *YY_BUFFER_STATE;
! 427: #endif
! 428:
! 429: #ifndef YY_TYPEDEF_YY_SIZE_T
! 430: #define YY_TYPEDEF_YY_SIZE_T
! 431: typedef size_t yy_size_t;
! 432: #endif
! 433:
! 434: /* %if-not-reentrant */
! 435: /* %endif */
! 436:
! 437: /* %if-c-only */
! 438: /* %if-not-reentrant */
! 439: /* %endif */
! 440: /* %endif */
! 441:
! 442: #define EOB_ACT_CONTINUE_SCAN 0
! 443: #define EOB_ACT_END_OF_FILE 1
! 444: #define EOB_ACT_LAST_MATCH 2
! 445:
! 446: /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
! 447: * access to the local variable yy_act. Since yyless() is a macro, it would break
! 448: * existing scanners that call yyless() from OUTSIDE yylex.
! 449: * One obvious solution it to make yy_act a global. I tried that, and saw
! 450: * a 5% performance hit in a non-yylineno scanner, because yy_act is
! 451: * normally declared as a register variable-- so it is not worth it.
! 452: */
! 453: #define YY_LESS_LINENO(n) \
! 454: do { \
! 455: int yyl;\
! 456: for ( yyl = n; yyl < yyleng; ++yyl )\
! 457: if ( yytext[yyl] == '\n' )\
! 458: --yylineno;\
! 459: }while(0)
! 460: #define YY_LINENO_REWIND_TO(dst) \
! 461: do {\
! 462: const char *p;\
! 463: for ( p = yy_cp-1; p >= (dst); --p)\
! 464: if ( *p == '\n' )\
! 465: --yylineno;\
! 466: }while(0)
! 467:
! 468: /* Return all but the first "n" matched characters back to the input stream. */
! 469: #define yyless(n) \
! 470: do \
! 471: { \
! 472: /* Undo effects of setting up yytext. */ \
! 473: int yyless_macro_arg = (n); \
! 474: YY_LESS_LINENO(yyless_macro_arg);\
! 475: *yy_cp = yyg->yy_hold_char; \
! 476: YY_RESTORE_YY_MORE_OFFSET \
! 477: yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
! 478: YY_DO_BEFORE_ACTION; /* set up yytext again */ \
! 479: } \
! 480: while ( 0 )
! 481: #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
! 482:
! 483: #ifndef YY_STRUCT_YY_BUFFER_STATE
! 484: #define YY_STRUCT_YY_BUFFER_STATE
! 485: struct yy_buffer_state
! 486: {
! 487: /* %if-c-only */
! 488: FILE *yy_input_file;
! 489: /* %endif */
! 490:
! 491: /* %if-c++-only */
! 492: /* %endif */
! 493:
! 494: char *yy_ch_buf; /* input buffer */
! 495: char *yy_buf_pos; /* current position in input buffer */
! 496:
! 497: /* Size of input buffer in bytes, not including room for EOB
! 498: * characters.
! 499: */
! 500: int yy_buf_size;
! 501:
! 502: /* Number of characters read into yy_ch_buf, not including EOB
! 503: * characters.
! 504: */
! 505: int yy_n_chars;
! 506:
! 507: /* Whether we "own" the buffer - i.e., we know we created it,
! 508: * and can realloc() it to grow it, and should free() it to
! 509: * delete it.
! 510: */
! 511: int yy_is_our_buffer;
! 512:
! 513: /* Whether this is an "interactive" input source; if so, and
! 514: * if we're using stdio for input, then we want to use getc()
! 515: * instead of fread(), to make sure we stop fetching input after
! 516: * each newline.
! 517: */
! 518: int yy_is_interactive;
! 519:
! 520: /* Whether we're considered to be at the beginning of a line.
! 521: * If so, '^' rules will be active on the next match, otherwise
! 522: * not.
! 523: */
! 524: int yy_at_bol;
! 525:
! 526: int yy_bs_lineno; /**< The line count. */
! 527: int yy_bs_column; /**< The column count. */
! 528:
! 529: /* Whether to try to fill the input buffer when we reach the
! 530: * end of it.
! 531: */
! 532: int yy_fill_buffer;
! 533:
! 534: int yy_buffer_status;
! 535:
! 536: #define YY_BUFFER_NEW 0
! 537: #define YY_BUFFER_NORMAL 1
! 538: /* When an EOF's been seen but there's still some text to process
! 539: * then we mark the buffer as YY_EOF_PENDING, to indicate that we
! 540: * shouldn't try reading from the input source any more. We might
! 541: * still have a bunch of tokens to match, though, because of
! 542: * possible backing-up.
! 543: *
! 544: * When we actually see the EOF, we change the status to "new"
! 545: * (via yyrestart()), so that the user can continue scanning by
! 546: * just pointing yyin at a new input file.
! 547: */
! 548: #define YY_BUFFER_EOF_PENDING 2
! 549:
! 550: };
! 551: #endif /* !YY_STRUCT_YY_BUFFER_STATE */
! 552:
! 553: /* %if-c-only Standard (non-C++) definition */
! 554: /* %not-for-header */
! 555: /* %if-not-reentrant */
! 556: /* %endif */
! 557: /* %ok-for-header */
! 558:
! 559: /* %endif */
! 560:
! 561: /* We provide macros for accessing buffer states in case in the
! 562: * future we want to put the buffer states in a more general
! 563: * "scanner state".
! 564: *
! 565: * Returns the top of the stack, or NULL.
! 566: */
! 567: #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
! 568: ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
! 569: : NULL)
! 570: /* Same as previous macro, but useful when we know that the buffer stack is not
! 571: * NULL or when we need an lvalue. For internal use only.
! 572: */
! 573: #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
! 574:
! 575: /* %if-c-only Standard (non-C++) definition */
! 576:
! 577: /* %if-not-reentrant */
! 578: /* %not-for-header */
! 579: /* %ok-for-header */
! 580:
! 581: /* %endif */
! 582:
! 583: void yyrestart ( FILE *input_file , yyscan_t yyscanner );
! 584: void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
! 585: YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
! 586: void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
! 587: void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
! 588: void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
! 589: void yypop_buffer_state ( yyscan_t yyscanner );
! 590:
! 591: static void yyensure_buffer_stack ( yyscan_t yyscanner );
! 592: static void yy_load_buffer_state ( yyscan_t yyscanner );
! 593: static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
! 594: #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
! 595:
! 596: YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
! 597: YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
! 598: YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
! 599:
! 600: /* %endif */
! 601:
! 602: void *yyalloc ( yy_size_t , yyscan_t yyscanner );
! 603: void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
! 604: void yyfree ( void * , yyscan_t yyscanner );
! 605:
! 606: #define yy_new_buffer yy_create_buffer
! 607: #define yy_set_interactive(is_interactive) \
! 608: { \
! 609: if ( ! YY_CURRENT_BUFFER ){ \
! 610: yyensure_buffer_stack (yyscanner); \
! 611: YY_CURRENT_BUFFER_LVALUE = \
! 612: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
! 613: } \
! 614: YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
! 615: }
! 616: #define yy_set_bol(at_bol) \
! 617: { \
! 618: if ( ! YY_CURRENT_BUFFER ){\
! 619: yyensure_buffer_stack (yyscanner); \
! 620: YY_CURRENT_BUFFER_LVALUE = \
! 621: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
! 622: } \
! 623: YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
! 624: }
! 625: #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
! 626:
! 627: /* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
! 628: /* Begin user sect3 */
! 629:
! 630: #define settings_parser_wrap(yyscanner) (/*CONSTCOND*/1)
! 631: #define YY_SKIP_YYWRAP
! 632:
! 633: #define FLEX_DEBUG
! 634: typedef flex_uint8_t YY_CHAR;
! 635:
! 636: typedef int yy_state_type;
! 637:
! 638: #define yytext_ptr yytext_r
! 639:
! 640: /* %% [1.5] DFA */
! 641:
! 642: /* %if-c-only Standard (non-C++) definition */
! 643:
! 644: static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
! 645: static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
! 646: static int yy_get_next_buffer ( yyscan_t yyscanner );
! 647: static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
! 648:
! 649: /* %endif */
! 650:
! 651: /* Done after the current pattern has been matched and before the
! 652: * corresponding action - sets up yytext.
! 653: */
! 654: #define YY_DO_BEFORE_ACTION \
! 655: yyg->yytext_ptr = yy_bp; \
! 656: /* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
! 657: yyleng = (int) (yy_cp - yy_bp); \
! 658: yyg->yy_hold_char = *yy_cp; \
! 659: *yy_cp = '\0'; \
! 660: /* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
! 661: yyg->yy_c_buf_p = yy_cp;
! 662: /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
! 663: #define YY_NUM_RULES 39
! 664: #define YY_END_OF_BUFFER 40
! 665: /* This struct is not used in this scanner,
! 666: but its presence is necessary. */
! 667: struct yy_trans_info
! 668: {
! 669: flex_int32_t yy_verify;
! 670: flex_int32_t yy_nxt;
! 671: };
! 672: static const flex_int16_t yy_accept[85] =
! 673: { 0,
! 674: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 675: 40, 12, 2, 3, 2, 11, 1, 7, 6, 8,
! 676: 9, 12, 4, 5, 17, 14, 15, 14, 18, 13,
! 677: 16, 23, 20, 21, 19, 22, 29, 25, 24, 26,
! 678: 27, 38, 30, 31, 32, 12, 2, 2, 1, 1,
! 679: 3, 0, 12, 17, 0, 14, 14, 13, 13, 15,
! 680: 0, 23, 20, 29, 28, 38, 37, 36, 37, 33,
! 681: 34, 35, 1, 12, 17, 13, 12, 12, 12, 12,
! 682: 0, 10, 10, 0
! 683: } ;
! 684:
! 685: static const YY_CHAR yy_ec[256] =
! 686: { 0,
! 687: 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
! 688: 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
! 689: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 690: 1, 5, 1, 6, 7, 1, 1, 1, 1, 1,
! 691: 1, 1, 1, 8, 1, 9, 1, 1, 1, 1,
! 692: 1, 1, 1, 1, 1, 1, 1, 10, 1, 1,
! 693: 11, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 694: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 695: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 696: 1, 12, 1, 1, 1, 1, 1, 1, 13, 14,
! 697:
! 698: 15, 1, 1, 1, 16, 1, 1, 17, 1, 18,
! 699: 1, 1, 1, 19, 1, 20, 21, 1, 1, 1,
! 700: 1, 1, 22, 1, 23, 1, 1, 1, 1, 1,
! 701: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 702: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 703: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 704: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 705: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 706: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 707: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 708:
! 709: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 710: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 711: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 712: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 713: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 714: 1, 1, 1, 1, 1
! 715: } ;
! 716:
! 717: static const YY_CHAR yy_meta[24] =
! 718: { 0,
! 719: 1, 2, 3, 4, 5, 6, 5, 7, 8, 7,
! 720: 9, 10, 1, 1, 1, 1, 1, 1, 1, 1,
! 721: 1, 7, 5
! 722: } ;
! 723:
! 724: static const flex_int16_t yy_base[103] =
! 725: { 0,
! 726: 0, 0, 23, 0, 45, 67, 89, 111, 49, 50,
! 727: 124, 0, 133, 335, 55, 335, 60, 335, 335, 335,
! 728: 335, 104, 335, 335, 112, 139, 335, 73, 335, 62,
! 729: 335, 0, 74, 335, 335, 335, 0, 335, 335, 335,
! 730: 0, 0, 335, 335, 144, 0, 0, 78, 0, 81,
! 731: 335, 117, 106, 102, 0, 0, 84, 0, 94, 335,
! 732: 107, 0, 97, 0, 335, 0, 335, 335, 106, 335,
! 733: 335, 335, 0, 89, 78, 0, 60, 53, 43, 98,
! 734: 102, 335, 103, 335, 164, 174, 184, 194, 204, 214,
! 735: 224, 234, 244, 249, 255, 264, 274, 284, 294, 304,
! 736:
! 737: 314, 324
! 738: } ;
! 739:
! 740: static const flex_int16_t yy_def[103] =
! 741: { 0,
! 742: 84, 1, 84, 3, 85, 85, 86, 86, 87, 87,
! 743: 84, 88, 84, 84, 84, 84, 89, 84, 84, 84,
! 744: 84, 88, 84, 84, 90, 84, 84, 84, 84, 91,
! 745: 84, 92, 84, 84, 84, 84, 93, 84, 84, 84,
! 746: 94, 95, 84, 84, 96, 88, 13, 84, 97, 89,
! 747: 84, 98, 88, 90, 99, 26, 84, 100, 91, 84,
! 748: 101, 92, 84, 93, 84, 95, 84, 84, 84, 84,
! 749: 84, 84, 97, 88, 99, 100, 88, 88, 88, 88,
! 750: 102, 84, 102, 0, 84, 84, 84, 84, 84, 84,
! 751: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
! 752:
! 753: 84, 84
! 754: } ;
! 755:
! 756: static const flex_int16_t yy_nxt[359] =
! 757: { 0,
! 758: 12, 13, 14, 15, 13, 16, 17, 18, 19, 20,
! 759: 21, 12, 12, 12, 12, 22, 12, 12, 12, 12,
! 760: 12, 23, 24, 25, 26, 27, 28, 26, 29, 30,
! 761: 31, 29, 29, 29, 25, 25, 25, 25, 25, 25,
! 762: 25, 25, 25, 25, 29, 29, 33, 34, 35, 33,
! 763: 36, 34, 43, 43, 44, 44, 48, 80, 48, 48,
! 764: 45, 45, 51, 52, 60, 61, 79, 34, 33, 34,
! 765: 35, 33, 36, 34, 57, 63, 57, 57, 63, 48,
! 766: 78, 48, 48, 51, 52, 57, 55, 57, 57, 34,
! 767: 38, 38, 39, 38, 40, 38, 60, 61, 63, 81,
! 768:
! 769: 41, 63, 81, 83, 83, 77, 83, 83, 68, 60,
! 770: 55, 38, 38, 38, 39, 38, 40, 38, 74, 51,
! 771: 55, 53, 41, 84, 84, 84, 84, 84, 84, 84,
! 772: 84, 84, 84, 38, 47, 84, 48, 47, 84, 49,
! 773: 56, 84, 57, 56, 84, 58, 68, 69, 84, 84,
! 774: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
! 775: 84, 70, 71, 72, 32, 32, 32, 32, 32, 32,
! 776: 32, 32, 32, 32, 37, 37, 37, 37, 37, 37,
! 777: 37, 37, 37, 37, 42, 42, 42, 42, 42, 42,
! 778: 42, 42, 42, 42, 46, 84, 84, 84, 84, 84,
! 779:
! 780: 84, 84, 84, 46, 50, 50, 50, 50, 50, 50,
! 781: 50, 50, 50, 50, 54, 84, 84, 84, 84, 84,
! 782: 84, 54, 84, 54, 59, 59, 59, 59, 59, 59,
! 783: 59, 59, 59, 59, 62, 84, 84, 84, 84, 84,
! 784: 62, 62, 62, 62, 64, 84, 84, 84, 84, 84,
! 785: 64, 64, 64, 65, 65, 66, 66, 66, 84, 66,
! 786: 84, 66, 66, 66, 67, 67, 67, 67, 67, 67,
! 787: 67, 67, 67, 67, 73, 73, 84, 84, 73, 73,
! 788: 73, 73, 73, 73, 52, 52, 52, 52, 52, 52,
! 789: 52, 52, 52, 52, 75, 84, 84, 84, 84, 84,
! 790:
! 791: 84, 84, 84, 75, 76, 76, 84, 84, 76, 76,
! 792: 76, 76, 76, 76, 61, 61, 61, 61, 61, 61,
! 793: 61, 61, 61, 61, 82, 82, 82, 82, 82, 82,
! 794: 82, 82, 84, 82, 11, 84, 84, 84, 84, 84,
! 795: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
! 796: 84, 84, 84, 84, 84, 84, 84, 84
! 797: } ;
! 798:
! 799: static const flex_int16_t yy_chk[359] =
! 800: { 0,
! 801: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 802: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 803: 1, 1, 1, 3, 3, 3, 3, 3, 3, 3,
! 804: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
! 805: 3, 3, 3, 3, 3, 3, 5, 5, 5, 5,
! 806: 5, 5, 9, 10, 9, 10, 15, 79, 15, 15,
! 807: 9, 10, 17, 17, 30, 30, 78, 5, 6, 6,
! 808: 6, 6, 6, 6, 28, 33, 28, 28, 33, 48,
! 809: 77, 48, 48, 50, 50, 57, 75, 57, 57, 6,
! 810: 7, 7, 7, 7, 7, 7, 59, 59, 63, 80,
! 811:
! 812: 7, 63, 80, 81, 83, 74, 81, 83, 69, 61,
! 813: 54, 7, 8, 8, 8, 8, 8, 8, 53, 52,
! 814: 25, 22, 8, 11, 0, 0, 0, 0, 0, 0,
! 815: 0, 0, 0, 8, 13, 0, 13, 13, 0, 13,
! 816: 26, 0, 26, 26, 0, 26, 45, 45, 0, 0,
! 817: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 818: 0, 45, 45, 45, 85, 85, 85, 85, 85, 85,
! 819: 85, 85, 85, 85, 86, 86, 86, 86, 86, 86,
! 820: 86, 86, 86, 86, 87, 87, 87, 87, 87, 87,
! 821: 87, 87, 87, 87, 88, 0, 0, 0, 0, 0,
! 822:
! 823: 0, 0, 0, 88, 89, 89, 89, 89, 89, 89,
! 824: 89, 89, 89, 89, 90, 0, 0, 0, 0, 0,
! 825: 0, 90, 0, 90, 91, 91, 91, 91, 91, 91,
! 826: 91, 91, 91, 91, 92, 0, 0, 0, 0, 0,
! 827: 92, 92, 92, 92, 93, 0, 0, 0, 0, 0,
! 828: 93, 93, 93, 94, 94, 95, 95, 95, 0, 95,
! 829: 0, 95, 95, 95, 96, 96, 96, 96, 96, 96,
! 830: 96, 96, 96, 96, 97, 97, 0, 0, 97, 97,
! 831: 97, 97, 97, 97, 98, 98, 98, 98, 98, 98,
! 832: 98, 98, 98, 98, 99, 0, 0, 0, 0, 0,
! 833:
! 834: 0, 0, 0, 99, 100, 100, 0, 0, 100, 100,
! 835: 100, 100, 100, 100, 101, 101, 101, 101, 101, 101,
! 836: 101, 101, 101, 101, 102, 102, 102, 102, 102, 102,
! 837: 102, 102, 0, 102, 84, 84, 84, 84, 84, 84,
! 838: 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
! 839: 84, 84, 84, 84, 84, 84, 84, 84
! 840: } ;
! 841:
! 842: /* Table of booleans, true if rule could match eol. */
! 843: static const flex_int32_t yy_rule_can_match_eol[40] =
! 844: { 0,
! 845: 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
! 846: 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
! 847: };
! 848:
! 849: static const flex_int16_t yy_rule_linenum[39] =
! 850: { 0,
! 851: 71, 72, 73, 75, 76, 78, 79, 81, 86, 91,
! 852: 96, 101, 107, 108, 109, 111, 113, 118, 125, 126,
! 853: 128, 149, 155, 162, 165, 185, 188, 191, 194, 200,
! 854: 201, 203, 223, 224, 225, 226, 227, 228
! 855: } ;
! 856:
! 857: /* The intent behind this definition is that it'll catch
! 858: * any uses of REJECT which flex missed.
! 859: */
! 860: #define REJECT reject_used_but_not_detected
! 861: #define yymore() yymore_used_but_not_detected
! 862: #define YY_MORE_ADJ 0
! 863: #define YY_RESTORE_YY_MORE_OFFSET
! 864: #line 1 "settings/settings_lexer.l"
! 865: #line 2 "settings/settings_lexer.l"
! 866: /*
! 867: * Copyright (C) 2014-2018 Tobias Brunner
! 868: * HSR Hochschule fuer Technik Rapperswil
! 869: *
! 870: * This program is free software; you can redistribute it and/or modify it
! 871: * under the terms of the GNU General Public License as published by the
! 872: * Free Software Foundation; either version 2 of the License, or (at your
! 873: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 874: *
! 875: * This program is distributed in the hope that it will be useful, but
! 876: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 877: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 878: * for more details.
! 879: */
! 880:
! 881: #include <utils/parser_helper.h>
! 882:
! 883: #include "settings_parser.h"
! 884:
! 885: bool settings_parser_open_next_file(parser_helper_t *ctx);
! 886:
! 887: static void include_files(parser_helper_t *ctx);
! 888:
! 889: #line 890 "settings/settings_lexer.c"
! 890: /* use start conditions stack */
! 891: /* do not declare unneeded functions */
! 892: #define YY_NO_INPUT 1
! 893: /* do not include unistd.h as it might conflict with our scanner states */
! 894: #define YY_NO_UNISTD_H 1
! 895: /* due to that disable interactive mode, which requires isatty() */
! 896: /* don't use global variables, and interact properly with bison */
! 897: /* maintain the line number */
! 898: /* don't generate a default rule */
! 899: /* prefix function/variable declarations */
! 900: /* don't change the name of the output file otherwise autotools has issues */
! 901: /* type of our extra data */
! 902: /* state used to scan references */
! 903:
! 904: /* state used to scan values */
! 905:
! 906: /* state used to scan include file patterns */
! 907:
! 908: /* state used to scan quoted strings */
! 909:
! 910: /* pattern for section/key names */
! 911: #line 912 "settings/settings_lexer.c"
! 912:
! 913: #define INITIAL 0
! 914: #define ref 1
! 915: #define val 2
! 916: #define inc 3
! 917: #define str 4
! 918:
! 919: #ifndef YY_NO_UNISTD_H
! 920: /* Special case for "unistd.h", since it is non-ANSI. We include it way
! 921: * down here because we want the user's section 1 to have been scanned first.
! 922: * The user has a chance to override it with an option.
! 923: */
! 924: /* %if-c-only */
! 925: #include <unistd.h>
! 926: /* %endif */
! 927: /* %if-c++-only */
! 928: /* %endif */
! 929: #endif
! 930:
! 931: #define YY_EXTRA_TYPE parser_helper_t*
! 932:
! 933: /* %if-c-only Reentrant structure and macros (non-C++). */
! 934: /* %if-reentrant */
! 935:
! 936: /* Holds the entire state of the reentrant scanner. */
! 937: struct yyguts_t
! 938: {
! 939:
! 940: /* User-defined. Not touched by flex. */
! 941: YY_EXTRA_TYPE yyextra_r;
! 942:
! 943: /* The rest are the same as the globals declared in the non-reentrant scanner. */
! 944: FILE *yyin_r, *yyout_r;
! 945: size_t yy_buffer_stack_top; /**< index of top of stack. */
! 946: size_t yy_buffer_stack_max; /**< capacity of stack. */
! 947: YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
! 948: char yy_hold_char;
! 949: int yy_n_chars;
! 950: int yyleng_r;
! 951: char *yy_c_buf_p;
! 952: int yy_init;
! 953: int yy_start;
! 954: int yy_did_buffer_switch_on_eof;
! 955: int yy_start_stack_ptr;
! 956: int yy_start_stack_depth;
! 957: int *yy_start_stack;
! 958: yy_state_type yy_last_accepting_state;
! 959: char* yy_last_accepting_cpos;
! 960:
! 961: int yylineno_r;
! 962: int yy_flex_debug_r;
! 963:
! 964: char *yytext_r;
! 965: int yy_more_flag;
! 966: int yy_more_len;
! 967:
! 968: YYSTYPE * yylval_r;
! 969:
! 970: }; /* end struct yyguts_t */
! 971:
! 972: /* %if-c-only */
! 973:
! 974: static int yy_init_globals ( yyscan_t yyscanner );
! 975:
! 976: /* %endif */
! 977:
! 978: /* %if-reentrant */
! 979:
! 980: /* This must go here because YYSTYPE and YYLTYPE are included
! 981: * from bison output in section 1.*/
! 982: # define yylval yyg->yylval_r
! 983:
! 984: int yylex_init (yyscan_t* scanner);
! 985:
! 986: int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
! 987:
! 988: /* %endif */
! 989:
! 990: /* %endif End reentrant structures and macros. */
! 991:
! 992: /* Accessor methods to globals.
! 993: These are made visible to non-reentrant scanners for convenience. */
! 994:
! 995: int yylex_destroy ( yyscan_t yyscanner );
! 996:
! 997: int yyget_debug ( yyscan_t yyscanner );
! 998:
! 999: void yyset_debug ( int debug_flag , yyscan_t yyscanner );
! 1000:
! 1001: YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
! 1002:
! 1003: void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
! 1004:
! 1005: FILE *yyget_in ( yyscan_t yyscanner );
! 1006:
! 1007: void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
! 1008:
! 1009: FILE *yyget_out ( yyscan_t yyscanner );
! 1010:
! 1011: void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
! 1012:
! 1013: int yyget_leng ( yyscan_t yyscanner );
! 1014:
! 1015: char *yyget_text ( yyscan_t yyscanner );
! 1016:
! 1017: int yyget_lineno ( yyscan_t yyscanner );
! 1018:
! 1019: void yyset_lineno ( int _line_number , yyscan_t yyscanner );
! 1020:
! 1021: int yyget_column ( yyscan_t yyscanner );
! 1022:
! 1023: void yyset_column ( int _column_no , yyscan_t yyscanner );
! 1024:
! 1025: /* %if-bison-bridge */
! 1026:
! 1027: YYSTYPE * yyget_lval ( yyscan_t yyscanner );
! 1028:
! 1029: void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
! 1030:
! 1031: /* %endif */
! 1032:
! 1033: /* Macros after this point can all be overridden by user definitions in
! 1034: * section 1.
! 1035: */
! 1036:
! 1037: #ifndef YY_SKIP_YYWRAP
! 1038: #ifdef __cplusplus
! 1039: extern "C" int yywrap ( yyscan_t yyscanner );
! 1040: #else
! 1041: extern int yywrap ( yyscan_t yyscanner );
! 1042: #endif
! 1043: #endif
! 1044:
! 1045: /* %not-for-header */
! 1046: #ifndef YY_NO_UNPUT
! 1047:
! 1048: static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner);
! 1049:
! 1050: #endif
! 1051: /* %ok-for-header */
! 1052:
! 1053: /* %endif */
! 1054:
! 1055: #ifndef yytext_ptr
! 1056: static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
! 1057: #endif
! 1058:
! 1059: #ifdef YY_NEED_STRLEN
! 1060: static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
! 1061: #endif
! 1062:
! 1063: #ifndef YY_NO_INPUT
! 1064: /* %if-c-only Standard (non-C++) definition */
! 1065: /* %not-for-header */
! 1066: #ifdef __cplusplus
! 1067: static int yyinput ( yyscan_t yyscanner );
! 1068: #else
! 1069: static int input ( yyscan_t yyscanner );
! 1070: #endif
! 1071: /* %ok-for-header */
! 1072:
! 1073: /* %endif */
! 1074: #endif
! 1075:
! 1076: /* %if-c-only */
! 1077:
! 1078: static void yy_push_state ( int _new_state , yyscan_t yyscanner);
! 1079:
! 1080: static void yy_pop_state ( yyscan_t yyscanner );
! 1081:
! 1082: static int yy_top_state ( yyscan_t yyscanner );
! 1083:
! 1084: /* %endif */
! 1085:
! 1086: /* Amount of stuff to slurp up with each read. */
! 1087: #ifndef YY_READ_BUF_SIZE
! 1088: #ifdef __ia64__
! 1089: /* On IA-64, the buffer size is 16k, not 8k */
! 1090: #define YY_READ_BUF_SIZE 16384
! 1091: #else
! 1092: #define YY_READ_BUF_SIZE 8192
! 1093: #endif /* __ia64__ */
! 1094: #endif
! 1095:
! 1096: /* Copy whatever the last rule matched to the standard output. */
! 1097: #ifndef ECHO
! 1098: /* %if-c-only Standard (non-C++) definition */
! 1099: /* This used to be an fputs(), but since the string might contain NUL's,
! 1100: * we now use fwrite().
! 1101: */
! 1102: #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
! 1103: /* %endif */
! 1104: /* %if-c++-only C++ definition */
! 1105: /* %endif */
! 1106: #endif
! 1107:
! 1108: /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
! 1109: * is returned in "result".
! 1110: */
! 1111: #ifndef YY_INPUT
! 1112: #define YY_INPUT(buf,result,max_size) \
! 1113: /* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
! 1114: if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
! 1115: { \
! 1116: int c = '*'; \
! 1117: int n; \
! 1118: for ( n = 0; n < max_size && \
! 1119: (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
! 1120: buf[n] = (char) c; \
! 1121: if ( c == '\n' ) \
! 1122: buf[n++] = (char) c; \
! 1123: if ( c == EOF && ferror( yyin ) ) \
! 1124: YY_FATAL_ERROR( "input in flex scanner failed" ); \
! 1125: result = n; \
! 1126: } \
! 1127: else \
! 1128: { \
! 1129: errno=0; \
! 1130: while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
! 1131: { \
! 1132: if( errno != EINTR) \
! 1133: { \
! 1134: YY_FATAL_ERROR( "input in flex scanner failed" ); \
! 1135: break; \
! 1136: } \
! 1137: errno=0; \
! 1138: clearerr(yyin); \
! 1139: } \
! 1140: }\
! 1141: \
! 1142: /* %if-c++-only C++ definition \ */\
! 1143: /* %endif */
! 1144:
! 1145: #endif
! 1146:
! 1147: /* No semi-colon after return; correct usage is to write "yyterminate();" -
! 1148: * we don't want an extra ';' after the "return" because that will cause
! 1149: * some compilers to complain about unreachable statements.
! 1150: */
! 1151: #ifndef yyterminate
! 1152: #define yyterminate() return YY_NULL
! 1153: #endif
! 1154:
! 1155: /* Number of entries by which start-condition stack grows. */
! 1156: #ifndef YY_START_STACK_INCR
! 1157: #define YY_START_STACK_INCR 25
! 1158: #endif
! 1159:
! 1160: /* Report a fatal error. */
! 1161: #ifndef YY_FATAL_ERROR
! 1162: /* %if-c-only */
! 1163: #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
! 1164: /* %endif */
! 1165: /* %if-c++-only */
! 1166: /* %endif */
! 1167: #endif
! 1168:
! 1169: /* %if-tables-serialization structures and prototypes */
! 1170: /* %not-for-header */
! 1171: /* %ok-for-header */
! 1172:
! 1173: /* %not-for-header */
! 1174: /* %tables-yydmap generated elements */
! 1175: /* %endif */
! 1176: /* end tables serialization structures and prototypes */
! 1177:
! 1178: /* %ok-for-header */
! 1179:
! 1180: /* Default declaration of generated scanner - a define so the user can
! 1181: * easily add parameters.
! 1182: */
! 1183: #ifndef YY_DECL
! 1184: #define YY_DECL_IS_OURS 1
! 1185: /* %if-c-only Standard (non-C++) definition */
! 1186:
! 1187: extern int yylex \
! 1188: (YYSTYPE * yylval_param , yyscan_t yyscanner);
! 1189:
! 1190: #define YY_DECL int yylex \
! 1191: (YYSTYPE * yylval_param , yyscan_t yyscanner)
! 1192: /* %endif */
! 1193: /* %if-c++-only C++ definition */
! 1194: /* %endif */
! 1195: #endif /* !YY_DECL */
! 1196:
! 1197: /* Code executed at the beginning of each rule, after yytext and yyleng
! 1198: * have been set up.
! 1199: */
! 1200: #ifndef YY_USER_ACTION
! 1201: #define YY_USER_ACTION
! 1202: #endif
! 1203:
! 1204: /* Code executed at the end of each rule. */
! 1205: #ifndef YY_BREAK
! 1206: #define YY_BREAK /*LINTED*/break;
! 1207: #endif
! 1208:
! 1209: /* %% [6.0] YY_RULE_SETUP definition goes here */
! 1210: #define YY_RULE_SETUP \
! 1211: YY_USER_ACTION
! 1212:
! 1213: /* %not-for-header */
! 1214: /** The main scanner function which does all the work.
! 1215: */
! 1216: YY_DECL
! 1217: {
! 1218: yy_state_type yy_current_state;
! 1219: char *yy_cp, *yy_bp;
! 1220: int yy_act;
! 1221: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 1222:
! 1223: yylval = yylval_param;
! 1224:
! 1225: if ( !yyg->yy_init )
! 1226: {
! 1227: yyg->yy_init = 1;
! 1228:
! 1229: #ifdef YY_USER_INIT
! 1230: YY_USER_INIT;
! 1231: #endif
! 1232:
! 1233: if ( ! yyg->yy_start )
! 1234: yyg->yy_start = 1; /* first start state */
! 1235:
! 1236: if ( ! yyin )
! 1237: /* %if-c-only */
! 1238: yyin = stdin;
! 1239: /* %endif */
! 1240: /* %if-c++-only */
! 1241: /* %endif */
! 1242:
! 1243: if ( ! yyout )
! 1244: /* %if-c-only */
! 1245: yyout = stdout;
! 1246: /* %endif */
! 1247: /* %if-c++-only */
! 1248: /* %endif */
! 1249:
! 1250: if ( ! YY_CURRENT_BUFFER ) {
! 1251: yyensure_buffer_stack (yyscanner);
! 1252: YY_CURRENT_BUFFER_LVALUE =
! 1253: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
! 1254: }
! 1255:
! 1256: yy_load_buffer_state( yyscanner );
! 1257: }
! 1258:
! 1259: {
! 1260: /* %% [7.0] user's declarations go here */
! 1261: #line 69 "settings/settings_lexer.l"
! 1262:
! 1263:
! 1264: #line 1265 "settings/settings_lexer.c"
! 1265:
! 1266: while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
! 1267: {
! 1268: /* %% [8.0] yymore()-related code goes here */
! 1269: yy_cp = yyg->yy_c_buf_p;
! 1270:
! 1271: /* Support of yytext. */
! 1272: *yy_cp = yyg->yy_hold_char;
! 1273:
! 1274: /* yy_bp points to the position in yy_ch_buf of the start of
! 1275: * the current run.
! 1276: */
! 1277: yy_bp = yy_cp;
! 1278:
! 1279: /* %% [9.0] code to set up and find next match goes here */
! 1280: yy_current_state = yyg->yy_start;
! 1281: yy_match:
! 1282: do
! 1283: {
! 1284: YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
! 1285: if ( yy_accept[yy_current_state] )
! 1286: {
! 1287: yyg->yy_last_accepting_state = yy_current_state;
! 1288: yyg->yy_last_accepting_cpos = yy_cp;
! 1289: }
! 1290: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
! 1291: {
! 1292: yy_current_state = (int) yy_def[yy_current_state];
! 1293: if ( yy_current_state >= 85 )
! 1294: yy_c = yy_meta[yy_c];
! 1295: }
! 1296: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
! 1297: ++yy_cp;
! 1298: }
! 1299: while ( yy_current_state != 84 );
! 1300: yy_cp = yyg->yy_last_accepting_cpos;
! 1301: yy_current_state = yyg->yy_last_accepting_state;
! 1302:
! 1303: yy_find_action:
! 1304: /* %% [10.0] code to find the action number goes here */
! 1305: yy_act = yy_accept[yy_current_state];
! 1306:
! 1307: YY_DO_BEFORE_ACTION;
! 1308:
! 1309: /* %% [11.0] code for yylineno update goes here */
! 1310:
! 1311: if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
! 1312: {
! 1313: int yyl;
! 1314: for ( yyl = 0; yyl < yyleng; ++yyl )
! 1315: if ( yytext[yyl] == '\n' )
! 1316:
! 1317: do{ yylineno++;
! 1318: yycolumn=0;
! 1319: }while(0)
! 1320: ;
! 1321: }
! 1322:
! 1323: do_action: /* This label is used only to access EOF actions. */
! 1324:
! 1325: /* %% [12.0] debug code goes here */
! 1326: if ( yy_flex_debug )
! 1327: {
! 1328: if ( yy_act == 0 )
! 1329: fprintf( stderr, "--scanner backing up\n" );
! 1330: else if ( yy_act < 39 )
! 1331: fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
! 1332: (long)yy_rule_linenum[yy_act], yytext );
! 1333: else if ( yy_act == 39 )
! 1334: fprintf( stderr, "--accepting default rule (\"%s\")\n",
! 1335: yytext );
! 1336: else if ( yy_act == 40 )
! 1337: fprintf( stderr, "--(end of buffer or a NUL)\n" );
! 1338: else
! 1339: fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
! 1340: }
! 1341:
! 1342: switch ( yy_act )
! 1343: { /* beginning of action switch */
! 1344: /* %% [13.0] actions go here */
! 1345: case 0: /* must back up */
! 1346: /* undo the effects of YY_DO_BEFORE_ACTION */
! 1347: *yy_cp = yyg->yy_hold_char;
! 1348: yy_cp = yyg->yy_last_accepting_cpos;
! 1349: yy_current_state = yyg->yy_last_accepting_state;
! 1350: goto yy_find_action;
! 1351:
! 1352: case 1:
! 1353: YY_RULE_SETUP
! 1354: #line 71 "settings/settings_lexer.l"
! 1355: /* eat comments */
! 1356: YY_BREAK
! 1357: case 2:
! 1358: YY_RULE_SETUP
! 1359: #line 72 "settings/settings_lexer.l"
! 1360: /* eat whitespace */
! 1361: YY_BREAK
! 1362: case 3:
! 1363: /* rule 3 can match eol */
! 1364: YY_RULE_SETUP
! 1365: #line 73 "settings/settings_lexer.l"
! 1366: /* eat newlines and comments at the end of a line */
! 1367: YY_BREAK
! 1368: case 4:
! 1369: #line 76 "settings/settings_lexer.l"
! 1370: case 5:
! 1371: YY_RULE_SETUP
! 1372: #line 76 "settings/settings_lexer.l"
! 1373: return yytext[0];
! 1374: YY_BREAK
! 1375: case 6:
! 1376: YY_RULE_SETUP
! 1377: #line 78 "settings/settings_lexer.l"
! 1378: return DOT;
! 1379: YY_BREAK
! 1380: case 7:
! 1381: YY_RULE_SETUP
! 1382: #line 79 "settings/settings_lexer.l"
! 1383: return COMMA;
! 1384: YY_BREAK
! 1385: case 8:
! 1386: YY_RULE_SETUP
! 1387: #line 81 "settings/settings_lexer.l"
! 1388: {
! 1389: yy_push_state(ref, yyscanner);
! 1390: return COLON;
! 1391: }
! 1392: YY_BREAK
! 1393: case 9:
! 1394: YY_RULE_SETUP
! 1395: #line 86 "settings/settings_lexer.l"
! 1396: {
! 1397: yy_push_state(val, yyscanner);
! 1398: return yytext[0];
! 1399: }
! 1400: YY_BREAK
! 1401: case 10:
! 1402: /* rule 10 can match eol */
! 1403: *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
! 1404: YY_LINENO_REWIND_TO(yy_cp - 1);
! 1405: yyg->yy_c_buf_p = yy_cp -= 1;
! 1406: YY_DO_BEFORE_ACTION; /* set up yytext again */
! 1407: YY_RULE_SETUP
! 1408: #line 91 "settings/settings_lexer.l"
! 1409: {
! 1410: yyextra->string_init(yyextra);
! 1411: yy_push_state(inc, yyscanner);
! 1412: }
! 1413: YY_BREAK
! 1414: case 11:
! 1415: YY_RULE_SETUP
! 1416: #line 96 "settings/settings_lexer.l"
! 1417: {
! 1418: PARSER_DBG1(yyextra, "unexpected string detected");
! 1419: return STRING_ERROR;
! 1420: }
! 1421: YY_BREAK
! 1422: case 12:
! 1423: YY_RULE_SETUP
! 1424: #line 101 "settings/settings_lexer.l"
! 1425: {
! 1426: yylval->s = strdup(yytext);
! 1427: return NAME;
! 1428: }
! 1429: YY_BREAK
! 1430:
! 1431: case 13:
! 1432: YY_RULE_SETUP
! 1433: #line 107 "settings/settings_lexer.l"
! 1434: /* eat comments */
! 1435: YY_BREAK
! 1436: case 14:
! 1437: YY_RULE_SETUP
! 1438: #line 108 "settings/settings_lexer.l"
! 1439: /* eat whitespace */
! 1440: YY_BREAK
! 1441: case 15:
! 1442: /* rule 15 can match eol */
! 1443: YY_RULE_SETUP
! 1444: #line 109 "settings/settings_lexer.l"
! 1445: /* eat newlines and comments at the end of a line */
! 1446: YY_BREAK
! 1447: case 16:
! 1448: YY_RULE_SETUP
! 1449: #line 111 "settings/settings_lexer.l"
! 1450: return COMMA;
! 1451: YY_BREAK
! 1452: case 17:
! 1453: YY_RULE_SETUP
! 1454: #line 113 "settings/settings_lexer.l"
! 1455: {
! 1456: yylval->s = strdup(yytext);
! 1457: return NAME;
! 1458: }
! 1459: YY_BREAK
! 1460: case 18:
! 1461: YY_RULE_SETUP
! 1462: #line 118 "settings/settings_lexer.l"
! 1463: {
! 1464: unput(yytext[0]);
! 1465: yy_pop_state(yyscanner);
! 1466: }
! 1467: YY_BREAK
! 1468:
! 1469:
! 1470: case 19:
! 1471: YY_RULE_SETUP
! 1472: #line 125 "settings/settings_lexer.l"
! 1473: /* just ignore these */
! 1474: YY_BREAK
! 1475: case 20:
! 1476: YY_RULE_SETUP
! 1477: #line 126 "settings/settings_lexer.l"
! 1478:
! 1479: YY_BREAK
! 1480: case YY_STATE_EOF(val):
! 1481: #line 127 "settings/settings_lexer.l"
! 1482: case 21:
! 1483: /* rule 21 can match eol */
! 1484: YY_RULE_SETUP
! 1485: #line 128 "settings/settings_lexer.l"
! 1486: {
! 1487: if (*yytext)
! 1488: {
! 1489: switch (yytext[0])
! 1490: {
! 1491: case '\n':
! 1492: /* put the newline back to fix the line numbers */
! 1493: unput('\n');
! 1494: yy_set_bol(0);
! 1495: break;
! 1496: case '#':
! 1497: case '}':
! 1498: /* these are parsed outside of this start condition */
! 1499: unput(yytext[0]);
! 1500: break;
! 1501: }
! 1502: }
! 1503: yy_pop_state(yyscanner);
! 1504: return NEWLINE;
! 1505: }
! 1506: YY_BREAK
! 1507: case 22:
! 1508: YY_RULE_SETUP
! 1509: #line 149 "settings/settings_lexer.l"
! 1510: {
! 1511: yyextra->string_init(yyextra);
! 1512: yy_push_state(str, yyscanner);
! 1513: }
! 1514: YY_BREAK
! 1515: /* same as above, but allow more characters */
! 1516: case 23:
! 1517: YY_RULE_SETUP
! 1518: #line 155 "settings/settings_lexer.l"
! 1519: {
! 1520: yylval->s = strdup(yytext);
! 1521: return NAME;
! 1522: }
! 1523: YY_BREAK
! 1524:
! 1525:
! 1526: case 24:
! 1527: YY_RULE_SETUP
! 1528: #line 162 "settings/settings_lexer.l"
! 1529: /* just ignore these */
! 1530: YY_BREAK
! 1531: /* we allow all characters except #, } and spaces, they can be escaped */
! 1532: case YY_STATE_EOF(inc):
! 1533: #line 164 "settings/settings_lexer.l"
! 1534: case 25:
! 1535: /* rule 25 can match eol */
! 1536: YY_RULE_SETUP
! 1537: #line 165 "settings/settings_lexer.l"
! 1538: {
! 1539: if (*yytext)
! 1540: {
! 1541: switch (yytext[0])
! 1542: {
! 1543: case '\n':
! 1544: /* put the newline back to fix the line numbers */
! 1545: unput('\n');
! 1546: yy_set_bol(0);
! 1547: break;
! 1548: case '#':
! 1549: case '}':
! 1550: /* these are parsed outside of this start condition */
! 1551: unput(yytext[0]);
! 1552: break;
! 1553: }
! 1554: }
! 1555: include_files(yyextra);
! 1556: yy_pop_state(yyscanner);
! 1557: }
! 1558: YY_BREAK
! 1559: case 26:
! 1560: YY_RULE_SETUP
! 1561: #line 185 "settings/settings_lexer.l"
! 1562: { /* string include */
! 1563: yy_push_state(str, yyscanner);
! 1564: }
! 1565: YY_BREAK
! 1566: case 27:
! 1567: YY_RULE_SETUP
! 1568: #line 188 "settings/settings_lexer.l"
! 1569: {
! 1570: yyextra->string_add(yyextra, yytext);
! 1571: }
! 1572: YY_BREAK
! 1573: case 28:
! 1574: YY_RULE_SETUP
! 1575: #line 191 "settings/settings_lexer.l"
! 1576: {
! 1577: yyextra->string_add(yyextra, yytext+1);
! 1578: }
! 1579: YY_BREAK
! 1580: case 29:
! 1581: YY_RULE_SETUP
! 1582: #line 194 "settings/settings_lexer.l"
! 1583: {
! 1584: yyextra->string_add(yyextra, yytext);
! 1585: }
! 1586: YY_BREAK
! 1587:
! 1588:
! 1589: case 30:
! 1590: YY_RULE_SETUP
! 1591: #line 200 "settings/settings_lexer.l"
! 1592: /* just ignore these */
! 1593: YY_BREAK
! 1594: case 31:
! 1595: #line 202 "settings/settings_lexer.l"
! 1596: YY_RULE_SETUP
! 1597: case YY_STATE_EOF(str):
! 1598: #line 202 "settings/settings_lexer.l"
! 1599: case 32:
! 1600: YY_RULE_SETUP
! 1601: #line 203 "settings/settings_lexer.l"
! 1602: {
! 1603: if (!streq(yytext, "\""))
! 1604: {
! 1605: PARSER_DBG1(yyextra, "unterminated string detected");
! 1606: return STRING_ERROR;
! 1607: }
! 1608: if (yy_top_state(yyscanner) == inc)
! 1609: { /* string include */
! 1610: include_files(yyextra);
! 1611: yy_pop_state(yyscanner);
! 1612: yy_pop_state(yyscanner);
! 1613: }
! 1614: else
! 1615: {
! 1616: yy_pop_state(yyscanner);
! 1617: yylval->s = yyextra->string_get(yyextra);
! 1618: return STRING;
! 1619: }
! 1620: }
! 1621: YY_BREAK
! 1622: case 33:
! 1623: YY_RULE_SETUP
! 1624: #line 223 "settings/settings_lexer.l"
! 1625: yyextra->string_add(yyextra, "\n");
! 1626: YY_BREAK
! 1627: case 34:
! 1628: YY_RULE_SETUP
! 1629: #line 224 "settings/settings_lexer.l"
! 1630: yyextra->string_add(yyextra, "\r");
! 1631: YY_BREAK
! 1632: case 35:
! 1633: YY_RULE_SETUP
! 1634: #line 225 "settings/settings_lexer.l"
! 1635: yyextra->string_add(yyextra, "\t");
! 1636: YY_BREAK
! 1637: case 36:
! 1638: /* rule 36 can match eol */
! 1639: YY_RULE_SETUP
! 1640: #line 226 "settings/settings_lexer.l"
! 1641: /* merge lines that end with escaped EOL characters */
! 1642: YY_BREAK
! 1643: case 37:
! 1644: YY_RULE_SETUP
! 1645: #line 227 "settings/settings_lexer.l"
! 1646: yyextra->string_add(yyextra, yytext+1);
! 1647: YY_BREAK
! 1648: case 38:
! 1649: /* rule 38 can match eol */
! 1650: YY_RULE_SETUP
! 1651: #line 228 "settings/settings_lexer.l"
! 1652: {
! 1653: yyextra->string_add(yyextra, yytext);
! 1654: }
! 1655: YY_BREAK
! 1656:
! 1657: case YY_STATE_EOF(INITIAL):
! 1658: case YY_STATE_EOF(ref):
! 1659: #line 233 "settings/settings_lexer.l"
! 1660: {
! 1661: settings_parser_pop_buffer_state(yyscanner);
! 1662: if (!settings_parser_open_next_file(yyextra) && !YY_CURRENT_BUFFER)
! 1663: {
! 1664: yyterminate();
! 1665: }
! 1666: }
! 1667: YY_BREAK
! 1668: case 39:
! 1669: YY_RULE_SETUP
! 1670: #line 241 "settings/settings_lexer.l"
! 1671: YY_FATAL_ERROR( "flex scanner jammed" );
! 1672: YY_BREAK
! 1673: #line 1674 "settings/settings_lexer.c"
! 1674:
! 1675: case YY_END_OF_BUFFER:
! 1676: {
! 1677: /* Amount of text matched not including the EOB char. */
! 1678: int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
! 1679:
! 1680: /* Undo the effects of YY_DO_BEFORE_ACTION. */
! 1681: *yy_cp = yyg->yy_hold_char;
! 1682: YY_RESTORE_YY_MORE_OFFSET
! 1683:
! 1684: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
! 1685: {
! 1686: /* We're scanning a new file or input source. It's
! 1687: * possible that this happened because the user
! 1688: * just pointed yyin at a new source and called
! 1689: * yylex(). If so, then we have to assure
! 1690: * consistency between YY_CURRENT_BUFFER and our
! 1691: * globals. Here is the right place to do so, because
! 1692: * this is the first action (other than possibly a
! 1693: * back-up) that will match for the new input source.
! 1694: */
! 1695: yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
! 1696: /* %if-c-only */
! 1697: YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
! 1698: /* %endif */
! 1699: /* %if-c++-only */
! 1700: /* %endif */
! 1701: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
! 1702: }
! 1703:
! 1704: /* Note that here we test for yy_c_buf_p "<=" to the position
! 1705: * of the first EOB in the buffer, since yy_c_buf_p will
! 1706: * already have been incremented past the NUL character
! 1707: * (since all states make transitions on EOB to the
! 1708: * end-of-buffer state). Contrast this with the test
! 1709: * in input().
! 1710: */
! 1711: if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
! 1712: { /* This was really a NUL. */
! 1713: yy_state_type yy_next_state;
! 1714:
! 1715: yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
! 1716:
! 1717: yy_current_state = yy_get_previous_state( yyscanner );
! 1718:
! 1719: /* Okay, we're now positioned to make the NUL
! 1720: * transition. We couldn't have
! 1721: * yy_get_previous_state() go ahead and do it
! 1722: * for us because it doesn't know how to deal
! 1723: * with the possibility of jamming (and we don't
! 1724: * want to build jamming into it because then it
! 1725: * will run more slowly).
! 1726: */
! 1727:
! 1728: yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
! 1729:
! 1730: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
! 1731:
! 1732: if ( yy_next_state )
! 1733: {
! 1734: /* Consume the NUL. */
! 1735: yy_cp = ++yyg->yy_c_buf_p;
! 1736: yy_current_state = yy_next_state;
! 1737: goto yy_match;
! 1738: }
! 1739:
! 1740: else
! 1741: {
! 1742: /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
! 1743: yy_cp = yyg->yy_last_accepting_cpos;
! 1744: yy_current_state = yyg->yy_last_accepting_state;
! 1745: goto yy_find_action;
! 1746: }
! 1747: }
! 1748:
! 1749: else switch ( yy_get_next_buffer( yyscanner ) )
! 1750: {
! 1751: case EOB_ACT_END_OF_FILE:
! 1752: {
! 1753: yyg->yy_did_buffer_switch_on_eof = 0;
! 1754:
! 1755: if ( yywrap( yyscanner ) )
! 1756: {
! 1757: /* Note: because we've taken care in
! 1758: * yy_get_next_buffer() to have set up
! 1759: * yytext, we can now set up
! 1760: * yy_c_buf_p so that if some total
! 1761: * hoser (like flex itself) wants to
! 1762: * call the scanner after we return the
! 1763: * YY_NULL, it'll still work - another
! 1764: * YY_NULL will get returned.
! 1765: */
! 1766: yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
! 1767:
! 1768: yy_act = YY_STATE_EOF(YY_START);
! 1769: goto do_action;
! 1770: }
! 1771:
! 1772: else
! 1773: {
! 1774: if ( ! yyg->yy_did_buffer_switch_on_eof )
! 1775: YY_NEW_FILE;
! 1776: }
! 1777: break;
! 1778: }
! 1779:
! 1780: case EOB_ACT_CONTINUE_SCAN:
! 1781: yyg->yy_c_buf_p =
! 1782: yyg->yytext_ptr + yy_amount_of_matched_text;
! 1783:
! 1784: yy_current_state = yy_get_previous_state( yyscanner );
! 1785:
! 1786: yy_cp = yyg->yy_c_buf_p;
! 1787: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
! 1788: goto yy_match;
! 1789:
! 1790: case EOB_ACT_LAST_MATCH:
! 1791: yyg->yy_c_buf_p =
! 1792: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
! 1793:
! 1794: yy_current_state = yy_get_previous_state( yyscanner );
! 1795:
! 1796: yy_cp = yyg->yy_c_buf_p;
! 1797: yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
! 1798: goto yy_find_action;
! 1799: }
! 1800: break;
! 1801: }
! 1802:
! 1803: default:
! 1804: YY_FATAL_ERROR(
! 1805: "fatal flex scanner internal error--no action found" );
! 1806: } /* end of action switch */
! 1807: } /* end of scanning one token */
! 1808: } /* end of user's declarations */
! 1809: } /* end of yylex */
! 1810: /* %ok-for-header */
! 1811:
! 1812: /* %if-c++-only */
! 1813: /* %not-for-header */
! 1814: /* %ok-for-header */
! 1815:
! 1816: /* %endif */
! 1817:
! 1818: /* yy_get_next_buffer - try to read in a new buffer
! 1819: *
! 1820: * Returns a code representing an action:
! 1821: * EOB_ACT_LAST_MATCH -
! 1822: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
! 1823: * EOB_ACT_END_OF_FILE - end of file
! 1824: */
! 1825: /* %if-c-only */
! 1826: static int yy_get_next_buffer (yyscan_t yyscanner)
! 1827: /* %endif */
! 1828: /* %if-c++-only */
! 1829: /* %endif */
! 1830: {
! 1831: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 1832: char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
! 1833: char *source = yyg->yytext_ptr;
! 1834: int number_to_move, i;
! 1835: int ret_val;
! 1836:
! 1837: if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
! 1838: YY_FATAL_ERROR(
! 1839: "fatal flex scanner internal error--end of buffer missed" );
! 1840:
! 1841: if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
! 1842: { /* Don't try to fill the buffer, so this is an EOF. */
! 1843: if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
! 1844: {
! 1845: /* We matched a single character, the EOB, so
! 1846: * treat this as a final EOF.
! 1847: */
! 1848: return EOB_ACT_END_OF_FILE;
! 1849: }
! 1850:
! 1851: else
! 1852: {
! 1853: /* We matched some text prior to the EOB, first
! 1854: * process it.
! 1855: */
! 1856: return EOB_ACT_LAST_MATCH;
! 1857: }
! 1858: }
! 1859:
! 1860: /* Try to read more data. */
! 1861:
! 1862: /* First move last chars to start of buffer. */
! 1863: number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
! 1864:
! 1865: for ( i = 0; i < number_to_move; ++i )
! 1866: *(dest++) = *(source++);
! 1867:
! 1868: if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
! 1869: /* don't do the read, it's not guaranteed to return an EOF,
! 1870: * just force an EOF
! 1871: */
! 1872: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
! 1873:
! 1874: else
! 1875: {
! 1876: int num_to_read =
! 1877: YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
! 1878:
! 1879: while ( num_to_read <= 0 )
! 1880: { /* Not enough room in the buffer - grow it. */
! 1881:
! 1882: /* just a shorter name for the current buffer */
! 1883: YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
! 1884:
! 1885: int yy_c_buf_p_offset =
! 1886: (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
! 1887:
! 1888: if ( b->yy_is_our_buffer )
! 1889: {
! 1890: int new_size = b->yy_buf_size * 2;
! 1891:
! 1892: if ( new_size <= 0 )
! 1893: b->yy_buf_size += b->yy_buf_size / 8;
! 1894: else
! 1895: b->yy_buf_size *= 2;
! 1896:
! 1897: b->yy_ch_buf = (char *)
! 1898: /* Include room in for 2 EOB chars. */
! 1899: yyrealloc( (void *) b->yy_ch_buf,
! 1900: (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
! 1901: }
! 1902: else
! 1903: /* Can't grow it, we don't own it. */
! 1904: b->yy_ch_buf = NULL;
! 1905:
! 1906: if ( ! b->yy_ch_buf )
! 1907: YY_FATAL_ERROR(
! 1908: "fatal error - scanner input buffer overflow" );
! 1909:
! 1910: yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
! 1911:
! 1912: num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
! 1913: number_to_move - 1;
! 1914:
! 1915: }
! 1916:
! 1917: if ( num_to_read > YY_READ_BUF_SIZE )
! 1918: num_to_read = YY_READ_BUF_SIZE;
! 1919:
! 1920: /* Read in more data. */
! 1921: YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
! 1922: yyg->yy_n_chars, num_to_read );
! 1923:
! 1924: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
! 1925: }
! 1926:
! 1927: if ( yyg->yy_n_chars == 0 )
! 1928: {
! 1929: if ( number_to_move == YY_MORE_ADJ )
! 1930: {
! 1931: ret_val = EOB_ACT_END_OF_FILE;
! 1932: yyrestart( yyin , yyscanner);
! 1933: }
! 1934:
! 1935: else
! 1936: {
! 1937: ret_val = EOB_ACT_LAST_MATCH;
! 1938: YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
! 1939: YY_BUFFER_EOF_PENDING;
! 1940: }
! 1941: }
! 1942:
! 1943: else
! 1944: ret_val = EOB_ACT_CONTINUE_SCAN;
! 1945:
! 1946: if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
! 1947: /* Extend the array by 50%, plus the number we really need. */
! 1948: int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
! 1949: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
! 1950: (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
! 1951: if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
! 1952: YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
! 1953: /* "- 2" to take care of EOB's */
! 1954: YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
! 1955: }
! 1956:
! 1957: yyg->yy_n_chars += number_to_move;
! 1958: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
! 1959: YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
! 1960:
! 1961: yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
! 1962:
! 1963: return ret_val;
! 1964: }
! 1965:
! 1966: /* yy_get_previous_state - get the state just before the EOB char was reached */
! 1967:
! 1968: /* %if-c-only */
! 1969: /* %not-for-header */
! 1970: static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
! 1971: /* %endif */
! 1972: /* %if-c++-only */
! 1973: /* %endif */
! 1974: {
! 1975: yy_state_type yy_current_state;
! 1976: char *yy_cp;
! 1977: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 1978:
! 1979: /* %% [15.0] code to get the start state into yy_current_state goes here */
! 1980: yy_current_state = yyg->yy_start;
! 1981:
! 1982: for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
! 1983: {
! 1984: /* %% [16.0] code to find the next state goes here */
! 1985: YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
! 1986: if ( yy_accept[yy_current_state] )
! 1987: {
! 1988: yyg->yy_last_accepting_state = yy_current_state;
! 1989: yyg->yy_last_accepting_cpos = yy_cp;
! 1990: }
! 1991: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
! 1992: {
! 1993: yy_current_state = (int) yy_def[yy_current_state];
! 1994: if ( yy_current_state >= 85 )
! 1995: yy_c = yy_meta[yy_c];
! 1996: }
! 1997: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
! 1998: }
! 1999:
! 2000: return yy_current_state;
! 2001: }
! 2002:
! 2003: /* yy_try_NUL_trans - try to make a transition on the NUL character
! 2004: *
! 2005: * synopsis
! 2006: * next_state = yy_try_NUL_trans( current_state );
! 2007: */
! 2008: /* %if-c-only */
! 2009: static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
! 2010: /* %endif */
! 2011: /* %if-c++-only */
! 2012: /* %endif */
! 2013: {
! 2014: int yy_is_jam;
! 2015: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
! 2016: /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
! 2017: char *yy_cp = yyg->yy_c_buf_p;
! 2018:
! 2019: YY_CHAR yy_c = 1;
! 2020: if ( yy_accept[yy_current_state] )
! 2021: {
! 2022: yyg->yy_last_accepting_state = yy_current_state;
! 2023: yyg->yy_last_accepting_cpos = yy_cp;
! 2024: }
! 2025: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
! 2026: {
! 2027: yy_current_state = (int) yy_def[yy_current_state];
! 2028: if ( yy_current_state >= 85 )
! 2029: yy_c = yy_meta[yy_c];
! 2030: }
! 2031: yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
! 2032: yy_is_jam = (yy_current_state == 84);
! 2033:
! 2034: (void)yyg;
! 2035: return yy_is_jam ? 0 : yy_current_state;
! 2036: }
! 2037:
! 2038: #ifndef YY_NO_UNPUT
! 2039: /* %if-c-only */
! 2040:
! 2041: static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
! 2042: /* %endif */
! 2043: /* %if-c++-only */
! 2044: /* %endif */
! 2045: {
! 2046: char *yy_cp;
! 2047: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2048:
! 2049: yy_cp = yyg->yy_c_buf_p;
! 2050:
! 2051: /* undo effects of setting up yytext */
! 2052: *yy_cp = yyg->yy_hold_char;
! 2053:
! 2054: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
! 2055: { /* need to shift things up to make room */
! 2056: /* +2 for EOB chars. */
! 2057: int number_to_move = yyg->yy_n_chars + 2;
! 2058: char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
! 2059: YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
! 2060: char *source =
! 2061: &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
! 2062:
! 2063: while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
! 2064: *--dest = *--source;
! 2065:
! 2066: yy_cp += (int) (dest - source);
! 2067: yy_bp += (int) (dest - source);
! 2068: YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
! 2069: yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
! 2070:
! 2071: if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
! 2072: YY_FATAL_ERROR( "flex scanner push-back overflow" );
! 2073: }
! 2074:
! 2075: *--yy_cp = (char) c;
! 2076:
! 2077: /* %% [18.0] update yylineno here */
! 2078:
! 2079: if ( c == '\n' ){
! 2080: --yylineno;
! 2081: }
! 2082:
! 2083: yyg->yytext_ptr = yy_bp;
! 2084: yyg->yy_hold_char = *yy_cp;
! 2085: yyg->yy_c_buf_p = yy_cp;
! 2086: }
! 2087: /* %if-c-only */
! 2088:
! 2089: /* %endif */
! 2090: #endif
! 2091:
! 2092: /* %if-c-only */
! 2093: #ifndef YY_NO_INPUT
! 2094: #ifdef __cplusplus
! 2095: static int yyinput (yyscan_t yyscanner)
! 2096: #else
! 2097: static int input (yyscan_t yyscanner)
! 2098: #endif
! 2099:
! 2100: /* %endif */
! 2101: /* %if-c++-only */
! 2102: /* %endif */
! 2103: {
! 2104: int c;
! 2105: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2106:
! 2107: *yyg->yy_c_buf_p = yyg->yy_hold_char;
! 2108:
! 2109: if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
! 2110: {
! 2111: /* yy_c_buf_p now points to the character we want to return.
! 2112: * If this occurs *before* the EOB characters, then it's a
! 2113: * valid NUL; if not, then we've hit the end of the buffer.
! 2114: */
! 2115: if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
! 2116: /* This was really a NUL. */
! 2117: *yyg->yy_c_buf_p = '\0';
! 2118:
! 2119: else
! 2120: { /* need more input */
! 2121: int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
! 2122: ++yyg->yy_c_buf_p;
! 2123:
! 2124: switch ( yy_get_next_buffer( yyscanner ) )
! 2125: {
! 2126: case EOB_ACT_LAST_MATCH:
! 2127: /* This happens because yy_g_n_b()
! 2128: * sees that we've accumulated a
! 2129: * token and flags that we need to
! 2130: * try matching the token before
! 2131: * proceeding. But for input(),
! 2132: * there's no matching to consider.
! 2133: * So convert the EOB_ACT_LAST_MATCH
! 2134: * to EOB_ACT_END_OF_FILE.
! 2135: */
! 2136:
! 2137: /* Reset buffer status. */
! 2138: yyrestart( yyin , yyscanner);
! 2139:
! 2140: /*FALLTHROUGH*/
! 2141:
! 2142: case EOB_ACT_END_OF_FILE:
! 2143: {
! 2144: if ( yywrap( yyscanner ) )
! 2145: return 0;
! 2146:
! 2147: if ( ! yyg->yy_did_buffer_switch_on_eof )
! 2148: YY_NEW_FILE;
! 2149: #ifdef __cplusplus
! 2150: return yyinput(yyscanner);
! 2151: #else
! 2152: return input(yyscanner);
! 2153: #endif
! 2154: }
! 2155:
! 2156: case EOB_ACT_CONTINUE_SCAN:
! 2157: yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
! 2158: break;
! 2159: }
! 2160: }
! 2161: }
! 2162:
! 2163: c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
! 2164: *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
! 2165: yyg->yy_hold_char = *++yyg->yy_c_buf_p;
! 2166:
! 2167: /* %% [19.0] update BOL and yylineno */
! 2168: if ( c == '\n' )
! 2169:
! 2170: do{ yylineno++;
! 2171: yycolumn=0;
! 2172: }while(0)
! 2173: ;
! 2174:
! 2175: return c;
! 2176: }
! 2177: /* %if-c-only */
! 2178: #endif /* ifndef YY_NO_INPUT */
! 2179: /* %endif */
! 2180:
! 2181: /** Immediately switch to a different input stream.
! 2182: * @param input_file A readable stream.
! 2183: * @param yyscanner The scanner object.
! 2184: * @note This function does not reset the start condition to @c INITIAL .
! 2185: */
! 2186: /* %if-c-only */
! 2187: void yyrestart (FILE * input_file , yyscan_t yyscanner)
! 2188: /* %endif */
! 2189: /* %if-c++-only */
! 2190: /* %endif */
! 2191: {
! 2192: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2193:
! 2194: if ( ! YY_CURRENT_BUFFER ){
! 2195: yyensure_buffer_stack (yyscanner);
! 2196: YY_CURRENT_BUFFER_LVALUE =
! 2197: yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
! 2198: }
! 2199:
! 2200: yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
! 2201: yy_load_buffer_state( yyscanner );
! 2202: }
! 2203:
! 2204: /* %if-c++-only */
! 2205: /* %endif */
! 2206:
! 2207: /** Switch to a different input buffer.
! 2208: * @param new_buffer The new input buffer.
! 2209: * @param yyscanner The scanner object.
! 2210: */
! 2211: /* %if-c-only */
! 2212: void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
! 2213: /* %endif */
! 2214: /* %if-c++-only */
! 2215: /* %endif */
! 2216: {
! 2217: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2218:
! 2219: /* TODO. We should be able to replace this entire function body
! 2220: * with
! 2221: * yypop_buffer_state();
! 2222: * yypush_buffer_state(new_buffer);
! 2223: */
! 2224: yyensure_buffer_stack (yyscanner);
! 2225: if ( YY_CURRENT_BUFFER == new_buffer )
! 2226: return;
! 2227:
! 2228: if ( YY_CURRENT_BUFFER )
! 2229: {
! 2230: /* Flush out information for old buffer. */
! 2231: *yyg->yy_c_buf_p = yyg->yy_hold_char;
! 2232: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
! 2233: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
! 2234: }
! 2235:
! 2236: YY_CURRENT_BUFFER_LVALUE = new_buffer;
! 2237: yy_load_buffer_state( yyscanner );
! 2238:
! 2239: /* We don't actually know whether we did this switch during
! 2240: * EOF (yywrap()) processing, but the only time this flag
! 2241: * is looked at is after yywrap() is called, so it's safe
! 2242: * to go ahead and always set it.
! 2243: */
! 2244: yyg->yy_did_buffer_switch_on_eof = 1;
! 2245: }
! 2246:
! 2247: /* %if-c-only */
! 2248: static void yy_load_buffer_state (yyscan_t yyscanner)
! 2249: /* %endif */
! 2250: /* %if-c++-only */
! 2251: /* %endif */
! 2252: {
! 2253: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2254: yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
! 2255: yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
! 2256: /* %if-c-only */
! 2257: yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
! 2258: /* %endif */
! 2259: /* %if-c++-only */
! 2260: /* %endif */
! 2261: yyg->yy_hold_char = *yyg->yy_c_buf_p;
! 2262: }
! 2263:
! 2264: /** Allocate and initialize an input buffer state.
! 2265: * @param file A readable stream.
! 2266: * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
! 2267: * @param yyscanner The scanner object.
! 2268: * @return the allocated buffer state.
! 2269: */
! 2270: /* %if-c-only */
! 2271: YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
! 2272: /* %endif */
! 2273: /* %if-c++-only */
! 2274: /* %endif */
! 2275: {
! 2276: YY_BUFFER_STATE b;
! 2277:
! 2278: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
! 2279: if ( ! b )
! 2280: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
! 2281:
! 2282: b->yy_buf_size = size;
! 2283:
! 2284: /* yy_ch_buf has to be 2 characters longer than the size given because
! 2285: * we need to put in 2 end-of-buffer characters.
! 2286: */
! 2287: b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
! 2288: if ( ! b->yy_ch_buf )
! 2289: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
! 2290:
! 2291: b->yy_is_our_buffer = 1;
! 2292:
! 2293: yy_init_buffer( b, file , yyscanner);
! 2294:
! 2295: return b;
! 2296: }
! 2297:
! 2298: /* %if-c++-only */
! 2299: /* %endif */
! 2300:
! 2301: /** Destroy the buffer.
! 2302: * @param b a buffer created with yy_create_buffer()
! 2303: * @param yyscanner The scanner object.
! 2304: */
! 2305: /* %if-c-only */
! 2306: void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
! 2307: /* %endif */
! 2308: /* %if-c++-only */
! 2309: /* %endif */
! 2310: {
! 2311: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2312:
! 2313: if ( ! b )
! 2314: return;
! 2315:
! 2316: if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
! 2317: YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
! 2318:
! 2319: if ( b->yy_is_our_buffer )
! 2320: yyfree( (void *) b->yy_ch_buf , yyscanner );
! 2321:
! 2322: yyfree( (void *) b , yyscanner );
! 2323: }
! 2324:
! 2325: /* Initializes or reinitializes a buffer.
! 2326: * This function is sometimes called more than once on the same buffer,
! 2327: * such as during a yyrestart() or at EOF.
! 2328: */
! 2329: /* %if-c-only */
! 2330: static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
! 2331: /* %endif */
! 2332: /* %if-c++-only */
! 2333: /* %endif */
! 2334:
! 2335: {
! 2336: int oerrno = errno;
! 2337: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2338:
! 2339: yy_flush_buffer( b , yyscanner);
! 2340:
! 2341: /* %if-c-only */
! 2342: b->yy_input_file = file;
! 2343: /* %endif */
! 2344: /* %if-c++-only */
! 2345: /* %endif */
! 2346: b->yy_fill_buffer = 1;
! 2347:
! 2348: /* If b is the current buffer, then yy_init_buffer was _probably_
! 2349: * called from yyrestart() or through yy_get_next_buffer.
! 2350: * In that case, we don't want to reset the lineno or column.
! 2351: */
! 2352: if (b != YY_CURRENT_BUFFER){
! 2353: b->yy_bs_lineno = 1;
! 2354: b->yy_bs_column = 0;
! 2355: }
! 2356:
! 2357: /* %if-c-only */
! 2358:
! 2359: b->yy_is_interactive = 0;
! 2360:
! 2361: /* %endif */
! 2362: /* %if-c++-only */
! 2363: /* %endif */
! 2364: errno = oerrno;
! 2365: }
! 2366:
! 2367: /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
! 2368: * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
! 2369: * @param yyscanner The scanner object.
! 2370: */
! 2371: /* %if-c-only */
! 2372: void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
! 2373: /* %endif */
! 2374: /* %if-c++-only */
! 2375: /* %endif */
! 2376: {
! 2377: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2378: if ( ! b )
! 2379: return;
! 2380:
! 2381: b->yy_n_chars = 0;
! 2382:
! 2383: /* We always need two end-of-buffer characters. The first causes
! 2384: * a transition to the end-of-buffer state. The second causes
! 2385: * a jam in that state.
! 2386: */
! 2387: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
! 2388: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
! 2389:
! 2390: b->yy_buf_pos = &b->yy_ch_buf[0];
! 2391:
! 2392: b->yy_at_bol = 1;
! 2393: b->yy_buffer_status = YY_BUFFER_NEW;
! 2394:
! 2395: if ( b == YY_CURRENT_BUFFER )
! 2396: yy_load_buffer_state( yyscanner );
! 2397: }
! 2398:
! 2399: /* %if-c-or-c++ */
! 2400: /** Pushes the new state onto the stack. The new state becomes
! 2401: * the current state. This function will allocate the stack
! 2402: * if necessary.
! 2403: * @param new_buffer The new state.
! 2404: * @param yyscanner The scanner object.
! 2405: */
! 2406: /* %if-c-only */
! 2407: void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
! 2408: /* %endif */
! 2409: /* %if-c++-only */
! 2410: /* %endif */
! 2411: {
! 2412: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2413: if (new_buffer == NULL)
! 2414: return;
! 2415:
! 2416: yyensure_buffer_stack(yyscanner);
! 2417:
! 2418: /* This block is copied from yy_switch_to_buffer. */
! 2419: if ( YY_CURRENT_BUFFER )
! 2420: {
! 2421: /* Flush out information for old buffer. */
! 2422: *yyg->yy_c_buf_p = yyg->yy_hold_char;
! 2423: YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
! 2424: YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
! 2425: }
! 2426:
! 2427: /* Only push if top exists. Otherwise, replace top. */
! 2428: if (YY_CURRENT_BUFFER)
! 2429: yyg->yy_buffer_stack_top++;
! 2430: YY_CURRENT_BUFFER_LVALUE = new_buffer;
! 2431:
! 2432: /* copied from yy_switch_to_buffer. */
! 2433: yy_load_buffer_state( yyscanner );
! 2434: yyg->yy_did_buffer_switch_on_eof = 1;
! 2435: }
! 2436: /* %endif */
! 2437:
! 2438: /* %if-c-or-c++ */
! 2439: /** Removes and deletes the top of the stack, if present.
! 2440: * The next element becomes the new top.
! 2441: * @param yyscanner The scanner object.
! 2442: */
! 2443: /* %if-c-only */
! 2444: void yypop_buffer_state (yyscan_t yyscanner)
! 2445: /* %endif */
! 2446: /* %if-c++-only */
! 2447: /* %endif */
! 2448: {
! 2449: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2450: if (!YY_CURRENT_BUFFER)
! 2451: return;
! 2452:
! 2453: yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
! 2454: YY_CURRENT_BUFFER_LVALUE = NULL;
! 2455: if (yyg->yy_buffer_stack_top > 0)
! 2456: --yyg->yy_buffer_stack_top;
! 2457:
! 2458: if (YY_CURRENT_BUFFER) {
! 2459: yy_load_buffer_state( yyscanner );
! 2460: yyg->yy_did_buffer_switch_on_eof = 1;
! 2461: }
! 2462: }
! 2463: /* %endif */
! 2464:
! 2465: /* %if-c-or-c++ */
! 2466: /* Allocates the stack if it does not exist.
! 2467: * Guarantees space for at least one push.
! 2468: */
! 2469: /* %if-c-only */
! 2470: static void yyensure_buffer_stack (yyscan_t yyscanner)
! 2471: /* %endif */
! 2472: /* %if-c++-only */
! 2473: /* %endif */
! 2474: {
! 2475: yy_size_t num_to_alloc;
! 2476: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2477:
! 2478: if (!yyg->yy_buffer_stack) {
! 2479:
! 2480: /* First allocation is just for 2 elements, since we don't know if this
! 2481: * scanner will even need a stack. We use 2 instead of 1 to avoid an
! 2482: * immediate realloc on the next call.
! 2483: */
! 2484: num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
! 2485: yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
! 2486: (num_to_alloc * sizeof(struct yy_buffer_state*)
! 2487: , yyscanner);
! 2488: if ( ! yyg->yy_buffer_stack )
! 2489: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
! 2490:
! 2491: memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
! 2492:
! 2493: yyg->yy_buffer_stack_max = num_to_alloc;
! 2494: yyg->yy_buffer_stack_top = 0;
! 2495: return;
! 2496: }
! 2497:
! 2498: if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
! 2499:
! 2500: /* Increase the buffer to prepare for a possible push. */
! 2501: yy_size_t grow_size = 8 /* arbitrary grow size */;
! 2502:
! 2503: num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
! 2504: yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
! 2505: (yyg->yy_buffer_stack,
! 2506: num_to_alloc * sizeof(struct yy_buffer_state*)
! 2507: , yyscanner);
! 2508: if ( ! yyg->yy_buffer_stack )
! 2509: YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
! 2510:
! 2511: /* zero only the new slots.*/
! 2512: memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
! 2513: yyg->yy_buffer_stack_max = num_to_alloc;
! 2514: }
! 2515: }
! 2516: /* %endif */
! 2517:
! 2518: /* %if-c-only */
! 2519: /** Setup the input buffer state to scan directly from a user-specified character buffer.
! 2520: * @param base the character buffer
! 2521: * @param size the size in bytes of the character buffer
! 2522: * @param yyscanner The scanner object.
! 2523: * @return the newly allocated buffer state object.
! 2524: */
! 2525: YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
! 2526: {
! 2527: YY_BUFFER_STATE b;
! 2528:
! 2529: if ( size < 2 ||
! 2530: base[size-2] != YY_END_OF_BUFFER_CHAR ||
! 2531: base[size-1] != YY_END_OF_BUFFER_CHAR )
! 2532: /* They forgot to leave room for the EOB's. */
! 2533: return NULL;
! 2534:
! 2535: b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
! 2536: if ( ! b )
! 2537: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
! 2538:
! 2539: b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
! 2540: b->yy_buf_pos = b->yy_ch_buf = base;
! 2541: b->yy_is_our_buffer = 0;
! 2542: b->yy_input_file = NULL;
! 2543: b->yy_n_chars = b->yy_buf_size;
! 2544: b->yy_is_interactive = 0;
! 2545: b->yy_at_bol = 1;
! 2546: b->yy_fill_buffer = 0;
! 2547: b->yy_buffer_status = YY_BUFFER_NEW;
! 2548:
! 2549: yy_switch_to_buffer( b , yyscanner );
! 2550:
! 2551: return b;
! 2552: }
! 2553: /* %endif */
! 2554:
! 2555: /* %if-c-only */
! 2556: /** Setup the input buffer state to scan a string. The next call to yylex() will
! 2557: * scan from a @e copy of @a str.
! 2558: * @param yystr a NUL-terminated string to scan
! 2559: * @param yyscanner The scanner object.
! 2560: * @return the newly allocated buffer state object.
! 2561: * @note If you want to scan bytes that may contain NUL values, then use
! 2562: * yy_scan_bytes() instead.
! 2563: */
! 2564: YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
! 2565: {
! 2566:
! 2567: return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
! 2568: }
! 2569: /* %endif */
! 2570:
! 2571: /* %if-c-only */
! 2572: /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
! 2573: * scan from a @e copy of @a bytes.
! 2574: * @param yybytes the byte buffer to scan
! 2575: * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
! 2576: * @param yyscanner The scanner object.
! 2577: * @return the newly allocated buffer state object.
! 2578: */
! 2579: YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
! 2580: {
! 2581: YY_BUFFER_STATE b;
! 2582: char *buf;
! 2583: yy_size_t n;
! 2584: int i;
! 2585:
! 2586: /* Get memory for full buffer, including space for trailing EOB's. */
! 2587: n = (yy_size_t) (_yybytes_len + 2);
! 2588: buf = (char *) yyalloc( n , yyscanner );
! 2589: if ( ! buf )
! 2590: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
! 2591:
! 2592: for ( i = 0; i < _yybytes_len; ++i )
! 2593: buf[i] = yybytes[i];
! 2594:
! 2595: buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
! 2596:
! 2597: b = yy_scan_buffer( buf, n , yyscanner);
! 2598: if ( ! b )
! 2599: YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
! 2600:
! 2601: /* It's okay to grow etc. this buffer, and we should throw it
! 2602: * away when we're done.
! 2603: */
! 2604: b->yy_is_our_buffer = 1;
! 2605:
! 2606: return b;
! 2607: }
! 2608: /* %endif */
! 2609:
! 2610: /* %if-c-only */
! 2611: static void yy_push_state (int _new_state , yyscan_t yyscanner)
! 2612: /* %endif */
! 2613: /* %if-c++-only */
! 2614: /* %endif */
! 2615: {
! 2616: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2617: if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
! 2618: {
! 2619: yy_size_t new_size;
! 2620:
! 2621: yyg->yy_start_stack_depth += YY_START_STACK_INCR;
! 2622: new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int );
! 2623:
! 2624: if ( ! yyg->yy_start_stack )
! 2625: yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner );
! 2626:
! 2627: else
! 2628: yyg->yy_start_stack = (int *) yyrealloc(
! 2629: (void *) yyg->yy_start_stack, new_size , yyscanner );
! 2630:
! 2631: if ( ! yyg->yy_start_stack )
! 2632: YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
! 2633: }
! 2634:
! 2635: yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
! 2636:
! 2637: BEGIN(_new_state);
! 2638: }
! 2639:
! 2640: /* %if-c-only */
! 2641: static void yy_pop_state (yyscan_t yyscanner)
! 2642: /* %endif */
! 2643: /* %if-c++-only */
! 2644: /* %endif */
! 2645: {
! 2646: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2647: if ( --yyg->yy_start_stack_ptr < 0 )
! 2648: YY_FATAL_ERROR( "start-condition stack underflow" );
! 2649:
! 2650: BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
! 2651: }
! 2652:
! 2653: /* %if-c-only */
! 2654: static int yy_top_state (yyscan_t yyscanner)
! 2655: /* %endif */
! 2656: /* %if-c++-only */
! 2657: /* %endif */
! 2658: {
! 2659: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2660: return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
! 2661: }
! 2662:
! 2663: #ifndef YY_EXIT_FAILURE
! 2664: #define YY_EXIT_FAILURE 2
! 2665: #endif
! 2666:
! 2667: /* %if-c-only */
! 2668: static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
! 2669: {
! 2670: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2671: (void)yyg;
! 2672: fprintf( stderr, "%s\n", msg );
! 2673: exit( YY_EXIT_FAILURE );
! 2674: }
! 2675: /* %endif */
! 2676: /* %if-c++-only */
! 2677: /* %endif */
! 2678:
! 2679: /* Redefine yyless() so it works in section 3 code. */
! 2680:
! 2681: #undef yyless
! 2682: #define yyless(n) \
! 2683: do \
! 2684: { \
! 2685: /* Undo effects of setting up yytext. */ \
! 2686: int yyless_macro_arg = (n); \
! 2687: YY_LESS_LINENO(yyless_macro_arg);\
! 2688: yytext[yyleng] = yyg->yy_hold_char; \
! 2689: yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
! 2690: yyg->yy_hold_char = *yyg->yy_c_buf_p; \
! 2691: *yyg->yy_c_buf_p = '\0'; \
! 2692: yyleng = yyless_macro_arg; \
! 2693: } \
! 2694: while ( 0 )
! 2695:
! 2696: /* Accessor methods (get/set functions) to struct members. */
! 2697:
! 2698: /* %if-c-only */
! 2699: /* %if-reentrant */
! 2700:
! 2701: /** Get the user-defined data for this scanner.
! 2702: * @param yyscanner The scanner object.
! 2703: */
! 2704: YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
! 2705: {
! 2706: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2707: return yyextra;
! 2708: }
! 2709:
! 2710: /* %endif */
! 2711:
! 2712: /** Get the current line number.
! 2713: * @param yyscanner The scanner object.
! 2714: */
! 2715: int yyget_lineno (yyscan_t yyscanner)
! 2716: {
! 2717: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2718:
! 2719: if (! YY_CURRENT_BUFFER)
! 2720: return 0;
! 2721:
! 2722: return yylineno;
! 2723: }
! 2724:
! 2725: /** Get the current column number.
! 2726: * @param yyscanner The scanner object.
! 2727: */
! 2728: int yyget_column (yyscan_t yyscanner)
! 2729: {
! 2730: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2731:
! 2732: if (! YY_CURRENT_BUFFER)
! 2733: return 0;
! 2734:
! 2735: return yycolumn;
! 2736: }
! 2737:
! 2738: /** Get the input stream.
! 2739: * @param yyscanner The scanner object.
! 2740: */
! 2741: FILE *yyget_in (yyscan_t yyscanner)
! 2742: {
! 2743: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2744: return yyin;
! 2745: }
! 2746:
! 2747: /** Get the output stream.
! 2748: * @param yyscanner The scanner object.
! 2749: */
! 2750: FILE *yyget_out (yyscan_t yyscanner)
! 2751: {
! 2752: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2753: return yyout;
! 2754: }
! 2755:
! 2756: /** Get the length of the current token.
! 2757: * @param yyscanner The scanner object.
! 2758: */
! 2759: int yyget_leng (yyscan_t yyscanner)
! 2760: {
! 2761: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2762: return yyleng;
! 2763: }
! 2764:
! 2765: /** Get the current token.
! 2766: * @param yyscanner The scanner object.
! 2767: */
! 2768:
! 2769: char *yyget_text (yyscan_t yyscanner)
! 2770: {
! 2771: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2772: return yytext;
! 2773: }
! 2774:
! 2775: /* %if-reentrant */
! 2776:
! 2777: /** Set the user-defined data. This data is never touched by the scanner.
! 2778: * @param user_defined The data to be associated with this scanner.
! 2779: * @param yyscanner The scanner object.
! 2780: */
! 2781: void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
! 2782: {
! 2783: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2784: yyextra = user_defined ;
! 2785: }
! 2786:
! 2787: /* %endif */
! 2788:
! 2789: /** Set the current line number.
! 2790: * @param _line_number line number
! 2791: * @param yyscanner The scanner object.
! 2792: */
! 2793: void yyset_lineno (int _line_number , yyscan_t yyscanner)
! 2794: {
! 2795: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2796:
! 2797: /* lineno is only valid if an input buffer exists. */
! 2798: if (! YY_CURRENT_BUFFER )
! 2799: YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
! 2800:
! 2801: yylineno = _line_number;
! 2802: }
! 2803:
! 2804: /** Set the current column.
! 2805: * @param _column_no column number
! 2806: * @param yyscanner The scanner object.
! 2807: */
! 2808: void yyset_column (int _column_no , yyscan_t yyscanner)
! 2809: {
! 2810: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2811:
! 2812: /* column is only valid if an input buffer exists. */
! 2813: if (! YY_CURRENT_BUFFER )
! 2814: YY_FATAL_ERROR( "yyset_column called with no buffer" );
! 2815:
! 2816: yycolumn = _column_no;
! 2817: }
! 2818:
! 2819: /** Set the input stream. This does not discard the current
! 2820: * input buffer.
! 2821: * @param _in_str A readable stream.
! 2822: * @param yyscanner The scanner object.
! 2823: * @see yy_switch_to_buffer
! 2824: */
! 2825: void yyset_in (FILE * _in_str , yyscan_t yyscanner)
! 2826: {
! 2827: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2828: yyin = _in_str ;
! 2829: }
! 2830:
! 2831: void yyset_out (FILE * _out_str , yyscan_t yyscanner)
! 2832: {
! 2833: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2834: yyout = _out_str ;
! 2835: }
! 2836:
! 2837: int yyget_debug (yyscan_t yyscanner)
! 2838: {
! 2839: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2840: return yy_flex_debug;
! 2841: }
! 2842:
! 2843: void yyset_debug (int _bdebug , yyscan_t yyscanner)
! 2844: {
! 2845: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2846: yy_flex_debug = _bdebug ;
! 2847: }
! 2848:
! 2849: /* %endif */
! 2850:
! 2851: /* %if-reentrant */
! 2852: /* Accessor methods for yylval and yylloc */
! 2853:
! 2854: /* %if-bison-bridge */
! 2855:
! 2856: YYSTYPE * yyget_lval (yyscan_t yyscanner)
! 2857: {
! 2858: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2859: return yylval;
! 2860: }
! 2861:
! 2862: void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
! 2863: {
! 2864: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2865: yylval = yylval_param;
! 2866: }
! 2867:
! 2868: /* %endif */
! 2869:
! 2870: /* User-visible API */
! 2871:
! 2872: /* yylex_init is special because it creates the scanner itself, so it is
! 2873: * the ONLY reentrant function that doesn't take the scanner as the last argument.
! 2874: * That's why we explicitly handle the declaration, instead of using our macros.
! 2875: */
! 2876: int yylex_init(yyscan_t* ptr_yy_globals)
! 2877: {
! 2878: if (ptr_yy_globals == NULL){
! 2879: errno = EINVAL;
! 2880: return 1;
! 2881: }
! 2882:
! 2883: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
! 2884:
! 2885: if (*ptr_yy_globals == NULL){
! 2886: errno = ENOMEM;
! 2887: return 1;
! 2888: }
! 2889:
! 2890: /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
! 2891: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
! 2892:
! 2893: return yy_init_globals ( *ptr_yy_globals );
! 2894: }
! 2895:
! 2896: /* yylex_init_extra has the same functionality as yylex_init, but follows the
! 2897: * convention of taking the scanner as the last argument. Note however, that
! 2898: * this is a *pointer* to a scanner, as it will be allocated by this call (and
! 2899: * is the reason, too, why this function also must handle its own declaration).
! 2900: * The user defined value in the first argument will be available to yyalloc in
! 2901: * the yyextra field.
! 2902: */
! 2903: int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
! 2904: {
! 2905: struct yyguts_t dummy_yyguts;
! 2906:
! 2907: yyset_extra (yy_user_defined, &dummy_yyguts);
! 2908:
! 2909: if (ptr_yy_globals == NULL){
! 2910: errno = EINVAL;
! 2911: return 1;
! 2912: }
! 2913:
! 2914: *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
! 2915:
! 2916: if (*ptr_yy_globals == NULL){
! 2917: errno = ENOMEM;
! 2918: return 1;
! 2919: }
! 2920:
! 2921: /* By setting to 0xAA, we expose bugs in
! 2922: yy_init_globals. Leave at 0x00 for releases. */
! 2923: memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
! 2924:
! 2925: yyset_extra (yy_user_defined, *ptr_yy_globals);
! 2926:
! 2927: return yy_init_globals ( *ptr_yy_globals );
! 2928: }
! 2929:
! 2930: /* %endif if-c-only */
! 2931:
! 2932: /* %if-c-only */
! 2933: static int yy_init_globals (yyscan_t yyscanner)
! 2934: {
! 2935: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2936: /* Initialization is the same as for the non-reentrant scanner.
! 2937: * This function is called from yylex_destroy(), so don't allocate here.
! 2938: */
! 2939:
! 2940: yyg->yy_buffer_stack = NULL;
! 2941: yyg->yy_buffer_stack_top = 0;
! 2942: yyg->yy_buffer_stack_max = 0;
! 2943: yyg->yy_c_buf_p = NULL;
! 2944: yyg->yy_init = 0;
! 2945: yyg->yy_start = 0;
! 2946:
! 2947: yyg->yy_start_stack_ptr = 0;
! 2948: yyg->yy_start_stack_depth = 0;
! 2949: yyg->yy_start_stack = NULL;
! 2950:
! 2951: /* Defined in main.c */
! 2952: #ifdef YY_STDINIT
! 2953: yyin = stdin;
! 2954: yyout = stdout;
! 2955: #else
! 2956: yyin = NULL;
! 2957: yyout = NULL;
! 2958: #endif
! 2959:
! 2960: /* For future reference: Set errno on error, since we are called by
! 2961: * yylex_init()
! 2962: */
! 2963: return 0;
! 2964: }
! 2965: /* %endif */
! 2966:
! 2967: /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
! 2968: /* yylex_destroy is for both reentrant and non-reentrant scanners. */
! 2969: int yylex_destroy (yyscan_t yyscanner)
! 2970: {
! 2971: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 2972:
! 2973: /* Pop the buffer stack, destroying each element. */
! 2974: while(YY_CURRENT_BUFFER){
! 2975: yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
! 2976: YY_CURRENT_BUFFER_LVALUE = NULL;
! 2977: yypop_buffer_state(yyscanner);
! 2978: }
! 2979:
! 2980: /* Destroy the stack itself. */
! 2981: yyfree(yyg->yy_buffer_stack , yyscanner);
! 2982: yyg->yy_buffer_stack = NULL;
! 2983:
! 2984: /* Destroy the start condition stack. */
! 2985: yyfree( yyg->yy_start_stack , yyscanner );
! 2986: yyg->yy_start_stack = NULL;
! 2987:
! 2988: /* Reset the globals. This is important in a non-reentrant scanner so the next time
! 2989: * yylex() is called, initialization will occur. */
! 2990: yy_init_globals( yyscanner);
! 2991:
! 2992: /* %if-reentrant */
! 2993: /* Destroy the main struct (reentrant only). */
! 2994: yyfree ( yyscanner , yyscanner );
! 2995: yyscanner = NULL;
! 2996: /* %endif */
! 2997: return 0;
! 2998: }
! 2999: /* %endif */
! 3000:
! 3001: /*
! 3002: * Internal utility routines.
! 3003: */
! 3004:
! 3005: #ifndef yytext_ptr
! 3006: static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
! 3007: {
! 3008: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 3009: (void)yyg;
! 3010:
! 3011: int i;
! 3012: for ( i = 0; i < n; ++i )
! 3013: s1[i] = s2[i];
! 3014: }
! 3015: #endif
! 3016:
! 3017: #ifdef YY_NEED_STRLEN
! 3018: static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
! 3019: {
! 3020: int n;
! 3021: for ( n = 0; s[n]; ++n )
! 3022: ;
! 3023:
! 3024: return n;
! 3025: }
! 3026: #endif
! 3027:
! 3028: void *yyalloc (yy_size_t size , yyscan_t yyscanner)
! 3029: {
! 3030: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 3031: (void)yyg;
! 3032: return malloc(size);
! 3033: }
! 3034:
! 3035: void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
! 3036: {
! 3037: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 3038: (void)yyg;
! 3039:
! 3040: /* The cast to (char *) in the following accommodates both
! 3041: * implementations that use char* generic pointers, and those
! 3042: * that use void* generic pointers. It works with the latter
! 3043: * because both ANSI C and C++ allow castless assignment from
! 3044: * any pointer type to void*, and deal with argument conversions
! 3045: * as though doing an assignment.
! 3046: */
! 3047: return realloc(ptr, size);
! 3048: }
! 3049:
! 3050: void yyfree (void * ptr , yyscan_t yyscanner)
! 3051: {
! 3052: struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
! 3053: (void)yyg;
! 3054: free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
! 3055: }
! 3056:
! 3057: /* %if-tables-serialization definitions */
! 3058: /* %define-yytables The name for this specific scanner's tables. */
! 3059: #define YYTABLES_NAME "yytables"
! 3060: /* %endif */
! 3061:
! 3062: /* %ok-for-header */
! 3063:
! 3064: #line 241 "settings/settings_lexer.l"
! 3065:
! 3066:
! 3067: /**
! 3068: * Open the next file, if any is queued and readable, otherwise returns FALSE.
! 3069: */
! 3070: bool settings_parser_open_next_file(parser_helper_t *ctx)
! 3071: {
! 3072: FILE *file;
! 3073:
! 3074: file = ctx->file_next(ctx);
! 3075: if (!file)
! 3076: {
! 3077: return FALSE;
! 3078: }
! 3079:
! 3080: settings_parser_set_in(file, ctx->scanner);
! 3081: settings_parser_push_buffer_state(
! 3082: settings_parser__create_buffer(file, YY_BUF_SIZE,
! 3083: ctx->scanner), ctx->scanner);
! 3084: return TRUE;
! 3085: }
! 3086:
! 3087: /**
! 3088: * Assumes that the file pattern to include is currently stored as string on
! 3089: * the helper object.
! 3090: */
! 3091: static void include_files(parser_helper_t *ctx)
! 3092: {
! 3093: char *pattern = ctx->string_get(ctx);
! 3094:
! 3095: ctx->file_include(ctx, pattern);
! 3096: free(pattern);
! 3097:
! 3098: settings_parser_open_next_file(ctx);
! 3099: }
! 3100:
! 3101: /**
! 3102: * Load the given string to be parsed next
! 3103: */
! 3104: void settings_parser_load_string(parser_helper_t *ctx, const char *content)
! 3105: {
! 3106: settings_parser__scan_string(content, ctx->scanner);
! 3107: }
! 3108:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to settings_lexer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / settings