00001 #line 2 "route/pktloc_grammar.c"
00002
00003 #line 4 "route/pktloc_grammar.c"
00004
00005 #define YY_INT_ALIGNED short int
00006
00007
00008
00009 #define FLEX_SCANNER
00010 #define YY_FLEX_MAJOR_VERSION 2
00011 #define YY_FLEX_MINOR_VERSION 5
00012 #define YY_FLEX_SUBMINOR_VERSION 35
00013 #if YY_FLEX_SUBMINOR_VERSION > 0
00014 #define FLEX_BETA
00015 #endif
00016
00017
00018
00019
00020 #include <stdio.h>
00021 #include <string.h>
00022 #include <errno.h>
00023 #include <stdlib.h>
00024
00025
00026
00027
00028
00029 #ifndef FLEXINT_H
00030 #define FLEXINT_H
00031
00032
00033
00034 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
00035
00036
00037
00038
00039 #ifndef __STDC_LIMIT_MACROS
00040 #define __STDC_LIMIT_MACROS 1
00041 #endif
00042
00043 #include <inttypes.h>
00044 typedef int8_t flex_int8_t;
00045 typedef uint8_t flex_uint8_t;
00046 typedef int16_t flex_int16_t;
00047 typedef uint16_t flex_uint16_t;
00048 typedef int32_t flex_int32_t;
00049 typedef uint32_t flex_uint32_t;
00050 #else
00051 typedef signed char flex_int8_t;
00052 typedef short int flex_int16_t;
00053 typedef int flex_int32_t;
00054 typedef unsigned char flex_uint8_t;
00055 typedef unsigned short int flex_uint16_t;
00056 typedef unsigned int flex_uint32_t;
00057
00058
00059 #ifndef INT8_MIN
00060 #define INT8_MIN (-128)
00061 #endif
00062 #ifndef INT16_MIN
00063 #define INT16_MIN (-32767-1)
00064 #endif
00065 #ifndef INT32_MIN
00066 #define INT32_MIN (-2147483647-1)
00067 #endif
00068 #ifndef INT8_MAX
00069 #define INT8_MAX (127)
00070 #endif
00071 #ifndef INT16_MAX
00072 #define INT16_MAX (32767)
00073 #endif
00074 #ifndef INT32_MAX
00075 #define INT32_MAX (2147483647)
00076 #endif
00077 #ifndef UINT8_MAX
00078 #define UINT8_MAX (255U)
00079 #endif
00080 #ifndef UINT16_MAX
00081 #define UINT16_MAX (65535U)
00082 #endif
00083 #ifndef UINT32_MAX
00084 #define UINT32_MAX (4294967295U)
00085 #endif
00086
00087 #endif
00088
00089 #endif
00090
00091 #ifdef __cplusplus
00092
00093
00094 #define YY_USE_CONST
00095
00096 #else
00097
00098
00099 #if defined (__STDC__)
00100
00101 #define YY_USE_CONST
00102
00103 #endif
00104 #endif
00105
00106 #ifdef YY_USE_CONST
00107 #define yyconst const
00108 #else
00109 #define yyconst
00110 #endif
00111
00112
00113 #define YY_NULL 0
00114
00115
00116
00117
00118
00119
00120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00121
00122
00123 #ifndef YY_TYPEDEF_YY_SCANNER_T
00124 #define YY_TYPEDEF_YY_SCANNER_T
00125 typedef void* yyscan_t;
00126 #endif
00127
00128
00129
00130 #define yyin yyg->yyin_r
00131 #define yyout yyg->yyout_r
00132 #define yyextra yyg->yyextra_r
00133 #define yyleng yyg->yyleng_r
00134 #define yytext yyg->yytext_r
00135 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
00136 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
00137 #define yy_flex_debug yyg->yy_flex_debug_r
00138
00139
00140
00141
00142
00143 #define BEGIN yyg->yy_start = 1 + 2 *
00144
00145
00146
00147
00148
00149 #define YY_START ((yyg->yy_start - 1) / 2)
00150 #define YYSTATE YY_START
00151
00152
00153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00154
00155
00156 #define YY_NEW_FILE pktloc_restart(yyin ,yyscanner )
00157
00158 #define YY_END_OF_BUFFER_CHAR 0
00159
00160
00161 #ifndef YY_BUF_SIZE
00162 #ifdef __ia64__
00163
00164
00165
00166
00167 #define YY_BUF_SIZE 32768
00168 #else
00169 #define YY_BUF_SIZE 16384
00170 #endif
00171 #endif
00172
00173
00174
00175 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
00176
00177 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
00178 #define YY_TYPEDEF_YY_BUFFER_STATE
00179 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00180 #endif
00181
00182 #define EOB_ACT_CONTINUE_SCAN 0
00183 #define EOB_ACT_END_OF_FILE 1
00184 #define EOB_ACT_LAST_MATCH 2
00185
00186 #define YY_LESS_LINENO(n)
00187
00188
00189 #define yyless(n) \
00190 do \
00191 { \
00192 \
00193 int yyless_macro_arg = (n); \
00194 YY_LESS_LINENO(yyless_macro_arg);\
00195 *yy_cp = yyg->yy_hold_char; \
00196 YY_RESTORE_YY_MORE_OFFSET \
00197 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
00198 YY_DO_BEFORE_ACTION; \
00199 } \
00200 while ( 0 )
00201
00202 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
00203
00204 #ifndef YY_TYPEDEF_YY_SIZE_T
00205 #define YY_TYPEDEF_YY_SIZE_T
00206 typedef size_t yy_size_t;
00207 #endif
00208
00209 #ifndef YY_STRUCT_YY_BUFFER_STATE
00210 #define YY_STRUCT_YY_BUFFER_STATE
00211 struct yy_buffer_state
00212 {
00213 FILE *yy_input_file;
00214
00215 char *yy_ch_buf;
00216 char *yy_buf_pos;
00217
00218
00219
00220
00221 yy_size_t yy_buf_size;
00222
00223
00224
00225
00226 int yy_n_chars;
00227
00228
00229
00230
00231
00232 int yy_is_our_buffer;
00233
00234
00235
00236
00237
00238
00239 int yy_is_interactive;
00240
00241
00242
00243
00244
00245 int yy_at_bol;
00246
00247 int yy_bs_lineno;
00248 int yy_bs_column;
00249
00250
00251
00252
00253 int yy_fill_buffer;
00254
00255 int yy_buffer_status;
00256
00257 #define YY_BUFFER_NEW 0
00258 #define YY_BUFFER_NORMAL 1
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269 #define YY_BUFFER_EOF_PENDING 2
00270
00271 };
00272 #endif
00273
00274
00275
00276
00277
00278
00279
00280 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
00281 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
00282 : NULL)
00283
00284
00285
00286
00287 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
00288
00289 void pktloc_restart (FILE *input_file ,yyscan_t yyscanner );
00290 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
00291 YY_BUFFER_STATE pktloc__create_buffer (FILE *file,int size ,yyscan_t yyscanner );
00292 void pktloc__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
00293 void pktloc__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
00294 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
00295 void pktloc_pop_buffer_state (yyscan_t yyscanner );
00296
00297 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner );
00298 static void pktloc__load_buffer_state (yyscan_t yyscanner );
00299 static void pktloc__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
00300
00301 #define YY_FLUSH_BUFFER pktloc__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
00302
00303 YY_BUFFER_STATE pktloc__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
00304 YY_BUFFER_STATE pktloc__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
00305 YY_BUFFER_STATE pktloc__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
00306
00307 void *pktloc_alloc (yy_size_t ,yyscan_t yyscanner );
00308 void *pktloc_realloc (void *,yy_size_t ,yyscan_t yyscanner );
00309 void pktloc_free (void * ,yyscan_t yyscanner );
00310
00311 #define yy_new_buffer pktloc__create_buffer
00312
00313 #define yy_set_interactive(is_interactive) \
00314 { \
00315 if ( ! YY_CURRENT_BUFFER ){ \
00316 pktloc_ensure_buffer_stack (yyscanner); \
00317 YY_CURRENT_BUFFER_LVALUE = \
00318 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
00319 } \
00320 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
00321 }
00322
00323 #define yy_set_bol(at_bol) \
00324 { \
00325 if ( ! YY_CURRENT_BUFFER ){\
00326 pktloc_ensure_buffer_stack (yyscanner); \
00327 YY_CURRENT_BUFFER_LVALUE = \
00328 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
00329 } \
00330 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
00331 }
00332
00333 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
00334
00335 #define pktloc_wrap(n) 1
00336 #define YY_SKIP_YYWRAP
00337
00338 typedef unsigned char YY_CHAR;
00339
00340 typedef int yy_state_type;
00341
00342 #define yytext_ptr yytext_r
00343
00344 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
00345 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
00346 static int yy_get_next_buffer (yyscan_t yyscanner );
00347 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
00348
00349
00350
00351
00352 #define YY_DO_BEFORE_ACTION \
00353 yyg->yytext_ptr = yy_bp; \
00354 yyleng = (size_t) (yy_cp - yy_bp); \
00355 yyg->yy_hold_char = *yy_cp; \
00356 *yy_cp = '\0'; \
00357 yyg->yy_c_buf_p = yy_cp;
00358
00359 #define YY_NUM_RULES 16
00360 #define YY_END_OF_BUFFER 17
00361
00362
00363 struct yy_trans_info
00364 {
00365 flex_int32_t yy_verify;
00366 flex_int32_t yy_nxt;
00367 };
00368 static yyconst flex_int16_t yy_accept[47] =
00369 { 0,
00370 0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
00371 15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
00372 15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
00373 4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
00374 15, 15, 15, 15, 13, 0
00375 } ;
00376
00377 static yyconst flex_int32_t yy_ec[256] =
00378 { 0,
00379 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
00380 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
00381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00382 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
00383 1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
00384 9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
00385 1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
00386 1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
00387 1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
00388 1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
00389
00390 16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
00391 22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
00392 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00398 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00399 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00400
00401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00406 1, 1, 1, 1, 1
00407 } ;
00408
00409 static yyconst flex_int32_t yy_meta[29] =
00410 { 0,
00411 1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
00412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00413 1, 1, 1, 1, 1, 1, 1, 1
00414 } ;
00415
00416 static yyconst flex_int16_t yy_base[50] =
00417 { 0,
00418 0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
00419 60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
00420 52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
00421 0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
00422 30, 29, 26, 18, 0, 87, 31, 68, 70
00423 } ;
00424
00425 static yyconst flex_int16_t yy_def[50] =
00426 { 0,
00427 46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
00428 47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
00429 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
00430 21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
00431 47, 47, 47, 47, 47, 0, 46, 46, 46
00432 } ;
00433
00434 static yyconst flex_int16_t yy_nxt[116] =
00435 { 0,
00436 4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
00437 9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
00438 13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
00439 19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
00440 20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
00441 43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
00442 31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
00443 19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
00444 25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
00445 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
00446
00447 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
00448 46, 46, 46, 46, 46
00449 } ;
00450
00451 static yyconst flex_int16_t yy_chk[116] =
00452 { 0,
00453 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00454 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00455 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
00456 6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
00457 8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
00458 42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
00459 21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
00460 49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
00461 13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
00462 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
00463
00464 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
00465 46, 46, 46, 46, 46
00466 } ;
00467
00468
00469
00470
00471 #define REJECT reject_used_but_not_detected
00472 #define yymore() yymore_used_but_not_detected
00473 #define YY_MORE_ADJ 0
00474 #define YY_RESTORE_YY_MORE_OFFSET
00475 #line 1 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00476 #line 2 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00477 #include <netlink-local.h>
00478 #include <netlink-tc.h>
00479 #include <netlink/netlink.h>
00480 #include <netlink/utils.h>
00481 #include <netlink/route/pktloc.h>
00482 #include "pktloc_syntax.h"
00483 #define YY_NO_INPUT 1
00484 #line 485 "route/pktloc_grammar.c"
00485
00486 #define INITIAL 0
00487
00488 #ifndef YY_NO_UNISTD_H
00489
00490
00491
00492
00493 #include <unistd.h>
00494 #endif
00495
00496 #ifndef YY_EXTRA_TYPE
00497 #define YY_EXTRA_TYPE void *
00498 #endif
00499
00500
00501 struct yyguts_t
00502 {
00503
00504
00505 YY_EXTRA_TYPE yyextra_r;
00506
00507
00508 FILE *yyin_r, *yyout_r;
00509 size_t yy_buffer_stack_top;
00510 size_t yy_buffer_stack_max;
00511 YY_BUFFER_STATE * yy_buffer_stack;
00512 char yy_hold_char;
00513 int yy_n_chars;
00514 int yyleng_r;
00515 char *yy_c_buf_p;
00516 int yy_init;
00517 int yy_start;
00518 int yy_did_buffer_switch_on_eof;
00519 int yy_start_stack_ptr;
00520 int yy_start_stack_depth;
00521 int *yy_start_stack;
00522 yy_state_type yy_last_accepting_state;
00523 char* yy_last_accepting_cpos;
00524
00525 int yylineno_r;
00526 int yy_flex_debug_r;
00527
00528 char *yytext_r;
00529 int yy_more_flag;
00530 int yy_more_len;
00531
00532 YYSTYPE * yylval_r;
00533
00534 YYLTYPE * yylloc_r;
00535
00536 };
00537
00538 static int yy_init_globals (yyscan_t yyscanner );
00539
00540
00541
00542 # define yylval yyg->yylval_r
00543
00544 # define yylloc yyg->yylloc_r
00545
00546 int pktloc_lex_init (yyscan_t* scanner);
00547
00548 int pktloc_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
00549
00550
00551
00552
00553 int pktloc_lex_destroy (yyscan_t yyscanner );
00554
00555 int pktloc_get_debug (yyscan_t yyscanner );
00556
00557 void pktloc_set_debug (int debug_flag ,yyscan_t yyscanner );
00558
00559 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner );
00560
00561 void pktloc_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
00562
00563 FILE *pktloc_get_in (yyscan_t yyscanner );
00564
00565 void pktloc_set_in (FILE * in_str ,yyscan_t yyscanner );
00566
00567 FILE *pktloc_get_out (yyscan_t yyscanner );
00568
00569 void pktloc_set_out (FILE * out_str ,yyscan_t yyscanner );
00570
00571 int pktloc_get_leng (yyscan_t yyscanner );
00572
00573 char *pktloc_get_text (yyscan_t yyscanner );
00574
00575 int pktloc_get_lineno (yyscan_t yyscanner );
00576
00577 void pktloc_set_lineno (int line_number ,yyscan_t yyscanner );
00578
00579 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner );
00580
00581 void pktloc_set_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
00582
00583 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner );
00584
00585 void pktloc_set_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
00586
00587
00588
00589
00590
00591 #ifndef YY_SKIP_YYWRAP
00592 #ifdef __cplusplus
00593 extern "C" int pktloc_wrap (yyscan_t yyscanner );
00594 #else
00595 extern int pktloc_wrap (yyscan_t yyscanner );
00596 #endif
00597 #endif
00598
00599 #ifndef yytext_ptr
00600 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
00601 #endif
00602
00603 #ifdef YY_NEED_STRLEN
00604 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
00605 #endif
00606
00607 #ifndef YY_NO_INPUT
00608
00609 #ifdef __cplusplus
00610 static int yyinput (yyscan_t yyscanner );
00611 #else
00612 static int input (yyscan_t yyscanner );
00613 #endif
00614
00615 #endif
00616
00617
00618 #ifndef YY_READ_BUF_SIZE
00619 #ifdef __ia64__
00620
00621 #define YY_READ_BUF_SIZE 16384
00622 #else
00623 #define YY_READ_BUF_SIZE 8192
00624 #endif
00625 #endif
00626
00627
00628 #ifndef ECHO
00629
00630
00631
00632 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
00633 #endif
00634
00635
00636
00637
00638 #ifndef YY_INPUT
00639 #define YY_INPUT(buf,result,max_size) \
00640 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
00641 { \
00642 int c = '*'; \
00643 size_t n; \
00644 for ( n = 0; n < max_size && \
00645 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00646 buf[n] = (char) c; \
00647 if ( c == '\n' ) \
00648 buf[n++] = (char) c; \
00649 if ( c == EOF && ferror( yyin ) ) \
00650 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00651 result = n; \
00652 } \
00653 else \
00654 { \
00655 errno=0; \
00656 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00657 { \
00658 if( errno != EINTR) \
00659 { \
00660 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00661 break; \
00662 } \
00663 errno=0; \
00664 clearerr(yyin); \
00665 } \
00666 }\
00667 \
00668
00669 #endif
00670
00671
00672
00673
00674
00675 #ifndef yyterminate
00676 #define yyterminate() return YY_NULL
00677 #endif
00678
00679
00680 #ifndef YY_START_STACK_INCR
00681 #define YY_START_STACK_INCR 25
00682 #endif
00683
00684
00685 #ifndef YY_FATAL_ERROR
00686 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
00687 #endif
00688
00689
00690
00691
00692
00693
00694 #ifndef YY_DECL
00695 #define YY_DECL_IS_OURS 1
00696
00697 extern int pktloc_lex \
00698 (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
00699
00700 #define YY_DECL int pktloc_lex \
00701 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
00702 #endif
00703
00704
00705
00706
00707 #ifndef YY_USER_ACTION
00708 #define YY_USER_ACTION
00709 #endif
00710
00711
00712 #ifndef YY_BREAK
00713 #define YY_BREAK break;
00714 #endif
00715
00716 #define YY_RULE_SETUP \
00717 YY_USER_ACTION
00718
00719
00720
00721 YY_DECL
00722 {
00723 register yy_state_type yy_current_state;
00724 register char *yy_cp, *yy_bp;
00725 register int yy_act;
00726 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
00727
00728 #line 20 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00729
00730
00731 #line 732 "route/pktloc_grammar.c"
00732
00733 yylval = yylval_param;
00734
00735 yylloc = yylloc_param;
00736
00737 if ( !yyg->yy_init )
00738 {
00739 yyg->yy_init = 1;
00740
00741 #ifdef YY_USER_INIT
00742 YY_USER_INIT;
00743 #endif
00744
00745 if ( ! yyg->yy_start )
00746 yyg->yy_start = 1;
00747
00748 if ( ! yyin )
00749 yyin = stdin;
00750
00751 if ( ! yyout )
00752 yyout = stdout;
00753
00754 if ( ! YY_CURRENT_BUFFER ) {
00755 pktloc_ensure_buffer_stack (yyscanner);
00756 YY_CURRENT_BUFFER_LVALUE =
00757 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
00758 }
00759
00760 pktloc__load_buffer_state(yyscanner );
00761 }
00762
00763 while ( 1 )
00764 {
00765 yy_cp = yyg->yy_c_buf_p;
00766
00767
00768 *yy_cp = yyg->yy_hold_char;
00769
00770
00771
00772
00773 yy_bp = yy_cp;
00774
00775 yy_current_state = yyg->yy_start;
00776 yy_match:
00777 do
00778 {
00779 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00780 if ( yy_accept[yy_current_state] )
00781 {
00782 yyg->yy_last_accepting_state = yy_current_state;
00783 yyg->yy_last_accepting_cpos = yy_cp;
00784 }
00785 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00786 {
00787 yy_current_state = (int) yy_def[yy_current_state];
00788 if ( yy_current_state >= 47 )
00789 yy_c = yy_meta[(unsigned int) yy_c];
00790 }
00791 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00792 ++yy_cp;
00793 }
00794 while ( yy_base[yy_current_state] != 87 );
00795
00796 yy_find_action:
00797 yy_act = yy_accept[yy_current_state];
00798 if ( yy_act == 0 )
00799 {
00800 yy_cp = yyg->yy_last_accepting_cpos;
00801 yy_current_state = yyg->yy_last_accepting_state;
00802 yy_act = yy_accept[yy_current_state];
00803 }
00804
00805 YY_DO_BEFORE_ACTION;
00806
00807 do_action:
00808
00809 switch ( yy_act )
00810 {
00811 case 0:
00812
00813 *yy_cp = yyg->yy_hold_char;
00814 yy_cp = yyg->yy_last_accepting_cpos;
00815 yy_current_state = yyg->yy_last_accepting_state;
00816 goto yy_find_action;
00817
00818 case 1:
00819
00820 YY_RULE_SETUP
00821 #line 22 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00822
00823 YY_BREAK
00824 case 2:
00825 YY_RULE_SETUP
00826 #line 24 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00827
00828 YY_BREAK
00829 case 3:
00830 #line 27 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00831 case 4:
00832 YY_RULE_SETUP
00833 #line 27 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00834 {
00835 yylval->i = strtoul(yytext, NULL, 0);
00836 return NUMBER;
00837 }
00838 YY_BREAK
00839 case 5:
00840 YY_RULE_SETUP
00841 #line 32 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00842 { return yylval->i = yytext[0]; }
00843 YY_BREAK
00844 case 6:
00845 YY_RULE_SETUP
00846 #line 34 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00847 { yylval->i = TCF_EM_ALIGN_U8; return ALIGN; }
00848 YY_BREAK
00849 case 7:
00850 YY_RULE_SETUP
00851 #line 35 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00852 { yylval->i = TCF_EM_ALIGN_U16; return ALIGN; }
00853 YY_BREAK
00854 case 8:
00855 YY_RULE_SETUP
00856 #line 36 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00857 { yylval->i = TCF_EM_ALIGN_U32; return ALIGN; }
00858 YY_BREAK
00859 case 9:
00860 #line 39 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00861 case 10:
00862 YY_RULE_SETUP
00863 #line 39 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00864 { yylval->i = TCF_LAYER_LINK; return LAYER; }
00865 YY_BREAK
00866 case 11:
00867 #line 41 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00868 case 12:
00869 YY_RULE_SETUP
00870 #line 41 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00871 { yylval->i = TCF_LAYER_NETWORK; return LAYER; }
00872 YY_BREAK
00873 case 13:
00874 #line 43 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00875 case 14:
00876 YY_RULE_SETUP
00877 #line 43 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00878 { yylval->i = TCF_LAYER_TRANSPORT; return LAYER; }
00879 YY_BREAK
00880 case 15:
00881 YY_RULE_SETUP
00882 #line 46 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00883 {
00884 yylval->s = strdup(yytext);
00885 if (yylval->s == NULL)
00886 return ERROR;
00887 return NAME;
00888 }
00889 YY_BREAK
00890 case 16:
00891 YY_RULE_SETUP
00892 #line 52 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"
00893 ECHO;
00894 YY_BREAK
00895 #line 896 "route/pktloc_grammar.c"
00896 case YY_STATE_EOF(INITIAL):
00897 yyterminate();
00898
00899 case YY_END_OF_BUFFER:
00900 {
00901
00902 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
00903
00904
00905 *yy_cp = yyg->yy_hold_char;
00906 YY_RESTORE_YY_MORE_OFFSET
00907
00908 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
00909 {
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
00920 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
00921 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
00922 }
00923
00924
00925
00926
00927
00928
00929
00930
00931 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
00932 {
00933 yy_state_type yy_next_state;
00934
00935 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
00936
00937 yy_current_state = yy_get_previous_state( yyscanner );
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
00949
00950 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
00951
00952 if ( yy_next_state )
00953 {
00954
00955 yy_cp = ++yyg->yy_c_buf_p;
00956 yy_current_state = yy_next_state;
00957 goto yy_match;
00958 }
00959
00960 else
00961 {
00962 yy_cp = yyg->yy_c_buf_p;
00963 goto yy_find_action;
00964 }
00965 }
00966
00967 else switch ( yy_get_next_buffer( yyscanner ) )
00968 {
00969 case EOB_ACT_END_OF_FILE:
00970 {
00971 yyg->yy_did_buffer_switch_on_eof = 0;
00972
00973 if ( pktloc_wrap(yyscanner ) )
00974 {
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
00985
00986 yy_act = YY_STATE_EOF(YY_START);
00987 goto do_action;
00988 }
00989
00990 else
00991 {
00992 if ( ! yyg->yy_did_buffer_switch_on_eof )
00993 YY_NEW_FILE;
00994 }
00995 break;
00996 }
00997
00998 case EOB_ACT_CONTINUE_SCAN:
00999 yyg->yy_c_buf_p =
01000 yyg->yytext_ptr + yy_amount_of_matched_text;
01001
01002 yy_current_state = yy_get_previous_state( yyscanner );
01003
01004 yy_cp = yyg->yy_c_buf_p;
01005 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01006 goto yy_match;
01007
01008 case EOB_ACT_LAST_MATCH:
01009 yyg->yy_c_buf_p =
01010 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
01011
01012 yy_current_state = yy_get_previous_state( yyscanner );
01013
01014 yy_cp = yyg->yy_c_buf_p;
01015 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01016 goto yy_find_action;
01017 }
01018 break;
01019 }
01020
01021 default:
01022 YY_FATAL_ERROR(
01023 "fatal flex scanner internal error--no action found" );
01024 }
01025 }
01026 }
01027
01028
01029
01030
01031
01032
01033
01034
01035 static int yy_get_next_buffer (yyscan_t yyscanner)
01036 {
01037 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01038 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
01039 register char *source = yyg->yytext_ptr;
01040 register int number_to_move, i;
01041 int ret_val;
01042
01043 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
01044 YY_FATAL_ERROR(
01045 "fatal flex scanner internal error--end of buffer missed" );
01046
01047 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
01048 {
01049 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
01050 {
01051
01052
01053
01054 return EOB_ACT_END_OF_FILE;
01055 }
01056
01057 else
01058 {
01059
01060
01061
01062 return EOB_ACT_LAST_MATCH;
01063 }
01064 }
01065
01066
01067
01068
01069 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
01070
01071 for ( i = 0; i < number_to_move; ++i )
01072 *(dest++) = *(source++);
01073
01074 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01075
01076
01077
01078 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
01079
01080 else
01081 {
01082 int num_to_read =
01083 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
01084
01085 while ( num_to_read <= 0 )
01086 {
01087
01088
01089 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
01090
01091 int yy_c_buf_p_offset =
01092 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
01093
01094 if ( b->yy_is_our_buffer )
01095 {
01096 int new_size = b->yy_buf_size * 2;
01097
01098 if ( new_size <= 0 )
01099 b->yy_buf_size += b->yy_buf_size / 8;
01100 else
01101 b->yy_buf_size *= 2;
01102
01103 b->yy_ch_buf = (char *)
01104
01105 pktloc_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
01106 }
01107 else
01108
01109 b->yy_ch_buf = 0;
01110
01111 if ( ! b->yy_ch_buf )
01112 YY_FATAL_ERROR(
01113 "fatal error - scanner input buffer overflow" );
01114
01115 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01116
01117 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
01118 number_to_move - 1;
01119
01120 }
01121
01122 if ( num_to_read > YY_READ_BUF_SIZE )
01123 num_to_read = YY_READ_BUF_SIZE;
01124
01125
01126 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
01127 yyg->yy_n_chars, (size_t) num_to_read );
01128
01129 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01130 }
01131
01132 if ( yyg->yy_n_chars == 0 )
01133 {
01134 if ( number_to_move == YY_MORE_ADJ )
01135 {
01136 ret_val = EOB_ACT_END_OF_FILE;
01137 pktloc_restart(yyin ,yyscanner);
01138 }
01139
01140 else
01141 {
01142 ret_val = EOB_ACT_LAST_MATCH;
01143 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
01144 YY_BUFFER_EOF_PENDING;
01145 }
01146 }
01147
01148 else
01149 ret_val = EOB_ACT_CONTINUE_SCAN;
01150
01151 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
01152
01153 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
01154 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pktloc_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
01155 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01156 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
01157 }
01158
01159 yyg->yy_n_chars += number_to_move;
01160 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01161 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01162
01163 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
01164
01165 return ret_val;
01166 }
01167
01168
01169
01170 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
01171 {
01172 register yy_state_type yy_current_state;
01173 register char *yy_cp;
01174 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01175
01176 yy_current_state = yyg->yy_start;
01177
01178 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
01179 {
01180 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01181 if ( yy_accept[yy_current_state] )
01182 {
01183 yyg->yy_last_accepting_state = yy_current_state;
01184 yyg->yy_last_accepting_cpos = yy_cp;
01185 }
01186 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01187 {
01188 yy_current_state = (int) yy_def[yy_current_state];
01189 if ( yy_current_state >= 47 )
01190 yy_c = yy_meta[(unsigned int) yy_c];
01191 }
01192 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01193 }
01194
01195 return yy_current_state;
01196 }
01197
01198
01199
01200
01201
01202
01203 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
01204 {
01205 register int yy_is_jam;
01206 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01207 register char *yy_cp = yyg->yy_c_buf_p;
01208
01209 register YY_CHAR yy_c = 1;
01210 if ( yy_accept[yy_current_state] )
01211 {
01212 yyg->yy_last_accepting_state = yy_current_state;
01213 yyg->yy_last_accepting_cpos = yy_cp;
01214 }
01215 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01216 {
01217 yy_current_state = (int) yy_def[yy_current_state];
01218 if ( yy_current_state >= 47 )
01219 yy_c = yy_meta[(unsigned int) yy_c];
01220 }
01221 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01222 yy_is_jam = (yy_current_state == 46);
01223
01224 return yy_is_jam ? 0 : yy_current_state;
01225 }
01226
01227 #ifndef YY_NO_INPUT
01228 #ifdef __cplusplus
01229 static int yyinput (yyscan_t yyscanner)
01230 #else
01231 static int input (yyscan_t yyscanner)
01232 #endif
01233
01234 {
01235 int c;
01236 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01237
01238 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01239
01240 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01241 {
01242
01243
01244
01245
01246 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01247
01248 *yyg->yy_c_buf_p = '\0';
01249
01250 else
01251 {
01252 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
01253 ++yyg->yy_c_buf_p;
01254
01255 switch ( yy_get_next_buffer( yyscanner ) )
01256 {
01257 case EOB_ACT_LAST_MATCH:
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269 pktloc_restart(yyin ,yyscanner);
01270
01271
01272
01273 case EOB_ACT_END_OF_FILE:
01274 {
01275 if ( pktloc_wrap(yyscanner ) )
01276 return EOF;
01277
01278 if ( ! yyg->yy_did_buffer_switch_on_eof )
01279 YY_NEW_FILE;
01280 #ifdef __cplusplus
01281 return yyinput(yyscanner);
01282 #else
01283 return input(yyscanner);
01284 #endif
01285 }
01286
01287 case EOB_ACT_CONTINUE_SCAN:
01288 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
01289 break;
01290 }
01291 }
01292 }
01293
01294 c = *(unsigned char *) yyg->yy_c_buf_p;
01295 *yyg->yy_c_buf_p = '\0';
01296 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
01297
01298 return c;
01299 }
01300 #endif
01301
01302
01303
01304
01305
01306
01307 void pktloc_restart (FILE * input_file , yyscan_t yyscanner)
01308 {
01309 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01310
01311 if ( ! YY_CURRENT_BUFFER ){
01312 pktloc_ensure_buffer_stack (yyscanner);
01313 YY_CURRENT_BUFFER_LVALUE =
01314 pktloc__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
01315 }
01316
01317 pktloc__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
01318 pktloc__load_buffer_state(yyscanner );
01319 }
01320
01321
01322
01323
01324
01325 void pktloc__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01326 {
01327 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01328
01329
01330
01331
01332
01333
01334 pktloc_ensure_buffer_stack (yyscanner);
01335 if ( YY_CURRENT_BUFFER == new_buffer )
01336 return;
01337
01338 if ( YY_CURRENT_BUFFER )
01339 {
01340
01341 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01342 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01343 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01344 }
01345
01346 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01347 pktloc__load_buffer_state(yyscanner );
01348
01349
01350
01351
01352
01353
01354 yyg->yy_did_buffer_switch_on_eof = 1;
01355 }
01356
01357 static void pktloc__load_buffer_state (yyscan_t yyscanner)
01358 {
01359 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01360 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01361 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
01362 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
01363 yyg->yy_hold_char = *yyg->yy_c_buf_p;
01364 }
01365
01366
01367
01368
01369
01370
01371
01372 YY_BUFFER_STATE pktloc__create_buffer (FILE * file, int size , yyscan_t yyscanner)
01373 {
01374 YY_BUFFER_STATE b;
01375
01376 b = (YY_BUFFER_STATE) pktloc_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
01377 if ( ! b )
01378 YY_FATAL_ERROR( "out of dynamic memory in pktloc__create_buffer()" );
01379
01380 b->yy_buf_size = size;
01381
01382
01383
01384
01385 b->yy_ch_buf = (char *) pktloc_alloc(b->yy_buf_size + 2 ,yyscanner );
01386 if ( ! b->yy_ch_buf )
01387 YY_FATAL_ERROR( "out of dynamic memory in pktloc__create_buffer()" );
01388
01389 b->yy_is_our_buffer = 1;
01390
01391 pktloc__init_buffer(b,file ,yyscanner);
01392
01393 return b;
01394 }
01395
01396
01397
01398
01399
01400 void pktloc__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
01401 {
01402 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01403
01404 if ( ! b )
01405 return;
01406
01407 if ( b == YY_CURRENT_BUFFER )
01408 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
01409
01410 if ( b->yy_is_our_buffer )
01411 pktloc_free((void *) b->yy_ch_buf ,yyscanner );
01412
01413 pktloc_free((void *) b ,yyscanner );
01414 }
01415
01416 #ifndef __cplusplus
01417 extern int isatty (int );
01418 #endif
01419
01420
01421
01422
01423
01424 static void pktloc__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
01425
01426 {
01427 int oerrno = errno;
01428 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01429
01430 pktloc__flush_buffer(b ,yyscanner);
01431
01432 b->yy_input_file = file;
01433 b->yy_fill_buffer = 1;
01434
01435
01436
01437
01438
01439 if (b != YY_CURRENT_BUFFER){
01440 b->yy_bs_lineno = 1;
01441 b->yy_bs_column = 0;
01442 }
01443
01444 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01445
01446 errno = oerrno;
01447 }
01448
01449
01450
01451
01452
01453 void pktloc__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
01454 {
01455 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01456 if ( ! b )
01457 return;
01458
01459 b->yy_n_chars = 0;
01460
01461
01462
01463
01464
01465 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01466 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01467
01468 b->yy_buf_pos = &b->yy_ch_buf[0];
01469
01470 b->yy_at_bol = 1;
01471 b->yy_buffer_status = YY_BUFFER_NEW;
01472
01473 if ( b == YY_CURRENT_BUFFER )
01474 pktloc__load_buffer_state(yyscanner );
01475 }
01476
01477
01478
01479
01480
01481
01482
01483 void pktloc_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01484 {
01485 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01486 if (new_buffer == NULL)
01487 return;
01488
01489 pktloc_ensure_buffer_stack(yyscanner);
01490
01491
01492 if ( YY_CURRENT_BUFFER )
01493 {
01494
01495 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01496 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01497 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01498 }
01499
01500
01501 if (YY_CURRENT_BUFFER)
01502 yyg->yy_buffer_stack_top++;
01503 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01504
01505
01506 pktloc__load_buffer_state(yyscanner );
01507 yyg->yy_did_buffer_switch_on_eof = 1;
01508 }
01509
01510
01511
01512
01513
01514 void pktloc_pop_buffer_state (yyscan_t yyscanner)
01515 {
01516 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01517 if (!YY_CURRENT_BUFFER)
01518 return;
01519
01520 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
01521 YY_CURRENT_BUFFER_LVALUE = NULL;
01522 if (yyg->yy_buffer_stack_top > 0)
01523 --yyg->yy_buffer_stack_top;
01524
01525 if (YY_CURRENT_BUFFER) {
01526 pktloc__load_buffer_state(yyscanner );
01527 yyg->yy_did_buffer_switch_on_eof = 1;
01528 }
01529 }
01530
01531
01532
01533
01534 static void pktloc_ensure_buffer_stack (yyscan_t yyscanner)
01535 {
01536 int num_to_alloc;
01537 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01538
01539 if (!yyg->yy_buffer_stack) {
01540
01541
01542
01543
01544
01545 num_to_alloc = 1;
01546 yyg->yy_buffer_stack = (struct yy_buffer_state**)pktloc_alloc
01547 (num_to_alloc * sizeof(struct yy_buffer_state*)
01548 , yyscanner);
01549 if ( ! yyg->yy_buffer_stack )
01550 YY_FATAL_ERROR( "out of dynamic memory in pktloc_ensure_buffer_stack()" );
01551
01552 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
01553
01554 yyg->yy_buffer_stack_max = num_to_alloc;
01555 yyg->yy_buffer_stack_top = 0;
01556 return;
01557 }
01558
01559 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
01560
01561
01562 int grow_size = 8 ;
01563
01564 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
01565 yyg->yy_buffer_stack = (struct yy_buffer_state**)pktloc_realloc
01566 (yyg->yy_buffer_stack,
01567 num_to_alloc * sizeof(struct yy_buffer_state*)
01568 , yyscanner);
01569 if ( ! yyg->yy_buffer_stack )
01570 YY_FATAL_ERROR( "out of dynamic memory in pktloc_ensure_buffer_stack()" );
01571
01572
01573 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
01574 yyg->yy_buffer_stack_max = num_to_alloc;
01575 }
01576 }
01577
01578
01579
01580
01581
01582
01583
01584 YY_BUFFER_STATE pktloc__scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
01585 {
01586 YY_BUFFER_STATE b;
01587
01588 if ( size < 2 ||
01589 base[size-2] != YY_END_OF_BUFFER_CHAR ||
01590 base[size-1] != YY_END_OF_BUFFER_CHAR )
01591
01592 return 0;
01593
01594 b = (YY_BUFFER_STATE) pktloc_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
01595 if ( ! b )
01596 YY_FATAL_ERROR( "out of dynamic memory in pktloc__scan_buffer()" );
01597
01598 b->yy_buf_size = size - 2;
01599 b->yy_buf_pos = b->yy_ch_buf = base;
01600 b->yy_is_our_buffer = 0;
01601 b->yy_input_file = 0;
01602 b->yy_n_chars = b->yy_buf_size;
01603 b->yy_is_interactive = 0;
01604 b->yy_at_bol = 1;
01605 b->yy_fill_buffer = 0;
01606 b->yy_buffer_status = YY_BUFFER_NEW;
01607
01608 pktloc__switch_to_buffer(b ,yyscanner );
01609
01610 return b;
01611 }
01612
01613
01614
01615
01616
01617
01618
01619
01620
01621 YY_BUFFER_STATE pktloc__scan_string (yyconst char * yystr , yyscan_t yyscanner)
01622 {
01623
01624 return pktloc__scan_bytes(yystr,strlen(yystr) ,yyscanner);
01625 }
01626
01627
01628
01629
01630
01631
01632
01633
01634 YY_BUFFER_STATE pktloc__scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
01635 {
01636 YY_BUFFER_STATE b;
01637 char *buf;
01638 yy_size_t n;
01639 int i;
01640
01641
01642 n = _yybytes_len + 2;
01643 buf = (char *) pktloc_alloc(n ,yyscanner );
01644 if ( ! buf )
01645 YY_FATAL_ERROR( "out of dynamic memory in pktloc__scan_bytes()" );
01646
01647 for ( i = 0; i < _yybytes_len; ++i )
01648 buf[i] = yybytes[i];
01649
01650 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
01651
01652 b = pktloc__scan_buffer(buf,n ,yyscanner);
01653 if ( ! b )
01654 YY_FATAL_ERROR( "bad buffer in pktloc__scan_bytes()" );
01655
01656
01657
01658
01659 b->yy_is_our_buffer = 1;
01660
01661 return b;
01662 }
01663
01664 #ifndef YY_EXIT_FAILURE
01665 #define YY_EXIT_FAILURE 2
01666 #endif
01667
01668 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
01669 {
01670 (void) fprintf( stderr, "%s\n", msg );
01671 exit( YY_EXIT_FAILURE );
01672 }
01673
01674
01675
01676 #undef yyless
01677 #define yyless(n) \
01678 do \
01679 { \
01680 \
01681 int yyless_macro_arg = (n); \
01682 YY_LESS_LINENO(yyless_macro_arg);\
01683 yytext[yyleng] = yyg->yy_hold_char; \
01684 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
01685 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
01686 *yyg->yy_c_buf_p = '\0'; \
01687 yyleng = yyless_macro_arg; \
01688 } \
01689 while ( 0 )
01690
01691
01692
01693
01694
01695
01696 YY_EXTRA_TYPE pktloc_get_extra (yyscan_t yyscanner)
01697 {
01698 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01699 return yyextra;
01700 }
01701
01702
01703
01704
01705 int pktloc_get_lineno (yyscan_t yyscanner)
01706 {
01707 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01708
01709 if (! YY_CURRENT_BUFFER)
01710 return 0;
01711
01712 return yylineno;
01713 }
01714
01715
01716
01717
01718 int pktloc_get_column (yyscan_t yyscanner)
01719 {
01720 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01721
01722 if (! YY_CURRENT_BUFFER)
01723 return 0;
01724
01725 return yycolumn;
01726 }
01727
01728
01729
01730
01731 FILE *pktloc_get_in (yyscan_t yyscanner)
01732 {
01733 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01734 return yyin;
01735 }
01736
01737
01738
01739
01740 FILE *pktloc_get_out (yyscan_t yyscanner)
01741 {
01742 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01743 return yyout;
01744 }
01745
01746
01747
01748
01749 int pktloc_get_leng (yyscan_t yyscanner)
01750 {
01751 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01752 return yyleng;
01753 }
01754
01755
01756
01757
01758
01759 char *pktloc_get_text (yyscan_t yyscanner)
01760 {
01761 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01762 return yytext;
01763 }
01764
01765
01766
01767
01768
01769 void pktloc_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
01770 {
01771 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01772 yyextra = user_defined ;
01773 }
01774
01775
01776
01777
01778
01779 void pktloc_set_lineno (int line_number , yyscan_t yyscanner)
01780 {
01781 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01782
01783
01784 if (! YY_CURRENT_BUFFER )
01785 yy_fatal_error( "pktloc_set_lineno called with no buffer" , yyscanner);
01786
01787 yylineno = line_number;
01788 }
01789
01790
01791
01792
01793
01794 void pktloc_set_column (int column_no , yyscan_t yyscanner)
01795 {
01796 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01797
01798
01799 if (! YY_CURRENT_BUFFER )
01800 yy_fatal_error( "pktloc_set_column called with no buffer" , yyscanner);
01801
01802 yycolumn = column_no;
01803 }
01804
01805
01806
01807
01808
01809
01810
01811 void pktloc_set_in (FILE * in_str , yyscan_t yyscanner)
01812 {
01813 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01814 yyin = in_str ;
01815 }
01816
01817 void pktloc_set_out (FILE * out_str , yyscan_t yyscanner)
01818 {
01819 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01820 yyout = out_str ;
01821 }
01822
01823 int pktloc_get_debug (yyscan_t yyscanner)
01824 {
01825 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01826 return yy_flex_debug;
01827 }
01828
01829 void pktloc_set_debug (int bdebug , yyscan_t yyscanner)
01830 {
01831 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01832 yy_flex_debug = bdebug ;
01833 }
01834
01835
01836
01837 YYSTYPE * pktloc_get_lval (yyscan_t yyscanner)
01838 {
01839 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01840 return yylval;
01841 }
01842
01843 void pktloc_set_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
01844 {
01845 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01846 yylval = yylval_param;
01847 }
01848
01849 YYLTYPE *pktloc_get_lloc (yyscan_t yyscanner)
01850 {
01851 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01852 return yylloc;
01853 }
01854
01855 void pktloc_set_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner)
01856 {
01857 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01858 yylloc = yylloc_param;
01859 }
01860
01861
01862
01863
01864
01865
01866
01867
01868 int pktloc_lex_init(yyscan_t* ptr_yy_globals)
01869
01870 {
01871 if (ptr_yy_globals == NULL){
01872 errno = EINVAL;
01873 return 1;
01874 }
01875
01876 *ptr_yy_globals = (yyscan_t) pktloc_alloc ( sizeof( struct yyguts_t ), NULL );
01877
01878 if (*ptr_yy_globals == NULL){
01879 errno = ENOMEM;
01880 return 1;
01881 }
01882
01883
01884 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
01885
01886 return yy_init_globals ( *ptr_yy_globals );
01887 }
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897 int pktloc_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
01898
01899 {
01900 struct yyguts_t dummy_yyguts;
01901
01902 pktloc_set_extra (yy_user_defined, &dummy_yyguts);
01903
01904 if (ptr_yy_globals == NULL){
01905 errno = EINVAL;
01906 return 1;
01907 }
01908
01909 *ptr_yy_globals = (yyscan_t) pktloc_alloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
01910
01911 if (*ptr_yy_globals == NULL){
01912 errno = ENOMEM;
01913 return 1;
01914 }
01915
01916
01917
01918 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
01919
01920 pktloc_set_extra (yy_user_defined, *ptr_yy_globals);
01921
01922 return yy_init_globals ( *ptr_yy_globals );
01923 }
01924
01925 static int yy_init_globals (yyscan_t yyscanner)
01926 {
01927 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01928
01929
01930
01931
01932 yyg->yy_buffer_stack = 0;
01933 yyg->yy_buffer_stack_top = 0;
01934 yyg->yy_buffer_stack_max = 0;
01935 yyg->yy_c_buf_p = (char *) 0;
01936 yyg->yy_init = 0;
01937 yyg->yy_start = 0;
01938
01939 yyg->yy_start_stack_ptr = 0;
01940 yyg->yy_start_stack_depth = 0;
01941 yyg->yy_start_stack = NULL;
01942
01943
01944 #ifdef YY_STDINIT
01945 yyin = stdin;
01946 yyout = stdout;
01947 #else
01948 yyin = (FILE *) 0;
01949 yyout = (FILE *) 0;
01950 #endif
01951
01952
01953
01954
01955 return 0;
01956 }
01957
01958
01959 int pktloc_lex_destroy (yyscan_t yyscanner)
01960 {
01961 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01962
01963
01964 while(YY_CURRENT_BUFFER){
01965 pktloc__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
01966 YY_CURRENT_BUFFER_LVALUE = NULL;
01967 pktloc_pop_buffer_state(yyscanner);
01968 }
01969
01970
01971 pktloc_free(yyg->yy_buffer_stack ,yyscanner);
01972 yyg->yy_buffer_stack = NULL;
01973
01974
01975 pktloc_free(yyg->yy_start_stack ,yyscanner );
01976 yyg->yy_start_stack = NULL;
01977
01978
01979
01980 yy_init_globals( yyscanner);
01981
01982
01983 pktloc_free ( yyscanner , yyscanner );
01984 yyscanner = NULL;
01985 return 0;
01986 }
01987
01988
01989
01990
01991
01992 #ifndef yytext_ptr
01993 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
01994 {
01995 register int i;
01996 for ( i = 0; i < n; ++i )
01997 s1[i] = s2[i];
01998 }
01999 #endif
02000
02001 #ifdef YY_NEED_STRLEN
02002 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
02003 {
02004 register int n;
02005 for ( n = 0; s[n]; ++n )
02006 ;
02007
02008 return n;
02009 }
02010 #endif
02011
02012 void *pktloc_alloc (yy_size_t size , yyscan_t yyscanner)
02013 {
02014 return (void *) malloc( size );
02015 }
02016
02017 void *pktloc_realloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
02018 {
02019
02020
02021
02022
02023
02024
02025
02026 return (void *) realloc( (char *) ptr, size );
02027 }
02028
02029 void pktloc_free (void * ptr , yyscan_t yyscanner)
02030 {
02031 free( (char *) ptr );
02032 }
02033
02034 #define YYTABLES_NAME "yytables"
02035
02036 #line 52 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_grammar.l"