cprover
json_lex.yy.cpp
Go to the documentation of this file.
1 #line 1 "json_lex.yy.cpp"
2 
3 #line 3 "json_lex.yy.cpp"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define yy_create_buffer yyjson_create_buffer
10 #define yy_delete_buffer yyjson_delete_buffer
11 #define yy_scan_buffer yyjson_scan_buffer
12 #define yy_scan_string yyjson_scan_string
13 #define yy_scan_bytes yyjson_scan_bytes
14 #define yy_init_buffer yyjson_init_buffer
15 #define yy_flush_buffer yyjson_flush_buffer
16 #define yy_load_buffer_state yyjson_load_buffer_state
17 #define yy_switch_to_buffer yyjson_switch_to_buffer
18 #define yypush_buffer_state yyjsonpush_buffer_state
19 #define yypop_buffer_state yyjsonpop_buffer_state
20 #define yyensure_buffer_stack yyjsonensure_buffer_stack
21 #define yy_flex_debug yyjson_flex_debug
22 #define yyin yyjsonin
23 #define yyleng yyjsonleng
24 #define yylex yyjsonlex
25 #define yylineno yyjsonlineno
26 #define yyout yyjsonout
27 #define yyrestart yyjsonrestart
28 #define yytext yyjsontext
29 #define yywrap yyjsonwrap
30 #define yyalloc yyjsonalloc
31 #define yyrealloc yyjsonrealloc
32 #define yyfree yyjsonfree
33 
34 #define FLEX_SCANNER
35 #define YY_FLEX_MAJOR_VERSION 2
36 #define YY_FLEX_MINOR_VERSION 6
37 #define YY_FLEX_SUBMINOR_VERSION 4
38 #if YY_FLEX_SUBMINOR_VERSION > 0
39 #define FLEX_BETA
40 #endif
41 
42 #ifdef yy_create_buffer
43 #define yyjson_create_buffer_ALREADY_DEFINED
44 #else
45 #define yy_create_buffer yyjson_create_buffer
46 #endif
47 
48 #ifdef yy_delete_buffer
49 #define yyjson_delete_buffer_ALREADY_DEFINED
50 #else
51 #define yy_delete_buffer yyjson_delete_buffer
52 #endif
53 
54 #ifdef yy_scan_buffer
55 #define yyjson_scan_buffer_ALREADY_DEFINED
56 #else
57 #define yy_scan_buffer yyjson_scan_buffer
58 #endif
59 
60 #ifdef yy_scan_string
61 #define yyjson_scan_string_ALREADY_DEFINED
62 #else
63 #define yy_scan_string yyjson_scan_string
64 #endif
65 
66 #ifdef yy_scan_bytes
67 #define yyjson_scan_bytes_ALREADY_DEFINED
68 #else
69 #define yy_scan_bytes yyjson_scan_bytes
70 #endif
71 
72 #ifdef yy_init_buffer
73 #define yyjson_init_buffer_ALREADY_DEFINED
74 #else
75 #define yy_init_buffer yyjson_init_buffer
76 #endif
77 
78 #ifdef yy_flush_buffer
79 #define yyjson_flush_buffer_ALREADY_DEFINED
80 #else
81 #define yy_flush_buffer yyjson_flush_buffer
82 #endif
83 
84 #ifdef yy_load_buffer_state
85 #define yyjson_load_buffer_state_ALREADY_DEFINED
86 #else
87 #define yy_load_buffer_state yyjson_load_buffer_state
88 #endif
89 
90 #ifdef yy_switch_to_buffer
91 #define yyjson_switch_to_buffer_ALREADY_DEFINED
92 #else
93 #define yy_switch_to_buffer yyjson_switch_to_buffer
94 #endif
95 
96 #ifdef yypush_buffer_state
97 #define yyjsonpush_buffer_state_ALREADY_DEFINED
98 #else
99 #define yypush_buffer_state yyjsonpush_buffer_state
100 #endif
101 
102 #ifdef yypop_buffer_state
103 #define yyjsonpop_buffer_state_ALREADY_DEFINED
104 #else
105 #define yypop_buffer_state yyjsonpop_buffer_state
106 #endif
107 
108 #ifdef yyensure_buffer_stack
109 #define yyjsonensure_buffer_stack_ALREADY_DEFINED
110 #else
111 #define yyensure_buffer_stack yyjsonensure_buffer_stack
112 #endif
113 
114 #ifdef yylex
115 #define yyjsonlex_ALREADY_DEFINED
116 #else
117 #define yylex yyjsonlex
118 #endif
119 
120 #ifdef yyrestart
121 #define yyjsonrestart_ALREADY_DEFINED
122 #else
123 #define yyrestart yyjsonrestart
124 #endif
125 
126 #ifdef yylex_init
127 #define yyjsonlex_init_ALREADY_DEFINED
128 #else
129 #define yylex_init yyjsonlex_init
130 #endif
131 
132 #ifdef yylex_init_extra
133 #define yyjsonlex_init_extra_ALREADY_DEFINED
134 #else
135 #define yylex_init_extra yyjsonlex_init_extra
136 #endif
137 
138 #ifdef yylex_destroy
139 #define yyjsonlex_destroy_ALREADY_DEFINED
140 #else
141 #define yylex_destroy yyjsonlex_destroy
142 #endif
143 
144 #ifdef yyget_debug
145 #define yyjsonget_debug_ALREADY_DEFINED
146 #else
147 #define yyget_debug yyjsonget_debug
148 #endif
149 
150 #ifdef yyset_debug
151 #define yyjsonset_debug_ALREADY_DEFINED
152 #else
153 #define yyset_debug yyjsonset_debug
154 #endif
155 
156 #ifdef yyget_extra
157 #define yyjsonget_extra_ALREADY_DEFINED
158 #else
159 #define yyget_extra yyjsonget_extra
160 #endif
161 
162 #ifdef yyset_extra
163 #define yyjsonset_extra_ALREADY_DEFINED
164 #else
165 #define yyset_extra yyjsonset_extra
166 #endif
167 
168 #ifdef yyget_in
169 #define yyjsonget_in_ALREADY_DEFINED
170 #else
171 #define yyget_in yyjsonget_in
172 #endif
173 
174 #ifdef yyset_in
175 #define yyjsonset_in_ALREADY_DEFINED
176 #else
177 #define yyset_in yyjsonset_in
178 #endif
179 
180 #ifdef yyget_out
181 #define yyjsonget_out_ALREADY_DEFINED
182 #else
183 #define yyget_out yyjsonget_out
184 #endif
185 
186 #ifdef yyset_out
187 #define yyjsonset_out_ALREADY_DEFINED
188 #else
189 #define yyset_out yyjsonset_out
190 #endif
191 
192 #ifdef yyget_leng
193 #define yyjsonget_leng_ALREADY_DEFINED
194 #else
195 #define yyget_leng yyjsonget_leng
196 #endif
197 
198 #ifdef yyget_text
199 #define yyjsonget_text_ALREADY_DEFINED
200 #else
201 #define yyget_text yyjsonget_text
202 #endif
203 
204 #ifdef yyget_lineno
205 #define yyjsonget_lineno_ALREADY_DEFINED
206 #else
207 #define yyget_lineno yyjsonget_lineno
208 #endif
209 
210 #ifdef yyset_lineno
211 #define yyjsonset_lineno_ALREADY_DEFINED
212 #else
213 #define yyset_lineno yyjsonset_lineno
214 #endif
215 
216 #ifdef yywrap
217 #define yyjsonwrap_ALREADY_DEFINED
218 #else
219 #define yywrap yyjsonwrap
220 #endif
221 
222 #ifdef yyalloc
223 #define yyjsonalloc_ALREADY_DEFINED
224 #else
225 #define yyalloc yyjsonalloc
226 #endif
227 
228 #ifdef yyrealloc
229 #define yyjsonrealloc_ALREADY_DEFINED
230 #else
231 #define yyrealloc yyjsonrealloc
232 #endif
233 
234 #ifdef yyfree
235 #define yyjsonfree_ALREADY_DEFINED
236 #else
237 #define yyfree yyjsonfree
238 #endif
239 
240 #ifdef yytext
241 #define yyjsontext_ALREADY_DEFINED
242 #else
243 #define yytext yyjsontext
244 #endif
245 
246 #ifdef yyleng
247 #define yyjsonleng_ALREADY_DEFINED
248 #else
249 #define yyleng yyjsonleng
250 #endif
251 
252 #ifdef yyin
253 #define yyjsonin_ALREADY_DEFINED
254 #else
255 #define yyin yyjsonin
256 #endif
257 
258 #ifdef yyout
259 #define yyjsonout_ALREADY_DEFINED
260 #else
261 #define yyout yyjsonout
262 #endif
263 
264 #ifdef yy_flex_debug
265 #define yyjson_flex_debug_ALREADY_DEFINED
266 #else
267 #define yy_flex_debug yyjson_flex_debug
268 #endif
269 
270 #ifdef yylineno
271 #define yyjsonlineno_ALREADY_DEFINED
272 #else
273 #define yylineno yyjsonlineno
274 #endif
275 
276 /* First, we deal with platform-specific or compiler-specific issues. */
277 
278 /* begin standard C headers. */
279 #include <stdio.h>
280 #include <string.h>
281 #include <errno.h>
282 #include <stdlib.h>
283 
284 /* end standard C headers. */
285 
286 /* flex integer type definitions */
287 
288 #ifndef FLEXINT_H
289 #define FLEXINT_H
290 
291 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
292 
293 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
294 
295 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
296  * if you want the limit (max/min) macros for int types.
297  */
298 #ifndef __STDC_LIMIT_MACROS
299 #define __STDC_LIMIT_MACROS 1
300 #endif
301 
302 #include <inttypes.h>
303 typedef int8_t flex_int8_t;
304 typedef uint8_t flex_uint8_t;
305 typedef int16_t flex_int16_t;
306 typedef uint16_t flex_uint16_t;
307 typedef int32_t flex_int32_t;
308 typedef uint32_t flex_uint32_t;
309 #else
310 typedef signed char flex_int8_t;
311 typedef short int flex_int16_t;
312 typedef int flex_int32_t;
313 typedef unsigned char flex_uint8_t;
314 typedef unsigned short int flex_uint16_t;
315 typedef unsigned int flex_uint32_t;
316 
317 /* Limits of integral types. */
318 #ifndef INT8_MIN
319 #define INT8_MIN (-128)
320 #endif
321 #ifndef INT16_MIN
322 #define INT16_MIN (-32767-1)
323 #endif
324 #ifndef INT32_MIN
325 #define INT32_MIN (-2147483647-1)
326 #endif
327 #ifndef INT8_MAX
328 #define INT8_MAX (127)
329 #endif
330 #ifndef INT16_MAX
331 #define INT16_MAX (32767)
332 #endif
333 #ifndef INT32_MAX
334 #define INT32_MAX (2147483647)
335 #endif
336 #ifndef UINT8_MAX
337 #define UINT8_MAX (255U)
338 #endif
339 #ifndef UINT16_MAX
340 #define UINT16_MAX (65535U)
341 #endif
342 #ifndef UINT32_MAX
343 #define UINT32_MAX (4294967295U)
344 #endif
345 
346 #ifndef SIZE_MAX
347 #define SIZE_MAX (~(size_t)0)
348 #endif
349 
350 #endif /* ! C99 */
351 
352 #endif /* ! FLEXINT_H */
353 
354 /* begin standard C++ headers. */
355 
356 /* TODO: this is always defined, so inline it */
357 #define yyconst const
358 
359 #if defined(__GNUC__) && __GNUC__ >= 3
360 #define yynoreturn __attribute__((__noreturn__))
361 #else
362 #define yynoreturn
363 #endif
364 
365 /* Returned upon end-of-file. */
366 #define YY_NULL 0
367 
368 /* Promotes a possibly negative, possibly signed char to an
369  * integer in range [0..255] for use as an array index.
370  */
371 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
372 
373 /* Enter a start condition. This macro really ought to take a parameter,
374  * but we do it the disgusting crufty way forced on us by the ()-less
375  * definition of BEGIN.
376  */
377 #define BEGIN (yy_start) = 1 + 2 *
378 /* Translate the current start state into a value that can be later handed
379  * to BEGIN to return to the state. The YYSTATE alias is for lex
380  * compatibility.
381  */
382 #define YY_START (((yy_start) - 1) / 2)
383 #define YYSTATE YY_START
384 /* Action number for EOF rule of a given start state. */
385 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
386 /* Special action meaning "start processing a new file". */
387 #define YY_NEW_FILE yyrestart( yyin )
388 #define YY_END_OF_BUFFER_CHAR 0
389 
390 /* Size of default input buffer. */
391 #ifndef YY_BUF_SIZE
392 #ifdef __ia64__
393 /* On IA-64, the buffer size is 16k, not 8k.
394  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
395  * Ditto for the __ia64__ case accordingly.
396  */
397 #define YY_BUF_SIZE 32768
398 #else
399 #define YY_BUF_SIZE 16384
400 #endif /* __ia64__ */
401 #endif
402 
403 /* The state buf must be large enough to hold one state per character in the main buffer.
404  */
405 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
406 
407 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
408 #define YY_TYPEDEF_YY_BUFFER_STATE
410 #endif
411 
412 #ifndef YY_TYPEDEF_YY_SIZE_T
413 #define YY_TYPEDEF_YY_SIZE_T
414 typedef size_t yy_size_t;
415 #endif
416 
417 extern int yyleng;
418 
419 extern FILE *yyin, *yyout;
420 
421 #define EOB_ACT_CONTINUE_SCAN 0
422 #define EOB_ACT_END_OF_FILE 1
423 #define EOB_ACT_LAST_MATCH 2
424 
425  #define YY_LESS_LINENO(n)
426  #define YY_LINENO_REWIND_TO(ptr)
427 
428 /* Return all but the first "n" matched characters back to the input stream. */
429 #define yyless(n) \
430  do \
431  { \
432  /* Undo effects of setting up yytext. */ \
433  int yyless_macro_arg = (n); \
434  YY_LESS_LINENO(yyless_macro_arg);\
435  *yy_cp = (yy_hold_char); \
436  YY_RESTORE_YY_MORE_OFFSET \
437  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
438  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
439  } \
440  while ( 0 )
441 #define unput(c) yyunput( c, (yytext_ptr) )
442 
443 #ifndef YY_STRUCT_YY_BUFFER_STATE
444 #define YY_STRUCT_YY_BUFFER_STATE
446  {
447  FILE *yy_input_file;
448 
449  char *yy_ch_buf; /* input buffer */
450  char *yy_buf_pos; /* current position in input buffer */
451 
452  /* Size of input buffer in bytes, not including room for EOB
453  * characters.
454  */
455  int yy_buf_size;
456 
457  /* Number of characters read into yy_ch_buf, not including EOB
458  * characters.
459  */
460  int yy_n_chars;
461 
462  /* Whether we "own" the buffer - i.e., we know we created it,
463  * and can realloc() it to grow it, and should free() it to
464  * delete it.
465  */
466  int yy_is_our_buffer;
467 
468  /* Whether this is an "interactive" input source; if so, and
469  * if we're using stdio for input, then we want to use getc()
470  * instead of fread(), to make sure we stop fetching input after
471  * each newline.
472  */
473  int yy_is_interactive;
474 
475  /* Whether we're considered to be at the beginning of a line.
476  * If so, '^' rules will be active on the next match, otherwise
477  * not.
478  */
479  int yy_at_bol;
480 
481  int yy_bs_lineno;
482  int yy_bs_column;
484  /* Whether to try to fill the input buffer when we reach the
485  * end of it.
486  */
487  int yy_fill_buffer;
488 
489  int yy_buffer_status;
490 
491 #define YY_BUFFER_NEW 0
492 #define YY_BUFFER_NORMAL 1
493  /* When an EOF's been seen but there's still some text to process
494  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
495  * shouldn't try reading from the input source any more. We might
496  * still have a bunch of tokens to match, though, because of
497  * possible backing-up.
498  *
499  * When we actually see the EOF, we change the status to "new"
500  * (via yyrestart()), so that the user can continue scanning by
501  * just pointing yyin at a new input file.
502  */
503 #define YY_BUFFER_EOF_PENDING 2
504 
505  };
506 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
507 
508 /* Stack of input buffers. */
509 static size_t yy_buffer_stack_top = 0;
510 static size_t yy_buffer_stack_max = 0;
513 /* We provide macros for accessing buffer states in case in the
514  * future we want to put the buffer states in a more general
515  * "scanner state".
516  *
517  * Returns the top of the stack, or NULL.
518  */
519 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
520  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
521  : NULL)
522 /* Same as previous macro, but useful when we know that the buffer stack is not
523  * NULL or when we need an lvalue. For internal use only.
524  */
525 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
526 
527 /* yy_hold_char holds the character lost when yytext is formed. */
528 static char yy_hold_char;
529 static int yy_n_chars; /* number of characters read into yy_ch_buf */
530 int yyleng;
531 
532 /* Points to current character in buffer. */
533 static char *yy_c_buf_p = NULL;
534 static int yy_init = 0; /* whether we need to initialize */
535 static int yy_start = 0; /* start state number */
536 
537 /* Flag which is used to allow yywrap()'s to do buffer switches
538  * instead of setting up a fresh yyin. A bit of a hack ...
539  */
541 
542 void yyrestart ( FILE *input_file );
543 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
544 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
547 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
548 void yypop_buffer_state ( void );
549 
550 static void yyensure_buffer_stack ( void );
551 static void yy_load_buffer_state ( void );
552 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
553 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
554 
555 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
556 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
557 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
558 
559 void *yyalloc ( yy_size_t );
560 void *yyrealloc ( void *, yy_size_t );
561 void yyfree ( void * );
562 
563 #define yy_new_buffer yy_create_buffer
564 #define yy_set_interactive(is_interactive) \
565  { \
566  if ( ! YY_CURRENT_BUFFER ){ \
567  yyensure_buffer_stack (); \
568  YY_CURRENT_BUFFER_LVALUE = \
569  yy_create_buffer( yyin, YY_BUF_SIZE ); \
570  } \
571  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
572  }
573 #define yy_set_bol(at_bol) \
574  { \
575  if ( ! YY_CURRENT_BUFFER ){\
576  yyensure_buffer_stack (); \
577  YY_CURRENT_BUFFER_LVALUE = \
578  yy_create_buffer( yyin, YY_BUF_SIZE ); \
579  } \
580  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
581  }
582 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
583 
584 #define yyjsonwrap() (/*CONSTCOND*/1)
585 #define YY_SKIP_YYWRAP
587 
588 FILE *yyin = NULL, *yyout = NULL;
589 
590 typedef int yy_state_type;
591 
592 extern int yylineno;
593 int yylineno = 1;
594 
595 extern char *yytext;
596 #ifdef yytext_ptr
597 #undef yytext_ptr
598 #endif
599 #define yytext_ptr yytext
600 
601 static yy_state_type yy_get_previous_state ( void );
602 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
603 static int yy_get_next_buffer ( void );
604 static void yynoreturn yy_fatal_error ( const char* msg );
605 
606 /* Done after the current pattern has been matched and before the
607  * corresponding action - sets up yytext.
608  */
609 #define YY_DO_BEFORE_ACTION \
610  (yytext_ptr) = yy_bp; \
611  yyleng = (int) (yy_cp - yy_bp); \
612  (yy_hold_char) = *yy_cp; \
613  *yy_cp = '\0'; \
614  (yy_c_buf_p) = yy_cp;
615 #define YY_NUM_RULES 8
616 #define YY_END_OF_BUFFER 9
617 /* This struct is not used in this scanner,
618  but its presence is necessary. */
619 struct yy_trans_info
620  {
623  };
624 static const flex_int16_t yy_accept[46] =
625  { 0,
626  0, 0, 9, 7, 6, 6, 6, 7, 2, 2,
627  7, 7, 7, 0, 1, 0, 2, 2, 0, 0,
628  0, 2, 0, 0, 0, 0, 2, 2, 0, 2,
629  0, 0, 0, 0, 0, 0, 0, 5, 3, 0,
630  0, 2, 4, 0, 0
631  } ;
632 
633 static const YY_CHAR yy_ec[256] =
634  { 0,
635  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
636  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
637  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
638  1, 2, 1, 4, 1, 1, 1, 1, 1, 1,
639  1, 1, 5, 1, 6, 7, 8, 9, 10, 10,
640  10, 10, 10, 10, 10, 10, 10, 1, 1, 1,
641  1, 1, 1, 1, 11, 11, 11, 11, 12, 11,
642  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
643  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
644  1, 13, 1, 1, 1, 1, 14, 15, 11, 11,
645 
646  16, 17, 1, 1, 1, 1, 1, 18, 1, 19,
647  1, 1, 1, 20, 21, 22, 23, 1, 1, 1,
648  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
649  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
650  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
651  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
652  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
653  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
654  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
655  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
656 
657  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
658  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
659  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
660  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
661  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
662  1, 1, 1, 1, 1
663  } ;
664 
665 static const YY_CHAR yy_meta[24] =
666  { 0,
667  1, 1, 1, 2, 1, 1, 1, 2, 3, 3,
668  3, 3, 2, 3, 4, 3, 4, 1, 2, 2,
669  1, 2, 2
670  } ;
671 
672 static const flex_int16_t yy_base[53] =
673  { 0,
674  0, 21, 93, 94, 94, 94, 1, 2, 21, 37,
675  69, 43, 42, 3, 94, 29, 29, 11, 25, 49,
676  0, 0, 30, 24, 16, 0, 0, 51, 41, 47,
677  11, 11, 10, 0, 63, 0, 2, 94, 94, 0,
678  55, 61, 94, 0, 94, 73, 77, 80, 82, 84,
679  86, 88
680  } ;
681 
682 static const flex_int16_t yy_def[53] =
683  { 0,
684  46, 46, 45, 45, 45, 45, 47, 45, 45, 45,
685  45, 45, 45, 47, 45, 48, 45, 10, 45, 45,
686  20, 10, 45, 45, 45, 49, 18, 45, 45, 45,
687  45, 45, 45, 50, 45, 35, 45, 45, 45, 51,
688  45, 45, 45, 52, 0, 45, 45, 45, 45, 45,
689  45, 45
690  } ;
691 
692 static const flex_int16_t yy_nxt[118] =
693  { 0,
694  45, 5, 6, 7, 15, 8, 15, 45, 9, 10,
695  17, 18, 45, 16, 45, 16, 11, 43, 12, 27,
696  27, 13, 5, 6, 7, 39, 8, 19, 38, 9,
697  10, 37, 20, 28, 28, 19, 21, 11, 33, 12,
698  20, 32, 13, 19, 21, 22, 22, 31, 20, 30,
699  30, 26, 21, 29, 29, 30, 30, 30, 30, 28,
700  28, 25, 35, 42, 42, 24, 36, 41, 41, 42,
701  42, 42, 42, 4, 4, 4, 4, 14, 14, 14,
702  14, 14, 23, 14, 34, 34, 40, 40, 44, 44,
703  14, 14, 45, 3, 45, 45, 45, 45, 45, 45,
704 
705  45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
706  45, 45, 45, 45, 45, 45, 45
707  } ;
708 
709 static const flex_int16_t yy_chk[118] =
710  { 0,
711  0, 1, 1, 1, 7, 1, 14, 0, 1, 1,
712  8, 8, 0, 7, 0, 14, 1, 37, 1, 18,
713  18, 1, 2, 2, 2, 33, 2, 9, 32, 2,
714  2, 31, 9, 19, 19, 17, 9, 2, 25, 2,
715  17, 24, 2, 10, 17, 10, 10, 23, 10, 29,
716  29, 16, 10, 20, 20, 30, 30, 20, 20, 28,
717  28, 13, 28, 41, 41, 12, 28, 35, 35, 42,
718  42, 35, 35, 46, 46, 46, 46, 47, 47, 47,
719  47, 48, 11, 48, 49, 49, 50, 50, 51, 51,
720  52, 52, 3, 45, 45, 45, 45, 45, 45, 45,
721 
722  45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
723  45, 45, 45, 45, 45, 45, 45
724  } ;
725 
728 
729 extern int yy_flex_debug;
731 
732 /* The intent behind this definition is that it'll catch
733  * any uses of REJECT which flex missed.
734  */
735 #define REJECT reject_used_but_not_detected
736 #define yymore() yymore_used_but_not_detected
737 #define YY_MORE_ADJ 0
738 #define YY_RESTORE_YY_MORE_OFFSET
739 char *yytext;
740 #line 1 "scanner.l"
741 #line 2 "scanner.l"
742 // Strictly follows http://www.json.org/
743 //
744 // The rule for char and its dependencies is based on
745 // https://gist.github.com/justjkk/436828
746 // which is MIT-licensed (retrieved on 2019-09-03)
747 #line 747 "json_lex.yy.cpp"
748 #define YY_NO_INPUT 1
749 #define YY_NO_UNISTD_H 1
750 #line 18 "scanner.l"
751 
752 #if defined _MSC_VER
753 // signed/unsigned mismatch
754 #pragma warning(disable:4365)
755 // macro re-definition: flex conditonally defines INT32_MAX et al. and thus
756 // they are set before library headers get to define them
757 #pragma warning(disable:4005)
758 #endif
759 
760 #define PARSER json_parser
761 
762 #include "json_parser.h"
763 #include "json_y.tab.h"
764 
765 #include <util/pragma_wsign_compare.def>
766 #include <util/pragma_wnull_conversion.def>
767 #include <util/pragma_wdeprecated_register.def>
768 
769 #line 769 "json_lex.yy.cpp"
770 #line 770 "json_lex.yy.cpp"
771 
772 #define INITIAL 0
773 
774 #ifndef YY_NO_UNISTD_H
775 /* Special case for "unistd.h", since it is non-ANSI. We include it way
776  * down here because we want the user's section 1 to have been scanned first.
777  * The user has a chance to override it with an option.
778  */
779 #include <unistd.h>
780 #endif
781 
782 #ifndef YY_EXTRA_TYPE
783 #define YY_EXTRA_TYPE void *
784 #endif
785 
786 static int yy_init_globals ( void );
787 
788 /* Accessor methods to globals.
789  These are made visible to non-reentrant scanners for convenience. */
790 
791 int yylex_destroy ( void );
792 
793 int yyget_debug ( void );
794 
795 void yyset_debug ( int debug_flag );
796 
798 
799 void yyset_extra ( YY_EXTRA_TYPE user_defined );
800 
801 FILE *yyget_in ( void );
802 
803 void yyset_in ( FILE * _in_str );
804 
805 FILE *yyget_out ( void );
806 
807 void yyset_out ( FILE * _out_str );
808 
809  int yyget_leng ( void );
810 
811 char *yyget_text ( void );
812 
813 int yyget_lineno ( void );
814 
815 void yyset_lineno ( int _line_number );
816 
817 /* Macros after this point can all be overridden by user definitions in
818  * section 1.
819  */
820 
821 #ifndef YY_SKIP_YYWRAP
822 #ifdef __cplusplus
823 extern "C" int yywrap ( void );
824 #else
825 extern int yywrap ( void );
826 #endif
827 #endif
828 
829 #ifndef YY_NO_UNPUT
830 
831 #endif
832 
833 #ifndef yytext_ptr
834 static void yy_flex_strncpy ( char *, const char *, int );
835 #endif
836 
837 #ifdef YY_NEED_STRLEN
838 static int yy_flex_strlen ( const char * );
839 #endif
840 
841 #ifndef YY_NO_INPUT
842 #ifdef __cplusplus
843 static int yyinput ( void );
844 #else
845 static int input ( void );
846 #endif
847 
848 #endif
849 
850 /* Amount of stuff to slurp up with each read. */
851 #ifndef YY_READ_BUF_SIZE
852 #ifdef __ia64__
853 /* On IA-64, the buffer size is 16k, not 8k */
854 #define YY_READ_BUF_SIZE 16384
855 #else
856 #define YY_READ_BUF_SIZE 8192
857 #endif /* __ia64__ */
858 #endif
859 
860 /* Copy whatever the last rule matched to the standard output. */
861 #ifndef ECHO
862 /* This used to be an fputs(), but since the string might contain NUL's,
863  * we now use fwrite().
864  */
865 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
866 #endif
867 
868 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
869  * is returned in "result".
870  */
871 #ifndef YY_INPUT
872 #define YY_INPUT(buf,result,max_size) \
873  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
874  { \
875  int c = '*'; \
876  int n; \
877  for ( n = 0; n < max_size && \
878  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
879  buf[n] = (char) c; \
880  if ( c == '\n' ) \
881  buf[n++] = (char) c; \
882  if ( c == EOF && ferror( yyin ) ) \
883  YY_FATAL_ERROR( "input in flex scanner failed" ); \
884  result = n; \
885  } \
886  else \
887  { \
888  errno=0; \
889  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
890  { \
891  if( errno != EINTR) \
892  { \
893  YY_FATAL_ERROR( "input in flex scanner failed" ); \
894  break; \
895  } \
896  errno=0; \
897  clearerr(yyin); \
898  } \
899  }\
900 \
901 
902 #endif
903 
904 /* No semi-colon after return; correct usage is to write "yyterminate();" -
905  * we don't want an extra ';' after the "return" because that will cause
906  * some compilers to complain about unreachable statements.
907  */
908 #ifndef yyterminate
909 #define yyterminate() return YY_NULL
910 #endif
911 
912 /* Number of entries by which start-condition stack grows. */
913 #ifndef YY_START_STACK_INCR
914 #define YY_START_STACK_INCR 25
915 #endif
916 
917 /* Report a fatal error. */
918 #ifndef YY_FATAL_ERROR
919 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
920 #endif
921 
922 /* end tables serialization structures and prototypes */
923 
924 /* Default declaration of generated scanner - a define so the user can
925  * easily add parameters.
926  */
927 #ifndef YY_DECL
928 #define YY_DECL_IS_OURS 1
929 
930 extern int yylex (void);
931 
932 #define YY_DECL int yylex (void)
933 #endif /* !YY_DECL */
934 
935 /* Code executed at the beginning of each rule, after yytext and yyleng
936  * have been set up.
937  */
938 #ifndef YY_USER_ACTION
939 #define YY_USER_ACTION
940 #endif
941 
942 /* Code executed at the end of each rule. */
943 #ifndef YY_BREAK
944 #define YY_BREAK /*LINTED*/break;
945 #endif
946 
947 #define YY_RULE_SETUP \
948  YY_USER_ACTION
949 
953 {
954  yy_state_type yy_current_state;
955  char *yy_cp, *yy_bp;
956  int yy_act;
957 
958  if ( !(yy_init) )
959  {
960  (yy_init) = 1;
961 
962 #ifdef YY_USER_INIT
963  YY_USER_INIT;
964 #endif
965 
966  if ( ! (yy_start) )
967  (yy_start) = 1; /* first start state */
968 
969  if ( ! yyin )
970  yyin = stdin;
971 
972  if ( ! yyout )
973  yyout = stdout;
974 
975  if ( ! YY_CURRENT_BUFFER ) {
979  }
980 
982  }
983 
984  {
985 #line 55 "scanner.l"
986 
987 
988 #line 988 "json_lex.yy.cpp"
989 
990  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
991  {
992  yy_cp = (yy_c_buf_p);
993 
994  /* Support of yytext. */
995  *yy_cp = (yy_hold_char);
996 
997  /* yy_bp points to the position in yy_ch_buf of the start of
998  * the current run.
999  */
1000  yy_bp = yy_cp;
1001 
1002  yy_current_state = (yy_start);
1003 yy_match:
1004  do
1005  {
1006  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1007  if ( yy_accept[yy_current_state] )
1008  {
1009  (yy_last_accepting_state) = yy_current_state;
1010  (yy_last_accepting_cpos) = yy_cp;
1011  }
1012  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1013  {
1014  yy_current_state = (int) yy_def[yy_current_state];
1015  if ( yy_current_state >= 46 )
1016  yy_c = yy_meta[yy_c];
1017  }
1018  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1019  ++yy_cp;
1020  }
1021  while ( yy_current_state != 45 );
1022  yy_cp = (yy_last_accepting_cpos);
1023  yy_current_state = (yy_last_accepting_state);
1024 
1025 yy_find_action:
1026  yy_act = yy_accept[yy_current_state];
1027 
1029 
1030 do_action: /* This label is used only to access EOF actions. */
1031 
1032  switch ( yy_act )
1033  { /* beginning of action switch */
1034  case 0: /* must back up */
1035  /* undo the effects of YY_DO_BEFORE_ACTION */
1036  *yy_cp = (yy_hold_char);
1037  yy_cp = (yy_last_accepting_cpos);
1038  yy_current_state = (yy_last_accepting_state);
1039  goto yy_find_action;
1040 
1041 case 1:
1042 /* rule 1 can match eol */
1044 #line 57 "scanner.l"
1045 { return TOK_STRING; }
1046  YY_BREAK
1047 case 2:
1049 #line 58 "scanner.l"
1050 { return TOK_NUMBER; }
1051  YY_BREAK
1052 case 3:
1054 #line 59 "scanner.l"
1055 { return TOK_TRUE; }
1056  YY_BREAK
1057 case 4:
1059 #line 60 "scanner.l"
1060 { return TOK_FALSE; }
1061  YY_BREAK
1062 case 5:
1064 #line 61 "scanner.l"
1065 { return TOK_NULL; }
1066  YY_BREAK
1067 case 6:
1068 /* rule 6 can match eol */
1070 #line 63 "scanner.l"
1071 { /* eat */ }
1072  YY_BREAK
1073 case 7:
1075 #line 64 "scanner.l"
1076 { return yytext[0]; }
1077  YY_BREAK
1078 case 8:
1080 #line 66 "scanner.l"
1081 YY_FATAL_ERROR( "flex scanner jammed" );
1082  YY_BREAK
1083 #line 1083 "json_lex.yy.cpp"
1084 case YY_STATE_EOF(INITIAL):
1085  yyterminate();
1086 
1087  case YY_END_OF_BUFFER:
1088  {
1089  /* Amount of text matched not including the EOB char. */
1090  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1091 
1092  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1093  *yy_cp = (yy_hold_char);
1095 
1096  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1097  {
1098  /* We're scanning a new file or input source. It's
1099  * possible that this happened because the user
1100  * just pointed yyin at a new source and called
1101  * yylex(). If so, then we have to assure
1102  * consistency between YY_CURRENT_BUFFER and our
1103  * globals. Here is the right place to do so, because
1104  * this is the first action (other than possibly a
1105  * back-up) that will match for the new input source.
1106  */
1107  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1108  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1109  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1110  }
1111 
1112  /* Note that here we test for yy_c_buf_p "<=" to the position
1113  * of the first EOB in the buffer, since yy_c_buf_p will
1114  * already have been incremented past the NUL character
1115  * (since all states make transitions on EOB to the
1116  * end-of-buffer state). Contrast this with the test
1117  * in input().
1118  */
1119  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1120  { /* This was really a NUL. */
1121  yy_state_type yy_next_state;
1122 
1123  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1124 
1125  yy_current_state = yy_get_previous_state( );
1126 
1127  /* Okay, we're now positioned to make the NUL
1128  * transition. We couldn't have
1129  * yy_get_previous_state() go ahead and do it
1130  * for us because it doesn't know how to deal
1131  * with the possibility of jamming (and we don't
1132  * want to build jamming into it because then it
1133  * will run more slowly).
1134  */
1135 
1136  yy_next_state = yy_try_NUL_trans( yy_current_state );
1137 
1138  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1139 
1140  if ( yy_next_state )
1141  {
1142  /* Consume the NUL. */
1143  yy_cp = ++(yy_c_buf_p);
1144  yy_current_state = yy_next_state;
1145  goto yy_match;
1146  }
1147 
1148  else
1149  {
1150  yy_cp = (yy_last_accepting_cpos);
1151  yy_current_state = (yy_last_accepting_state);
1152  goto yy_find_action;
1153  }
1154  }
1155 
1156  else switch ( yy_get_next_buffer( ) )
1157  {
1158  case EOB_ACT_END_OF_FILE:
1159  {
1161 
1162  if ( yywrap( ) )
1163  {
1164  /* Note: because we've taken care in
1165  * yy_get_next_buffer() to have set up
1166  * yytext, we can now set up
1167  * yy_c_buf_p so that if some total
1168  * hoser (like flex itself) wants to
1169  * call the scanner after we return the
1170  * YY_NULL, it'll still work - another
1171  * YY_NULL will get returned.
1172  */
1174 
1175  yy_act = YY_STATE_EOF(YY_START);
1176  goto do_action;
1177  }
1178 
1179  else
1180  {
1181  if ( ! (yy_did_buffer_switch_on_eof) )
1182  YY_NEW_FILE;
1183  }
1184  break;
1185  }
1186 
1187  case EOB_ACT_CONTINUE_SCAN:
1188  (yy_c_buf_p) =
1189  (yytext_ptr) + yy_amount_of_matched_text;
1190 
1191  yy_current_state = yy_get_previous_state( );
1192 
1193  yy_cp = (yy_c_buf_p);
1194  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1195  goto yy_match;
1196 
1197  case EOB_ACT_LAST_MATCH:
1198  (yy_c_buf_p) =
1199  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1200 
1201  yy_current_state = yy_get_previous_state( );
1202 
1203  yy_cp = (yy_c_buf_p);
1204  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1205  goto yy_find_action;
1206  }
1207  break;
1208  }
1209 
1210  default:
1212  "fatal flex scanner internal error--no action found" );
1213  } /* end of action switch */
1214  } /* end of scanning one token */
1215  } /* end of user's declarations */
1216 } /* end of yylex */
1217 
1218 /* yy_get_next_buffer - try to read in a new buffer
1219  *
1220  * Returns a code representing an action:
1221  * EOB_ACT_LAST_MATCH -
1222  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1223  * EOB_ACT_END_OF_FILE - end of file
1224  */
1225 static int yy_get_next_buffer (void)
1226 {
1227  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1228  char *source = (yytext_ptr);
1229  int number_to_move, i;
1230  int ret_val;
1231 
1232  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1234  "fatal flex scanner internal error--end of buffer missed" );
1235 
1236  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1237  { /* Don't try to fill the buffer, so this is an EOF. */
1238  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1239  {
1240  /* We matched a single character, the EOB, so
1241  * treat this as a final EOF.
1242  */
1243  return EOB_ACT_END_OF_FILE;
1244  }
1245 
1246  else
1247  {
1248  /* We matched some text prior to the EOB, first
1249  * process it.
1250  */
1251  return EOB_ACT_LAST_MATCH;
1252  }
1253  }
1254 
1255  /* Try to read more data. */
1256 
1257  /* First move last chars to start of buffer. */
1258  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1259 
1260  for ( i = 0; i < number_to_move; ++i )
1261  *(dest++) = *(source++);
1262 
1263  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1264  /* don't do the read, it's not guaranteed to return an EOF,
1265  * just force an EOF
1266  */
1267  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1268 
1269  else
1270  {
1271  int num_to_read =
1272  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1273 
1274  while ( num_to_read <= 0 )
1275  { /* Not enough room in the buffer - grow it. */
1276 
1277  /* just a shorter name for the current buffer */
1279 
1280  int yy_c_buf_p_offset =
1281  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1282 
1283  if ( b->yy_is_our_buffer )
1284  {
1285  int new_size = b->yy_buf_size * 2;
1286 
1287  if ( new_size <= 0 )
1288  b->yy_buf_size += b->yy_buf_size / 8;
1289  else
1290  b->yy_buf_size *= 2;
1291 
1292  b->yy_ch_buf = (char *)
1293  /* Include room in for 2 EOB chars. */
1294  yyrealloc( (void *) b->yy_ch_buf,
1295  (yy_size_t) (b->yy_buf_size + 2) );
1296  }
1297  else
1298  /* Can't grow it, we don't own it. */
1299  b->yy_ch_buf = NULL;
1300 
1301  if ( ! b->yy_ch_buf )
1303  "fatal error - scanner input buffer overflow" );
1304 
1305  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1306 
1307  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1308  number_to_move - 1;
1309 
1310  }
1311 
1312  if ( num_to_read > YY_READ_BUF_SIZE )
1313  num_to_read = YY_READ_BUF_SIZE;
1314 
1315  /* Read in more data. */
1316  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1317  (yy_n_chars), num_to_read );
1318 
1319  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1320  }
1321 
1322  if ( (yy_n_chars) == 0 )
1323  {
1324  if ( number_to_move == YY_MORE_ADJ )
1325  {
1326  ret_val = EOB_ACT_END_OF_FILE;
1327  yyrestart( yyin );
1328  }
1329 
1330  else
1331  {
1332  ret_val = EOB_ACT_LAST_MATCH;
1333  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1335  }
1336  }
1337 
1338  else
1339  ret_val = EOB_ACT_CONTINUE_SCAN;
1340 
1341  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1342  /* Extend the array by 50%, plus the number we really need. */
1343  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1344  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1345  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1346  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1347  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1348  /* "- 2" to take care of EOB's */
1349  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1350  }
1351 
1352  (yy_n_chars) += number_to_move;
1355 
1356  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1357 
1358  return ret_val;
1359 }
1360 
1361 /* yy_get_previous_state - get the state just before the EOB char was reached */
1362 
1364 {
1365  yy_state_type yy_current_state;
1366  char *yy_cp;
1367 
1368  yy_current_state = (yy_start);
1369 
1370  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1371  {
1372  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1373  if ( yy_accept[yy_current_state] )
1374  {
1375  (yy_last_accepting_state) = yy_current_state;
1376  (yy_last_accepting_cpos) = yy_cp;
1377  }
1378  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1379  {
1380  yy_current_state = (int) yy_def[yy_current_state];
1381  if ( yy_current_state >= 46 )
1382  yy_c = yy_meta[yy_c];
1383  }
1384  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1385  }
1386 
1387  return yy_current_state;
1388 }
1389 
1390 /* yy_try_NUL_trans - try to make a transition on the NUL character
1391  *
1392  * synopsis
1393  * next_state = yy_try_NUL_trans( current_state );
1394  */
1395  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1396 {
1397  int yy_is_jam;
1398  char *yy_cp = (yy_c_buf_p);
1399 
1400  YY_CHAR yy_c = 1;
1401  if ( yy_accept[yy_current_state] )
1402  {
1403  (yy_last_accepting_state) = yy_current_state;
1404  (yy_last_accepting_cpos) = yy_cp;
1405  }
1406  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1407  {
1408  yy_current_state = (int) yy_def[yy_current_state];
1409  if ( yy_current_state >= 46 )
1410  yy_c = yy_meta[yy_c];
1411  }
1412  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1413  yy_is_jam = (yy_current_state == 45);
1414 
1415  return yy_is_jam ? 0 : yy_current_state;
1416 }
1417 
1418 #ifndef YY_NO_UNPUT
1419 
1420 #endif
1421 
1422 #ifndef YY_NO_INPUT
1423 #ifdef __cplusplus
1424  static int yyinput (void)
1425 #else
1426  static int input (void)
1427 #endif
1428 
1429 {
1430  int c;
1431 
1432  *(yy_c_buf_p) = (yy_hold_char);
1433 
1434  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1435  {
1436  /* yy_c_buf_p now points to the character we want to return.
1437  * If this occurs *before* the EOB characters, then it's a
1438  * valid NUL; if not, then we've hit the end of the buffer.
1439  */
1440  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1441  /* This was really a NUL. */
1442  *(yy_c_buf_p) = '\0';
1443 
1444  else
1445  { /* need more input */
1446  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1447  ++(yy_c_buf_p);
1448 
1449  switch ( yy_get_next_buffer( ) )
1450  {
1451  case EOB_ACT_LAST_MATCH:
1452  /* This happens because yy_g_n_b()
1453  * sees that we've accumulated a
1454  * token and flags that we need to
1455  * try matching the token before
1456  * proceeding. But for input(),
1457  * there's no matching to consider.
1458  * So convert the EOB_ACT_LAST_MATCH
1459  * to EOB_ACT_END_OF_FILE.
1460  */
1461 
1462  /* Reset buffer status. */
1463  yyrestart( yyin );
1464 
1465  /*FALLTHROUGH*/
1466 
1467  case EOB_ACT_END_OF_FILE:
1468  {
1469  if ( yywrap( ) )
1470  return 0;
1471 
1472  if ( ! (yy_did_buffer_switch_on_eof) )
1473  YY_NEW_FILE;
1474 #ifdef __cplusplus
1475  return yyinput();
1476 #else
1477  return input();
1478 #endif
1479  }
1480 
1481  case EOB_ACT_CONTINUE_SCAN:
1482  (yy_c_buf_p) = (yytext_ptr) + offset;
1483  break;
1484  }
1485  }
1486  }
1487 
1488  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1489  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1490  (yy_hold_char) = *++(yy_c_buf_p);
1491 
1492  return c;
1493 }
1494 #endif /* ifndef YY_NO_INPUT */
1495 
1501  void yyrestart (FILE * input_file )
1502 {
1503 
1504  if ( ! YY_CURRENT_BUFFER ){
1508  }
1509 
1510  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1512 }
1513 
1519 {
1520 
1521  /* TODO. We should be able to replace this entire function body
1522  * with
1523  * yypop_buffer_state();
1524  * yypush_buffer_state(new_buffer);
1525  */
1527  if ( YY_CURRENT_BUFFER == new_buffer )
1528  return;
1529 
1530  if ( YY_CURRENT_BUFFER )
1531  {
1532  /* Flush out information for old buffer. */
1533  *(yy_c_buf_p) = (yy_hold_char);
1534  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1535  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1536  }
1537 
1538  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1540 
1541  /* We don't actually know whether we did this switch during
1542  * EOF (yywrap()) processing, but the only time this flag
1543  * is looked at is after yywrap() is called, so it's safe
1544  * to go ahead and always set it.
1545  */
1547 }
1548 
1549 static void yy_load_buffer_state (void)
1550 {
1551  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1552  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1553  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1554  (yy_hold_char) = *(yy_c_buf_p);
1555 }
1556 
1564 {
1565  YY_BUFFER_STATE b;
1566 
1567  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1568  if ( ! b )
1569  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1570 
1571  b->yy_buf_size = size;
1572 
1573  /* yy_ch_buf has to be 2 characters longer than the size given because
1574  * we need to put in 2 end-of-buffer characters.
1575  */
1576  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1577  if ( ! b->yy_ch_buf )
1578  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1579 
1580  b->yy_is_our_buffer = 1;
1581 
1582  yy_init_buffer( b, file );
1583 
1584  return b;
1585 }
1586 
1592 {
1593 
1594  if ( ! b )
1595  return;
1596 
1597  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1599 
1600  if ( b->yy_is_our_buffer )
1601  yyfree( (void *) b->yy_ch_buf );
1602 
1603  yyfree( (void *) b );
1604 }
1605 
1606 /* Initializes or reinitializes a buffer.
1607  * This function is sometimes called more than once on the same buffer,
1608  * such as during a yyrestart() or at EOF.
1609  */
1610  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1611 
1612 {
1613  int oerrno = errno;
1614 
1615  yy_flush_buffer( b );
1616 
1617  b->yy_input_file = file;
1618  b->yy_fill_buffer = 1;
1619 
1620  /* If b is the current buffer, then yy_init_buffer was _probably_
1621  * called from yyrestart() or through yy_get_next_buffer.
1622  * In that case, we don't want to reset the lineno or column.
1623  */
1624  if (b != YY_CURRENT_BUFFER){
1625  b->yy_bs_lineno = 1;
1626  b->yy_bs_column = 0;
1627  }
1628 
1629  b->yy_is_interactive = 0;
1630 
1631  errno = oerrno;
1632 }
1633 
1639 {
1640  if ( ! b )
1641  return;
1642 
1643  b->yy_n_chars = 0;
1644 
1645  /* We always need two end-of-buffer characters. The first causes
1646  * a transition to the end-of-buffer state. The second causes
1647  * a jam in that state.
1648  */
1651 
1652  b->yy_buf_pos = &b->yy_ch_buf[0];
1653 
1654  b->yy_at_bol = 1;
1656 
1657  if ( b == YY_CURRENT_BUFFER )
1659 }
1660 
1668 {
1669  if (new_buffer == NULL)
1670  return;
1671 
1673 
1674  /* This block is copied from yy_switch_to_buffer. */
1675  if ( YY_CURRENT_BUFFER )
1676  {
1677  /* Flush out information for old buffer. */
1678  *(yy_c_buf_p) = (yy_hold_char);
1679  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1680  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1681  }
1682 
1683  /* Only push if top exists. Otherwise, replace top. */
1684  if (YY_CURRENT_BUFFER)
1685  (yy_buffer_stack_top)++;
1686  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1687 
1688  /* copied from yy_switch_to_buffer. */
1691 }
1692 
1698 {
1699  if (!YY_CURRENT_BUFFER)
1700  return;
1701 
1703  YY_CURRENT_BUFFER_LVALUE = NULL;
1704  if ((yy_buffer_stack_top) > 0)
1705  --(yy_buffer_stack_top);
1706 
1707  if (YY_CURRENT_BUFFER) {
1710  }
1711 }
1712 
1713 /* Allocates the stack if it does not exist.
1714  * Guarantees space for at least one push.
1715  */
1716 static void yyensure_buffer_stack (void)
1717 {
1718  yy_size_t num_to_alloc;
1719 
1720  if (!(yy_buffer_stack)) {
1721 
1722  /* First allocation is just for 2 elements, since we don't know if this
1723  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1724  * immediate realloc on the next call.
1725  */
1726  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1728  (num_to_alloc * sizeof(struct yy_buffer_state*)
1729  );
1730  if ( ! (yy_buffer_stack) )
1731  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1732 
1733  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1734 
1735  (yy_buffer_stack_max) = num_to_alloc;
1736  (yy_buffer_stack_top) = 0;
1737  return;
1738  }
1739 
1740  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1741 
1742  /* Increase the buffer to prepare for a possible push. */
1743  yy_size_t grow_size = 8 /* arbitrary grow size */;
1744 
1745  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1747  ((yy_buffer_stack),
1748  num_to_alloc * sizeof(struct yy_buffer_state*)
1749  );
1750  if ( ! (yy_buffer_stack) )
1751  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1752 
1753  /* zero only the new slots.*/
1754  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1755  (yy_buffer_stack_max) = num_to_alloc;
1756  }
1757 }
1758 
1766 {
1767  YY_BUFFER_STATE b;
1768 
1769  if ( size < 2 ||
1770  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1771  base[size-1] != YY_END_OF_BUFFER_CHAR )
1772  /* They forgot to leave room for the EOB's. */
1773  return NULL;
1774 
1775  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1776  if ( ! b )
1777  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1778 
1779  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1780  b->yy_buf_pos = b->yy_ch_buf = base;
1781  b->yy_is_our_buffer = 0;
1782  b->yy_input_file = NULL;
1783  b->yy_n_chars = b->yy_buf_size;
1784  b->yy_is_interactive = 0;
1785  b->yy_at_bol = 1;
1786  b->yy_fill_buffer = 0;
1788 
1789  yy_switch_to_buffer( b );
1790 
1791  return b;
1792 }
1793 
1802 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1803 {
1804 
1805  return yy_scan_bytes( yystr, (int) strlen(yystr) );
1806 }
1807 
1815 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1816 {
1817  YY_BUFFER_STATE b;
1818  char *buf;
1819  yy_size_t n;
1820  int i;
1821 
1822  /* Get memory for full buffer, including space for trailing EOB's. */
1823  n = (yy_size_t) (_yybytes_len + 2);
1824  buf = (char *) yyalloc( n );
1825  if ( ! buf )
1826  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1827 
1828  for ( i = 0; i < _yybytes_len; ++i )
1829  buf[i] = yybytes[i];
1830 
1831  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1832 
1833  b = yy_scan_buffer( buf, n );
1834  if ( ! b )
1835  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1836 
1837  /* It's okay to grow etc. this buffer, and we should throw it
1838  * away when we're done.
1839  */
1840  b->yy_is_our_buffer = 1;
1841 
1842  return b;
1843 }
1844 
1845 #ifndef YY_EXIT_FAILURE
1846 #define YY_EXIT_FAILURE 2
1847 #endif
1848 
1849 static void yynoreturn yy_fatal_error (const char* msg )
1850 {
1851  fprintf( stderr, "%s\n", msg );
1852  exit( YY_EXIT_FAILURE );
1853 }
1854 
1855 /* Redefine yyless() so it works in section 3 code. */
1856 
1857 #undef yyless
1858 #define yyless(n) \
1859  do \
1860  { \
1861  /* Undo effects of setting up yytext. */ \
1862  int yyless_macro_arg = (n); \
1863  YY_LESS_LINENO(yyless_macro_arg);\
1864  yytext[yyleng] = (yy_hold_char); \
1865  (yy_c_buf_p) = yytext + yyless_macro_arg; \
1866  (yy_hold_char) = *(yy_c_buf_p); \
1867  *(yy_c_buf_p) = '\0'; \
1868  yyleng = yyless_macro_arg; \
1869  } \
1870  while ( 0 )
1871 
1872 /* Accessor methods (get/set functions) to struct members. */
1873 
1877 int yyget_lineno (void)
1878 {
1879 
1880  return yylineno;
1881 }
1882 
1886 FILE *yyget_in (void)
1887 {
1888  return yyin;
1889 }
1890 
1894 FILE *yyget_out (void)
1895 {
1896  return yyout;
1897 }
1898 
1902 int yyget_leng (void)
1903 {
1904  return yyleng;
1905 }
1906 
1911 char *yyget_text (void)
1912 {
1913  return yytext;
1914 }
1915 
1920 void yyset_lineno (int _line_number )
1921 {
1922 
1923  yylineno = _line_number;
1924 }
1925 
1932 void yyset_in (FILE * _in_str )
1933 {
1934  yyin = _in_str ;
1935 }
1936 
1937 void yyset_out (FILE * _out_str )
1938 {
1939  yyout = _out_str ;
1940 }
1941 
1942 int yyget_debug (void)
1943 {
1944  return yy_flex_debug;
1945 }
1946 
1947 void yyset_debug (int _bdebug )
1948 {
1949  yy_flex_debug = _bdebug ;
1950 }
1951 
1952 static int yy_init_globals (void)
1953 {
1954  /* Initialization is the same as for the non-reentrant scanner.
1955  * This function is called from yylex_destroy(), so don't allocate here.
1956  */
1957 
1958  (yy_buffer_stack) = NULL;
1959  (yy_buffer_stack_top) = 0;
1960  (yy_buffer_stack_max) = 0;
1961  (yy_c_buf_p) = NULL;
1962  (yy_init) = 0;
1963  (yy_start) = 0;
1964 
1965 /* Defined in main.c */
1966 #ifdef YY_STDINIT
1967  yyin = stdin;
1968  yyout = stdout;
1969 #else
1970  yyin = NULL;
1971  yyout = NULL;
1972 #endif
1973 
1974  /* For future reference: Set errno on error, since we are called by
1975  * yylex_init()
1976  */
1977  return 0;
1978 }
1979 
1980 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1981 int yylex_destroy (void)
1982 {
1983 
1984  /* Pop the buffer stack, destroying each element. */
1985  while(YY_CURRENT_BUFFER){
1987  YY_CURRENT_BUFFER_LVALUE = NULL;
1989  }
1990 
1991  /* Destroy the stack itself. */
1992  yyfree((yy_buffer_stack) );
1993  (yy_buffer_stack) = NULL;
1994 
1995  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1996  * yylex() is called, initialization will occur. */
1997  yy_init_globals( );
1998 
1999  return 0;
2000 }
2001 
2002 /*
2003  * Internal utility routines.
2004  */
2005 
2006 #ifndef yytext_ptr
2007 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2008 {
2009 
2010  int i;
2011  for ( i = 0; i < n; ++i )
2012  s1[i] = s2[i];
2013 }
2014 #endif
2015 
2016 #ifdef YY_NEED_STRLEN
2017 static int yy_flex_strlen (const char * s )
2018 {
2019  int n;
2020  for ( n = 0; s[n]; ++n )
2021  ;
2022 
2023  return n;
2024 }
2025 #endif
2026 
2027 void *yyalloc (yy_size_t size )
2028 {
2029  return malloc(size);
2030 }
2031 
2032 void *yyrealloc (void * ptr, yy_size_t size )
2033 {
2034 
2035  /* The cast to (char *) in the following accommodates both
2036  * implementations that use char* generic pointers, and those
2037  * that use void* generic pointers. It works with the latter
2038  * because both ANSI C and C++ allow castless assignment from
2039  * any pointer type to void*, and deal with argument conversions
2040  * as though doing an assignment.
2041  */
2042  return realloc(ptr, size);
2043 }
2044 
2045 void yyfree (void * ptr )
2046 {
2047  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2048 }
2049 
2050 #define YYTABLES_NAME "yytables"
2052 #line 66 "scanner.l"
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: json_lex.yy.cpp:783
yy_nxt
static const flex_int16_t yy_nxt[118]
Definition: json_lex.yy.cpp:692
flex_int32_t
int flex_int32_t
Definition: ansi_c_lex.yy.cpp:312
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: json_lex.yy.cpp:519
flex_int8_t
signed char flex_int8_t
Definition: json_lex.yy.cpp:310
yynoreturn
#define yynoreturn
Definition: json_lex.yy.cpp:362
yytext
#define yytext
Definition: json_lex.yy.cpp:28
yy_create_buffer
#define yy_create_buffer
Definition: json_lex.yy.cpp:9
yy_trans_info
Definition: ansi_c_lex.yy.cpp:619
yyterminate
#define yyterminate()
Definition: json_lex.yy.cpp:909
yy_buffer_state::yy_input_file
FILE * yy_input_file
Definition: ansi_c_lex.yy.cpp:447
yy_buffer_stack
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition: json_lex.yy.cpp:511
yy_init
static int yy_init
Definition: json_lex.yy.cpp:534
YY_BREAK
#define YY_BREAK
Definition: json_lex.yy.cpp:944
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: json_lex.yy.cpp:738
yy_buffer_state
Definition: ansi_c_lex.yy.cpp:446
yyget_leng
#define yyget_leng
Definition: json_lex.yy.cpp:195
yyget_in
#define yyget_in
Definition: json_lex.yy.cpp:171
file
Definition: kdev_t.h:19
s1
int8_t s1
Definition: bytecode_info.h:59
yy_last_accepting_state
static yy_state_type yy_last_accepting_state
Definition: json_lex.yy.cpp:726
yy_scan_bytes
#define yy_scan_bytes
Definition: json_lex.yy.cpp:13
yyset_out
#define yyset_out
Definition: json_lex.yy.cpp:189
yy_hold_char
static char yy_hold_char
Definition: json_lex.yy.cpp:528
yy_accept
static const flex_int16_t yy_accept[46]
Definition: json_lex.yy.cpp:624
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: json_lex.yy.cpp:856
INITIAL
#define INITIAL
Definition: json_lex.yy.cpp:772
yyset_in
#define yyset_in
Definition: json_lex.yy.cpp:177
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: ansi_c_lex.yy.cpp:479
yy_meta
static const YY_CHAR yy_meta[24]
Definition: json_lex.yy.cpp:665
yy_ec
static const YY_CHAR yy_ec[256]
Definition: json_lex.yy.cpp:633
TOK_FALSE
@ TOK_FALSE
Definition: ansi_c_y.tab.h:203
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: ansi_c_lex.yy.cpp:466
yy_load_buffer_state
#define yy_load_buffer_state
Definition: json_lex.yy.cpp:16
yy_last_accepting_cpos
static char * yy_last_accepting_cpos
Definition: json_lex.yy.cpp:727
yy_state_type
int yy_state_type
Definition: json_lex.yy.cpp:590
yy_switch_to_buffer
#define yy_switch_to_buffer
Definition: json_lex.yy.cpp:17
json_parser.h
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: json_lex.yy.cpp:423
flex_uint16_t
unsigned short int flex_uint16_t
Definition: json_lex.yy.cpp:314
yy_delete_buffer
#define yy_delete_buffer
Definition: json_lex.yy.cpp:10
yy_c_buf_p
static char * yy_c_buf_p
Definition: json_lex.yy.cpp:533
yy_fatal_error
static void yy_fatal_error(const char *msg)
Definition: json_lex.yy.cpp:1849
yyfree
#define yyfree
Definition: json_lex.yy.cpp:32
yyset_debug
#define yyset_debug
Definition: json_lex.yy.cpp:153
yyget_debug
#define yyget_debug
Definition: json_lex.yy.cpp:147
YY_START
#define YY_START
Definition: json_lex.yy.cpp:382
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: json_lex.yy.cpp:872
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: json_lex.yy.cpp:422
yyalloc
#define yyalloc
Definition: json_lex.yy.cpp:30
yy_flex_debug
#define yy_flex_debug
Definition: json_lex.yy.cpp:21
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: ansi_c_lex.yy.cpp:487
yylex
#define yylex
Definition: json_lex.yy.cpp:24
yypop_buffer_state
#define yypop_buffer_state
Definition: json_lex.yy.cpp:19
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: json_lex.yy.cpp:947
yyensure_buffer_stack
#define yyensure_buffer_stack
Definition: json_lex.yy.cpp:20
flex_int16_t
short int flex_int16_t
Definition: ansi_c_lex.yy.cpp:311
yyin
#define yyin
Definition: json_lex.yy.cpp:22
yy_buffer_state::yy_buf_size
int yy_buf_size
Definition: ansi_c_lex.yy.cpp:455
yy_buffer_state::yy_ch_buf
char * yy_ch_buf
Definition: ansi_c_lex.yy.cpp:449
yyset_extra
#define yyset_extra
Definition: json_lex.yy.cpp:165
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: json_lex.yy.cpp:1395
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: json_lex.yy.cpp:399
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: json_lex.yy.cpp:409
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: json_lex.yy.cpp:540
TOK_STRING
@ TOK_STRING
Definition: ansi_c_y.tab.h:121
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: json_lex.yy.cpp:388
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: json_lex.yy.cpp:737
YY_NEW_FILE
#define YY_NEW_FILE
Definition: json_lex.yy.cpp:387
yyget_lineno
#define yyget_lineno
Definition: json_lex.yy.cpp:207
flex_int32_t
int flex_int32_t
Definition: json_lex.yy.cpp:312
yy_scan_string
#define yy_scan_string
Definition: json_lex.yy.cpp:12
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: json_lex.yy.cpp:525
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: json_lex.yy.cpp:421
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: json_lex.yy.cpp:503
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: json_lex.yy.cpp:616
TOK_TRUE
@ TOK_TRUE
Definition: ansi_c_y.tab.h:202
yy_buffer_stack_max
static size_t yy_buffer_stack_max
capacity of stack.
Definition: json_lex.yy.cpp:510
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: ansi_c_lex.yy.cpp:489
yy_flush_buffer
#define yy_flush_buffer
Definition: json_lex.yy.cpp:15
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: ansi_c_lex.yy.cpp:450
yy_scan_buffer
#define yy_scan_buffer
Definition: json_lex.yy.cpp:11
yy_buffer_stack_top
static size_t yy_buffer_stack_top
index of top of stack.
Definition: json_lex.yy.cpp:509
yy_trans_info::yy_nxt
flex_int32_t yy_nxt
Definition: ansi_c_lex.yy.cpp:621
yypush_buffer_state
#define yypush_buffer_state
Definition: json_lex.yy.cpp:18
yy_trans_info::yy_verify
flex_int32_t yy_verify
Definition: ansi_c_lex.yy.cpp:620
yylineno
#define yylineno
Definition: json_lex.yy.cpp:25
yy_def
static const flex_int16_t yy_def[53]
Definition: json_lex.yy.cpp:682
yyget_extra
#define yyget_extra
Definition: json_lex.yy.cpp:159
yy_buffer_state::yy_bs_column
int yy_bs_column
The column count.
Definition: ansi_c_lex.yy.cpp:482
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: json_lex.yy.cpp:609
yy_buffer_state::yy_n_chars
int yy_n_chars
Definition: ansi_c_lex.yy.cpp:460
yy_n_chars
static int yy_n_chars
Definition: json_lex.yy.cpp:529
yywrap
#define yywrap
Definition: json_lex.yy.cpp:29
yyset_lineno
#define yyset_lineno
Definition: json_lex.yy.cpp:213
yy_chk
static const flex_int16_t yy_chk[118]
Definition: json_lex.yy.cpp:709
YY_CHAR
flex_uint8_t YY_CHAR
Definition: ansi_c_lex.yy.cpp:585
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: json_lex.yy.cpp:919
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: json_lex.yy.cpp:1846
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: ansi_c_lex.yy.cpp:473
malloc
void * malloc(unsigned)
yy_init_globals
static int yy_init_globals(void)
Definition: json_lex.yy.cpp:1952
TOK_NUMBER
@ TOK_NUMBER
Definition: json_y.tab.cpp:204
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: json_lex.yy.cpp:385
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: json_lex.yy.cpp:492
yy_init_buffer
#define yy_init_buffer
Definition: json_lex.yy.cpp:14
yylex_destroy
#define yylex_destroy
Definition: json_lex.yy.cpp:141
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: json_lex.yy.cpp:371
yyout
#define yyout
Definition: json_lex.yy.cpp:26
flex_uint8_t
unsigned char flex_uint8_t
Definition: ansi_c_lex.yy.cpp:313
YY_DECL
#define YY_DECL
Definition: json_lex.yy.cpp:932
json_y.tab.h
flex_uint8_t
unsigned char flex_uint8_t
Definition: json_lex.yy.cpp:313
YY_CHAR
flex_uint8_t YY_CHAR
Definition: json_lex.yy.cpp:586
flex_uint32_t
unsigned int flex_uint32_t
Definition: json_lex.yy.cpp:315
s2
int16_t s2
Definition: bytecode_info.h:60
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: json_lex.yy.cpp:491
yy_start
static int yy_start
Definition: json_lex.yy.cpp:535
yy_size_t
size_t yy_size_t
Definition: json_lex.yy.cpp:414
yytext_ptr
#define yytext_ptr
Definition: json_lex.yy.cpp:599
yy_size_t
size_t yy_size_t
Definition: ansi_c_lex.yy.cpp:414
yyrestart
#define yyrestart
Definition: json_lex.yy.cpp:27
yyleng
#define yyleng
Definition: json_lex.yy.cpp:23
yy_get_previous_state
static yy_state_type yy_get_previous_state(void)
Definition: json_lex.yy.cpp:1363
yyrealloc
#define yyrealloc
Definition: json_lex.yy.cpp:31
free
void free(void *)
TOK_NULL
@ TOK_NULL
Definition: jsil_y.tab.h:77
yyget_text
#define yyget_text
Definition: json_lex.yy.cpp:201
yy_buffer_state::yy_bs_lineno
int yy_bs_lineno
The line count.
Definition: ansi_c_lex.yy.cpp:481
yy_state_type
int yy_state_type
Definition: ansi_c_lex.yy.cpp:589
yy_get_next_buffer
static int yy_get_next_buffer(void)
Definition: json_lex.yy.cpp:1225
yyget_out
#define yyget_out
Definition: json_lex.yy.cpp:183
flex_int16_t
short int flex_int16_t
Definition: json_lex.yy.cpp:311
yy_base
static const flex_int16_t yy_base[53]
Definition: json_lex.yy.cpp:672