1 #line 2 "route/pktloc_grammar.c" 3 #line 4 "route/pktloc_grammar.c" 5 #define YY_INT_ALIGNED short int 10 #define YY_FLEX_MAJOR_VERSION 2 11 #define YY_FLEX_MINOR_VERSION 6 12 #define YY_FLEX_SUBMINOR_VERSION 0 13 #if YY_FLEX_SUBMINOR_VERSION > 0 34 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 39 #ifndef __STDC_LIMIT_MACROS 40 #define __STDC_LIMIT_MACROS 1 44 typedef int8_t flex_int8_t;
45 typedef uint8_t flex_uint8_t;
46 typedef int16_t flex_int16_t;
47 typedef uint16_t flex_uint16_t;
48 typedef int32_t flex_int32_t;
49 typedef uint32_t flex_uint32_t;
51 typedef signed char flex_int8_t;
52 typedef short int flex_int16_t;
53 typedef int flex_int32_t;
54 typedef unsigned char flex_uint8_t;
55 typedef unsigned short int flex_uint16_t;
56 typedef unsigned int flex_uint32_t;
60 #define INT8_MIN (-128) 63 #define INT16_MIN (-32767-1) 66 #define INT32_MIN (-2147483647-1) 69 #define INT8_MAX (127) 72 #define INT16_MAX (32767) 75 #define INT32_MAX (2147483647) 78 #define UINT8_MAX (255U) 81 #define UINT16_MAX (65535U) 84 #define UINT32_MAX (4294967295U) 99 #if defined (__STDC__) 107 #define yyconst const 120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 123 #ifndef YY_TYPEDEF_YY_SCANNER_T 124 #define YY_TYPEDEF_YY_SCANNER_T 125 typedef void* yyscan_t;
130 #define yyin yyg->yyin_r 131 #define yyout yyg->yyout_r 132 #define yyextra yyg->yyextra_r 133 #define yyleng yyg->yyleng_r 134 #define yytext yyg->yytext_r 135 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) 136 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) 137 #define yy_flex_debug yyg->yy_flex_debug_r 143 #define BEGIN yyg->yy_start = 1 + 2 * 149 #define YY_START ((yyg->yy_start - 1) / 2) 150 #define YYSTATE YY_START 153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 156 #define YY_NEW_FILE pktloc_restart(yyin ,yyscanner ) 158 #define YY_END_OF_BUFFER_CHAR 0 167 #define YY_BUF_SIZE 32768 169 #define YY_BUF_SIZE 16384 175 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 177 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 178 #define YY_TYPEDEF_YY_BUFFER_STATE 182 #ifndef YY_TYPEDEF_YY_SIZE_T 183 #define YY_TYPEDEF_YY_SIZE_T 184 typedef size_t yy_size_t;
187 #define EOB_ACT_CONTINUE_SCAN 0 188 #define EOB_ACT_END_OF_FILE 1 189 #define EOB_ACT_LAST_MATCH 2 191 #define YY_LESS_LINENO(n) 192 #define YY_LINENO_REWIND_TO(ptr) 199 yy_size_t yyless_macro_arg = (n); \ 200 YY_LESS_LINENO(yyless_macro_arg);\ 201 *yy_cp = yyg->yy_hold_char; \ 202 YY_RESTORE_YY_MORE_OFFSET \ 203 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 204 YY_DO_BEFORE_ACTION; \ 208 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) 210 #ifndef YY_STRUCT_YY_BUFFER_STATE 211 #define YY_STRUCT_YY_BUFFER_STATE 222 yy_size_t yy_buf_size;
227 yy_size_t yy_n_chars;
233 int yy_is_our_buffer;
240 int yy_is_interactive;
256 int yy_buffer_status;
258 #define YY_BUFFER_NEW 0 259 #define YY_BUFFER_NORMAL 1 270 #define YY_BUFFER_EOF_PENDING 2 281 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ 282 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ 288 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] 290 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
291 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
292 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
293 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
294 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
295 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
296 void pktloc_pop_buffer_state (yyscan_t yyscanner );
298 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
299 static void pktloc__load_buffer_state (yyscan_t yyscanner );
300 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
302 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner) 304 YY_BUFFER_STATE pktloc__scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
305 YY_BUFFER_STATE pktloc__scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
306 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char *bytes,yy_size_t len ,yyscan_t yyscanner );
308 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
309 void *pktloc_realloc (
void *,yy_size_t ,yyscan_t yyscanner );
310 void pktloc_free (
void * ,yyscan_t yyscanner );
312 #define yy_new_buffer pktloc__create_buffer 314 #define yy_set_interactive(is_interactive) \ 316 if ( ! YY_CURRENT_BUFFER ){ \ 317 pktloc_ensure_buffer_stack (yyscanner); \ 318 YY_CURRENT_BUFFER_LVALUE = \ 319 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 321 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 324 #define yy_set_bol(at_bol) \ 326 if ( ! YY_CURRENT_BUFFER ){\ 327 pktloc_ensure_buffer_stack (yyscanner); \ 328 YY_CURRENT_BUFFER_LVALUE = \ 329 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 331 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 334 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 336 #define pktloc_wrap(yyscanner) (1) 337 #define YY_SKIP_YYWRAP 339 typedef unsigned char YY_CHAR;
341 typedef int yy_state_type;
343 #define yytext_ptr yytext_r 345 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
346 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
347 static int yy_get_next_buffer (yyscan_t yyscanner );
348 #if defined(__GNUC__) && __GNUC__ >= 3 349 __attribute__((__noreturn__))
351 static void yy_fatal_error (yyconst
char msg[] ,yyscan_t yyscanner );
356 #define YY_DO_BEFORE_ACTION \ 357 yyg->yytext_ptr = yy_bp; \ 358 yyleng = (size_t) (yy_cp - yy_bp); \ 359 yyg->yy_hold_char = *yy_cp; \ 361 yyg->yy_c_buf_p = yy_cp; 363 #define YY_NUM_RULES 16 364 #define YY_END_OF_BUFFER 17 369 flex_int32_t yy_verify;
372 static yyconst flex_int16_t yy_accept[47] =
374 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
375 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
376 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
377 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
378 15, 15, 15, 15, 13, 0
381 static yyconst YY_CHAR yy_ec[256] =
383 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
384 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
387 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
388 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
389 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
390 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
391 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
392 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
394 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
395 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413 static yyconst YY_CHAR yy_meta[29] =
415 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1
420 static yyconst flex_uint16_t yy_base[50] =
422 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
423 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
424 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
425 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
426 30, 29, 26, 18, 0, 87, 31, 68, 70
429 static yyconst flex_int16_t yy_def[50] =
431 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
432 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
433 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
434 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
435 47, 47, 47, 47, 47, 0, 46, 46, 46
438 static yyconst flex_uint16_t yy_nxt[116] =
440 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
441 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
442 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
443 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
444 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
445 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
446 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
447 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
448 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
449 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
451 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
455 static yyconst flex_int16_t yy_chk[116] =
457 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
459 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
460 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
461 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
462 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
463 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
464 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
465 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
466 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
468 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
475 #define REJECT reject_used_but_not_detected 476 #define yymore() yymore_used_but_not_detected 477 #define YY_MORE_ADJ 0 478 #define YY_RESTORE_YY_MORE_OFFSET 479 #line 1 "route/pktloc_grammar.l" 480 #line 2 "route/pktloc_grammar.l" 481 #include <netlink-private/netlink.h> 482 #include <netlink-private/tc.h> 483 #include <netlink/netlink.h> 484 #include <netlink/utils.h> 485 #include <netlink/route/pktloc.h> 486 #include "pktloc_syntax.h" 487 #define YY_NO_INPUT 1 488 #line 489 "route/pktloc_grammar.c" 492 #ifndef YY_NO_UNISTD_H 500 #ifndef YY_EXTRA_TYPE 501 #define YY_EXTRA_TYPE void * 509 YY_EXTRA_TYPE yyextra_r;
512 FILE *yyin_r, *yyout_r;
513 size_t yy_buffer_stack_top;
514 size_t yy_buffer_stack_max;
515 YY_BUFFER_STATE * yy_buffer_stack;
517 yy_size_t yy_n_chars;
522 int yy_did_buffer_switch_on_eof;
523 int yy_start_stack_ptr;
524 int yy_start_stack_depth;
526 yy_state_type yy_last_accepting_state;
527 char* yy_last_accepting_cpos;
542 static int yy_init_globals (yyscan_t yyscanner );
546 # define yylval yyg->yylval_r 548 # define yylloc yyg->yylloc_r 550 int pktloc_lex_init (yyscan_t* scanner);
552 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
557 int pktloc_lex_destroy (yyscan_t yyscanner );
559 int pktloc_get_debug (yyscan_t yyscanner );
561 void pktloc_set_debug (
int debug_flag ,yyscan_t yyscanner );
563 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
565 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
567 FILE *pktloc_get_in (yyscan_t yyscanner );
569 void pktloc_set_in (FILE * _in_str ,yyscan_t yyscanner );
571 FILE *pktloc_get_out (yyscan_t yyscanner );
573 void pktloc_set_out (FILE * _out_str ,yyscan_t yyscanner );
575 yy_size_t pktloc_get_leng (yyscan_t yyscanner );
577 char *pktloc_get_text (yyscan_t yyscanner );
579 int pktloc_get_lineno (yyscan_t yyscanner );
581 void pktloc_set_lineno (
int _line_number ,yyscan_t yyscanner );
583 int pktloc_get_column (yyscan_t yyscanner );
585 void pktloc_set_column (
int _column_no ,yyscan_t yyscanner );
587 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
589 void pktloc_set_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
591 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
593 void pktloc_set_lloc (
YYLTYPE * yylloc_param ,yyscan_t yyscanner );
599 #ifndef YY_SKIP_YYWRAP 601 extern "C" int pktloc_wrap (yyscan_t yyscanner );
603 extern int pktloc_wrap (yyscan_t yyscanner );
612 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
615 #ifdef YY_NEED_STRLEN 616 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
622 static int yyinput (yyscan_t yyscanner );
624 static int input (yyscan_t yyscanner );
630 #ifndef YY_READ_BUF_SIZE 633 #define YY_READ_BUF_SIZE 16384 635 #define YY_READ_BUF_SIZE 8192 644 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 651 #define YY_INPUT(buf,result,max_size) \ 652 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 656 for ( n = 0; n < max_size && \ 657 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 660 buf[n++] = (char) c; \ 661 if ( c == EOF && ferror( yyin ) ) \ 662 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 668 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 670 if( errno != EINTR) \ 672 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 688 #define yyterminate() return YY_NULL 692 #ifndef YY_START_STACK_INCR 693 #define YY_START_STACK_INCR 25 697 #ifndef YY_FATAL_ERROR 698 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) 707 #define YY_DECL_IS_OURS 1 709 extern int pktloc_lex \
710 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
712 #define YY_DECL int pktloc_lex \ 713 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) 719 #ifndef YY_USER_ACTION 720 #define YY_USER_ACTION 725 #define YY_BREAK break; 728 #define YY_RULE_SETUP \ 735 yy_state_type yy_current_state;
740 yylval = yylval_param;
742 yylloc = yylloc_param;
752 if ( ! yyg->yy_start )
761 if ( ! YY_CURRENT_BUFFER ) {
762 pktloc_ensure_buffer_stack (yyscanner);
763 YY_CURRENT_BUFFER_LVALUE =
764 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
767 pktloc__load_buffer_state(yyscanner );
771 #line 20 "route/pktloc_grammar.l" 774 #line 775 "route/pktloc_grammar.c" 778 yy_cp = yyg->yy_c_buf_p;
781 *yy_cp = yyg->yy_hold_char;
788 yy_current_state = yyg->yy_start;
792 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
793 if ( yy_accept[yy_current_state] )
795 yyg->yy_last_accepting_state = yy_current_state;
796 yyg->yy_last_accepting_cpos = yy_cp;
798 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
800 yy_current_state = (int) yy_def[yy_current_state];
801 if ( yy_current_state >= 47 )
802 yy_c = yy_meta[(
unsigned int) yy_c];
804 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
807 while ( yy_base[yy_current_state] != 87 );
810 yy_act = yy_accept[yy_current_state];
813 yy_cp = yyg->yy_last_accepting_cpos;
814 yy_current_state = yyg->yy_last_accepting_state;
815 yy_act = yy_accept[yy_current_state];
826 *yy_cp = yyg->yy_hold_char;
827 yy_cp = yyg->yy_last_accepting_cpos;
828 yy_current_state = yyg->yy_last_accepting_state;
834 #line 22 "route/pktloc_grammar.l" 839 #line 24 "route/pktloc_grammar.l" 843 #line 27 "route/pktloc_grammar.l" 846 #line 27 "route/pktloc_grammar.l" 848 yylval->i = strtoul(yytext, NULL, 0);
854 #line 32 "route/pktloc_grammar.l" 855 {
return yylval->i = yytext[0]; }
859 #line 34 "route/pktloc_grammar.l" 860 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
864 #line 35 "route/pktloc_grammar.l" 865 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
869 #line 36 "route/pktloc_grammar.l" 870 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
873 #line 39 "route/pktloc_grammar.l" 876 #line 39 "route/pktloc_grammar.l" 877 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
880 #line 41 "route/pktloc_grammar.l" 883 #line 41 "route/pktloc_grammar.l" 884 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
887 #line 43 "route/pktloc_grammar.l" 890 #line 43 "route/pktloc_grammar.l" 891 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
895 #line 46 "route/pktloc_grammar.l" 897 yylval->s = strdup(yytext);
898 if (yylval->s == NULL)
905 #line 52 "route/pktloc_grammar.l" 908 #line 909 "route/pktloc_grammar.c" 909 case YY_STATE_EOF(INITIAL):
912 case YY_END_OF_BUFFER:
915 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
918 *yy_cp = yyg->yy_hold_char;
919 YY_RESTORE_YY_MORE_OFFSET
921 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
932 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
933 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
934 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
944 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
946 yy_state_type yy_next_state;
948 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
950 yy_current_state = yy_get_previous_state( yyscanner );
961 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
963 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
968 yy_cp = ++yyg->yy_c_buf_p;
969 yy_current_state = yy_next_state;
975 yy_cp = yyg->yy_c_buf_p;
980 else switch ( yy_get_next_buffer( yyscanner ) )
982 case EOB_ACT_END_OF_FILE:
984 yyg->yy_did_buffer_switch_on_eof = 0;
986 if ( pktloc_wrap(yyscanner ) )
997 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
999 yy_act = YY_STATE_EOF(YY_START);
1005 if ( ! yyg->yy_did_buffer_switch_on_eof )
1011 case EOB_ACT_CONTINUE_SCAN:
1013 yyg->yytext_ptr + yy_amount_of_matched_text;
1015 yy_current_state = yy_get_previous_state( yyscanner );
1017 yy_cp = yyg->yy_c_buf_p;
1018 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1021 case EOB_ACT_LAST_MATCH:
1023 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1025 yy_current_state = yy_get_previous_state( yyscanner );
1027 yy_cp = yyg->yy_c_buf_p;
1028 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1029 goto yy_find_action;
1036 "fatal flex scanner internal error--no action found" );
1049 static int yy_get_next_buffer (yyscan_t yyscanner)
1052 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1053 char *source = yyg->yytext_ptr;
1054 yy_size_t number_to_move, i;
1057 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1059 "fatal flex scanner internal error--end of buffer missed" );
1061 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1063 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1068 return EOB_ACT_END_OF_FILE;
1076 return EOB_ACT_LAST_MATCH;
1083 number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1085 for ( i = 0; i < number_to_move; ++i )
1086 *(dest++) = *(source++);
1088 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1092 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1097 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1099 while ( num_to_read <= 0 )
1103 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1105 int yy_c_buf_p_offset =
1106 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1108 if ( b->yy_is_our_buffer )
1110 yy_size_t new_size = b->yy_buf_size * 2;
1112 if ( new_size <= 0 )
1113 b->yy_buf_size += b->yy_buf_size / 8;
1115 b->yy_buf_size *= 2;
1117 b->yy_ch_buf = (
char *)
1119 pktloc_realloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1125 if ( ! b->yy_ch_buf )
1127 "fatal error - scanner input buffer overflow" );
1129 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1131 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1136 if ( num_to_read > YY_READ_BUF_SIZE )
1137 num_to_read = YY_READ_BUF_SIZE;
1140 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1141 yyg->yy_n_chars, num_to_read );
1143 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1146 if ( yyg->yy_n_chars == 0 )
1148 if ( number_to_move == YY_MORE_ADJ )
1150 ret_val = EOB_ACT_END_OF_FILE;
1151 pktloc_restart(yyin ,yyscanner);
1156 ret_val = EOB_ACT_LAST_MATCH;
1157 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1158 YY_BUFFER_EOF_PENDING;
1163 ret_val = EOB_ACT_CONTINUE_SCAN;
1165 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1167 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1168 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1169 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1170 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1173 yyg->yy_n_chars += number_to_move;
1174 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1175 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1177 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1184 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1186 yy_state_type yy_current_state;
1190 yy_current_state = yyg->yy_start;
1192 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1194 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1195 if ( yy_accept[yy_current_state] )
1197 yyg->yy_last_accepting_state = yy_current_state;
1198 yyg->yy_last_accepting_cpos = yy_cp;
1200 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1202 yy_current_state = (int) yy_def[yy_current_state];
1203 if ( yy_current_state >= 47 )
1204 yy_c = yy_meta[(
unsigned int) yy_c];
1206 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1209 return yy_current_state;
1217 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1221 char *yy_cp = yyg->yy_c_buf_p;
1224 if ( yy_accept[yy_current_state] )
1226 yyg->yy_last_accepting_state = yy_current_state;
1227 yyg->yy_last_accepting_cpos = yy_cp;
1229 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1231 yy_current_state = (int) yy_def[yy_current_state];
1232 if ( yy_current_state >= 47 )
1233 yy_c = yy_meta[(
unsigned int) yy_c];
1235 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1236 yy_is_jam = (yy_current_state == 46);
1239 return yy_is_jam ? 0 : yy_current_state;
1248 static int yyinput (yyscan_t yyscanner)
1250 static int input (yyscan_t yyscanner)
1257 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1259 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1265 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1267 *yyg->yy_c_buf_p =
'\0';
1271 yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1274 switch ( yy_get_next_buffer( yyscanner ) )
1276 case EOB_ACT_LAST_MATCH:
1288 pktloc_restart(yyin ,yyscanner);
1292 case EOB_ACT_END_OF_FILE:
1294 if ( pktloc_wrap(yyscanner ) )
1297 if ( ! yyg->yy_did_buffer_switch_on_eof )
1300 return yyinput(yyscanner);
1302 return input(yyscanner);
1306 case EOB_ACT_CONTINUE_SCAN:
1307 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1313 c = *(
unsigned char *) yyg->yy_c_buf_p;
1314 *yyg->yy_c_buf_p =
'\0';
1315 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1326 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1330 if ( ! YY_CURRENT_BUFFER ){
1331 pktloc_ensure_buffer_stack (yyscanner);
1332 YY_CURRENT_BUFFER_LVALUE =
1333 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1336 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1337 pktloc__load_buffer_state(yyscanner );
1344 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1353 pktloc_ensure_buffer_stack (yyscanner);
1354 if ( YY_CURRENT_BUFFER == new_buffer )
1357 if ( YY_CURRENT_BUFFER )
1360 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1361 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1362 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1365 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1366 pktloc__load_buffer_state(yyscanner );
1373 yyg->yy_did_buffer_switch_on_eof = 1;
1376 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1379 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1380 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1381 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1382 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1391 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1395 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1397 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1399 b->yy_buf_size = (yy_size_t)size;
1404 b->yy_ch_buf = (
char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
1405 if ( ! b->yy_ch_buf )
1406 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1408 b->yy_is_our_buffer = 1;
1410 pktloc__init_buffer(b,file ,yyscanner);
1419 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1426 if ( b == YY_CURRENT_BUFFER )
1427 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1429 if ( b->yy_is_our_buffer )
1430 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1432 pktloc_free((
void *) b ,yyscanner );
1439 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1445 pktloc__flush_buffer(b ,yyscanner);
1447 b->yy_input_file = file;
1448 b->yy_fill_buffer = 1;
1454 if (b != YY_CURRENT_BUFFER){
1459 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1468 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1480 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1481 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1483 b->yy_buf_pos = &b->yy_ch_buf[0];
1486 b->yy_buffer_status = YY_BUFFER_NEW;
1488 if ( b == YY_CURRENT_BUFFER )
1489 pktloc__load_buffer_state(yyscanner );
1498 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1501 if (new_buffer == NULL)
1504 pktloc_ensure_buffer_stack(yyscanner);
1507 if ( YY_CURRENT_BUFFER )
1510 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1511 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1512 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1516 if (YY_CURRENT_BUFFER)
1518 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1521 pktloc__load_buffer_state(yyscanner );
1522 yyg->yy_did_buffer_switch_on_eof = 1;
1529 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1532 if (!YY_CURRENT_BUFFER)
1535 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1536 YY_CURRENT_BUFFER_LVALUE = NULL;
1540 if (YY_CURRENT_BUFFER) {
1541 pktloc__load_buffer_state(yyscanner );
1542 yyg->yy_did_buffer_switch_on_eof = 1;
1549 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1551 yy_size_t num_to_alloc;
1565 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1577 yy_size_t grow_size = 8 ;
1585 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1599 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1604 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1605 base[size-1] != YY_END_OF_BUFFER_CHAR )
1609 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1611 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1613 b->yy_buf_size = size - 2;
1614 b->yy_buf_pos = b->yy_ch_buf = base;
1615 b->yy_is_our_buffer = 0;
1616 b->yy_input_file = 0;
1617 b->yy_n_chars = b->yy_buf_size;
1618 b->yy_is_interactive = 0;
1620 b->yy_fill_buffer = 0;
1621 b->yy_buffer_status = YY_BUFFER_NEW;
1623 pktloc__switch_to_buffer(b ,yyscanner );
1636 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1639 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
1649 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
1657 n = _yybytes_len + 2;
1658 buf = (
char *) pktloc_alloc(n ,yyscanner );
1660 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1662 for ( i = 0; i < _yybytes_len; ++i )
1663 buf[i] = yybytes[i];
1665 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1667 b = pktloc__scan_buffer(buf,n ,yyscanner);
1669 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1674 b->yy_is_our_buffer = 1;
1679 #ifndef YY_EXIT_FAILURE 1680 #define YY_EXIT_FAILURE 2 1683 static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1687 (void) fprintf( stderr,
"%s\n", msg );
1688 exit( YY_EXIT_FAILURE );
1698 yy_size_t yyless_macro_arg = (n); \ 1699 YY_LESS_LINENO(yyless_macro_arg);\ 1700 yytext[yyleng] = yyg->yy_hold_char; \ 1701 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 1702 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 1703 *yyg->yy_c_buf_p = '\0'; \ 1704 yyleng = yyless_macro_arg; \ 1713 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1722 int pktloc_get_lineno (yyscan_t yyscanner)
1726 if (! YY_CURRENT_BUFFER)
1735 int pktloc_get_column (yyscan_t yyscanner)
1739 if (! YY_CURRENT_BUFFER)
1748 FILE *pktloc_get_in (yyscan_t yyscanner)
1757 FILE *pktloc_get_out (yyscan_t yyscanner)
1766 yy_size_t pktloc_get_leng (yyscan_t yyscanner)
1776 char *pktloc_get_text (yyscan_t yyscanner)
1786 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1789 yyextra = user_defined ;
1796 void pktloc_set_lineno (
int _line_number , yyscan_t yyscanner)
1801 if (! YY_CURRENT_BUFFER )
1802 YY_FATAL_ERROR(
"pktloc_set_lineno called with no buffer" );
1804 yylineno = _line_number;
1811 void pktloc_set_column (
int _column_no , yyscan_t yyscanner)
1816 if (! YY_CURRENT_BUFFER )
1817 YY_FATAL_ERROR(
"pktloc_set_column called with no buffer" );
1819 yycolumn = _column_no;
1828 void pktloc_set_in (FILE * _in_str , yyscan_t yyscanner)
1834 void pktloc_set_out (FILE * _out_str , yyscan_t yyscanner)
1840 int pktloc_get_debug (yyscan_t yyscanner)
1843 return yy_flex_debug;
1846 void pktloc_set_debug (
int _bdebug , yyscan_t yyscanner)
1849 yy_flex_debug = _bdebug ;
1854 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1860 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1863 yylval = yylval_param;
1866 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1872 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1875 yylloc = yylloc_param;
1885 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1888 if (ptr_yy_globals == NULL){
1893 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1895 if (*ptr_yy_globals == NULL){
1901 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1903 return yy_init_globals ( *ptr_yy_globals );
1914 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1919 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1921 if (ptr_yy_globals == NULL){
1926 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1928 if (*ptr_yy_globals == NULL){
1935 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1937 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1939 return yy_init_globals ( *ptr_yy_globals );
1942 static int yy_init_globals (yyscan_t yyscanner)
1952 yyg->yy_c_buf_p = (
char *) 0;
1956 yyg->yy_start_stack_ptr = 0;
1957 yyg->yy_start_stack_depth = 0;
1958 yyg->yy_start_stack = NULL;
1976 int pktloc_lex_destroy (yyscan_t yyscanner)
1981 while(YY_CURRENT_BUFFER){
1982 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1983 YY_CURRENT_BUFFER_LVALUE = NULL;
1984 pktloc_pop_buffer_state(yyscanner);
1992 pktloc_free(yyg->yy_start_stack ,yyscanner );
1993 yyg->yy_start_stack = NULL;
1997 yy_init_globals( yyscanner);
2000 pktloc_free ( yyscanner , yyscanner );
2010 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
2016 for ( i = 0; i < n; ++i )
2021 #ifdef YY_NEED_STRLEN 2022 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
2025 for ( n = 0; s[n]; ++n )
2032 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2036 return (
void *) malloc( size );
2039 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2051 return (
void *) realloc( (
char *) ptr, size );
2054 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2058 free( (
char *) ptr );
2061 #define YYTABLES_NAME "yytables" 2063 #line 52 "route/pktloc_grammar.l"
size_t yy_buffer_stack_top
index of top of stack.
int yy_bs_lineno
The line count.
size_t yy_buffer_stack_max
capacity of stack.
int yy_bs_column
The column count.
YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.