1 #line 2 "route/pktloc_grammar.c"
3 #line 4 "route/pktloc_grammar.c"
5 #define YY_INT_ALIGNED short int
10 #define YY_FLEX_MAJOR_VERSION 2
11 #define YY_FLEX_MINOR_VERSION 5
12 #define YY_FLEX_SUBMINOR_VERSION 35
13 #if YY_FLEX_SUBMINOR_VERSION > 0
34 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
39 #ifndef __STDC_LIMIT_MACROS
40 #define __STDC_LIMIT_MACROS 1
44 typedef int8_t flex_int8_t;
45 typedef uint8_t flex_uint8_t;
46 typedef int16_t flex_int16_t;
47 typedef uint16_t flex_uint16_t;
48 typedef int32_t flex_int32_t;
49 typedef uint32_t flex_uint32_t;
51 typedef signed char flex_int8_t;
52 typedef short int flex_int16_t;
53 typedef int flex_int32_t;
54 typedef unsigned char flex_uint8_t;
55 typedef unsigned short int flex_uint16_t;
56 typedef unsigned int flex_uint32_t;
61 #define INT8_MIN (-128)
64 #define INT16_MIN (-32767-1)
67 #define INT32_MIN (-2147483647-1)
70 #define INT8_MAX (127)
73 #define INT16_MAX (32767)
76 #define INT32_MAX (2147483647)
79 #define UINT8_MAX (255U)
82 #define UINT16_MAX (65535U)
85 #define UINT32_MAX (4294967295U)
98 #if defined (__STDC__)
106 #define yyconst const
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
122 #ifndef YY_TYPEDEF_YY_SCANNER_T
123 #define YY_TYPEDEF_YY_SCANNER_T
124 typedef void* yyscan_t;
129 #define yyin yyg->yyin_r
130 #define yyout yyg->yyout_r
131 #define yyextra yyg->yyextra_r
132 #define yyleng yyg->yyleng_r
133 #define yytext yyg->yytext_r
134 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
135 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
136 #define yy_flex_debug yyg->yy_flex_debug_r
142 #define BEGIN yyg->yy_start = 1 + 2 *
148 #define YY_START ((yyg->yy_start - 1) / 2)
149 #define YYSTATE YY_START
152 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155 #define YY_NEW_FILE pktloc_restart(yyin ,yyscanner )
157 #define YY_END_OF_BUFFER_CHAR 0
161 #define YY_BUF_SIZE 16384
166 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
169 #define YY_TYPEDEF_YY_BUFFER_STATE
173 #define EOB_ACT_CONTINUE_SCAN 0
174 #define EOB_ACT_END_OF_FILE 1
175 #define EOB_ACT_LAST_MATCH 2
177 #define YY_LESS_LINENO(n)
184 int yyless_macro_arg = (n); \
185 YY_LESS_LINENO(yyless_macro_arg);\
186 *yy_cp = yyg->yy_hold_char; \
187 YY_RESTORE_YY_MORE_OFFSET \
188 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
189 YY_DO_BEFORE_ACTION; \
193 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
195 #ifndef YY_TYPEDEF_YY_SIZE_T
196 #define YY_TYPEDEF_YY_SIZE_T
197 typedef size_t yy_size_t;
200 #ifndef YY_STRUCT_YY_BUFFER_STATE
201 #define YY_STRUCT_YY_BUFFER_STATE
212 yy_size_t yy_buf_size;
223 int yy_is_our_buffer;
230 int yy_is_interactive;
246 int yy_buffer_status;
248 #define YY_BUFFER_NEW 0
249 #define YY_BUFFER_NORMAL 1
260 #define YY_BUFFER_EOF_PENDING 2
271 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
272 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
278 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
280 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
281 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
282 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
283 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
284 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
285 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
286 void pktloc_pop_buffer_state (yyscan_t yyscanner );
288 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
289 static void pktloc__load_buffer_state (yyscan_t yyscanner );
290 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
292 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
294 YY_BUFFER_STATE pktloc__scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
295 YY_BUFFER_STATE pktloc__scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
296 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char *bytes,
int len ,yyscan_t yyscanner );
298 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
299 void *pktloc_realloc (
void *,yy_size_t ,yyscan_t yyscanner );
300 void pktloc_free (
void * ,yyscan_t yyscanner );
302 #define yy_new_buffer pktloc__create_buffer
304 #define yy_set_interactive(is_interactive) \
306 if ( ! YY_CURRENT_BUFFER ){ \
307 pktloc_ensure_buffer_stack (yyscanner); \
308 YY_CURRENT_BUFFER_LVALUE = \
309 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
311 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
314 #define yy_set_bol(at_bol) \
316 if ( ! YY_CURRENT_BUFFER ){\
317 pktloc_ensure_buffer_stack (yyscanner); \
318 YY_CURRENT_BUFFER_LVALUE = \
319 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
321 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
324 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
326 #define pktloc_wrap(n) 1
327 #define YY_SKIP_YYWRAP
329 typedef unsigned char YY_CHAR;
331 typedef int yy_state_type;
333 #define yytext_ptr yytext_r
335 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
336 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
337 static int yy_get_next_buffer (yyscan_t yyscanner );
338 static void yy_fatal_error (yyconst
char msg[] ,yyscan_t yyscanner );
343 #define YY_DO_BEFORE_ACTION \
344 yyg->yytext_ptr = yy_bp; \
345 yyleng = (size_t) (yy_cp - yy_bp); \
346 yyg->yy_hold_char = *yy_cp; \
348 yyg->yy_c_buf_p = yy_cp;
350 #define YY_NUM_RULES 16
351 #define YY_END_OF_BUFFER 17
356 flex_int32_t yy_verify;
359 static yyconst flex_int16_t yy_accept[47] =
361 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
362 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
363 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
364 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
365 15, 15, 15, 15, 13, 0
368 static yyconst flex_int32_t yy_ec[256] =
370 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
371 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
373 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
374 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
375 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
376 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
377 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
378 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
379 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
381 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
382 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
387 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
389 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
392 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 static yyconst flex_int32_t yy_meta[29] =
402 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
404 1, 1, 1, 1, 1, 1, 1, 1
407 static yyconst flex_int16_t yy_base[50] =
409 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
410 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
411 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
412 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
413 30, 29, 26, 18, 0, 87, 31, 68, 70
416 static yyconst flex_int16_t yy_def[50] =
418 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
419 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
420 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
421 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
422 47, 47, 47, 47, 47, 0, 46, 46, 46
425 static yyconst flex_int16_t yy_nxt[116] =
427 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
428 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
429 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
430 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
431 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
432 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
433 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
434 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
435 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
436 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
438 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
442 static yyconst flex_int16_t yy_chk[116] =
444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
447 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
448 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
449 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
450 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
451 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
452 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
453 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
455 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
462 #define REJECT reject_used_but_not_detected
463 #define yymore() yymore_used_but_not_detected
464 #define YY_MORE_ADJ 0
465 #define YY_RESTORE_YY_MORE_OFFSET
466 #line 1 "route/pktloc_grammar.l"
467 #line 2 "route/pktloc_grammar.l"
468 #include <netlink-local.h>
469 #include <netlink-tc.h>
470 #include <netlink/netlink.h>
471 #include <netlink/utils.h>
472 #include <netlink/route/pktloc.h>
473 #include "pktloc_syntax.h"
474 #define YY_NO_INPUT 1
475 #line 476 "route/pktloc_grammar.c"
479 #ifndef YY_NO_UNISTD_H
487 #ifndef YY_EXTRA_TYPE
488 #define YY_EXTRA_TYPE void *
496 YY_EXTRA_TYPE yyextra_r;
499 FILE *yyin_r, *yyout_r;
509 int yy_did_buffer_switch_on_eof;
510 int yy_start_stack_ptr;
511 int yy_start_stack_depth;
513 yy_state_type yy_last_accepting_state;
514 char* yy_last_accepting_cpos;
529 static int yy_init_globals (yyscan_t yyscanner );
533 # define yylval yyg->yylval_r
535 # define yylloc yyg->yylloc_r
537 int pktloc_lex_init (yyscan_t* scanner);
539 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
544 int pktloc_lex_destroy (yyscan_t yyscanner );
546 int pktloc_get_debug (yyscan_t yyscanner );
548 void pktloc_set_debug (
int debug_flag ,yyscan_t yyscanner );
550 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
552 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
554 FILE *pktloc_get_in (yyscan_t yyscanner );
556 void pktloc_set_in (FILE * in_str ,yyscan_t yyscanner );
558 FILE *pktloc_get_out (yyscan_t yyscanner );
560 void pktloc_set_out (FILE * out_str ,yyscan_t yyscanner );
562 int pktloc_get_leng (yyscan_t yyscanner );
564 char *pktloc_get_text (yyscan_t yyscanner );
566 int pktloc_get_lineno (yyscan_t yyscanner );
568 void pktloc_set_lineno (
int line_number ,yyscan_t yyscanner );
570 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
572 void pktloc_set_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
574 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
576 void pktloc_set_lloc (
YYLTYPE * yylloc_param ,yyscan_t yyscanner );
582 #ifndef YY_SKIP_YYWRAP
584 extern "C" int pktloc_wrap (yyscan_t yyscanner );
586 extern int pktloc_wrap (yyscan_t yyscanner );
591 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
594 #ifdef YY_NEED_STRLEN
595 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
601 static int yyinput (yyscan_t yyscanner );
603 static int input (yyscan_t yyscanner );
609 #ifndef YY_READ_BUF_SIZE
610 #define YY_READ_BUF_SIZE 8192
618 #define ECHO fwrite( yytext, yyleng, 1, yyout )
625 #define YY_INPUT(buf,result,max_size) \
626 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
630 for ( n = 0; n < max_size && \
631 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
634 buf[n++] = (char) c; \
635 if ( c == EOF && ferror( yyin ) ) \
636 YY_FATAL_ERROR( "input in flex scanner failed" ); \
642 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
644 if( errno != EINTR) \
646 YY_FATAL_ERROR( "input in flex scanner failed" ); \
662 #define yyterminate() return YY_NULL
666 #ifndef YY_START_STACK_INCR
667 #define YY_START_STACK_INCR 25
671 #ifndef YY_FATAL_ERROR
672 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
681 #define YY_DECL_IS_OURS 1
683 extern int pktloc_lex \
684 (
YYSTYPE * yylval_param,
YYLTYPE * yylloc_param ,yyscan_t yyscanner);
686 #define YY_DECL int pktloc_lex \
687 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
693 #ifndef YY_USER_ACTION
694 #define YY_USER_ACTION
699 #define YY_BREAK break;
702 #define YY_RULE_SETUP \
709 register yy_state_type yy_current_state;
710 register char *yy_cp, *yy_bp;
714 #line 20 "route/pktloc_grammar.l"
717 #line 718 "route/pktloc_grammar.c"
719 yylval = yylval_param;
721 yylloc = yylloc_param;
731 if ( ! yyg->yy_start )
740 if ( ! YY_CURRENT_BUFFER ) {
741 pktloc_ensure_buffer_stack (yyscanner);
742 YY_CURRENT_BUFFER_LVALUE =
743 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
746 pktloc__load_buffer_state(yyscanner );
751 yy_cp = yyg->yy_c_buf_p;
754 *yy_cp = yyg->yy_hold_char;
761 yy_current_state = yyg->yy_start;
765 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
766 if ( yy_accept[yy_current_state] )
768 yyg->yy_last_accepting_state = yy_current_state;
769 yyg->yy_last_accepting_cpos = yy_cp;
771 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
773 yy_current_state = (int) yy_def[yy_current_state];
774 if ( yy_current_state >= 47 )
775 yy_c = yy_meta[(
unsigned int) yy_c];
777 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
780 while ( yy_base[yy_current_state] != 87 );
783 yy_act = yy_accept[yy_current_state];
786 yy_cp = yyg->yy_last_accepting_cpos;
787 yy_current_state = yyg->yy_last_accepting_state;
788 yy_act = yy_accept[yy_current_state];
799 *yy_cp = yyg->yy_hold_char;
800 yy_cp = yyg->yy_last_accepting_cpos;
801 yy_current_state = yyg->yy_last_accepting_state;
807 #line 22 "route/pktloc_grammar.l"
812 #line 24 "route/pktloc_grammar.l"
816 #line 27 "route/pktloc_grammar.l"
819 #line 27 "route/pktloc_grammar.l"
821 yylval->i = strtoul(yytext, NULL, 0);
827 #line 32 "route/pktloc_grammar.l"
828 {
return yylval->i = yytext[0]; }
832 #line 34 "route/pktloc_grammar.l"
833 { yylval->i = TCF_EM_ALIGN_U8;
return ALIGN; }
837 #line 35 "route/pktloc_grammar.l"
838 { yylval->i = TCF_EM_ALIGN_U16;
return ALIGN; }
842 #line 36 "route/pktloc_grammar.l"
843 { yylval->i = TCF_EM_ALIGN_U32;
return ALIGN; }
846 #line 39 "route/pktloc_grammar.l"
849 #line 39 "route/pktloc_grammar.l"
850 { yylval->i = TCF_LAYER_LINK;
return LAYER; }
853 #line 41 "route/pktloc_grammar.l"
856 #line 41 "route/pktloc_grammar.l"
857 { yylval->i = TCF_LAYER_NETWORK;
return LAYER; }
860 #line 43 "route/pktloc_grammar.l"
863 #line 43 "route/pktloc_grammar.l"
864 { yylval->i = TCF_LAYER_TRANSPORT;
return LAYER; }
868 #line 46 "route/pktloc_grammar.l"
870 yylval->s = strdup(yytext);
871 if (yylval->s == NULL)
878 #line 52 "route/pktloc_grammar.l"
881 #line 882 "route/pktloc_grammar.c"
882 case YY_STATE_EOF(INITIAL):
885 case YY_END_OF_BUFFER:
888 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
891 *yy_cp = yyg->yy_hold_char;
892 YY_RESTORE_YY_MORE_OFFSET
894 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
905 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
906 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
907 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
917 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
919 yy_state_type yy_next_state;
921 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
923 yy_current_state = yy_get_previous_state( yyscanner );
934 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
936 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
941 yy_cp = ++yyg->yy_c_buf_p;
942 yy_current_state = yy_next_state;
948 yy_cp = yyg->yy_c_buf_p;
953 else switch ( yy_get_next_buffer( yyscanner ) )
955 case EOB_ACT_END_OF_FILE:
957 yyg->yy_did_buffer_switch_on_eof = 0;
959 if ( pktloc_wrap(yyscanner ) )
970 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
972 yy_act = YY_STATE_EOF(YY_START);
978 if ( ! yyg->yy_did_buffer_switch_on_eof )
984 case EOB_ACT_CONTINUE_SCAN:
986 yyg->yytext_ptr + yy_amount_of_matched_text;
988 yy_current_state = yy_get_previous_state( yyscanner );
990 yy_cp = yyg->yy_c_buf_p;
991 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
994 case EOB_ACT_LAST_MATCH:
996 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
998 yy_current_state = yy_get_previous_state( yyscanner );
1000 yy_cp = yyg->yy_c_buf_p;
1001 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1002 goto yy_find_action;
1009 "fatal flex scanner internal error--no action found" );
1021 static int yy_get_next_buffer (yyscan_t yyscanner)
1024 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1025 register char *source = yyg->yytext_ptr;
1026 register int number_to_move, i;
1029 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1031 "fatal flex scanner internal error--end of buffer missed" );
1033 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1035 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1040 return EOB_ACT_END_OF_FILE;
1048 return EOB_ACT_LAST_MATCH;
1055 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1057 for ( i = 0; i < number_to_move; ++i )
1058 *(dest++) = *(source++);
1060 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1064 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1069 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1071 while ( num_to_read <= 0 )
1075 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1077 int yy_c_buf_p_offset =
1078 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1080 if ( b->yy_is_our_buffer )
1082 int new_size = b->yy_buf_size * 2;
1084 if ( new_size <= 0 )
1085 b->yy_buf_size += b->yy_buf_size / 8;
1087 b->yy_buf_size *= 2;
1089 b->yy_ch_buf = (
char *)
1091 pktloc_realloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1097 if ( ! b->yy_ch_buf )
1099 "fatal error - scanner input buffer overflow" );
1101 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1103 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1108 if ( num_to_read > YY_READ_BUF_SIZE )
1109 num_to_read = YY_READ_BUF_SIZE;
1112 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1113 yyg->yy_n_chars, (
size_t) num_to_read );
1115 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1118 if ( yyg->yy_n_chars == 0 )
1120 if ( number_to_move == YY_MORE_ADJ )
1122 ret_val = EOB_ACT_END_OF_FILE;
1123 pktloc_restart(yyin ,yyscanner);
1128 ret_val = EOB_ACT_LAST_MATCH;
1129 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1130 YY_BUFFER_EOF_PENDING;
1135 ret_val = EOB_ACT_CONTINUE_SCAN;
1137 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1139 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1140 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) pktloc_realloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1141 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1142 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1145 yyg->yy_n_chars += number_to_move;
1146 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1147 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1149 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1156 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1158 register yy_state_type yy_current_state;
1159 register char *yy_cp;
1162 yy_current_state = yyg->yy_start;
1164 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1166 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1167 if ( yy_accept[yy_current_state] )
1169 yyg->yy_last_accepting_state = yy_current_state;
1170 yyg->yy_last_accepting_cpos = yy_cp;
1172 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1174 yy_current_state = (int) yy_def[yy_current_state];
1175 if ( yy_current_state >= 47 )
1176 yy_c = yy_meta[(
unsigned int) yy_c];
1178 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1181 return yy_current_state;
1189 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1191 register int yy_is_jam;
1193 register char *yy_cp = yyg->yy_c_buf_p;
1195 register YY_CHAR yy_c = 1;
1196 if ( yy_accept[yy_current_state] )
1198 yyg->yy_last_accepting_state = yy_current_state;
1199 yyg->yy_last_accepting_cpos = yy_cp;
1201 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1203 yy_current_state = (int) yy_def[yy_current_state];
1204 if ( yy_current_state >= 47 )
1205 yy_c = yy_meta[(
unsigned int) yy_c];
1207 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1208 yy_is_jam = (yy_current_state == 46);
1210 return yy_is_jam ? 0 : yy_current_state;
1215 static int yyinput (yyscan_t yyscanner)
1217 static int input (yyscan_t yyscanner)
1224 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1226 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1232 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1234 *yyg->yy_c_buf_p =
'\0';
1238 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1241 switch ( yy_get_next_buffer( yyscanner ) )
1243 case EOB_ACT_LAST_MATCH:
1255 pktloc_restart(yyin ,yyscanner);
1259 case EOB_ACT_END_OF_FILE:
1261 if ( pktloc_wrap(yyscanner ) )
1264 if ( ! yyg->yy_did_buffer_switch_on_eof )
1267 return yyinput(yyscanner);
1269 return input(yyscanner);
1273 case EOB_ACT_CONTINUE_SCAN:
1274 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1280 c = *(
unsigned char *) yyg->yy_c_buf_p;
1281 *yyg->yy_c_buf_p =
'\0';
1282 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1293 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
1297 if ( ! YY_CURRENT_BUFFER ){
1298 pktloc_ensure_buffer_stack (yyscanner);
1299 YY_CURRENT_BUFFER_LVALUE =
1300 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1303 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1304 pktloc__load_buffer_state(yyscanner );
1311 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1320 pktloc_ensure_buffer_stack (yyscanner);
1321 if ( YY_CURRENT_BUFFER == new_buffer )
1324 if ( YY_CURRENT_BUFFER )
1327 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1328 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1329 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1332 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1333 pktloc__load_buffer_state(yyscanner );
1340 yyg->yy_did_buffer_switch_on_eof = 1;
1343 static void pktloc__load_buffer_state (yyscan_t yyscanner)
1346 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1347 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1348 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1349 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1358 YY_BUFFER_STATE pktloc__create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1362 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1364 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1366 b->yy_buf_size = size;
1371 b->yy_ch_buf = (
char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
1372 if ( ! b->yy_ch_buf )
1373 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__create_buffer()" );
1375 b->yy_is_our_buffer = 1;
1377 pktloc__init_buffer(b,file ,yyscanner);
1386 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1393 if ( b == YY_CURRENT_BUFFER )
1394 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1396 if ( b->yy_is_our_buffer )
1397 pktloc_free((
void *) b->yy_ch_buf ,yyscanner );
1399 pktloc_free((
void *) b ,yyscanner );
1403 extern int isatty (
int );
1410 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1416 pktloc__flush_buffer(b ,yyscanner);
1418 b->yy_input_file = file;
1419 b->yy_fill_buffer = 1;
1425 if (b != YY_CURRENT_BUFFER){
1430 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1439 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1451 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1452 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1454 b->yy_buf_pos = &b->yy_ch_buf[0];
1457 b->yy_buffer_status = YY_BUFFER_NEW;
1459 if ( b == YY_CURRENT_BUFFER )
1460 pktloc__load_buffer_state(yyscanner );
1469 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1472 if (new_buffer == NULL)
1475 pktloc_ensure_buffer_stack(yyscanner);
1478 if ( YY_CURRENT_BUFFER )
1481 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1482 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1483 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1487 if (YY_CURRENT_BUFFER)
1489 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1492 pktloc__load_buffer_state(yyscanner );
1493 yyg->yy_did_buffer_switch_on_eof = 1;
1500 void pktloc_pop_buffer_state (yyscan_t yyscanner)
1503 if (!YY_CURRENT_BUFFER)
1506 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1507 YY_CURRENT_BUFFER_LVALUE = NULL;
1511 if (YY_CURRENT_BUFFER) {
1512 pktloc__load_buffer_state(yyscanner );
1513 yyg->yy_did_buffer_switch_on_eof = 1;
1520 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
1536 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1556 YY_FATAL_ERROR(
"out of dynamic memory in pktloc_ensure_buffer_stack()" );
1570 YY_BUFFER_STATE pktloc__scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1575 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1576 base[size-1] != YY_END_OF_BUFFER_CHAR )
1580 b = (YY_BUFFER_STATE) pktloc_alloc(
sizeof(
struct yy_buffer_state ) ,yyscanner );
1582 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_buffer()" );
1584 b->yy_buf_size = size - 2;
1585 b->yy_buf_pos = b->yy_ch_buf = base;
1586 b->yy_is_our_buffer = 0;
1587 b->yy_input_file = 0;
1588 b->yy_n_chars = b->yy_buf_size;
1589 b->yy_is_interactive = 0;
1591 b->yy_fill_buffer = 0;
1592 b->yy_buffer_status = YY_BUFFER_NEW;
1594 pktloc__switch_to_buffer(b ,yyscanner );
1607 YY_BUFFER_STATE pktloc__scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1610 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
1620 YY_BUFFER_STATE pktloc__scan_bytes (yyconst
char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1628 n = _yybytes_len + 2;
1629 buf = (
char *) pktloc_alloc(n ,yyscanner );
1631 YY_FATAL_ERROR(
"out of dynamic memory in pktloc__scan_bytes()" );
1633 for ( i = 0; i < _yybytes_len; ++i )
1634 buf[i] = yybytes[i];
1636 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1638 b = pktloc__scan_buffer(buf,n ,yyscanner);
1640 YY_FATAL_ERROR(
"bad buffer in pktloc__scan_bytes()" );
1645 b->yy_is_our_buffer = 1;
1650 #ifndef YY_EXIT_FAILURE
1651 #define YY_EXIT_FAILURE 2
1654 static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1656 (void) fprintf( stderr,
"%s\n", msg );
1657 exit( YY_EXIT_FAILURE );
1667 int yyless_macro_arg = (n); \
1668 YY_LESS_LINENO(yyless_macro_arg);\
1669 yytext[yyleng] = yyg->yy_hold_char; \
1670 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1671 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1672 *yyg->yy_c_buf_p = '\0'; \
1673 yyleng = yyless_macro_arg; \
1682 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
1691 int pktloc_get_lineno (yyscan_t yyscanner)
1695 if (! YY_CURRENT_BUFFER)
1704 int pktloc_get_column (yyscan_t yyscanner)
1708 if (! YY_CURRENT_BUFFER)
1717 FILE *pktloc_get_in (yyscan_t yyscanner)
1726 FILE *pktloc_get_out (yyscan_t yyscanner)
1735 int pktloc_get_leng (yyscan_t yyscanner)
1745 char *pktloc_get_text (yyscan_t yyscanner)
1755 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1758 yyextra = user_defined ;
1765 void pktloc_set_lineno (
int line_number , yyscan_t yyscanner)
1770 if (! YY_CURRENT_BUFFER )
1771 yy_fatal_error(
"pktloc_set_lineno called with no buffer" , yyscanner);
1773 yylineno = line_number;
1780 void pktloc_set_column (
int column_no , yyscan_t yyscanner)
1785 if (! YY_CURRENT_BUFFER )
1786 yy_fatal_error(
"pktloc_set_column called with no buffer" , yyscanner);
1788 yycolumn = column_no;
1797 void pktloc_set_in (FILE * in_str , yyscan_t yyscanner)
1803 void pktloc_set_out (FILE * out_str , yyscan_t yyscanner)
1809 int pktloc_get_debug (yyscan_t yyscanner)
1812 return yy_flex_debug;
1815 void pktloc_set_debug (
int bdebug , yyscan_t yyscanner)
1818 yy_flex_debug = bdebug ;
1823 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
1829 void pktloc_set_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
1832 yylval = yylval_param;
1835 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
1841 void pktloc_set_lloc (
YYLTYPE * yylloc_param , yyscan_t yyscanner)
1844 yylloc = yylloc_param;
1854 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
1857 if (ptr_yy_globals == NULL){
1862 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), NULL );
1864 if (*ptr_yy_globals == NULL){
1870 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1872 return yy_init_globals ( *ptr_yy_globals );
1883 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1888 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
1890 if (ptr_yy_globals == NULL){
1895 *ptr_yy_globals = (yyscan_t) pktloc_alloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
1897 if (*ptr_yy_globals == NULL){
1904 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
1906 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
1908 return yy_init_globals ( *ptr_yy_globals );
1911 static int yy_init_globals (yyscan_t yyscanner)
1921 yyg->yy_c_buf_p = (
char *) 0;
1925 yyg->yy_start_stack_ptr = 0;
1926 yyg->yy_start_stack_depth = 0;
1927 yyg->yy_start_stack = NULL;
1945 int pktloc_lex_destroy (yyscan_t yyscanner)
1950 while(YY_CURRENT_BUFFER){
1951 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1952 YY_CURRENT_BUFFER_LVALUE = NULL;
1953 pktloc_pop_buffer_state(yyscanner);
1961 pktloc_free(yyg->yy_start_stack ,yyscanner );
1962 yyg->yy_start_stack = NULL;
1966 yy_init_globals( yyscanner);
1969 pktloc_free ( yyscanner , yyscanner );
1979 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
1982 for ( i = 0; i < n; ++i )
1987 #ifdef YY_NEED_STRLEN
1988 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
1991 for ( n = 0; s[n]; ++n )
1998 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
2000 return (
void *) malloc( size );
2003 void *pktloc_realloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2012 return (
void *) realloc( (
char *) ptr, size );
2015 void pktloc_free (
void * ptr , yyscan_t yyscanner)
2017 free( (
char *) ptr );
2020 #define YYTABLES_NAME "yytables"
2022 #line 52 "route/pktloc_grammar.l"