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 5 12 #define YY_FLEX_SUBMINOR_VERSION 39 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 162 #define YY_BUF_SIZE 16384 167 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 169 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 170 #define YY_TYPEDEF_YY_BUFFER_STATE 174 #ifndef YY_TYPEDEF_YY_SIZE_T 175 #define YY_TYPEDEF_YY_SIZE_T 176 typedef size_t yy_size_t;
179 #define EOB_ACT_CONTINUE_SCAN 0 180 #define EOB_ACT_END_OF_FILE 1 181 #define EOB_ACT_LAST_MATCH 2 183 #define YY_LESS_LINENO(n) 184 #define YY_LINENO_REWIND_TO(ptr) 191 int yyless_macro_arg = (n); \ 192 YY_LESS_LINENO(yyless_macro_arg);\ 193 *yy_cp = yyg->yy_hold_char; \ 194 YY_RESTORE_YY_MORE_OFFSET \ 195 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 196 YY_DO_BEFORE_ACTION; \ 200 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) 202 #ifndef YY_STRUCT_YY_BUFFER_STATE 203 #define YY_STRUCT_YY_BUFFER_STATE 214 yy_size_t yy_buf_size;
219 yy_size_t yy_n_chars;
225 int yy_is_our_buffer;
232 int yy_is_interactive;
248 int yy_buffer_status;
250 #define YY_BUFFER_NEW 0 251 #define YY_BUFFER_NORMAL 1 262 #define YY_BUFFER_EOF_PENDING 2 273 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ 274 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ 280 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] 282 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
283 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
284 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
285 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
286 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
287 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
288 void pktloc_pop_buffer_state (yyscan_t yyscanner );
290 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
291 static void pktloc__load_buffer_state (yyscan_t yyscanner );
292 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
294 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner) 296 YY_BUFFER_STATE pktloc__scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
297 YY_BUFFER_STATE pktloc__scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
298 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char *bytes,yy_size_t len ,yyscan_t yyscanner );
300 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
301 void *pktloc_realloc (
void *,yy_size_t ,yyscan_t yyscanner );
302 void pktloc_free (
void * ,yyscan_t yyscanner );
304 #define yy_new_buffer pktloc__create_buffer 306 #define yy_set_interactive(is_interactive) \ 308 if ( ! YY_CURRENT_BUFFER ){ \ 309 pktloc_ensure_buffer_stack (yyscanner); \ 310 YY_CURRENT_BUFFER_LVALUE = \ 311 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 313 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 316 #define yy_set_bol(at_bol) \ 318 if ( ! YY_CURRENT_BUFFER ){\ 319 pktloc_ensure_buffer_stack (yyscanner); \ 320 YY_CURRENT_BUFFER_LVALUE = \ 321 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 323 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 326 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 328 #define pktloc_wrap(yyscanner) 1 329 #define YY_SKIP_YYWRAP 331 typedef unsigned char YY_CHAR;
333 typedef int yy_state_type;
335 #define yytext_ptr yytext_r 337 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
338 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
339 static int yy_get_next_buffer (yyscan_t yyscanner );
340 static void yy_fatal_error (yyconst
char msg[] ,yyscan_t yyscanner );
345 #define YY_DO_BEFORE_ACTION \ 346 yyg->yytext_ptr = yy_bp; \ 347 yyleng = (size_t) (yy_cp - yy_bp); \ 348 yyg->yy_hold_char = *yy_cp; \ 350 yyg->yy_c_buf_p = yy_cp; 352 #define YY_NUM_RULES 16 353 #define YY_END_OF_BUFFER 17 358 flex_int32_t yy_verify;
361 static yyconst flex_int16_t yy_accept[47] =
363 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
364 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
365 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
366 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
367 15, 15, 15, 15, 13, 0
370 static yyconst flex_int32_t yy_ec[256] =
372 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
373 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
374 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
375 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
376 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
377 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
378 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
379 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
380 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
381 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
383 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
384 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
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,
389 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,
394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
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,
402 static yyconst flex_int32_t yy_meta[29] =
404 1, 2, 3, 1, 2, 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
409 static yyconst flex_int16_t yy_base[50] =
411 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
412 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
413 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
414 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
415 30, 29, 26, 18, 0, 87, 31, 68, 70
418 static yyconst flex_int16_t yy_def[50] =
420 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
421 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
422 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
423 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
424 47, 47, 47, 47, 47, 0, 46, 46, 46
427 static yyconst flex_int16_t yy_nxt[116] =
429 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
430 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
431 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
432 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
433 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
434 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
435 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
436 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
437 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
438 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
440 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
444 static yyconst flex_int16_t yy_chk[116] =
446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
449 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
450 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
451 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
452 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
453 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
454 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
455 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
457 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
464 #define REJECT reject_used_but_not_detected 465 #define yymore() yymore_used_but_not_detected 466 #define YY_MORE_ADJ 0 467 #define YY_RESTORE_YY_MORE_OFFSET 468 #line 1 "route/pktloc_grammar.l" 469 #line 2 "route/pktloc_grammar.l" 470 #include <netlink-private/netlink.h> 471 #include <netlink-private/tc.h> 472 #include <netlink/netlink.h> 473 #include <netlink/utils.h> 474 #include <netlink/route/pktloc.h> 475 #include "pktloc_syntax.h" 476 #define YY_NO_INPUT 1 477 #line 478 "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;
506 yy_size_t yy_n_chars;
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 yy_size_t 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 );
597 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
600 #ifdef YY_NEED_STRLEN 601 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
607 static int yyinput (yyscan_t yyscanner );
609 static int input (yyscan_t yyscanner );
615 #ifndef YY_READ_BUF_SIZE 616 #define YY_READ_BUF_SIZE 8192 624 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 631 #define YY_INPUT(buf,result,max_size) \ 632 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 636 for ( n = 0; n < max_size && \ 637 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 640 buf[n++] = (char) c; \ 641 if ( c == EOF && ferror( yyin ) ) \ 642 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 648 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 650 if( errno != EINTR) \ 652 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 668 #define yyterminate() return YY_NULL 672 #ifndef YY_START_STACK_INCR 673 #define YY_START_STACK_INCR 25 677 #ifndef YY_FATAL_ERROR 678 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) 687 #define YY_DECL_IS_OURS 1 689 extern int pktloc_lex \
690 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
692 #define YY_DECL int pktloc_lex \ 693 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) 699 #ifndef YY_USER_ACTION 700 #define YY_USER_ACTION 705 #define YY_BREAK break; 708 #define YY_RULE_SETUP \ 715 register yy_state_type yy_current_state;
716 register char *yy_cp, *yy_bp;
720 yylval = yylval_param;
722 yylloc = yylloc_param;
732 if ( ! yyg->yy_start )
741 if ( ! YY_CURRENT_BUFFER ) {
742 pktloc_ensure_buffer_stack (yyscanner);
743 YY_CURRENT_BUFFER_LVALUE =
744 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
747 pktloc__load_buffer_state(yyscanner );
751 #line 20 "route/pktloc_grammar.l" 754 #line 755 "route/pktloc_grammar.c" 758 yy_cp = yyg->yy_c_buf_p;
761 *yy_cp = yyg->yy_hold_char;
768 yy_current_state = yyg->yy_start;
772 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
773 if ( yy_accept[yy_current_state] )
775 yyg->yy_last_accepting_state = yy_current_state;
776 yyg->yy_last_accepting_cpos = yy_cp;
778 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
780 yy_current_state = (int) yy_def[yy_current_state];
781 if ( yy_current_state >= 47 )
782 yy_c = yy_meta[(
unsigned int) yy_c];
784 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
787 while ( yy_base[yy_current_state] != 87 );
790 yy_act = yy_accept[yy_current_state];
793 yy_cp = yyg->yy_last_accepting_cpos;
794 yy_current_state = yyg->yy_last_accepting_state;
795 yy_act = yy_accept[yy_current_state];
806 *yy_cp = yyg->yy_hold_char;
807 yy_cp = yyg->yy_last_accepting_cpos;
808 yy_current_state = yyg->yy_last_accepting_state;
814 #line 22 "route/pktloc_grammar.l" 819 #line 24 "route/pktloc_grammar.l" 823 #line 27 "route/pktloc_grammar.l" 826 #line 27 "route/pktloc_grammar.l" 828 yylval->i = strtoul(yytext, NULL, 0);
834 #line 32 "route/pktloc_grammar.l" 835 {
return yylval->i = yytext[0]; }
839 #line 34 "route/pktloc_grammar.l" 840 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
844 #line 35 "route/pktloc_grammar.l" 845 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
849 #line 36 "route/pktloc_grammar.l" 850 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
853 #line 39 "route/pktloc_grammar.l" 856 #line 39 "route/pktloc_grammar.l" 857 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
860 #line 41 "route/pktloc_grammar.l" 863 #line 41 "route/pktloc_grammar.l" 864 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
867 #line 43 "route/pktloc_grammar.l" 870 #line 43 "route/pktloc_grammar.l" 871 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
875 #line 46 "route/pktloc_grammar.l" 877 yylval->s = strdup(yytext);
878 if (yylval->s == NULL)
885 #line 52 "route/pktloc_grammar.l" 888 #line 889 "route/pktloc_grammar.c" 889 case YY_STATE_EOF(INITIAL):
892 case YY_END_OF_BUFFER:
895 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
898 *yy_cp = yyg->yy_hold_char;
899 YY_RESTORE_YY_MORE_OFFSET
901 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
912 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
913 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
914 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
924 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
926 yy_state_type yy_next_state;
928 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
930 yy_current_state = yy_get_previous_state( yyscanner );
941 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
943 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
948 yy_cp = ++yyg->yy_c_buf_p;
949 yy_current_state = yy_next_state;
955 yy_cp = yyg->yy_c_buf_p;
960 else switch ( yy_get_next_buffer( yyscanner ) )
962 case EOB_ACT_END_OF_FILE:
964 yyg->yy_did_buffer_switch_on_eof = 0;
966 if ( pktloc_wrap(yyscanner ) )
977 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
979 yy_act = YY_STATE_EOF(YY_START);
985 if ( ! yyg->yy_did_buffer_switch_on_eof )
991 case EOB_ACT_CONTINUE_SCAN:
993 yyg->yytext_ptr + yy_amount_of_matched_text;
995 yy_current_state = yy_get_previous_state( yyscanner );
997 yy_cp = yyg->yy_c_buf_p;
998 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1001 case EOB_ACT_LAST_MATCH:
1003 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1005 yy_current_state = yy_get_previous_state( yyscanner );
1007 yy_cp = yyg->yy_c_buf_p;
1008 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1009 goto yy_find_action;
1016 "fatal flex scanner internal error--no action found" );
1029 static int yy_get_next_buffer (yyscan_t yyscanner)
1032 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1033 register char *source = yyg->yytext_ptr;
1034 register int number_to_move, i;
1037 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1039 "fatal flex scanner internal error--end of buffer missed" );
1041 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1043 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1048 return EOB_ACT_END_OF_FILE;
1056 return EOB_ACT_LAST_MATCH;
1063 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1065 for ( i = 0; i < number_to_move; ++i )
1066 *(dest++) = *(source++);
1068 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1072 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1076 yy_size_t num_to_read =
1077 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1079 while ( num_to_read <= 0 )
1083 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1085 int yy_c_buf_p_offset =
1086 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1088 if ( b->yy_is_our_buffer )
1090 yy_size_t new_size = b->yy_buf_size * 2;
1092 if ( new_size <= 0 )
1093 b->yy_buf_size += b->yy_buf_size / 8;
1095 b->yy_buf_size *= 2;
1097 b->yy_ch_buf = (
char *)
1099 pktloc_realloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1105 if ( ! b->yy_ch_buf )
1107 "fatal error - scanner input buffer overflow" );
1109 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1111 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1116 if ( num_to_read > YY_READ_BUF_SIZE )
1117 num_to_read = YY_READ_BUF_SIZE;
1120 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1121 yyg->yy_n_chars, num_to_read );
1123 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1126 if ( yyg->yy_n_chars == 0 )
1128 if ( number_to_move == YY_MORE_ADJ )
1130 ret_val = EOB_ACT_END_OF_FILE;
1131 pktloc_restart(yyin ,yyscanner);
1136 ret_val = EOB_ACT_LAST_MATCH;
1137 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1138 YY_BUFFER_EOF_PENDING;
1143 ret_val = EOB_ACT_CONTINUE_SCAN;
1145 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1147 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1148 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1149 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1150 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1153 yyg->yy_n_chars += number_to_move;
1154 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1155 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1157 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1164 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1166 register yy_state_type yy_current_state;
1167 register char *yy_cp;
1170 yy_current_state = yyg->yy_start;
1172 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1174 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1175 if ( yy_accept[yy_current_state] )
1177 yyg->yy_last_accepting_state = yy_current_state;
1178 yyg->yy_last_accepting_cpos = yy_cp;
1180 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1182 yy_current_state = (int) yy_def[yy_current_state];
1183 if ( yy_current_state >= 47 )
1184 yy_c = yy_meta[(
unsigned int) yy_c];
1186 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1189 return yy_current_state;
1197 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1199 register int yy_is_jam;
1201 register char *yy_cp = yyg->yy_c_buf_p;
1203 register YY_CHAR yy_c = 1;
1204 if ( yy_accept[yy_current_state] )
1206 yyg->yy_last_accepting_state = yy_current_state;
1207 yyg->yy_last_accepting_cpos = yy_cp;
1209 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1211 yy_current_state = (int) yy_def[yy_current_state];
1212 if ( yy_current_state >= 47 )
1213 yy_c = yy_meta[(
unsigned int) yy_c];
1215 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1216 yy_is_jam = (yy_current_state == 46);
1219 return yy_is_jam ? 0 : yy_current_state;
1224 static int yyinput (yyscan_t yyscanner)
1226 static int input (yyscan_t yyscanner)
1233 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1235 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1241 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1243 *yyg->yy_c_buf_p =
'\0';
1247 yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1250 switch ( yy_get_next_buffer( yyscanner ) )
1252 case EOB_ACT_LAST_MATCH:
1264 pktloc_restart(yyin ,yyscanner);
1268 case EOB_ACT_END_OF_FILE:
1270 if ( pktloc_wrap(yyscanner ) )
1273 if ( ! yyg->yy_did_buffer_switch_on_eof )
1276 return yyinput(yyscanner);
1278 return input(yyscanner);
1282 case EOB_ACT_CONTINUE_SCAN:
1283 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1289 c = *(
unsigned char *) yyg->yy_c_buf_p;
1290 *yyg->yy_c_buf_p =
'\0';
1291 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1302 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1306 if ( ! YY_CURRENT_BUFFER ){
1307 pktloc_ensure_buffer_stack (yyscanner);
1308 YY_CURRENT_BUFFER_LVALUE =
1309 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1312 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1313 pktloc__load_buffer_state(yyscanner );
1320 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1329 pktloc_ensure_buffer_stack (yyscanner);
1330 if ( YY_CURRENT_BUFFER == new_buffer )
1333 if ( YY_CURRENT_BUFFER )
1336 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1337 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1338 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1341 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1342 pktloc__load_buffer_state(yyscanner );
1349 yyg->yy_did_buffer_switch_on_eof = 1;
1352 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1355 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1356 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1357 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1358 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1367 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1371 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1373 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1375 b->yy_buf_size = size;
1380 b->yy_ch_buf = (
char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
1381 if ( ! b->yy_ch_buf )
1382 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1384 b->yy_is_our_buffer = 1;
1386 pktloc__init_buffer(b,file ,yyscanner);
1395 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1402 if ( b == YY_CURRENT_BUFFER )
1403 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1405 if ( b->yy_is_our_buffer )
1406 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1408 pktloc_free((
void *) b ,yyscanner );
1415 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1421 pktloc__flush_buffer(b ,yyscanner);
1423 b->yy_input_file = file;
1424 b->yy_fill_buffer = 1;
1430 if (b != YY_CURRENT_BUFFER){
1435 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1444 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1456 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1457 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1459 b->yy_buf_pos = &b->yy_ch_buf[0];
1462 b->yy_buffer_status = YY_BUFFER_NEW;
1464 if ( b == YY_CURRENT_BUFFER )
1465 pktloc__load_buffer_state(yyscanner );
1474 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1477 if (new_buffer == NULL)
1480 pktloc_ensure_buffer_stack(yyscanner);
1483 if ( YY_CURRENT_BUFFER )
1486 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1487 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1488 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1492 if (YY_CURRENT_BUFFER)
1494 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1497 pktloc__load_buffer_state(yyscanner );
1498 yyg->yy_did_buffer_switch_on_eof = 1;
1505 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1508 if (!YY_CURRENT_BUFFER)
1511 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1512 YY_CURRENT_BUFFER_LVALUE = NULL;
1516 if (YY_CURRENT_BUFFER) {
1517 pktloc__load_buffer_state(yyscanner );
1518 yyg->yy_did_buffer_switch_on_eof = 1;
1525 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1527 yy_size_t num_to_alloc;
1541 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1561 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1575 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1580 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1581 base[size-1] != YY_END_OF_BUFFER_CHAR )
1585 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1587 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1589 b->yy_buf_size = size - 2;
1590 b->yy_buf_pos = b->yy_ch_buf = base;
1591 b->yy_is_our_buffer = 0;
1592 b->yy_input_file = 0;
1593 b->yy_n_chars = b->yy_buf_size;
1594 b->yy_is_interactive = 0;
1596 b->yy_fill_buffer = 0;
1597 b->yy_buffer_status = YY_BUFFER_NEW;
1599 pktloc__switch_to_buffer(b ,yyscanner );
1612 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1615 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
1625 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
1633 n = _yybytes_len + 2;
1634 buf = (
char *) pktloc_alloc(n ,yyscanner );
1636 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1638 for ( i = 0; i < _yybytes_len; ++i )
1639 buf[i] = yybytes[i];
1641 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1643 b = pktloc__scan_buffer(buf,n ,yyscanner);
1645 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1650 b->yy_is_our_buffer = 1;
1655 #ifndef YY_EXIT_FAILURE 1656 #define YY_EXIT_FAILURE 2 1659 static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1661 (void) fprintf( stderr,
"%s\n", msg );
1662 exit( YY_EXIT_FAILURE );
1672 int yyless_macro_arg = (n); \ 1673 YY_LESS_LINENO(yyless_macro_arg);\ 1674 yytext[yyleng] = yyg->yy_hold_char; \ 1675 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 1676 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 1677 *yyg->yy_c_buf_p = '\0'; \ 1678 yyleng = yyless_macro_arg; \ 1687 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1696 int pktloc_get_lineno (yyscan_t yyscanner)
1700 if (! YY_CURRENT_BUFFER)
1709 int pktloc_get_column (yyscan_t yyscanner)
1713 if (! YY_CURRENT_BUFFER)
1722 FILE *pktloc_get_in (yyscan_t yyscanner)
1731 FILE *pktloc_get_out (yyscan_t yyscanner)
1740 yy_size_t pktloc_get_leng (yyscan_t yyscanner)
1750 char *pktloc_get_text (yyscan_t yyscanner)
1760 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1763 yyextra = user_defined ;
1770 void pktloc_set_lineno (
int line_number , yyscan_t yyscanner)
1775 if (! YY_CURRENT_BUFFER )
1776 YY_FATAL_ERROR(
"pktloc_set_lineno called with no buffer" );
1778 yylineno = line_number;
1785 void pktloc_set_column (
int column_no , yyscan_t yyscanner)
1790 if (! YY_CURRENT_BUFFER )
1791 YY_FATAL_ERROR(
"pktloc_set_column called with no buffer" );
1793 yycolumn = column_no;
1802 void pktloc_set_in (FILE * in_str , yyscan_t yyscanner)
1808 void pktloc_set_out (FILE * out_str , yyscan_t yyscanner)
1814 int pktloc_get_debug (yyscan_t yyscanner)
1817 return yy_flex_debug;
1820 void pktloc_set_debug (
int bdebug , yyscan_t yyscanner)
1823 yy_flex_debug = bdebug ;
1828 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1834 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1837 yylval = yylval_param;
1840 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1846 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1849 yylloc = yylloc_param;
1859 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1862 if (ptr_yy_globals == NULL){
1867 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1869 if (*ptr_yy_globals == NULL){
1875 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1877 return yy_init_globals ( *ptr_yy_globals );
1888 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1893 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1895 if (ptr_yy_globals == NULL){
1900 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1902 if (*ptr_yy_globals == NULL){
1909 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1911 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1913 return yy_init_globals ( *ptr_yy_globals );
1916 static int yy_init_globals (yyscan_t yyscanner)
1926 yyg->yy_c_buf_p = (
char *) 0;
1930 yyg->yy_start_stack_ptr = 0;
1931 yyg->yy_start_stack_depth = 0;
1932 yyg->yy_start_stack = NULL;
1950 int pktloc_lex_destroy (yyscan_t yyscanner)
1955 while(YY_CURRENT_BUFFER){
1956 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1957 YY_CURRENT_BUFFER_LVALUE = NULL;
1958 pktloc_pop_buffer_state(yyscanner);
1966 pktloc_free(yyg->yy_start_stack ,yyscanner );
1967 yyg->yy_start_stack = NULL;
1971 yy_init_globals( yyscanner);
1974 pktloc_free ( yyscanner , yyscanner );
1984 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
1987 for ( i = 0; i < n; ++i )
1992 #ifdef YY_NEED_STRLEN 1993 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
1996 for ( n = 0; s[n]; ++n )
2003 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2005 return (
void *) malloc( size );
2008 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2017 return (
void *) realloc( (
char *) ptr, size );
2020 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2022 free( (
char *) ptr );
2025 #define YYTABLES_NAME "yytables" 2027 #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.