libnl  3.5.0
pktloc_grammar.c
1 #line 1 "lib/route/pktloc_grammar.c"
2 
3 #line 3 "lib/route/pktloc_grammar.c"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define FLEX_SCANNER
10 #define YY_FLEX_MAJOR_VERSION 2
11 #define YY_FLEX_MINOR_VERSION 6
12 #define YY_FLEX_SUBMINOR_VERSION 4
13 #if YY_FLEX_SUBMINOR_VERSION > 0
14 #define FLEX_BETA
15 #endif
16 
17 #ifdef yy_create_buffer
18 #define pktloc__create_buffer_ALREADY_DEFINED
19 #else
20 #define yy_create_buffer pktloc__create_buffer
21 #endif
22 
23 #ifdef yy_delete_buffer
24 #define pktloc__delete_buffer_ALREADY_DEFINED
25 #else
26 #define yy_delete_buffer pktloc__delete_buffer
27 #endif
28 
29 #ifdef yy_scan_buffer
30 #define pktloc__scan_buffer_ALREADY_DEFINED
31 #else
32 #define yy_scan_buffer pktloc__scan_buffer
33 #endif
34 
35 #ifdef yy_scan_string
36 #define pktloc__scan_string_ALREADY_DEFINED
37 #else
38 #define yy_scan_string pktloc__scan_string
39 #endif
40 
41 #ifdef yy_scan_bytes
42 #define pktloc__scan_bytes_ALREADY_DEFINED
43 #else
44 #define yy_scan_bytes pktloc__scan_bytes
45 #endif
46 
47 #ifdef yy_init_buffer
48 #define pktloc__init_buffer_ALREADY_DEFINED
49 #else
50 #define yy_init_buffer pktloc__init_buffer
51 #endif
52 
53 #ifdef yy_flush_buffer
54 #define pktloc__flush_buffer_ALREADY_DEFINED
55 #else
56 #define yy_flush_buffer pktloc__flush_buffer
57 #endif
58 
59 #ifdef yy_load_buffer_state
60 #define pktloc__load_buffer_state_ALREADY_DEFINED
61 #else
62 #define yy_load_buffer_state pktloc__load_buffer_state
63 #endif
64 
65 #ifdef yy_switch_to_buffer
66 #define pktloc__switch_to_buffer_ALREADY_DEFINED
67 #else
68 #define yy_switch_to_buffer pktloc__switch_to_buffer
69 #endif
70 
71 #ifdef yypush_buffer_state
72 #define pktloc_push_buffer_state_ALREADY_DEFINED
73 #else
74 #define yypush_buffer_state pktloc_push_buffer_state
75 #endif
76 
77 #ifdef yypop_buffer_state
78 #define pktloc_pop_buffer_state_ALREADY_DEFINED
79 #else
80 #define yypop_buffer_state pktloc_pop_buffer_state
81 #endif
82 
83 #ifdef yyensure_buffer_stack
84 #define pktloc_ensure_buffer_stack_ALREADY_DEFINED
85 #else
86 #define yyensure_buffer_stack pktloc_ensure_buffer_stack
87 #endif
88 
89 #ifdef yylex
90 #define pktloc_lex_ALREADY_DEFINED
91 #else
92 #define yylex pktloc_lex
93 #endif
94 
95 #ifdef yyrestart
96 #define pktloc_restart_ALREADY_DEFINED
97 #else
98 #define yyrestart pktloc_restart
99 #endif
100 
101 #ifdef yylex_init
102 #define pktloc_lex_init_ALREADY_DEFINED
103 #else
104 #define yylex_init pktloc_lex_init
105 #endif
106 
107 #ifdef yylex_init_extra
108 #define pktloc_lex_init_extra_ALREADY_DEFINED
109 #else
110 #define yylex_init_extra pktloc_lex_init_extra
111 #endif
112 
113 #ifdef yylex_destroy
114 #define pktloc_lex_destroy_ALREADY_DEFINED
115 #else
116 #define yylex_destroy pktloc_lex_destroy
117 #endif
118 
119 #ifdef yyget_debug
120 #define pktloc_get_debug_ALREADY_DEFINED
121 #else
122 #define yyget_debug pktloc_get_debug
123 #endif
124 
125 #ifdef yyset_debug
126 #define pktloc_set_debug_ALREADY_DEFINED
127 #else
128 #define yyset_debug pktloc_set_debug
129 #endif
130 
131 #ifdef yyget_extra
132 #define pktloc_get_extra_ALREADY_DEFINED
133 #else
134 #define yyget_extra pktloc_get_extra
135 #endif
136 
137 #ifdef yyset_extra
138 #define pktloc_set_extra_ALREADY_DEFINED
139 #else
140 #define yyset_extra pktloc_set_extra
141 #endif
142 
143 #ifdef yyget_in
144 #define pktloc_get_in_ALREADY_DEFINED
145 #else
146 #define yyget_in pktloc_get_in
147 #endif
148 
149 #ifdef yyset_in
150 #define pktloc_set_in_ALREADY_DEFINED
151 #else
152 #define yyset_in pktloc_set_in
153 #endif
154 
155 #ifdef yyget_out
156 #define pktloc_get_out_ALREADY_DEFINED
157 #else
158 #define yyget_out pktloc_get_out
159 #endif
160 
161 #ifdef yyset_out
162 #define pktloc_set_out_ALREADY_DEFINED
163 #else
164 #define yyset_out pktloc_set_out
165 #endif
166 
167 #ifdef yyget_leng
168 #define pktloc_get_leng_ALREADY_DEFINED
169 #else
170 #define yyget_leng pktloc_get_leng
171 #endif
172 
173 #ifdef yyget_text
174 #define pktloc_get_text_ALREADY_DEFINED
175 #else
176 #define yyget_text pktloc_get_text
177 #endif
178 
179 #ifdef yyget_lineno
180 #define pktloc_get_lineno_ALREADY_DEFINED
181 #else
182 #define yyget_lineno pktloc_get_lineno
183 #endif
184 
185 #ifdef yyset_lineno
186 #define pktloc_set_lineno_ALREADY_DEFINED
187 #else
188 #define yyset_lineno pktloc_set_lineno
189 #endif
190 
191 #ifdef yyget_column
192 #define pktloc_get_column_ALREADY_DEFINED
193 #else
194 #define yyget_column pktloc_get_column
195 #endif
196 
197 #ifdef yyset_column
198 #define pktloc_set_column_ALREADY_DEFINED
199 #else
200 #define yyset_column pktloc_set_column
201 #endif
202 
203 #ifdef yywrap
204 #define pktloc_wrap_ALREADY_DEFINED
205 #else
206 #define yywrap pktloc_wrap
207 #endif
208 
209 #ifdef yyget_lval
210 #define pktloc_get_lval_ALREADY_DEFINED
211 #else
212 #define yyget_lval pktloc_get_lval
213 #endif
214 
215 #ifdef yyset_lval
216 #define pktloc_set_lval_ALREADY_DEFINED
217 #else
218 #define yyset_lval pktloc_set_lval
219 #endif
220 
221 #ifdef yyget_lloc
222 #define pktloc_get_lloc_ALREADY_DEFINED
223 #else
224 #define yyget_lloc pktloc_get_lloc
225 #endif
226 
227 #ifdef yyset_lloc
228 #define pktloc_set_lloc_ALREADY_DEFINED
229 #else
230 #define yyset_lloc pktloc_set_lloc
231 #endif
232 
233 #ifdef yyalloc
234 #define pktloc_alloc_ALREADY_DEFINED
235 #else
236 #define yyalloc pktloc_alloc
237 #endif
238 
239 #ifdef yyrealloc
240 #define pktloc_realloc_ALREADY_DEFINED
241 #else
242 #define yyrealloc pktloc_realloc
243 #endif
244 
245 #ifdef yyfree
246 #define pktloc_free_ALREADY_DEFINED
247 #else
248 #define yyfree pktloc_free
249 #endif
250 
251 /* First, we deal with platform-specific or compiler-specific issues. */
252 
253 /* begin standard C headers. */
254 #include <stdio.h>
255 #include <string.h>
256 #include <errno.h>
257 #include <stdlib.h>
258 
259 /* end standard C headers. */
260 
261 /* flex integer type definitions */
262 
263 #ifndef FLEXINT_H
264 #define FLEXINT_H
265 
266 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
267 
268 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
269 
270 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
271  * if you want the limit (max/min) macros for int types.
272  */
273 #ifndef __STDC_LIMIT_MACROS
274 #define __STDC_LIMIT_MACROS 1
275 #endif
276 
277 #include <inttypes.h>
278 typedef int8_t flex_int8_t;
279 typedef uint8_t flex_uint8_t;
280 typedef int16_t flex_int16_t;
281 typedef uint16_t flex_uint16_t;
282 typedef int32_t flex_int32_t;
283 typedef uint32_t flex_uint32_t;
284 #else
285 typedef signed char flex_int8_t;
286 typedef short int flex_int16_t;
287 typedef int flex_int32_t;
288 typedef unsigned char flex_uint8_t;
289 typedef unsigned short int flex_uint16_t;
290 typedef unsigned int flex_uint32_t;
291 
292 /* Limits of integral types. */
293 #ifndef INT8_MIN
294 #define INT8_MIN (-128)
295 #endif
296 #ifndef INT16_MIN
297 #define INT16_MIN (-32767-1)
298 #endif
299 #ifndef INT32_MIN
300 #define INT32_MIN (-2147483647-1)
301 #endif
302 #ifndef INT8_MAX
303 #define INT8_MAX (127)
304 #endif
305 #ifndef INT16_MAX
306 #define INT16_MAX (32767)
307 #endif
308 #ifndef INT32_MAX
309 #define INT32_MAX (2147483647)
310 #endif
311 #ifndef UINT8_MAX
312 #define UINT8_MAX (255U)
313 #endif
314 #ifndef UINT16_MAX
315 #define UINT16_MAX (65535U)
316 #endif
317 #ifndef UINT32_MAX
318 #define UINT32_MAX (4294967295U)
319 #endif
320 
321 #ifndef SIZE_MAX
322 #define SIZE_MAX (~(size_t)0)
323 #endif
324 
325 #endif /* ! C99 */
326 
327 #endif /* ! FLEXINT_H */
328 
329 /* begin standard C++ headers. */
330 
331 /* TODO: this is always defined, so inline it */
332 #define yyconst const
333 
334 #if defined(__GNUC__) && __GNUC__ >= 3
335 #define yynoreturn __attribute__((__noreturn__))
336 #else
337 #define yynoreturn
338 #endif
339 
340 /* Returned upon end-of-file. */
341 #define YY_NULL 0
342 
343 /* Promotes a possibly negative, possibly signed char to an
344  * integer in range [0..255] for use as an array index.
345  */
346 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
347 
348 /* An opaque pointer. */
349 #ifndef YY_TYPEDEF_YY_SCANNER_T
350 #define YY_TYPEDEF_YY_SCANNER_T
351 typedef void* yyscan_t;
352 #endif
353 
354 /* For convenience, these vars (plus the bison vars far below)
355  are macros in the reentrant scanner. */
356 #define yyin yyg->yyin_r
357 #define yyout yyg->yyout_r
358 #define yyextra yyg->yyextra_r
359 #define yyleng yyg->yyleng_r
360 #define yytext yyg->yytext_r
361 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
362 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
363 #define yy_flex_debug yyg->yy_flex_debug_r
364 
365 /* Enter a start condition. This macro really ought to take a parameter,
366  * but we do it the disgusting crufty way forced on us by the ()-less
367  * definition of BEGIN.
368  */
369 #define BEGIN yyg->yy_start = 1 + 2 *
370 /* Translate the current start state into a value that can be later handed
371  * to BEGIN to return to the state. The YYSTATE alias is for lex
372  * compatibility.
373  */
374 #define YY_START ((yyg->yy_start - 1) / 2)
375 #define YYSTATE YY_START
376 /* Action number for EOF rule of a given start state. */
377 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
378 /* Special action meaning "start processing a new file". */
379 #define YY_NEW_FILE yyrestart( yyin , yyscanner )
380 #define YY_END_OF_BUFFER_CHAR 0
381 
382 /* Size of default input buffer. */
383 #ifndef YY_BUF_SIZE
384 #ifdef __ia64__
385 /* On IA-64, the buffer size is 16k, not 8k.
386  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
387  * Ditto for the __ia64__ case accordingly.
388  */
389 #define YY_BUF_SIZE 32768
390 #else
391 #define YY_BUF_SIZE 16384
392 #endif /* __ia64__ */
393 #endif
394 
395 /* The state buf must be large enough to hold one state per character in the main buffer.
396  */
397 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
398 
399 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
400 #define YY_TYPEDEF_YY_BUFFER_STATE
401 typedef struct yy_buffer_state *YY_BUFFER_STATE;
402 #endif
403 
404 #ifndef YY_TYPEDEF_YY_SIZE_T
405 #define YY_TYPEDEF_YY_SIZE_T
406 typedef size_t yy_size_t;
407 #endif
408 
409 #define EOB_ACT_CONTINUE_SCAN 0
410 #define EOB_ACT_END_OF_FILE 1
411 #define EOB_ACT_LAST_MATCH 2
412 
413  #define YY_LESS_LINENO(n)
414  #define YY_LINENO_REWIND_TO(ptr)
415 
416 /* Return all but the first "n" matched characters back to the input stream. */
417 #define yyless(n) \
418  do \
419  { \
420  /* Undo effects of setting up yytext. */ \
421  int yyless_macro_arg = (n); \
422  YY_LESS_LINENO(yyless_macro_arg);\
423  *yy_cp = yyg->yy_hold_char; \
424  YY_RESTORE_YY_MORE_OFFSET \
425  yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
426  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
427  } \
428  while ( 0 )
429 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
430 
431 #ifndef YY_STRUCT_YY_BUFFER_STATE
432 #define YY_STRUCT_YY_BUFFER_STATE
433 struct yy_buffer_state
434  {
435  FILE *yy_input_file;
436 
437  char *yy_ch_buf; /* input buffer */
438  char *yy_buf_pos; /* current position in input buffer */
439 
440  /* Size of input buffer in bytes, not including room for EOB
441  * characters.
442  */
443  int yy_buf_size;
444 
445  /* Number of characters read into yy_ch_buf, not including EOB
446  * characters.
447  */
448  int yy_n_chars;
449 
450  /* Whether we "own" the buffer - i.e., we know we created it,
451  * and can realloc() it to grow it, and should free() it to
452  * delete it.
453  */
454  int yy_is_our_buffer;
455 
456  /* Whether this is an "interactive" input source; if so, and
457  * if we're using stdio for input, then we want to use getc()
458  * instead of fread(), to make sure we stop fetching input after
459  * each newline.
460  */
461  int yy_is_interactive;
462 
463  /* Whether we're considered to be at the beginning of a line.
464  * If so, '^' rules will be active on the next match, otherwise
465  * not.
466  */
467  int yy_at_bol;
468 
469  int yy_bs_lineno; /**< The line count. */
470  int yy_bs_column; /**< The column count. */
471 
472  /* Whether to try to fill the input buffer when we reach the
473  * end of it.
474  */
475  int yy_fill_buffer;
476 
477  int yy_buffer_status;
478 
479 #define YY_BUFFER_NEW 0
480 #define YY_BUFFER_NORMAL 1
481  /* When an EOF's been seen but there's still some text to process
482  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
483  * shouldn't try reading from the input source any more. We might
484  * still have a bunch of tokens to match, though, because of
485  * possible backing-up.
486  *
487  * When we actually see the EOF, we change the status to "new"
488  * (via yyrestart()), so that the user can continue scanning by
489  * just pointing yyin at a new input file.
490  */
491 #define YY_BUFFER_EOF_PENDING 2
492 
493  };
494 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
495 
496 /* We provide macros for accessing buffer states in case in the
497  * future we want to put the buffer states in a more general
498  * "scanner state".
499  *
500  * Returns the top of the stack, or NULL.
501  */
502 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
503  ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
504  : NULL)
505 /* Same as previous macro, but useful when we know that the buffer stack is not
506  * NULL or when we need an lvalue. For internal use only.
507  */
508 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
509 
510 void yyrestart ( FILE *input_file , yyscan_t yyscanner );
511 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
512 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
513 void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
514 void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
515 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
516 void yypop_buffer_state ( yyscan_t yyscanner );
517 
518 static void yyensure_buffer_stack ( yyscan_t yyscanner );
519 static void yy_load_buffer_state ( yyscan_t yyscanner );
520 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
521 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
522 
523 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
524 YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
525 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
526 
527 void *yyalloc ( yy_size_t , yyscan_t yyscanner );
528 void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
529 void yyfree ( void * , yyscan_t yyscanner );
530 
531 #define yy_new_buffer yy_create_buffer
532 #define yy_set_interactive(is_interactive) \
533  { \
534  if ( ! YY_CURRENT_BUFFER ){ \
535  yyensure_buffer_stack (yyscanner); \
536  YY_CURRENT_BUFFER_LVALUE = \
537  yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
538  } \
539  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
540  }
541 #define yy_set_bol(at_bol) \
542  { \
543  if ( ! YY_CURRENT_BUFFER ){\
544  yyensure_buffer_stack (yyscanner); \
545  YY_CURRENT_BUFFER_LVALUE = \
546  yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
547  } \
548  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
549  }
550 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
551 
552 #define pktloc_wrap(yyscanner) (/*CONSTCOND*/1)
553 #define YY_SKIP_YYWRAP
554 typedef flex_uint8_t YY_CHAR;
555 
556 typedef int yy_state_type;
557 
558 #define yytext_ptr yytext_r
559 
560 static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
561 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
562 static int yy_get_next_buffer ( yyscan_t yyscanner );
563 static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
564 
565 /* Done after the current pattern has been matched and before the
566  * corresponding action - sets up yytext.
567  */
568 #define YY_DO_BEFORE_ACTION \
569  yyg->yytext_ptr = yy_bp; \
570  yyleng = (int) (yy_cp - yy_bp); \
571  yyg->yy_hold_char = *yy_cp; \
572  *yy_cp = '\0'; \
573  yyg->yy_c_buf_p = yy_cp;
574 #define YY_NUM_RULES 16
575 #define YY_END_OF_BUFFER 17
576 /* This struct is not used in this scanner,
577  but its presence is necessary. */
578 struct yy_trans_info
579  {
580  flex_int32_t yy_verify;
581  flex_int32_t yy_nxt;
582  };
583 static const flex_int16_t yy_accept[47] =
584  { 0,
585  0, 0, 17, 15, 1, 2, 5, 3, 3, 15,
586  15, 15, 15, 15, 15, 15, 1, 2, 2, 3,
587  15, 15, 12, 15, 15, 15, 15, 15, 15, 6,
588  4, 10, 15, 11, 14, 15, 7, 8, 9, 15,
589  15, 15, 15, 15, 13, 0
590  } ;
591 
592 static const YY_CHAR yy_ec[256] =
593  { 0,
594  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
595  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
596  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
597  1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
598  1, 1, 5, 1, 1, 1, 1, 6, 7, 8,
599  9, 10, 10, 11, 10, 12, 10, 1, 1, 1,
600  1, 1, 1, 1, 13, 14, 15, 14, 16, 14,
601  1, 17, 18, 1, 19, 20, 1, 21, 22, 23,
602  1, 24, 25, 26, 27, 1, 1, 28, 1, 1,
603  1, 1, 1, 1, 1, 1, 13, 14, 15, 14,
604 
605  16, 14, 1, 17, 18, 1, 19, 20, 1, 21,
606  22, 23, 1, 24, 25, 26, 27, 1, 1, 28,
607  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
608  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
609  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
610  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
611  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
612  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
613  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
614  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
615 
616  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
617  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
618  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
619  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
620  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
621  1, 1, 1, 1, 1
622  } ;
623 
624 static const YY_CHAR yy_meta[29] =
625  { 0,
626  1, 2, 3, 1, 2, 1, 1, 1, 1, 1,
627  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
628  1, 1, 1, 1, 1, 1, 1, 1
629  } ;
630 
631 static const flex_int16_t yy_base[50] =
632  { 0,
633  0, 0, 86, 0, 27, 29, 87, 29, 57, 58,
634  60, 64, 65, 18, 36, 0, 44, 47, 0, 52,
635  52, 62, 0, 57, 51, 53, 62, 63, 65, 0,
636  0, 0, 37, 0, 0, 34, 0, 0, 0, 29,
637  30, 29, 26, 18, 0, 87, 31, 68, 70
638  } ;
639 
640 static const flex_int16_t yy_def[50] =
641  { 0,
642  46, 1, 46, 47, 46, 48, 46, 47, 8, 47,
643  47, 47, 47, 47, 47, 47, 46, 48, 49, 8,
644  47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
645  21, 47, 47, 47, 47, 47, 47, 47, 47, 47,
646  47, 47, 47, 47, 47, 0, 46, 46, 46
647  } ;
648 
649 static const flex_int16_t yy_nxt[116] =
650  { 0,
651  4, 5, 5, 6, 7, 8, 9, 9, 9, 9,
652  9, 9, 4, 4, 4, 10, 4, 11, 4, 12,
653  13, 4, 4, 4, 4, 14, 15, 4, 17, 17,
654  19, 16, 26, 19, 20, 20, 20, 20, 20, 20,
655  20, 27, 28, 45, 29, 17, 17, 30, 19, 44,
656  43, 19, 42, 41, 40, 39, 21, 31, 31, 31,
657  31, 31, 31, 31, 31, 31, 31, 31, 18, 18,
658  19, 19, 38, 37, 36, 35, 34, 33, 32, 16,
659  25, 24, 23, 22, 16, 46, 3, 46, 46, 46,
660  46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
661 
662  46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
663  46, 46, 46, 46, 46
664  } ;
665 
666 static const flex_int16_t yy_chk[116] =
667  { 0,
668  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
669  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
670  1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
671  6, 47, 14, 6, 8, 8, 8, 8, 8, 8,
672  8, 14, 15, 44, 15, 17, 17, 15, 18, 43,
673  42, 18, 41, 40, 36, 33, 8, 21, 21, 21,
674  21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
675  49, 49, 29, 28, 27, 26, 25, 24, 22, 20,
676  13, 12, 11, 10, 9, 3, 46, 46, 46, 46,
677  46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
678 
679  46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
680  46, 46, 46, 46, 46
681  } ;
682 
683 /* The intent behind this definition is that it'll catch
684  * any uses of REJECT which flex missed.
685  */
686 #define REJECT reject_used_but_not_detected
687 #define yymore() yymore_used_but_not_detected
688 #define YY_MORE_ADJ 0
689 #define YY_RESTORE_YY_MORE_OFFSET
690 #line 1 "lib/route/pktloc_grammar.l"
691 #line 2 "lib/route/pktloc_grammar.l"
692  #include <netlink-private/netlink.h>
693  #include <netlink-private/tc.h>
694  #include <netlink/netlink.h>
695  #include <netlink/utils.h>
696  #include <netlink/route/pktloc.h>
697  #include <linux/tc_ematch/tc_em_cmp.h>
698  #include "pktloc_syntax.h"
699 
700  int pktloc_get_column(yyscan_t);
701  void pktloc_set_column(int, yyscan_t);
702 #line 702 "lib/route/pktloc_grammar.c"
703 #define YY_NO_INPUT 1
704 #line 704 "lib/route/pktloc_grammar.c"
705 
706 #define INITIAL 0
707 
708 #ifndef YY_NO_UNISTD_H
709 /* Special case for "unistd.h", since it is non-ANSI. We include it way
710  * down here because we want the user's section 1 to have been scanned first.
711  * The user has a chance to override it with an option.
712  */
713 #include <unistd.h>
714 #endif
715 
716 #ifndef YY_EXTRA_TYPE
717 #define YY_EXTRA_TYPE void *
718 #endif
719 
720 /* Holds the entire state of the reentrant scanner. */
721 struct yyguts_t
722  {
723 
724  /* User-defined. Not touched by flex. */
725  YY_EXTRA_TYPE yyextra_r;
726 
727  /* The rest are the same as the globals declared in the non-reentrant scanner. */
728  FILE *yyin_r, *yyout_r;
729  size_t yy_buffer_stack_top; /**< index of top of stack. */
730  size_t yy_buffer_stack_max; /**< capacity of stack. */
731  YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
732  char yy_hold_char;
733  int yy_n_chars;
734  int yyleng_r;
735  char *yy_c_buf_p;
736  int yy_init;
737  int yy_start;
738  int yy_did_buffer_switch_on_eof;
739  int yy_start_stack_ptr;
740  int yy_start_stack_depth;
741  int *yy_start_stack;
742  yy_state_type yy_last_accepting_state;
743  char* yy_last_accepting_cpos;
744 
745  int yylineno_r;
746  int yy_flex_debug_r;
747 
748  char *yytext_r;
749  int yy_more_flag;
750  int yy_more_len;
751 
752  YYSTYPE * yylval_r;
753 
754  YYLTYPE * yylloc_r;
755 
756  }; /* end struct yyguts_t */
757 
758 static int yy_init_globals ( yyscan_t yyscanner );
759 
760  /* This must go here because YYSTYPE and YYLTYPE are included
761  * from bison output in section 1.*/
762  # define yylval yyg->yylval_r
763 
764  # define yylloc yyg->yylloc_r
765 
766 int yylex_init (yyscan_t* scanner);
767 
768 int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
769 
770 /* Accessor methods to globals.
771  These are made visible to non-reentrant scanners for convenience. */
772 
773 int yylex_destroy ( yyscan_t yyscanner );
774 
775 int yyget_debug ( yyscan_t yyscanner );
776 
777 void yyset_debug ( int debug_flag , yyscan_t yyscanner );
778 
779 YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
780 
781 void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
782 
783 FILE *yyget_in ( yyscan_t yyscanner );
784 
785 void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
786 
787 FILE *yyget_out ( yyscan_t yyscanner );
788 
789 void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
790 
791  int yyget_leng ( yyscan_t yyscanner );
792 
793 char *yyget_text ( yyscan_t yyscanner );
794 
795 int yyget_lineno ( yyscan_t yyscanner );
796 
797 void yyset_lineno ( int _line_number , yyscan_t yyscanner );
798 
799 int yyget_column ( yyscan_t yyscanner );
800 
801 void yyset_column ( int _column_no , yyscan_t yyscanner );
802 
803 YYSTYPE * yyget_lval ( yyscan_t yyscanner );
804 
805 void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
806 
807  YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
808 
809  void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
810 
811 /* Macros after this point can all be overridden by user definitions in
812  * section 1.
813  */
814 
815 #ifndef YY_SKIP_YYWRAP
816 #ifdef __cplusplus
817 extern "C" int yywrap ( yyscan_t yyscanner );
818 #else
819 extern int yywrap ( yyscan_t yyscanner );
820 #endif
821 #endif
822 
823 #ifndef YY_NO_UNPUT
824 
825 #endif
826 
827 #ifndef yytext_ptr
828 static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
829 #endif
830 
831 #ifdef YY_NEED_STRLEN
832 static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
833 #endif
834 
835 #ifndef YY_NO_INPUT
836 #ifdef __cplusplus
837 static int yyinput ( yyscan_t yyscanner );
838 #else
839 static int input ( yyscan_t yyscanner );
840 #endif
841 
842 #endif
843 
844 /* Amount of stuff to slurp up with each read. */
845 #ifndef YY_READ_BUF_SIZE
846 #ifdef __ia64__
847 /* On IA-64, the buffer size is 16k, not 8k */
848 #define YY_READ_BUF_SIZE 16384
849 #else
850 #define YY_READ_BUF_SIZE 8192
851 #endif /* __ia64__ */
852 #endif
853 
854 /* Copy whatever the last rule matched to the standard output. */
855 #ifndef ECHO
856 /* This used to be an fputs(), but since the string might contain NUL's,
857  * we now use fwrite().
858  */
859 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
860 #endif
861 
862 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
863  * is returned in "result".
864  */
865 #ifndef YY_INPUT
866 #define YY_INPUT(buf,result,max_size) \
867  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
868  { \
869  int c = '*'; \
870  int n; \
871  for ( n = 0; n < max_size && \
872  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
873  buf[n] = (char) c; \
874  if ( c == '\n' ) \
875  buf[n++] = (char) c; \
876  if ( c == EOF && ferror( yyin ) ) \
877  YY_FATAL_ERROR( "input in flex scanner failed" ); \
878  result = n; \
879  } \
880  else \
881  { \
882  errno=0; \
883  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
884  { \
885  if( errno != EINTR) \
886  { \
887  YY_FATAL_ERROR( "input in flex scanner failed" ); \
888  break; \
889  } \
890  errno=0; \
891  clearerr(yyin); \
892  } \
893  }\
894 \
895 
896 #endif
897 
898 /* No semi-colon after return; correct usage is to write "yyterminate();" -
899  * we don't want an extra ';' after the "return" because that will cause
900  * some compilers to complain about unreachable statements.
901  */
902 #ifndef yyterminate
903 #define yyterminate() return YY_NULL
904 #endif
905 
906 /* Number of entries by which start-condition stack grows. */
907 #ifndef YY_START_STACK_INCR
908 #define YY_START_STACK_INCR 25
909 #endif
910 
911 /* Report a fatal error. */
912 #ifndef YY_FATAL_ERROR
913 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
914 #endif
915 
916 /* end tables serialization structures and prototypes */
917 
918 /* Default declaration of generated scanner - a define so the user can
919  * easily add parameters.
920  */
921 #ifndef YY_DECL
922 #define YY_DECL_IS_OURS 1
923 
924 extern int yylex \
925  (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
926 
927 #define YY_DECL int yylex \
928  (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
929 #endif /* !YY_DECL */
930 
931 /* Code executed at the beginning of each rule, after yytext and yyleng
932  * have been set up.
933  */
934 #ifndef YY_USER_ACTION
935 #define YY_USER_ACTION
936 #endif
937 
938 /* Code executed at the end of each rule. */
939 #ifndef YY_BREAK
940 #define YY_BREAK /*LINTED*/break;
941 #endif
942 
943 #define YY_RULE_SETUP \
944  YY_USER_ACTION
945 
946 /** The main scanner function which does all the work.
947  */
948 YY_DECL
949 {
950  yy_state_type yy_current_state;
951  char *yy_cp, *yy_bp;
952  int yy_act;
953  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
954 
955  yylval = yylval_param;
956 
957  yylloc = yylloc_param;
958 
959  if ( !yyg->yy_init )
960  {
961  yyg->yy_init = 1;
962 
963 #ifdef YY_USER_INIT
964  YY_USER_INIT;
965 #endif
966 
967  if ( ! yyg->yy_start )
968  yyg->yy_start = 1; /* first start state */
969 
970  if ( ! yyin )
971  yyin = stdin;
972 
973  if ( ! yyout )
974  yyout = stdout;
975 
976  if ( ! YY_CURRENT_BUFFER ) {
977  yyensure_buffer_stack (yyscanner);
978  YY_CURRENT_BUFFER_LVALUE =
979  yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
980  }
981 
982  yy_load_buffer_state( yyscanner );
983  }
984 
985  {
986 #line 24 "lib/route/pktloc_grammar.l"
987 
988 
989 #line 989 "lib/route/pktloc_grammar.c"
990 
991  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
992  {
993  yy_cp = yyg->yy_c_buf_p;
994 
995  /* Support of yytext. */
996  *yy_cp = yyg->yy_hold_char;
997 
998  /* yy_bp points to the position in yy_ch_buf of the start of
999  * the current run.
1000  */
1001  yy_bp = yy_cp;
1002 
1003  yy_current_state = yyg->yy_start;
1004 yy_match:
1005  do
1006  {
1007  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1008  if ( yy_accept[yy_current_state] )
1009  {
1010  yyg->yy_last_accepting_state = yy_current_state;
1011  yyg->yy_last_accepting_cpos = yy_cp;
1012  }
1013  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1014  {
1015  yy_current_state = (int) yy_def[yy_current_state];
1016  if ( yy_current_state >= 47 )
1017  yy_c = yy_meta[yy_c];
1018  }
1019  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1020  ++yy_cp;
1021  }
1022  while ( yy_base[yy_current_state] != 87 );
1023 
1024 yy_find_action:
1025  yy_act = yy_accept[yy_current_state];
1026  if ( yy_act == 0 )
1027  { /* have to back up */
1028  yy_cp = yyg->yy_last_accepting_cpos;
1029  yy_current_state = yyg->yy_last_accepting_state;
1030  yy_act = yy_accept[yy_current_state];
1031  }
1032 
1033  YY_DO_BEFORE_ACTION;
1034 
1035 do_action: /* This label is used only to access EOF actions. */
1036 
1037  switch ( yy_act )
1038  { /* beginning of action switch */
1039  case 0: /* must back up */
1040  /* undo the effects of YY_DO_BEFORE_ACTION */
1041  *yy_cp = yyg->yy_hold_char;
1042  yy_cp = yyg->yy_last_accepting_cpos;
1043  yy_current_state = yyg->yy_last_accepting_state;
1044  goto yy_find_action;
1045 
1046 case 1:
1047 /* rule 1 can match eol */
1048 YY_RULE_SETUP
1049 #line 26 "lib/route/pktloc_grammar.l"
1050 
1051  YY_BREAK
1052 case 2:
1053 YY_RULE_SETUP
1054 #line 28 "lib/route/pktloc_grammar.l"
1055 
1056  YY_BREAK
1057 case 3:
1058 #line 31 "lib/route/pktloc_grammar.l"
1059 case 4:
1060 YY_RULE_SETUP
1061 #line 31 "lib/route/pktloc_grammar.l"
1062 {
1063  yylval->i = strtoul(yytext, NULL, 0);
1064  return NUMBER;
1065  }
1066  YY_BREAK
1067 case 5:
1068 YY_RULE_SETUP
1069 #line 36 "lib/route/pktloc_grammar.l"
1070 { return yylval->i = yytext[0]; }
1071  YY_BREAK
1072 case 6:
1073 YY_RULE_SETUP
1074 #line 38 "lib/route/pktloc_grammar.l"
1075 { yylval->i = TCF_EM_ALIGN_U8; return ALIGN; }
1076  YY_BREAK
1077 case 7:
1078 YY_RULE_SETUP
1079 #line 39 "lib/route/pktloc_grammar.l"
1080 { yylval->i = TCF_EM_ALIGN_U16; return ALIGN; }
1081  YY_BREAK
1082 case 8:
1083 YY_RULE_SETUP
1084 #line 40 "lib/route/pktloc_grammar.l"
1085 { yylval->i = TCF_EM_ALIGN_U32; return ALIGN; }
1086  YY_BREAK
1087 case 9:
1088 #line 43 "lib/route/pktloc_grammar.l"
1089 case 10:
1090 YY_RULE_SETUP
1091 #line 43 "lib/route/pktloc_grammar.l"
1092 { yylval->i = TCF_LAYER_LINK; return LAYER; }
1093  YY_BREAK
1094 case 11:
1095 #line 45 "lib/route/pktloc_grammar.l"
1096 case 12:
1097 YY_RULE_SETUP
1098 #line 45 "lib/route/pktloc_grammar.l"
1099 { yylval->i = TCF_LAYER_NETWORK; return LAYER; }
1100  YY_BREAK
1101 case 13:
1102 #line 47 "lib/route/pktloc_grammar.l"
1103 case 14:
1104 YY_RULE_SETUP
1105 #line 47 "lib/route/pktloc_grammar.l"
1106 { yylval->i = TCF_LAYER_TRANSPORT; return LAYER; }
1107  YY_BREAK
1108 case 15:
1109 YY_RULE_SETUP
1110 #line 50 "lib/route/pktloc_grammar.l"
1111 {
1112  yylval->s = strdup(yytext);
1113  if (yylval->s == NULL)
1114  return ERROR;
1115  return NAME;
1116  }
1117  YY_BREAK
1118 case 16:
1119 YY_RULE_SETUP
1120 #line 56 "lib/route/pktloc_grammar.l"
1121 ECHO;
1122  YY_BREAK
1123 #line 1123 "lib/route/pktloc_grammar.c"
1124 case YY_STATE_EOF(INITIAL):
1125  yyterminate();
1126 
1127  case YY_END_OF_BUFFER:
1128  {
1129  /* Amount of text matched not including the EOB char. */
1130  int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1131 
1132  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1133  *yy_cp = yyg->yy_hold_char;
1134  YY_RESTORE_YY_MORE_OFFSET
1135 
1136  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1137  {
1138  /* We're scanning a new file or input source. It's
1139  * possible that this happened because the user
1140  * just pointed yyin at a new source and called
1141  * yylex(). If so, then we have to assure
1142  * consistency between YY_CURRENT_BUFFER and our
1143  * globals. Here is the right place to do so, because
1144  * this is the first action (other than possibly a
1145  * back-up) that will match for the new input source.
1146  */
1147  yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1148  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1149  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1150  }
1151 
1152  /* Note that here we test for yy_c_buf_p "<=" to the position
1153  * of the first EOB in the buffer, since yy_c_buf_p will
1154  * already have been incremented past the NUL character
1155  * (since all states make transitions on EOB to the
1156  * end-of-buffer state). Contrast this with the test
1157  * in input().
1158  */
1159  if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1160  { /* This was really a NUL. */
1161  yy_state_type yy_next_state;
1162 
1163  yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1164 
1165  yy_current_state = yy_get_previous_state( yyscanner );
1166 
1167  /* Okay, we're now positioned to make the NUL
1168  * transition. We couldn't have
1169  * yy_get_previous_state() go ahead and do it
1170  * for us because it doesn't know how to deal
1171  * with the possibility of jamming (and we don't
1172  * want to build jamming into it because then it
1173  * will run more slowly).
1174  */
1175 
1176  yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1177 
1178  yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1179 
1180  if ( yy_next_state )
1181  {
1182  /* Consume the NUL. */
1183  yy_cp = ++yyg->yy_c_buf_p;
1184  yy_current_state = yy_next_state;
1185  goto yy_match;
1186  }
1187 
1188  else
1189  {
1190  yy_cp = yyg->yy_c_buf_p;
1191  goto yy_find_action;
1192  }
1193  }
1194 
1195  else switch ( yy_get_next_buffer( yyscanner ) )
1196  {
1197  case EOB_ACT_END_OF_FILE:
1198  {
1199  yyg->yy_did_buffer_switch_on_eof = 0;
1200 
1201  if ( yywrap( yyscanner ) )
1202  {
1203  /* Note: because we've taken care in
1204  * yy_get_next_buffer() to have set up
1205  * yytext, we can now set up
1206  * yy_c_buf_p so that if some total
1207  * hoser (like flex itself) wants to
1208  * call the scanner after we return the
1209  * YY_NULL, it'll still work - another
1210  * YY_NULL will get returned.
1211  */
1212  yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1213 
1214  yy_act = YY_STATE_EOF(YY_START);
1215  goto do_action;
1216  }
1217 
1218  else
1219  {
1220  if ( ! yyg->yy_did_buffer_switch_on_eof )
1221  YY_NEW_FILE;
1222  }
1223  break;
1224  }
1225 
1226  case EOB_ACT_CONTINUE_SCAN:
1227  yyg->yy_c_buf_p =
1228  yyg->yytext_ptr + yy_amount_of_matched_text;
1229 
1230  yy_current_state = yy_get_previous_state( yyscanner );
1231 
1232  yy_cp = yyg->yy_c_buf_p;
1233  yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1234  goto yy_match;
1235 
1236  case EOB_ACT_LAST_MATCH:
1237  yyg->yy_c_buf_p =
1238  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1239 
1240  yy_current_state = yy_get_previous_state( yyscanner );
1241 
1242  yy_cp = yyg->yy_c_buf_p;
1243  yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1244  goto yy_find_action;
1245  }
1246  break;
1247  }
1248 
1249  default:
1250  YY_FATAL_ERROR(
1251  "fatal flex scanner internal error--no action found" );
1252  } /* end of action switch */
1253  } /* end of scanning one token */
1254  } /* end of user's declarations */
1255 } /* end of yylex */
1256 
1257 /* yy_get_next_buffer - try to read in a new buffer
1258  *
1259  * Returns a code representing an action:
1260  * EOB_ACT_LAST_MATCH -
1261  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1262  * EOB_ACT_END_OF_FILE - end of file
1263  */
1264 static int yy_get_next_buffer (yyscan_t yyscanner)
1265 {
1266  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1267  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1268  char *source = yyg->yytext_ptr;
1269  int number_to_move, i;
1270  int ret_val;
1271 
1272  if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1273  YY_FATAL_ERROR(
1274  "fatal flex scanner internal error--end of buffer missed" );
1275 
1276  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1277  { /* Don't try to fill the buffer, so this is an EOF. */
1278  if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1279  {
1280  /* We matched a single character, the EOB, so
1281  * treat this as a final EOF.
1282  */
1283  return EOB_ACT_END_OF_FILE;
1284  }
1285 
1286  else
1287  {
1288  /* We matched some text prior to the EOB, first
1289  * process it.
1290  */
1291  return EOB_ACT_LAST_MATCH;
1292  }
1293  }
1294 
1295  /* Try to read more data. */
1296 
1297  /* First move last chars to start of buffer. */
1298  number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
1299 
1300  for ( i = 0; i < number_to_move; ++i )
1301  *(dest++) = *(source++);
1302 
1303  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1304  /* don't do the read, it's not guaranteed to return an EOF,
1305  * just force an EOF
1306  */
1307  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1308 
1309  else
1310  {
1311  int num_to_read =
1312  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1313 
1314  while ( num_to_read <= 0 )
1315  { /* Not enough room in the buffer - grow it. */
1316 
1317  /* just a shorter name for the current buffer */
1318  YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1319 
1320  int yy_c_buf_p_offset =
1321  (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1322 
1323  if ( b->yy_is_our_buffer )
1324  {
1325  int new_size = b->yy_buf_size * 2;
1326 
1327  if ( new_size <= 0 )
1328  b->yy_buf_size += b->yy_buf_size / 8;
1329  else
1330  b->yy_buf_size *= 2;
1331 
1332  b->yy_ch_buf = (char *)
1333  /* Include room in for 2 EOB chars. */
1334  yyrealloc( (void *) b->yy_ch_buf,
1335  (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1336  }
1337  else
1338  /* Can't grow it, we don't own it. */
1339  b->yy_ch_buf = NULL;
1340 
1341  if ( ! b->yy_ch_buf )
1342  YY_FATAL_ERROR(
1343  "fatal error - scanner input buffer overflow" );
1344 
1345  yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1346 
1347  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1348  number_to_move - 1;
1349 
1350  }
1351 
1352  if ( num_to_read > YY_READ_BUF_SIZE )
1353  num_to_read = YY_READ_BUF_SIZE;
1354 
1355  /* Read in more data. */
1356  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1357  yyg->yy_n_chars, num_to_read );
1358 
1359  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1360  }
1361 
1362  if ( yyg->yy_n_chars == 0 )
1363  {
1364  if ( number_to_move == YY_MORE_ADJ )
1365  {
1366  ret_val = EOB_ACT_END_OF_FILE;
1367  yyrestart( yyin , yyscanner);
1368  }
1369 
1370  else
1371  {
1372  ret_val = EOB_ACT_LAST_MATCH;
1373  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1374  YY_BUFFER_EOF_PENDING;
1375  }
1376  }
1377 
1378  else
1379  ret_val = EOB_ACT_CONTINUE_SCAN;
1380 
1381  if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1382  /* Extend the array by 50%, plus the number we really need. */
1383  int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1384  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1385  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
1386  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1387  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1388  /* "- 2" to take care of EOB's */
1389  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1390  }
1391 
1392  yyg->yy_n_chars += number_to_move;
1393  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1394  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1395 
1396  yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1397 
1398  return ret_val;
1399 }
1400 
1401 /* yy_get_previous_state - get the state just before the EOB char was reached */
1402 
1403  static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1404 {
1405  yy_state_type yy_current_state;
1406  char *yy_cp;
1407  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1408 
1409  yy_current_state = yyg->yy_start;
1410 
1411  for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1412  {
1413  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1414  if ( yy_accept[yy_current_state] )
1415  {
1416  yyg->yy_last_accepting_state = yy_current_state;
1417  yyg->yy_last_accepting_cpos = yy_cp;
1418  }
1419  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1420  {
1421  yy_current_state = (int) yy_def[yy_current_state];
1422  if ( yy_current_state >= 47 )
1423  yy_c = yy_meta[yy_c];
1424  }
1425  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1426  }
1427 
1428  return yy_current_state;
1429 }
1430 
1431 /* yy_try_NUL_trans - try to make a transition on the NUL character
1432  *
1433  * synopsis
1434  * next_state = yy_try_NUL_trans( current_state );
1435  */
1436  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1437 {
1438  int yy_is_jam;
1439  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1440  char *yy_cp = yyg->yy_c_buf_p;
1441 
1442  YY_CHAR yy_c = 1;
1443  if ( yy_accept[yy_current_state] )
1444  {
1445  yyg->yy_last_accepting_state = yy_current_state;
1446  yyg->yy_last_accepting_cpos = yy_cp;
1447  }
1448  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1449  {
1450  yy_current_state = (int) yy_def[yy_current_state];
1451  if ( yy_current_state >= 47 )
1452  yy_c = yy_meta[yy_c];
1453  }
1454  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1455  yy_is_jam = (yy_current_state == 46);
1456 
1457  (void)yyg;
1458  return yy_is_jam ? 0 : yy_current_state;
1459 }
1460 
1461 #ifndef YY_NO_UNPUT
1462 
1463 #endif
1464 
1465 #ifndef YY_NO_INPUT
1466 #ifdef __cplusplus
1467  static int yyinput (yyscan_t yyscanner)
1468 #else
1469  static int input (yyscan_t yyscanner)
1470 #endif
1471 
1472 {
1473  int c;
1474  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1475 
1476  *yyg->yy_c_buf_p = yyg->yy_hold_char;
1477 
1478  if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1479  {
1480  /* yy_c_buf_p now points to the character we want to return.
1481  * If this occurs *before* the EOB characters, then it's a
1482  * valid NUL; if not, then we've hit the end of the buffer.
1483  */
1484  if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1485  /* This was really a NUL. */
1486  *yyg->yy_c_buf_p = '\0';
1487 
1488  else
1489  { /* need more input */
1490  int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
1491  ++yyg->yy_c_buf_p;
1492 
1493  switch ( yy_get_next_buffer( yyscanner ) )
1494  {
1495  case EOB_ACT_LAST_MATCH:
1496  /* This happens because yy_g_n_b()
1497  * sees that we've accumulated a
1498  * token and flags that we need to
1499  * try matching the token before
1500  * proceeding. But for input(),
1501  * there's no matching to consider.
1502  * So convert the EOB_ACT_LAST_MATCH
1503  * to EOB_ACT_END_OF_FILE.
1504  */
1505 
1506  /* Reset buffer status. */
1507  yyrestart( yyin , yyscanner);
1508 
1509  /*FALLTHROUGH*/
1510 
1511  case EOB_ACT_END_OF_FILE:
1512  {
1513  if ( yywrap( yyscanner ) )
1514  return 0;
1515 
1516  if ( ! yyg->yy_did_buffer_switch_on_eof )
1517  YY_NEW_FILE;
1518 #ifdef __cplusplus
1519  return yyinput(yyscanner);
1520 #else
1521  return input(yyscanner);
1522 #endif
1523  }
1524 
1525  case EOB_ACT_CONTINUE_SCAN:
1526  yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1527  break;
1528  }
1529  }
1530  }
1531 
1532  c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1533  *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
1534  yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1535 
1536  return c;
1537 }
1538 #endif /* ifndef YY_NO_INPUT */
1539 
1540 /** Immediately switch to a different input stream.
1541  * @param input_file A readable stream.
1542  * @param yyscanner The scanner object.
1543  * @note This function does not reset the start condition to @c INITIAL .
1544  */
1545  void yyrestart (FILE * input_file , yyscan_t yyscanner)
1546 {
1547  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1548 
1549  if ( ! YY_CURRENT_BUFFER ){
1550  yyensure_buffer_stack (yyscanner);
1551  YY_CURRENT_BUFFER_LVALUE =
1552  yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
1553  }
1554 
1555  yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
1556  yy_load_buffer_state( yyscanner );
1557 }
1558 
1559 /** Switch to a different input buffer.
1560  * @param new_buffer The new input buffer.
1561  * @param yyscanner The scanner object.
1562  */
1563  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1564 {
1565  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1566 
1567  /* TODO. We should be able to replace this entire function body
1568  * with
1569  * yypop_buffer_state();
1570  * yypush_buffer_state(new_buffer);
1571  */
1572  yyensure_buffer_stack (yyscanner);
1573  if ( YY_CURRENT_BUFFER == new_buffer )
1574  return;
1575 
1576  if ( YY_CURRENT_BUFFER )
1577  {
1578  /* Flush out information for old buffer. */
1579  *yyg->yy_c_buf_p = yyg->yy_hold_char;
1580  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1581  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1582  }
1583 
1584  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1585  yy_load_buffer_state( yyscanner );
1586 
1587  /* We don't actually know whether we did this switch during
1588  * EOF (yywrap()) processing, but the only time this flag
1589  * is looked at is after yywrap() is called, so it's safe
1590  * to go ahead and always set it.
1591  */
1592  yyg->yy_did_buffer_switch_on_eof = 1;
1593 }
1594 
1595 static void yy_load_buffer_state (yyscan_t yyscanner)
1596 {
1597  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1598  yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1599  yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1600  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1601  yyg->yy_hold_char = *yyg->yy_c_buf_p;
1602 }
1603 
1604 /** Allocate and initialize an input buffer state.
1605  * @param file A readable stream.
1606  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1607  * @param yyscanner The scanner object.
1608  * @return the allocated buffer state.
1609  */
1610  YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
1611 {
1612  YY_BUFFER_STATE b;
1613 
1614  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
1615  if ( ! b )
1616  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1617 
1618  b->yy_buf_size = size;
1619 
1620  /* yy_ch_buf has to be 2 characters longer than the size given because
1621  * we need to put in 2 end-of-buffer characters.
1622  */
1623  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
1624  if ( ! b->yy_ch_buf )
1625  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1626 
1627  b->yy_is_our_buffer = 1;
1628 
1629  yy_init_buffer( b, file , yyscanner);
1630 
1631  return b;
1632 }
1633 
1634 /** Destroy the buffer.
1635  * @param b a buffer created with yy_create_buffer()
1636  * @param yyscanner The scanner object.
1637  */
1638  void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1639 {
1640  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1641 
1642  if ( ! b )
1643  return;
1644 
1645  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1646  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1647 
1648  if ( b->yy_is_our_buffer )
1649  yyfree( (void *) b->yy_ch_buf , yyscanner );
1650 
1651  yyfree( (void *) b , yyscanner );
1652 }
1653 
1654 /* Initializes or reinitializes a buffer.
1655  * This function is sometimes called more than once on the same buffer,
1656  * such as during a yyrestart() or at EOF.
1657  */
1658  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1659 
1660 {
1661  int oerrno = errno;
1662  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1663 
1664  yy_flush_buffer( b , yyscanner);
1665 
1666  b->yy_input_file = file;
1667  b->yy_fill_buffer = 1;
1668 
1669  /* If b is the current buffer, then yy_init_buffer was _probably_
1670  * called from yyrestart() or through yy_get_next_buffer.
1671  * In that case, we don't want to reset the lineno or column.
1672  */
1673  if (b != YY_CURRENT_BUFFER){
1674  b->yy_bs_lineno = 1;
1675  b->yy_bs_column = 0;
1676  }
1677 
1678  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1679 
1680  errno = oerrno;
1681 }
1682 
1683 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1684  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1685  * @param yyscanner The scanner object.
1686  */
1687  void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1688 {
1689  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1690  if ( ! b )
1691  return;
1692 
1693  b->yy_n_chars = 0;
1694 
1695  /* We always need two end-of-buffer characters. The first causes
1696  * a transition to the end-of-buffer state. The second causes
1697  * a jam in that state.
1698  */
1699  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1700  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1701 
1702  b->yy_buf_pos = &b->yy_ch_buf[0];
1703 
1704  b->yy_at_bol = 1;
1705  b->yy_buffer_status = YY_BUFFER_NEW;
1706 
1707  if ( b == YY_CURRENT_BUFFER )
1708  yy_load_buffer_state( yyscanner );
1709 }
1710 
1711 /** Pushes the new state onto the stack. The new state becomes
1712  * the current state. This function will allocate the stack
1713  * if necessary.
1714  * @param new_buffer The new state.
1715  * @param yyscanner The scanner object.
1716  */
1717 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1718 {
1719  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1720  if (new_buffer == NULL)
1721  return;
1722 
1723  yyensure_buffer_stack(yyscanner);
1724 
1725  /* This block is copied from yy_switch_to_buffer. */
1726  if ( YY_CURRENT_BUFFER )
1727  {
1728  /* Flush out information for old buffer. */
1729  *yyg->yy_c_buf_p = yyg->yy_hold_char;
1730  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1731  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1732  }
1733 
1734  /* Only push if top exists. Otherwise, replace top. */
1735  if (YY_CURRENT_BUFFER)
1736  yyg->yy_buffer_stack_top++;
1737  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1738 
1739  /* copied from yy_switch_to_buffer. */
1740  yy_load_buffer_state( yyscanner );
1741  yyg->yy_did_buffer_switch_on_eof = 1;
1742 }
1743 
1744 /** Removes and deletes the top of the stack, if present.
1745  * The next element becomes the new top.
1746  * @param yyscanner The scanner object.
1747  */
1748 void yypop_buffer_state (yyscan_t yyscanner)
1749 {
1750  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1751  if (!YY_CURRENT_BUFFER)
1752  return;
1753 
1754  yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
1755  YY_CURRENT_BUFFER_LVALUE = NULL;
1756  if (yyg->yy_buffer_stack_top > 0)
1757  --yyg->yy_buffer_stack_top;
1758 
1759  if (YY_CURRENT_BUFFER) {
1760  yy_load_buffer_state( yyscanner );
1761  yyg->yy_did_buffer_switch_on_eof = 1;
1762  }
1763 }
1764 
1765 /* Allocates the stack if it does not exist.
1766  * Guarantees space for at least one push.
1767  */
1768 static void yyensure_buffer_stack (yyscan_t yyscanner)
1769 {
1770  yy_size_t num_to_alloc;
1771  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1772 
1773  if (!yyg->yy_buffer_stack) {
1774 
1775  /* First allocation is just for 2 elements, since we don't know if this
1776  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1777  * immediate realloc on the next call.
1778  */
1779  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1780  yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
1781  (num_to_alloc * sizeof(struct yy_buffer_state*)
1782  , yyscanner);
1783  if ( ! yyg->yy_buffer_stack )
1784  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1785 
1786  memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1787 
1788  yyg->yy_buffer_stack_max = num_to_alloc;
1789  yyg->yy_buffer_stack_top = 0;
1790  return;
1791  }
1792 
1793  if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1794 
1795  /* Increase the buffer to prepare for a possible push. */
1796  yy_size_t grow_size = 8 /* arbitrary grow size */;
1797 
1798  num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1799  yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
1800  (yyg->yy_buffer_stack,
1801  num_to_alloc * sizeof(struct yy_buffer_state*)
1802  , yyscanner);
1803  if ( ! yyg->yy_buffer_stack )
1804  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1805 
1806  /* zero only the new slots.*/
1807  memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1808  yyg->yy_buffer_stack_max = num_to_alloc;
1809  }
1810 }
1811 
1812 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1813  * @param base the character buffer
1814  * @param size the size in bytes of the character buffer
1815  * @param yyscanner The scanner object.
1816  * @return the newly allocated buffer state object.
1817  */
1818 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
1819 {
1820  YY_BUFFER_STATE b;
1821 
1822  if ( size < 2 ||
1823  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1824  base[size-1] != YY_END_OF_BUFFER_CHAR )
1825  /* They forgot to leave room for the EOB's. */
1826  return NULL;
1827 
1828  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
1829  if ( ! b )
1830  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1831 
1832  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1833  b->yy_buf_pos = b->yy_ch_buf = base;
1834  b->yy_is_our_buffer = 0;
1835  b->yy_input_file = NULL;
1836  b->yy_n_chars = b->yy_buf_size;
1837  b->yy_is_interactive = 0;
1838  b->yy_at_bol = 1;
1839  b->yy_fill_buffer = 0;
1840  b->yy_buffer_status = YY_BUFFER_NEW;
1841 
1842  yy_switch_to_buffer( b , yyscanner );
1843 
1844  return b;
1845 }
1846 
1847 /** Setup the input buffer state to scan a string. The next call to yylex() will
1848  * scan from a @e copy of @a str.
1849  * @param yystr a NUL-terminated string to scan
1850  * @param yyscanner The scanner object.
1851  * @return the newly allocated buffer state object.
1852  * @note If you want to scan bytes that may contain NUL values, then use
1853  * yy_scan_bytes() instead.
1854  */
1855 YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
1856 {
1857 
1858  return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
1859 }
1860 
1861 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1862  * scan from a @e copy of @a bytes.
1863  * @param yybytes the byte buffer to scan
1864  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1865  * @param yyscanner The scanner object.
1866  * @return the newly allocated buffer state object.
1867  */
1868 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
1869 {
1870  YY_BUFFER_STATE b;
1871  char *buf;
1872  yy_size_t n;
1873  int i;
1874 
1875  /* Get memory for full buffer, including space for trailing EOB's. */
1876  n = (yy_size_t) (_yybytes_len + 2);
1877  buf = (char *) yyalloc( n , yyscanner );
1878  if ( ! buf )
1879  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1880 
1881  for ( i = 0; i < _yybytes_len; ++i )
1882  buf[i] = yybytes[i];
1883 
1884  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1885 
1886  b = yy_scan_buffer( buf, n , yyscanner);
1887  if ( ! b )
1888  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1889 
1890  /* It's okay to grow etc. this buffer, and we should throw it
1891  * away when we're done.
1892  */
1893  b->yy_is_our_buffer = 1;
1894 
1895  return b;
1896 }
1897 
1898 #ifndef YY_EXIT_FAILURE
1899 #define YY_EXIT_FAILURE 2
1900 #endif
1901 
1902 static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
1903 {
1904  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1905  (void)yyg;
1906  fprintf( stderr, "%s\n", msg );
1907  exit( YY_EXIT_FAILURE );
1908 }
1909 
1910 /* Redefine yyless() so it works in section 3 code. */
1911 
1912 #undef yyless
1913 #define yyless(n) \
1914  do \
1915  { \
1916  /* Undo effects of setting up yytext. */ \
1917  int yyless_macro_arg = (n); \
1918  YY_LESS_LINENO(yyless_macro_arg);\
1919  yytext[yyleng] = yyg->yy_hold_char; \
1920  yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1921  yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1922  *yyg->yy_c_buf_p = '\0'; \
1923  yyleng = yyless_macro_arg; \
1924  } \
1925  while ( 0 )
1926 
1927 /* Accessor methods (get/set functions) to struct members. */
1928 
1929 /** Get the user-defined data for this scanner.
1930  * @param yyscanner The scanner object.
1931  */
1932 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1933 {
1934  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1935  return yyextra;
1936 }
1937 
1938 /** Get the current line number.
1939  * @param yyscanner The scanner object.
1940  */
1941 int yyget_lineno (yyscan_t yyscanner)
1942 {
1943  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1944 
1945  if (! YY_CURRENT_BUFFER)
1946  return 0;
1947 
1948  return yylineno;
1949 }
1950 
1951 /** Get the current column number.
1952  * @param yyscanner The scanner object.
1953  */
1954 int yyget_column (yyscan_t yyscanner)
1955 {
1956  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1957 
1958  if (! YY_CURRENT_BUFFER)
1959  return 0;
1960 
1961  return yycolumn;
1962 }
1963 
1964 /** Get the input stream.
1965  * @param yyscanner The scanner object.
1966  */
1967 FILE *yyget_in (yyscan_t yyscanner)
1968 {
1969  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1970  return yyin;
1971 }
1972 
1973 /** Get the output stream.
1974  * @param yyscanner The scanner object.
1975  */
1976 FILE *yyget_out (yyscan_t yyscanner)
1977 {
1978  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1979  return yyout;
1980 }
1981 
1982 /** Get the length of the current token.
1983  * @param yyscanner The scanner object.
1984  */
1985 int yyget_leng (yyscan_t yyscanner)
1986 {
1987  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1988  return yyleng;
1989 }
1990 
1991 /** Get the current token.
1992  * @param yyscanner The scanner object.
1993  */
1994 
1995 char *yyget_text (yyscan_t yyscanner)
1996 {
1997  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1998  return yytext;
1999 }
2000 
2001 /** Set the user-defined data. This data is never touched by the scanner.
2002  * @param user_defined The data to be associated with this scanner.
2003  * @param yyscanner The scanner object.
2004  */
2005 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2006 {
2007  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2008  yyextra = user_defined ;
2009 }
2010 
2011 /** Set the current line number.
2012  * @param _line_number line number
2013  * @param yyscanner The scanner object.
2014  */
2015 void yyset_lineno (int _line_number , yyscan_t yyscanner)
2016 {
2017  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2018 
2019  /* lineno is only valid if an input buffer exists. */
2020  if (! YY_CURRENT_BUFFER )
2021  YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
2022 
2023  yylineno = _line_number;
2024 }
2025 
2026 /** Set the current column.
2027  * @param _column_no column number
2028  * @param yyscanner The scanner object.
2029  */
2030 void yyset_column (int _column_no , yyscan_t yyscanner)
2031 {
2032  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2033 
2034  /* column is only valid if an input buffer exists. */
2035  if (! YY_CURRENT_BUFFER )
2036  YY_FATAL_ERROR( "yyset_column called with no buffer" );
2037 
2038  yycolumn = _column_no;
2039 }
2040 
2041 /** Set the input stream. This does not discard the current
2042  * input buffer.
2043  * @param _in_str A readable stream.
2044  * @param yyscanner The scanner object.
2045  * @see yy_switch_to_buffer
2046  */
2047 void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2048 {
2049  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2050  yyin = _in_str ;
2051 }
2052 
2053 void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2054 {
2055  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2056  yyout = _out_str ;
2057 }
2058 
2059 int yyget_debug (yyscan_t yyscanner)
2060 {
2061  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2062  return yy_flex_debug;
2063 }
2064 
2065 void yyset_debug (int _bdebug , yyscan_t yyscanner)
2066 {
2067  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2068  yy_flex_debug = _bdebug ;
2069 }
2070 
2071 /* Accessor methods for yylval and yylloc */
2072 
2073 YYSTYPE * yyget_lval (yyscan_t yyscanner)
2074 {
2075  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2076  return yylval;
2077 }
2078 
2079 void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
2080 {
2081  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2082  yylval = yylval_param;
2083 }
2084 
2085 YYLTYPE *yyget_lloc (yyscan_t yyscanner)
2086 {
2087  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2088  return yylloc;
2089 }
2090 
2091 void yyset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner)
2092 {
2093  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2094  yylloc = yylloc_param;
2095 }
2096 
2097 /* User-visible API */
2098 
2099 /* yylex_init is special because it creates the scanner itself, so it is
2100  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2101  * That's why we explicitly handle the declaration, instead of using our macros.
2102  */
2103 int yylex_init(yyscan_t* ptr_yy_globals)
2104 {
2105  if (ptr_yy_globals == NULL){
2106  errno = EINVAL;
2107  return 1;
2108  }
2109 
2110  *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2111 
2112  if (*ptr_yy_globals == NULL){
2113  errno = ENOMEM;
2114  return 1;
2115  }
2116 
2117  /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2118  memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2119 
2120  return yy_init_globals ( *ptr_yy_globals );
2121 }
2122 
2123 /* yylex_init_extra has the same functionality as yylex_init, but follows the
2124  * convention of taking the scanner as the last argument. Note however, that
2125  * this is a *pointer* to a scanner, as it will be allocated by this call (and
2126  * is the reason, too, why this function also must handle its own declaration).
2127  * The user defined value in the first argument will be available to yyalloc in
2128  * the yyextra field.
2129  */
2130 int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
2131 {
2132  struct yyguts_t dummy_yyguts;
2133 
2134  yyset_extra (yy_user_defined, &dummy_yyguts);
2135 
2136  if (ptr_yy_globals == NULL){
2137  errno = EINVAL;
2138  return 1;
2139  }
2140 
2141  *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2142 
2143  if (*ptr_yy_globals == NULL){
2144  errno = ENOMEM;
2145  return 1;
2146  }
2147 
2148  /* By setting to 0xAA, we expose bugs in
2149  yy_init_globals. Leave at 0x00 for releases. */
2150  memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2151 
2152  yyset_extra (yy_user_defined, *ptr_yy_globals);
2153 
2154  return yy_init_globals ( *ptr_yy_globals );
2155 }
2156 
2157 static int yy_init_globals (yyscan_t yyscanner)
2158 {
2159  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2160  /* Initialization is the same as for the non-reentrant scanner.
2161  * This function is called from yylex_destroy(), so don't allocate here.
2162  */
2163 
2164  yyg->yy_buffer_stack = NULL;
2165  yyg->yy_buffer_stack_top = 0;
2166  yyg->yy_buffer_stack_max = 0;
2167  yyg->yy_c_buf_p = NULL;
2168  yyg->yy_init = 0;
2169  yyg->yy_start = 0;
2170 
2171  yyg->yy_start_stack_ptr = 0;
2172  yyg->yy_start_stack_depth = 0;
2173  yyg->yy_start_stack = NULL;
2174 
2175 /* Defined in main.c */
2176 #ifdef YY_STDINIT
2177  yyin = stdin;
2178  yyout = stdout;
2179 #else
2180  yyin = NULL;
2181  yyout = NULL;
2182 #endif
2183 
2184  /* For future reference: Set errno on error, since we are called by
2185  * yylex_init()
2186  */
2187  return 0;
2188 }
2189 
2190 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2191 int yylex_destroy (yyscan_t yyscanner)
2192 {
2193  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2194 
2195  /* Pop the buffer stack, destroying each element. */
2196  while(YY_CURRENT_BUFFER){
2197  yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
2198  YY_CURRENT_BUFFER_LVALUE = NULL;
2199  yypop_buffer_state(yyscanner);
2200  }
2201 
2202  /* Destroy the stack itself. */
2203  yyfree(yyg->yy_buffer_stack , yyscanner);
2204  yyg->yy_buffer_stack = NULL;
2205 
2206  /* Destroy the start condition stack. */
2207  yyfree( yyg->yy_start_stack , yyscanner );
2208  yyg->yy_start_stack = NULL;
2209 
2210  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2211  * yylex() is called, initialization will occur. */
2212  yy_init_globals( yyscanner);
2213 
2214  /* Destroy the main struct (reentrant only). */
2215  yyfree ( yyscanner , yyscanner );
2216  yyscanner = NULL;
2217  return 0;
2218 }
2219 
2220 /*
2221  * Internal utility routines.
2222  */
2223 
2224 #ifndef yytext_ptr
2225 static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
2226 {
2227  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2228  (void)yyg;
2229 
2230  int i;
2231  for ( i = 0; i < n; ++i )
2232  s1[i] = s2[i];
2233 }
2234 #endif
2235 
2236 #ifdef YY_NEED_STRLEN
2237 static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
2238 {
2239  int n;
2240  for ( n = 0; s[n]; ++n )
2241  ;
2242 
2243  return n;
2244 }
2245 #endif
2246 
2247 void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2248 {
2249  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2250  (void)yyg;
2251  return malloc(size);
2252 }
2253 
2254 void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2255 {
2256  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2257  (void)yyg;
2258 
2259  /* The cast to (char *) in the following accommodates both
2260  * implementations that use char* generic pointers, and those
2261  * that use void* generic pointers. It works with the latter
2262  * because both ANSI C and C++ allow castless assignment from
2263  * any pointer type to void*, and deal with argument conversions
2264  * as though doing an assignment.
2265  */
2266  return realloc(ptr, size);
2267 }
2268 
2269 void yyfree (void * ptr , yyscan_t yyscanner)
2270 {
2271  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2272  (void)yyg;
2273  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2274 }
2275 
2276 #define YYTABLES_NAME "yytables"
2277 
2278 #line 56 "lib/route/pktloc_grammar.l"
size_t yy_buffer_stack_top
index of top of stack.
int yy_bs_lineno
The line count.
size_t yy_buffer_stack_max
capacity of stack.
int yy_bs_column
The column count.
YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.