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 1 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) 94 #if defined(__GNUC__) && __GNUC__ >= 3 95 #define yynoreturn __attribute__((__noreturn__)) 108 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 111 #ifndef YY_TYPEDEF_YY_SCANNER_T 112 #define YY_TYPEDEF_YY_SCANNER_T 113 typedef void* yyscan_t;
118 #define yyin yyg->yyin_r 119 #define yyout yyg->yyout_r 120 #define yyextra yyg->yyextra_r 121 #define yyleng yyg->yyleng_r 122 #define yytext yyg->yytext_r 123 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) 124 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) 125 #define yy_flex_debug yyg->yy_flex_debug_r 131 #define BEGIN yyg->yy_start = 1 + 2 * 137 #define YY_START ((yyg->yy_start - 1) / 2) 138 #define YYSTATE YY_START 141 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 144 #define YY_NEW_FILE pktloc_restart(yyin ,yyscanner ) 146 #define YY_END_OF_BUFFER_CHAR 0 155 #define YY_BUF_SIZE 32768 157 #define YY_BUF_SIZE 16384 163 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 165 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 166 #define YY_TYPEDEF_YY_BUFFER_STATE 170 #ifndef YY_TYPEDEF_YY_SIZE_T 171 #define YY_TYPEDEF_YY_SIZE_T 172 typedef size_t yy_size_t;
175 #define EOB_ACT_CONTINUE_SCAN 0 176 #define EOB_ACT_END_OF_FILE 1 177 #define EOB_ACT_LAST_MATCH 2 179 #define YY_LESS_LINENO(n) 180 #define YY_LINENO_REWIND_TO(ptr) 187 yy_size_t yyless_macro_arg = (n); \ 188 YY_LESS_LINENO(yyless_macro_arg);\ 189 *yy_cp = yyg->yy_hold_char; \ 190 YY_RESTORE_YY_MORE_OFFSET \ 191 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 192 YY_DO_BEFORE_ACTION; \ 196 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) 198 #ifndef YY_STRUCT_YY_BUFFER_STATE 199 #define YY_STRUCT_YY_BUFFER_STATE 221 int yy_is_our_buffer;
228 int yy_is_interactive;
244 int yy_buffer_status;
246 #define YY_BUFFER_NEW 0 247 #define YY_BUFFER_NORMAL 1 258 #define YY_BUFFER_EOF_PENDING 2 269 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ 270 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ 276 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] 278 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
279 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
280 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
281 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
282 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
283 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
284 void pktloc_pop_buffer_state (yyscan_t yyscanner );
286 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
287 static void pktloc__load_buffer_state (yyscan_t yyscanner );
288 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
290 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner) 292 YY_BUFFER_STATE pktloc__scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
293 YY_BUFFER_STATE pktloc__scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
294 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char *bytes,
int len ,yyscan_t yyscanner );
296 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
297 void *pktloc_realloc (
void *,yy_size_t ,yyscan_t yyscanner );
298 void pktloc_free (
void * ,yyscan_t yyscanner );
300 #define yy_new_buffer pktloc__create_buffer 302 #define yy_set_interactive(is_interactive) \ 304 if ( ! YY_CURRENT_BUFFER ){ \ 305 pktloc_ensure_buffer_stack (yyscanner); \ 306 YY_CURRENT_BUFFER_LVALUE = \ 307 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 309 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 312 #define yy_set_bol(at_bol) \ 314 if ( ! YY_CURRENT_BUFFER ){\ 315 pktloc_ensure_buffer_stack (yyscanner); \ 316 YY_CURRENT_BUFFER_LVALUE = \ 317 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 319 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 322 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 324 #define pktloc_wrap(yyscanner) (1) 325 #define YY_SKIP_YYWRAP 327 typedef unsigned char YY_CHAR;
329 typedef int yy_state_type;
331 #define yytext_ptr yytext_r 333 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
334 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
335 static int yy_get_next_buffer (yyscan_t yyscanner );
336 static void yynoreturn yy_fatal_error (yyconst
char* msg ,yyscan_t yyscanner );
341 #define YY_DO_BEFORE_ACTION \ 342 yyg->yytext_ptr = yy_bp; \ 343 yyleng = (int) (yy_cp - yy_bp); \ 344 yyg->yy_hold_char = *yy_cp; \ 346 yyg->yy_c_buf_p = yy_cp; 348 #define YY_NUM_RULES 16 349 #define YY_END_OF_BUFFER 17 354 flex_int32_t yy_verify;
357 static yyconst flex_int16_t yy_accept[47] =
359 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
360 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
361 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
362 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
363 15, 15, 15, 15, 13, 0
366 static yyconst YY_CHAR yy_ec[256] =
368 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
369 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
370 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
371 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
372 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
373 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
374 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
375 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
376 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
377 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
379 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
380 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
387 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
391 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
392 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398 static yyconst YY_CHAR yy_meta[29] =
400 1, 2, 3, 1, 2, 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
405 static yyconst flex_uint16_t yy_base[50] =
407 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
408 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
409 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
410 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
411 30, 29, 26, 18, 0, 87, 31, 68, 70
414 static yyconst flex_int16_t yy_def[50] =
416 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
417 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
418 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
419 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
420 47, 47, 47, 47, 47, 0, 46, 46, 46
423 static yyconst flex_uint16_t yy_nxt[116] =
425 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
426 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
427 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
428 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
429 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
430 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
431 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
432 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
433 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
434 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
436 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
440 static yyconst flex_int16_t yy_chk[116] =
442 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
443 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
444 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
445 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
446 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
447 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
448 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
449 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
450 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
451 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
453 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
460 #define REJECT reject_used_but_not_detected 461 #define yymore() yymore_used_but_not_detected 462 #define YY_MORE_ADJ 0 463 #define YY_RESTORE_YY_MORE_OFFSET 464 #line 1 "lib/route/pktloc_grammar.l" 465 #line 2 "lib/route/pktloc_grammar.l" 466 #include <netlink-private/netlink.h> 467 #include <netlink-private/tc.h> 468 #include <netlink/netlink.h> 469 #include <netlink/utils.h> 470 #include <netlink/route/pktloc.h> 471 #include <linux/tc_ematch/tc_em_cmp.h> 472 #include "pktloc_syntax.h" 474 int pktloc_get_column(yyscan_t);
475 void pktloc_set_column(
int, yyscan_t);
476 #define YY_NO_INPUT 1 477 #line 478 "lib/route/pktloc_grammar.c" 481 #ifndef YY_NO_UNISTD_H 489 #ifndef YY_EXTRA_TYPE 490 #define YY_EXTRA_TYPE void * 498 YY_EXTRA_TYPE yyextra_r;
501 FILE *yyin_r, *yyout_r;
502 size_t yy_buffer_stack_top;
503 size_t yy_buffer_stack_max;
504 YY_BUFFER_STATE * yy_buffer_stack;
511 int yy_did_buffer_switch_on_eof;
512 int yy_start_stack_ptr;
513 int yy_start_stack_depth;
515 yy_state_type yy_last_accepting_state;
516 char* yy_last_accepting_cpos;
531 static int yy_init_globals (yyscan_t yyscanner );
535 # define yylval yyg->yylval_r 537 # define yylloc yyg->yylloc_r 539 int pktloc_lex_init (yyscan_t* scanner);
541 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
546 int pktloc_lex_destroy (yyscan_t yyscanner );
548 int pktloc_get_debug (yyscan_t yyscanner );
550 void pktloc_set_debug (
int debug_flag ,yyscan_t yyscanner );
552 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
554 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
556 FILE *pktloc_get_in (yyscan_t yyscanner );
558 void pktloc_set_in (FILE * _in_str ,yyscan_t yyscanner );
560 FILE *pktloc_get_out (yyscan_t yyscanner );
562 void pktloc_set_out (FILE * _out_str ,yyscan_t yyscanner );
564 int pktloc_get_leng (yyscan_t yyscanner );
566 char *pktloc_get_text (yyscan_t yyscanner );
568 int pktloc_get_lineno (yyscan_t yyscanner );
570 void pktloc_set_lineno (
int _line_number ,yyscan_t yyscanner );
572 int pktloc_get_column (yyscan_t yyscanner );
574 void pktloc_set_column (
int _column_no ,yyscan_t yyscanner );
576 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
578 void pktloc_set_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
580 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
582 void pktloc_set_lloc (
YYLTYPE * yylloc_param ,yyscan_t yyscanner );
588 #ifndef YY_SKIP_YYWRAP 590 extern "C" int pktloc_wrap (yyscan_t yyscanner );
592 extern int pktloc_wrap (yyscan_t yyscanner );
601 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
604 #ifdef YY_NEED_STRLEN 605 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
611 static int yyinput (yyscan_t yyscanner );
613 static int input (yyscan_t yyscanner );
619 #ifndef YY_READ_BUF_SIZE 622 #define YY_READ_BUF_SIZE 16384 624 #define YY_READ_BUF_SIZE 8192 633 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) 640 #define YY_INPUT(buf,result,max_size) \ 641 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 645 for ( n = 0; n < max_size && \ 646 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 649 buf[n++] = (char) c; \ 650 if ( c == EOF && ferror( yyin ) ) \ 651 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 657 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ 659 if( errno != EINTR) \ 661 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 677 #define yyterminate() return YY_NULL 681 #ifndef YY_START_STACK_INCR 682 #define YY_START_STACK_INCR 25 686 #ifndef YY_FATAL_ERROR 687 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) 696 #define YY_DECL_IS_OURS 1 698 extern int pktloc_lex \
699 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
701 #define YY_DECL int pktloc_lex \ 702 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) 708 #ifndef YY_USER_ACTION 709 #define YY_USER_ACTION 714 #define YY_BREAK break; 717 #define YY_RULE_SETUP \ 724 yy_state_type yy_current_state;
729 yylval = yylval_param;
731 yylloc = yylloc_param;
741 if ( ! yyg->yy_start )
750 if ( ! YY_CURRENT_BUFFER ) {
751 pktloc_ensure_buffer_stack (yyscanner);
752 YY_CURRENT_BUFFER_LVALUE =
753 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
756 pktloc__load_buffer_state(yyscanner );
760 #line 24 "lib/route/pktloc_grammar.l" 763 #line 764 "lib/route/pktloc_grammar.c" 767 yy_cp = yyg->yy_c_buf_p;
770 *yy_cp = yyg->yy_hold_char;
777 yy_current_state = yyg->yy_start;
781 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
782 if ( yy_accept[yy_current_state] )
784 yyg->yy_last_accepting_state = yy_current_state;
785 yyg->yy_last_accepting_cpos = yy_cp;
787 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
789 yy_current_state = (int) yy_def[yy_current_state];
790 if ( yy_current_state >= 47 )
791 yy_c = yy_meta[(
unsigned int) yy_c];
793 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
796 while ( yy_base[yy_current_state] != 87 );
799 yy_act = yy_accept[yy_current_state];
802 yy_cp = yyg->yy_last_accepting_cpos;
803 yy_current_state = yyg->yy_last_accepting_state;
804 yy_act = yy_accept[yy_current_state];
815 *yy_cp = yyg->yy_hold_char;
816 yy_cp = yyg->yy_last_accepting_cpos;
817 yy_current_state = yyg->yy_last_accepting_state;
823 #line 26 "lib/route/pktloc_grammar.l" 828 #line 28 "lib/route/pktloc_grammar.l" 832 #line 31 "lib/route/pktloc_grammar.l" 835 #line 31 "lib/route/pktloc_grammar.l" 837 yylval->i = strtoul(yytext, NULL, 0);
843 #line 36 "lib/route/pktloc_grammar.l" 844 {
return yylval->i = yytext[0]; }
848 #line 38 "lib/route/pktloc_grammar.l" 849 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
853 #line 39 "lib/route/pktloc_grammar.l" 854 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
858 #line 40 "lib/route/pktloc_grammar.l" 859 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
862 #line 43 "lib/route/pktloc_grammar.l" 865 #line 43 "lib/route/pktloc_grammar.l" 866 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
869 #line 45 "lib/route/pktloc_grammar.l" 872 #line 45 "lib/route/pktloc_grammar.l" 873 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
876 #line 47 "lib/route/pktloc_grammar.l" 879 #line 47 "lib/route/pktloc_grammar.l" 880 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
884 #line 50 "lib/route/pktloc_grammar.l" 886 yylval->s = strdup(yytext);
887 if (yylval->s == NULL)
894 #line 56 "lib/route/pktloc_grammar.l" 897 #line 898 "lib/route/pktloc_grammar.c" 898 case YY_STATE_EOF(INITIAL):
901 case YY_END_OF_BUFFER:
904 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
907 *yy_cp = yyg->yy_hold_char;
908 YY_RESTORE_YY_MORE_OFFSET
910 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
921 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
922 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
923 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
933 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
935 yy_state_type yy_next_state;
937 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
939 yy_current_state = yy_get_previous_state( yyscanner );
950 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
952 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
957 yy_cp = ++yyg->yy_c_buf_p;
958 yy_current_state = yy_next_state;
964 yy_cp = yyg->yy_c_buf_p;
969 else switch ( yy_get_next_buffer( yyscanner ) )
971 case EOB_ACT_END_OF_FILE:
973 yyg->yy_did_buffer_switch_on_eof = 0;
975 if ( pktloc_wrap(yyscanner ) )
986 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
988 yy_act = YY_STATE_EOF(YY_START);
994 if ( ! yyg->yy_did_buffer_switch_on_eof )
1000 case EOB_ACT_CONTINUE_SCAN:
1002 yyg->yytext_ptr + yy_amount_of_matched_text;
1004 yy_current_state = yy_get_previous_state( yyscanner );
1006 yy_cp = yyg->yy_c_buf_p;
1007 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1010 case EOB_ACT_LAST_MATCH:
1012 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1014 yy_current_state = yy_get_previous_state( yyscanner );
1016 yy_cp = yyg->yy_c_buf_p;
1017 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1018 goto yy_find_action;
1025 "fatal flex scanner internal error--no action found" );
1038 static int yy_get_next_buffer (yyscan_t yyscanner)
1041 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1042 char *source = yyg->yytext_ptr;
1043 yy_size_t number_to_move, i;
1046 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1048 "fatal flex scanner internal error--end of buffer missed" );
1050 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1052 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1057 return EOB_ACT_END_OF_FILE;
1065 return EOB_ACT_LAST_MATCH;
1072 number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1074 for ( i = 0; i < number_to_move; ++i )
1075 *(dest++) = *(source++);
1077 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1081 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1086 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1088 while ( num_to_read <= 0 )
1092 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1094 int yy_c_buf_p_offset =
1095 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1097 if ( b->yy_is_our_buffer )
1099 int new_size = b->yy_buf_size * 2;
1101 if ( new_size <= 0 )
1102 b->yy_buf_size += b->yy_buf_size / 8;
1104 b->yy_buf_size *= 2;
1106 b->yy_ch_buf = (
char *)
1108 pktloc_realloc((
void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) ,yyscanner );
1112 b->yy_ch_buf = NULL;
1114 if ( ! b->yy_ch_buf )
1116 "fatal error - scanner input buffer overflow" );
1118 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1120 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1125 if ( num_to_read > YY_READ_BUF_SIZE )
1126 num_to_read = YY_READ_BUF_SIZE;
1129 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1130 yyg->yy_n_chars, num_to_read );
1132 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1135 if ( yyg->yy_n_chars == 0 )
1137 if ( number_to_move == YY_MORE_ADJ )
1139 ret_val = EOB_ACT_END_OF_FILE;
1140 pktloc_restart(yyin ,yyscanner);
1145 ret_val = EOB_ACT_LAST_MATCH;
1146 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1147 YY_BUFFER_EOF_PENDING;
1152 ret_val = EOB_ACT_CONTINUE_SCAN;
1154 if ((
int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1156 int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1157 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ,yyscanner );
1158 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1159 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1162 yyg->yy_n_chars += number_to_move;
1163 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1164 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1166 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1173 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1175 yy_state_type yy_current_state;
1179 yy_current_state = yyg->yy_start;
1181 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1183 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1184 if ( yy_accept[yy_current_state] )
1186 yyg->yy_last_accepting_state = yy_current_state;
1187 yyg->yy_last_accepting_cpos = yy_cp;
1189 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1191 yy_current_state = (int) yy_def[yy_current_state];
1192 if ( yy_current_state >= 47 )
1193 yy_c = yy_meta[(
unsigned int) yy_c];
1195 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1198 return yy_current_state;
1206 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1210 char *yy_cp = yyg->yy_c_buf_p;
1213 if ( yy_accept[yy_current_state] )
1215 yyg->yy_last_accepting_state = yy_current_state;
1216 yyg->yy_last_accepting_cpos = yy_cp;
1218 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1220 yy_current_state = (int) yy_def[yy_current_state];
1221 if ( yy_current_state >= 47 )
1222 yy_c = yy_meta[(
unsigned int) yy_c];
1224 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1225 yy_is_jam = (yy_current_state == 46);
1228 return yy_is_jam ? 0 : yy_current_state;
1237 static int yyinput (yyscan_t yyscanner)
1239 static int input (yyscan_t yyscanner)
1246 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1248 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1254 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1256 *yyg->yy_c_buf_p =
'\0';
1260 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1263 switch ( yy_get_next_buffer( yyscanner ) )
1265 case EOB_ACT_LAST_MATCH:
1277 pktloc_restart(yyin ,yyscanner);
1281 case EOB_ACT_END_OF_FILE:
1283 if ( pktloc_wrap(yyscanner ) )
1286 if ( ! yyg->yy_did_buffer_switch_on_eof )
1289 return yyinput(yyscanner);
1291 return input(yyscanner);
1295 case EOB_ACT_CONTINUE_SCAN:
1296 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1302 c = *(
unsigned char *) yyg->yy_c_buf_p;
1303 *yyg->yy_c_buf_p =
'\0';
1304 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1315 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1319 if ( ! YY_CURRENT_BUFFER ){
1320 pktloc_ensure_buffer_stack (yyscanner);
1321 YY_CURRENT_BUFFER_LVALUE =
1322 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1325 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1326 pktloc__load_buffer_state(yyscanner );
1333 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1342 pktloc_ensure_buffer_stack (yyscanner);
1343 if ( YY_CURRENT_BUFFER == new_buffer )
1346 if ( YY_CURRENT_BUFFER )
1349 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1350 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1351 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1354 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1355 pktloc__load_buffer_state(yyscanner );
1362 yyg->yy_did_buffer_switch_on_eof = 1;
1365 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1368 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1369 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1370 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1371 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1380 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1384 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1386 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1388 b->yy_buf_size = size;
1393 b->yy_ch_buf = (
char *) pktloc_alloc((yy_size_t) (b->yy_buf_size + 2) ,yyscanner );
1394 if ( ! b->yy_ch_buf )
1395 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1397 b->yy_is_our_buffer = 1;
1399 pktloc__init_buffer(b,file ,yyscanner);
1408 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1415 if ( b == YY_CURRENT_BUFFER )
1416 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1418 if ( b->yy_is_our_buffer )
1419 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1421 pktloc_free((
void *) b ,yyscanner );
1428 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1434 pktloc__flush_buffer(b ,yyscanner);
1436 b->yy_input_file = file;
1437 b->yy_fill_buffer = 1;
1443 if (b != YY_CURRENT_BUFFER){
1448 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1457 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1469 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1470 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1472 b->yy_buf_pos = &b->yy_ch_buf[0];
1475 b->yy_buffer_status = YY_BUFFER_NEW;
1477 if ( b == YY_CURRENT_BUFFER )
1478 pktloc__load_buffer_state(yyscanner );
1487 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1490 if (new_buffer == NULL)
1493 pktloc_ensure_buffer_stack(yyscanner);
1496 if ( YY_CURRENT_BUFFER )
1499 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1500 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1501 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1505 if (YY_CURRENT_BUFFER)
1507 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1510 pktloc__load_buffer_state(yyscanner );
1511 yyg->yy_did_buffer_switch_on_eof = 1;
1518 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1521 if (!YY_CURRENT_BUFFER)
1524 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1525 YY_CURRENT_BUFFER_LVALUE = NULL;
1529 if (YY_CURRENT_BUFFER) {
1530 pktloc__load_buffer_state(yyscanner );
1531 yyg->yy_did_buffer_switch_on_eof = 1;
1538 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1554 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1566 yy_size_t grow_size = 8 ;
1574 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1588 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1593 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1594 base[size-1] != YY_END_OF_BUFFER_CHAR )
1598 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1600 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1602 b->yy_buf_size = (int) (size - 2);
1603 b->yy_buf_pos = b->yy_ch_buf = base;
1604 b->yy_is_our_buffer = 0;
1605 b->yy_input_file = NULL;
1606 b->yy_n_chars = b->yy_buf_size;
1607 b->yy_is_interactive = 0;
1609 b->yy_fill_buffer = 0;
1610 b->yy_buffer_status = YY_BUFFER_NEW;
1612 pktloc__switch_to_buffer(b ,yyscanner );
1625 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1628 return pktloc__scan_bytes(yystr,(
int) strlen(yystr) ,yyscanner);
1638 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1646 n = (yy_size_t) _yybytes_len + 2;
1647 buf = (
char *) pktloc_alloc(n ,yyscanner );
1649 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1651 for ( i = 0; i < _yybytes_len; ++i )
1652 buf[i] = yybytes[i];
1654 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1656 b = pktloc__scan_buffer(buf,n ,yyscanner);
1658 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1663 b->yy_is_our_buffer = 1;
1668 #ifndef YY_EXIT_FAILURE 1669 #define YY_EXIT_FAILURE 2 1672 static void yynoreturn yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1676 (void) fprintf( stderr,
"%s\n", msg );
1677 exit( YY_EXIT_FAILURE );
1687 yy_size_t yyless_macro_arg = (n); \ 1688 YY_LESS_LINENO(yyless_macro_arg);\ 1689 yytext[yyleng] = yyg->yy_hold_char; \ 1690 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 1691 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 1692 *yyg->yy_c_buf_p = '\0'; \ 1693 yyleng = yyless_macro_arg; \ 1702 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1711 int pktloc_get_lineno (yyscan_t yyscanner)
1715 if (! YY_CURRENT_BUFFER)
1724 int pktloc_get_column (yyscan_t yyscanner)
1728 if (! YY_CURRENT_BUFFER)
1737 FILE *pktloc_get_in (yyscan_t yyscanner)
1746 FILE *pktloc_get_out (yyscan_t yyscanner)
1755 int pktloc_get_leng (yyscan_t yyscanner)
1765 char *pktloc_get_text (yyscan_t yyscanner)
1775 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1778 yyextra = user_defined ;
1785 void pktloc_set_lineno (
int _line_number , yyscan_t yyscanner)
1790 if (! YY_CURRENT_BUFFER )
1791 YY_FATAL_ERROR(
"pktloc_set_lineno called with no buffer" );
1793 yylineno = _line_number;
1800 void pktloc_set_column (
int _column_no , yyscan_t yyscanner)
1805 if (! YY_CURRENT_BUFFER )
1806 YY_FATAL_ERROR(
"pktloc_set_column called with no buffer" );
1808 yycolumn = _column_no;
1817 void pktloc_set_in (FILE * _in_str , yyscan_t yyscanner)
1823 void pktloc_set_out (FILE * _out_str , yyscan_t yyscanner)
1829 int pktloc_get_debug (yyscan_t yyscanner)
1832 return yy_flex_debug;
1835 void pktloc_set_debug (
int _bdebug , yyscan_t yyscanner)
1838 yy_flex_debug = _bdebug ;
1843 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1849 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1852 yylval = yylval_param;
1855 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1861 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1864 yylloc = yylloc_param;
1874 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1877 if (ptr_yy_globals == NULL){
1882 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1884 if (*ptr_yy_globals == NULL){
1890 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1892 return yy_init_globals ( *ptr_yy_globals );
1903 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1908 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1910 if (ptr_yy_globals == NULL){
1915 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1917 if (*ptr_yy_globals == NULL){
1924 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1926 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1928 return yy_init_globals ( *ptr_yy_globals );
1931 static int yy_init_globals (yyscan_t yyscanner)
1941 yyg->yy_c_buf_p = NULL;
1945 yyg->yy_start_stack_ptr = 0;
1946 yyg->yy_start_stack_depth = 0;
1947 yyg->yy_start_stack = NULL;
1965 int pktloc_lex_destroy (yyscan_t yyscanner)
1970 while(YY_CURRENT_BUFFER){
1971 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1972 YY_CURRENT_BUFFER_LVALUE = NULL;
1973 pktloc_pop_buffer_state(yyscanner);
1981 pktloc_free(yyg->yy_start_stack ,yyscanner );
1982 yyg->yy_start_stack = NULL;
1986 yy_init_globals( yyscanner);
1989 pktloc_free ( yyscanner , yyscanner );
1999 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
2005 for ( i = 0; i < n; ++i )
2010 #ifdef YY_NEED_STRLEN 2011 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
2014 for ( n = 0; s[n]; ++n )
2021 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2025 return malloc(size);
2028 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2040 return realloc(ptr, size);
2043 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2047 free( (
char *) ptr );
2050 #define YYTABLES_NAME "yytables" 2052 #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.