Kea: netconf_lexer.cc Source File

| Kea 2.2.0

netconf_lexer.cc
Go to the documentation of this file.
1#line 1 "netconf_lexer.cc"
2
3#line 3 "netconf_lexer.cc"
4
5#define YY_INT_ALIGNED short int
6
7/* A lexical scanner generated by flex */
8
9/* %not-for-header */
10/* %if-c-only */
11/* %if-not-reentrant */
12#define yy_create_buffer netconf__create_buffer
13#define yy_delete_buffer netconf__delete_buffer
14#define yy_scan_buffer netconf__scan_buffer
15#define yy_scan_string netconf__scan_string
16#define yy_scan_bytes netconf__scan_bytes
17#define yy_init_buffer netconf__init_buffer
18#define yy_flush_buffer netconf__flush_buffer
19#define yy_load_buffer_state netconf__load_buffer_state
20#define yy_switch_to_buffer netconf__switch_to_buffer
21#define yypush_buffer_state netconf_push_buffer_state
22#define yypop_buffer_state netconf_pop_buffer_state
23#define yyensure_buffer_stack netconf_ensure_buffer_stack
24#define yy_flex_debug netconf__flex_debug
25#define yyin netconf_in
26#define yyleng netconf_leng
27#define yylex netconf_lex
28#define yylineno netconf_lineno
29#define yyout netconf_out
30#define yyrestart netconf_restart
31#define yytext netconf_text
32#define yywrap netconf_wrap
33#define yyalloc netconf_alloc
34#define yyrealloc netconf_realloc
35#define yyfree netconf_free
36
37/* %endif */
38/* %endif */
39/* %ok-for-header */
40
41#define FLEX_SCANNER
42#define YY_FLEX_MAJOR_VERSION 2
43#define YY_FLEX_MINOR_VERSION 6
44#define YY_FLEX_SUBMINOR_VERSION 4
45#if YY_FLEX_SUBMINOR_VERSION > 0
46#define FLEX_BETA
47#endif
48
49/* %if-c++-only */
50/* %endif */
51
52/* %if-c-only */
53#ifdef yy_create_buffer
54#define netconf__create_buffer_ALREADY_DEFINED
55#else
56#define yy_create_buffer netconf__create_buffer
57#endif
58
59#ifdef yy_delete_buffer
60#define netconf__delete_buffer_ALREADY_DEFINED
61#else
62#define yy_delete_buffer netconf__delete_buffer
63#endif
64
65#ifdef yy_scan_buffer
66#define netconf__scan_buffer_ALREADY_DEFINED
67#else
68#define yy_scan_buffer netconf__scan_buffer
69#endif
70
71#ifdef yy_scan_string
72#define netconf__scan_string_ALREADY_DEFINED
73#else
74#define yy_scan_string netconf__scan_string
75#endif
76
77#ifdef yy_scan_bytes
78#define netconf__scan_bytes_ALREADY_DEFINED
79#else
80#define yy_scan_bytes netconf__scan_bytes
81#endif
82
83#ifdef yy_init_buffer
84#define netconf__init_buffer_ALREADY_DEFINED
85#else
86#define yy_init_buffer netconf__init_buffer
87#endif
88
89#ifdef yy_flush_buffer
90#define netconf__flush_buffer_ALREADY_DEFINED
91#else
92#define yy_flush_buffer netconf__flush_buffer
93#endif
94
95#ifdef yy_load_buffer_state
96#define netconf__load_buffer_state_ALREADY_DEFINED
97#else
98#define yy_load_buffer_state netconf__load_buffer_state
99#endif
100
101#ifdef yy_switch_to_buffer
102#define netconf__switch_to_buffer_ALREADY_DEFINED
103#else
104#define yy_switch_to_buffer netconf__switch_to_buffer
105#endif
106
107#ifdef yypush_buffer_state
108#define netconf_push_buffer_state_ALREADY_DEFINED
109#else
110#define yypush_buffer_state netconf_push_buffer_state
111#endif
112
113#ifdef yypop_buffer_state
114#define netconf_pop_buffer_state_ALREADY_DEFINED
115#else
116#define yypop_buffer_state netconf_pop_buffer_state
117#endif
118
119#ifdef yyensure_buffer_stack
120#define netconf_ensure_buffer_stack_ALREADY_DEFINED
121#else
122#define yyensure_buffer_stack netconf_ensure_buffer_stack
123#endif
124
125#ifdef yylex
126#define netconf_lex_ALREADY_DEFINED
127#else
128#define yylex netconf_lex
129#endif
130
131#ifdef yyrestart
132#define netconf_restart_ALREADY_DEFINED
133#else
134#define yyrestart netconf_restart
135#endif
136
137#ifdef yylex_init
138#define netconf_lex_init_ALREADY_DEFINED
139#else
140#define yylex_init netconf_lex_init
141#endif
142
143#ifdef yylex_init_extra
144#define netconf_lex_init_extra_ALREADY_DEFINED
145#else
146#define yylex_init_extra netconf_lex_init_extra
147#endif
148
149#ifdef yylex_destroy
150#define netconf_lex_destroy_ALREADY_DEFINED
151#else
152#define yylex_destroy netconf_lex_destroy
153#endif
154
155#ifdef yyget_debug
156#define netconf_get_debug_ALREADY_DEFINED
157#else
158#define yyget_debug netconf_get_debug
159#endif
160
161#ifdef yyset_debug
162#define netconf_set_debug_ALREADY_DEFINED
163#else
164#define yyset_debug netconf_set_debug
165#endif
166
167#ifdef yyget_extra
168#define netconf_get_extra_ALREADY_DEFINED
169#else
170#define yyget_extra netconf_get_extra
171#endif
172
173#ifdef yyset_extra
174#define netconf_set_extra_ALREADY_DEFINED
175#else
176#define yyset_extra netconf_set_extra
177#endif
178
179#ifdef yyget_in
180#define netconf_get_in_ALREADY_DEFINED
181#else
182#define yyget_in netconf_get_in
183#endif
184
185#ifdef yyset_in
186#define netconf_set_in_ALREADY_DEFINED
187#else
188#define yyset_in netconf_set_in
189#endif
190
191#ifdef yyget_out
192#define netconf_get_out_ALREADY_DEFINED
193#else
194#define yyget_out netconf_get_out
195#endif
196
197#ifdef yyset_out
198#define netconf_set_out_ALREADY_DEFINED
199#else
200#define yyset_out netconf_set_out
201#endif
202
203#ifdef yyget_leng
204#define netconf_get_leng_ALREADY_DEFINED
205#else
206#define yyget_leng netconf_get_leng
207#endif
208
209#ifdef yyget_text
210#define netconf_get_text_ALREADY_DEFINED
211#else
212#define yyget_text netconf_get_text
213#endif
214
215#ifdef yyget_lineno
216#define netconf_get_lineno_ALREADY_DEFINED
217#else
218#define yyget_lineno netconf_get_lineno
219#endif
220
221#ifdef yyset_lineno
222#define netconf_set_lineno_ALREADY_DEFINED
223#else
224#define yyset_lineno netconf_set_lineno
225#endif
226
227#ifdef yywrap
228#define netconf_wrap_ALREADY_DEFINED
229#else
230#define yywrap netconf_wrap
231#endif
232
233/* %endif */
234
235#ifdef yyalloc
236#define netconf_alloc_ALREADY_DEFINED
237#else
238#define yyalloc netconf_alloc
239#endif
240
241#ifdef yyrealloc
242#define netconf_realloc_ALREADY_DEFINED
243#else
244#define yyrealloc netconf_realloc
245#endif
246
247#ifdef yyfree
248#define netconf_free_ALREADY_DEFINED
249#else
250#define yyfree netconf_free
251#endif
252
253/* %if-c-only */
254
255#ifdef yytext
256#define netconf_text_ALREADY_DEFINED
257#else
258#define yytext netconf_text
259#endif
260
261#ifdef yyleng
262#define netconf_leng_ALREADY_DEFINED
263#else
264#define yyleng netconf_leng
265#endif
266
267#ifdef yyin
268#define netconf_in_ALREADY_DEFINED
269#else
270#define yyin netconf_in
271#endif
272
273#ifdef yyout
274#define netconf_out_ALREADY_DEFINED
275#else
276#define yyout netconf_out
277#endif
278
279#ifdef yy_flex_debug
280#define netconf__flex_debug_ALREADY_DEFINED
281#else
282#define yy_flex_debug netconf__flex_debug
283#endif
284
285#ifdef yylineno
286#define netconf_lineno_ALREADY_DEFINED
287#else
288#define yylineno netconf_lineno
289#endif
290
291/* %endif */
292
293/* First, we deal with platform-specific or compiler-specific issues. */
294
295/* begin standard C headers. */
296/* %if-c-only */
297#include <stdio.h>
298#include <string.h>
299#include <errno.h>
300#include <stdlib.h>
301/* %endif */
302
303/* %if-tables-serialization */
304/* %endif */
305/* end standard C headers. */
306
307/* %if-c-or-c++ */
308/* flex integer type definitions */
309
310#ifndef FLEXINT_H
311#define FLEXINT_H
312
313/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
314
315#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
316
317/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
318 * if you want the limit (max/min) macros for int types.
319 */
320#ifndef __STDC_LIMIT_MACROS
321#define __STDC_LIMIT_MACROS 1
322#endif
323
324#include <inttypes.h>
325typedef int8_t flex_int8_t;
326typedef uint8_t flex_uint8_t;
327typedef int16_t flex_int16_t;
328typedef uint16_t flex_uint16_t;
329typedef int32_t flex_int32_t;
330typedef uint32_t flex_uint32_t;
331#else
332 typedef signed char flex_int8_t;
333 typedef short int flex_int16_t;
334 typedef int flex_int32_t;
335 typedef unsigned char flex_uint8_t;
336 typedef unsigned short int flex_uint16_t;
337 typedef unsigned int flex_uint32_t;
338
339/* Limits of integral types. */
340#ifndef INT8_MIN
341#define INT8_MIN (-128)
342#endif
343#ifndef INT16_MIN
344#define INT16_MIN (-32767-1)
345#endif
346#ifndef INT32_MIN
347#define INT32_MIN (-2147483647-1)
348#endif
349#ifndef INT8_MAX
350#define INT8_MAX (127)
351#endif
352#ifndef INT16_MAX
353#define INT16_MAX (32767)
354#endif
355#ifndef INT32_MAX
356#define INT32_MAX (2147483647)
357#endif
358#ifndef UINT8_MAX
359#define UINT8_MAX (255U)
360#endif
361#ifndef UINT16_MAX
362#define UINT16_MAX (65535U)
363#endif
364#ifndef UINT32_MAX
365#define UINT32_MAX (4294967295U)
366#endif
367
368#ifndef SIZE_MAX
369#define SIZE_MAX (~(size_t)0)
370#endif
371
372#endif /* ! C99 */
373
374#endif /* ! FLEXINT_H */
375
376/* %endif */
377
378/* begin standard C++ headers. */
379/* %if-c++-only */
380/* %endif */
381
382/* TODO: this is always defined, so inline it */
383#define yyconst const
384
385#if defined(__GNUC__) && __GNUC__ >= 3
386#define yynoreturn __attribute__((__noreturn__))
387#else
388#define yynoreturn
389#endif
390
391/* %not-for-header */
392/* Returned upon end-of-file. */
393#define YY_NULL 0
394/* %ok-for-header */
395
396/* %not-for-header */
397/* Promotes a possibly negative, possibly signed char to an
398 * integer in range [0..255] for use as an array index.
399 */
400#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
401/* %ok-for-header */
402
403/* %if-reentrant */
404/* %endif */
405
406/* %if-not-reentrant */
407
408/* %endif */
409
410/* Enter a start condition. This macro really ought to take a parameter,
411 * but we do it the disgusting crufty way forced on us by the ()-less
412 * definition of BEGIN.
413 */
414#define BEGIN (yy_start) = 1 + 2 *
415/* Translate the current start state into a value that can be later handed
416 * to BEGIN to return to the state. The YYSTATE alias is for lex
417 * compatibility.
418 */
419#define YY_START (((yy_start) - 1) / 2)
420#define YYSTATE YY_START
421/* Action number for EOF rule of a given start state. */
422#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
423/* Special action meaning "start processing a new file". */
424#define YY_NEW_FILE yyrestart( yyin )
425#define YY_END_OF_BUFFER_CHAR 0
426
427/* Size of default input buffer. */
428#ifndef YY_BUF_SIZE
429#ifdef __ia64__
430/* On IA-64, the buffer size is 16k, not 8k.
431 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
432 * Ditto for the __ia64__ case accordingly.
433 */
434#define YY_BUF_SIZE 32768
435#else
436#define YY_BUF_SIZE 16384
437#endif /* __ia64__ */
438#endif
439
440/* The state buf must be large enough to hold one state per character in the main buffer.
441 */
442#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
443
444#ifndef YY_TYPEDEF_YY_BUFFER_STATE
445#define YY_TYPEDEF_YY_BUFFER_STATE
446 typedef struct yy_buffer_state *YY_BUFFER_STATE;
447#endif
448
449#ifndef YY_TYPEDEF_YY_SIZE_T
450#define YY_TYPEDEF_YY_SIZE_T
451 typedef size_t yy_size_t;
452#endif
453
454/* %if-not-reentrant */
455extern int yyleng;
456/* %endif */
457
458/* %if-c-only */
459/* %if-not-reentrant */
460 extern FILE *yyin, *yyout;
461/* %endif */
462/* %endif */
463
464#define EOB_ACT_CONTINUE_SCAN 0
465#define EOB_ACT_END_OF_FILE 1
466#define EOB_ACT_LAST_MATCH 2
467
468 #define YY_LESS_LINENO(n)
469 #define YY_LINENO_REWIND_TO(ptr)
470
471/* Return all but the first "n" matched characters back to the input stream. */
472#define yyless(n) \
473 do \
474 { \
475 /* Undo effects of setting up yytext. */ \
476 int yyless_macro_arg = (n); \
477 YY_LESS_LINENO(yyless_macro_arg);\
478 *yy_cp = (yy_hold_char); \
479 YY_RESTORE_YY_MORE_OFFSET \
480 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
481 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
482 } \
483 while ( 0 )
484#define unput(c) yyunput( c, (yytext_ptr) )
485
486#ifndef YY_STRUCT_YY_BUFFER_STATE
487#define YY_STRUCT_YY_BUFFER_STATE
488struct yy_buffer_state
489 {
490/* %if-c-only */
491 FILE *yy_input_file;
492/* %endif */
493
494/* %if-c++-only */
495/* %endif */
496
497 char *yy_ch_buf; /* input buffer */
498 char *yy_buf_pos; /* current position in input buffer */
499
500 /* Size of input buffer in bytes, not including room for EOB
501 * characters.
502 */
503 int yy_buf_size;
504
505 /* Number of characters read into yy_ch_buf, not including EOB
506 * characters.
507 */
508 int yy_n_chars;
509
510 /* Whether we "own" the buffer - i.e., we know we created it,
511 * and can realloc() it to grow it, and should free() it to
512 * delete it.
513 */
514 int yy_is_our_buffer;
515
516 /* Whether this is an "interactive" input source; if so, and
517 * if we're using stdio for input, then we want to use getc()
518 * instead of fread(), to make sure we stop fetching input after
519 * each newline.
520 */
521 int yy_is_interactive;
522
523 /* Whether we're considered to be at the beginning of a line.
524 * If so, '^' rules will be active on the next match, otherwise
525 * not.
526 */
527 int yy_at_bol;
528
529 int yy_bs_lineno;
530 int yy_bs_column;
532 /* Whether to try to fill the input buffer when we reach the
533 * end of it.
534 */
535 int yy_fill_buffer;
536
537 int yy_buffer_status;
538
539#define YY_BUFFER_NEW 0
540#define YY_BUFFER_NORMAL 1
541 /* When an EOF's been seen but there's still some text to process
542 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
543 * shouldn't try reading from the input source any more. We might
544 * still have a bunch of tokens to match, though, because of
545 * possible backing-up.
546 *
547 * When we actually see the EOF, we change the status to "new"
548 * (via yyrestart()), so that the user can continue scanning by
549 * just pointing yyin at a new input file.
550 */
551#define YY_BUFFER_EOF_PENDING 2
552
553 };
554#endif /* !YY_STRUCT_YY_BUFFER_STATE */
555
556/* %if-c-only Standard (non-C++) definition */
557/* %not-for-header */
558/* %if-not-reentrant */
559
560/* Stack of input buffers. */
561static size_t yy_buffer_stack_top = 0;
562static size_t yy_buffer_stack_max = 0;
563static YY_BUFFER_STATE * yy_buffer_stack = NULL;
564/* %endif */
565/* %ok-for-header */
566
567/* %endif */
568
569/* We provide macros for accessing buffer states in case in the
570 * future we want to put the buffer states in a more general
571 * "scanner state".
572 *
573 * Returns the top of the stack, or NULL.
574 */
575#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
576 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
577 : NULL)
578/* Same as previous macro, but useful when we know that the buffer stack is not
579 * NULL or when we need an lvalue. For internal use only.
580 */
581#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
582
583/* %if-c-only Standard (non-C++) definition */
584
585/* %if-not-reentrant */
586/* %not-for-header */
587/* yy_hold_char holds the character lost when yytext is formed. */
588static char yy_hold_char;
589static int yy_n_chars; /* number of characters read into yy_ch_buf */
590 int yyleng;
591
592/* Points to current character in buffer. */
593static char *yy_c_buf_p = NULL;
594static int yy_init = 0; /* whether we need to initialize */
595static int yy_start = 0; /* start state number */
596
597/* Flag which is used to allow yywrap()'s to do buffer switches
598 * instead of setting up a fresh yyin. A bit of a hack ...
599 */
600static int yy_did_buffer_switch_on_eof;
601/* %ok-for-header */
602
603/* %endif */
604
605void yyrestart ( FILE *input_file );
606void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
607 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
608void yy_delete_buffer ( YY_BUFFER_STATE b );
609void yy_flush_buffer ( YY_BUFFER_STATE b );
610void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
611void yypop_buffer_state ( void );
612
613static void yyensure_buffer_stack ( void );
614static void yy_load_buffer_state ( void );
615static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
616#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
617
618 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
619 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
620 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
621
622/* %endif */
623
624void *yyalloc ( yy_size_t );
625void *yyrealloc ( void *, yy_size_t );
626void yyfree ( void * );
627
628#define yy_new_buffer yy_create_buffer
629#define yy_set_interactive(is_interactive) \
630 { \
631 if ( ! YY_CURRENT_BUFFER ){ \
632 yyensure_buffer_stack (); \
633 YY_CURRENT_BUFFER_LVALUE = \
634 yy_create_buffer( yyin, YY_BUF_SIZE ); \
635 } \
636 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
637 }
638#define yy_set_bol(at_bol) \
639 { \
640 if ( ! YY_CURRENT_BUFFER ){\
641 yyensure_buffer_stack (); \
642 YY_CURRENT_BUFFER_LVALUE = \
643 yy_create_buffer( yyin, YY_BUF_SIZE ); \
644 } \
645 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
646 }
647#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
648
649/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
650/* Begin user sect3 */
651
652#define netconf_wrap() (/*CONSTCOND*/1)
653#define YY_SKIP_YYWRAP
654
655#define FLEX_DEBUG
656 typedef flex_uint8_t YY_CHAR;
657
658FILE *yyin = NULL, *yyout = NULL;
659
660 typedef int yy_state_type;
661
662extern int yylineno;
663 int yylineno = 1;
664
665extern char *yytext;
666#ifdef yytext_ptr
667#undef yytext_ptr
668#endif
669#define yytext_ptr yytext
670
671/* %% [1.5] DFA */
672
673/* %if-c-only Standard (non-C++) definition */
674
675static yy_state_type yy_get_previous_state ( void );
676static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
677static int yy_get_next_buffer ( void );
678static void yynoreturn yy_fatal_error ( const char* msg );
679
680/* %endif */
681
682/* Done after the current pattern has been matched and before the
683 * corresponding action - sets up yytext.
684 */
685#define YY_DO_BEFORE_ACTION \
686 (yytext_ptr) = yy_bp; \
687/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
688 yyleng = (int) (yy_cp - yy_bp); \
689 (yy_hold_char) = *yy_cp; \
690 *yy_cp = '\0'; \
691/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
692 (yy_c_buf_p) = yy_cp;
693/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
694#define YY_NUM_RULES 63
695#define YY_END_OF_BUFFER 64
696/* This struct is not used in this scanner,
697 but its presence is necessary. */
698struct yy_trans_info
699 {
700 flex_int32_t yy_verify;
701 flex_int32_t yy_nxt;
702 };
703static const flex_int16_t yy_accept[362] =
704 { 0,
705 56, 56, 0, 0, 0, 0, 0, 0, 0, 0,
706 64, 62, 10, 11, 62, 1, 56, 53, 56, 56,
707 62, 55, 54, 62, 62, 62, 62, 62, 49, 50,
708 62, 62, 62, 51, 52, 5, 5, 5, 62, 62,
709 62, 10, 11, 0, 0, 44, 0, 0, 0, 0,
710 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
711 0, 1, 56, 56, 0, 55, 56, 3, 2, 6,
712 0, 56, 0, 0, 0, 0, 0, 0, 4, 0,
713 0, 9, 0, 45, 0, 0, 0, 47, 0, 0,
714 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
715
716 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
717 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
718 8, 0, 0, 46, 48, 0, 0, 22, 0, 0,
719 21, 0, 0, 0, 0, 0, 0, 0, 0, 0,
720 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
721 0, 0, 0, 61, 59, 0, 58, 57, 0, 0,
722 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
723 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
724 0, 0, 0, 0, 0, 0, 60, 57, 0, 0,
725 0, 0, 0, 0, 0, 0, 0, 0, 0, 26,
726
727 0, 0, 0, 0, 0, 0, 35, 0, 0, 0,
728 0, 0, 0, 0, 25, 0, 0, 0, 0, 0,
729 0, 0, 0, 19, 20, 38, 0, 0, 0, 0,
730 0, 0, 23, 0, 0, 0, 0, 0, 0, 0,
731 0, 0, 7, 0, 0, 0, 0, 0, 0, 0,
732 0, 0, 0, 40, 37, 0, 0, 0, 0, 0,
733 27, 0, 0, 0, 12, 0, 14, 0, 0, 0,
734 32, 34, 0, 39, 0, 0, 41, 0, 0, 0,
735 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
736 0, 43, 0, 0, 0, 0, 0, 0, 0, 0,
737
738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
739 0, 0, 0, 42, 0, 0, 0, 33, 0, 0,
740 30, 0, 0, 0, 15, 0, 0, 0, 0, 29,
741 28, 0, 0, 0, 0, 0, 0, 0, 0, 13,
742 0, 0, 0, 0, 0, 0, 0, 24, 0, 0,
743 36, 0, 0, 31, 18, 0, 0, 0, 17, 16,
744 0
745 } ;
746
747static const YY_CHAR yy_ec[256] =
748 { 0,
749 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
750 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
751 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
752 1, 4, 5, 6, 7, 5, 5, 5, 5, 5,
753 5, 8, 9, 10, 11, 12, 13, 14, 14, 15,
754 14, 16, 14, 17, 14, 14, 14, 18, 5, 19,
755 5, 20, 21, 5, 22, 23, 23, 23, 24, 25,
756 5, 5, 5, 5, 5, 26, 5, 27, 5, 5,
757 5, 28, 29, 30, 31, 5, 5, 5, 5, 5,
758 32, 33, 34, 5, 35, 5, 36, 37, 38, 39,
759
760 40, 41, 42, 43, 44, 5, 45, 46, 47, 48,
761 49, 50, 5, 51, 52, 53, 54, 55, 5, 56,
762 57, 58, 59, 5, 60, 5, 5, 5, 5, 5,
763 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
764 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
765 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
766 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
767 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
768 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
769 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
770
771 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
772 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
773 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
774 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
775 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
776 5, 5, 5, 5, 5
777 } ;
778
779static const YY_CHAR yy_meta[61] =
780 { 0,
781 1, 1, 2, 1, 1, 3, 1, 1, 1, 1,
782 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
783 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
784 1, 1, 4, 1, 1, 1, 4, 1, 1, 1,
785 4, 1, 1, 1, 1, 1, 1, 4, 1, 1,
786 4, 1, 4, 4, 1, 1, 1, 1, 1, 1
787 } ;
788
789static const flex_int16_t yy_base[371] =
790 { 0,
791 0, 0, 59, 62, 65, 0, 63, 67, 47, 64,
792 286, 2435, 84, 259, 125, 0, 105, 2435, 120, 125,
793 85, 169, 2435, 238, 139, 65, 69, 82, 2435, 2435,
794 80, 84, 118, 2435, 2435, 2435, 92, 205, 168, 0,
795 193, 110, 205, 97, 186, 2435, 193, 184, 201, 209,
796 221, 238, 245, 264, 254, 271, 279, 290, 299, 308,
797 314, 0, 314, 347, 358, 364, 368, 2435, 0, 2435,
798 214, 320, 121, 152, 128, 174, 217, 160, 2435, 168,
799 199, 2435, 137, 2435, 0, 388, 195, 394, 436, 400,
800 410, 422, 429, 462, 477, 483, 490, 499, 505, 511,
801
802 518, 524, 544, 553, 559, 566, 578, 587, 594, 601,
803 616, 622, 0, 223, 223, 255, 224, 242, 259, 130,
804 2435, 634, 155, 2435, 2435, 659, 656, 2435, 645, 684,
805 2435, 700, 709, 717, 723, 729, 737, 743, 771, 780,
806 788, 794, 800, 808, 814, 823, 836, 851, 858, 869,
807 876, 884, 282, 2435, 2435, 300, 2435, 2435, 103, 891,
808 927, 902, 913, 928, 953, 968, 974, 986, 996, 1003,
809 1009, 1019, 1025, 1031, 1042, 1053, 1064, 1075, 1081, 1090,
810 1097, 1103, 1109, 1123, 1132, 1143, 2435, 2435, 112, 1152,
811 1187, 1160, 1172, 1166, 1185, 1231, 1237, 1243, 1249, 2435,
812
813 1255, 1265, 1271, 1277, 1288, 1294, 2435, 1311, 1317, 1323,
814 1335, 1345, 1352, 1359, 2435, 1369, 1380, 64, 1387, 1393,
815 1416, 1428, 1435, 2435, 2435, 2435, 1444, 1450, 1456, 1464,
816 1478, 1490, 2435, 1498, 1511, 1518, 1524, 1534, 1540, 1546,
817 1552, 1559, 2435, 1569, 1580, 1592, 1603, 1614, 1620, 1626,
818 1632, 1638, 1649, 2435, 2435, 1655, 1672, 1678, 1684, 1690,
819 2435, 1696, 1707, 1713, 2435, 1724, 2435, 1733, 1746, 1761,
820 2435, 2435, 1767, 2435, 1774, 1781, 2435, 1787, 1800, 1807,
821 1815, 1825, 1836, 1843, 1849, 1871, 1877, 1884, 1891, 1897,
822 1905, 2435, 1912, 1931, 1938, 1945, 1952, 1960, 1966, 1974,
823
824 1985, 1994, 2002, 2008, 2014, 2022, 2030, 2036, 2042, 2048,
825 2055, 2070, 2076, 2435, 2083, 2089, 2099, 2435, 2105, 2112,
826 2435, 2122, 2134, 2140, 2435, 2148, 2156, 2168, 2176, 2435,
827 2435, 2189, 2196, 2204, 2210, 2217, 2225, 2232, 2238, 2435,
828 2245, 2258, 2266, 2279, 2287, 2294, 2300, 2435, 2308, 2320,
829 2435, 2336, 2342, 2435, 2435, 2348, 2354, 2360, 2435, 2435,
830 2435, 2400, 2404, 2408, 2412, 2416, 2420, 2424, 2426, 2430
831 } ;
832
833static const flex_int16_t yy_def[371] =
834 { 0,
835 361, 1, 362, 362, 1, 5, 5, 5, 5, 5,
836 361, 361, 361, 361, 363, 364, 361, 361, 361, 361,
837 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
838 361, 361, 361, 361, 361, 361, 361, 361, 361, 365,
839 361, 361, 361, 366, 363, 361, 363, 367, 363, 363,
840 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
841 363, 364, 361, 361, 361, 361, 361, 361, 368, 361,
842 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
843 365, 361, 366, 361, 369, 363, 370, 363, 367, 363,
844 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
845
846 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
847 363, 363, 368, 361, 361, 361, 361, 361, 361, 361,
848 361, 363, 370, 361, 361, 89, 363, 361, 363, 363,
849 361, 363, 363, 363, 363, 363, 363, 363, 363, 363,
850 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
851 363, 363, 361, 361, 361, 361, 361, 361, 361, 363,
852 89, 363, 363, 363, 363, 363, 363, 363, 363, 363,
853 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
854 363, 363, 363, 363, 363, 363, 361, 361, 361, 363,
855 89, 363, 363, 363, 363, 363, 363, 363, 363, 361,
856
857 363, 363, 363, 363, 363, 363, 361, 363, 363, 363,
858 363, 363, 363, 363, 361, 363, 363, 361, 363, 363,
859 363, 363, 363, 361, 361, 361, 363, 363, 363, 363,
860 363, 363, 361, 363, 363, 363, 363, 363, 363, 363,
861 363, 363, 361, 363, 363, 363, 363, 363, 363, 363,
862 363, 363, 363, 361, 361, 363, 363, 363, 363, 363,
863 361, 363, 363, 363, 361, 363, 361, 363, 363, 363,
864 361, 361, 363, 361, 363, 363, 361, 363, 363, 363,
865 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
866 363, 361, 363, 363, 363, 363, 363, 363, 363, 363,
867
868 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
869 363, 363, 363, 361, 363, 363, 363, 361, 363, 363,
870 361, 363, 363, 363, 361, 363, 363, 363, 363, 361,
871 361, 363, 363, 363, 363, 363, 363, 363, 363, 361,
872 363, 363, 363, 363, 363, 363, 363, 361, 363, 363,
873 361, 363, 363, 361, 361, 363, 363, 363, 361, 361,
874 0, 361, 361, 361, 361, 361, 361, 361, 361, 361
875 } ;
876
877static const flex_int16_t yy_nxt[2496] =
878 { 0,
879 12, 13, 14, 13, 12, 15, 16, 12, 17, 18,
880 19, 20, 21, 22, 22, 22, 22, 23, 24, 12,
881 12, 12, 12, 25, 26, 12, 27, 12, 12, 28,
882 12, 29, 12, 30, 12, 12, 12, 12, 12, 25,
883 31, 12, 12, 12, 12, 12, 12, 32, 12, 12,
884 12, 12, 33, 12, 12, 12, 12, 12, 34, 35,
885 37, 14, 37, 37, 14, 37, 38, 41, 40, 38,
886 12, 12, 40, 12, 12, 12, 12, 12, 12, 12,
887 12, 12, 12, 12, 41, 42, 73, 42, 12, 12,
888 12, 12, 68, 42, 12, 42, 12, 69, 12, 74,
889
890 73, 73, 84, 243, 12, 12, 12, 12, 39, 75,
891 12, 42, 12, 42, 74, 76, 63, 12, 64, 64,
892 64, 64, 74, 12, 12, 44, 44, 44, 65, 85,
893 46, 63, 75, 66, 66, 66, 66, 77, 67, 67,
894 67, 67, 84, 65, 65, 75, 114, 71, 65, 71,
895 218, 47, 72, 72, 72, 72, 189, 48, 116, 65,
896 124, 49, 50, 51, 65, 52, 114, 53, 78, 85,
897 54, 55, 56, 57, 58, 159, 59, 115, 60, 61,
898 63, 116, 66, 66, 66, 66, 44, 44, 44, 88,
899 116, 46, 65, 44, 44, 44, 45, 115, 46, 114,
900
901 124, 44, 44, 44, 121, 120, 46, 43, 65, 44,
902 44, 44, 82, 119, 46, 80, 45, 79, 48, 117,
903 45, 44, 44, 44, 45, 48, 46, 72, 72, 72,
904 72, 45, 86, 48, 45, 93, 45, 89, 44, 44,
905 44, 48, 115, 46, 91, 44, 44, 44, 154, 90,
906 46, 153, 153, 48, 44, 44, 44, 92, 70, 46,
907 94, 43, 118, 95, 44, 44, 44, 154, 154, 46,
908 48, 44, 44, 44, 153, 156, 46, 48, 155, 44,
909 44, 44, 155, 96, 46, 361, 48, 157, 361, 101,
910 44, 44, 44, 97, 155, 46, 48, 98, 158, 44,
911
912 44, 44, 102, 48, 46, 187, 103, 99, 44, 44,
913 44, 48, 100, 46, 44, 44, 44, 361, 361, 46,
914 361, 187, 48, 187, 361, 105, 361, 67, 67, 67,
915 67, 48, 104, 72, 72, 72, 72, 65, 106, 188,
916 48, 361, 361, 361, 361, 361, 48, 107, 361, 112,
917 361, 108, 109, 65, 361, 110, 361, 361, 63, 111,
918 64, 64, 64, 64, 361, 361, 71, 361, 71, 361,
919 65, 72, 72, 72, 72, 63, 361, 66, 66, 66,
920 66, 67, 67, 67, 67, 361, 65, 65, 44, 44,
921 44, 65, 361, 46, 44, 44, 44, 361, 361, 46,
922
923 44, 44, 44, 65, 361, 46, 361, 65, 361, 361,
924 44, 44, 44, 361, 361, 128, 361, 361, 361, 361,
925 48, 361, 44, 44, 44, 361, 48, 46, 361, 44,
926 44, 44, 48, 361, 131, 361, 361, 361, 361, 361,
927 122, 125, 48, 361, 361, 361, 361, 361, 127, 126,
928 126, 126, 126, 361, 48, 361, 361, 126, 126, 126,
929 126, 48, 44, 44, 44, 361, 361, 46, 129, 130,
930 361, 126, 126, 126, 126, 126, 126, 44, 44, 44,
931 361, 361, 46, 44, 44, 44, 361, 361, 46, 361,
932 44, 44, 44, 361, 48, 46, 361, 361, 132, 44,
933
934 44, 44, 361, 361, 46, 44, 44, 44, 361, 48,
935 46, 44, 44, 44, 133, 48, 46, 361, 44, 44,
936 44, 361, 48, 46, 44, 44, 44, 361, 361, 46,
937 361, 48, 361, 361, 361, 361, 134, 48, 135, 361,
938 361, 137, 361, 48, 44, 44, 44, 361, 361, 46,
939 48, 136, 138, 44, 44, 44, 48, 361, 46, 44,
940 44, 44, 141, 361, 46, 139, 44, 44, 44, 361,
941 361, 46, 361, 140, 361, 361, 48, 361, 44, 44,
942 44, 361, 361, 46, 361, 48, 361, 44, 44, 44,
943 142, 48, 46, 361, 44, 44, 44, 361, 48, 46,
944
945 361, 44, 44, 44, 361, 143, 46, 361, 361, 144,
946 48, 145, 361, 361, 361, 147, 44, 44, 44, 48,
947 146, 46, 44, 44, 44, 148, 48, 46, 361, 361,
948 149, 361, 361, 48, 44, 44, 44, 361, 361, 46,
949 361, 361, 361, 361, 150, 44, 44, 44, 48, 361,
950 46, 361, 361, 361, 48, 151, 44, 44, 44, 361,
951 361, 46, 361, 361, 361, 361, 48, 152, 361, 361,
952 361, 160, 161, 161, 161, 161, 361, 48, 361, 361,
953 161, 161, 161, 161, 44, 44, 44, 361, 48, 46,
954 361, 163, 361, 361, 161, 161, 161, 161, 161, 161,
955
956 44, 44, 44, 361, 361, 46, 361, 361, 162, 44,
957 44, 44, 361, 361, 46, 361, 48, 44, 44, 44,
958 361, 361, 46, 44, 44, 44, 361, 361, 46, 44,
959 44, 44, 48, 361, 46, 361, 164, 44, 44, 44,
960 361, 48, 46, 44, 44, 44, 361, 361, 46, 48,
961 361, 361, 361, 165, 361, 48, 361, 361, 166, 361,
962 361, 48, 361, 361, 361, 361, 361, 168, 167, 48,
963 361, 44, 44, 44, 361, 48, 46, 361, 169, 361,
964 44, 44, 44, 361, 171, 46, 361, 170, 44, 44,
965 44, 361, 361, 46, 44, 44, 44, 361, 361, 46,
966
967 44, 44, 44, 48, 361, 46, 172, 361, 44, 44,
968 44, 361, 48, 46, 44, 44, 44, 361, 361, 46,
969 48, 361, 361, 44, 44, 44, 48, 175, 46, 361,
970 361, 173, 48, 176, 174, 361, 44, 44, 44, 361,
971 48, 46, 361, 178, 361, 361, 48, 361, 361, 177,
972 361, 44, 44, 44, 361, 48, 46, 361, 44, 44,
973 44, 361, 180, 46, 361, 361, 179, 361, 48, 44,
974 44, 44, 361, 361, 46, 361, 44, 44, 44, 361,
975 181, 46, 361, 48, 44, 44, 44, 361, 361, 46,
976 48, 44, 44, 44, 361, 361, 46, 361, 361, 182,
977
978 361, 48, 44, 44, 44, 361, 361, 46, 48, 183,
979 361, 361, 192, 44, 44, 44, 48, 361, 46, 361,
980 361, 361, 361, 48, 184, 361, 185, 186, 44, 44,
981 44, 361, 361, 46, 48, 361, 361, 361, 361, 190,
982 191, 191, 191, 191, 361, 48, 361, 361, 191, 191,
983 191, 191, 193, 44, 44, 44, 361, 361, 46, 361,
984 48, 361, 191, 191, 191, 191, 191, 191, 44, 44,
985 44, 361, 361, 46, 44, 44, 44, 361, 194, 46,
986 361, 361, 361, 196, 197, 48, 44, 44, 44, 361,
987 361, 46, 361, 361, 195, 361, 44, 44, 44, 361,
988
989 48, 200, 361, 44, 44, 44, 48, 361, 46, 44,
990 44, 44, 361, 361, 46, 361, 198, 361, 48, 44,
991 44, 44, 361, 361, 46, 44, 44, 44, 48, 361,
992 46, 44, 44, 44, 361, 48, 46, 199, 201, 361,
993 361, 48, 44, 44, 44, 361, 361, 46, 202, 361,
994 361, 48, 361, 44, 44, 44, 361, 48, 207, 361,
995 203, 361, 361, 48, 44, 44, 44, 361, 204, 46,
996 205, 361, 361, 361, 48, 44, 44, 44, 361, 361,
997 46, 44, 44, 44, 361, 48, 46, 206, 361, 361,
998 44, 44, 44, 361, 361, 46, 48, 44, 44, 44,
999
1000 361, 361, 46, 44, 44, 44, 361, 48, 46, 44,
1001 44, 44, 361, 48, 46, 361, 361, 208, 361, 361,
1002 210, 209, 48, 44, 44, 44, 361, 361, 215, 48,
1003 361, 361, 44, 44, 44, 48, 212, 46, 361, 361,
1004 211, 48, 216, 44, 44, 44, 214, 361, 46, 361,
1005 361, 361, 44, 44, 44, 48, 213, 46, 361, 361,
1006 44, 44, 44, 361, 48, 46, 44, 44, 44, 361,
1007 361, 46, 44, 44, 44, 48, 361, 46, 361, 361,
1008 361, 217, 361, 361, 48, 44, 44, 44, 361, 361,
1009 46, 361, 48, 361, 361, 361, 361, 361, 48, 219,
1010
1011 45, 45, 45, 45, 48, 361, 361, 361, 45, 45,
1012 45, 45, 361, 220, 222, 361, 361, 48, 361, 221,
1013 361, 361, 45, 45, 45, 45, 45, 45, 361, 361,
1014 223, 44, 44, 44, 361, 361, 224, 44, 44, 44,
1015 361, 361, 225, 44, 44, 44, 361, 361, 226, 44,
1016 44, 44, 361, 361, 46, 44, 44, 44, 361, 227,
1017 46, 361, 361, 48, 361, 44, 44, 44, 361, 48,
1018 46, 44, 44, 44, 361, 48, 46, 44, 44, 44,
1019 361, 48, 46, 361, 361, 361, 361, 48, 44, 44,
1020 44, 361, 361, 46, 44, 44, 44, 48, 361, 233,
1021
1022 361, 361, 361, 48, 361, 228, 361, 361, 361, 48,
1023 230, 44, 44, 44, 361, 229, 46, 44, 44, 44,
1024 48, 361, 46, 44, 44, 44, 48, 361, 46, 361,
1025 361, 361, 361, 361, 231, 44, 44, 44, 232, 361,
1026 46, 361, 361, 48, 361, 44, 44, 44, 361, 48,
1027 46, 361, 44, 44, 44, 48, 235, 46, 361, 44,
1028 44, 44, 361, 234, 46, 361, 361, 48, 361, 44,
1029 44, 44, 361, 236, 46, 361, 361, 48, 237, 361,
1030 44, 44, 44, 361, 48, 46, 361, 44, 44, 44,
1031 361, 48, 46, 44, 44, 44, 361, 238, 46, 361,
1032
1033 361, 48, 361, 361, 239, 361, 241, 361, 361, 240,
1034 361, 361, 48, 361, 361, 242, 44, 44, 44, 48,
1035 361, 46, 361, 361, 361, 48, 361, 244, 44, 44,
1036 44, 361, 361, 46, 361, 44, 44, 44, 361, 361,
1037 46, 361, 245, 361, 44, 44, 44, 361, 48, 46,
1038 44, 44, 44, 361, 361, 46, 44, 44, 44, 361,
1039 48, 46, 361, 361, 44, 44, 44, 48, 246, 46,
1040 361, 361, 361, 247, 248, 361, 48, 361, 44, 44,
1041 44, 361, 48, 46, 361, 361, 361, 361, 48, 249,
1042 44, 44, 44, 361, 361, 254, 48, 361, 44, 44,
1043
1044 44, 361, 252, 255, 361, 361, 250, 251, 361, 361,
1045 48, 44, 44, 44, 361, 361, 46, 253, 44, 44,
1046 44, 361, 48, 46, 44, 44, 44, 361, 361, 46,
1047 48, 361, 256, 361, 44, 44, 44, 361, 361, 46,
1048 44, 44, 44, 48, 260, 261, 44, 44, 44, 361,
1049 48, 46, 44, 44, 44, 361, 48, 46, 361, 44,
1050 44, 44, 361, 257, 46, 258, 48, 361, 361, 44,
1051 44, 44, 48, 361, 265, 361, 259, 361, 48, 361,
1052 44, 44, 44, 361, 48, 46, 361, 361, 361, 262,
1053 361, 48, 44, 44, 44, 361, 361, 267, 361, 361,
1054
1055 263, 48, 361, 44, 44, 44, 361, 361, 46, 361,
1056 361, 264, 48, 268, 44, 44, 44, 361, 266, 46,
1057 44, 44, 44, 361, 48, 46, 44, 44, 44, 361,
1058 361, 271, 44, 44, 44, 48, 361, 272, 44, 44,
1059 44, 361, 361, 46, 361, 361, 48, 361, 273, 44,
1060 44, 44, 48, 361, 274, 44, 44, 44, 48, 361,
1061 46, 361, 361, 270, 48, 361, 361, 361, 269, 361,
1062 48, 361, 44, 44, 44, 361, 361, 46, 44, 44,
1063 44, 48, 361, 277, 44, 44, 44, 48, 361, 46,
1064 44, 44, 44, 361, 361, 46, 44, 44, 44, 361,
1065
1066 361, 46, 361, 275, 48, 361, 361, 44, 44, 44,
1067 48, 276, 46, 44, 44, 44, 48, 361, 46, 361,
1068 361, 361, 48, 361, 44, 44, 44, 361, 48, 46,
1069 361, 361, 282, 44, 44, 44, 361, 279, 46, 48,
1070 278, 361, 280, 281, 361, 48, 44, 44, 44, 361,
1071 361, 46, 284, 361, 283, 361, 48, 361, 361, 285,
1072 361, 44, 44, 44, 361, 48, 46, 44, 44, 44,
1073 361, 361, 46, 361, 44, 44, 44, 361, 48, 46,
1074 361, 44, 44, 44, 286, 287, 46, 44, 44, 44,
1075 361, 361, 292, 48, 361, 361, 361, 288, 361, 48,
1076
1077 44, 44, 44, 361, 361, 46, 48, 44, 44, 44,
1078 361, 361, 46, 48, 361, 44, 44, 44, 289, 48,
1079 46, 361, 361, 290, 361, 44, 44, 44, 361, 361,
1080 46, 291, 48, 361, 361, 293, 44, 44, 44, 48,
1081 361, 46, 361, 44, 44, 44, 361, 48, 46, 44,
1082 44, 44, 361, 298, 46, 361, 361, 48, 361, 361,
1083 361, 361, 361, 294, 296, 295, 361, 361, 48, 361,
1084 361, 44, 44, 44, 361, 48, 46, 44, 44, 44,
1085 361, 48, 46, 361, 44, 44, 44, 361, 297, 46,
1086 361, 44, 44, 44, 361, 361, 46, 44, 44, 44,
1087
1088 361, 299, 46, 48, 361, 44, 44, 44, 361, 48,
1089 46, 361, 44, 44, 44, 361, 48, 46, 361, 300,
1090 361, 361, 301, 48, 361, 361, 361, 361, 361, 48,
1091 303, 44, 44, 44, 302, 361, 46, 48, 44, 44,
1092 44, 361, 361, 46, 48, 44, 44, 44, 361, 304,
1093 46, 361, 44, 44, 44, 309, 305, 46, 306, 361,
1094 44, 44, 44, 48, 361, 46, 44, 44, 44, 361,
1095 48, 46, 361, 361, 44, 44, 44, 48, 361, 46,
1096 307, 361, 361, 308, 48, 44, 44, 44, 361, 361,
1097 314, 310, 48, 361, 44, 44, 44, 311, 48, 46,
1098
1099 361, 361, 44, 44, 44, 312, 48, 46, 44, 44,
1100 44, 313, 361, 46, 44, 44, 44, 48, 361, 318,
1101 361, 361, 44, 44, 44, 361, 48, 46, 361, 315,
1102 44, 44, 44, 361, 48, 46, 44, 44, 44, 361,
1103 48, 321, 44, 44, 44, 361, 48, 46, 44, 44,
1104 44, 317, 316, 46, 48, 44, 44, 44, 361, 361,
1105 46, 319, 48, 361, 361, 361, 361, 361, 48, 320,
1106 44, 44, 44, 361, 48, 325, 44, 44, 44, 322,
1107 48, 46, 361, 44, 44, 44, 361, 48, 46, 44,
1108 44, 44, 361, 361, 46, 361, 361, 324, 361, 44,
1109
1110 44, 44, 48, 323, 46, 44, 44, 44, 48, 361,
1111 330, 361, 44, 44, 44, 48, 361, 331, 361, 361,
1112 326, 48, 44, 44, 44, 361, 361, 46, 361, 361,
1113 361, 48, 361, 327, 44, 44, 44, 48, 361, 46,
1114 44, 44, 44, 328, 48, 46, 361, 329, 44, 44,
1115 44, 361, 361, 46, 48, 361, 44, 44, 44, 361,
1116 361, 46, 361, 361, 332, 361, 48, 361, 44, 44,
1117 44, 361, 48, 46, 361, 334, 44, 44, 44, 361,
1118 48, 46, 361, 361, 361, 361, 333, 335, 48, 44,
1119 44, 44, 361, 361, 46, 361, 44, 44, 44, 336,
1120
1121 48, 340, 361, 361, 44, 44, 44, 337, 48, 46,
1122 44, 44, 44, 361, 361, 46, 361, 44, 44, 44,
1123 361, 48, 46, 338, 339, 44, 44, 44, 48, 361,
1124 46, 361, 44, 44, 44, 361, 48, 46, 44, 44,
1125 44, 361, 48, 46, 361, 44, 44, 44, 361, 48,
1126 46, 341, 361, 361, 361, 361, 343, 48, 44, 44,
1127 44, 361, 342, 348, 48, 361, 44, 44, 44, 361,
1128 48, 46, 361, 361, 361, 344, 361, 48, 361, 44,
1129 44, 44, 361, 345, 46, 346, 347, 44, 44, 44,
1130 48, 361, 351, 361, 44, 44, 44, 361, 48, 46,
1131
1132 44, 44, 44, 361, 361, 46, 361, 361, 44, 44,
1133 44, 48, 361, 354, 361, 361, 361, 349, 361, 48,
1134 44, 44, 44, 361, 361, 355, 48, 361, 361, 361,
1135 350, 361, 48, 361, 361, 352, 44, 44, 44, 353,
1136 48, 46, 44, 44, 44, 361, 361, 46, 44, 44,
1137 44, 361, 48, 46, 44, 44, 44, 361, 361, 359,
1138 44, 44, 44, 361, 361, 360, 361, 361, 48, 361,
1139 361, 361, 361, 361, 48, 356, 361, 361, 361, 361,
1140 48, 361, 361, 361, 361, 361, 48, 361, 361, 361,
1141 361, 361, 48, 357, 361, 361, 361, 361, 361, 358,
1142
1143 36, 36, 36, 36, 45, 45, 45, 45, 62, 361,
1144 62, 62, 81, 361, 361, 81, 83, 83, 83, 83,
1145 87, 87, 87, 87, 113, 361, 113, 113, 83, 83,
1146 123, 123, 123, 123, 11, 361, 361, 361, 361, 361,
1147 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1148 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1149 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1150 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1151 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1152 361, 361, 361, 361, 361
1153
1154 } ;
1155
1156static const flex_int16_t yy_chk[2496] =
1157 { 0,
1158 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1159 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1160 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1161 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1162 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1163 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1164 3, 3, 3, 4, 4, 4, 3, 9, 7, 4,
1165 5, 5, 8, 5, 5, 5, 5, 5, 5, 5,
1166 5, 5, 5, 5, 10, 13, 26, 13, 5, 5,
1167 9, 5, 21, 37, 5, 37, 5, 21, 5, 27,
1168
1169 26, 31, 44, 218, 5, 5, 7, 10, 5, 28,
1170 8, 42, 5, 42, 32, 31, 17, 5, 17, 17,
1171 17, 17, 27, 5, 5, 15, 15, 15, 17, 44,
1172 15, 19, 28, 19, 19, 19, 19, 32, 20, 20,
1173 20, 20, 83, 19, 17, 33, 73, 25, 20, 25,
1174 189, 15, 25, 25, 25, 25, 159, 15, 75, 19,
1175 123, 15, 15, 15, 20, 15, 73, 15, 33, 83,
1176 15, 15, 15, 15, 15, 120, 15, 74, 15, 15,
1177 22, 75, 22, 22, 22, 22, 45, 45, 45, 48,
1178 78, 45, 22, 47, 47, 47, 48, 74, 47, 76,
1179
1180 87, 49, 49, 49, 81, 80, 49, 43, 22, 50,
1181 50, 50, 41, 78, 50, 39, 48, 38, 45, 76,
1182 48, 51, 51, 51, 48, 47, 51, 71, 71, 71,
1183 71, 48, 47, 49, 48, 51, 48, 48, 52, 52,
1184 52, 50, 77, 52, 50, 53, 53, 53, 115, 49,
1185 53, 114, 117, 51, 55, 55, 55, 50, 24, 55,
1186 51, 14, 77, 51, 54, 54, 54, 118, 115, 54,
1187 52, 56, 56, 56, 114, 117, 56, 53, 116, 57,
1188 57, 57, 119, 52, 57, 11, 55, 118, 0, 55,
1189 58, 58, 58, 53, 116, 58, 54, 53, 119, 59,
1190
1191 59, 59, 55, 56, 59, 153, 56, 54, 60, 60,
1192 60, 57, 54, 60, 61, 61, 61, 0, 0, 61,
1193 0, 153, 58, 156, 0, 58, 0, 63, 63, 63,
1194 63, 59, 57, 72, 72, 72, 72, 63, 59, 156,
1195 60, 0, 0, 0, 0, 0, 61, 59, 0, 61,
1196 0, 59, 59, 63, 0, 60, 0, 0, 64, 60,
1197 64, 64, 64, 64, 0, 0, 65, 0, 65, 0,
1198 64, 65, 65, 65, 65, 66, 0, 66, 66, 66,
1199 66, 67, 67, 67, 67, 0, 64, 66, 86, 86,
1200 86, 67, 0, 86, 88, 88, 88, 0, 0, 88,
1201
1202 90, 90, 90, 66, 0, 90, 0, 67, 0, 0,
1203 91, 91, 91, 0, 0, 91, 0, 0, 0, 0,
1204 86, 0, 92, 92, 92, 0, 88, 92, 0, 93,
1205 93, 93, 90, 0, 93, 0, 0, 0, 0, 0,
1206 86, 89, 91, 0, 0, 0, 0, 0, 90, 89,
1207 89, 89, 89, 0, 92, 0, 0, 89, 89, 89,
1208 89, 93, 94, 94, 94, 0, 0, 94, 92, 92,
1209 0, 89, 89, 89, 89, 89, 89, 95, 95, 95,
1210 0, 0, 95, 96, 96, 96, 0, 0, 96, 0,
1211 97, 97, 97, 0, 94, 97, 0, 0, 94, 98,
1212
1213 98, 98, 0, 0, 98, 99, 99, 99, 0, 95,
1214 99, 100, 100, 100, 95, 96, 100, 0, 101, 101,
1215 101, 0, 97, 101, 102, 102, 102, 0, 0, 102,
1216 0, 98, 0, 0, 0, 0, 96, 99, 97, 0,
1217 0, 99, 0, 100, 103, 103, 103, 0, 0, 103,
1218 101, 98, 100, 104, 104, 104, 102, 0, 104, 105,
1219 105, 105, 102, 0, 105, 101, 106, 106, 106, 0,
1220 0, 106, 0, 101, 0, 0, 103, 0, 107, 107,
1221 107, 0, 0, 107, 0, 104, 0, 108, 108, 108,
1222 103, 105, 108, 0, 109, 109, 109, 0, 106, 109,
1223
1224 0, 110, 110, 110, 0, 104, 110, 0, 0, 105,
1225 107, 105, 0, 0, 0, 107, 111, 111, 111, 108,
1226 106, 111, 112, 112, 112, 108, 109, 112, 0, 0,
1227 109, 0, 0, 110, 122, 122, 122, 0, 0, 122,
1228 0, 0, 0, 0, 110, 129, 129, 129, 111, 0,
1229 129, 0, 0, 0, 112, 111, 127, 127, 127, 0,
1230 0, 127, 0, 0, 0, 0, 122, 112, 0, 0,
1231 0, 122, 126, 126, 126, 126, 0, 129, 0, 0,
1232 126, 126, 126, 126, 130, 130, 130, 0, 127, 130,
1233 0, 129, 0, 0, 126, 126, 126, 126, 126, 126,
1234
1235 132, 132, 132, 0, 0, 132, 0, 0, 127, 133,
1236 133, 133, 0, 0, 133, 0, 130, 134, 134, 134,
1237 0, 0, 134, 135, 135, 135, 0, 0, 135, 136,
1238 136, 136, 132, 0, 136, 0, 130, 137, 137, 137,
1239 0, 133, 137, 138, 138, 138, 0, 0, 138, 134,
1240 0, 0, 0, 132, 0, 135, 0, 0, 133, 0,
1241 0, 136, 0, 0, 0, 0, 0, 135, 134, 137,
1242 0, 139, 139, 139, 0, 138, 139, 0, 136, 0,
1243 140, 140, 140, 0, 138, 140, 0, 137, 141, 141,
1244 141, 0, 0, 141, 142, 142, 142, 0, 0, 142,
1245
1246 143, 143, 143, 139, 0, 143, 139, 0, 144, 144,
1247 144, 0, 140, 144, 145, 145, 145, 0, 0, 145,
1248 141, 0, 0, 146, 146, 146, 142, 141, 146, 0,
1249 0, 140, 143, 142, 140, 0, 147, 147, 147, 0,
1250 144, 147, 0, 144, 0, 0, 145, 0, 0, 143,
1251 0, 148, 148, 148, 0, 146, 148, 0, 149, 149,
1252 149, 0, 146, 149, 0, 0, 145, 0, 147, 150,
1253 150, 150, 0, 0, 150, 0, 151, 151, 151, 0,
1254 147, 151, 0, 148, 152, 152, 152, 0, 0, 152,
1255 149, 160, 160, 160, 0, 0, 160, 0, 0, 148,
1256
1257 0, 150, 162, 162, 162, 0, 0, 162, 151, 149,
1258 0, 0, 162, 163, 163, 163, 152, 0, 163, 0,
1259 0, 0, 0, 160, 150, 0, 151, 152, 164, 164,
1260 164, 0, 0, 164, 162, 0, 0, 0, 0, 160,
1261 161, 161, 161, 161, 0, 163, 0, 0, 161, 161,
1262 161, 161, 163, 165, 165, 165, 0, 0, 165, 0,
1263 164, 0, 161, 161, 161, 161, 161, 161, 166, 166,
1264 166, 0, 0, 166, 167, 167, 167, 0, 164, 167,
1265 0, 0, 0, 166, 166, 165, 168, 168, 168, 0,
1266 0, 168, 0, 0, 165, 0, 169, 169, 169, 0,
1267
1268 166, 169, 0, 170, 170, 170, 167, 0, 170, 171,
1269 171, 171, 0, 0, 171, 0, 167, 0, 168, 172,
1270 172, 172, 0, 0, 172, 173, 173, 173, 169, 0,
1271 173, 174, 174, 174, 0, 170, 174, 168, 170, 0,
1272 0, 171, 175, 175, 175, 0, 0, 175, 171, 0,
1273 0, 172, 0, 176, 176, 176, 0, 173, 176, 0,
1274 172, 0, 0, 174, 177, 177, 177, 0, 173, 177,
1275 174, 0, 0, 0, 175, 178, 178, 178, 0, 0,
1276 178, 179, 179, 179, 0, 176, 179, 175, 0, 0,
1277 180, 180, 180, 0, 0, 180, 177, 181, 181, 181,
1278
1279 0, 0, 181, 182, 182, 182, 0, 178, 182, 183,
1280 183, 183, 0, 179, 183, 0, 0, 177, 0, 0,
1281 179, 178, 180, 184, 184, 184, 0, 0, 184, 181,
1282 0, 0, 185, 185, 185, 182, 181, 185, 0, 0,
1283 180, 183, 185, 186, 186, 186, 183, 0, 186, 0,
1284 0, 0, 190, 190, 190, 184, 182, 190, 0, 0,
1285 192, 192, 192, 0, 185, 192, 194, 194, 194, 0,
1286 0, 194, 193, 193, 193, 186, 0, 193, 0, 0,
1287 0, 186, 0, 0, 190, 195, 195, 195, 0, 0,
1288 195, 0, 192, 0, 0, 0, 0, 0, 194, 190,
1289
1290 191, 191, 191, 191, 193, 0, 0, 0, 191, 191,
1291 191, 191, 0, 192, 194, 0, 0, 195, 0, 193,
1292 0, 0, 191, 191, 191, 191, 191, 191, 0, 0,
1293 195, 196, 196, 196, 0, 0, 196, 197, 197, 197,
1294 0, 0, 197, 198, 198, 198, 0, 0, 198, 199,
1295 199, 199, 0, 0, 199, 201, 201, 201, 0, 199,
1296 201, 0, 0, 196, 0, 202, 202, 202, 0, 197,
1297 202, 203, 203, 203, 0, 198, 203, 204, 204, 204,
1298 0, 199, 204, 0, 0, 0, 0, 201, 205, 205,
1299 205, 0, 0, 205, 206, 206, 206, 202, 0, 206,
1300
1301 0, 0, 0, 203, 0, 201, 0, 0, 0, 204,
1302 203, 208, 208, 208, 0, 202, 208, 209, 209, 209,
1303 205, 0, 209, 210, 210, 210, 206, 0, 210, 0,
1304 0, 0, 0, 0, 204, 211, 211, 211, 205, 0,
1305 211, 0, 0, 208, 0, 212, 212, 212, 0, 209,
1306 212, 0, 213, 213, 213, 210, 209, 213, 0, 214,
1307 214, 214, 0, 208, 214, 0, 0, 211, 0, 216,
1308 216, 216, 0, 210, 216, 0, 0, 212, 211, 0,
1309 217, 217, 217, 0, 213, 217, 0, 219, 219, 219,
1310 0, 214, 219, 220, 220, 220, 0, 212, 220, 0,
1311
1312 0, 216, 0, 0, 213, 0, 216, 0, 0, 214,
1313 0, 0, 217, 0, 0, 217, 221, 221, 221, 219,
1314 0, 221, 0, 0, 0, 220, 0, 219, 222, 222,
1315 222, 0, 0, 222, 0, 223, 223, 223, 0, 0,
1316 223, 0, 220, 0, 227, 227, 227, 0, 221, 227,
1317 228, 228, 228, 0, 0, 228, 229, 229, 229, 0,
1318 222, 229, 0, 0, 230, 230, 230, 223, 221, 230,
1319 0, 0, 0, 222, 223, 0, 227, 0, 231, 231,
1320 231, 0, 228, 231, 0, 0, 0, 0, 229, 227,
1321 232, 232, 232, 0, 0, 232, 230, 0, 234, 234,
1322
1323 234, 0, 230, 234, 0, 0, 228, 229, 0, 0,
1324 231, 235, 235, 235, 0, 0, 235, 231, 236, 236,
1325 236, 0, 232, 236, 237, 237, 237, 0, 0, 237,
1326 234, 0, 234, 0, 238, 238, 238, 0, 0, 238,
1327 239, 239, 239, 235, 238, 239, 240, 240, 240, 0,
1328 236, 240, 241, 241, 241, 0, 237, 241, 0, 242,
1329 242, 242, 0, 235, 242, 236, 238, 0, 0, 244,
1330 244, 244, 239, 0, 244, 0, 237, 0, 240, 0,
1331 245, 245, 245, 0, 241, 245, 0, 0, 0, 240,
1332 0, 242, 246, 246, 246, 0, 0, 246, 0, 0,
1333
1334 241, 244, 0, 247, 247, 247, 0, 0, 247, 0,
1335 0, 242, 245, 247, 248, 248, 248, 0, 245, 248,
1336 249, 249, 249, 0, 246, 249, 250, 250, 250, 0,
1337 0, 250, 251, 251, 251, 247, 0, 251, 252, 252,
1338 252, 0, 0, 252, 0, 0, 248, 0, 252, 253,
1339 253, 253, 249, 0, 253, 256, 256, 256, 250, 0,
1340 256, 0, 0, 249, 251, 0, 0, 0, 248, 0,
1341 252, 0, 257, 257, 257, 0, 0, 257, 258, 258,
1342 258, 253, 0, 258, 259, 259, 259, 256, 0, 259,
1343 260, 260, 260, 0, 0, 260, 262, 262, 262, 0,
1344
1345 0, 262, 0, 256, 257, 0, 0, 263, 263, 263,
1346 258, 257, 263, 264, 264, 264, 259, 0, 264, 0,
1347 0, 0, 260, 0, 266, 266, 266, 0, 262, 266,
1348 0, 0, 262, 268, 268, 268, 0, 260, 268, 263,
1349 259, 0, 260, 260, 0, 264, 269, 269, 269, 0,
1350 0, 269, 264, 0, 263, 0, 266, 0, 0, 266,
1351 0, 270, 270, 270, 0, 268, 270, 273, 273, 273,
1352 0, 0, 273, 0, 275, 275, 275, 0, 269, 275,
1353 0, 276, 276, 276, 268, 269, 276, 278, 278, 278,
1354 0, 0, 278, 270, 0, 0, 0, 270, 0, 273,
1355
1356 279, 279, 279, 0, 0, 279, 275, 280, 280, 280,
1357 0, 0, 280, 276, 0, 281, 281, 281, 273, 278,
1358 281, 0, 0, 275, 0, 282, 282, 282, 0, 0,
1359 282, 276, 279, 0, 0, 279, 283, 283, 283, 280,
1360 0, 283, 0, 284, 284, 284, 0, 281, 284, 285,
1361 285, 285, 0, 284, 285, 0, 0, 282, 0, 0,
1362 0, 0, 0, 280, 282, 281, 0, 0, 283, 0,
1363 0, 286, 286, 286, 0, 284, 286, 287, 287, 287,
1364 0, 285, 287, 0, 288, 288, 288, 0, 283, 288,
1365 0, 289, 289, 289, 0, 0, 289, 290, 290, 290,
1366
1367 0, 285, 290, 286, 0, 291, 291, 291, 0, 287,
1368 291, 0, 293, 293, 293, 0, 288, 293, 0, 286,
1369 0, 0, 287, 289, 0, 0, 0, 0, 0, 290,
1370 289, 294, 294, 294, 288, 0, 294, 291, 295, 295,
1371 295, 0, 0, 295, 293, 296, 296, 296, 0, 290,
1372 296, 0, 297, 297, 297, 296, 291, 297, 293, 0,
1373 298, 298, 298, 294, 0, 298, 299, 299, 299, 0,
1374 295, 299, 0, 0, 300, 300, 300, 296, 0, 300,
1375 294, 0, 0, 295, 297, 301, 301, 301, 0, 0,
1376 301, 297, 298, 0, 302, 302, 302, 298, 299, 302,
1377
1378 0, 0, 303, 303, 303, 299, 300, 303, 304, 304,
1379 304, 300, 0, 304, 305, 305, 305, 301, 0, 305,
1380 0, 0, 306, 306, 306, 0, 302, 306, 0, 302,
1381 307, 307, 307, 0, 303, 307, 308, 308, 308, 0,
1382 304, 308, 309, 309, 309, 0, 305, 309, 310, 310,
1383 310, 304, 303, 310, 306, 311, 311, 311, 0, 0,
1384 311, 306, 307, 0, 0, 0, 0, 0, 308, 307,
1385 312, 312, 312, 0, 309, 312, 313, 313, 313, 309,
1386 310, 313, 0, 315, 315, 315, 0, 311, 315, 316,
1387 316, 316, 0, 0, 316, 0, 0, 311, 0, 317,
1388
1389 317, 317, 312, 310, 317, 319, 319, 319, 313, 0,
1390 319, 0, 320, 320, 320, 315, 0, 320, 0, 0,
1391 313, 316, 322, 322, 322, 0, 0, 322, 0, 0,
1392 0, 317, 0, 315, 323, 323, 323, 319, 0, 323,
1393 324, 324, 324, 316, 320, 324, 0, 317, 326, 326,
1394 326, 0, 0, 326, 322, 0, 327, 327, 327, 0,
1395 0, 327, 0, 0, 322, 0, 323, 0, 328, 328,
1396 328, 0, 324, 328, 0, 324, 329, 329, 329, 0,
1397 326, 329, 0, 0, 0, 0, 323, 326, 327, 332,
1398 332, 332, 0, 0, 332, 0, 333, 333, 333, 327,
1399
1400 328, 333, 0, 0, 334, 334, 334, 328, 329, 334,
1401 335, 335, 335, 0, 0, 335, 0, 336, 336, 336,
1402 0, 332, 336, 329, 332, 337, 337, 337, 333, 0,
1403 337, 0, 338, 338, 338, 0, 334, 338, 339, 339,
1404 339, 0, 335, 339, 0, 341, 341, 341, 0, 336,
1405 341, 334, 0, 0, 0, 0, 336, 337, 342, 342,
1406 342, 0, 335, 342, 338, 0, 343, 343, 343, 0,
1407 339, 343, 0, 0, 0, 337, 0, 341, 0, 344,
1408 344, 344, 0, 338, 344, 339, 341, 345, 345, 345,
1409 342, 0, 345, 0, 346, 346, 346, 0, 343, 346,
1410
1411 347, 347, 347, 0, 0, 347, 0, 0, 349, 349,
1412 349, 344, 0, 349, 0, 0, 0, 343, 0, 345,
1413 350, 350, 350, 0, 0, 350, 346, 0, 0, 0,
1414 344, 0, 347, 0, 0, 346, 352, 352, 352, 347,
1415 349, 352, 353, 353, 353, 0, 0, 353, 356, 356,
1416 356, 0, 350, 356, 357, 357, 357, 0, 0, 357,
1417 358, 358, 358, 0, 0, 358, 0, 0, 352, 0,
1418 0, 0, 0, 0, 353, 352, 0, 0, 0, 0,
1419 356, 0, 0, 0, 0, 0, 357, 0, 0, 0,
1420 0, 0, 358, 353, 0, 0, 0, 0, 0, 356,
1421
1422 362, 362, 362, 362, 363, 363, 363, 363, 364, 0,
1423 364, 364, 365, 0, 0, 365, 366, 366, 366, 366,
1424 367, 367, 367, 367, 368, 0, 368, 368, 369, 369,
1425 370, 370, 370, 370, 361, 361, 361, 361, 361, 361,
1426 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1427 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1428 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1429 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1430 361, 361, 361, 361, 361, 361, 361, 361, 361, 361,
1431 361, 361, 361, 361, 361
1432
1433 } ;
1434
1435static yy_state_type yy_last_accepting_state;
1436static char *yy_last_accepting_cpos;
1437
1438extern int yy_flex_debug;
1439 int yy_flex_debug = 1;
1440
1441static const flex_int16_t yy_rule_linenum[63] =
1442 { 0,
1443 134, 136, 138, 143, 144, 149, 150, 151, 163, 166,
1444 171, 178, 187, 199, 211, 221, 231, 241, 250, 259,
1445 268, 277, 286, 295, 304, 313, 322, 331, 340, 349,
1446 358, 367, 376, 385, 394, 403, 412, 421, 430, 439,
1447 448, 457, 466, 475, 576, 592, 641, 649, 664, 665,
1448 666, 667, 668, 669, 671, 689, 702, 707, 711, 713,
1449 715, 717
1450 } ;
1451
1452/* The intent behind this definition is that it'll catch
1453 * any uses of REJECT which flex missed.
1454 */
1455#define REJECT reject_used_but_not_detected
1456#define yymore() yymore_used_but_not_detected
1457#define YY_MORE_ADJ 0
1458#define YY_RESTORE_YY_MORE_OFFSET
1459 char *yytext;
1460#line 1 "netconf_lexer.ll"
1461/* Copyright (C) 2018-2020 Internet Systems Consortium, Inc. ("ISC")
1462
1463 This Source Code Form is subject to the terms of the Mozilla Public
1464 License, v. 2.0. If a copy of the MPL was not distributed with this
1465 file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1466#line 8 "netconf_lexer.ll"
1467
1468/* Generated files do not make clang static analyser so happy */
1469#ifndef __clang_analyzer__
1470
1471#include <cctype>
1472#include <cerrno>
1473#include <climits>
1474#include <cstdlib>
1475#include <string>
1476#include <netconf/parser_context.h>
1477#include <asiolink/io_address.h>
1478#include <boost/lexical_cast.hpp>
1479#include <exceptions/exceptions.h>
1480#include <cc/dhcp_config_error.h>
1481
1482/* Please avoid C++ style comments (// ... eol) as they break flex 2.6.2 */
1483
1484/* Work around an incompatibility in flex (at least versions
1485 2.5.31 through 2.5.33): it generates code that does
1486 not conform to C89. See Debian bug 333231
1487 <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>. */
1488# undef yywrap
1489# define yywrap() 1
1490
1491namespace {
1492
1493bool start_token_flag = false;
1494
1495 isc::netconf::ParserContext::ParserType start_token_value;
1496unsigned int comment_start_line = 0;
1497
1498using namespace isc;
1499using isc::netconf::NetconfParser;
1500
1501};
1502
1503/* To avoid the call to exit... oops! */
1504#define YY_FATAL_ERROR(msg) isc::netconf::ParserContext::fatal(msg)
1505#line 1505 "netconf_lexer.cc"
1506/* noyywrap disables automatic rewinding for the next file to parse. Since we
1507 always parse only a single string, there's no need to do any wraps. And
1508 using yywrap requires linking with -lfl, which provides the default yywrap
1509 implementation that always returns 1 anyway. */
1510/* nounput simplifies the lexer, by removing support for putting a character
1511 back into the input stream. We never use such capability anyway. */
1512/* batch means that we'll never use the generated lexer interactively. */
1513/* avoid to get static global variables to remain with C++. */
1514/* in last resort %option reentrant */
1515/* Enables debug mode. To see the debug messages, one needs to also set
1516 yy_flex_debug to 1, then the debug messages will be printed on stderr. */
1517/* I have no idea what this option does, except it was specified in the bison
1518 examples and Postgres folks added it to remove gcc 4.3 warnings. Let's
1519 be on the safe side and keep it. */
1520#define YY_NO_INPUT 1
1521
1522/* These are not token expressions yet, just convenience expressions that
1523 can be used during actual token definitions. Note some can match
1524 incorrect inputs (e.g., IP addresses) which must be checked. */
1525/* for errors */
1526#line 97 "netconf_lexer.ll"
1527/* This code run each time a pattern is matched. It updates the location
1528 by moving it ahead by yyleng bytes. yyleng specifies the length of the
1529 currently matched token. */
1530#define YY_USER_ACTION driver.loc_.columns(yyleng);
1531#line 1531 "netconf_lexer.cc"
1532#line 1532 "netconf_lexer.cc"
1533
1534#define INITIAL 0
1535#define COMMENT 1
1536#define DIR_ENTER 2
1537#define DIR_INCLUDE 3
1538#define DIR_EXIT 4
1539
1540#ifndef YY_NO_UNISTD_H
1541/* Special case for "unistd.h", since it is non-ANSI. We include it way
1542 * down here because we want the user's section 1 to have been scanned first.
1543 * The user has a chance to override it with an option.
1544 */
1545/* %if-c-only */
1546#include <unistd.h>
1547/* %endif */
1548/* %if-c++-only */
1549/* %endif */
1550#endif
1551
1552#ifndef YY_EXTRA_TYPE
1553#define YY_EXTRA_TYPE void *
1554#endif
1555
1556/* %if-c-only Reentrant structure and macros (non-C++). */
1557/* %if-reentrant */
1558/* %if-c-only */
1559
1560static int yy_init_globals ( void );
1561
1562/* %endif */
1563/* %if-reentrant */
1564/* %endif */
1565/* %endif End reentrant structures and macros. */
1566
1567/* Accessor methods to globals.
1568 These are made visible to non-reentrant scanners for convenience. */
1569
1570int yylex_destroy ( void );
1571
1572int yyget_debug ( void );
1573
1574void yyset_debug ( int debug_flag );
1575
1576 YY_EXTRA_TYPE yyget_extra ( void );
1577
1578 void yyset_extra ( YY_EXTRA_TYPE user_defined );
1579
1580FILE *yyget_in ( void );
1581
1582void yyset_in ( FILE * _in_str );
1583
1584FILE *yyget_out ( void );
1585
1586void yyset_out ( FILE * _out_str );
1587
1588 int yyget_leng ( void );
1589
1590char *yyget_text ( void );
1591
1592int yyget_lineno ( void );
1593
1594void yyset_lineno ( int _line_number );
1595
1596/* %if-bison-bridge */
1597/* %endif */
1598
1599/* Macros after this point can all be overridden by user definitions in
1600 * section 1.
1601 */
1602
1603#ifndef YY_SKIP_YYWRAP
1604#ifdef __cplusplus
1605extern "C" int yywrap ( void );
1606#else
1607extern int yywrap ( void );
1608#endif
1609#endif
1610
1611/* %not-for-header */
1612#ifndef YY_NO_UNPUT
1613
1614#endif
1615/* %ok-for-header */
1616
1617/* %endif */
1618
1619#ifndef yytext_ptr
1620static void yy_flex_strncpy ( char *, const char *, int );
1621#endif
1622
1623#ifdef YY_NEED_STRLEN
1624static int yy_flex_strlen ( const char * );
1625#endif
1626
1627#ifndef YY_NO_INPUT
1628/* %if-c-only Standard (non-C++) definition */
1629/* %not-for-header */
1630#ifdef __cplusplus
1631static int yyinput ( void );
1632#else
1633static int input ( void );
1634#endif
1635/* %ok-for-header */
1636
1637/* %endif */
1638#endif
1639
1640/* %if-c-only */
1641
1642/* %endif */
1643
1644/* Amount of stuff to slurp up with each read. */
1645#ifndef YY_READ_BUF_SIZE
1646#ifdef __ia64__
1647/* On IA-64, the buffer size is 16k, not 8k */
1648#define YY_READ_BUF_SIZE 16384
1649#else
1650#define YY_READ_BUF_SIZE 8192
1651#endif /* __ia64__ */
1652#endif
1653
1654/* Copy whatever the last rule matched to the standard output. */
1655#ifndef ECHO
1656/* %if-c-only Standard (non-C++) definition */
1657/* This used to be an fputs(), but since the string might contain NUL's,
1658 * we now use fwrite().
1659 */
1660#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
1661/* %endif */
1662/* %if-c++-only C++ definition */
1663/* %endif */
1664#endif
1665
1666/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1667 * is returned in "result".
1668 */
1669#ifndef YY_INPUT
1670#define YY_INPUT(buf,result,max_size) \
1671/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
1672 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1673 { \
1674 int c = '*'; \
1675 int n; \
1676 for ( n = 0; n < max_size && \
1677 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1678 buf[n] = (char) c; \
1679 if ( c == '\n' ) \
1680 buf[n++] = (char) c; \
1681 if ( c == EOF && ferror( yyin ) ) \
1682 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1683 result = n; \
1684 } \
1685 else \
1686 { \
1687 errno=0; \
1688 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
1689 { \
1690 if( errno != EINTR) \
1691 { \
1692 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1693 break; \
1694 } \
1695 errno=0; \
1696 clearerr(yyin); \
1697 } \
1698 }\
1699\
1700/* %if-c++-only C++ definition \ */\
1701/* %endif */
1702
1703#endif
1704
1705/* No semi-colon after return; correct usage is to write "yyterminate();" -
1706 * we don't want an extra ';' after the "return" because that will cause
1707 * some compilers to complain about unreachable statements.
1708 */
1709#ifndef yyterminate
1710#define yyterminate() return YY_NULL
1711#endif
1712
1713/* Number of entries by which start-condition stack grows. */
1714#ifndef YY_START_STACK_INCR
1715#define YY_START_STACK_INCR 25
1716#endif
1717
1718/* Report a fatal error. */
1719#ifndef YY_FATAL_ERROR
1720/* %if-c-only */
1721#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1722/* %endif */
1723/* %if-c++-only */
1724/* %endif */
1725#endif
1726
1727/* %if-tables-serialization structures and prototypes */
1728/* %not-for-header */
1729/* %ok-for-header */
1730
1731/* %not-for-header */
1732/* %tables-yydmap generated elements */
1733/* %endif */
1734/* end tables serialization structures and prototypes */
1735
1736/* %ok-for-header */
1737
1738/* Default declaration of generated scanner - a define so the user can
1739 * easily add parameters.
1740 */
1741#ifndef YY_DECL
1742#define YY_DECL_IS_OURS 1
1743/* %if-c-only Standard (non-C++) definition */
1744
1745extern int yylex (void);
1746
1747#define YY_DECL int yylex (void)
1748/* %endif */
1749/* %if-c++-only C++ definition */
1750/* %endif */
1751#endif /* !YY_DECL */
1752
1753/* Code executed at the beginning of each rule, after yytext and yyleng
1754 * have been set up.
1755 */
1756#ifndef YY_USER_ACTION
1757#define YY_USER_ACTION
1758#endif
1759
1760/* Code executed at the end of each rule. */
1761#ifndef YY_BREAK
1762#define YY_BREAK /*LINTED*/break;
1763#endif
1764
1765/* %% [6.0] YY_RULE_SETUP definition goes here */
1766#define YY_RULE_SETUP \
1767 YY_USER_ACTION
1768
1769/* %not-for-header */
1772 YY_DECL
1773{
1774 yy_state_type yy_current_state;
1775 char *yy_cp, *yy_bp;
1776 int yy_act;
1777
1778 if ( !(yy_init) )
1779 {
1780 (yy_init) = 1;
1781
1782#ifdef YY_USER_INIT
1783 YY_USER_INIT;
1784#endif
1785
1786 if ( ! (yy_start) )
1787 (yy_start) = 1; /* first start state */
1788
1789 if ( ! yyin )
1790/* %if-c-only */
1791 yyin = stdin;
1792/* %endif */
1793/* %if-c++-only */
1794/* %endif */
1795
1796 if ( ! yyout )
1797/* %if-c-only */
1798 yyout = stdout;
1799/* %endif */
1800/* %if-c++-only */
1801/* %endif */
1802
1803 if ( ! YY_CURRENT_BUFFER ) {
1804 yyensure_buffer_stack ();
1805 YY_CURRENT_BUFFER_LVALUE =
1806 yy_create_buffer( yyin, YY_BUF_SIZE );
1807 }
1808
1809 yy_load_buffer_state( );
1810 }
1811
1812 {
1813/* %% [7.0] user's declarations go here */
1814#line 103 "netconf_lexer.ll"
1815
1816
1817
1818#line 107 "netconf_lexer.ll"
1819 /* This part of the code is copied over to the verbatim to the top
1820 of the generated yylex function. Explanation:
1821 http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html */
1822
1823 /* Code run each time yylex is called. */
1824 driver.loc_.step();
1825
1826 /* We currently have 3 points of entries defined:
1827 START_JSON - which expects any valid JSON
1828 START_NETCONF - which expects full configuration (with outer map and Netconf
1829 object in it.
1830 START_SUB_NETCONF - which expects only content of the Netconf, this is
1831 primarily useful for testing. */
1832 if (start_token_flag) {
1833 start_token_flag = false;
1834 switch (start_token_value) {
1835 case ParserContext::PARSER_JSON:
1836 default:
1837 return NetconfParser::make_START_JSON(driver.loc_);
1838 case ParserContext::PARSER_NETCONF:
1839 return NetconfParser::make_START_NETCONF(driver.loc_);
1840 case ParserContext::PARSER_SUB_NETCONF:
1841 return NetconfParser::make_START_SUB_NETCONF(driver.loc_);
1842 }
1843 }
1844
1845
1846#line 1846 "netconf_lexer.cc"
1847
1848 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1849 {
1850/* %% [8.0] yymore()-related code goes here */
1851 yy_cp = (yy_c_buf_p);
1852
1853 /* Support of yytext. */
1854 *yy_cp = (yy_hold_char);
1855
1856 /* yy_bp points to the position in yy_ch_buf of the start of
1857 * the current run.
1858 */
1859 yy_bp = yy_cp;
1860
1861/* %% [9.0] code to set up and find next match goes here */
1862 yy_current_state = (yy_start);
1863yy_match:
1864 do
1865 {
1866 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1867 if ( yy_accept[yy_current_state] )
1868 {
1869 (yy_last_accepting_state) = yy_current_state;
1870 (yy_last_accepting_cpos) = yy_cp;
1871 }
1872 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1873 {
1874 yy_current_state = (int) yy_def[yy_current_state];
1875 if ( yy_current_state >= 362 )
1876 yy_c = yy_meta[yy_c];
1877 }
1878 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1879 ++yy_cp;
1880 }
1881 while ( yy_current_state != 361 );
1882 yy_cp = (yy_last_accepting_cpos);
1883 yy_current_state = (yy_last_accepting_state);
1884
1885yy_find_action:
1886/* %% [10.0] code to find the action number goes here */
1887 yy_act = yy_accept[yy_current_state];
1888
1889 YY_DO_BEFORE_ACTION;
1890
1891/* %% [11.0] code for yylineno update goes here */
1892
1893do_action: /* This label is used only to access EOF actions. */
1894
1895/* %% [12.0] debug code goes here */
1896 if ( yy_flex_debug )
1897 {
1898 if ( yy_act == 0 )
1899 fprintf( stderr, "--scanner backing up\n" );
1900 else if ( yy_act < 63 )
1901 fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
1902 (long)yy_rule_linenum[yy_act], yytext );
1903 else if ( yy_act == 63 )
1904 fprintf( stderr, "--accepting default rule (\"%s\")\n",
1905 yytext );
1906 else if ( yy_act == 64 )
1907 fprintf( stderr, "--(end of buffer or a NUL)\n" );
1908 else
1909 fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
1910 }
1911
1912 switch ( yy_act )
1913 { /* beginning of action switch */
1914/* %% [13.0] actions go here */
1915 case 0: /* must back up */
1916 /* undo the effects of YY_DO_BEFORE_ACTION */
1917 *yy_cp = (yy_hold_char);
1918 yy_cp = (yy_last_accepting_cpos);
1919 yy_current_state = (yy_last_accepting_state);
1920 goto yy_find_action;
1921
1922case 1:
1923 YY_RULE_SETUP
1924#line 134 "netconf_lexer.ll"
1925;
1926 YY_BREAK
1927case 2:
1928 YY_RULE_SETUP
1929#line 136 "netconf_lexer.ll"
1930;
1931 YY_BREAK
1932case 3:
1933 YY_RULE_SETUP
1934#line 138 "netconf_lexer.ll"
1935{
1936 BEGIN(COMMENT);
1937 comment_start_line = driver.loc_.end.line;;
1938}
1939 YY_BREAK
1940case 4:
1941 YY_RULE_SETUP
1942#line 143 "netconf_lexer.ll"
1943 BEGIN(INITIAL);
1944 YY_BREAK
1945case 5:
1946 YY_RULE_SETUP
1947#line 144 "netconf_lexer.ll"
1948;
1949 YY_BREAK
1950case YY_STATE_EOF(COMMENT):
1951#line 145 "netconf_lexer.ll"
1952{
1953 isc_throw(ParseError, "Comment not closed. (/* in line " << comment_start_line);
1954}
1955 YY_BREAK
1956case 6:
1957 YY_RULE_SETUP
1958#line 149 "netconf_lexer.ll"
1959 BEGIN(DIR_ENTER);
1960 YY_BREAK
1961case 7:
1962 YY_RULE_SETUP
1963#line 150 "netconf_lexer.ll"
1964 BEGIN(DIR_INCLUDE);
1965 YY_BREAK
1966case 8:
1967 YY_RULE_SETUP
1968#line 151 "netconf_lexer.ll"
1969{
1970 /* Include directive. */
1971
1972 /* Extract the filename. */
1973 std::string tmp(yytext+1);
1974 tmp.resize(tmp.size() - 1);
1975
1976 driver.includeFile(tmp);
1977}
1978 YY_BREAK
1979case YY_STATE_EOF(DIR_ENTER):
1980case YY_STATE_EOF(DIR_INCLUDE):
1981case YY_STATE_EOF(DIR_EXIT):
1982#line 160 "netconf_lexer.ll"
1983{
1984 isc_throw(ParseError, "Directive not closed.");
1985}
1986 YY_BREAK
1987case 9:
1988 YY_RULE_SETUP
1989#line 163 "netconf_lexer.ll"
1990 BEGIN(INITIAL);
1991 YY_BREAK
1992case 10:
1993 YY_RULE_SETUP
1994#line 166 "netconf_lexer.ll"
1995{
1996 /* Ok, we found a with space. Let's ignore it and update loc variable. */
1997 driver.loc_.step();
1998}
1999 YY_BREAK
2000case 11:
2001/* rule 11 can match eol */
2002 YY_RULE_SETUP
2003#line 171 "netconf_lexer.ll"
2004{
2005 /* Newline found. Let's update the location and continue. */
2006 driver.loc_.lines(yyleng);
2007 driver.loc_.step();
2008}
2009 YY_BREAK
2010case 12:
2011 YY_RULE_SETUP
2012#line 178 "netconf_lexer.ll"
2013{
2014 switch(driver.ctx_) {
2015 case ParserContext::CONFIG:
2016 return NetconfParser::make_NETCONF(driver.loc_);
2017 default:
2018 return NetconfParser::make_STRING("Netconf", driver.loc_);
2019 }
2020}
2021 YY_BREAK
2022case 13:
2023 YY_RULE_SETUP
2024#line 187 "netconf_lexer.ll"
2025{
2026 switch(driver.ctx_) {
2027 case ParserContext::NETCONF:
2028 case ParserContext::SERVER:
2029 case ParserContext::CONTROL_SOCKET:
2030 case ParserContext::LOGGERS:
2031 return NetconfParser::make_USER_CONTEXT(driver.loc_);
2032 default:
2033 return NetconfParser::make_STRING("user-context", driver.loc_);
2034 }
2035}
2036 YY_BREAK
2037case 14:
2038 YY_RULE_SETUP
2039#line 199 "netconf_lexer.ll"
2040{
2041 switch(driver.ctx_) {
2042 case ParserContext::NETCONF:
2043 case ParserContext::SERVER:
2044 case ParserContext::CONTROL_SOCKET:
2045 case ParserContext::LOGGERS:
2046 return NetconfParser::make_COMMENT(driver.loc_);
2047 default:
2048 return NetconfParser::make_STRING("comment", driver.loc_);
2049 }
2050}
2051 YY_BREAK
2052case 15:
2053 YY_RULE_SETUP
2054#line 211 "netconf_lexer.ll"
2055{
2056 switch(driver.ctx_) {
2057 case ParserContext::NETCONF:
2058 case ParserContext::SERVER:
2059 return NetconfParser::make_BOOT_UPDATE(driver.loc_);
2060 default:
2061 return NetconfParser::make_STRING("boot-update", driver.loc_);
2062 }
2063}
2064 YY_BREAK
2065case 16:
2066 YY_RULE_SETUP
2067#line 221 "netconf_lexer.ll"
2068{
2069 switch(driver.ctx_) {
2070 case ParserContext::NETCONF:
2071 case ParserContext::SERVER:
2072 return NetconfParser::make_SUBSCRIBE_CHANGES(driver.loc_);
2073 default:
2074 return NetconfParser::make_STRING("subscribe-changes", driver.loc_);
2075 }
2076}
2077 YY_BREAK
2078case 17:
2079 YY_RULE_SETUP
2080#line 231 "netconf_lexer.ll"
2081{
2082 switch(driver.ctx_) {
2083 case ParserContext::NETCONF:
2084 case ParserContext::SERVER:
2085 return NetconfParser::make_VALIDATE_CHANGES(driver.loc_);
2086 default:
2087 return NetconfParser::make_STRING("validate-changes", driver.loc_);
2088 }
2089}
2090 YY_BREAK
2091case 18:
2092 YY_RULE_SETUP
2093#line 241 "netconf_lexer.ll"
2094{
2095 switch(driver.ctx_) {
2096 case ParserContext::NETCONF:
2097 return NetconfParser::make_MANAGED_SERVERS(driver.loc_);
2098 default:
2099 return NetconfParser::make_STRING("managed-servers", driver.loc_);
2100 }
2101}
2102 YY_BREAK
2103case 19:
2104 YY_RULE_SETUP
2105#line 250 "netconf_lexer.ll"
2106{
2107 switch(driver.ctx_) {
2108 case ParserContext::MANAGED_SERVERS:
2109 return NetconfParser::make_DHCP4_SERVER(driver.loc_);
2110 default:
2111 return NetconfParser::make_STRING("dhcp4", driver.loc_);
2112 }
2113}
2114 YY_BREAK
2115case 20:
2116 YY_RULE_SETUP
2117#line 259 "netconf_lexer.ll"
2118{
2119 switch(driver.ctx_) {
2120 case ParserContext::MANAGED_SERVERS:
2121 return NetconfParser::make_DHCP6_SERVER(driver.loc_);
2122 default:
2123 return NetconfParser::make_STRING("dhcp6", driver.loc_);
2124 }
2125}
2126 YY_BREAK
2127case 21:
2128 YY_RULE_SETUP
2129#line 268 "netconf_lexer.ll"
2130{
2131 switch(driver.ctx_) {
2132 case ParserContext::MANAGED_SERVERS:
2133 return NetconfParser::make_D2_SERVER(driver.loc_);
2134 default:
2135 return NetconfParser::make_STRING("d2", driver.loc_);
2136 }
2137}
2138 YY_BREAK
2139case 22:
2140 YY_RULE_SETUP
2141#line 277 "netconf_lexer.ll"
2142{
2143 switch(driver.ctx_) {
2144 case ParserContext::MANAGED_SERVERS:
2145 return NetconfParser::make_CA_SERVER(driver.loc_);
2146 default:
2147 return NetconfParser::make_STRING("ca", driver.loc_);
2148 }
2149}
2150 YY_BREAK
2151case 23:
2152 YY_RULE_SETUP
2153#line 286 "netconf_lexer.ll"
2154{
2155 switch(driver.ctx_) {
2156 case ParserContext::SERVER:
2157 return NetconfParser::make_MODEL(driver.loc_);
2158 default:
2159 return NetconfParser::make_STRING("model", driver.loc_);
2160 }
2161}
2162 YY_BREAK
2163case 24:
2164 YY_RULE_SETUP
2165#line 295 "netconf_lexer.ll"
2166{
2167 switch(driver.ctx_) {
2168 case ParserContext::SERVER:
2169 return NetconfParser::make_CONTROL_SOCKET(driver.loc_);
2170 default:
2171 return NetconfParser::make_STRING("control-socket", driver.loc_);
2172 }
2173}
2174 YY_BREAK
2175case 25:
2176 YY_RULE_SETUP
2177#line 304 "netconf_lexer.ll"
2178{
2179 switch(driver.ctx_) {
2180 case ParserContext::SOCKET_TYPE:
2181 return NetconfParser::make_UNIX(driver.loc_);
2182 default:
2183 return NetconfParser::make_STRING("unix", driver.loc_);
2184 }
2185}
2186 YY_BREAK
2187case 26:
2188 YY_RULE_SETUP
2189#line 313 "netconf_lexer.ll"
2190{
2191 switch(driver.ctx_) {
2192 case ParserContext::SOCKET_TYPE:
2193 return NetconfParser::make_HTTP(driver.loc_);
2194 default:
2195 return NetconfParser::make_STRING("http", driver.loc_);
2196 }
2197}
2198 YY_BREAK
2199case 27:
2200 YY_RULE_SETUP
2201#line 322 "netconf_lexer.ll"
2202{
2203 switch(driver.ctx_) {
2204 case ParserContext::SOCKET_TYPE:
2205 return NetconfParser::make_STDOUT(driver.loc_);
2206 default:
2207 return NetconfParser::make_STRING("stdout", driver.loc_);
2208 }
2209}
2210 YY_BREAK
2211case 28:
2212 YY_RULE_SETUP
2213#line 331 "netconf_lexer.ll"
2214{
2215 switch(driver.ctx_) {
2216 case ParserContext::CONTROL_SOCKET:
2217 return NetconfParser::make_SOCKET_TYPE(driver.loc_);
2218 default:
2219 return NetconfParser::make_STRING("socket-type", driver.loc_);
2220 }
2221}
2222 YY_BREAK
2223case 29:
2224 YY_RULE_SETUP
2225#line 340 "netconf_lexer.ll"
2226{
2227 switch(driver.ctx_) {
2228 case ParserContext::CONTROL_SOCKET:
2229 return NetconfParser::make_SOCKET_NAME(driver.loc_);
2230 default:
2231 return NetconfParser::make_STRING("socket-name", driver.loc_);
2232 }
2233}
2234 YY_BREAK
2235case 30:
2236 YY_RULE_SETUP
2237#line 349 "netconf_lexer.ll"
2238{
2239 switch(driver.ctx_) {
2240 case ParserContext::CONTROL_SOCKET:
2241 return NetconfParser::make_SOCKET_URL(driver.loc_);
2242 default:
2243 return NetconfParser::make_STRING("socket-url", driver.loc_);
2244 }
2245}
2246 YY_BREAK
2247case 31:
2248 YY_RULE_SETUP
2249#line 358 "netconf_lexer.ll"
2250{
2251 switch(driver.ctx_) {
2252 case ParserContext::NETCONF:
2253 return NetconfParser::make_HOOKS_LIBRARIES(driver.loc_);
2254 default:
2255 return NetconfParser::make_STRING("hooks-libraries", driver.loc_);
2256 }
2257}
2258 YY_BREAK
2259case 32:
2260 YY_RULE_SETUP
2261#line 367 "netconf_lexer.ll"
2262{
2263 switch(driver.ctx_) {
2264 case ParserContext::HOOKS_LIBRARIES:
2265 return NetconfParser::make_LIBRARY(driver.loc_);
2266 default:
2267 return NetconfParser::make_STRING("library", driver.loc_);
2268 }
2269}
2270 YY_BREAK
2271case 33:
2272 YY_RULE_SETUP
2273#line 376 "netconf_lexer.ll"
2274{
2275 switch(driver.ctx_) {
2276 case ParserContext::HOOKS_LIBRARIES:
2277 return NetconfParser::make_PARAMETERS(driver.loc_);
2278 default:
2279 return NetconfParser::make_STRING("parameters", driver.loc_);
2280 }
2281}
2282 YY_BREAK
2283case 34:
2284 YY_RULE_SETUP
2285#line 385 "netconf_lexer.ll"
2286{
2287 switch(driver.ctx_) {
2288 case ParserContext::NETCONF:
2289 return NetconfParser::make_LOGGERS(driver.loc_);
2290 default:
2291 return NetconfParser::make_STRING("loggers", driver.loc_);
2292 }
2293}
2294 YY_BREAK
2295case 35:
2296 YY_RULE_SETUP
2297#line 394 "netconf_lexer.ll"
2298{
2299 switch(driver.ctx_) {
2300 case ParserContext::LOGGERS:
2301 return NetconfParser::make_NAME(driver.loc_);
2302 default:
2303 return NetconfParser::make_STRING("name", driver.loc_);
2304 }
2305}
2306 YY_BREAK
2307case 36:
2308 YY_RULE_SETUP
2309#line 403 "netconf_lexer.ll"
2310{
2311 switch(driver.ctx_) {
2312 case ParserContext::LOGGERS:
2313 return NetconfParser::make_OUTPUT_OPTIONS(driver.loc_);
2314 default:
2315 return NetconfParser::make_STRING("output_options", driver.loc_);
2316 }
2317}
2318 YY_BREAK
2319case 37:
2320 YY_RULE_SETUP
2321#line 412 "netconf_lexer.ll"
2322{
2323 switch(driver.ctx_) {
2324 case ParserContext::OUTPUT_OPTIONS:
2325 return NetconfParser::make_OUTPUT(driver.loc_);
2326 default:
2327 return NetconfParser::make_STRING("output", driver.loc_);
2328 }
2329}
2330 YY_BREAK
2331case 38:
2332 YY_RULE_SETUP
2333#line 421 "netconf_lexer.ll"
2334{
2335 switch(driver.ctx_) {
2336 case ParserContext::OUTPUT_OPTIONS:
2337 return NetconfParser::make_FLUSH(driver.loc_);
2338 default:
2339 return NetconfParser::make_STRING("flush", driver.loc_);
2340 }
2341}
2342 YY_BREAK
2343case 39:
2344 YY_RULE_SETUP
2345#line 430 "netconf_lexer.ll"
2346{
2347 switch(driver.ctx_) {
2348 case ParserContext::OUTPUT_OPTIONS:
2349 return NetconfParser::make_MAXSIZE(driver.loc_);
2350 default:
2351 return NetconfParser::make_STRING("maxsize", driver.loc_);
2352 }
2353}
2354 YY_BREAK
2355case 40:
2356 YY_RULE_SETUP
2357#line 439 "netconf_lexer.ll"
2358{
2359 switch(driver.ctx_) {
2360 case ParserContext::OUTPUT_OPTIONS:
2361 return NetconfParser::make_MAXVER(driver.loc_);
2362 default:
2363 return NetconfParser::make_STRING("maxver", driver.loc_);
2364 }
2365}
2366 YY_BREAK
2367case 41:
2368 YY_RULE_SETUP
2369#line 448 "netconf_lexer.ll"
2370{
2371 switch(driver.ctx_) {
2372 case ParserContext::OUTPUT_OPTIONS:
2373 return NetconfParser::make_PATTERN(driver.loc_);
2374 default:
2375 return NetconfParser::make_STRING("pattern", driver.loc_);
2376 }
2377}
2378 YY_BREAK
2379case 42:
2380 YY_RULE_SETUP
2381#line 457 "netconf_lexer.ll"
2382{
2383 switch(driver.ctx_) {
2384 case ParserContext::LOGGERS:
2385 return NetconfParser::make_DEBUGLEVEL(driver.loc_);
2386 default:
2387 return NetconfParser::make_STRING("debuglevel", driver.loc_);
2388 }
2389}
2390 YY_BREAK
2391case 43:
2392 YY_RULE_SETUP
2393#line 466 "netconf_lexer.ll"
2394{
2395 switch(driver.ctx_) {
2396 case ParserContext::LOGGERS:
2397 return NetconfParser::make_SEVERITY(driver.loc_);
2398 default:
2399 return NetconfParser::make_STRING("severity", driver.loc_);
2400 }
2401}
2402 YY_BREAK
2403case 44:
2404 YY_RULE_SETUP
2405#line 475 "netconf_lexer.ll"
2406{
2407 /* A string has been matched. It contains the actual string and single quotes.
2408 We need to get those quotes out of the way and just use its content, e.g.
2409 for 'foo' we should get foo */
2410 std::string raw(yytext+1);
2411 size_t len = raw.size() - 1;
2412 raw.resize(len);
2413 std::string decoded;
2414 decoded.reserve(len);
2415 for (size_t pos = 0; pos < len; ++pos) {
2416 int b = 0;
2417 char c = raw[pos];
2418 switch (c) {
2419 case '"':
2420 /* impossible condition */
2421 driver.error(driver.loc_, "Bad quote in \"" + raw + "\"");
2422 break;
2423 case '\\':
2424 ++pos;
2425 if (pos >= len) {
2426 /* impossible condition */
2427 driver.error(driver.loc_, "Overflow escape in \"" + raw + "\"");
2428 }
2429 c = raw[pos];
2430 switch (c) {
2431 case '"':
2432 case '\\':
2433 case '/':
2434 decoded.push_back(c);
2435 break;
2436 case 'b':
2437 decoded.push_back('\b');
2438 break;
2439 case 'f':
2440 decoded.push_back('\f');
2441 break;
2442 case 'n':
2443 decoded.push_back('\n');
2444 break;
2445 case 'r':
2446 decoded.push_back('\r');
2447 break;
2448 case 't':
2449 decoded.push_back('\t');
2450 break;
2451 case 'u':
2452 /* support only \u0000 to \u00ff */
2453 ++pos;
2454 if (pos + 4 > len) {
2455 /* impossible condition */
2456 driver.error(driver.loc_,
2457 "Overflow unicode escape in \"" + raw + "\"");
2458 }
2459 if ((raw[pos] != '0') || (raw[pos + 1] != '0')) {
2460 driver.error(driver.loc_,
2461 "Unsupported unicode escape in \"" + raw + "\"",
2462 pos + 1);
2463 }
2464 pos += 2;
2465 c = raw[pos];
2466 if ((c >= '0') && (c <= '9')) {
2467 b = (c - '0') << 4;
2468 } else if ((c >= 'A') && (c <= 'F')) {
2469 b = (c - 'A' + 10) << 4;
2470 } else if ((c >= 'a') && (c <= 'f')) {
2471 b = (c - 'a' + 10) << 4;
2472 } else {
2473 /* impossible condition */
2474 driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
2475 }
2476 pos++;
2477 c = raw[pos];
2478 if ((c >= '0') && (c <= '9')) {
2479 b |= c - '0';
2480 } else if ((c >= 'A') && (c <= 'F')) {
2481 b |= c - 'A' + 10;
2482 } else if ((c >= 'a') && (c <= 'f')) {
2483 b |= c - 'a' + 10;
2484 } else {
2485 /* impossible condition */
2486 driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
2487 }
2488 decoded.push_back(static_cast<char>(b & 0xff));
2489 break;
2490 default:
2491 /* impossible condition */
2492 driver.error(driver.loc_, "Bad escape in \"" + raw + "\"");
2493 }
2494 break;
2495 default:
2496 if ((c >= 0) && (c < 0x20)) {
2497 /* impossible condition */
2498 driver.error(driver.loc_, "Invalid control in \"" + raw + "\"");
2499 }
2500 decoded.push_back(c);
2501 }
2502 }
2503
2504 return NetconfParser::make_STRING(decoded, driver.loc_);
2505}
2506 YY_BREAK
2507case 45:
2508/* rule 45 can match eol */
2509 YY_RULE_SETUP
2510#line 576 "netconf_lexer.ll"
2511{
2512 /* Bad string with a forbidden control character inside */
2513 std::string raw(yytext+1);
2514 size_t len = raw.size() - 1;
2515 size_t pos = 0;
2516 for (; pos < len; ++pos) {
2517 char c = raw[pos];
2518 if ((c >= 0) && (c < 0x20)) {
2519 break;
2520 }
2521 }
2522 driver.error(driver.loc_,
2523 "Invalid control in " + std::string(yytext),
2524 pos + 1);
2525}
2526 YY_BREAK
2527case 46:
2528/* rule 46 can match eol */
2529 YY_RULE_SETUP
2530#line 592 "netconf_lexer.ll"
2531{
2532 /* Bad string with a bad escape inside */
2533 std::string raw(yytext+1);
2534 size_t len = raw.size() - 1;
2535 size_t pos = 0;
2536 bool found = false;
2537 for (; pos < len; ++pos) {
2538 if (found) {
2539 break;
2540 }
2541 char c = raw[pos];
2542 if (c == '\\') {
2543 ++pos;
2544 c = raw[pos];
2545 switch (c) {
2546 case '"':
2547 case '\\':
2548 case '/':
2549 case 'b':
2550 case 'f':
2551 case 'n':
2552 case 'r':
2553 case 't':
2554 break;
2555 case 'u':
2556 if ((pos + 4 > len) ||
2557 !std::isxdigit(raw[pos + 1]) ||
2558 !std::isxdigit(raw[pos + 2]) ||
2559 !std::isxdigit(raw[pos + 3]) ||
2560 !std::isxdigit(raw[pos + 4])) {
2561 found = true;
2562 }
2563 break;
2564 default:
2565 found = true;
2566 break;
2567 }
2568 }
2569 }
2570 /* The rule stops on the first " including on \" so add ... in this case */
2571 std::string trailer = "";
2572 if (raw[len - 1] == '\\') {
2573 trailer = "...";
2574 }
2575 driver.error(driver.loc_,
2576 "Bad escape in " + std::string(yytext) + trailer,
2577 pos);
2578}
2579 YY_BREAK
2580case 47:
2581 YY_RULE_SETUP
2582#line 641 "netconf_lexer.ll"
2583{
2584 /* Bad string with an open escape at the end */
2585 std::string raw(yytext+1);
2586 driver.error(driver.loc_,
2587 "Overflow escape in " + std::string(yytext),
2588 raw.size() + 1);
2589}
2590 YY_BREAK
2591case 48:
2592 YY_RULE_SETUP
2593#line 649 "netconf_lexer.ll"
2594{
2595 /* Bad string with an open unicode escape at the end */
2596 std::string raw(yytext+1);
2597 size_t pos = raw.size() - 1;
2598 for (; pos > 0; --pos) {
2599 char c = raw[pos];
2600 if (c == 'u') {
2601 break;
2602 }
2603 }
2604 driver.error(driver.loc_,
2605 "Overflow unicode escape in " + std::string(yytext),
2606 pos + 1);
2607}
2608 YY_BREAK
2609case 49:
2610 YY_RULE_SETUP
2611#line 664 "netconf_lexer.ll"
2612{ return NetconfParser::make_LSQUARE_BRACKET(driver.loc_); }
2613 YY_BREAK
2614case 50:
2615 YY_RULE_SETUP
2616#line 665 "netconf_lexer.ll"
2617{ return NetconfParser::make_RSQUARE_BRACKET(driver.loc_); }
2618 YY_BREAK
2619case 51:
2620 YY_RULE_SETUP
2621#line 666 "netconf_lexer.ll"
2622{ return NetconfParser::make_LCURLY_BRACKET(driver.loc_); }
2623 YY_BREAK
2624case 52:
2625 YY_RULE_SETUP
2626#line 667 "netconf_lexer.ll"
2627{ return NetconfParser::make_RCURLY_BRACKET(driver.loc_); }
2628 YY_BREAK
2629case 53:
2630 YY_RULE_SETUP
2631#line 668 "netconf_lexer.ll"
2632{ return NetconfParser::make_COMMA(driver.loc_); }
2633 YY_BREAK
2634case 54:
2635 YY_RULE_SETUP
2636#line 669 "netconf_lexer.ll"
2637{ return NetconfParser::make_COLON(driver.loc_); }
2638 YY_BREAK
2639case 55:
2640 YY_RULE_SETUP
2641#line 671 "netconf_lexer.ll"
2642{
2643 /* An integer was found. */
2644 std::string tmp(yytext);
2645 int64_t integer = 0;
2646 try {
2647 /* In substring we want to use negative values (e.g. -1).
2648 In enterprise-id we need to use values up to 0xffffffff.
2649 To cover both of those use cases, we need at least
2650 int64_t. */
2651 integer = boost::lexical_cast<int64_t>(tmp);
2652 } catch (const boost::bad_lexical_cast &) {
2653 driver.error(driver.loc_, "Failed to convert " + tmp + " to an integer.");
2654 }
2655
2656 /* The parser needs the string form as double conversion is no lossless */
2657 return NetconfParser::make_INTEGER(integer, driver.loc_);
2658}
2659 YY_BREAK
2660case 56:
2661 YY_RULE_SETUP
2662#line 689 "netconf_lexer.ll"
2663{
2664 /* A floating point was found. */
2665 std::string tmp(yytext);
2666 double fp = 0.0;
2667 try {
2668 fp = boost::lexical_cast<double>(tmp);
2669 } catch (const boost::bad_lexical_cast &) {
2670 driver.error(driver.loc_, "Failed to convert " + tmp + " to a floating point.");
2671 }
2672
2673 return NetconfParser::make_FLOAT(fp, driver.loc_);
2674}
2675 YY_BREAK
2676case 57:
2677 YY_RULE_SETUP
2678#line 702 "netconf_lexer.ll"
2679{
2680 string tmp(yytext);
2681 return NetconfParser::make_BOOLEAN(tmp == "true", driver.loc_);
2682}
2683 YY_BREAK
2684case 58:
2685 YY_RULE_SETUP
2686#line 707 "netconf_lexer.ll"
2687{
2688 return NetconfParser::make_NULL_TYPE(driver.loc_);
2689}
2690 YY_BREAK
2691case 59:
2692 YY_RULE_SETUP
2693#line 711 "netconf_lexer.ll"
2694driver.error (driver.loc_, "JSON true reserved keyword is lower case only");
2695 YY_BREAK
2696case 60:
2697 YY_RULE_SETUP
2698#line 713 "netconf_lexer.ll"
2699driver.error (driver.loc_, "JSON false reserved keyword is lower case only");
2700 YY_BREAK
2701case 61:
2702 YY_RULE_SETUP
2703#line 715 "netconf_lexer.ll"
2704driver.error (driver.loc_, "JSON null reserved keyword is lower case only");
2705 YY_BREAK
2706case 62:
2707 YY_RULE_SETUP
2708#line 717 "netconf_lexer.ll"
2709driver.error (driver.loc_, "Invalid character: " + std::string(yytext));
2710 YY_BREAK
2711case YY_STATE_EOF(INITIAL):
2712#line 719 "netconf_lexer.ll"
2713{
2714 if (driver.states_.empty()) {
2715 return NetconfParser::make_END(driver.loc_);
2716 }
2717 driver.loc_ = driver.locs_.back();
2718 driver.locs_.pop_back();
2719 driver.file_ = driver.files_.back();
2720 driver.files_.pop_back();
2721 if (driver.sfile_) {
2722 fclose(driver.sfile_);
2723 driver.sfile_ = 0;
2724 }
2725 if (!driver.sfiles_.empty()) {
2726 driver.sfile_ = driver.sfiles_.back();
2727 driver.sfiles_.pop_back();
2728 }
2729 netconf__delete_buffer(YY_CURRENT_BUFFER);
2730 netconf__switch_to_buffer(driver.states_.back());
2731 driver.states_.pop_back();
2732
2733 BEGIN(DIR_EXIT);
2734}
2735 YY_BREAK
2736case 63:
2737 YY_RULE_SETUP
2738#line 742 "netconf_lexer.ll"
2739 ECHO;
2740 YY_BREAK
2741#line 2741 "netconf_lexer.cc"
2742
2743 case YY_END_OF_BUFFER:
2744 {
2745 /* Amount of text matched not including the EOB char. */
2746 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2747
2748 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2749 *yy_cp = (yy_hold_char);
2750 YY_RESTORE_YY_MORE_OFFSET
2751
2752 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2753 {
2754 /* We're scanning a new file or input source. It's
2755 * possible that this happened because the user
2756 * just pointed yyin at a new source and called
2757 * yylex(). If so, then we have to assure
2758 * consistency between YY_CURRENT_BUFFER and our
2759 * globals. Here is the right place to do so, because
2760 * this is the first action (other than possibly a
2761 * back-up) that will match for the new input source.
2762 */
2763 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2764/* %if-c-only */
2765 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2766/* %endif */
2767/* %if-c++-only */
2768/* %endif */
2769 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2770 }
2771
2772 /* Note that here we test for yy_c_buf_p "<=" to the position
2773 * of the first EOB in the buffer, since yy_c_buf_p will
2774 * already have been incremented past the NUL character
2775 * (since all states make transitions on EOB to the
2776 * end-of-buffer state). Contrast this with the test
2777 * in input().
2778 */
2779 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2780 { /* This was really a NUL. */
2781 yy_state_type yy_next_state;
2782
2783 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2784
2785 yy_current_state = yy_get_previous_state( );
2786
2787 /* Okay, we're now positioned to make the NUL
2788 * transition. We couldn't have
2789 * yy_get_previous_state() go ahead and do it
2790 * for us because it doesn't know how to deal
2791 * with the possibility of jamming (and we don't
2792 * want to build jamming into it because then it
2793 * will run more slowly).
2794 */
2795
2796 yy_next_state = yy_try_NUL_trans( yy_current_state );
2797
2798 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2799
2800 if ( yy_next_state )
2801 {
2802 /* Consume the NUL. */
2803 yy_cp = ++(yy_c_buf_p);
2804 yy_current_state = yy_next_state;
2805 goto yy_match;
2806 }
2807
2808 else
2809 {
2810/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
2811 yy_cp = (yy_last_accepting_cpos);
2812 yy_current_state = (yy_last_accepting_state);
2813 goto yy_find_action;
2814 }
2815 }
2816
2817 else switch ( yy_get_next_buffer( ) )
2818 {
2819 case EOB_ACT_END_OF_FILE:
2820 {
2821 (yy_did_buffer_switch_on_eof) = 0;
2822
2823 if ( yywrap( ) )
2824 {
2825 /* Note: because we've taken care in
2826 * yy_get_next_buffer() to have set up
2827 * yytext, we can now set up
2828 * yy_c_buf_p so that if some total
2829 * hoser (like flex itself) wants to
2830 * call the scanner after we return the
2831 * YY_NULL, it'll still work - another
2832 * YY_NULL will get returned.
2833 */
2834 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2835
2836 yy_act = YY_STATE_EOF(YY_START);
2837 goto do_action;
2838 }
2839
2840 else
2841 {
2842 if ( ! (yy_did_buffer_switch_on_eof) )
2843 YY_NEW_FILE;
2844 }
2845 break;
2846 }
2847
2848 case EOB_ACT_CONTINUE_SCAN:
2849 (yy_c_buf_p) =
2850 (yytext_ptr) + yy_amount_of_matched_text;
2851
2852 yy_current_state = yy_get_previous_state( );
2853
2854 yy_cp = (yy_c_buf_p);
2855 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2856 goto yy_match;
2857
2858 case EOB_ACT_LAST_MATCH:
2859 (yy_c_buf_p) =
2860 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2861
2862 yy_current_state = yy_get_previous_state( );
2863
2864 yy_cp = (yy_c_buf_p);
2865 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2866 goto yy_find_action;
2867 }
2868 break;
2869 }
2870
2871 default:
2872 YY_FATAL_ERROR(
2873 "fatal flex scanner internal error--no action found" );
2874 } /* end of action switch */
2875 } /* end of scanning one token */
2876 } /* end of user's declarations */
2877} /* end of yylex */
2878/* %ok-for-header */
2879
2880/* %if-c++-only */
2881/* %not-for-header */
2882/* %ok-for-header */
2883
2884/* %endif */
2885
2886/* yy_get_next_buffer - try to read in a new buffer
2887 *
2888 * Returns a code representing an action:
2889 * EOB_ACT_LAST_MATCH -
2890 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2891 * EOB_ACT_END_OF_FILE - end of file
2892 */
2893/* %if-c-only */
2894static int yy_get_next_buffer (void)
2895/* %endif */
2896/* %if-c++-only */
2897/* %endif */
2898{
2899 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2900 char *source = (yytext_ptr);
2901 int number_to_move, i;
2902 int ret_val;
2903
2904 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2905 YY_FATAL_ERROR(
2906 "fatal flex scanner internal error--end of buffer missed" );
2907
2908 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2909 { /* Don't try to fill the buffer, so this is an EOF. */
2910 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2911 {
2912 /* We matched a single character, the EOB, so
2913 * treat this as a final EOF.
2914 */
2915 return EOB_ACT_END_OF_FILE;
2916 }
2917
2918 else
2919 {
2920 /* We matched some text prior to the EOB, first
2921 * process it.
2922 */
2923 return EOB_ACT_LAST_MATCH;
2924 }
2925 }
2926
2927 /* Try to read more data. */
2928
2929 /* First move last chars to start of buffer. */
2930 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
2931
2932 for ( i = 0; i < number_to_move; ++i )
2933 *(dest++) = *(source++);
2934
2935 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2936 /* don't do the read, it's not guaranteed to return an EOF,
2937 * just force an EOF
2938 */
2939 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2940
2941 else
2942 {
2943 int num_to_read =
2944 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2945
2946 while ( num_to_read <= 0 )
2947 { /* Not enough room in the buffer - grow it. */
2948
2949 /* just a shorter name for the current buffer */
2950 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
2951
2952 int yy_c_buf_p_offset =
2953 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2954
2955 if ( b->yy_is_our_buffer )
2956 {
2957 int new_size = b->yy_buf_size * 2;
2958
2959 if ( new_size <= 0 )
2960 b->yy_buf_size += b->yy_buf_size / 8;
2961 else
2962 b->yy_buf_size *= 2;
2963
2964 b->yy_ch_buf = (char *)
2965 /* Include room in for 2 EOB chars. */
2966 yyrealloc( (void *) b->yy_ch_buf,
2967 (yy_size_t) (b->yy_buf_size + 2) );
2968 }
2969 else
2970 /* Can't grow it, we don't own it. */
2971 b->yy_ch_buf = NULL;
2972
2973 if ( ! b->yy_ch_buf )
2974 YY_FATAL_ERROR(
2975 "fatal error - scanner input buffer overflow" );
2976
2977 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2978
2979 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2980 number_to_move - 1;
2981
2982 }
2983
2984 if ( num_to_read > YY_READ_BUF_SIZE )
2985 num_to_read = YY_READ_BUF_SIZE;
2986
2987 /* Read in more data. */
2988 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2989 (yy_n_chars), num_to_read );
2990
2991 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2992 }
2993
2994 if ( (yy_n_chars) == 0 )
2995 {
2996 if ( number_to_move == YY_MORE_ADJ )
2997 {
2998 ret_val = EOB_ACT_END_OF_FILE;
2999 yyrestart( yyin );
3000 }
3001
3002 else
3003 {
3004 ret_val = EOB_ACT_LAST_MATCH;
3005 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3006 YY_BUFFER_EOF_PENDING;
3007 }
3008 }
3009
3010 else
3011 ret_val = EOB_ACT_CONTINUE_SCAN;
3012
3013 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
3014 /* Extend the array by 50%, plus the number we really need. */
3015 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3016 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
3017 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
3018 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3019 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3020 /* "- 2" to take care of EOB's */
3021 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
3022 }
3023
3024 (yy_n_chars) += number_to_move;
3025 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3026 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3027
3028 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3029
3030 return ret_val;
3031}
3032
3033/* yy_get_previous_state - get the state just before the EOB char was reached */
3034
3035/* %if-c-only */
3036/* %not-for-header */
3037 static yy_state_type yy_get_previous_state (void)
3038/* %endif */
3039/* %if-c++-only */
3040/* %endif */
3041{
3042 yy_state_type yy_current_state;
3043 char *yy_cp;
3044
3045/* %% [15.0] code to get the start state into yy_current_state goes here */
3046 yy_current_state = (yy_start);
3047
3048 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3049 {
3050/* %% [16.0] code to find the next state goes here */
3051 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3052 if ( yy_accept[yy_current_state] )
3053 {
3054 (yy_last_accepting_state) = yy_current_state;
3055 (yy_last_accepting_cpos) = yy_cp;
3056 }
3057 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3058 {
3059 yy_current_state = (int) yy_def[yy_current_state];
3060 if ( yy_current_state >= 362 )
3061 yy_c = yy_meta[yy_c];
3062 }
3063 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
3064 }
3065
3066 return yy_current_state;
3067}
3068
3069/* yy_try_NUL_trans - try to make a transition on the NUL character
3070 *
3071 * synopsis
3072 * next_state = yy_try_NUL_trans( current_state );
3073 */
3074/* %if-c-only */
3075 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
3076/* %endif */
3077/* %if-c++-only */
3078/* %endif */
3079{
3080 int yy_is_jam;
3081 /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
3082 char *yy_cp = (yy_c_buf_p);
3083
3084 YY_CHAR yy_c = 1;
3085 if ( yy_accept[yy_current_state] )
3086 {
3087 (yy_last_accepting_state) = yy_current_state;
3088 (yy_last_accepting_cpos) = yy_cp;
3089 }
3090 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3091 {
3092 yy_current_state = (int) yy_def[yy_current_state];
3093 if ( yy_current_state >= 362 )
3094 yy_c = yy_meta[yy_c];
3095 }
3096 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
3097 yy_is_jam = (yy_current_state == 361);
3098
3099 return yy_is_jam ? 0 : yy_current_state;
3100}
3101
3102#ifndef YY_NO_UNPUT
3103/* %if-c-only */
3104
3105/* %endif */
3106#endif
3107
3108/* %if-c-only */
3109#ifndef YY_NO_INPUT
3110#ifdef __cplusplus
3111 static int yyinput (void)
3112#else
3113 static int input (void)
3114#endif
3115
3116/* %endif */
3117/* %if-c++-only */
3118/* %endif */
3119{
3120 int c;
3121
3122 *(yy_c_buf_p) = (yy_hold_char);
3123
3124 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3125 {
3126 /* yy_c_buf_p now points to the character we want to return.
3127 * If this occurs *before* the EOB characters, then it's a
3128 * valid NUL; if not, then we've hit the end of the buffer.
3129 */
3130 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3131 /* This was really a NUL. */
3132 *(yy_c_buf_p) = '\0';
3133
3134 else
3135 { /* need more input */
3136 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
3137 ++(yy_c_buf_p);
3138
3139 switch ( yy_get_next_buffer( ) )
3140 {
3141 case EOB_ACT_LAST_MATCH:
3142 /* This happens because yy_g_n_b()
3143 * sees that we've accumulated a
3144 * token and flags that we need to
3145 * try matching the token before
3146 * proceeding. But for input(),
3147 * there's no matching to consider.
3148 * So convert the EOB_ACT_LAST_MATCH
3149 * to EOB_ACT_END_OF_FILE.
3150 */
3151
3152 /* Reset buffer status. */
3153 yyrestart( yyin );
3154
3155 /*FALLTHROUGH*/
3156
3157 case EOB_ACT_END_OF_FILE:
3158 {
3159 if ( yywrap( ) )
3160 return 0;
3161
3162 if ( ! (yy_did_buffer_switch_on_eof) )
3163 YY_NEW_FILE;
3164#ifdef __cplusplus
3165 return yyinput();
3166#else
3167 return input();
3168#endif
3169 }
3170
3171 case EOB_ACT_CONTINUE_SCAN:
3172 (yy_c_buf_p) = (yytext_ptr) + offset;
3173 break;
3174 }
3175 }
3176 }
3177
3178 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
3179 *(yy_c_buf_p) = '\0'; /* preserve yytext */
3180 (yy_hold_char) = *++(yy_c_buf_p);
3181
3182/* %% [19.0] update BOL and yylineno */
3183
3184 return c;
3185}
3186/* %if-c-only */
3187#endif /* ifndef YY_NO_INPUT */
3188/* %endif */
3189
3195/* %if-c-only */
3196 void yyrestart (FILE * input_file )
3197/* %endif */
3198/* %if-c++-only */
3199/* %endif */
3200{
3201
3202 if ( ! YY_CURRENT_BUFFER ){
3203 yyensure_buffer_stack ();
3204 YY_CURRENT_BUFFER_LVALUE =
3205 yy_create_buffer( yyin, YY_BUF_SIZE );
3206 }
3207
3208 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
3209 yy_load_buffer_state( );
3210}
3211
3212/* %if-c++-only */
3213/* %endif */
3214
3219/* %if-c-only */
3220 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
3221/* %endif */
3222/* %if-c++-only */
3223/* %endif */
3224{
3225
3226 /* TODO. We should be able to replace this entire function body
3227 * with
3228 * yypop_buffer_state();
3229 * yypush_buffer_state(new_buffer);
3230 */
3231 yyensure_buffer_stack ();
3232 if ( YY_CURRENT_BUFFER == new_buffer )
3233 return;
3234
3235 if ( YY_CURRENT_BUFFER )
3236 {
3237 /* Flush out information for old buffer. */
3238 *(yy_c_buf_p) = (yy_hold_char);
3239 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3240 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3241 }
3242
3243 YY_CURRENT_BUFFER_LVALUE = new_buffer;
3244 yy_load_buffer_state( );
3245
3246 /* We don't actually know whether we did this switch during
3247 * EOF (yywrap()) processing, but the only time this flag
3248 * is looked at is after yywrap() is called, so it's safe
3249 * to go ahead and always set it.
3250 */
3251 (yy_did_buffer_switch_on_eof) = 1;
3252}
3253
3254/* %if-c-only */
3255static void yy_load_buffer_state (void)
3256/* %endif */
3257/* %if-c++-only */
3258/* %endif */
3259{
3260 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3261 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
3262/* %if-c-only */
3263 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
3264/* %endif */
3265/* %if-c++-only */
3266/* %endif */
3267 (yy_hold_char) = *(yy_c_buf_p);
3268}
3269
3276/* %if-c-only */
3277 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
3278/* %endif */
3279/* %if-c++-only */
3280/* %endif */
3281{
3282 YY_BUFFER_STATE b;
3283
3284 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
3285 if ( ! b )
3286 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3287
3288 b->yy_buf_size = size;
3289
3290 /* yy_ch_buf has to be 2 characters longer than the size given because
3291 * we need to put in 2 end-of-buffer characters.
3292 */
3293 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
3294 if ( ! b->yy_ch_buf )
3295 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3296
3297 b->yy_is_our_buffer = 1;
3298
3299 yy_init_buffer( b, file );
3300
3301 return b;
3302}
3303
3304/* %if-c++-only */
3305/* %endif */
3306
3311/* %if-c-only */
3312 void yy_delete_buffer (YY_BUFFER_STATE b )
3313/* %endif */
3314/* %if-c++-only */
3315/* %endif */
3316{
3317
3318 if ( ! b )
3319 return;
3320
3321 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3322 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3323
3324 if ( b->yy_is_our_buffer )
3325 yyfree( (void *) b->yy_ch_buf );
3326
3327 yyfree( (void *) b );
3328}
3329
3330/* Initializes or reinitializes a buffer.
3331 * This function is sometimes called more than once on the same buffer,
3332 * such as during a yyrestart() or at EOF.
3333 */
3334/* %if-c-only */
3335 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
3336/* %endif */
3337/* %if-c++-only */
3338/* %endif */
3339
3340{
3341 int oerrno = errno;
3342
3343 yy_flush_buffer( b );
3344
3345/* %if-c-only */
3346 b->yy_input_file = file;
3347/* %endif */
3348/* %if-c++-only */
3349/* %endif */
3350 b->yy_fill_buffer = 1;
3351
3352 /* If b is the current buffer, then yy_init_buffer was _probably_
3353 * called from yyrestart() or through yy_get_next_buffer.
3354 * In that case, we don't want to reset the lineno or column.
3355 */
3356 if (b != YY_CURRENT_BUFFER){
3357 b->yy_bs_lineno = 1;
3358 b->yy_bs_column = 0;
3359 }
3360
3361/* %if-c-only */
3362
3363 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3364
3365/* %endif */
3366/* %if-c++-only */
3367/* %endif */
3368 errno = oerrno;
3369}
3370
3375/* %if-c-only */
3376 void yy_flush_buffer (YY_BUFFER_STATE b )
3377/* %endif */
3378/* %if-c++-only */
3379/* %endif */
3380{
3381 if ( ! b )
3382 return;
3383
3384 b->yy_n_chars = 0;
3385
3386 /* We always need two end-of-buffer characters. The first causes
3387 * a transition to the end-of-buffer state. The second causes
3388 * a jam in that state.
3389 */
3390 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3391 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3392
3393 b->yy_buf_pos = &b->yy_ch_buf[0];
3394
3395 b->yy_at_bol = 1;
3396 b->yy_buffer_status = YY_BUFFER_NEW;
3397
3398 if ( b == YY_CURRENT_BUFFER )
3399 yy_load_buffer_state( );
3400}
3401
3402/* %if-c-or-c++ */
3409/* %if-c-only */
3410 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
3411/* %endif */
3412/* %if-c++-only */
3413/* %endif */
3414{
3415 if (new_buffer == NULL)
3416 return;
3417
3418 yyensure_buffer_stack();
3419
3420 /* This block is copied from yy_switch_to_buffer. */
3421 if ( YY_CURRENT_BUFFER )
3422 {
3423 /* Flush out information for old buffer. */
3424 *(yy_c_buf_p) = (yy_hold_char);
3425 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3426 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3427 }
3428
3429 /* Only push if top exists. Otherwise, replace top. */
3430 if (YY_CURRENT_BUFFER)
3431 (yy_buffer_stack_top)++;
3432 YY_CURRENT_BUFFER_LVALUE = new_buffer;
3433
3434 /* copied from yy_switch_to_buffer. */
3435 yy_load_buffer_state( );
3436 (yy_did_buffer_switch_on_eof) = 1;
3437}
3438/* %endif */
3439
3440/* %if-c-or-c++ */
3445/* %if-c-only */
3446void yypop_buffer_state (void)
3447/* %endif */
3448/* %if-c++-only */
3449/* %endif */
3450{
3451 if (!YY_CURRENT_BUFFER)
3452 return;
3453
3454 yy_delete_buffer(YY_CURRENT_BUFFER );
3455 YY_CURRENT_BUFFER_LVALUE = NULL;
3456 if ((yy_buffer_stack_top) > 0)
3457 --(yy_buffer_stack_top);
3458
3459 if (YY_CURRENT_BUFFER) {
3460 yy_load_buffer_state( );
3461 (yy_did_buffer_switch_on_eof) = 1;
3462 }
3463}
3464/* %endif */
3465
3466/* %if-c-or-c++ */
3467/* Allocates the stack if it does not exist.
3468 * Guarantees space for at least one push.
3469 */
3470/* %if-c-only */
3471static void yyensure_buffer_stack (void)
3472/* %endif */
3473/* %if-c++-only */
3474/* %endif */
3475{
3476 yy_size_t num_to_alloc;
3477
3478 if (!(yy_buffer_stack)) {
3479
3480 /* First allocation is just for 2 elements, since we don't know if this
3481 * scanner will even need a stack. We use 2 instead of 1 to avoid an
3482 * immediate realloc on the next call.
3483 */
3484 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
3485 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
3486 (num_to_alloc * sizeof(struct yy_buffer_state*)
3487 );
3488 if ( ! (yy_buffer_stack) )
3489 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3490
3491 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3492
3493 (yy_buffer_stack_max) = num_to_alloc;
3494 (yy_buffer_stack_top) = 0;
3495 return;
3496 }
3497
3498 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3499
3500 /* Increase the buffer to prepare for a possible push. */
3501 yy_size_t grow_size = 8 /* arbitrary grow size */;
3502
3503 num_to_alloc = (yy_buffer_stack_max) + grow_size;
3504 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
3505 ((yy_buffer_stack),
3506 num_to_alloc * sizeof(struct yy_buffer_state*)
3507 );
3508 if ( ! (yy_buffer_stack) )
3509 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3510
3511 /* zero only the new slots.*/
3512 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3513 (yy_buffer_stack_max) = num_to_alloc;
3514 }
3515}
3516/* %endif */
3517
3518/* %if-c-only */
3525 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
3526{
3527 YY_BUFFER_STATE b;
3528
3529 if ( size < 2 ||
3530 base[size-2] != YY_END_OF_BUFFER_CHAR ||
3531 base[size-1] != YY_END_OF_BUFFER_CHAR )
3532 /* They forgot to leave room for the EOB's. */
3533 return NULL;
3534
3535 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
3536 if ( ! b )
3537 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3538
3539 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
3540 b->yy_buf_pos = b->yy_ch_buf = base;
3541 b->yy_is_our_buffer = 0;
3542 b->yy_input_file = NULL;
3543 b->yy_n_chars = b->yy_buf_size;
3544 b->yy_is_interactive = 0;
3545 b->yy_at_bol = 1;
3546 b->yy_fill_buffer = 0;
3547 b->yy_buffer_status = YY_BUFFER_NEW;
3548
3549 yy_switch_to_buffer( b );
3550
3551 return b;
3552}
3553/* %endif */
3554
3555/* %if-c-only */
3564 YY_BUFFER_STATE yy_scan_string (const char * yystr )
3565{
3566
3567 return yy_scan_bytes( yystr, (int) strlen(yystr) );
3568}
3569/* %endif */
3570
3571/* %if-c-only */
3579 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
3580{
3581 YY_BUFFER_STATE b;
3582 char *buf;
3583 yy_size_t n;
3584 int i;
3585
3586 /* Get memory for full buffer, including space for trailing EOB's. */
3587 n = (yy_size_t) (_yybytes_len + 2);
3588 buf = (char *) yyalloc( n );
3589 if ( ! buf )
3590 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3591
3592 for ( i = 0; i < _yybytes_len; ++i )
3593 buf[i] = yybytes[i];
3594
3595 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3596
3597 b = yy_scan_buffer( buf, n );
3598 if ( ! b )
3599 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3600
3601 /* It's okay to grow etc. this buffer, and we should throw it
3602 * away when we're done.
3603 */
3604 b->yy_is_our_buffer = 1;
3605
3606 return b;
3607}
3608/* %endif */
3609
3610#ifndef YY_EXIT_FAILURE
3611#define YY_EXIT_FAILURE 2
3612#endif
3613
3614/* %if-c-only */
3615static void yynoreturn yy_fatal_error (const char* msg )
3616{
3617 fprintf( stderr, "%s\n", msg );
3618 exit( YY_EXIT_FAILURE );
3619}
3620/* %endif */
3621/* %if-c++-only */
3622/* %endif */
3623
3624/* Redefine yyless() so it works in section 3 code. */
3625
3626#undef yyless
3627#define yyless(n) \
3628 do \
3629 { \
3630 /* Undo effects of setting up yytext. */ \
3631 int yyless_macro_arg = (n); \
3632 YY_LESS_LINENO(yyless_macro_arg);\
3633 yytext[yyleng] = (yy_hold_char); \
3634 (yy_c_buf_p) = yytext + yyless_macro_arg; \
3635 (yy_hold_char) = *(yy_c_buf_p); \
3636 *(yy_c_buf_p) = '\0'; \
3637 yyleng = yyless_macro_arg; \
3638 } \
3639 while ( 0 )
3640
3641/* Accessor methods (get/set functions) to struct members. */
3642
3643/* %if-c-only */
3644/* %if-reentrant */
3645/* %endif */
3646
3650int yyget_lineno (void)
3651{
3652
3653 return yylineno;
3654}
3655
3659FILE *yyget_in (void)
3660{
3661 return yyin;
3662}
3663
3667FILE *yyget_out (void)
3668{
3669 return yyout;
3670}
3671
3675int yyget_leng (void)
3676{
3677 return yyleng;
3678}
3679
3684char *yyget_text (void)
3685{
3686 return yytext;
3687}
3688
3689/* %if-reentrant */
3690/* %endif */
3691
3696 void yyset_lineno (int _line_number )
3697{
3698
3699 yylineno = _line_number;
3700}
3701
3708 void yyset_in (FILE * _in_str )
3709{
3710 yyin = _in_str ;
3711}
3712
3713 void yyset_out (FILE * _out_str )
3714{
3715 yyout = _out_str ;
3716}
3717
3718int yyget_debug (void)
3719{
3720 return yy_flex_debug;
3721}
3722
3723 void yyset_debug (int _bdebug )
3724{
3725 yy_flex_debug = _bdebug ;
3726}
3727
3728/* %endif */
3729
3730/* %if-reentrant */
3731/* %if-bison-bridge */
3732/* %endif */
3733/* %endif if-c-only */
3734
3735/* %if-c-only */
3736static int yy_init_globals (void)
3737{
3738 /* Initialization is the same as for the non-reentrant scanner.
3739 * This function is called from yylex_destroy(), so don't allocate here.
3740 */
3741
3742 (yy_buffer_stack) = NULL;
3743 (yy_buffer_stack_top) = 0;
3744 (yy_buffer_stack_max) = 0;
3745 (yy_c_buf_p) = NULL;
3746 (yy_init) = 0;
3747 (yy_start) = 0;
3748
3749/* Defined in main.c */
3750#ifdef YY_STDINIT
3751 yyin = stdin;
3752 yyout = stdout;
3753#else
3754 yyin = NULL;
3755 yyout = NULL;
3756#endif
3757
3758 /* For future reference: Set errno on error, since we are called by
3759 * yylex_init()
3760 */
3761 return 0;
3762}
3763/* %endif */
3764
3765/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
3766/* yylex_destroy is for both reentrant and non-reentrant scanners. */
3767int yylex_destroy (void)
3768{
3769
3770 /* Pop the buffer stack, destroying each element. */
3771 while(YY_CURRENT_BUFFER){
3772 yy_delete_buffer( YY_CURRENT_BUFFER );
3773 YY_CURRENT_BUFFER_LVALUE = NULL;
3774 yypop_buffer_state();
3775 }
3776
3777 /* Destroy the stack itself. */
3778 yyfree((yy_buffer_stack) );
3779 (yy_buffer_stack) = NULL;
3780
3781 /* Reset the globals. This is important in a non-reentrant scanner so the next time
3782 * yylex() is called, initialization will occur. */
3783 yy_init_globals( );
3784
3785/* %if-reentrant */
3786/* %endif */
3787 return 0;
3788}
3789/* %endif */
3790
3791/*
3792 * Internal utility routines.
3793 */
3794
3795#ifndef yytext_ptr
3796static void yy_flex_strncpy (char* s1, const char * s2, int n )
3797{
3798
3799 int i;
3800 for ( i = 0; i < n; ++i )
3801 s1[i] = s2[i];
3802}
3803#endif
3804
3805#ifdef YY_NEED_STRLEN
3806static int yy_flex_strlen (const char * s )
3807{
3808 int n;
3809 for ( n = 0; s[n]; ++n )
3810 ;
3811
3812 return n;
3813}
3814#endif
3815
3816 void *yyalloc (yy_size_t size )
3817{
3818 return malloc(size);
3819}
3820
3821 void *yyrealloc (void * ptr, yy_size_t size )
3822{
3823
3824 /* The cast to (char *) in the following accommodates both
3825 * implementations that use char* generic pointers, and those
3826 * that use void* generic pointers. It works with the latter
3827 * because both ANSI C and C++ allow castless assignment from
3828 * any pointer type to void*, and deal with argument conversions
3829 * as though doing an assignment.
3830 */
3831 return realloc(ptr, size);
3832}
3833
3834 void yyfree (void * ptr )
3835{
3836 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
3837}
3838
3839/* %if-tables-serialization definitions */
3840/* %define-yytables The name for this specific scanner's tables. */
3841#define YYTABLES_NAME "yytables"
3842/* %endif */
3843
3844/* %ok-for-header */
3845
3846#line 742 "netconf_lexer.ll"
3847
3848
3849using namespace isc::dhcp;
3850
3851void
3852ParserContext::scanStringBegin(const std::string& str, ParserType parser_type)
3853{
3854 start_token_flag = true;
3855 start_token_value = parser_type;
3856
3857 file_ = "<string>";
3858 sfile_ = 0;
3859 loc_.initialize(&file_);
3860 yy_flex_debug = trace_scanning_;
3861 YY_BUFFER_STATE buffer;
3862 buffer = netconf__scan_bytes(str.c_str(), str.size());
3863 if (!buffer) {
3864 fatal("cannot scan string");
3865 /* fatal() throws an exception so this can't be reached */
3866 }
3867}
3868
3869void
3870ParserContext::scanFileBegin(FILE * f,
3871 const std::string& filename,
3872 ParserType parser_type)
3873{
3874 start_token_flag = true;
3875 start_token_value = parser_type;
3876
3877 file_ = filename;
3878 sfile_ = f;
3879 loc_.initialize(&file_);
3880 yy_flex_debug = trace_scanning_;
3881 YY_BUFFER_STATE buffer;
3882
3883 /* See netconf_lexer.cc header for available definitions */
3884 buffer = netconf__create_buffer(f, 65536 /*buffer size*/);
3885 if (!buffer) {
3886 fatal("cannot scan file " + filename);
3887 }
3888 netconf__switch_to_buffer(buffer);
3889}
3890
3891void
3892ParserContext::scanEnd() {
3893 if (sfile_)
3894 fclose(sfile_);
3895 sfile_ = 0;
3896 static_cast<void>(netconf_lex_destroy());
3897 /* Close files */
3898 while (!sfiles_.empty()) {
3899 FILE* f = sfiles_.back();
3900 if (f) {
3901 fclose(f);
3902 }
3903 sfiles_.pop_back();
3904 }
3905 /* Delete states */
3906 while (!states_.empty()) {
3907 netconf__delete_buffer(states_.back());
3908 states_.pop_back();
3909 }
3910}
3911
3912void
3913ParserContext::includeFile(const std::string& filename) {
3914 if (states_.size() > 10) {
3915 fatal("Too many nested include.");
3916 }
3917
3918 FILE* f = fopen(filename.c_str(), "r");
3919 if (!f) {
3920 fatal("Can't open include file " + filename);
3921 }
3922 if (sfile_) {
3923 sfiles_.push_back(sfile_);
3924 }
3925 sfile_ = f;
3926 states_.push_back(YY_CURRENT_BUFFER);
3927 YY_BUFFER_STATE buffer;
3928 buffer = netconf__create_buffer(f, 65536 /*buffer size*/);
3929 if (!buffer) {
3930 fatal( "Can't scan include file " + filename);
3931 }
3932 netconf__switch_to_buffer(buffer);
3933 files_.push_back(file_);
3934 file_ = filename;
3935 locs_.push_back(loc_);
3936 loc_.initialize(&file_);
3937
3938 BEGIN(INITIAL);
3939}
3940
3941namespace {
3943class Dummy {
3944 /* cppcheck-suppress unusedPrivateFunction */
3945 void dummy() { yy_fatal_error("Fix me: how to disable its definition?"); }
3946};
3947}
3948#endif /* !__clang_analyzer__ */
3949
flex_uint8_t
unsigned char flex_uint8_t
Definition: agent_lexer.cc:335
flex_int16_t
short int flex_int16_t
Definition: agent_lexer.cc:333
flex_int32_t
int flex_int32_t
Definition: agent_lexer.cc:334
yy_state_type
int yy_state_type
Definition: agent_lexer.cc:660
YY_CHAR
flex_uint8_t YY_CHAR
Definition: agent_lexer.cc:656
yy_size_t
size_t yy_size_t
Definition: agent_lexer.cc:451
isc::ParseError
Evaluation error exception raised when trying to parse.
Definition: dhcp_config_error.h:18
isc::netconf::NetconfParser
A Bison parser.
Definition: netconf_parser.h:215
isc::netconf::ParserContext::scanFileBegin
void scanFileBegin(FILE *f, const std::string &filename, ParserType type)
Method called before scanning starts on a file.
Definition: netconf_lexer.cc:3870
isc::netconf::ParserContext::files_
std::vector< std::string > files_
File name stack.
Definition: netconf/parser_context.h:234
isc::netconf::ParserContext::includeFile
void includeFile(const std::string &filename)
Divert input to an include file.
Definition: netconf_lexer.cc:3913
isc::netconf::ParserContext::locs_
std::vector< isc::netconf::location > locs_
Location stack.
Definition: netconf/parser_context.h:243
isc::netconf::ParserContext::sfile_
FILE * sfile_
sFile (aka FILE)
Definition: netconf/parser_context.h:249
isc::netconf::ParserContext::fatal
static void fatal(const std::string &what)
Fatal error handler.
Definition: netconf/parser_context.cc:92
isc::netconf::ParserContext::loc_
isc::netconf::location loc_
Location of the current token.
Definition: netconf/parser_context.h:240
isc::netconf::ParserContext::ParserType
ParserType
Defines currently supported scopes.
Definition: netconf/parser_context.h:48
isc::netconf::ParserContext::sfiles_
std::vector< FILE * > sfiles_
sFile (aka FILE) stack
Definition: netconf/parser_context.h:256
isc::netconf::ParserContext::file_
std::string file_
File name.
Definition: netconf/parser_context.h:231
isc::netconf::ParserContext::states_
std::vector< struct yy_buffer_state * > states_
Lexer state stack.
Definition: netconf/parser_context.h:246
isc::netconf::ParserContext::scanEnd
void scanEnd()
Method called after the last tokens are scanned.
Definition: netconf_lexer.cc:3892
dhcp_config_error.h
exceptions.h
isc_throw
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Definition: exceptions/exceptions.h:210
io_address.h
isc::asiolink::SERVER
@ SERVER
Definition: common_tls.h:31
isc::dhcp
Definition: dhcp4/client_handler.cc:20
isc
Defines the logger used by the top-level component of kea-lfc.
Definition: agent_parser.cc:143
parser_context.h
yy_load_buffer_state
#define yy_load_buffer_state
Definition: netconf_lexer.cc:19
YY_NEW_FILE
#define YY_NEW_FILE
Definition: netconf_lexer.cc:424
yyset_extra
#define yyset_extra
Definition: netconf_lexer.cc:176
yytext
#define yytext
Definition: netconf_lexer.cc:31
flex_uint8_t
unsigned char flex_uint8_t
Definition: netconf_lexer.cc:335
yyset_lineno
#define yyset_lineno
Definition: netconf_lexer.cc:224
COMMENT
#define COMMENT
Definition: netconf_lexer.cc:1535
yyrestart
#define yyrestart
Definition: netconf_lexer.cc:30
yyset_debug
#define yyset_debug
Definition: netconf_lexer.cc:164
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: netconf_lexer.cc:1553
DIR_INCLUDE
#define DIR_INCLUDE
Definition: netconf_lexer.cc:1537
flex_int16_t
short int flex_int16_t
Definition: netconf_lexer.cc:333
yy_flex_debug
#define yy_flex_debug
Definition: netconf_lexer.cc:24
flex_uint32_t
unsigned int flex_uint32_t
Definition: netconf_lexer.cc:337
yy_scan_bytes
#define yy_scan_bytes
Definition: netconf_lexer.cc:16
YY_BREAK
#define YY_BREAK
Definition: netconf_lexer.cc:1762
yynoreturn
#define yynoreturn
Definition: netconf_lexer.cc:388
yyget_debug
#define yyget_debug
Definition: netconf_lexer.cc:158
yy_act
int yy_act
Definition: netconf_lexer.cc:1776
yypush_buffer_state
#define yypush_buffer_state
Definition: netconf_lexer.cc:21
yyget_in
#define yyget_in
Get the input stream.
Definition: netconf_lexer.cc:182
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: netconf_lexer.cc:446
yyfree
#define yyfree
Definition: netconf_lexer.cc:35
yyout
#define yyout
Definition: netconf_lexer.cc:29
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: netconf_lexer.cc:539
yylex
#define yylex
Definition: netconf_lexer.cc:27
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: netconf_lexer.cc:1458
yyget_leng
#define yyget_leng
Get the length of the current token.
Definition: netconf_lexer.cc:206
yywrap
#define yywrap
Definition: netconf_lexer.cc:1489
yyget_out
#define yyget_out
Get the output stream.
Definition: netconf_lexer.cc:194
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: netconf_lexer.cc:540
yy_cp
char * yy_cp
Definition: netconf_lexer.cc:1775
yyensure_buffer_stack
#define yyensure_buffer_stack
Definition: netconf_lexer.cc:23
yy_scan_buffer
#define yy_scan_buffer
Definition: netconf_lexer.cc:14
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: netconf_lexer.cc:1457
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: netconf_lexer.cc:1766
yy_scan_string
#define yy_scan_string
Definition: netconf_lexer.cc:15
DIR_EXIT
#define DIR_EXIT
Definition: netconf_lexer.cc:1538
yytext_ptr
#define yytext_ptr
Definition: netconf_lexer.cc:669
flex_int8_t
signed char flex_int8_t
Definition: netconf_lexer.cc:332
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: netconf_lexer.cc:465
yyalloc
#define yyalloc
Definition: netconf_lexer.cc:33
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: netconf_lexer.cc:581
flex_int32_t
int flex_int32_t
Definition: netconf_lexer.cc:334
yylex_destroy
#define yylex_destroy
Definition: netconf_lexer.cc:152
YY_START
#define YY_START
Definition: netconf_lexer.cc:419
yyget_text
#define yyget_text
Get the current token.
Definition: netconf_lexer.cc:212
yy_switch_to_buffer
#define yy_switch_to_buffer
Definition: netconf_lexer.cc:20
yy_state_type
int yy_state_type
Definition: netconf_lexer.cc:660
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: netconf_lexer.cc:575
yy_init_buffer
#define yy_init_buffer
Definition: netconf_lexer.cc:17
INITIAL
#define INITIAL
Definition: netconf_lexer.cc:1534
yyget_extra
#define yyget_extra
Definition: netconf_lexer.cc:170
yy_bp
char * yy_bp
Definition: netconf_lexer.cc:1775
yyin
#define yyin
Definition: netconf_lexer.cc:25
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: netconf_lexer.cc:1650
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: netconf_lexer.cc:1670
ECHO
#define ECHO
Definition: netconf_lexer.cc:1660
yy_flush_buffer
#define yy_flush_buffer
Definition: netconf_lexer.cc:18
yyrealloc
#define yyrealloc
Definition: netconf_lexer.cc:34
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: netconf_lexer.cc:695
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: netconf_lexer.cc:422
BEGIN
#define BEGIN
Definition: netconf_lexer.cc:414
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: netconf_lexer.cc:425
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: netconf_lexer.cc:1504
flex_uint16_t
unsigned short int flex_uint16_t
Definition: netconf_lexer.cc:336
yypop_buffer_state
#define yypop_buffer_state
Removes and deletes the top of the stack, if present.
Definition: netconf_lexer.cc:22
yy_create_buffer
#define yy_create_buffer
Definition: netconf_lexer.cc:12
YY_CHAR
flex_uint8_t YY_CHAR
Definition: netconf_lexer.cc:656
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: netconf_lexer.cc:685
yy_delete_buffer
#define yy_delete_buffer
Definition: netconf_lexer.cc:13
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: netconf_lexer.cc:466
yy_size_t
size_t yy_size_t
Definition: netconf_lexer.cc:451
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: netconf_lexer.cc:551
yylineno
#define yylineno
Definition: netconf_lexer.cc:28
yyset_out
#define yyset_out
Definition: netconf_lexer.cc:200
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: netconf_lexer.cc:464
yyget_lineno
#define yyget_lineno
Get the current line number.
Definition: netconf_lexer.cc:218
YY_DECL
#define YY_DECL
Definition: netconf_lexer.cc:1747
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: netconf_lexer.cc:436
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: netconf_lexer.cc:3611
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: netconf_lexer.cc:400
DIR_ENTER
#define DIR_ENTER
Definition: netconf_lexer.cc:1536
yyleng
#define yyleng
Definition: netconf_lexer.cc:26
yyset_in
#define yyset_in
Definition: netconf_lexer.cc:188
yy_buffer_state
Definition: agent_lexer.cc:489
yy_buffer_state::yy_n_chars
int yy_n_chars
Definition: agent_lexer.cc:508
yy_buffer_state::yy_ch_buf
char * yy_ch_buf
Definition: agent_lexer.cc:497
yy_buffer_state::yy_bs_column
int yy_bs_column
The column count.
Definition: agent_lexer.cc:530
yy_buffer_state::yy_input_file
FILE * yy_input_file
Definition: agent_lexer.cc:491
yy_buffer_state::yy_buf_size
int yy_buf_size
Definition: agent_lexer.cc:503
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: agent_lexer.cc:535
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: agent_lexer.cc:537
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: agent_lexer.cc:514
yy_buffer_state::yy_bs_lineno
int yy_bs_lineno
The line count.
Definition: agent_lexer.cc:529
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: agent_lexer.cc:498
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: agent_lexer.cc:527
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: agent_lexer.cc:521
yy_trans_info
Definition: agent_lexer.cc:699
yy_trans_info::yy_verify
flex_int32_t yy_verify
Definition: agent_lexer.cc:700
yy_trans_info::yy_nxt
flex_int32_t yy_nxt
Definition: agent_lexer.cc:701