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 35
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;
61 #define INT8_MIN (-128)
64 #define INT16_MIN (-32767-1)
67 #define INT32_MIN (-2147483647-1)
70 #define INT8_MAX (127)
73 #define INT16_MAX (32767)
76 #define INT32_MAX (2147483647)
79 #define UINT8_MAX (255U)
82 #define UINT16_MAX (65535U)
85 #define UINT32_MAX (4294967295U)
98 #if defined (__STDC__)
106 #define yyconst const
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
122 #ifndef YY_TYPEDEF_YY_SCANNER_T
123 #define YY_TYPEDEF_YY_SCANNER_T
124 typedef void* yyscan_t;
129 #define yyin yyg->yyin_r
130 #define yyout yyg->yyout_r
131 #define yyextra yyg->yyextra_r
132 #define yyleng yyg->yyleng_r
133 #define yytext yyg->yytext_r
134 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
135 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
136 #define yy_flex_debug yyg->yy_flex_debug_r
142 #define BEGIN yyg->yy_start = 1 + 2 *
148 #define YY_START ((yyg->yy_start - 1) / 2)
149 #define YYSTATE YY_START
152 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155 #define YY_NEW_FILE pktloc_restart(yyin ,yyscanner )
157 #define YY_END_OF_BUFFER_CHAR 0
161 #define YY_BUF_SIZE 16384
166 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
169 #define YY_TYPEDEF_YY_BUFFER_STATE
173 #define EOB_ACT_CONTINUE_SCAN 0
174 #define EOB_ACT_END_OF_FILE 1
175 #define EOB_ACT_LAST_MATCH 2
177 #define YY_LESS_LINENO(n)
184 int yyless_macro_arg = (n); \
185 YY_LESS_LINENO(yyless_macro_arg);\
186 *yy_cp = yyg->yy_hold_char; \
187 YY_RESTORE_YY_MORE_OFFSET \
188 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
189 YY_DO_BEFORE_ACTION; \
193 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
195 #ifndef YY_TYPEDEF_YY_SIZE_T
196 #define YY_TYPEDEF_YY_SIZE_T
197 typedef size_t yy_size_t;
200 #ifndef YY_STRUCT_YY_BUFFER_STATE
201 #define YY_STRUCT_YY_BUFFER_STATE
212 yy_size_t yy_buf_size;
223 int yy_is_our_buffer;
230 int yy_is_interactive;
246 int yy_buffer_status;
248 #define YY_BUFFER_NEW 0
249 #define YY_BUFFER_NORMAL 1
260 #define YY_BUFFER_EOF_PENDING 2
271 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
272 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
278 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
280 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
281 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
282 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
283 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
284 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
285 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
286 void pktloc_pop_buffer_state (yyscan_t yyscanner );
288 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
289 static void pktloc__load_buffer_state (yyscan_t yyscanner );
290 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
292 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
294 YY_BUFFER_STATE pktloc__scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
295 YY_BUFFER_STATE pktloc__scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
296 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char *bytes,
int len ,yyscan_t yyscanner );
298 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
299 void *pktloc_realloc (
void *,yy_size_t ,yyscan_t yyscanner );
300 void pktloc_free (
void * ,yyscan_t yyscanner );
302 #define yy_new_buffer pktloc__create_buffer
304 #define yy_set_interactive(is_interactive) \
306 if ( ! YY_CURRENT_BUFFER ){ \
307 pktloc_ensure_buffer_stack (yyscanner); \
308 YY_CURRENT_BUFFER_LVALUE = \
309 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
311 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
314 #define yy_set_bol(at_bol) \
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_at_bol = at_bol; \
324 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
326 #define pktloc_wrap(n) 1
327 #define YY_SKIP_YYWRAP
329 typedef unsigned char YY_CHAR;
331 typedef int yy_state_type;
333 #define yytext_ptr yytext_r
335 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
336 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
337 static int yy_get_next_buffer (yyscan_t yyscanner );
338 static void yy_fatal_error (yyconst
char msg[] ,yyscan_t yyscanner );
343 #define YY_DO_BEFORE_ACTION \
344 yyg->yytext_ptr = yy_bp; \
345 yyleng = (size_t) (yy_cp - yy_bp); \
346 yyg->yy_hold_char = *yy_cp; \
348 yyg->yy_c_buf_p = yy_cp;
350 #define YY_NUM_RULES 16
351 #define YY_END_OF_BUFFER 17
356 flex_int32_t yy_verify;
359 static yyconst flex_int16_t yy_accept[47] =
361 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
362 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
363 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
364 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
365 15, 15, 15, 15, 13, 0
368 static yyconst flex_int32_t yy_ec[256] =
370 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
371 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
373 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
374 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
375 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
376 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
377 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
378 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
379 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
381 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
382 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
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,
389 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390 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,
395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 static yyconst flex_int32_t yy_meta[29] =
402 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
404 1, 1, 1, 1, 1, 1, 1, 1
407 static yyconst flex_int16_t yy_base[50] =
409 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
410 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
411 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
412 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
413 30, 29, 26, 18, 0, 87, 31, 68, 70
416 static yyconst flex_int16_t yy_def[50] =
418 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
419 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
420 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
421 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
422 47, 47, 47, 47, 47, 0, 46, 46, 46
425 static yyconst flex_int16_t yy_nxt[116] =
427 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
428 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
429 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
430 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
431 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
432 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
433 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
434 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
435 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
436 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
438 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
442 static yyconst flex_int16_t yy_chk[116] =
444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
447 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
448 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
449 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
450 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
451 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
452 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
453 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
455 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
462 #define REJECT reject_used_but_not_detected
463 #define yymore() yymore_used_but_not_detected
464 #define YY_MORE_ADJ 0
465 #define YY_RESTORE_YY_MORE_OFFSET
466 #line 1 "route/pktloc_grammar.l"
467 #line 2 "route/pktloc_grammar.l"
468 #include <netlink-local.h>
469 #include <netlink-tc.h>
470 #include <netlink/netlink.h>
471 #include <netlink/utils.h>
472 #include <netlink/route/pktloc.h>
473 #include "pktloc_syntax.h"
474 #define YY_NO_INPUT 1
475 #line 476 "route/pktloc_grammar.c"
479 #ifndef YY_NO_UNISTD_H
487 #ifndef YY_EXTRA_TYPE
488 #define YY_EXTRA_TYPE void *
496 YY_EXTRA_TYPE yyextra_r;
499 FILE *yyin_r, *yyout_r;
509 int yy_did_buffer_switch_on_eof;
510 int yy_start_stack_ptr;
511 int yy_start_stack_depth;
513 yy_state_type yy_last_accepting_state;
514 char* yy_last_accepting_cpos;
529 static int yy_init_globals (yyscan_t yyscanner );
533 # define yylval yyg->yylval_r
535 # define yylloc yyg->yylloc_r
537 int pktloc_lex_init (yyscan_t* scanner);
539 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
544 int pktloc_lex_destroy (yyscan_t yyscanner );
546 int pktloc_get_debug (yyscan_t yyscanner );
548 void pktloc_set_debug (
int debug_flag ,yyscan_t yyscanner );
550 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
552 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
554 FILE *pktloc_get_in (yyscan_t yyscanner );
556 void pktloc_set_in (FILE * in_str ,yyscan_t yyscanner );
558 FILE *pktloc_get_out (yyscan_t yyscanner );
560 void pktloc_set_out (FILE * out_str ,yyscan_t yyscanner );
562 int pktloc_get_leng (yyscan_t yyscanner );
564 char *pktloc_get_text (yyscan_t yyscanner );
566 int pktloc_get_lineno (yyscan_t yyscanner );
568 void pktloc_set_lineno (
int line_number ,yyscan_t yyscanner );
570 int pktloc_get_column (yyscan_t yyscanner );
572 void pktloc_set_column (
int column_no ,yyscan_t yyscanner );
574 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
576 void pktloc_set_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
578 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
580 void pktloc_set_lloc (
YYLTYPE * yylloc_param ,yyscan_t yyscanner );
586 #ifndef YY_SKIP_YYWRAP
588 extern "C" int pktloc_wrap (yyscan_t yyscanner );
590 extern int pktloc_wrap (yyscan_t yyscanner );
595 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
598 #ifdef YY_NEED_STRLEN
599 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
605 static int yyinput (yyscan_t yyscanner );
607 static int input (yyscan_t yyscanner );
613 #ifndef YY_READ_BUF_SIZE
614 #define YY_READ_BUF_SIZE 8192
622 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
629 #define YY_INPUT(buf,result,max_size) \
630 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
634 for ( n = 0; n < max_size && \
635 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
638 buf[n++] = (char) c; \
639 if ( c == EOF && ferror( yyin ) ) \
640 YY_FATAL_ERROR( "input in flex scanner failed" ); \
646 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
648 if( errno != EINTR) \
650 YY_FATAL_ERROR( "input in flex scanner failed" ); \
666 #define yyterminate() return YY_NULL
670 #ifndef YY_START_STACK_INCR
671 #define YY_START_STACK_INCR 25
675 #ifndef YY_FATAL_ERROR
676 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
685 #define YY_DECL_IS_OURS 1
687 extern int pktloc_lex \
688 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
690 #define YY_DECL int pktloc_lex \
691 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
697 #ifndef YY_USER_ACTION
698 #define YY_USER_ACTION
703 #define YY_BREAK break;
706 #define YY_RULE_SETUP \
713 register yy_state_type yy_current_state;
714 register char *yy_cp, *yy_bp;
718 #line 20 "route/pktloc_grammar.l"
721 #line 722 "route/pktloc_grammar.c"
723 yylval = yylval_param;
725 yylloc = yylloc_param;
735 if ( ! yyg->yy_start )
744 if ( ! YY_CURRENT_BUFFER ) {
745 pktloc_ensure_buffer_stack (yyscanner);
746 YY_CURRENT_BUFFER_LVALUE =
747 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
750 pktloc__load_buffer_state(yyscanner );
755 yy_cp = yyg->yy_c_buf_p;
758 *yy_cp = yyg->yy_hold_char;
765 yy_current_state = yyg->yy_start;
769 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
770 if ( yy_accept[yy_current_state] )
772 yyg->yy_last_accepting_state = yy_current_state;
773 yyg->yy_last_accepting_cpos = yy_cp;
775 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
777 yy_current_state = (int) yy_def[yy_current_state];
778 if ( yy_current_state >= 47 )
779 yy_c = yy_meta[(
unsigned int) yy_c];
781 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
784 while ( yy_base[yy_current_state] != 87 );
787 yy_act = yy_accept[yy_current_state];
790 yy_cp = yyg->yy_last_accepting_cpos;
791 yy_current_state = yyg->yy_last_accepting_state;
792 yy_act = yy_accept[yy_current_state];
803 *yy_cp = yyg->yy_hold_char;
804 yy_cp = yyg->yy_last_accepting_cpos;
805 yy_current_state = yyg->yy_last_accepting_state;
811 #line 22 "route/pktloc_grammar.l"
816 #line 24 "route/pktloc_grammar.l"
820 #line 27 "route/pktloc_grammar.l"
823 #line 27 "route/pktloc_grammar.l"
825 yylval->i = strtoul(yytext, NULL, 0);
831 #line 32 "route/pktloc_grammar.l"
832 {
return yylval->i = yytext[0]; }
836 #line 34 "route/pktloc_grammar.l"
837 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
841 #line 35 "route/pktloc_grammar.l"
842 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
846 #line 36 "route/pktloc_grammar.l"
847 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
850 #line 39 "route/pktloc_grammar.l"
853 #line 39 "route/pktloc_grammar.l"
854 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
857 #line 41 "route/pktloc_grammar.l"
860 #line 41 "route/pktloc_grammar.l"
861 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
864 #line 43 "route/pktloc_grammar.l"
867 #line 43 "route/pktloc_grammar.l"
868 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
872 #line 46 "route/pktloc_grammar.l"
874 yylval->s = strdup(yytext);
875 if (yylval->s == NULL)
882 #line 52 "route/pktloc_grammar.l"
885 #line 886 "route/pktloc_grammar.c"
886 case YY_STATE_EOF(INITIAL):
889 case YY_END_OF_BUFFER:
892 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
895 *yy_cp = yyg->yy_hold_char;
896 YY_RESTORE_YY_MORE_OFFSET
898 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
909 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
910 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
911 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
921 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
923 yy_state_type yy_next_state;
925 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
927 yy_current_state = yy_get_previous_state( yyscanner );
938 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
940 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
945 yy_cp = ++yyg->yy_c_buf_p;
946 yy_current_state = yy_next_state;
952 yy_cp = yyg->yy_c_buf_p;
957 else switch ( yy_get_next_buffer( yyscanner ) )
959 case EOB_ACT_END_OF_FILE:
961 yyg->yy_did_buffer_switch_on_eof = 0;
963 if ( pktloc_wrap(yyscanner ) )
974 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
976 yy_act = YY_STATE_EOF(YY_START);
982 if ( ! yyg->yy_did_buffer_switch_on_eof )
988 case EOB_ACT_CONTINUE_SCAN:
990 yyg->yytext_ptr + yy_amount_of_matched_text;
992 yy_current_state = yy_get_previous_state( yyscanner );
994 yy_cp = yyg->yy_c_buf_p;
995 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
998 case EOB_ACT_LAST_MATCH:
1000 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1002 yy_current_state = yy_get_previous_state( yyscanner );
1004 yy_cp = yyg->yy_c_buf_p;
1005 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1006 goto yy_find_action;
1013 "fatal flex scanner internal error--no action found" );
1025 static int yy_get_next_buffer (yyscan_t yyscanner)
1028 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1029 register char *source = yyg->yytext_ptr;
1030 register int number_to_move, i;
1033 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1035 "fatal flex scanner internal error--end of buffer missed" );
1037 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1039 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1044 return EOB_ACT_END_OF_FILE;
1052 return EOB_ACT_LAST_MATCH;
1059 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1061 for ( i = 0; i < number_to_move; ++i )
1062 *(dest++) = *(source++);
1064 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1068 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1073 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1075 while ( num_to_read <= 0 )
1079 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1081 int yy_c_buf_p_offset =
1082 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1084 if ( b->yy_is_our_buffer )
1086 int new_size = b->yy_buf_size * 2;
1088 if ( new_size <= 0 )
1089 b->yy_buf_size += b->yy_buf_size / 8;
1091 b->yy_buf_size *= 2;
1093 b->yy_ch_buf = (
char *)
1095 pktloc_realloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1101 if ( ! b->yy_ch_buf )
1103 "fatal error - scanner input buffer overflow" );
1105 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1107 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1112 if ( num_to_read > YY_READ_BUF_SIZE )
1113 num_to_read = YY_READ_BUF_SIZE;
1116 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1117 yyg->yy_n_chars, (
size_t) num_to_read );
1119 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1122 if ( yyg->yy_n_chars == 0 )
1124 if ( number_to_move == YY_MORE_ADJ )
1126 ret_val = EOB_ACT_END_OF_FILE;
1127 pktloc_restart(yyin ,yyscanner);
1132 ret_val = EOB_ACT_LAST_MATCH;
1133 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1134 YY_BUFFER_EOF_PENDING;
1139 ret_val = EOB_ACT_CONTINUE_SCAN;
1141 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1143 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1144 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1145 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1146 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1149 yyg->yy_n_chars += number_to_move;
1150 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1151 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1153 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1160 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1162 register yy_state_type yy_current_state;
1163 register char *yy_cp;
1166 yy_current_state = yyg->yy_start;
1168 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1170 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1171 if ( yy_accept[yy_current_state] )
1173 yyg->yy_last_accepting_state = yy_current_state;
1174 yyg->yy_last_accepting_cpos = yy_cp;
1176 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1178 yy_current_state = (int) yy_def[yy_current_state];
1179 if ( yy_current_state >= 47 )
1180 yy_c = yy_meta[(
unsigned int) yy_c];
1182 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1185 return yy_current_state;
1193 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1195 register int yy_is_jam;
1197 register char *yy_cp = yyg->yy_c_buf_p;
1199 register YY_CHAR yy_c = 1;
1200 if ( yy_accept[yy_current_state] )
1202 yyg->yy_last_accepting_state = yy_current_state;
1203 yyg->yy_last_accepting_cpos = yy_cp;
1205 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1207 yy_current_state = (int) yy_def[yy_current_state];
1208 if ( yy_current_state >= 47 )
1209 yy_c = yy_meta[(
unsigned int) yy_c];
1211 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1212 yy_is_jam = (yy_current_state == 46);
1214 return yy_is_jam ? 0 : yy_current_state;
1219 static int yyinput (yyscan_t yyscanner)
1221 static int input (yyscan_t yyscanner)
1228 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1230 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1236 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1238 *yyg->yy_c_buf_p =
'\0';
1242 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1245 switch ( yy_get_next_buffer( yyscanner ) )
1247 case EOB_ACT_LAST_MATCH:
1259 pktloc_restart(yyin ,yyscanner);
1263 case EOB_ACT_END_OF_FILE:
1265 if ( pktloc_wrap(yyscanner ) )
1268 if ( ! yyg->yy_did_buffer_switch_on_eof )
1271 return yyinput(yyscanner);
1273 return input(yyscanner);
1277 case EOB_ACT_CONTINUE_SCAN:
1278 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1284 c = *(
unsigned char *) yyg->yy_c_buf_p;
1285 *yyg->yy_c_buf_p =
'\0';
1286 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1297 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1301 if ( ! YY_CURRENT_BUFFER ){
1302 pktloc_ensure_buffer_stack (yyscanner);
1303 YY_CURRENT_BUFFER_LVALUE =
1304 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1307 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1308 pktloc__load_buffer_state(yyscanner );
1315 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1324 pktloc_ensure_buffer_stack (yyscanner);
1325 if ( YY_CURRENT_BUFFER == new_buffer )
1328 if ( YY_CURRENT_BUFFER )
1331 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1332 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1333 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1336 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1337 pktloc__load_buffer_state(yyscanner );
1344 yyg->yy_did_buffer_switch_on_eof = 1;
1347 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1350 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1351 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1352 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1353 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1362 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1366 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1368 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1370 b->yy_buf_size = size;
1375 b->yy_ch_buf = (
char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
1376 if ( ! b->yy_ch_buf )
1377 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1379 b->yy_is_our_buffer = 1;
1381 pktloc__init_buffer(b,file ,yyscanner);
1390 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1397 if ( b == YY_CURRENT_BUFFER )
1398 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1400 if ( b->yy_is_our_buffer )
1401 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1403 pktloc_free((
void *) b ,yyscanner );
1407 extern int isatty (
int );
1414 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1420 pktloc__flush_buffer(b ,yyscanner);
1422 b->yy_input_file = file;
1423 b->yy_fill_buffer = 1;
1429 if (b != YY_CURRENT_BUFFER){
1434 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1443 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1455 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1456 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1458 b->yy_buf_pos = &b->yy_ch_buf[0];
1461 b->yy_buffer_status = YY_BUFFER_NEW;
1463 if ( b == YY_CURRENT_BUFFER )
1464 pktloc__load_buffer_state(yyscanner );
1473 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1476 if (new_buffer == NULL)
1479 pktloc_ensure_buffer_stack(yyscanner);
1482 if ( YY_CURRENT_BUFFER )
1485 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1486 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1487 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1491 if (YY_CURRENT_BUFFER)
1493 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1496 pktloc__load_buffer_state(yyscanner );
1497 yyg->yy_did_buffer_switch_on_eof = 1;
1504 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1507 if (!YY_CURRENT_BUFFER)
1510 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1511 YY_CURRENT_BUFFER_LVALUE = NULL;
1515 if (YY_CURRENT_BUFFER) {
1516 pktloc__load_buffer_state(yyscanner );
1517 yyg->yy_did_buffer_switch_on_eof = 1;
1524 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1540 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1560 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1574 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1579 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1580 base[size-1] != YY_END_OF_BUFFER_CHAR )
1584 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1586 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1588 b->yy_buf_size = size - 2;
1589 b->yy_buf_pos = b->yy_ch_buf = base;
1590 b->yy_is_our_buffer = 0;
1591 b->yy_input_file = 0;
1592 b->yy_n_chars = b->yy_buf_size;
1593 b->yy_is_interactive = 0;
1595 b->yy_fill_buffer = 0;
1596 b->yy_buffer_status = YY_BUFFER_NEW;
1598 pktloc__switch_to_buffer(b ,yyscanner );
1611 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1614 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
1624 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1632 n = _yybytes_len + 2;
1633 buf = (
char *) pktloc_alloc(n ,yyscanner );
1635 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1637 for ( i = 0; i < _yybytes_len; ++i )
1638 buf[i] = yybytes[i];
1640 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1642 b = pktloc__scan_buffer(buf,n ,yyscanner);
1644 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1649 b->yy_is_our_buffer = 1;
1654 #ifndef YY_EXIT_FAILURE
1655 #define YY_EXIT_FAILURE 2
1658 static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1660 (void) fprintf( stderr,
"%s\n", msg );
1661 exit( YY_EXIT_FAILURE );
1671 int yyless_macro_arg = (n); \
1672 YY_LESS_LINENO(yyless_macro_arg);\
1673 yytext[yyleng] = yyg->yy_hold_char; \
1674 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1675 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1676 *yyg->yy_c_buf_p = '\0'; \
1677 yyleng = yyless_macro_arg; \
1686 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1695 int pktloc_get_lineno (yyscan_t yyscanner)
1699 if (! YY_CURRENT_BUFFER)
1708 int pktloc_get_column (yyscan_t yyscanner)
1712 if (! YY_CURRENT_BUFFER)
1721 FILE *pktloc_get_in (yyscan_t yyscanner)
1730 FILE *pktloc_get_out (yyscan_t yyscanner)
1739 int pktloc_get_leng (yyscan_t yyscanner)
1749 char *pktloc_get_text (yyscan_t yyscanner)
1759 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1762 yyextra = user_defined ;
1769 void pktloc_set_lineno (
int line_number , yyscan_t yyscanner)
1774 if (! YY_CURRENT_BUFFER )
1775 yy_fatal_error(
"pktloc_set_lineno called with no buffer" , yyscanner);
1777 yylineno = line_number;
1784 void pktloc_set_column (
int column_no , yyscan_t yyscanner)
1789 if (! YY_CURRENT_BUFFER )
1790 yy_fatal_error(
"pktloc_set_column called with no buffer" , yyscanner);
1792 yycolumn = column_no;
1801 void pktloc_set_in (FILE * in_str , yyscan_t yyscanner)
1807 void pktloc_set_out (FILE * out_str , yyscan_t yyscanner)
1813 int pktloc_get_debug (yyscan_t yyscanner)
1816 return yy_flex_debug;
1819 void pktloc_set_debug (
int bdebug , yyscan_t yyscanner)
1822 yy_flex_debug = bdebug ;
1827 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1833 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1836 yylval = yylval_param;
1839 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1845 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1848 yylloc = yylloc_param;
1858 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1861 if (ptr_yy_globals == NULL){
1866 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1868 if (*ptr_yy_globals == NULL){
1874 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1876 return yy_init_globals ( *ptr_yy_globals );
1887 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1892 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1894 if (ptr_yy_globals == NULL){
1899 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1901 if (*ptr_yy_globals == NULL){
1908 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1910 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1912 return yy_init_globals ( *ptr_yy_globals );
1915 static int yy_init_globals (yyscan_t yyscanner)
1925 yyg->yy_c_buf_p = (
char *) 0;
1929 yyg->yy_start_stack_ptr = 0;
1930 yyg->yy_start_stack_depth = 0;
1931 yyg->yy_start_stack = NULL;
1949 int pktloc_lex_destroy (yyscan_t yyscanner)
1954 while(YY_CURRENT_BUFFER){
1955 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1956 YY_CURRENT_BUFFER_LVALUE = NULL;
1957 pktloc_pop_buffer_state(yyscanner);
1965 pktloc_free(yyg->yy_start_stack ,yyscanner );
1966 yyg->yy_start_stack = NULL;
1970 yy_init_globals( yyscanner);
1973 pktloc_free ( yyscanner , yyscanner );
1983 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
1986 for ( i = 0; i < n; ++i )
1991 #ifdef YY_NEED_STRLEN
1992 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
1995 for ( n = 0; s[n]; ++n )
2002 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2004 return (
void *) malloc( size );
2007 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2016 return (
void *) realloc( (
char *) ptr, size );
2019 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2021 free( (
char *) ptr );
2024 #define YYTABLES_NAME "yytables"
2026 #line 52 "route/pktloc_grammar.l"