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