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