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 37
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)
190 int yyless_macro_arg = (n); \
191 YY_LESS_LINENO(yyless_macro_arg);\
192 *yy_cp = yyg->yy_hold_char; \
193 YY_RESTORE_YY_MORE_OFFSET \
194 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195 YY_DO_BEFORE_ACTION; \
199 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
201 #ifndef YY_STRUCT_YY_BUFFER_STATE
202 #define YY_STRUCT_YY_BUFFER_STATE
213 yy_size_t yy_buf_size;
218 yy_size_t yy_n_chars;
224 int yy_is_our_buffer;
231 int yy_is_interactive;
247 int yy_buffer_status;
249 #define YY_BUFFER_NEW 0
250 #define YY_BUFFER_NORMAL 1
261 #define YY_BUFFER_EOF_PENDING 2
272 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
273 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
279 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
281 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
282 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
283 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
284 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
285 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
286 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
287 void pktloc_pop_buffer_state (yyscan_t yyscanner );
289 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
290 static void pktloc__load_buffer_state (yyscan_t yyscanner );
291 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
293 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
295 YY_BUFFER_STATE pktloc__scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
296 YY_BUFFER_STATE pktloc__scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
297 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char *bytes,yy_size_t len ,yyscan_t yyscanner );
299 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
300 void *pktloc_realloc (
void *,yy_size_t ,yyscan_t yyscanner );
301 void pktloc_free (
void * ,yyscan_t yyscanner );
303 #define yy_new_buffer pktloc__create_buffer
305 #define yy_set_interactive(is_interactive) \
307 if ( ! YY_CURRENT_BUFFER ){ \
308 pktloc_ensure_buffer_stack (yyscanner); \
309 YY_CURRENT_BUFFER_LVALUE = \
310 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
312 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
315 #define yy_set_bol(at_bol) \
317 if ( ! YY_CURRENT_BUFFER ){\
318 pktloc_ensure_buffer_stack (yyscanner); \
319 YY_CURRENT_BUFFER_LVALUE = \
320 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
322 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
325 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
327 #define pktloc_wrap(yyscanner) 1
328 #define YY_SKIP_YYWRAP
330 typedef unsigned char YY_CHAR;
332 typedef int yy_state_type;
334 #define yytext_ptr yytext_r
336 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
337 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
338 static int yy_get_next_buffer (yyscan_t yyscanner );
339 static void yy_fatal_error (yyconst
char msg[] ,yyscan_t yyscanner );
344 #define YY_DO_BEFORE_ACTION \
345 yyg->yytext_ptr = yy_bp; \
346 yyleng = (size_t) (yy_cp - yy_bp); \
347 yyg->yy_hold_char = *yy_cp; \
349 yyg->yy_c_buf_p = yy_cp;
351 #define YY_NUM_RULES 16
352 #define YY_END_OF_BUFFER 17
357 flex_int32_t yy_verify;
360 static yyconst flex_int16_t yy_accept[47] =
362 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
363 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
364 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
365 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
366 15, 15, 15, 15, 13, 0
369 static yyconst flex_int32_t yy_ec[256] =
371 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
372 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
373 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
374 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
375 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
376 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
377 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
378 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
379 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
380 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
382 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
383 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
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,
391 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,
397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 static yyconst flex_int32_t yy_meta[29] =
403 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1
408 static yyconst flex_int16_t yy_base[50] =
410 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
411 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
412 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
413 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
414 30, 29, 26, 18, 0, 87, 31, 68, 70
417 static yyconst flex_int16_t yy_def[50] =
419 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
420 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
421 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
422 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
423 47, 47, 47, 47, 47, 0, 46, 46, 46
426 static yyconst flex_int16_t yy_nxt[116] =
428 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
429 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
430 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
431 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
432 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
433 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
434 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
435 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
436 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
437 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
439 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
443 static yyconst flex_int16_t yy_chk[116] =
445 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
448 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
449 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
450 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
451 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
452 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
453 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
454 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
456 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
463 #define REJECT reject_used_but_not_detected
464 #define yymore() yymore_used_but_not_detected
465 #define YY_MORE_ADJ 0
466 #define YY_RESTORE_YY_MORE_OFFSET
467 #line 1 "route/pktloc_grammar.l"
468 #line 2 "route/pktloc_grammar.l"
469 #include <netlink-private/netlink.h>
470 #include <netlink-private/tc.h>
471 #include <netlink/netlink.h>
472 #include <netlink/utils.h>
473 #include <netlink/route/pktloc.h>
474 #include "pktloc_syntax.h"
475 #define YY_NO_INPUT 1
476 #line 477 "route/pktloc_grammar.c"
480 #ifndef YY_NO_UNISTD_H
488 #ifndef YY_EXTRA_TYPE
489 #define YY_EXTRA_TYPE void *
497 YY_EXTRA_TYPE yyextra_r;
500 FILE *yyin_r, *yyout_r;
505 yy_size_t yy_n_chars;
510 int yy_did_buffer_switch_on_eof;
511 int yy_start_stack_ptr;
512 int yy_start_stack_depth;
514 yy_state_type yy_last_accepting_state;
515 char* yy_last_accepting_cpos;
530 static int yy_init_globals (yyscan_t yyscanner );
534 # define yylval yyg->yylval_r
536 # define yylloc yyg->yylloc_r
538 int pktloc_lex_init (yyscan_t* scanner);
540 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
545 int pktloc_lex_destroy (yyscan_t yyscanner );
547 int pktloc_get_debug (yyscan_t yyscanner );
549 void pktloc_set_debug (
int debug_flag ,yyscan_t yyscanner );
551 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
553 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
555 FILE *pktloc_get_in (yyscan_t yyscanner );
557 void pktloc_set_in (FILE * in_str ,yyscan_t yyscanner );
559 FILE *pktloc_get_out (yyscan_t yyscanner );
561 void pktloc_set_out (FILE * out_str ,yyscan_t yyscanner );
563 yy_size_t pktloc_get_leng (yyscan_t yyscanner );
565 char *pktloc_get_text (yyscan_t yyscanner );
567 int pktloc_get_lineno (yyscan_t yyscanner );
569 void pktloc_set_lineno (
int line_number ,yyscan_t yyscanner );
571 int pktloc_get_column (yyscan_t yyscanner );
573 void pktloc_set_column (
int column_no ,yyscan_t yyscanner );
575 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
577 void pktloc_set_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
579 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
581 void pktloc_set_lloc (
YYLTYPE * yylloc_param ,yyscan_t yyscanner );
587 #ifndef YY_SKIP_YYWRAP
589 extern "C" int pktloc_wrap (yyscan_t yyscanner );
591 extern int pktloc_wrap (yyscan_t yyscanner );
596 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
599 #ifdef YY_NEED_STRLEN
600 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
606 static int yyinput (yyscan_t yyscanner );
608 static int input (yyscan_t yyscanner );
614 #ifndef YY_READ_BUF_SIZE
615 #define YY_READ_BUF_SIZE 8192
623 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
630 #define YY_INPUT(buf,result,max_size) \
631 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
635 for ( n = 0; n < max_size && \
636 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
639 buf[n++] = (char) c; \
640 if ( c == EOF && ferror( yyin ) ) \
641 YY_FATAL_ERROR( "input in flex scanner failed" ); \
647 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
649 if( errno != EINTR) \
651 YY_FATAL_ERROR( "input in flex scanner failed" ); \
667 #define yyterminate() return YY_NULL
671 #ifndef YY_START_STACK_INCR
672 #define YY_START_STACK_INCR 25
676 #ifndef YY_FATAL_ERROR
677 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
686 #define YY_DECL_IS_OURS 1
688 extern int pktloc_lex \
689 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
691 #define YY_DECL int pktloc_lex \
692 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
698 #ifndef YY_USER_ACTION
699 #define YY_USER_ACTION
704 #define YY_BREAK break;
707 #define YY_RULE_SETUP \
714 register yy_state_type yy_current_state;
715 register char *yy_cp, *yy_bp;
719 #line 20 "route/pktloc_grammar.l"
722 #line 723 "route/pktloc_grammar.c"
724 yylval = yylval_param;
726 yylloc = yylloc_param;
736 if ( ! yyg->yy_start )
745 if ( ! YY_CURRENT_BUFFER ) {
746 pktloc_ensure_buffer_stack (yyscanner);
747 YY_CURRENT_BUFFER_LVALUE =
748 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
751 pktloc__load_buffer_state(yyscanner );
756 yy_cp = yyg->yy_c_buf_p;
759 *yy_cp = yyg->yy_hold_char;
766 yy_current_state = yyg->yy_start;
770 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
771 if ( yy_accept[yy_current_state] )
773 yyg->yy_last_accepting_state = yy_current_state;
774 yyg->yy_last_accepting_cpos = yy_cp;
776 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
778 yy_current_state = (int) yy_def[yy_current_state];
779 if ( yy_current_state >= 47 )
780 yy_c = yy_meta[(
unsigned int) yy_c];
782 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
785 while ( yy_base[yy_current_state] != 87 );
788 yy_act = yy_accept[yy_current_state];
791 yy_cp = yyg->yy_last_accepting_cpos;
792 yy_current_state = yyg->yy_last_accepting_state;
793 yy_act = yy_accept[yy_current_state];
804 *yy_cp = yyg->yy_hold_char;
805 yy_cp = yyg->yy_last_accepting_cpos;
806 yy_current_state = yyg->yy_last_accepting_state;
812 #line 22 "route/pktloc_grammar.l"
817 #line 24 "route/pktloc_grammar.l"
821 #line 27 "route/pktloc_grammar.l"
824 #line 27 "route/pktloc_grammar.l"
826 yylval->i = strtoul(yytext, NULL, 0);
832 #line 32 "route/pktloc_grammar.l"
833 {
return yylval->i = yytext[0]; }
837 #line 34 "route/pktloc_grammar.l"
838 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
842 #line 35 "route/pktloc_grammar.l"
843 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
847 #line 36 "route/pktloc_grammar.l"
848 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
851 #line 39 "route/pktloc_grammar.l"
854 #line 39 "route/pktloc_grammar.l"
855 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
858 #line 41 "route/pktloc_grammar.l"
861 #line 41 "route/pktloc_grammar.l"
862 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
865 #line 43 "route/pktloc_grammar.l"
868 #line 43 "route/pktloc_grammar.l"
869 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
873 #line 46 "route/pktloc_grammar.l"
875 yylval->s = strdup(yytext);
876 if (yylval->s == NULL)
883 #line 52 "route/pktloc_grammar.l"
886 #line 887 "route/pktloc_grammar.c"
887 case YY_STATE_EOF(INITIAL):
890 case YY_END_OF_BUFFER:
893 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
896 *yy_cp = yyg->yy_hold_char;
897 YY_RESTORE_YY_MORE_OFFSET
899 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
910 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
911 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
912 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
922 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
924 yy_state_type yy_next_state;
926 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
928 yy_current_state = yy_get_previous_state( yyscanner );
939 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
941 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
946 yy_cp = ++yyg->yy_c_buf_p;
947 yy_current_state = yy_next_state;
953 yy_cp = yyg->yy_c_buf_p;
958 else switch ( yy_get_next_buffer( yyscanner ) )
960 case EOB_ACT_END_OF_FILE:
962 yyg->yy_did_buffer_switch_on_eof = 0;
964 if ( pktloc_wrap(yyscanner ) )
975 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
977 yy_act = YY_STATE_EOF(YY_START);
983 if ( ! yyg->yy_did_buffer_switch_on_eof )
989 case EOB_ACT_CONTINUE_SCAN:
991 yyg->yytext_ptr + yy_amount_of_matched_text;
993 yy_current_state = yy_get_previous_state( yyscanner );
995 yy_cp = yyg->yy_c_buf_p;
996 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
999 case EOB_ACT_LAST_MATCH:
1001 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1003 yy_current_state = yy_get_previous_state( yyscanner );
1005 yy_cp = yyg->yy_c_buf_p;
1006 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1007 goto yy_find_action;
1014 "fatal flex scanner internal error--no action found" );
1026 static int yy_get_next_buffer (yyscan_t yyscanner)
1029 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1030 register char *source = yyg->yytext_ptr;
1031 register int number_to_move, i;
1034 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1036 "fatal flex scanner internal error--end of buffer missed" );
1038 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1040 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1045 return EOB_ACT_END_OF_FILE;
1053 return EOB_ACT_LAST_MATCH;
1060 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1062 for ( i = 0; i < number_to_move; ++i )
1063 *(dest++) = *(source++);
1065 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1069 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1073 yy_size_t num_to_read =
1074 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1076 while ( num_to_read <= 0 )
1080 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1082 int yy_c_buf_p_offset =
1083 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1085 if ( b->yy_is_our_buffer )
1087 yy_size_t new_size = b->yy_buf_size * 2;
1089 if ( new_size <= 0 )
1090 b->yy_buf_size += b->yy_buf_size / 8;
1092 b->yy_buf_size *= 2;
1094 b->yy_ch_buf = (
char *)
1096 pktloc_realloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1102 if ( ! b->yy_ch_buf )
1104 "fatal error - scanner input buffer overflow" );
1106 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1108 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1113 if ( num_to_read > YY_READ_BUF_SIZE )
1114 num_to_read = YY_READ_BUF_SIZE;
1117 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1118 yyg->yy_n_chars, num_to_read );
1120 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1123 if ( yyg->yy_n_chars == 0 )
1125 if ( number_to_move == YY_MORE_ADJ )
1127 ret_val = EOB_ACT_END_OF_FILE;
1128 pktloc_restart(yyin ,yyscanner);
1133 ret_val = EOB_ACT_LAST_MATCH;
1134 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1135 YY_BUFFER_EOF_PENDING;
1140 ret_val = EOB_ACT_CONTINUE_SCAN;
1142 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1144 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1145 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1146 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1147 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1150 yyg->yy_n_chars += number_to_move;
1151 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1152 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1154 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1161 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1163 register yy_state_type yy_current_state;
1164 register char *yy_cp;
1167 yy_current_state = yyg->yy_start;
1169 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1171 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1172 if ( yy_accept[yy_current_state] )
1174 yyg->yy_last_accepting_state = yy_current_state;
1175 yyg->yy_last_accepting_cpos = yy_cp;
1177 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1179 yy_current_state = (int) yy_def[yy_current_state];
1180 if ( yy_current_state >= 47 )
1181 yy_c = yy_meta[(
unsigned int) yy_c];
1183 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1186 return yy_current_state;
1194 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1196 register int yy_is_jam;
1198 register char *yy_cp = yyg->yy_c_buf_p;
1200 register YY_CHAR yy_c = 1;
1201 if ( yy_accept[yy_current_state] )
1203 yyg->yy_last_accepting_state = yy_current_state;
1204 yyg->yy_last_accepting_cpos = yy_cp;
1206 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1208 yy_current_state = (int) yy_def[yy_current_state];
1209 if ( yy_current_state >= 47 )
1210 yy_c = yy_meta[(
unsigned int) yy_c];
1212 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1213 yy_is_jam = (yy_current_state == 46);
1216 return yy_is_jam ? 0 : yy_current_state;
1221 static int yyinput (yyscan_t yyscanner)
1223 static int input (yyscan_t yyscanner)
1230 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1232 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1238 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1240 *yyg->yy_c_buf_p =
'\0';
1244 yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1247 switch ( yy_get_next_buffer( yyscanner ) )
1249 case EOB_ACT_LAST_MATCH:
1261 pktloc_restart(yyin ,yyscanner);
1265 case EOB_ACT_END_OF_FILE:
1267 if ( pktloc_wrap(yyscanner ) )
1270 if ( ! yyg->yy_did_buffer_switch_on_eof )
1273 return yyinput(yyscanner);
1275 return input(yyscanner);
1279 case EOB_ACT_CONTINUE_SCAN:
1280 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1286 c = *(
unsigned char *) yyg->yy_c_buf_p;
1287 *yyg->yy_c_buf_p =
'\0';
1288 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1299 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1303 if ( ! YY_CURRENT_BUFFER ){
1304 pktloc_ensure_buffer_stack (yyscanner);
1305 YY_CURRENT_BUFFER_LVALUE =
1306 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1309 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1310 pktloc__load_buffer_state(yyscanner );
1317 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1326 pktloc_ensure_buffer_stack (yyscanner);
1327 if ( YY_CURRENT_BUFFER == new_buffer )
1330 if ( YY_CURRENT_BUFFER )
1333 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1334 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1335 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1338 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1339 pktloc__load_buffer_state(yyscanner );
1346 yyg->yy_did_buffer_switch_on_eof = 1;
1349 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1352 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1353 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1354 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1355 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1364 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1368 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1370 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1372 b->yy_buf_size = size;
1377 b->yy_ch_buf = (
char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
1378 if ( ! b->yy_ch_buf )
1379 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1381 b->yy_is_our_buffer = 1;
1383 pktloc__init_buffer(b,file ,yyscanner);
1392 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1399 if ( b == YY_CURRENT_BUFFER )
1400 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1402 if ( b->yy_is_our_buffer )
1403 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1405 pktloc_free((
void *) b ,yyscanner );
1412 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1418 pktloc__flush_buffer(b ,yyscanner);
1420 b->yy_input_file = file;
1421 b->yy_fill_buffer = 1;
1427 if (b != YY_CURRENT_BUFFER){
1432 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1441 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1453 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1454 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1456 b->yy_buf_pos = &b->yy_ch_buf[0];
1459 b->yy_buffer_status = YY_BUFFER_NEW;
1461 if ( b == YY_CURRENT_BUFFER )
1462 pktloc__load_buffer_state(yyscanner );
1471 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1474 if (new_buffer == NULL)
1477 pktloc_ensure_buffer_stack(yyscanner);
1480 if ( YY_CURRENT_BUFFER )
1483 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1484 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1485 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1489 if (YY_CURRENT_BUFFER)
1491 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1494 pktloc__load_buffer_state(yyscanner );
1495 yyg->yy_did_buffer_switch_on_eof = 1;
1502 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1505 if (!YY_CURRENT_BUFFER)
1508 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1509 YY_CURRENT_BUFFER_LVALUE = NULL;
1513 if (YY_CURRENT_BUFFER) {
1514 pktloc__load_buffer_state(yyscanner );
1515 yyg->yy_did_buffer_switch_on_eof = 1;
1522 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1524 yy_size_t num_to_alloc;
1538 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1558 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1572 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1577 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1578 base[size-1] != YY_END_OF_BUFFER_CHAR )
1582 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1584 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1586 b->yy_buf_size = size - 2;
1587 b->yy_buf_pos = b->yy_ch_buf = base;
1588 b->yy_is_our_buffer = 0;
1589 b->yy_input_file = 0;
1590 b->yy_n_chars = b->yy_buf_size;
1591 b->yy_is_interactive = 0;
1593 b->yy_fill_buffer = 0;
1594 b->yy_buffer_status = YY_BUFFER_NEW;
1596 pktloc__switch_to_buffer(b ,yyscanner );
1609 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1612 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
1622 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
1630 n = _yybytes_len + 2;
1631 buf = (
char *) pktloc_alloc(n ,yyscanner );
1633 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1635 for ( i = 0; i < _yybytes_len; ++i )
1636 buf[i] = yybytes[i];
1638 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1640 b = pktloc__scan_buffer(buf,n ,yyscanner);
1642 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1647 b->yy_is_our_buffer = 1;
1652 #ifndef YY_EXIT_FAILURE
1653 #define YY_EXIT_FAILURE 2
1656 static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1658 (void) fprintf( stderr,
"%s\n", msg );
1659 exit( YY_EXIT_FAILURE );
1669 int yyless_macro_arg = (n); \
1670 YY_LESS_LINENO(yyless_macro_arg);\
1671 yytext[yyleng] = yyg->yy_hold_char; \
1672 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1673 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1674 *yyg->yy_c_buf_p = '\0'; \
1675 yyleng = yyless_macro_arg; \
1684 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1693 int pktloc_get_lineno (yyscan_t yyscanner)
1697 if (! YY_CURRENT_BUFFER)
1706 int pktloc_get_column (yyscan_t yyscanner)
1710 if (! YY_CURRENT_BUFFER)
1719 FILE *pktloc_get_in (yyscan_t yyscanner)
1728 FILE *pktloc_get_out (yyscan_t yyscanner)
1737 yy_size_t pktloc_get_leng (yyscan_t yyscanner)
1747 char *pktloc_get_text (yyscan_t yyscanner)
1757 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1760 yyextra = user_defined ;
1767 void pktloc_set_lineno (
int line_number , yyscan_t yyscanner)
1772 if (! YY_CURRENT_BUFFER )
1773 YY_FATAL_ERROR(
"pktloc_set_lineno called with no buffer" );
1775 yylineno = line_number;
1782 void pktloc_set_column (
int column_no , yyscan_t yyscanner)
1787 if (! YY_CURRENT_BUFFER )
1788 YY_FATAL_ERROR(
"pktloc_set_column called with no buffer" );
1790 yycolumn = column_no;
1799 void pktloc_set_in (FILE * in_str , yyscan_t yyscanner)
1805 void pktloc_set_out (FILE * out_str , yyscan_t yyscanner)
1811 int pktloc_get_debug (yyscan_t yyscanner)
1814 return yy_flex_debug;
1817 void pktloc_set_debug (
int bdebug , yyscan_t yyscanner)
1820 yy_flex_debug = bdebug ;
1825 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1831 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1834 yylval = yylval_param;
1837 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1843 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1846 yylloc = yylloc_param;
1856 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1859 if (ptr_yy_globals == NULL){
1864 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1866 if (*ptr_yy_globals == NULL){
1872 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1874 return yy_init_globals ( *ptr_yy_globals );
1885 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1890 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1892 if (ptr_yy_globals == NULL){
1897 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1899 if (*ptr_yy_globals == NULL){
1906 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1908 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1910 return yy_init_globals ( *ptr_yy_globals );
1913 static int yy_init_globals (yyscan_t yyscanner)
1923 yyg->yy_c_buf_p = (
char *) 0;
1927 yyg->yy_start_stack_ptr = 0;
1928 yyg->yy_start_stack_depth = 0;
1929 yyg->yy_start_stack = NULL;
1947 int pktloc_lex_destroy (yyscan_t yyscanner)
1952 while(YY_CURRENT_BUFFER){
1953 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1954 YY_CURRENT_BUFFER_LVALUE = NULL;
1955 pktloc_pop_buffer_state(yyscanner);
1963 pktloc_free(yyg->yy_start_stack ,yyscanner );
1964 yyg->yy_start_stack = NULL;
1968 yy_init_globals( yyscanner);
1971 pktloc_free ( yyscanner , yyscanner );
1981 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
1984 for ( i = 0; i < n; ++i )
1989 #ifdef YY_NEED_STRLEN
1990 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
1993 for ( n = 0; s[n]; ++n )
2000 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2002 return (
void *) malloc( size );
2005 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2014 return (
void *) realloc( (
char *) ptr, size );
2017 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2019 free( (
char *) ptr );
2022 #define YYTABLES_NAME "yytables"
2024 #line 52 "route/pktloc_grammar.l"