1 #line 2 "lib/route/pktloc_grammar.c" 3 #line 4 "lib/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 "lib/route/pktloc_grammar.l" 480 #line 2 "lib/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 <linux/tc_ematch/tc_em_cmp.h> 487 #include "pktloc_syntax.h" 489 int pktloc_get_column(yyscan_t);
490 void pktloc_set_column(
int, yyscan_t);
491 #define YY_NO_INPUT 1 492 #line 493 "lib/route/pktloc_grammar.c" 496 #ifndef YY_NO_UNISTD_H 504 #ifndef YY_EXTRA_TYPE 505 #define YY_EXTRA_TYPE void * 513 YY_EXTRA_TYPE yyextra_r;
516 FILE *yyin_r, *yyout_r;
517 size_t yy_buffer_stack_top;
518 size_t yy_buffer_stack_max;
519 YY_BUFFER_STATE * yy_buffer_stack;
521 yy_size_t yy_n_chars;
526 int yy_did_buffer_switch_on_eof;
527 int yy_start_stack_ptr;
528 int yy_start_stack_depth;
530 yy_state_type yy_last_accepting_state;
531 char* yy_last_accepting_cpos;
546 static int yy_init_globals (yyscan_t yyscanner );
550 # define yylval yyg->yylval_r 552 # define yylloc yyg->yylloc_r 554 int pktloc_lex_init (yyscan_t* scanner);
556 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
561 int pktloc_lex_destroy (yyscan_t yyscanner );
563 int pktloc_get_debug (yyscan_t yyscanner );
565 void pktloc_set_debug (
int debug_flag ,yyscan_t yyscanner );
567 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
569 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
571 FILE *pktloc_get_in (yyscan_t yyscanner );
573 void pktloc_set_in (FILE * _in_str ,yyscan_t yyscanner );
575 FILE *pktloc_get_out (yyscan_t yyscanner );
577 void pktloc_set_out (FILE * _out_str ,yyscan_t yyscanner );
579 yy_size_t pktloc_get_leng (yyscan_t yyscanner );
581 char *pktloc_get_text (yyscan_t yyscanner );
583 int pktloc_get_lineno (yyscan_t yyscanner );
585 void pktloc_set_lineno (
int _line_number ,yyscan_t yyscanner );
587 int pktloc_get_column (yyscan_t yyscanner );
589 void pktloc_set_column (
int _column_no ,yyscan_t yyscanner );
591 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
593 void pktloc_set_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
595 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
597 void pktloc_set_lloc (
YYLTYPE * yylloc_param ,yyscan_t yyscanner );
603 #ifndef YY_SKIP_YYWRAP 605 extern "C" int pktloc_wrap (yyscan_t yyscanner );
607 extern int pktloc_wrap (yyscan_t yyscanner );
616 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
619 #ifdef YY_NEED_STRLEN 620 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
626 static int yyinput (yyscan_t yyscanner );
628 static int input (yyscan_t yyscanner );
634 #ifndef YY_READ_BUF_SIZE 637 #define YY_READ_BUF_SIZE 16384 639 #define YY_READ_BUF_SIZE 8192 648 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 655 #define YY_INPUT(buf,result,max_size) \ 656 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 660 for ( n = 0; n < max_size && \ 661 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 664 buf[n++] = (char) c; \ 665 if ( c == EOF && ferror( yyin ) ) \ 666 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 672 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 674 if( errno != EINTR) \ 676 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 692 #define yyterminate() return YY_NULL 696 #ifndef YY_START_STACK_INCR 697 #define YY_START_STACK_INCR 25 701 #ifndef YY_FATAL_ERROR 702 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) 711 #define YY_DECL_IS_OURS 1 713 extern int pktloc_lex \
714 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
716 #define YY_DECL int pktloc_lex \ 717 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) 723 #ifndef YY_USER_ACTION 724 #define YY_USER_ACTION 729 #define YY_BREAK break; 732 #define YY_RULE_SETUP \ 739 yy_state_type yy_current_state;
744 yylval = yylval_param;
746 yylloc = yylloc_param;
756 if ( ! yyg->yy_start )
765 if ( ! YY_CURRENT_BUFFER ) {
766 pktloc_ensure_buffer_stack (yyscanner);
767 YY_CURRENT_BUFFER_LVALUE =
768 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
771 pktloc__load_buffer_state(yyscanner );
775 #line 24 "lib/route/pktloc_grammar.l" 778 #line 779 "lib/route/pktloc_grammar.c" 782 yy_cp = yyg->yy_c_buf_p;
785 *yy_cp = yyg->yy_hold_char;
792 yy_current_state = yyg->yy_start;
796 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
797 if ( yy_accept[yy_current_state] )
799 yyg->yy_last_accepting_state = yy_current_state;
800 yyg->yy_last_accepting_cpos = yy_cp;
802 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
804 yy_current_state = (int) yy_def[yy_current_state];
805 if ( yy_current_state >= 47 )
806 yy_c = yy_meta[(
unsigned int) yy_c];
808 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
811 while ( yy_base[yy_current_state] != 87 );
814 yy_act = yy_accept[yy_current_state];
817 yy_cp = yyg->yy_last_accepting_cpos;
818 yy_current_state = yyg->yy_last_accepting_state;
819 yy_act = yy_accept[yy_current_state];
830 *yy_cp = yyg->yy_hold_char;
831 yy_cp = yyg->yy_last_accepting_cpos;
832 yy_current_state = yyg->yy_last_accepting_state;
838 #line 26 "lib/route/pktloc_grammar.l" 843 #line 28 "lib/route/pktloc_grammar.l" 847 #line 31 "lib/route/pktloc_grammar.l" 850 #line 31 "lib/route/pktloc_grammar.l" 852 yylval->i = strtoul(yytext, NULL, 0);
858 #line 36 "lib/route/pktloc_grammar.l" 859 {
return yylval->i = yytext[0]; }
863 #line 38 "lib/route/pktloc_grammar.l" 864 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
868 #line 39 "lib/route/pktloc_grammar.l" 869 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
873 #line 40 "lib/route/pktloc_grammar.l" 874 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
877 #line 43 "lib/route/pktloc_grammar.l" 880 #line 43 "lib/route/pktloc_grammar.l" 881 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
884 #line 45 "lib/route/pktloc_grammar.l" 887 #line 45 "lib/route/pktloc_grammar.l" 888 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
891 #line 47 "lib/route/pktloc_grammar.l" 894 #line 47 "lib/route/pktloc_grammar.l" 895 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
899 #line 50 "lib/route/pktloc_grammar.l" 901 yylval->s = strdup(yytext);
902 if (yylval->s == NULL)
909 #line 56 "lib/route/pktloc_grammar.l" 912 #line 913 "lib/route/pktloc_grammar.c" 913 case YY_STATE_EOF(INITIAL):
916 case YY_END_OF_BUFFER:
919 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
922 *yy_cp = yyg->yy_hold_char;
923 YY_RESTORE_YY_MORE_OFFSET
925 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
936 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
937 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
938 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
948 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
950 yy_state_type yy_next_state;
952 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
954 yy_current_state = yy_get_previous_state( yyscanner );
965 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
967 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
972 yy_cp = ++yyg->yy_c_buf_p;
973 yy_current_state = yy_next_state;
979 yy_cp = yyg->yy_c_buf_p;
984 else switch ( yy_get_next_buffer( yyscanner ) )
986 case EOB_ACT_END_OF_FILE:
988 yyg->yy_did_buffer_switch_on_eof = 0;
990 if ( pktloc_wrap(yyscanner ) )
1001 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1003 yy_act = YY_STATE_EOF(YY_START);
1009 if ( ! yyg->yy_did_buffer_switch_on_eof )
1015 case EOB_ACT_CONTINUE_SCAN:
1017 yyg->yytext_ptr + yy_amount_of_matched_text;
1019 yy_current_state = yy_get_previous_state( yyscanner );
1021 yy_cp = yyg->yy_c_buf_p;
1022 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1025 case EOB_ACT_LAST_MATCH:
1027 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1029 yy_current_state = yy_get_previous_state( yyscanner );
1031 yy_cp = yyg->yy_c_buf_p;
1032 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1033 goto yy_find_action;
1040 "fatal flex scanner internal error--no action found" );
1053 static int yy_get_next_buffer (yyscan_t yyscanner)
1056 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1057 char *source = yyg->yytext_ptr;
1058 yy_size_t number_to_move, i;
1061 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1063 "fatal flex scanner internal error--end of buffer missed" );
1065 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1067 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1072 return EOB_ACT_END_OF_FILE;
1080 return EOB_ACT_LAST_MATCH;
1087 number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1089 for ( i = 0; i < number_to_move; ++i )
1090 *(dest++) = *(source++);
1092 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1096 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1101 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1103 while ( num_to_read <= 0 )
1107 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1109 int yy_c_buf_p_offset =
1110 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1112 if ( b->yy_is_our_buffer )
1114 yy_size_t new_size = b->yy_buf_size * 2;
1116 if ( new_size <= 0 )
1117 b->yy_buf_size += b->yy_buf_size / 8;
1119 b->yy_buf_size *= 2;
1121 b->yy_ch_buf = (
char *)
1123 pktloc_realloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1129 if ( ! b->yy_ch_buf )
1131 "fatal error - scanner input buffer overflow" );
1133 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1135 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1140 if ( num_to_read > YY_READ_BUF_SIZE )
1141 num_to_read = YY_READ_BUF_SIZE;
1144 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1145 yyg->yy_n_chars, num_to_read );
1147 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1150 if ( yyg->yy_n_chars == 0 )
1152 if ( number_to_move == YY_MORE_ADJ )
1154 ret_val = EOB_ACT_END_OF_FILE;
1155 pktloc_restart(yyin ,yyscanner);
1160 ret_val = EOB_ACT_LAST_MATCH;
1161 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1162 YY_BUFFER_EOF_PENDING;
1167 ret_val = EOB_ACT_CONTINUE_SCAN;
1169 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1171 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1172 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1173 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1174 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1177 yyg->yy_n_chars += number_to_move;
1178 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1179 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1181 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1188 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1190 yy_state_type yy_current_state;
1194 yy_current_state = yyg->yy_start;
1196 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1198 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1199 if ( yy_accept[yy_current_state] )
1201 yyg->yy_last_accepting_state = yy_current_state;
1202 yyg->yy_last_accepting_cpos = yy_cp;
1204 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1206 yy_current_state = (int) yy_def[yy_current_state];
1207 if ( yy_current_state >= 47 )
1208 yy_c = yy_meta[(
unsigned int) yy_c];
1210 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1213 return yy_current_state;
1221 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1225 char *yy_cp = yyg->yy_c_buf_p;
1228 if ( yy_accept[yy_current_state] )
1230 yyg->yy_last_accepting_state = yy_current_state;
1231 yyg->yy_last_accepting_cpos = yy_cp;
1233 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1235 yy_current_state = (int) yy_def[yy_current_state];
1236 if ( yy_current_state >= 47 )
1237 yy_c = yy_meta[(
unsigned int) yy_c];
1239 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1240 yy_is_jam = (yy_current_state == 46);
1243 return yy_is_jam ? 0 : yy_current_state;
1252 static int yyinput (yyscan_t yyscanner)
1254 static int input (yyscan_t yyscanner)
1261 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1263 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1269 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1271 *yyg->yy_c_buf_p =
'\0';
1275 yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1278 switch ( yy_get_next_buffer( yyscanner ) )
1280 case EOB_ACT_LAST_MATCH:
1292 pktloc_restart(yyin ,yyscanner);
1296 case EOB_ACT_END_OF_FILE:
1298 if ( pktloc_wrap(yyscanner ) )
1301 if ( ! yyg->yy_did_buffer_switch_on_eof )
1304 return yyinput(yyscanner);
1306 return input(yyscanner);
1310 case EOB_ACT_CONTINUE_SCAN:
1311 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1317 c = *(
unsigned char *) yyg->yy_c_buf_p;
1318 *yyg->yy_c_buf_p =
'\0';
1319 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1330 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1334 if ( ! YY_CURRENT_BUFFER ){
1335 pktloc_ensure_buffer_stack (yyscanner);
1336 YY_CURRENT_BUFFER_LVALUE =
1337 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1340 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1341 pktloc__load_buffer_state(yyscanner );
1348 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1357 pktloc_ensure_buffer_stack (yyscanner);
1358 if ( YY_CURRENT_BUFFER == new_buffer )
1361 if ( YY_CURRENT_BUFFER )
1364 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1365 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1366 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1369 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1370 pktloc__load_buffer_state(yyscanner );
1377 yyg->yy_did_buffer_switch_on_eof = 1;
1380 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1383 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1384 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1385 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1386 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1395 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1399 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1401 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1403 b->yy_buf_size = (yy_size_t)size;
1408 b->yy_ch_buf = (
char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
1409 if ( ! b->yy_ch_buf )
1410 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1412 b->yy_is_our_buffer = 1;
1414 pktloc__init_buffer(b,file ,yyscanner);
1423 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1430 if ( b == YY_CURRENT_BUFFER )
1431 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1433 if ( b->yy_is_our_buffer )
1434 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1436 pktloc_free((
void *) b ,yyscanner );
1443 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1449 pktloc__flush_buffer(b ,yyscanner);
1451 b->yy_input_file = file;
1452 b->yy_fill_buffer = 1;
1458 if (b != YY_CURRENT_BUFFER){
1463 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1472 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1484 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1485 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1487 b->yy_buf_pos = &b->yy_ch_buf[0];
1490 b->yy_buffer_status = YY_BUFFER_NEW;
1492 if ( b == YY_CURRENT_BUFFER )
1493 pktloc__load_buffer_state(yyscanner );
1502 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1505 if (new_buffer == NULL)
1508 pktloc_ensure_buffer_stack(yyscanner);
1511 if ( YY_CURRENT_BUFFER )
1514 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1515 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1516 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1520 if (YY_CURRENT_BUFFER)
1522 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1525 pktloc__load_buffer_state(yyscanner );
1526 yyg->yy_did_buffer_switch_on_eof = 1;
1533 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1536 if (!YY_CURRENT_BUFFER)
1539 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1540 YY_CURRENT_BUFFER_LVALUE = NULL;
1544 if (YY_CURRENT_BUFFER) {
1545 pktloc__load_buffer_state(yyscanner );
1546 yyg->yy_did_buffer_switch_on_eof = 1;
1553 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1555 yy_size_t num_to_alloc;
1569 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1581 yy_size_t grow_size = 8 ;
1589 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1603 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1608 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1609 base[size-1] != YY_END_OF_BUFFER_CHAR )
1613 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1615 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1617 b->yy_buf_size = size - 2;
1618 b->yy_buf_pos = b->yy_ch_buf = base;
1619 b->yy_is_our_buffer = 0;
1620 b->yy_input_file = 0;
1621 b->yy_n_chars = b->yy_buf_size;
1622 b->yy_is_interactive = 0;
1624 b->yy_fill_buffer = 0;
1625 b->yy_buffer_status = YY_BUFFER_NEW;
1627 pktloc__switch_to_buffer(b ,yyscanner );
1640 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1643 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
1653 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
1661 n = _yybytes_len + 2;
1662 buf = (
char *) pktloc_alloc(n ,yyscanner );
1664 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1666 for ( i = 0; i < _yybytes_len; ++i )
1667 buf[i] = yybytes[i];
1669 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1671 b = pktloc__scan_buffer(buf,n ,yyscanner);
1673 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1678 b->yy_is_our_buffer = 1;
1683 #ifndef YY_EXIT_FAILURE 1684 #define YY_EXIT_FAILURE 2 1687 static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1691 (void) fprintf( stderr,
"%s\n", msg );
1692 exit( YY_EXIT_FAILURE );
1702 yy_size_t yyless_macro_arg = (n); \ 1703 YY_LESS_LINENO(yyless_macro_arg);\ 1704 yytext[yyleng] = yyg->yy_hold_char; \ 1705 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 1706 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 1707 *yyg->yy_c_buf_p = '\0'; \ 1708 yyleng = yyless_macro_arg; \ 1717 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1726 int pktloc_get_lineno (yyscan_t yyscanner)
1730 if (! YY_CURRENT_BUFFER)
1739 int pktloc_get_column (yyscan_t yyscanner)
1743 if (! YY_CURRENT_BUFFER)
1752 FILE *pktloc_get_in (yyscan_t yyscanner)
1761 FILE *pktloc_get_out (yyscan_t yyscanner)
1770 yy_size_t pktloc_get_leng (yyscan_t yyscanner)
1780 char *pktloc_get_text (yyscan_t yyscanner)
1790 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1793 yyextra = user_defined ;
1800 void pktloc_set_lineno (
int _line_number , yyscan_t yyscanner)
1805 if (! YY_CURRENT_BUFFER )
1806 YY_FATAL_ERROR(
"pktloc_set_lineno called with no buffer" );
1808 yylineno = _line_number;
1815 void pktloc_set_column (
int _column_no , yyscan_t yyscanner)
1820 if (! YY_CURRENT_BUFFER )
1821 YY_FATAL_ERROR(
"pktloc_set_column called with no buffer" );
1823 yycolumn = _column_no;
1832 void pktloc_set_in (FILE * _in_str , yyscan_t yyscanner)
1838 void pktloc_set_out (FILE * _out_str , yyscan_t yyscanner)
1844 int pktloc_get_debug (yyscan_t yyscanner)
1847 return yy_flex_debug;
1850 void pktloc_set_debug (
int _bdebug , yyscan_t yyscanner)
1853 yy_flex_debug = _bdebug ;
1858 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1864 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1867 yylval = yylval_param;
1870 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1876 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1879 yylloc = yylloc_param;
1889 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1892 if (ptr_yy_globals == NULL){
1897 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1899 if (*ptr_yy_globals == NULL){
1905 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1907 return yy_init_globals ( *ptr_yy_globals );
1918 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1923 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1925 if (ptr_yy_globals == NULL){
1930 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1932 if (*ptr_yy_globals == NULL){
1939 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1941 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1943 return yy_init_globals ( *ptr_yy_globals );
1946 static int yy_init_globals (yyscan_t yyscanner)
1956 yyg->yy_c_buf_p = (
char *) 0;
1960 yyg->yy_start_stack_ptr = 0;
1961 yyg->yy_start_stack_depth = 0;
1962 yyg->yy_start_stack = NULL;
1980 int pktloc_lex_destroy (yyscan_t yyscanner)
1985 while(YY_CURRENT_BUFFER){
1986 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1987 YY_CURRENT_BUFFER_LVALUE = NULL;
1988 pktloc_pop_buffer_state(yyscanner);
1996 pktloc_free(yyg->yy_start_stack ,yyscanner );
1997 yyg->yy_start_stack = NULL;
2001 yy_init_globals( yyscanner);
2004 pktloc_free ( yyscanner , yyscanner );
2014 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
2020 for ( i = 0; i < n; ++i )
2025 #ifdef YY_NEED_STRLEN 2026 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
2029 for ( n = 0; s[n]; ++n )
2036 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2040 return (
void *) malloc( size );
2043 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2055 return (
void *) realloc( (
char *) ptr, size );
2058 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2062 free( (
char *) ptr );
2065 #define YYTABLES_NAME "yytables" 2067 #line 56 "lib/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.