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
445 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[43] =
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, 1, 2, 2, 0, 2,
629  0, 0, 0, 0, 0, 0, 5, 3, 0, 2,
630  4, 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, 1, 8, 9, 9,
640  9, 9, 9, 9, 9, 9, 9, 1, 1, 1,
641  1, 1, 1, 1, 1, 1, 1, 1, 10, 1,
642  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
643  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
644  1, 11, 1, 1, 1, 1, 12, 1, 1, 1,
645 
646  13, 14, 1, 1, 1, 1, 1, 15, 1, 16,
647  1, 1, 1, 17, 18, 19, 20, 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[21] =
666  { 0,
667  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
668  1, 1, 1, 1, 1, 1, 1, 1, 1, 1
669  } ;
670 
671 static const flex_int16_t yy_base[44] =
672  { 0,
673  0, 0, 71, 72, 72, 72, 17, 14, 17, 17,
674  58, 49, 51, 25, 72, 27, 0, 24, 26, 34,
675  0, 0, 52, 51, 45, 33, 0, 37, 40, 43,
676  46, 48, 49, 48, 0, 42, 72, 72, 50, 52,
677  72, 72, 40
678  } ;
679 
680 static const flex_int16_t yy_def[44] =
681  { 0,
682  42, 1, 42, 42, 42, 42, 43, 42, 42, 9,
683  42, 42, 42, 43, 42, 43, 9, 9, 42, 42,
684  20, 10, 42, 42, 42, 43, 18, 42, 42, 42,
685  42, 42, 42, 42, 34, 42, 42, 42, 42, 42,
686  42, 0, 42
687  } ;
688 
689 static const flex_int16_t yy_nxt[93] =
690  { 0,
691  4, 5, 6, 7, 4, 8, 4, 9, 10, 4,
692  4, 4, 4, 11, 4, 12, 4, 4, 13, 4,
693  15, 17, 18, 19, 22, 22, 20, 16, 15, 21,
694  26, 27, 27, 28, 28, 16, 15, 16, 29, 29,
695  14, 30, 30, 16, 28, 28, 34, 30, 30, 35,
696  30, 30, 39, 39, 41, 40, 40, 40, 40, 40,
697  40, 38, 37, 36, 33, 32, 31, 25, 24, 23,
698  42, 3, 42, 42, 42, 42, 42, 42, 42, 42,
699  42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
700  42, 42
701 
702  } ;
703 
704 static const flex_int16_t yy_chk[93] =
705  { 0,
706  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
708  7, 8, 8, 9, 10, 10, 9, 7, 14, 9,
709  16, 18, 18, 19, 19, 14, 26, 16, 20, 20,
710  43, 20, 20, 26, 28, 28, 28, 29, 29, 28,
711  30, 30, 34, 34, 36, 34, 34, 39, 39, 40,
712  40, 33, 32, 31, 25, 24, 23, 13, 12, 11,
713  3, 42, 42, 42, 42, 42, 42, 42, 42, 42,
714  42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
715  42, 42
716 
717  } ;
718 
721 
722 extern int yy_flex_debug;
724 
725 /* The intent behind this definition is that it'll catch
726  * any uses of REJECT which flex missed.
727  */
728 #define REJECT reject_used_but_not_detected
729 #define yymore() yymore_used_but_not_detected
730 #define YY_MORE_ADJ 0
731 #define YY_RESTORE_YY_MORE_OFFSET
732 char *yytext;
733 #line 1 "scanner.l"
734 #line 2 "scanner.l"
735 // Strictly follows http://www.json.org/
736 #line 736 "json_lex.yy.cpp"
737 #define YY_NO_INPUT 1
738 #define YY_NO_UNISTD_H 1
739 #line 14 "scanner.l"
740 
741 #define PARSER json_parser
742 
743 #include "json_parser.h"
744 #include "json_y.tab.h"
745 
746 #include <util/pragma_wsign_compare.def>
747 #include <util/pragma_wnull_conversion.def>
748 #include <util/pragma_wdeprecated_register.def>
749 
750 #line 750 "json_lex.yy.cpp"
751 #line 751 "json_lex.yy.cpp"
752 
753 #define INITIAL 0
754 
755 #ifndef YY_NO_UNISTD_H
756 /* Special case for "unistd.h", since it is non-ANSI. We include it way
757  * down here because we want the user's section 1 to have been scanned first.
758  * The user has a chance to override it with an option.
759  */
760 #include <unistd.h>
761 #endif
762 
763 #ifndef YY_EXTRA_TYPE
764 #define YY_EXTRA_TYPE void *
765 #endif
766 
767 static int yy_init_globals ( void );
768 
769 /* Accessor methods to globals.
770  These are made visible to non-reentrant scanners for convenience. */
771 
772 int yylex_destroy ( void );
773 
774 int yyget_debug ( void );
775 
776 void yyset_debug ( int debug_flag );
777 
778 YY_EXTRA_TYPE yyget_extra ( void );
779 
780 void yyset_extra ( YY_EXTRA_TYPE user_defined );
781 
782 FILE *yyget_in ( void );
783 
784 void yyset_in ( FILE * _in_str );
785 
786 FILE *yyget_out ( void );
787 
788 void yyset_out ( FILE * _out_str );
789 
790  int yyget_leng ( void );
791 
792 char *yyget_text ( void );
793 
794 int yyget_lineno ( void );
795 
796 void yyset_lineno ( int _line_number );
797 
798 /* Macros after this point can all be overridden by user definitions in
799  * section 1.
800  */
801 
802 #ifndef YY_SKIP_YYWRAP
803 #ifdef __cplusplus
804 extern "C" int yywrap ( void );
805 #else
806 extern int yywrap ( void );
807 #endif
808 #endif
809 
810 #ifndef YY_NO_UNPUT
811 
812 #endif
813 
814 #ifndef yytext_ptr
815 static void yy_flex_strncpy ( char *, const char *, int );
816 #endif
817 
818 #ifdef YY_NEED_STRLEN
819 static int yy_flex_strlen ( const char * );
820 #endif
821 
822 #ifndef YY_NO_INPUT
823 #ifdef __cplusplus
824 static int yyinput ( void );
825 #else
826 static int input ( void );
827 #endif
828 
829 #endif
830 
831 /* Amount of stuff to slurp up with each read. */
832 #ifndef YY_READ_BUF_SIZE
833 #ifdef __ia64__
834 /* On IA-64, the buffer size is 16k, not 8k */
835 #define YY_READ_BUF_SIZE 16384
836 #else
837 #define YY_READ_BUF_SIZE 8192
838 #endif /* __ia64__ */
839 #endif
840 
841 /* Copy whatever the last rule matched to the standard output. */
842 #ifndef ECHO
843 /* This used to be an fputs(), but since the string might contain NUL's,
844  * we now use fwrite().
845  */
846 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
847 #endif
848 
849 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
850  * is returned in "result".
851  */
852 #ifndef YY_INPUT
853 #define YY_INPUT(buf,result,max_size) \
854  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
855  { \
856  int c = '*'; \
857  int n; \
858  for ( n = 0; n < max_size && \
859  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
860  buf[n] = (char) c; \
861  if ( c == '\n' ) \
862  buf[n++] = (char) c; \
863  if ( c == EOF && ferror( yyin ) ) \
864  YY_FATAL_ERROR( "input in flex scanner failed" ); \
865  result = n; \
866  } \
867  else \
868  { \
869  errno=0; \
870  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
871  { \
872  if( errno != EINTR) \
873  { \
874  YY_FATAL_ERROR( "input in flex scanner failed" ); \
875  break; \
876  } \
877  errno=0; \
878  clearerr(yyin); \
879  } \
880  }\
881 \
882 
883 #endif
884 
885 /* No semi-colon after return; correct usage is to write "yyterminate();" -
886  * we don't want an extra ';' after the "return" because that will cause
887  * some compilers to complain about unreachable statements.
888  */
889 #ifndef yyterminate
890 #define yyterminate() return YY_NULL
891 #endif
892 
893 /* Number of entries by which start-condition stack grows. */
894 #ifndef YY_START_STACK_INCR
895 #define YY_START_STACK_INCR 25
896 #endif
897 
898 /* Report a fatal error. */
899 #ifndef YY_FATAL_ERROR
900 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
901 #endif
902 
903 /* end tables serialization structures and prototypes */
904 
905 /* Default declaration of generated scanner - a define so the user can
906  * easily add parameters.
907  */
908 #ifndef YY_DECL
909 #define YY_DECL_IS_OURS 1
910 
911 extern int yylex (void);
912 
913 #define YY_DECL int yylex (void)
914 #endif /* !YY_DECL */
915 
916 /* Code executed at the beginning of each rule, after yytext and yyleng
917  * have been set up.
918  */
919 #ifndef YY_USER_ACTION
920 #define YY_USER_ACTION
921 #endif
922 
923 /* Code executed at the end of each rule. */
924 #ifndef YY_BREAK
925 #define YY_BREAK /*LINTED*/break;
926 #endif
927 
928 #define YY_RULE_SETUP \
929  YY_USER_ACTION
930 
934 {
935  yy_state_type yy_current_state;
936  char *yy_cp, *yy_bp;
937  int yy_act;
938 
939  if ( !(yy_init) )
940  {
941  (yy_init) = 1;
942 
943 #ifdef YY_USER_INIT
944  YY_USER_INIT;
945 #endif
946 
947  if ( ! (yy_start) )
948  (yy_start) = 1; /* first start state */
949 
950  if ( ! yyin )
951  yyin = stdin;
952 
953  if ( ! yyout )
954  yyout = stdout;
955 
956  if ( ! YY_CURRENT_BUFFER ) {
960  }
961 
963  }
964 
965  {
966 #line 39 "scanner.l"
967 
968 
969 #line 969 "json_lex.yy.cpp"
970 
971  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
972  {
973  yy_cp = (yy_c_buf_p);
974 
975  /* Support of yytext. */
976  *yy_cp = (yy_hold_char);
977 
978  /* yy_bp points to the position in yy_ch_buf of the start of
979  * the current run.
980  */
981  yy_bp = yy_cp;
982 
983  yy_current_state = (yy_start);
984 yy_match:
985  do
986  {
987  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
988  if ( yy_accept[yy_current_state] )
989  {
990  (yy_last_accepting_state) = yy_current_state;
991  (yy_last_accepting_cpos) = yy_cp;
992  }
993  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
994  {
995  yy_current_state = (int) yy_def[yy_current_state];
996  if ( yy_current_state >= 43 )
997  yy_c = yy_meta[yy_c];
998  }
999  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1000  ++yy_cp;
1001  }
1002  while ( yy_current_state != 42 );
1003  yy_cp = (yy_last_accepting_cpos);
1004  yy_current_state = (yy_last_accepting_state);
1005 
1006 yy_find_action:
1007  yy_act = yy_accept[yy_current_state];
1008 
1010 
1011 do_action: /* This label is used only to access EOF actions. */
1012 
1013  switch ( yy_act )
1014  { /* beginning of action switch */
1015  case 0: /* must back up */
1016  /* undo the effects of YY_DO_BEFORE_ACTION */
1017  *yy_cp = (yy_hold_char);
1018  yy_cp = (yy_last_accepting_cpos);
1019  yy_current_state = (yy_last_accepting_state);
1020  goto yy_find_action;
1021 
1022 case 1:
1023 /* rule 1 can match eol */
1025 #line 41 "scanner.l"
1026 { return TOK_STRING; }
1027  YY_BREAK
1028 case 2:
1030 #line 42 "scanner.l"
1031 { return TOK_NUMBER; }
1032  YY_BREAK
1033 case 3:
1035 #line 43 "scanner.l"
1036 { return TOK_TRUE; }
1037  YY_BREAK
1038 case 4:
1040 #line 44 "scanner.l"
1041 { return TOK_FALSE; }
1042  YY_BREAK
1043 case 5:
1045 #line 45 "scanner.l"
1046 { return TOK_NULL; }
1047  YY_BREAK
1048 case 6:
1049 /* rule 6 can match eol */
1051 #line 47 "scanner.l"
1052 { /* eat */ }
1053  YY_BREAK
1054 case 7:
1056 #line 48 "scanner.l"
1057 { return yytext[0]; }
1058  YY_BREAK
1059 case 8:
1061 #line 50 "scanner.l"
1062 YY_FATAL_ERROR( "flex scanner jammed" );
1063  YY_BREAK
1064 #line 1064 "json_lex.yy.cpp"
1065 case YY_STATE_EOF(INITIAL):
1066  yyterminate();
1067 
1068  case YY_END_OF_BUFFER:
1069  {
1070  /* Amount of text matched not including the EOB char. */
1071  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1072 
1073  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1074  *yy_cp = (yy_hold_char);
1076 
1077  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1078  {
1079  /* We're scanning a new file or input source. It's
1080  * possible that this happened because the user
1081  * just pointed yyin at a new source and called
1082  * yylex(). If so, then we have to assure
1083  * consistency between YY_CURRENT_BUFFER and our
1084  * globals. Here is the right place to do so, because
1085  * this is the first action (other than possibly a
1086  * back-up) that will match for the new input source.
1087  */
1088  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1089  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1090  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1091  }
1092 
1093  /* Note that here we test for yy_c_buf_p "<=" to the position
1094  * of the first EOB in the buffer, since yy_c_buf_p will
1095  * already have been incremented past the NUL character
1096  * (since all states make transitions on EOB to the
1097  * end-of-buffer state). Contrast this with the test
1098  * in input().
1099  */
1100  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1101  { /* This was really a NUL. */
1102  yy_state_type yy_next_state;
1103 
1104  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1105 
1106  yy_current_state = yy_get_previous_state( );
1107 
1108  /* Okay, we're now positioned to make the NUL
1109  * transition. We couldn't have
1110  * yy_get_previous_state() go ahead and do it
1111  * for us because it doesn't know how to deal
1112  * with the possibility of jamming (and we don't
1113  * want to build jamming into it because then it
1114  * will run more slowly).
1115  */
1116 
1117  yy_next_state = yy_try_NUL_trans( yy_current_state );
1118 
1119  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1120 
1121  if ( yy_next_state )
1122  {
1123  /* Consume the NUL. */
1124  yy_cp = ++(yy_c_buf_p);
1125  yy_current_state = yy_next_state;
1126  goto yy_match;
1127  }
1128 
1129  else
1130  {
1131  yy_cp = (yy_last_accepting_cpos);
1132  yy_current_state = (yy_last_accepting_state);
1133  goto yy_find_action;
1134  }
1135  }
1136 
1137  else switch ( yy_get_next_buffer( ) )
1138  {
1139  case EOB_ACT_END_OF_FILE:
1140  {
1142 
1143  if ( yywrap( ) )
1144  {
1145  /* Note: because we've taken care in
1146  * yy_get_next_buffer() to have set up
1147  * yytext, we can now set up
1148  * yy_c_buf_p so that if some total
1149  * hoser (like flex itself) wants to
1150  * call the scanner after we return the
1151  * YY_NULL, it'll still work - another
1152  * YY_NULL will get returned.
1153  */
1155 
1156  yy_act = YY_STATE_EOF(YY_START);
1157  goto do_action;
1158  }
1159 
1160  else
1161  {
1162  if ( ! (yy_did_buffer_switch_on_eof) )
1163  YY_NEW_FILE;
1164  }
1165  break;
1166  }
1167 
1168  case EOB_ACT_CONTINUE_SCAN:
1169  (yy_c_buf_p) =
1170  (yytext_ptr) + yy_amount_of_matched_text;
1171 
1172  yy_current_state = yy_get_previous_state( );
1173 
1174  yy_cp = (yy_c_buf_p);
1175  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1176  goto yy_match;
1177 
1178  case EOB_ACT_LAST_MATCH:
1179  (yy_c_buf_p) =
1180  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1181 
1182  yy_current_state = yy_get_previous_state( );
1183 
1184  yy_cp = (yy_c_buf_p);
1185  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1186  goto yy_find_action;
1187  }
1188  break;
1189  }
1190 
1191  default:
1193  "fatal flex scanner internal error--no action found" );
1194  } /* end of action switch */
1195  } /* end of scanning one token */
1196  } /* end of user's declarations */
1197 } /* end of yylex */
1198 
1199 /* yy_get_next_buffer - try to read in a new buffer
1200  *
1201  * Returns a code representing an action:
1202  * EOB_ACT_LAST_MATCH -
1203  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1204  * EOB_ACT_END_OF_FILE - end of file
1205  */
1206 static int yy_get_next_buffer (void)
1207 {
1208  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1209  char *source = (yytext_ptr);
1210  int number_to_move, i;
1211  int ret_val;
1212 
1213  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1215  "fatal flex scanner internal error--end of buffer missed" );
1216 
1217  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1218  { /* Don't try to fill the buffer, so this is an EOF. */
1219  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1220  {
1221  /* We matched a single character, the EOB, so
1222  * treat this as a final EOF.
1223  */
1224  return EOB_ACT_END_OF_FILE;
1225  }
1226 
1227  else
1228  {
1229  /* We matched some text prior to the EOB, first
1230  * process it.
1231  */
1232  return EOB_ACT_LAST_MATCH;
1233  }
1234  }
1235 
1236  /* Try to read more data. */
1237 
1238  /* First move last chars to start of buffer. */
1239  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1240 
1241  for ( i = 0; i < number_to_move; ++i )
1242  *(dest++) = *(source++);
1243 
1244  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1245  /* don't do the read, it's not guaranteed to return an EOF,
1246  * just force an EOF
1247  */
1248  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1249 
1250  else
1251  {
1252  int num_to_read =
1253  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1254 
1255  while ( num_to_read <= 0 )
1256  { /* Not enough room in the buffer - grow it. */
1257 
1258  /* just a shorter name for the current buffer */
1260 
1261  int yy_c_buf_p_offset =
1262  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1263 
1264  if ( b->yy_is_our_buffer )
1265  {
1266  int new_size = b->yy_buf_size * 2;
1267 
1268  if ( new_size <= 0 )
1269  b->yy_buf_size += b->yy_buf_size / 8;
1270  else
1271  b->yy_buf_size *= 2;
1272 
1273  b->yy_ch_buf = (char *)
1274  /* Include room in for 2 EOB chars. */
1275  yyrealloc( (void *) b->yy_ch_buf,
1276  (yy_size_t) (b->yy_buf_size + 2) );
1277  }
1278  else
1279  /* Can't grow it, we don't own it. */
1280  b->yy_ch_buf = NULL;
1281 
1282  if ( ! b->yy_ch_buf )
1284  "fatal error - scanner input buffer overflow" );
1285 
1286  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1287 
1288  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1289  number_to_move - 1;
1290 
1291  }
1292 
1293  if ( num_to_read > YY_READ_BUF_SIZE )
1294  num_to_read = YY_READ_BUF_SIZE;
1295 
1296  /* Read in more data. */
1297  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1298  (yy_n_chars), num_to_read );
1299 
1300  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1301  }
1302 
1303  if ( (yy_n_chars) == 0 )
1304  {
1305  if ( number_to_move == YY_MORE_ADJ )
1306  {
1307  ret_val = EOB_ACT_END_OF_FILE;
1308  yyrestart( yyin );
1309  }
1310 
1311  else
1312  {
1313  ret_val = EOB_ACT_LAST_MATCH;
1314  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1316  }
1317  }
1318 
1319  else
1320  ret_val = EOB_ACT_CONTINUE_SCAN;
1321 
1322  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1323  /* Extend the array by 50%, plus the number we really need. */
1324  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1325  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1326  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1327  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1328  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1329  /* "- 2" to take care of EOB's */
1330  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1331  }
1332 
1333  (yy_n_chars) += number_to_move;
1336 
1337  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1338 
1339  return ret_val;
1340 }
1341 
1342 /* yy_get_previous_state - get the state just before the EOB char was reached */
1343 
1345 {
1346  yy_state_type yy_current_state;
1347  char *yy_cp;
1348 
1349  yy_current_state = (yy_start);
1350 
1351  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1352  {
1353  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1354  if ( yy_accept[yy_current_state] )
1355  {
1356  (yy_last_accepting_state) = yy_current_state;
1357  (yy_last_accepting_cpos) = yy_cp;
1358  }
1359  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1360  {
1361  yy_current_state = (int) yy_def[yy_current_state];
1362  if ( yy_current_state >= 43 )
1363  yy_c = yy_meta[yy_c];
1364  }
1365  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1366  }
1367 
1368  return yy_current_state;
1369 }
1370 
1371 /* yy_try_NUL_trans - try to make a transition on the NUL character
1372  *
1373  * synopsis
1374  * next_state = yy_try_NUL_trans( current_state );
1375  */
1376  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1377 {
1378  int yy_is_jam;
1379  char *yy_cp = (yy_c_buf_p);
1380 
1381  YY_CHAR yy_c = 1;
1382  if ( yy_accept[yy_current_state] )
1383  {
1384  (yy_last_accepting_state) = yy_current_state;
1385  (yy_last_accepting_cpos) = yy_cp;
1386  }
1387  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1388  {
1389  yy_current_state = (int) yy_def[yy_current_state];
1390  if ( yy_current_state >= 43 )
1391  yy_c = yy_meta[yy_c];
1392  }
1393  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1394  yy_is_jam = (yy_current_state == 42);
1395 
1396  return yy_is_jam ? 0 : yy_current_state;
1397 }
1398 
1399 #ifndef YY_NO_UNPUT
1400 
1401 #endif
1402 
1403 #ifndef YY_NO_INPUT
1404 #ifdef __cplusplus
1405  static int yyinput (void)
1406 #else
1407  static int input (void)
1408 #endif
1409 
1410 {
1411  int c;
1412 
1413  *(yy_c_buf_p) = (yy_hold_char);
1414 
1415  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1416  {
1417  /* yy_c_buf_p now points to the character we want to return.
1418  * If this occurs *before* the EOB characters, then it's a
1419  * valid NUL; if not, then we've hit the end of the buffer.
1420  */
1421  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1422  /* This was really a NUL. */
1423  *(yy_c_buf_p) = '\0';
1424 
1425  else
1426  { /* need more input */
1427  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1428  ++(yy_c_buf_p);
1429 
1430  switch ( yy_get_next_buffer( ) )
1431  {
1432  case EOB_ACT_LAST_MATCH:
1433  /* This happens because yy_g_n_b()
1434  * sees that we've accumulated a
1435  * token and flags that we need to
1436  * try matching the token before
1437  * proceeding. But for input(),
1438  * there's no matching to consider.
1439  * So convert the EOB_ACT_LAST_MATCH
1440  * to EOB_ACT_END_OF_FILE.
1441  */
1442 
1443  /* Reset buffer status. */
1444  yyrestart( yyin );
1445 
1446  /*FALLTHROUGH*/
1447 
1448  case EOB_ACT_END_OF_FILE:
1449  {
1450  if ( yywrap( ) )
1451  return 0;
1452 
1453  if ( ! (yy_did_buffer_switch_on_eof) )
1454  YY_NEW_FILE;
1455 #ifdef __cplusplus
1456  return yyinput();
1457 #else
1458  return input();
1459 #endif
1460  }
1461 
1462  case EOB_ACT_CONTINUE_SCAN:
1463  (yy_c_buf_p) = (yytext_ptr) + offset;
1464  break;
1465  }
1466  }
1467  }
1468 
1469  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1470  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1471  (yy_hold_char) = *++(yy_c_buf_p);
1472 
1473  return c;
1474 }
1475 #endif /* ifndef YY_NO_INPUT */
1476 
1482  void yyrestart (FILE * input_file )
1483 {
1484 
1485  if ( ! YY_CURRENT_BUFFER ){
1489  }
1490 
1491  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1493 }
1494 
1500 {
1501 
1502  /* TODO. We should be able to replace this entire function body
1503  * with
1504  * yypop_buffer_state();
1505  * yypush_buffer_state(new_buffer);
1506  */
1508  if ( YY_CURRENT_BUFFER == new_buffer )
1509  return;
1510 
1511  if ( YY_CURRENT_BUFFER )
1512  {
1513  /* Flush out information for old buffer. */
1514  *(yy_c_buf_p) = (yy_hold_char);
1515  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1516  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1517  }
1518 
1519  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1521 
1522  /* We don't actually know whether we did this switch during
1523  * EOF (yywrap()) processing, but the only time this flag
1524  * is looked at is after yywrap() is called, so it's safe
1525  * to go ahead and always set it.
1526  */
1528 }
1529 
1530 static void yy_load_buffer_state (void)
1531 {
1532  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1533  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1534  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1535  (yy_hold_char) = *(yy_c_buf_p);
1536 }
1537 
1545 {
1546  YY_BUFFER_STATE b;
1547 
1548  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1549  if ( ! b )
1550  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1551 
1552  b->yy_buf_size = size;
1553 
1554  /* yy_ch_buf has to be 2 characters longer than the size given because
1555  * we need to put in 2 end-of-buffer characters.
1556  */
1557  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1558  if ( ! b->yy_ch_buf )
1559  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1560 
1561  b->yy_is_our_buffer = 1;
1562 
1563  yy_init_buffer( b, file );
1564 
1565  return b;
1566 }
1567 
1573 {
1574 
1575  if ( ! b )
1576  return;
1577 
1578  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1580 
1581  if ( b->yy_is_our_buffer )
1582  yyfree( (void *) b->yy_ch_buf );
1583 
1584  yyfree( (void *) b );
1585 }
1586 
1587 /* Initializes or reinitializes a buffer.
1588  * This function is sometimes called more than once on the same buffer,
1589  * such as during a yyrestart() or at EOF.
1590  */
1591  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1592 
1593 {
1594  int oerrno = errno;
1595 
1596  yy_flush_buffer( b );
1597 
1598  b->yy_input_file = file;
1599  b->yy_fill_buffer = 1;
1600 
1601  /* If b is the current buffer, then yy_init_buffer was _probably_
1602  * called from yyrestart() or through yy_get_next_buffer.
1603  * In that case, we don't want to reset the lineno or column.
1604  */
1605  if (b != YY_CURRENT_BUFFER){
1606  b->yy_bs_lineno = 1;
1607  b->yy_bs_column = 0;
1608  }
1609 
1610  b->yy_is_interactive = 0;
1611 
1612  errno = oerrno;
1613 }
1614 
1620 {
1621  if ( ! b )
1622  return;
1623 
1624  b->yy_n_chars = 0;
1625 
1626  /* We always need two end-of-buffer characters. The first causes
1627  * a transition to the end-of-buffer state. The second causes
1628  * a jam in that state.
1629  */
1632 
1633  b->yy_buf_pos = &b->yy_ch_buf[0];
1634 
1635  b->yy_at_bol = 1;
1637 
1638  if ( b == YY_CURRENT_BUFFER )
1640 }
1641 
1649 {
1650  if (new_buffer == NULL)
1651  return;
1652 
1654 
1655  /* This block is copied from yy_switch_to_buffer. */
1656  if ( YY_CURRENT_BUFFER )
1657  {
1658  /* Flush out information for old buffer. */
1659  *(yy_c_buf_p) = (yy_hold_char);
1660  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1661  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1662  }
1663 
1664  /* Only push if top exists. Otherwise, replace top. */
1665  if (YY_CURRENT_BUFFER)
1666  (yy_buffer_stack_top)++;
1667  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1668 
1669  /* copied from yy_switch_to_buffer. */
1672 }
1673 
1679 {
1680  if (!YY_CURRENT_BUFFER)
1681  return;
1682 
1684  YY_CURRENT_BUFFER_LVALUE = NULL;
1685  if ((yy_buffer_stack_top) > 0)
1686  --(yy_buffer_stack_top);
1687 
1688  if (YY_CURRENT_BUFFER) {
1691  }
1692 }
1693 
1694 /* Allocates the stack if it does not exist.
1695  * Guarantees space for at least one push.
1696  */
1697 static void yyensure_buffer_stack (void)
1698 {
1699  yy_size_t num_to_alloc;
1700 
1701  if (!(yy_buffer_stack)) {
1702 
1703  /* First allocation is just for 2 elements, since we don't know if this
1704  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1705  * immediate realloc on the next call.
1706  */
1707  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1709  (num_to_alloc * sizeof(struct yy_buffer_state*)
1710  );
1711  if ( ! (yy_buffer_stack) )
1712  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1713 
1714  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1715 
1716  (yy_buffer_stack_max) = num_to_alloc;
1717  (yy_buffer_stack_top) = 0;
1718  return;
1719  }
1720 
1721  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1722 
1723  /* Increase the buffer to prepare for a possible push. */
1724  yy_size_t grow_size = 8 /* arbitrary grow size */;
1725 
1726  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1728  ((yy_buffer_stack),
1729  num_to_alloc * sizeof(struct yy_buffer_state*)
1730  );
1731  if ( ! (yy_buffer_stack) )
1732  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1733 
1734  /* zero only the new slots.*/
1735  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1736  (yy_buffer_stack_max) = num_to_alloc;
1737  }
1738 }
1739 
1747 {
1748  YY_BUFFER_STATE b;
1749 
1750  if ( size < 2 ||
1751  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1752  base[size-1] != YY_END_OF_BUFFER_CHAR )
1753  /* They forgot to leave room for the EOB's. */
1754  return NULL;
1755 
1756  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1757  if ( ! b )
1758  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1759 
1760  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1761  b->yy_buf_pos = b->yy_ch_buf = base;
1762  b->yy_is_our_buffer = 0;
1763  b->yy_input_file = NULL;
1764  b->yy_n_chars = b->yy_buf_size;
1765  b->yy_is_interactive = 0;
1766  b->yy_at_bol = 1;
1767  b->yy_fill_buffer = 0;
1769 
1770  yy_switch_to_buffer( b );
1771 
1772  return b;
1773 }
1774 
1783 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1784 {
1785 
1786  return yy_scan_bytes( yystr, (int) strlen(yystr) );
1787 }
1788 
1796 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1797 {
1798  YY_BUFFER_STATE b;
1799  char *buf;
1800  yy_size_t n;
1801  int i;
1802 
1803  /* Get memory for full buffer, including space for trailing EOB's. */
1804  n = (yy_size_t) (_yybytes_len + 2);
1805  buf = (char *) yyalloc( n );
1806  if ( ! buf )
1807  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1808 
1809  for ( i = 0; i < _yybytes_len; ++i )
1810  buf[i] = yybytes[i];
1811 
1812  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1813 
1814  b = yy_scan_buffer( buf, n );
1815  if ( ! b )
1816  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1817 
1818  /* It's okay to grow etc. this buffer, and we should throw it
1819  * away when we're done.
1820  */
1821  b->yy_is_our_buffer = 1;
1822 
1823  return b;
1824 }
1825 
1826 #ifndef YY_EXIT_FAILURE
1827 #define YY_EXIT_FAILURE 2
1828 #endif
1829 
1830 static void yynoreturn yy_fatal_error (const char* msg )
1831 {
1832  fprintf( stderr, "%s\n", msg );
1833  exit( YY_EXIT_FAILURE );
1834 }
1835 
1836 /* Redefine yyless() so it works in section 3 code. */
1837 
1838 #undef yyless
1839 #define yyless(n) \
1840  do \
1841  { \
1842  /* Undo effects of setting up yytext. */ \
1843  int yyless_macro_arg = (n); \
1844  YY_LESS_LINENO(yyless_macro_arg);\
1845  yytext[yyleng] = (yy_hold_char); \
1846  (yy_c_buf_p) = yytext + yyless_macro_arg; \
1847  (yy_hold_char) = *(yy_c_buf_p); \
1848  *(yy_c_buf_p) = '\0'; \
1849  yyleng = yyless_macro_arg; \
1850  } \
1851  while ( 0 )
1852 
1853 /* Accessor methods (get/set functions) to struct members. */
1854 
1858 int yyget_lineno (void)
1859 {
1860 
1861  return yylineno;
1862 }
1863 
1867 FILE *yyget_in (void)
1868 {
1869  return yyin;
1870 }
1871 
1875 FILE *yyget_out (void)
1876 {
1877  return yyout;
1878 }
1879 
1883 int yyget_leng (void)
1884 {
1885  return yyleng;
1886 }
1887 
1892 char *yyget_text (void)
1893 {
1894  return yytext;
1895 }
1896 
1901 void yyset_lineno (int _line_number )
1902 {
1903 
1904  yylineno = _line_number;
1905 }
1906 
1913 void yyset_in (FILE * _in_str )
1914 {
1915  yyin = _in_str ;
1916 }
1917 
1918 void yyset_out (FILE * _out_str )
1919 {
1920  yyout = _out_str ;
1921 }
1922 
1923 int yyget_debug (void)
1924 {
1925  return yy_flex_debug;
1926 }
1927 
1928 void yyset_debug (int _bdebug )
1929 {
1930  yy_flex_debug = _bdebug ;
1931 }
1932 
1933 static int yy_init_globals (void)
1934 {
1935  /* Initialization is the same as for the non-reentrant scanner.
1936  * This function is called from yylex_destroy(), so don't allocate here.
1937  */
1938 
1939  (yy_buffer_stack) = NULL;
1940  (yy_buffer_stack_top) = 0;
1941  (yy_buffer_stack_max) = 0;
1942  (yy_c_buf_p) = NULL;
1943  (yy_init) = 0;
1944  (yy_start) = 0;
1945 
1946 /* Defined in main.c */
1947 #ifdef YY_STDINIT
1948  yyin = stdin;
1949  yyout = stdout;
1950 #else
1951  yyin = NULL;
1952  yyout = NULL;
1953 #endif
1954 
1955  /* For future reference: Set errno on error, since we are called by
1956  * yylex_init()
1957  */
1958  return 0;
1959 }
1960 
1961 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1962 int yylex_destroy (void)
1963 {
1964 
1965  /* Pop the buffer stack, destroying each element. */
1966  while(YY_CURRENT_BUFFER){
1968  YY_CURRENT_BUFFER_LVALUE = NULL;
1970  }
1971 
1972  /* Destroy the stack itself. */
1973  yyfree((yy_buffer_stack) );
1974  (yy_buffer_stack) = NULL;
1975 
1976  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1977  * yylex() is called, initialization will occur. */
1978  yy_init_globals( );
1979 
1980  return 0;
1981 }
1982 
1983 /*
1984  * Internal utility routines.
1985  */
1986 
1987 #ifndef yytext_ptr
1988 static void yy_flex_strncpy (char* s1, const char * s2, int n )
1989 {
1990 
1991  int i;
1992  for ( i = 0; i < n; ++i )
1993  s1[i] = s2[i];
1994 }
1995 #endif
1996 
1997 #ifdef YY_NEED_STRLEN
1998 static int yy_flex_strlen (const char * s )
1999 {
2000  int n;
2001  for ( n = 0; s[n]; ++n )
2002  ;
2003 
2004  return n;
2005 }
2006 #endif
2007 
2008 void *yyalloc (yy_size_t size )
2009 {
2010  return malloc(size);
2011 }
2012 
2013 void *yyrealloc (void * ptr, yy_size_t size )
2014 {
2015 
2016  /* The cast to (char *) in the following accommodates both
2017  * implementations that use char* generic pointers, and those
2018  * that use void* generic pointers. It works with the latter
2019  * because both ANSI C and C++ allow castless assignment from
2020  * any pointer type to void*, and deal with argument conversions
2021  * as though doing an assignment.
2022  */
2023  return realloc(ptr, size);
2024 }
2025 
2026 void yyfree (void * ptr )
2027 {
2028  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2029 }
2030 
2031 #define YYTABLES_NAME "yytables"
2032 
2033 #line 50 "scanner.l"
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: json_lex.yy.cpp:764
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:618
yyterminate
#define yyterminate()
Definition: json_lex.yy.cpp:890
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:925
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: json_lex.yy.cpp:731
yy_buffer_state
Definition: ansi_c_lex.yy.cpp:445
yyget_leng
#define yyget_leng
Definition: json_lex.yy.cpp:195
yyget_in
#define yyget_in
Definition: json_lex.yy.cpp:171
yy_meta
static const YY_CHAR yy_meta[21]
Definition: json_lex.yy.cpp:665
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:719
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
TOK_NUMBER
#define TOK_NUMBER
Definition: json_y.tab.cpp:192
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: json_lex.yy.cpp:837
INITIAL
#define INITIAL
Definition: json_lex.yy.cpp:753
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_ec
static const YY_CHAR yy_ec[256]
Definition: json_lex.yy.cpp:633
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:720
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:1830
TOK_NULL
#define TOK_NULL
Definition: jsil_y.tab.cpp:230
yyfree
#define yyfree
Definition: json_lex.yy.cpp:32
yyset_debug
#define yyset_debug
Definition: json_lex.yy.cpp:153
yy_accept
static const flex_int16_t yy_accept[43]
Definition: json_lex.yy.cpp:624
yyget_debug
#define yyget_debug
Definition: json_lex.yy.cpp:147
TOK_STRING
#define TOK_STRING
Definition: ansi_c_y.tab.cpp:425
yy_chk
static const flex_int16_t yy_chk[93]
Definition: json_lex.yy.cpp:704
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:853
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
yy_nxt
static const flex_int16_t yy_nxt[93]
Definition: json_lex.yy.cpp:689
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:928
TOK_FALSE
#define TOK_FALSE
Definition: ansi_c_y.tab.cpp:507
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:1376
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
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:730
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
TOK_TRUE
#define TOK_TRUE
Definition: ansi_c_y.tab.cpp:506
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
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
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_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:900
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: json_lex.yy.cpp:1827
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:1933
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:913
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_base
static const flex_int16_t yy_base[44]
Definition: json_lex.yy.cpp:671
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
yy_def
static const flex_int16_t yy_def[44]
Definition: json_lex.yy.cpp:680
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:1344
yyrealloc
#define yyrealloc
Definition: json_lex.yy.cpp:31
free
void free(void *)
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:1206
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