1#line 1 "lib/route/pktloc_grammar.c"
2 #include "nl-default.h"
4#line 4 "lib/route/pktloc_grammar.c"
6#define YY_INT_ALIGNED short int
11#define YY_FLEX_MAJOR_VERSION 2
12#define YY_FLEX_MINOR_VERSION 6
13#define YY_FLEX_SUBMINOR_VERSION 4
14#if YY_FLEX_SUBMINOR_VERSION > 0
18#ifdef yy_create_buffer
19#define pktloc__create_buffer_ALREADY_DEFINED
21#define yy_create_buffer pktloc__create_buffer
24#ifdef yy_delete_buffer
25#define pktloc__delete_buffer_ALREADY_DEFINED
27#define yy_delete_buffer pktloc__delete_buffer
31#define pktloc__scan_buffer_ALREADY_DEFINED
33#define yy_scan_buffer pktloc__scan_buffer
37#define pktloc__scan_string_ALREADY_DEFINED
39#define yy_scan_string pktloc__scan_string
43#define pktloc__scan_bytes_ALREADY_DEFINED
45#define yy_scan_bytes pktloc__scan_bytes
49#define pktloc__init_buffer_ALREADY_DEFINED
51#define yy_init_buffer pktloc__init_buffer
55#define pktloc__flush_buffer_ALREADY_DEFINED
57#define yy_flush_buffer pktloc__flush_buffer
60#ifdef yy_load_buffer_state
61#define pktloc__load_buffer_state_ALREADY_DEFINED
63#define yy_load_buffer_state pktloc__load_buffer_state
66#ifdef yy_switch_to_buffer
67#define pktloc__switch_to_buffer_ALREADY_DEFINED
69#define yy_switch_to_buffer pktloc__switch_to_buffer
72#ifdef yypush_buffer_state
73#define pktloc_push_buffer_state_ALREADY_DEFINED
75#define yypush_buffer_state pktloc_push_buffer_state
78#ifdef yypop_buffer_state
79#define pktloc_pop_buffer_state_ALREADY_DEFINED
81#define yypop_buffer_state pktloc_pop_buffer_state
84#ifdef yyensure_buffer_stack
85#define pktloc_ensure_buffer_stack_ALREADY_DEFINED
87#define yyensure_buffer_stack pktloc_ensure_buffer_stack
91#define pktloc_lex_ALREADY_DEFINED
93#define yylex pktloc_lex
97#define pktloc_restart_ALREADY_DEFINED
99#define yyrestart pktloc_restart
103#define pktloc_lex_init_ALREADY_DEFINED
105#define yylex_init pktloc_lex_init
108#ifdef yylex_init_extra
109#define pktloc_lex_init_extra_ALREADY_DEFINED
111#define yylex_init_extra pktloc_lex_init_extra
115#define pktloc_lex_destroy_ALREADY_DEFINED
117#define yylex_destroy pktloc_lex_destroy
121#define pktloc_get_debug_ALREADY_DEFINED
123#define yyget_debug pktloc_get_debug
127#define pktloc_set_debug_ALREADY_DEFINED
129#define yyset_debug pktloc_set_debug
133#define pktloc_get_extra_ALREADY_DEFINED
135#define yyget_extra pktloc_get_extra
139#define pktloc_set_extra_ALREADY_DEFINED
141#define yyset_extra pktloc_set_extra
145#define pktloc_get_in_ALREADY_DEFINED
147#define yyget_in pktloc_get_in
151#define pktloc_set_in_ALREADY_DEFINED
153#define yyset_in pktloc_set_in
157#define pktloc_get_out_ALREADY_DEFINED
159#define yyget_out pktloc_get_out
163#define pktloc_set_out_ALREADY_DEFINED
165#define yyset_out pktloc_set_out
169#define pktloc_get_leng_ALREADY_DEFINED
171#define yyget_leng pktloc_get_leng
175#define pktloc_get_text_ALREADY_DEFINED
177#define yyget_text pktloc_get_text
181#define pktloc_get_lineno_ALREADY_DEFINED
183#define yyget_lineno pktloc_get_lineno
187#define pktloc_set_lineno_ALREADY_DEFINED
189#define yyset_lineno pktloc_set_lineno
193#define pktloc_get_column_ALREADY_DEFINED
195#define yyget_column pktloc_get_column
199#define pktloc_set_column_ALREADY_DEFINED
201#define yyset_column pktloc_set_column
205#define pktloc_wrap_ALREADY_DEFINED
207#define yywrap pktloc_wrap
211#define pktloc_get_lval_ALREADY_DEFINED
213#define yyget_lval pktloc_get_lval
217#define pktloc_set_lval_ALREADY_DEFINED
219#define yyset_lval pktloc_set_lval
223#define pktloc_get_lloc_ALREADY_DEFINED
225#define yyget_lloc pktloc_get_lloc
229#define pktloc_set_lloc_ALREADY_DEFINED
231#define yyset_lloc pktloc_set_lloc
235#define pktloc_alloc_ALREADY_DEFINED
237#define yyalloc pktloc_alloc
241#define pktloc_realloc_ALREADY_DEFINED
243#define yyrealloc pktloc_realloc
247#define pktloc_free_ALREADY_DEFINED
249#define yyfree pktloc_free
269#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
274#ifndef __STDC_LIMIT_MACROS
275#define __STDC_LIMIT_MACROS 1
279typedef int8_t flex_int8_t;
280typedef uint8_t flex_uint8_t;
281typedef int16_t flex_int16_t;
282typedef uint16_t flex_uint16_t;
283typedef int32_t flex_int32_t;
284typedef uint32_t flex_uint32_t;
286typedef signed char flex_int8_t;
287typedef short int flex_int16_t;
288typedef int flex_int32_t;
289typedef unsigned char flex_uint8_t;
290typedef unsigned short int flex_uint16_t;
291typedef unsigned int flex_uint32_t;
295#define INT8_MIN (-128)
298#define INT16_MIN (-32767-1)
301#define INT32_MIN (-2147483647-1)
304#define INT8_MAX (127)
307#define INT16_MAX (32767)
310#define INT32_MAX (2147483647)
313#define UINT8_MAX (255U)
316#define UINT16_MAX (65535U)
319#define UINT32_MAX (4294967295U)
323#define SIZE_MAX (~(size_t)0)
335#if defined(__GNUC__) && __GNUC__ >= 3
336#define yynoreturn __attribute__((__noreturn__))
347#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
350#ifndef YY_TYPEDEF_YY_SCANNER_T
351#define YY_TYPEDEF_YY_SCANNER_T
352typedef void* yyscan_t;
357#define yyin yyg->yyin_r
358#define yyout yyg->yyout_r
359#define yyextra yyg->yyextra_r
360#define yyleng yyg->yyleng_r
361#define yytext yyg->yytext_r
362#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
363#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
364#define yy_flex_debug yyg->yy_flex_debug_r
370#define BEGIN yyg->yy_start = 1 + 2 *
375#define YY_START ((yyg->yy_start - 1) / 2)
376#define YYSTATE YY_START
378#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
380#define YY_NEW_FILE yyrestart( yyin , yyscanner )
381#define YY_END_OF_BUFFER_CHAR 0
390#define YY_BUF_SIZE 32768
392#define YY_BUF_SIZE 16384
398#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
400#ifndef YY_TYPEDEF_YY_BUFFER_STATE
401#define YY_TYPEDEF_YY_BUFFER_STATE
405#ifndef YY_TYPEDEF_YY_SIZE_T
406#define YY_TYPEDEF_YY_SIZE_T
407typedef size_t yy_size_t;
410#define EOB_ACT_CONTINUE_SCAN 0
411#define EOB_ACT_END_OF_FILE 1
412#define EOB_ACT_LAST_MATCH 2
414 #define YY_LESS_LINENO(n)
415 #define YY_LINENO_REWIND_TO(ptr)
422 int yyless_macro_arg = (n); \
423 YY_LESS_LINENO(yyless_macro_arg);\
424 *yy_cp = yyg->yy_hold_char; \
425 YY_RESTORE_YY_MORE_OFFSET \
426 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
427 YY_DO_BEFORE_ACTION; \
430#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
432#ifndef YY_STRUCT_YY_BUFFER_STATE
433#define YY_STRUCT_YY_BUFFER_STATE
455 int yy_is_our_buffer;
462 int yy_is_interactive;
478 int yy_buffer_status;
480#define YY_BUFFER_NEW 0
481#define YY_BUFFER_NORMAL 1
492#define YY_BUFFER_EOF_PENDING 2
503#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
504 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
509#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
511void yyrestart ( FILE *input_file , yyscan_t yyscanner );
512void yy_switch_to_buffer (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
513YY_BUFFER_STATE yy_create_buffer ( FILE *file,
int size , yyscan_t yyscanner );
516void yypush_buffer_state (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
517void yypop_buffer_state ( yyscan_t yyscanner );
519static void yyensure_buffer_stack ( yyscan_t yyscanner );
520static void yy_load_buffer_state ( yyscan_t yyscanner );
521static void yy_init_buffer (
YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
522#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
524YY_BUFFER_STATE yy_scan_buffer (
char *base, yy_size_t size , yyscan_t yyscanner );
525YY_BUFFER_STATE yy_scan_string (
const char *yy_str , yyscan_t yyscanner );
526YY_BUFFER_STATE yy_scan_bytes (
const char *bytes,
int len , yyscan_t yyscanner );
528void *
yyalloc ( yy_size_t , yyscan_t yyscanner );
529void *yyrealloc (
void *, yy_size_t , yyscan_t yyscanner );
530void yyfree (
void * , yyscan_t yyscanner );
532#define yy_new_buffer yy_create_buffer
533#define yy_set_interactive(is_interactive) \
535 if ( ! YY_CURRENT_BUFFER ){ \
536 yyensure_buffer_stack (yyscanner); \
537 YY_CURRENT_BUFFER_LVALUE = \
538 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
540 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
542#define yy_set_bol(at_bol) \
544 if ( ! YY_CURRENT_BUFFER ){\
545 yyensure_buffer_stack (yyscanner); \
546 YY_CURRENT_BUFFER_LVALUE = \
547 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
549 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
551#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
553#define pktloc_wrap(yyscanner) (1)
554#define YY_SKIP_YYWRAP
555typedef flex_uint8_t YY_CHAR;
557typedef int yy_state_type;
559#define yytext_ptr yytext_r
561static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
562static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
563static int yy_get_next_buffer ( yyscan_t yyscanner );
564static void yynoreturn yy_fatal_error (
const char* msg , yyscan_t yyscanner );
569#define YY_DO_BEFORE_ACTION \
570 yyg->yytext_ptr = yy_bp; \
571 yyleng = (int) (yy_cp - yy_bp); \
572 yyg->yy_hold_char = *yy_cp; \
574 yyg->yy_c_buf_p = yy_cp;
575#define YY_NUM_RULES 16
576#define YY_END_OF_BUFFER 17
581 flex_int32_t yy_verify;
584static const flex_int16_t yy_accept[47] =
586 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
587 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
588 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
589 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
590 15, 15, 15, 15, 13, 0
593static const YY_CHAR yy_ec[256] =
595 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
596 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
597 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
598 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
599 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
600 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
601 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
602 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
603 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
604 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
606 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
607 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
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,
615 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,
621 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
625static const YY_CHAR yy_meta[29] =
627 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
628 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
629 1, 1, 1, 1, 1, 1, 1, 1
632static const flex_int16_t yy_base[50] =
634 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
635 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
636 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
637 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
638 30, 29, 26, 18, 0, 87, 31, 68, 70
641static const flex_int16_t yy_def[50] =
643 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
644 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
645 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
646 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
647 47, 47, 47, 47, 47, 0, 46, 46, 46
650static const flex_int16_t yy_nxt[116] =
652 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
653 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
654 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
655 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
656 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
657 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
658 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
659 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
660 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
661 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
663 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
667static const flex_int16_t yy_chk[116] =
669 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
670 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
671 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
672 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
673 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
674 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
675 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
676 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
677 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
678 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
680 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
687#define REJECT reject_used_but_not_detected
688#define yymore() yymore_used_but_not_detected
690#define YY_RESTORE_YY_MORE_OFFSET
691#line 1 "lib/route/pktloc_grammar.l"
693#line 5 "lib/route/pktloc_grammar.l"
694 #include <linux/tc_ematch/tc_em_cmp.h>
696 #include <netlink/netlink.h>
697 #include <netlink/utils.h>
698 #include <netlink/route/pktloc.h>
700 #include "pktloc_syntax.h"
702 int pktloc_get_column(yyscan_t);
703 void pktloc_set_column(
int, yyscan_t);
704#line 704 "lib/route/pktloc_grammar.c"
706#line 706 "lib/route/pktloc_grammar.c"
710#ifndef YY_NO_UNISTD_H
719#define YY_EXTRA_TYPE void *
727 YY_EXTRA_TYPE yyextra_r;
730 FILE *yyin_r, *yyout_r;
740 int yy_did_buffer_switch_on_eof;
741 int yy_start_stack_ptr;
742 int yy_start_stack_depth;
744 yy_state_type yy_last_accepting_state;
745 char* yy_last_accepting_cpos;
760static int yy_init_globals ( yyscan_t yyscanner );
764 # define yylval yyg->yylval_r
766 # define yylloc yyg->yylloc_r
768int yylex_init (yyscan_t* scanner);
770int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
775int yylex_destroy ( yyscan_t yyscanner );
777int yyget_debug ( yyscan_t yyscanner );
779void yyset_debug (
int debug_flag , yyscan_t yyscanner );
781YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
783void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
785FILE *yyget_in ( yyscan_t yyscanner );
787void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
789FILE *yyget_out ( yyscan_t yyscanner );
791void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
793 int yyget_leng ( yyscan_t yyscanner );
795char *yyget_text ( yyscan_t yyscanner );
797int yyget_lineno ( yyscan_t yyscanner );
799void yyset_lineno (
int _line_number , yyscan_t yyscanner );
801int yyget_column ( yyscan_t yyscanner );
803void yyset_column (
int _column_no , yyscan_t yyscanner );
805YYSTYPE * yyget_lval ( yyscan_t yyscanner );
807void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner );
809 YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
811 void yyset_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner );
817#ifndef YY_SKIP_YYWRAP
819extern "C" int yywrap ( yyscan_t yyscanner );
821extern int yywrap ( yyscan_t yyscanner );
830static void yy_flex_strncpy (
char *,
const char *,
int , yyscan_t yyscanner);
834static int yy_flex_strlen (
const char * , yyscan_t yyscanner);
839static int yyinput ( yyscan_t yyscanner );
841static int input ( yyscan_t yyscanner );
847#ifndef YY_READ_BUF_SIZE
850#define YY_READ_BUF_SIZE 16384
852#define YY_READ_BUF_SIZE 8192
861#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
868#define YY_INPUT(buf,result,max_size) \
869 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
873 for ( n = 0; n < max_size && \
874 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
877 buf[n++] = (char) c; \
878 if ( c == EOF && ferror( yyin ) ) \
879 YY_FATAL_ERROR( "input in flex scanner failed" ); \
885 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
887 if( errno != EINTR) \
889 YY_FATAL_ERROR( "input in flex scanner failed" ); \
905#define yyterminate() return YY_NULL
909#ifndef YY_START_STACK_INCR
910#define YY_START_STACK_INCR 25
914#ifndef YY_FATAL_ERROR
915#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
924#define YY_DECL_IS_OURS 1
927 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param , yyscan_t yyscanner);
929#define YY_DECL int yylex \
930 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
936#ifndef YY_USER_ACTION
937#define YY_USER_ACTION
942#define YY_BREAK break;
945#define YY_RULE_SETUP \
952 yy_state_type yy_current_state;
957 yylval = yylval_param;
959 yylloc = yylloc_param;
969 if ( ! yyg->yy_start )
978 if ( ! YY_CURRENT_BUFFER ) {
979 yyensure_buffer_stack (yyscanner);
980 YY_CURRENT_BUFFER_LVALUE =
981 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
984 yy_load_buffer_state( yyscanner );
988#line 27 "lib/route/pktloc_grammar.l"
991#line 991 "lib/route/pktloc_grammar.c"
995 yy_cp = yyg->yy_c_buf_p;
998 *yy_cp = yyg->yy_hold_char;
1005 yy_current_state = yyg->yy_start;
1009 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1010 if ( yy_accept[yy_current_state] )
1012 yyg->yy_last_accepting_state = yy_current_state;
1013 yyg->yy_last_accepting_cpos = yy_cp;
1015 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1017 yy_current_state = (int) yy_def[yy_current_state];
1018 if ( yy_current_state >= 47 )
1019 yy_c = yy_meta[yy_c];
1021 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1024 while ( yy_base[yy_current_state] != 87 );
1027 yy_act = yy_accept[yy_current_state];
1030 yy_cp = yyg->yy_last_accepting_cpos;
1031 yy_current_state = yyg->yy_last_accepting_state;
1032 yy_act = yy_accept[yy_current_state];
1035 YY_DO_BEFORE_ACTION;
1043 *yy_cp = yyg->yy_hold_char;
1044 yy_cp = yyg->yy_last_accepting_cpos;
1045 yy_current_state = yyg->yy_last_accepting_state;
1046 goto yy_find_action;
1051#line 29 "lib/route/pktloc_grammar.l"
1056#line 31 "lib/route/pktloc_grammar.l"
1060#line 34 "lib/route/pktloc_grammar.l"
1063#line 34 "lib/route/pktloc_grammar.l"
1065 yylval->i = strtoul(yytext, NULL, 0);
1071#line 39 "lib/route/pktloc_grammar.l"
1072{
return yylval->i = yytext[0]; }
1076#line 41 "lib/route/pktloc_grammar.l"
1077{ yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
1081#line 42 "lib/route/pktloc_grammar.l"
1082{ yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
1086#line 43 "lib/route/pktloc_grammar.l"
1087{ yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
1090#line 46 "lib/route/pktloc_grammar.l"
1093#line 46 "lib/route/pktloc_grammar.l"
1094{ yylval->i = TCF_LAYER_LINK;
return LAYER; }
1097#line 48 "lib/route/pktloc_grammar.l"
1100#line 48 "lib/route/pktloc_grammar.l"
1101{ yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
1104#line 50 "lib/route/pktloc_grammar.l"
1107#line 50 "lib/route/pktloc_grammar.l"
1108{ yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
1112#line 53 "lib/route/pktloc_grammar.l"
1114 yylval->s = strdup(yytext);
1115 if (yylval->s == NULL)
1122#line 59 "lib/route/pktloc_grammar.l"
1125#line 1125 "lib/route/pktloc_grammar.c"
1126case YY_STATE_EOF(INITIAL):
1129 case YY_END_OF_BUFFER:
1132 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1135 *yy_cp = yyg->yy_hold_char;
1136 YY_RESTORE_YY_MORE_OFFSET
1138 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1149 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1150 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1151 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1161 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1163 yy_state_type yy_next_state;
1165 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1167 yy_current_state = yy_get_previous_state( yyscanner );
1178 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1180 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1182 if ( yy_next_state )
1185 yy_cp = ++yyg->yy_c_buf_p;
1186 yy_current_state = yy_next_state;
1192 yy_cp = yyg->yy_c_buf_p;
1193 goto yy_find_action;
1197 else switch ( yy_get_next_buffer( yyscanner ) )
1199 case EOB_ACT_END_OF_FILE:
1201 yyg->yy_did_buffer_switch_on_eof = 0;
1203 if ( yywrap( yyscanner ) )
1214 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1216 yy_act = YY_STATE_EOF(YY_START);
1222 if ( ! yyg->yy_did_buffer_switch_on_eof )
1228 case EOB_ACT_CONTINUE_SCAN:
1230 yyg->yytext_ptr + yy_amount_of_matched_text;
1232 yy_current_state = yy_get_previous_state( yyscanner );
1234 yy_cp = yyg->yy_c_buf_p;
1235 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1238 case EOB_ACT_LAST_MATCH:
1240 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1242 yy_current_state = yy_get_previous_state( yyscanner );
1244 yy_cp = yyg->yy_c_buf_p;
1245 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1246 goto yy_find_action;
1253 "fatal flex scanner internal error--no action found" );
1266static int yy_get_next_buffer (yyscan_t yyscanner)
1269 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1270 char *source = yyg->yytext_ptr;
1271 int number_to_move, i;
1274 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1276 "fatal flex scanner internal error--end of buffer missed" );
1278 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1280 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1285 return EOB_ACT_END_OF_FILE;
1293 return EOB_ACT_LAST_MATCH;
1300 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
1302 for ( i = 0; i < number_to_move; ++i )
1303 *(dest++) = *(source++);
1305 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1309 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1314 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1316 while ( num_to_read <= 0 )
1322 int yy_c_buf_p_offset =
1323 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1325 if ( b->yy_is_our_buffer )
1327 int new_size = b->yy_buf_size * 2;
1329 if ( new_size <= 0 )
1330 b->yy_buf_size += b->yy_buf_size / 8;
1332 b->yy_buf_size *= 2;
1334 b->yy_ch_buf = (
char *)
1336 yyrealloc( (
void *) b->yy_ch_buf,
1337 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1341 b->yy_ch_buf = NULL;
1343 if ( ! b->yy_ch_buf )
1345 "fatal error - scanner input buffer overflow" );
1347 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1349 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1354 if ( num_to_read > YY_READ_BUF_SIZE )
1355 num_to_read = YY_READ_BUF_SIZE;
1358 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1359 yyg->yy_n_chars, num_to_read );
1361 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1364 if ( yyg->yy_n_chars == 0 )
1366 if ( number_to_move == YY_MORE_ADJ )
1368 ret_val = EOB_ACT_END_OF_FILE;
1369 yyrestart( yyin , yyscanner);
1374 ret_val = EOB_ACT_LAST_MATCH;
1375 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1376 YY_BUFFER_EOF_PENDING;
1381 ret_val = EOB_ACT_CONTINUE_SCAN;
1383 if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1385 int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1386 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc(
1387 (
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
1388 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1389 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1391 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1394 yyg->yy_n_chars += number_to_move;
1395 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1396 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1398 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1405 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1407 yy_state_type yy_current_state;
1411 yy_current_state = yyg->yy_start;
1413 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1415 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1416 if ( yy_accept[yy_current_state] )
1418 yyg->yy_last_accepting_state = yy_current_state;
1419 yyg->yy_last_accepting_cpos = yy_cp;
1421 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1423 yy_current_state = (int) yy_def[yy_current_state];
1424 if ( yy_current_state >= 47 )
1425 yy_c = yy_meta[yy_c];
1427 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1430 return yy_current_state;
1438 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1442 char *yy_cp = yyg->yy_c_buf_p;
1445 if ( yy_accept[yy_current_state] )
1447 yyg->yy_last_accepting_state = yy_current_state;
1448 yyg->yy_last_accepting_cpos = yy_cp;
1450 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1452 yy_current_state = (int) yy_def[yy_current_state];
1453 if ( yy_current_state >= 47 )
1454 yy_c = yy_meta[yy_c];
1456 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1457 yy_is_jam = (yy_current_state == 46);
1460 return yy_is_jam ? 0 : yy_current_state;
1469 static int yyinput (yyscan_t yyscanner)
1471 static int input (yyscan_t yyscanner)
1478 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1480 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1486 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1488 *yyg->yy_c_buf_p =
'\0';
1492 int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
1495 switch ( yy_get_next_buffer( yyscanner ) )
1497 case EOB_ACT_LAST_MATCH:
1509 yyrestart( yyin , yyscanner);
1513 case EOB_ACT_END_OF_FILE:
1515 if ( yywrap( yyscanner ) )
1518 if ( ! yyg->yy_did_buffer_switch_on_eof )
1521 return yyinput(yyscanner);
1523 return input(yyscanner);
1527 case EOB_ACT_CONTINUE_SCAN:
1528 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1534 c = *(
unsigned char *) yyg->yy_c_buf_p;
1535 *yyg->yy_c_buf_p =
'\0';
1536 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1547 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1551 if ( ! YY_CURRENT_BUFFER ){
1552 yyensure_buffer_stack (yyscanner);
1553 YY_CURRENT_BUFFER_LVALUE =
1554 yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
1557 yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
1558 yy_load_buffer_state( yyscanner );
1565 void yy_switch_to_buffer (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1574 yyensure_buffer_stack (yyscanner);
1575 if ( YY_CURRENT_BUFFER == new_buffer )
1578 if ( YY_CURRENT_BUFFER )
1581 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1582 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1583 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1586 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1587 yy_load_buffer_state( yyscanner );
1594 yyg->yy_did_buffer_switch_on_eof = 1;
1597static void yy_load_buffer_state (yyscan_t yyscanner)
1600 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1601 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1602 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1603 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1612 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1618 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1620 b->yy_buf_size = size;
1625 b->yy_ch_buf = (
char *)
yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1626 if ( ! b->yy_ch_buf )
1627 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1629 b->yy_is_our_buffer = 1;
1631 yy_init_buffer( b, file , yyscanner);
1647 if ( b == YY_CURRENT_BUFFER )
1650 if ( b->yy_is_our_buffer )
1651 yyfree( (
void *) b->yy_ch_buf , yyscanner );
1653 yyfree( (
void *) b , yyscanner );
1660 static void yy_init_buffer (
YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1666 yy_flush_buffer( b , yyscanner);
1668 b->yy_input_file = file;
1669 b->yy_fill_buffer = 1;
1675 if (b != YY_CURRENT_BUFFER){
1680 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1701 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1702 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1704 b->yy_buf_pos = &b->yy_ch_buf[0];
1707 b->yy_buffer_status = YY_BUFFER_NEW;
1709 if ( b == YY_CURRENT_BUFFER )
1710 yy_load_buffer_state( yyscanner );
1719void yypush_buffer_state (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1722 if (new_buffer == NULL)
1725 yyensure_buffer_stack(yyscanner);
1728 if ( YY_CURRENT_BUFFER )
1731 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1732 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1733 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1737 if (YY_CURRENT_BUFFER)
1739 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1742 yy_load_buffer_state( yyscanner );
1743 yyg->yy_did_buffer_switch_on_eof = 1;
1750void yypop_buffer_state (yyscan_t yyscanner)
1753 if (!YY_CURRENT_BUFFER)
1756 yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
1757 YY_CURRENT_BUFFER_LVALUE = NULL;
1761 if (YY_CURRENT_BUFFER) {
1762 yy_load_buffer_state( yyscanner );
1763 yyg->yy_did_buffer_switch_on_eof = 1;
1770static void yyensure_buffer_stack (yyscan_t yyscanner)
1772 yy_size_t num_to_alloc;
1786 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1798 yy_size_t grow_size = 8 ;
1806 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1820YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1825 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1826 base[size-1] != YY_END_OF_BUFFER_CHAR )
1832 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1834 b->yy_buf_size = (int) (size - 2);
1835 b->yy_buf_pos = b->yy_ch_buf = base;
1836 b->yy_is_our_buffer = 0;
1837 b->yy_input_file = NULL;
1838 b->yy_n_chars = b->yy_buf_size;
1839 b->yy_is_interactive = 0;
1841 b->yy_fill_buffer = 0;
1842 b->yy_buffer_status = YY_BUFFER_NEW;
1844 yy_switch_to_buffer( b , yyscanner );
1857YY_BUFFER_STATE yy_scan_string (
const char * yystr , yyscan_t yyscanner)
1860 return yy_scan_bytes( yystr, (
int) strlen(yystr) , yyscanner);
1870YY_BUFFER_STATE yy_scan_bytes (
const char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1878 n = (yy_size_t) (_yybytes_len + 2);
1879 buf = (
char *)
yyalloc( n , yyscanner );
1881 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1883 for ( i = 0; i < _yybytes_len; ++i )
1884 buf[i] = yybytes[i];
1886 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1888 b = yy_scan_buffer( buf, n , yyscanner);
1890 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1895 b->yy_is_our_buffer = 1;
1900#ifndef YY_EXIT_FAILURE
1901#define YY_EXIT_FAILURE 2
1904static void yynoreturn yy_fatal_error (
const char* msg , yyscan_t yyscanner)
1908 fprintf( stderr,
"%s\n", msg );
1909 exit( YY_EXIT_FAILURE );
1919 int yyless_macro_arg = (n); \
1920 YY_LESS_LINENO(yyless_macro_arg);\
1921 yytext[yyleng] = yyg->yy_hold_char; \
1922 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1923 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1924 *yyg->yy_c_buf_p = '\0'; \
1925 yyleng = yyless_macro_arg; \
1934YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1943int yyget_lineno (yyscan_t yyscanner)
1947 if (! YY_CURRENT_BUFFER)
1956int yyget_column (yyscan_t yyscanner)
1960 if (! YY_CURRENT_BUFFER)
1969FILE *yyget_in (yyscan_t yyscanner)
1978FILE *yyget_out (yyscan_t yyscanner)
1987int yyget_leng (yyscan_t yyscanner)
1997char *yyget_text (yyscan_t yyscanner)
2007void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2010 yyextra = user_defined ;
2017void yyset_lineno (
int _line_number , yyscan_t yyscanner)
2022 if (! YY_CURRENT_BUFFER )
2023 YY_FATAL_ERROR(
"yyset_lineno called with no buffer" );
2025 yylineno = _line_number;
2032void yyset_column (
int _column_no , yyscan_t yyscanner)
2037 if (! YY_CURRENT_BUFFER )
2038 YY_FATAL_ERROR(
"yyset_column called with no buffer" );
2040 yycolumn = _column_no;
2049void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2055void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2061int yyget_debug (yyscan_t yyscanner)
2064 return yy_flex_debug;
2067void yyset_debug (
int _bdebug , yyscan_t yyscanner)
2070 yy_flex_debug = _bdebug ;
2075YYSTYPE * yyget_lval (yyscan_t yyscanner)
2081void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
2084 yylval = yylval_param;
2087YYLTYPE *yyget_lloc (yyscan_t yyscanner)
2093void yyset_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
2096 yylloc = yylloc_param;
2105int yylex_init(yyscan_t* ptr_yy_globals)
2107 if (ptr_yy_globals == NULL){
2112 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), NULL );
2114 if (*ptr_yy_globals == NULL){
2120 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2122 return yy_init_globals ( *ptr_yy_globals );
2132int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2136 yyset_extra (yy_user_defined, &dummy_yyguts);
2138 if (ptr_yy_globals == NULL){
2143 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
2145 if (*ptr_yy_globals == NULL){
2152 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2154 yyset_extra (yy_user_defined, *ptr_yy_globals);
2156 return yy_init_globals ( *ptr_yy_globals );
2159static int yy_init_globals (yyscan_t yyscanner)
2169 yyg->yy_c_buf_p = NULL;
2173 yyg->yy_start_stack_ptr = 0;
2174 yyg->yy_start_stack_depth = 0;
2175 yyg->yy_start_stack = NULL;
2193int yylex_destroy (yyscan_t yyscanner)
2198 while(YY_CURRENT_BUFFER){
2199 yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
2200 YY_CURRENT_BUFFER_LVALUE = NULL;
2201 yypop_buffer_state(yyscanner);
2209 yyfree( yyg->yy_start_stack , yyscanner );
2210 yyg->yy_start_stack = NULL;
2214 yy_init_globals( yyscanner);
2217 yyfree ( yyscanner , yyscanner );
2227static void yy_flex_strncpy (
char* s1,
const char * s2,
int n , yyscan_t yyscanner)
2233 for ( i = 0; i < n; ++i )
2238#ifdef YY_NEED_STRLEN
2239static int yy_flex_strlen (
const char * s , yyscan_t yyscanner)
2242 for ( n = 0; s[n]; ++n )
2249void *
yyalloc (yy_size_t size , yyscan_t yyscanner)
2253 return malloc(size);
2256void *yyrealloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2268 return realloc(ptr, size);
2271void yyfree (
void * ptr , yyscan_t yyscanner)
2275 free( (
char *) ptr );
2278#define YYTABLES_NAME "yytables"
2280#line 59 "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.