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