1#line 1 "lib/route/pktloc_grammar.c"
3#line 3 "lib/route/pktloc_grammar.c"
5#define YY_INT_ALIGNED short int
10#define YY_FLEX_MAJOR_VERSION 2
11#define YY_FLEX_MINOR_VERSION 6
12#define YY_FLEX_SUBMINOR_VERSION 4
13#if YY_FLEX_SUBMINOR_VERSION > 0
17#ifdef yy_create_buffer
18#define pktloc__create_buffer_ALREADY_DEFINED
20#define yy_create_buffer pktloc__create_buffer
23#ifdef yy_delete_buffer
24#define pktloc__delete_buffer_ALREADY_DEFINED
26#define yy_delete_buffer pktloc__delete_buffer
30#define pktloc__scan_buffer_ALREADY_DEFINED
32#define yy_scan_buffer pktloc__scan_buffer
36#define pktloc__scan_string_ALREADY_DEFINED
38#define yy_scan_string pktloc__scan_string
42#define pktloc__scan_bytes_ALREADY_DEFINED
44#define yy_scan_bytes pktloc__scan_bytes
48#define pktloc__init_buffer_ALREADY_DEFINED
50#define yy_init_buffer pktloc__init_buffer
54#define pktloc__flush_buffer_ALREADY_DEFINED
56#define yy_flush_buffer pktloc__flush_buffer
59#ifdef yy_load_buffer_state
60#define pktloc__load_buffer_state_ALREADY_DEFINED
62#define yy_load_buffer_state pktloc__load_buffer_state
65#ifdef yy_switch_to_buffer
66#define pktloc__switch_to_buffer_ALREADY_DEFINED
68#define yy_switch_to_buffer pktloc__switch_to_buffer
71#ifdef yypush_buffer_state
72#define pktloc_push_buffer_state_ALREADY_DEFINED
74#define yypush_buffer_state pktloc_push_buffer_state
77#ifdef yypop_buffer_state
78#define pktloc_pop_buffer_state_ALREADY_DEFINED
80#define yypop_buffer_state pktloc_pop_buffer_state
83#ifdef yyensure_buffer_stack
84#define pktloc_ensure_buffer_stack_ALREADY_DEFINED
86#define yyensure_buffer_stack pktloc_ensure_buffer_stack
90#define pktloc_lex_ALREADY_DEFINED
92#define yylex pktloc_lex
96#define pktloc_restart_ALREADY_DEFINED
98#define yyrestart pktloc_restart
102#define pktloc_lex_init_ALREADY_DEFINED
104#define yylex_init pktloc_lex_init
107#ifdef yylex_init_extra
108#define pktloc_lex_init_extra_ALREADY_DEFINED
110#define yylex_init_extra pktloc_lex_init_extra
114#define pktloc_lex_destroy_ALREADY_DEFINED
116#define yylex_destroy pktloc_lex_destroy
120#define pktloc_get_debug_ALREADY_DEFINED
122#define yyget_debug pktloc_get_debug
126#define pktloc_set_debug_ALREADY_DEFINED
128#define yyset_debug pktloc_set_debug
132#define pktloc_get_extra_ALREADY_DEFINED
134#define yyget_extra pktloc_get_extra
138#define pktloc_set_extra_ALREADY_DEFINED
140#define yyset_extra pktloc_set_extra
144#define pktloc_get_in_ALREADY_DEFINED
146#define yyget_in pktloc_get_in
150#define pktloc_set_in_ALREADY_DEFINED
152#define yyset_in pktloc_set_in
156#define pktloc_get_out_ALREADY_DEFINED
158#define yyget_out pktloc_get_out
162#define pktloc_set_out_ALREADY_DEFINED
164#define yyset_out pktloc_set_out
168#define pktloc_get_leng_ALREADY_DEFINED
170#define yyget_leng pktloc_get_leng
174#define pktloc_get_text_ALREADY_DEFINED
176#define yyget_text pktloc_get_text
180#define pktloc_get_lineno_ALREADY_DEFINED
182#define yyget_lineno pktloc_get_lineno
186#define pktloc_set_lineno_ALREADY_DEFINED
188#define yyset_lineno pktloc_set_lineno
192#define pktloc_get_column_ALREADY_DEFINED
194#define yyget_column pktloc_get_column
198#define pktloc_set_column_ALREADY_DEFINED
200#define yyset_column pktloc_set_column
204#define pktloc_wrap_ALREADY_DEFINED
206#define yywrap pktloc_wrap
210#define pktloc_get_lval_ALREADY_DEFINED
212#define yyget_lval pktloc_get_lval
216#define pktloc_set_lval_ALREADY_DEFINED
218#define yyset_lval pktloc_set_lval
222#define pktloc_get_lloc_ALREADY_DEFINED
224#define yyget_lloc pktloc_get_lloc
228#define pktloc_set_lloc_ALREADY_DEFINED
230#define yyset_lloc pktloc_set_lloc
234#define pktloc_alloc_ALREADY_DEFINED
236#define yyalloc pktloc_alloc
240#define pktloc_realloc_ALREADY_DEFINED
242#define yyrealloc pktloc_realloc
246#define pktloc_free_ALREADY_DEFINED
248#define yyfree pktloc_free
268#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
273#ifndef __STDC_LIMIT_MACROS
274#define __STDC_LIMIT_MACROS 1
278typedef int8_t flex_int8_t;
279typedef uint8_t flex_uint8_t;
280typedef int16_t flex_int16_t;
281typedef uint16_t flex_uint16_t;
282typedef int32_t flex_int32_t;
283typedef uint32_t flex_uint32_t;
285typedef signed char flex_int8_t;
286typedef short int flex_int16_t;
287typedef int flex_int32_t;
288typedef unsigned char flex_uint8_t;
289typedef unsigned short int flex_uint16_t;
290typedef unsigned int flex_uint32_t;
294#define INT8_MIN (-128)
297#define INT16_MIN (-32767-1)
300#define INT32_MIN (-2147483647-1)
303#define INT8_MAX (127)
306#define INT16_MAX (32767)
309#define INT32_MAX (2147483647)
312#define UINT8_MAX (255U)
315#define UINT16_MAX (65535U)
318#define UINT32_MAX (4294967295U)
322#define SIZE_MAX (~(size_t)0)
334#if defined(__GNUC__) && __GNUC__ >= 3
335#define yynoreturn __attribute__((__noreturn__))
346#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
349#ifndef YY_TYPEDEF_YY_SCANNER_T
350#define YY_TYPEDEF_YY_SCANNER_T
351typedef void* yyscan_t;
356#define yyin yyg->yyin_r
357#define yyout yyg->yyout_r
358#define yyextra yyg->yyextra_r
359#define yyleng yyg->yyleng_r
360#define yytext yyg->yytext_r
361#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
362#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
363#define yy_flex_debug yyg->yy_flex_debug_r
369#define BEGIN yyg->yy_start = 1 + 2 *
374#define YY_START ((yyg->yy_start - 1) / 2)
375#define YYSTATE YY_START
377#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
379#define YY_NEW_FILE yyrestart( yyin , yyscanner )
380#define YY_END_OF_BUFFER_CHAR 0
389#define YY_BUF_SIZE 32768
391#define YY_BUF_SIZE 16384
397#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
399#ifndef YY_TYPEDEF_YY_BUFFER_STATE
400#define YY_TYPEDEF_YY_BUFFER_STATE
404#ifndef YY_TYPEDEF_YY_SIZE_T
405#define YY_TYPEDEF_YY_SIZE_T
406typedef size_t yy_size_t;
409#define EOB_ACT_CONTINUE_SCAN 0
410#define EOB_ACT_END_OF_FILE 1
411#define EOB_ACT_LAST_MATCH 2
413 #define YY_LESS_LINENO(n)
414 #define YY_LINENO_REWIND_TO(ptr)
421 int yyless_macro_arg = (n); \
422 YY_LESS_LINENO(yyless_macro_arg);\
423 *yy_cp = yyg->yy_hold_char; \
424 YY_RESTORE_YY_MORE_OFFSET \
425 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
426 YY_DO_BEFORE_ACTION; \
429#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
431#ifndef YY_STRUCT_YY_BUFFER_STATE
432#define YY_STRUCT_YY_BUFFER_STATE
454 int yy_is_our_buffer;
461 int yy_is_interactive;
477 int yy_buffer_status;
479#define YY_BUFFER_NEW 0
480#define YY_BUFFER_NORMAL 1
491#define YY_BUFFER_EOF_PENDING 2
502#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
503 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
508#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
510void yyrestart ( FILE *input_file , yyscan_t yyscanner );
511void yy_switch_to_buffer (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
512YY_BUFFER_STATE yy_create_buffer ( FILE *file,
int size , yyscan_t yyscanner );
515void yypush_buffer_state (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
516void yypop_buffer_state ( yyscan_t yyscanner );
518static void yyensure_buffer_stack ( yyscan_t yyscanner );
519static void yy_load_buffer_state ( yyscan_t yyscanner );
520static void yy_init_buffer (
YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
521#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
523YY_BUFFER_STATE yy_scan_buffer (
char *base, yy_size_t size , yyscan_t yyscanner );
524YY_BUFFER_STATE yy_scan_string (
const char *yy_str , yyscan_t yyscanner );
525YY_BUFFER_STATE yy_scan_bytes (
const char *bytes,
int len , yyscan_t yyscanner );
527void *
yyalloc ( yy_size_t , yyscan_t yyscanner );
528void *yyrealloc (
void *, yy_size_t , yyscan_t yyscanner );
529void yyfree (
void * , yyscan_t yyscanner );
531#define yy_new_buffer yy_create_buffer
532#define yy_set_interactive(is_interactive) \
534 if ( ! YY_CURRENT_BUFFER ){ \
535 yyensure_buffer_stack (yyscanner); \
536 YY_CURRENT_BUFFER_LVALUE = \
537 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
539 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
541#define yy_set_bol(at_bol) \
543 if ( ! YY_CURRENT_BUFFER ){\
544 yyensure_buffer_stack (yyscanner); \
545 YY_CURRENT_BUFFER_LVALUE = \
546 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
548 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
550#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
552#define pktloc_wrap(yyscanner) (1)
553#define YY_SKIP_YYWRAP
554typedef flex_uint8_t YY_CHAR;
556typedef int yy_state_type;
558#define yytext_ptr yytext_r
560static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
561static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
562static int yy_get_next_buffer ( yyscan_t yyscanner );
563static void yynoreturn yy_fatal_error (
const char* msg , yyscan_t yyscanner );
568#define YY_DO_BEFORE_ACTION \
569 yyg->yytext_ptr = yy_bp; \
570 yyleng = (int) (yy_cp - yy_bp); \
571 yyg->yy_hold_char = *yy_cp; \
573 yyg->yy_c_buf_p = yy_cp;
574#define YY_NUM_RULES 16
575#define YY_END_OF_BUFFER 17
580 flex_int32_t yy_verify;
583static const flex_int16_t yy_accept[47] =
585 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
586 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
587 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
588 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
589 15, 15, 15, 15, 13, 0
592static const YY_CHAR yy_ec[256] =
594 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
595 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
596 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
597 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
598 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
599 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
600 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
601 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
602 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
603 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
605 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
606 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
607 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
608 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
609 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
610 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
611 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
612 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
613 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
614 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
616 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
617 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
618 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
619 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
620 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
624static const YY_CHAR yy_meta[29] =
626 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
627 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
628 1, 1, 1, 1, 1, 1, 1, 1
631static const flex_int16_t yy_base[50] =
633 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
634 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
635 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
636 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
637 30, 29, 26, 18, 0, 87, 31, 68, 70
640static const flex_int16_t yy_def[50] =
642 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
643 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
644 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
645 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
646 47, 47, 47, 47, 47, 0, 46, 46, 46
649static const flex_int16_t yy_nxt[116] =
651 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
652 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
653 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
654 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
655 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
656 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
657 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
658 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
659 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
660 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
662 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
666static const flex_int16_t yy_chk[116] =
668 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
669 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
670 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
671 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
672 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
673 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
674 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
675 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
676 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
677 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
679 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
686#define REJECT reject_used_but_not_detected
687#define yymore() yymore_used_but_not_detected
689#define YY_RESTORE_YY_MORE_OFFSET
690#line 1 "lib/route/pktloc_grammar.l"
691#line 2 "lib/route/pktloc_grammar.l"
692 #include <linux/tc_ematch/tc_em_cmp.h>
694 #include <netlink/netlink.h>
695 #include <netlink/utils.h>
696 #include <netlink/route/pktloc.h>
698 #include "pktloc_syntax.h"
700 int pktloc_get_column(yyscan_t);
701 void pktloc_set_column(
int, yyscan_t);
702#line 702 "lib/route/pktloc_grammar.c"
704#line 704 "lib/route/pktloc_grammar.c"
708#ifndef YY_NO_UNISTD_H
717#define YY_EXTRA_TYPE void *
725 YY_EXTRA_TYPE yyextra_r;
728 FILE *yyin_r, *yyout_r;
738 int yy_did_buffer_switch_on_eof;
739 int yy_start_stack_ptr;
740 int yy_start_stack_depth;
742 yy_state_type yy_last_accepting_state;
743 char* yy_last_accepting_cpos;
758static int yy_init_globals ( yyscan_t yyscanner );
762 # define yylval yyg->yylval_r
764 # define yylloc yyg->yylloc_r
766int yylex_init (yyscan_t* scanner);
768int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
773int yylex_destroy ( yyscan_t yyscanner );
775int yyget_debug ( yyscan_t yyscanner );
777void yyset_debug (
int debug_flag , yyscan_t yyscanner );
779YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
781void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
783FILE *yyget_in ( yyscan_t yyscanner );
785void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
787FILE *yyget_out ( yyscan_t yyscanner );
789void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
791 int yyget_leng ( yyscan_t yyscanner );
793char *yyget_text ( yyscan_t yyscanner );
795int yyget_lineno ( yyscan_t yyscanner );
797void yyset_lineno (
int _line_number , yyscan_t yyscanner );
799int yyget_column ( yyscan_t yyscanner );
801void yyset_column (
int _column_no , yyscan_t yyscanner );
803YYSTYPE * yyget_lval ( yyscan_t yyscanner );
805void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner );
807 YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
809 void yyset_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner );
815#ifndef YY_SKIP_YYWRAP
817extern "C" int yywrap ( yyscan_t yyscanner );
819extern int yywrap ( yyscan_t yyscanner );
828static void yy_flex_strncpy (
char *,
const char *,
int , yyscan_t yyscanner);
832static int yy_flex_strlen (
const char * , yyscan_t yyscanner);
837static int yyinput ( yyscan_t yyscanner );
839static int input ( yyscan_t yyscanner );
845#ifndef YY_READ_BUF_SIZE
848#define YY_READ_BUF_SIZE 16384
850#define YY_READ_BUF_SIZE 8192
859#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
866#define YY_INPUT(buf,result,max_size) \
867 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
871 for ( n = 0; n < max_size && \
872 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
875 buf[n++] = (char) c; \
876 if ( c == EOF && ferror( yyin ) ) \
877 YY_FATAL_ERROR( "input in flex scanner failed" ); \
883 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
885 if( errno != EINTR) \
887 YY_FATAL_ERROR( "input in flex scanner failed" ); \
903#define yyterminate() return YY_NULL
907#ifndef YY_START_STACK_INCR
908#define YY_START_STACK_INCR 25
912#ifndef YY_FATAL_ERROR
913#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
922#define YY_DECL_IS_OURS 1
925 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param , yyscan_t yyscanner);
927#define YY_DECL int yylex \
928 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
934#ifndef YY_USER_ACTION
935#define YY_USER_ACTION
940#define YY_BREAK break;
943#define YY_RULE_SETUP \
950 yy_state_type yy_current_state;
955 yylval = yylval_param;
957 yylloc = yylloc_param;
967 if ( ! yyg->yy_start )
976 if ( ! YY_CURRENT_BUFFER ) {
977 yyensure_buffer_stack (yyscanner);
978 YY_CURRENT_BUFFER_LVALUE =
979 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
982 yy_load_buffer_state( yyscanner );
986#line 24 "lib/route/pktloc_grammar.l"
989#line 989 "lib/route/pktloc_grammar.c"
993 yy_cp = yyg->yy_c_buf_p;
996 *yy_cp = yyg->yy_hold_char;
1003 yy_current_state = yyg->yy_start;
1007 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1008 if ( yy_accept[yy_current_state] )
1010 yyg->yy_last_accepting_state = yy_current_state;
1011 yyg->yy_last_accepting_cpos = yy_cp;
1013 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1015 yy_current_state = (int) yy_def[yy_current_state];
1016 if ( yy_current_state >= 47 )
1017 yy_c = yy_meta[yy_c];
1019 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1022 while ( yy_base[yy_current_state] != 87 );
1025 yy_act = yy_accept[yy_current_state];
1028 yy_cp = yyg->yy_last_accepting_cpos;
1029 yy_current_state = yyg->yy_last_accepting_state;
1030 yy_act = yy_accept[yy_current_state];
1033 YY_DO_BEFORE_ACTION;
1041 *yy_cp = yyg->yy_hold_char;
1042 yy_cp = yyg->yy_last_accepting_cpos;
1043 yy_current_state = yyg->yy_last_accepting_state;
1044 goto yy_find_action;
1049#line 26 "lib/route/pktloc_grammar.l"
1054#line 28 "lib/route/pktloc_grammar.l"
1058#line 31 "lib/route/pktloc_grammar.l"
1061#line 31 "lib/route/pktloc_grammar.l"
1063 yylval->i = strtoul(yytext, NULL, 0);
1069#line 36 "lib/route/pktloc_grammar.l"
1070{
return yylval->i = yytext[0]; }
1074#line 38 "lib/route/pktloc_grammar.l"
1075{ yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
1079#line 39 "lib/route/pktloc_grammar.l"
1080{ yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
1084#line 40 "lib/route/pktloc_grammar.l"
1085{ yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
1088#line 43 "lib/route/pktloc_grammar.l"
1091#line 43 "lib/route/pktloc_grammar.l"
1092{ yylval->i = TCF_LAYER_LINK;
return LAYER; }
1095#line 45 "lib/route/pktloc_grammar.l"
1098#line 45 "lib/route/pktloc_grammar.l"
1099{ yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
1102#line 47 "lib/route/pktloc_grammar.l"
1105#line 47 "lib/route/pktloc_grammar.l"
1106{ yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
1110#line 50 "lib/route/pktloc_grammar.l"
1112 yylval->s = strdup(yytext);
1113 if (yylval->s == NULL)
1120#line 56 "lib/route/pktloc_grammar.l"
1123#line 1123 "lib/route/pktloc_grammar.c"
1124case YY_STATE_EOF(INITIAL):
1127 case YY_END_OF_BUFFER:
1130 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1133 *yy_cp = yyg->yy_hold_char;
1134 YY_RESTORE_YY_MORE_OFFSET
1136 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1147 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1148 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1149 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1159 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1161 yy_state_type yy_next_state;
1163 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1165 yy_current_state = yy_get_previous_state( yyscanner );
1176 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1178 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1180 if ( yy_next_state )
1183 yy_cp = ++yyg->yy_c_buf_p;
1184 yy_current_state = yy_next_state;
1190 yy_cp = yyg->yy_c_buf_p;
1191 goto yy_find_action;
1195 else switch ( yy_get_next_buffer( yyscanner ) )
1197 case EOB_ACT_END_OF_FILE:
1199 yyg->yy_did_buffer_switch_on_eof = 0;
1201 if ( yywrap( yyscanner ) )
1212 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1214 yy_act = YY_STATE_EOF(YY_START);
1220 if ( ! yyg->yy_did_buffer_switch_on_eof )
1226 case EOB_ACT_CONTINUE_SCAN:
1228 yyg->yytext_ptr + yy_amount_of_matched_text;
1230 yy_current_state = yy_get_previous_state( yyscanner );
1232 yy_cp = yyg->yy_c_buf_p;
1233 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1236 case EOB_ACT_LAST_MATCH:
1238 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1240 yy_current_state = yy_get_previous_state( yyscanner );
1242 yy_cp = yyg->yy_c_buf_p;
1243 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1244 goto yy_find_action;
1251 "fatal flex scanner internal error--no action found" );
1264static int yy_get_next_buffer (yyscan_t yyscanner)
1267 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1268 char *source = yyg->yytext_ptr;
1269 int number_to_move, i;
1272 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1274 "fatal flex scanner internal error--end of buffer missed" );
1276 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1278 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1283 return EOB_ACT_END_OF_FILE;
1291 return EOB_ACT_LAST_MATCH;
1298 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
1300 for ( i = 0; i < number_to_move; ++i )
1301 *(dest++) = *(source++);
1303 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1307 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1312 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1314 while ( num_to_read <= 0 )
1320 int yy_c_buf_p_offset =
1321 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1323 if ( b->yy_is_our_buffer )
1325 int new_size = b->yy_buf_size * 2;
1327 if ( new_size <= 0 )
1328 b->yy_buf_size += b->yy_buf_size / 8;
1330 b->yy_buf_size *= 2;
1332 b->yy_ch_buf = (
char *)
1334 yyrealloc( (
void *) b->yy_ch_buf,
1335 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1339 b->yy_ch_buf = NULL;
1341 if ( ! b->yy_ch_buf )
1343 "fatal error - scanner input buffer overflow" );
1345 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1347 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1352 if ( num_to_read > YY_READ_BUF_SIZE )
1353 num_to_read = YY_READ_BUF_SIZE;
1356 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1357 yyg->yy_n_chars, num_to_read );
1359 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1362 if ( yyg->yy_n_chars == 0 )
1364 if ( number_to_move == YY_MORE_ADJ )
1366 ret_val = EOB_ACT_END_OF_FILE;
1367 yyrestart( yyin , yyscanner);
1372 ret_val = EOB_ACT_LAST_MATCH;
1373 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1374 YY_BUFFER_EOF_PENDING;
1379 ret_val = EOB_ACT_CONTINUE_SCAN;
1381 if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1383 int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1384 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc(
1385 (
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
1386 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1387 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1389 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1392 yyg->yy_n_chars += number_to_move;
1393 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1394 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1396 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1403 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1405 yy_state_type yy_current_state;
1409 yy_current_state = yyg->yy_start;
1411 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1413 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1414 if ( yy_accept[yy_current_state] )
1416 yyg->yy_last_accepting_state = yy_current_state;
1417 yyg->yy_last_accepting_cpos = yy_cp;
1419 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1421 yy_current_state = (int) yy_def[yy_current_state];
1422 if ( yy_current_state >= 47 )
1423 yy_c = yy_meta[yy_c];
1425 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1428 return yy_current_state;
1436 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1440 char *yy_cp = yyg->yy_c_buf_p;
1443 if ( yy_accept[yy_current_state] )
1445 yyg->yy_last_accepting_state = yy_current_state;
1446 yyg->yy_last_accepting_cpos = yy_cp;
1448 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1450 yy_current_state = (int) yy_def[yy_current_state];
1451 if ( yy_current_state >= 47 )
1452 yy_c = yy_meta[yy_c];
1454 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1455 yy_is_jam = (yy_current_state == 46);
1458 return yy_is_jam ? 0 : yy_current_state;
1467 static int yyinput (yyscan_t yyscanner)
1469 static int input (yyscan_t yyscanner)
1476 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1478 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1484 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1486 *yyg->yy_c_buf_p =
'\0';
1490 int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
1493 switch ( yy_get_next_buffer( yyscanner ) )
1495 case EOB_ACT_LAST_MATCH:
1507 yyrestart( yyin , yyscanner);
1511 case EOB_ACT_END_OF_FILE:
1513 if ( yywrap( yyscanner ) )
1516 if ( ! yyg->yy_did_buffer_switch_on_eof )
1519 return yyinput(yyscanner);
1521 return input(yyscanner);
1525 case EOB_ACT_CONTINUE_SCAN:
1526 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1532 c = *(
unsigned char *) yyg->yy_c_buf_p;
1533 *yyg->yy_c_buf_p =
'\0';
1534 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1545 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1549 if ( ! YY_CURRENT_BUFFER ){
1550 yyensure_buffer_stack (yyscanner);
1551 YY_CURRENT_BUFFER_LVALUE =
1552 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
1555 yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
1556 yy_load_buffer_state( yyscanner );
1563 void yy_switch_to_buffer (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1572 yyensure_buffer_stack (yyscanner);
1573 if ( YY_CURRENT_BUFFER == new_buffer )
1576 if ( YY_CURRENT_BUFFER )
1579 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1580 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1581 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1584 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1585 yy_load_buffer_state( yyscanner );
1592 yyg->yy_did_buffer_switch_on_eof = 1;
1595static void yy_load_buffer_state (yyscan_t yyscanner)
1598 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1599 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1600 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1601 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1610 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1616 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1618 b->yy_buf_size = size;
1623 b->yy_ch_buf = (
char *)
yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1624 if ( ! b->yy_ch_buf )
1625 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1627 b->yy_is_our_buffer = 1;
1629 yy_init_buffer( b, file , yyscanner);
1645 if ( b == YY_CURRENT_BUFFER )
1648 if ( b->yy_is_our_buffer )
1649 yyfree( (
void *) b->yy_ch_buf , yyscanner );
1651 yyfree( (
void *) b , yyscanner );
1658 static void yy_init_buffer (
YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1664 yy_flush_buffer( b , yyscanner);
1666 b->yy_input_file = file;
1667 b->yy_fill_buffer = 1;
1673 if (b != YY_CURRENT_BUFFER){
1678 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1699 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1700 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1702 b->yy_buf_pos = &b->yy_ch_buf[0];
1705 b->yy_buffer_status = YY_BUFFER_NEW;
1707 if ( b == YY_CURRENT_BUFFER )
1708 yy_load_buffer_state( yyscanner );
1717void yypush_buffer_state (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1720 if (new_buffer == NULL)
1723 yyensure_buffer_stack(yyscanner);
1726 if ( YY_CURRENT_BUFFER )
1729 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1730 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1731 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1735 if (YY_CURRENT_BUFFER)
1737 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1740 yy_load_buffer_state( yyscanner );
1741 yyg->yy_did_buffer_switch_on_eof = 1;
1748void yypop_buffer_state (yyscan_t yyscanner)
1751 if (!YY_CURRENT_BUFFER)
1754 yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
1755 YY_CURRENT_BUFFER_LVALUE = NULL;
1759 if (YY_CURRENT_BUFFER) {
1760 yy_load_buffer_state( yyscanner );
1761 yyg->yy_did_buffer_switch_on_eof = 1;
1768static void yyensure_buffer_stack (yyscan_t yyscanner)
1770 yy_size_t num_to_alloc;
1784 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1796 yy_size_t grow_size = 8 ;
1804 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1818YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1823 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1824 base[size-1] != YY_END_OF_BUFFER_CHAR )
1830 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1832 b->yy_buf_size = (int) (size - 2);
1833 b->yy_buf_pos = b->yy_ch_buf = base;
1834 b->yy_is_our_buffer = 0;
1835 b->yy_input_file = NULL;
1836 b->yy_n_chars = b->yy_buf_size;
1837 b->yy_is_interactive = 0;
1839 b->yy_fill_buffer = 0;
1840 b->yy_buffer_status = YY_BUFFER_NEW;
1842 yy_switch_to_buffer( b , yyscanner );
1855YY_BUFFER_STATE yy_scan_string (
const char * yystr , yyscan_t yyscanner)
1858 return yy_scan_bytes( yystr, (
int) strlen(yystr) , yyscanner);
1868YY_BUFFER_STATE yy_scan_bytes (
const char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1876 n = (yy_size_t) (_yybytes_len + 2);
1877 buf = (
char *)
yyalloc( n , yyscanner );
1879 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1881 for ( i = 0; i < _yybytes_len; ++i )
1882 buf[i] = yybytes[i];
1884 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1886 b = yy_scan_buffer( buf, n , yyscanner);
1888 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1893 b->yy_is_our_buffer = 1;
1898#ifndef YY_EXIT_FAILURE
1899#define YY_EXIT_FAILURE 2
1902static void yynoreturn yy_fatal_error (
const char* msg , yyscan_t yyscanner)
1906 fprintf( stderr,
"%s\n", msg );
1907 exit( YY_EXIT_FAILURE );
1917 int yyless_macro_arg = (n); \
1918 YY_LESS_LINENO(yyless_macro_arg);\
1919 yytext[yyleng] = yyg->yy_hold_char; \
1920 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1921 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1922 *yyg->yy_c_buf_p = '\0'; \
1923 yyleng = yyless_macro_arg; \
1932YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1941int yyget_lineno (yyscan_t yyscanner)
1945 if (! YY_CURRENT_BUFFER)
1954int yyget_column (yyscan_t yyscanner)
1958 if (! YY_CURRENT_BUFFER)
1967FILE *yyget_in (yyscan_t yyscanner)
1976FILE *yyget_out (yyscan_t yyscanner)
1985int yyget_leng (yyscan_t yyscanner)
1995char *yyget_text (yyscan_t yyscanner)
2005void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2008 yyextra = user_defined ;
2015void yyset_lineno (
int _line_number , yyscan_t yyscanner)
2020 if (! YY_CURRENT_BUFFER )
2021 YY_FATAL_ERROR(
"yyset_lineno called with no buffer" );
2023 yylineno = _line_number;
2030void yyset_column (
int _column_no , yyscan_t yyscanner)
2035 if (! YY_CURRENT_BUFFER )
2036 YY_FATAL_ERROR(
"yyset_column called with no buffer" );
2038 yycolumn = _column_no;
2047void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2053void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2059int yyget_debug (yyscan_t yyscanner)
2062 return yy_flex_debug;
2065void yyset_debug (
int _bdebug , yyscan_t yyscanner)
2068 yy_flex_debug = _bdebug ;
2073YYSTYPE * yyget_lval (yyscan_t yyscanner)
2079void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
2082 yylval = yylval_param;
2085YYLTYPE *yyget_lloc (yyscan_t yyscanner)
2091void yyset_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
2094 yylloc = yylloc_param;
2103int yylex_init(yyscan_t* ptr_yy_globals)
2105 if (ptr_yy_globals == NULL){
2110 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), NULL );
2112 if (*ptr_yy_globals == NULL){
2118 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2120 return yy_init_globals ( *ptr_yy_globals );
2130int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2134 yyset_extra (yy_user_defined, &dummy_yyguts);
2136 if (ptr_yy_globals == NULL){
2141 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
2143 if (*ptr_yy_globals == NULL){
2150 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2152 yyset_extra (yy_user_defined, *ptr_yy_globals);
2154 return yy_init_globals ( *ptr_yy_globals );
2157static int yy_init_globals (yyscan_t yyscanner)
2167 yyg->yy_c_buf_p = NULL;
2171 yyg->yy_start_stack_ptr = 0;
2172 yyg->yy_start_stack_depth = 0;
2173 yyg->yy_start_stack = NULL;
2191int yylex_destroy (yyscan_t yyscanner)
2196 while(YY_CURRENT_BUFFER){
2197 yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
2198 YY_CURRENT_BUFFER_LVALUE = NULL;
2199 yypop_buffer_state(yyscanner);
2207 yyfree( yyg->yy_start_stack , yyscanner );
2208 yyg->yy_start_stack = NULL;
2212 yy_init_globals( yyscanner);
2215 yyfree ( yyscanner , yyscanner );
2225static void yy_flex_strncpy (
char* s1,
const char * s2,
int n , yyscan_t yyscanner)
2231 for ( i = 0; i < n; ++i )
2236#ifdef YY_NEED_STRLEN
2237static int yy_flex_strlen (
const char * s , yyscan_t yyscanner)
2240 for ( n = 0; s[n]; ++n )
2247void *
yyalloc (yy_size_t size , yyscan_t yyscanner)
2251 return malloc(size);
2254void *yyrealloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2266 return realloc(ptr, size);
2269void yyfree (
void * ptr , yyscan_t yyscanner)
2273 free( (
char *) ptr );
2276#define YYTABLES_NAME "yytables"
2278#line 56 "lib/route/pktloc_grammar.l"
int yy_bs_column
The column count.
int yy_bs_lineno
The line count.
size_t yy_buffer_stack_max
capacity of stack.
YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
size_t yy_buffer_stack_top
index of top of stack.