cprover
xml_lex.yy.cpp
Go to the documentation of this file.
1 #line 1 "xml_lex.yy.cpp"
2 
3 #line 3 "xml_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 yyxml_create_buffer
10 #define yy_delete_buffer yyxml_delete_buffer
11 #define yy_scan_buffer yyxml_scan_buffer
12 #define yy_scan_string yyxml_scan_string
13 #define yy_scan_bytes yyxml_scan_bytes
14 #define yy_init_buffer yyxml_init_buffer
15 #define yy_flush_buffer yyxml_flush_buffer
16 #define yy_load_buffer_state yyxml_load_buffer_state
17 #define yy_switch_to_buffer yyxml_switch_to_buffer
18 #define yypush_buffer_state yyxmlpush_buffer_state
19 #define yypop_buffer_state yyxmlpop_buffer_state
20 #define yyensure_buffer_stack yyxmlensure_buffer_stack
21 #define yy_flex_debug yyxml_flex_debug
22 #define yyin yyxmlin
23 #define yyleng yyxmlleng
24 #define yylex yyxmllex
25 #define yylineno yyxmllineno
26 #define yyout yyxmlout
27 #define yyrestart yyxmlrestart
28 #define yytext yyxmltext
29 #define yywrap yyxmlwrap
30 #define yyalloc yyxmlalloc
31 #define yyrealloc yyxmlrealloc
32 #define yyfree yyxmlfree
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 yyxml_create_buffer_ALREADY_DEFINED
44 #else
45 #define yy_create_buffer yyxml_create_buffer
46 #endif
47 
48 #ifdef yy_delete_buffer
49 #define yyxml_delete_buffer_ALREADY_DEFINED
50 #else
51 #define yy_delete_buffer yyxml_delete_buffer
52 #endif
53 
54 #ifdef yy_scan_buffer
55 #define yyxml_scan_buffer_ALREADY_DEFINED
56 #else
57 #define yy_scan_buffer yyxml_scan_buffer
58 #endif
59 
60 #ifdef yy_scan_string
61 #define yyxml_scan_string_ALREADY_DEFINED
62 #else
63 #define yy_scan_string yyxml_scan_string
64 #endif
65 
66 #ifdef yy_scan_bytes
67 #define yyxml_scan_bytes_ALREADY_DEFINED
68 #else
69 #define yy_scan_bytes yyxml_scan_bytes
70 #endif
71 
72 #ifdef yy_init_buffer
73 #define yyxml_init_buffer_ALREADY_DEFINED
74 #else
75 #define yy_init_buffer yyxml_init_buffer
76 #endif
77 
78 #ifdef yy_flush_buffer
79 #define yyxml_flush_buffer_ALREADY_DEFINED
80 #else
81 #define yy_flush_buffer yyxml_flush_buffer
82 #endif
83 
84 #ifdef yy_load_buffer_state
85 #define yyxml_load_buffer_state_ALREADY_DEFINED
86 #else
87 #define yy_load_buffer_state yyxml_load_buffer_state
88 #endif
89 
90 #ifdef yy_switch_to_buffer
91 #define yyxml_switch_to_buffer_ALREADY_DEFINED
92 #else
93 #define yy_switch_to_buffer yyxml_switch_to_buffer
94 #endif
95 
96 #ifdef yypush_buffer_state
97 #define yyxmlpush_buffer_state_ALREADY_DEFINED
98 #else
99 #define yypush_buffer_state yyxmlpush_buffer_state
100 #endif
101 
102 #ifdef yypop_buffer_state
103 #define yyxmlpop_buffer_state_ALREADY_DEFINED
104 #else
105 #define yypop_buffer_state yyxmlpop_buffer_state
106 #endif
107 
108 #ifdef yyensure_buffer_stack
109 #define yyxmlensure_buffer_stack_ALREADY_DEFINED
110 #else
111 #define yyensure_buffer_stack yyxmlensure_buffer_stack
112 #endif
113 
114 #ifdef yylex
115 #define yyxmllex_ALREADY_DEFINED
116 #else
117 #define yylex yyxmllex
118 #endif
119 
120 #ifdef yyrestart
121 #define yyxmlrestart_ALREADY_DEFINED
122 #else
123 #define yyrestart yyxmlrestart
124 #endif
125 
126 #ifdef yylex_init
127 #define yyxmllex_init_ALREADY_DEFINED
128 #else
129 #define yylex_init yyxmllex_init
130 #endif
131 
132 #ifdef yylex_init_extra
133 #define yyxmllex_init_extra_ALREADY_DEFINED
134 #else
135 #define yylex_init_extra yyxmllex_init_extra
136 #endif
137 
138 #ifdef yylex_destroy
139 #define yyxmllex_destroy_ALREADY_DEFINED
140 #else
141 #define yylex_destroy yyxmllex_destroy
142 #endif
143 
144 #ifdef yyget_debug
145 #define yyxmlget_debug_ALREADY_DEFINED
146 #else
147 #define yyget_debug yyxmlget_debug
148 #endif
149 
150 #ifdef yyset_debug
151 #define yyxmlset_debug_ALREADY_DEFINED
152 #else
153 #define yyset_debug yyxmlset_debug
154 #endif
155 
156 #ifdef yyget_extra
157 #define yyxmlget_extra_ALREADY_DEFINED
158 #else
159 #define yyget_extra yyxmlget_extra
160 #endif
161 
162 #ifdef yyset_extra
163 #define yyxmlset_extra_ALREADY_DEFINED
164 #else
165 #define yyset_extra yyxmlset_extra
166 #endif
167 
168 #ifdef yyget_in
169 #define yyxmlget_in_ALREADY_DEFINED
170 #else
171 #define yyget_in yyxmlget_in
172 #endif
173 
174 #ifdef yyset_in
175 #define yyxmlset_in_ALREADY_DEFINED
176 #else
177 #define yyset_in yyxmlset_in
178 #endif
179 
180 #ifdef yyget_out
181 #define yyxmlget_out_ALREADY_DEFINED
182 #else
183 #define yyget_out yyxmlget_out
184 #endif
185 
186 #ifdef yyset_out
187 #define yyxmlset_out_ALREADY_DEFINED
188 #else
189 #define yyset_out yyxmlset_out
190 #endif
191 
192 #ifdef yyget_leng
193 #define yyxmlget_leng_ALREADY_DEFINED
194 #else
195 #define yyget_leng yyxmlget_leng
196 #endif
197 
198 #ifdef yyget_text
199 #define yyxmlget_text_ALREADY_DEFINED
200 #else
201 #define yyget_text yyxmlget_text
202 #endif
203 
204 #ifdef yyget_lineno
205 #define yyxmlget_lineno_ALREADY_DEFINED
206 #else
207 #define yyget_lineno yyxmlget_lineno
208 #endif
209 
210 #ifdef yyset_lineno
211 #define yyxmlset_lineno_ALREADY_DEFINED
212 #else
213 #define yyset_lineno yyxmlset_lineno
214 #endif
215 
216 #ifdef yywrap
217 #define yyxmlwrap_ALREADY_DEFINED
218 #else
219 #define yywrap yyxmlwrap
220 #endif
221 
222 #ifdef yyalloc
223 #define yyxmlalloc_ALREADY_DEFINED
224 #else
225 #define yyalloc yyxmlalloc
226 #endif
227 
228 #ifdef yyrealloc
229 #define yyxmlrealloc_ALREADY_DEFINED
230 #else
231 #define yyrealloc yyxmlrealloc
232 #endif
233 
234 #ifdef yyfree
235 #define yyxmlfree_ALREADY_DEFINED
236 #else
237 #define yyfree yyxmlfree
238 #endif
239 
240 #ifdef yytext
241 #define yyxmltext_ALREADY_DEFINED
242 #else
243 #define yytext yyxmltext
244 #endif
245 
246 #ifdef yyleng
247 #define yyxmlleng_ALREADY_DEFINED
248 #else
249 #define yyleng yyxmlleng
250 #endif
251 
252 #ifdef yyin
253 #define yyxmlin_ALREADY_DEFINED
254 #else
255 #define yyin yyxmlin
256 #endif
257 
258 #ifdef yyout
259 #define yyxmlout_ALREADY_DEFINED
260 #else
261 #define yyout yyxmlout
262 #endif
263 
264 #ifdef yy_flex_debug
265 #define yyxml_flex_debug_ALREADY_DEFINED
266 #else
267 #define yy_flex_debug yyxml_flex_debug
268 #endif
269 
270 #ifdef yylineno
271 #define yyxmllineno_ALREADY_DEFINED
272 #else
273 #define yylineno yyxmllineno
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 /* Begin user sect3 */
586 
587 FILE *yyin = NULL, *yyout = NULL;
588 
589 typedef int yy_state_type;
590 
591 extern int yylineno;
592 int yylineno = 1;
593 
594 extern char *yytext;
595 #ifdef yytext_ptr
596 #undef yytext_ptr
597 #endif
598 #define yytext_ptr yytext
599 
600 static yy_state_type yy_get_previous_state ( void );
601 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
602 static int yy_get_next_buffer ( void );
603 static void yynoreturn yy_fatal_error ( const char* msg );
604 
605 /* Done after the current pattern has been matched and before the
606  * corresponding action - sets up yytext.
607  */
608 #define YY_DO_BEFORE_ACTION \
609  (yytext_ptr) = yy_bp; \
610  yyleng = (int) (yy_cp - yy_bp); \
611  (yy_hold_char) = *yy_cp; \
612  *yy_cp = '\0'; \
613  (yy_c_buf_p) = yy_cp;
614 #define YY_NUM_RULES 19
615 #define YY_END_OF_BUFFER 20
616 /* This struct is not used in this scanner,
617  but its presence is necessary. */
618 struct yy_trans_info
619  {
622  };
623 static const flex_int16_t yy_accept[108] =
624  { 0,
625  0, 0, 0, 0, 0, 0, 0, 0, 20, 17,
626  1, 1, 1, 17, 17, 2, 17, 3, 4, 17,
627  5, 13, 18, 13, 17, 17, 1, 1, 15, 18,
628  15, 15, 15, 1, 0, 1, 0, 6, 0, 0,
629  0, 0, 0, 9, 11, 8, 4, 4, 7, 5,
630  13, 0, 0, 0, 0, 18, 0, 0, 0, 1,
631  18, 16, 0, 0, 0, 0, 0, 0, 0, 0,
632  8, 7, 7, 0, 0, 0, 0, 13, 16, 16,
633  0, 0, 0, 0, 0, 0, 0, 0, 0, 13,
634  0, 0, 0, 0, 0, 0, 10, 0, 0, 0,
635 
636  12, 0, 12, 12, 0, 14, 0
637  } ;
638 
639 static const YY_CHAR yy_ec[256] =
640  { 0,
641  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
642  1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
643  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
644  1, 2, 5, 6, 7, 1, 1, 8, 9, 1,
645  1, 1, 1, 1, 10, 11, 12, 13, 13, 13,
646  13, 13, 13, 13, 13, 13, 13, 11, 14, 15,
647  16, 17, 18, 1, 19, 19, 20, 21, 22, 19,
648  23, 23, 23, 23, 23, 23, 23, 23, 24, 25,
649  23, 23, 23, 26, 23, 23, 23, 23, 27, 23,
650  1, 1, 28, 1, 29, 1, 19, 19, 19, 19,
651 
652  19, 19, 23, 23, 23, 23, 23, 30, 31, 23,
653  23, 23, 23, 23, 23, 23, 23, 23, 23, 32,
654  23, 23, 1, 1, 1, 1, 1, 29, 29, 29,
655  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
656  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
657  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
658  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
659  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
660  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
661  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
662 
663  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
664  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
665  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
666  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
667  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
668  29, 29, 29, 29, 29
669  } ;
670 
671 static const YY_CHAR yy_meta[33] =
672  { 0,
673  1, 2, 2, 2, 3, 1, 4, 1, 1, 5,
674  6, 3, 7, 1, 8, 1, 1, 3, 9, 9,
675  10, 9, 11, 11, 11, 11, 11, 1, 12, 11,
676  11, 11
677  } ;
678 
679 static const flex_int16_t yy_base[126] =
680  { 0,
681  0, 0, 30, 32, 45, 60, 38, 40, 295, 330,
682  48, 67, 76, 31, 50, 330, 90, 330, 70, 272,
683  0, 53, 68, 81, 277, 107, 83, 101, 330, 268,
684  85, 0, 265, 111, 276, 118, 59, 330, 272, 98,
685  271, 112, 80, 330, 241, 0, 330, 269, 120, 0,
686  123, 263, 263, 258, 0, 119, 86, 121, 254, 134,
687  248, 136, 116, 136, 119, 138, 151, 252, 233, 225,
688  0, 330, 252, 128, 149, 133, 0, 154, 330, 251,
689  145, 0, 151, 0, 238, 216, 198, 153, 0, 165,
690  213, 212, 211, 214, 161, 135, 330, 130, 125, 70,
691 
692  166, 56, 330, 51, 24, 330, 330, 173, 185, 197,
693  209, 220, 228, 240, 249, 257, 265, 275, 281, 290,
694  295, 299, 303, 313, 319
695  } ;
696 
697 static const flex_int16_t yy_def[126] =
698  { 0,
699  107, 1, 108, 108, 1, 1, 109, 109, 107, 107,
700  107, 107, 107, 110, 111, 107, 112, 107, 107, 107,
701  113, 114, 114, 114, 115, 112, 107, 107, 107, 107,
702  107, 26, 107, 107, 26, 107, 110, 107, 116, 111,
703  117, 26, 118, 107, 107, 119, 107, 107, 107, 113,
704  114, 114, 115, 120, 26, 114, 107, 115, 107, 107,
705  107, 107, 107, 116, 107, 117, 107, 107, 107, 107,
706  119, 107, 107, 107, 120, 107, 121, 114, 107, 107,
707  107, 122, 107, 123, 124, 107, 107, 107, 125, 114,
708  121, 122, 123, 124, 124, 107, 107, 125, 107, 107,
709 
710  107, 107, 107, 107, 107, 107, 0, 107, 107, 107,
711  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
712  107, 107, 107, 107, 107
713  } ;
714 
715 static const flex_int16_t yy_nxt[363] =
716  { 0,
717  10, 11, 12, 13, 10, 14, 10, 10, 15, 10,
718  10, 16, 10, 10, 17, 18, 19, 20, 21, 21,
719  21, 21, 21, 21, 21, 21, 21, 10, 21, 21,
720  21, 21, 23, 24, 23, 24, 38, 25, 39, 25,
721  30, 31, 30, 31, 26, 106, 26, 27, 28, 34,
722  34, 34, 32, 103, 32, 52, 10, 41, 38, 26,
723  53, 10, 27, 28, 38, 33, 39, 33, 34, 34,
724  34, 10, 47, 48, 26, 54, 10, 34, 36, 34,
725  105, 35, 55, 56, 34, 34, 34, 61, 53, 68,
726  35, 42, 42, 42, 43, 55, 102, 55, 76, 55,
727 
728  69, 44, 34, 60, 34, 41, 38, 45, 42, 42,
729  42, 59, 34, 34, 34, 55, 107, 77, 44, 34,
730  34, 34, 72, 73, 45, 52, 54, 107, 81, 107,
731  53, 83, 35, 55, 78, 34, 34, 34, 79, 80,
732  88, 101, 107, 90, 107, 76, 78, 82, 55, 37,
733  84, 40, 67, 67, 67, 107, 52, 81, 37, 89,
734  100, 53, 90, 83, 40, 88, 90, 52, 103, 104,
735  99, 69, 53, 22, 22, 22, 22, 22, 22, 22,
736  22, 22, 22, 22, 22, 29, 29, 29, 29, 29,
737  29, 29, 29, 29, 29, 29, 29, 37, 37, 37,
738 
739  37, 37, 37, 37, 37, 37, 37, 37, 37, 40,
740  40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
741  40, 46, 46, 95, 40, 37, 78, 97, 46, 46,
742  46, 46, 50, 50, 50, 96, 50, 50, 50, 50,
743  51, 51, 51, 51, 51, 51, 51, 95, 51, 51,
744  51, 51, 58, 79, 72, 87, 86, 58, 58, 58,
745  64, 85, 55, 68, 74, 64, 64, 64, 66, 57,
746  54, 47, 70, 66, 66, 66, 67, 65, 63, 67,
747  43, 62, 55, 57, 67, 71, 71, 71, 49, 71,
748  71, 71, 71, 75, 107, 107, 107, 107, 75, 75,
749 
750  75, 91, 107, 91, 91, 92, 107, 92, 92, 93,
751  107, 93, 93, 94, 94, 94, 94, 94, 94, 94,
752  94, 94, 94, 94, 94, 98, 107, 98, 98, 9,
753  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
754  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
755  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
756  107, 107
757  } ;
758 
759 static const flex_int16_t yy_chk[363] =
760  { 0,
761  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
762  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
763  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
764  1, 1, 3, 3, 4, 4, 14, 3, 14, 4,
765  7, 7, 8, 8, 3, 105, 4, 5, 5, 11,
766  11, 11, 7, 104, 8, 22, 5, 15, 15, 5,
767  22, 5, 6, 6, 37, 7, 37, 8, 12, 12,
768  12, 6, 19, 19, 6, 23, 6, 13, 13, 13,
769  102, 12, 23, 24, 27, 27, 27, 31, 24, 43,
770  13, 17, 17, 17, 17, 24, 100, 27, 57, 31,
771 
772  43, 17, 28, 28, 28, 40, 40, 17, 26, 26,
773  26, 26, 34, 34, 34, 28, 42, 57, 26, 36,
774  36, 36, 49, 49, 26, 51, 56, 58, 63, 42,
775  51, 65, 36, 56, 58, 60, 60, 60, 62, 62,
776  74, 99, 64, 98, 66, 76, 76, 63, 60, 64,
777  65, 66, 67, 67, 67, 75, 78, 81, 81, 74,
778  96, 78, 75, 83, 83, 88, 88, 90, 101, 101,
779  95, 67, 90, 108, 108, 108, 108, 108, 108, 108,
780  108, 108, 108, 108, 108, 109, 109, 109, 109, 109,
781  109, 109, 109, 109, 109, 109, 109, 110, 110, 110,
782 
783  110, 110, 110, 110, 110, 110, 110, 110, 110, 111,
784  111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
785  111, 112, 112, 94, 93, 92, 91, 87, 112, 112,
786  112, 112, 113, 113, 113, 86, 113, 113, 113, 113,
787  114, 114, 114, 114, 114, 114, 114, 85, 114, 114,
788  114, 114, 115, 80, 73, 70, 69, 115, 115, 115,
789  116, 68, 61, 59, 54, 116, 116, 116, 117, 53,
790  52, 48, 45, 117, 117, 117, 118, 41, 39, 118,
791  35, 33, 30, 25, 118, 119, 119, 119, 20, 119,
792  119, 119, 119, 120, 9, 0, 0, 0, 120, 120,
793 
794  120, 121, 0, 121, 121, 122, 0, 122, 122, 123,
795  0, 123, 123, 124, 124, 124, 124, 124, 124, 124,
796  124, 124, 124, 124, 124, 125, 0, 125, 125, 107,
797  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
798  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
799  107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
800  107, 107
801  } ;
802 
805 
806 extern int yy_flex_debug;
808 
809 /* The intent behind this definition is that it'll catch
810  * any uses of REJECT which flex missed.
811  */
812 #define REJECT reject_used_but_not_detected
813 #define yymore() yymore_used_but_not_detected
814 #define YY_MORE_ADJ 0
815 #define YY_RESTORE_YY_MORE_OFFSET
816 char *yytext;
817 #line 1 "scanner.l"
818 #define YY_NO_INPUT 1
819 #define YY_NO_UNISTD_H 1
820 #line 8 "scanner.l"
821 
822 #include <cctype>
823 #include <cstring>
824 #include <cstdlib>
825 
826 #include "xml_parser.h"
827 #include "xml_y.tab.h"
828 
829 #define PARSER xml_parser
830 
831 //static int keep; /* To store start condition */
832 
833 static char *word(char *s)
834 {
835  char *buf;
836  int i, k;
837  for (k = 0; isspace(s[k]) || s[k] == '<'; k++) ;
838  for (i = k; s[i] && ! isspace(s[i]); i++) ;
839  buf = (char *)malloc((i - k + 1) * sizeof(char));
840  strncpy(buf, &s[k], i - k);
841  buf[i - k] = '\0';
842  return buf;
843 }
844 
845 #include <util/pragma_wsign_compare.def>
846 #include <util/pragma_wnull_conversion.def>
847 #include <util/pragma_wdeprecated_register.def>
848 
849 #line 849 "xml_lex.yy.cpp"
850 /*
851  * The CONTENT mode is used for the content of elements, i.e.,
852  * between the ">" and "<" of element tags.
853  * The INITIAL mode is used outside the top level element
854  * and inside markup.
855  */
856 
857 #line 857 "xml_lex.yy.cpp"
858 
859 #define INITIAL 0
860 #define CONTENT 1
861 #define PI 2
862 #define DTD 3
863 
864 #ifndef YY_NO_UNISTD_H
865 /* Special case for "unistd.h", since it is non-ANSI. We include it way
866  * down here because we want the user's section 1 to have been scanned first.
867  * The user has a chance to override it with an option.
868  */
869 #include <unistd.h>
870 #endif
871 
872 #ifndef YY_EXTRA_TYPE
873 #define YY_EXTRA_TYPE void *
874 #endif
875 
876 static int yy_init_globals ( void );
877 
878 /* Accessor methods to globals.
879  These are made visible to non-reentrant scanners for convenience. */
880 
881 int yylex_destroy ( void );
882 
883 int yyget_debug ( void );
884 
885 void yyset_debug ( int debug_flag );
886 
887 YY_EXTRA_TYPE yyget_extra ( void );
888 
889 void yyset_extra ( YY_EXTRA_TYPE user_defined );
890 
891 FILE *yyget_in ( void );
892 
893 void yyset_in ( FILE * _in_str );
894 
895 FILE *yyget_out ( void );
896 
897 void yyset_out ( FILE * _out_str );
898 
899  int yyget_leng ( void );
900 
901 char *yyget_text ( void );
902 
903 int yyget_lineno ( void );
904 
905 void yyset_lineno ( int _line_number );
906 
907 /* Macros after this point can all be overridden by user definitions in
908  * section 1.
909  */
910 
911 #ifndef YY_SKIP_YYWRAP
912 #ifdef __cplusplus
913 extern "C" int yywrap ( void );
914 #else
915 extern int yywrap ( void );
916 #endif
917 #endif
918 
919 #ifndef YY_NO_UNPUT
920 
921 #endif
922 
923 #ifndef yytext_ptr
924 static void yy_flex_strncpy ( char *, const char *, int );
925 #endif
926 
927 #ifdef YY_NEED_STRLEN
928 static int yy_flex_strlen ( const char * );
929 #endif
930 
931 #ifndef YY_NO_INPUT
932 #ifdef __cplusplus
933 static int yyinput ( void );
934 #else
935 static int input ( void );
936 #endif
937 
938 #endif
939 
940 /* Amount of stuff to slurp up with each read. */
941 #ifndef YY_READ_BUF_SIZE
942 #ifdef __ia64__
943 /* On IA-64, the buffer size is 16k, not 8k */
944 #define YY_READ_BUF_SIZE 16384
945 #else
946 #define YY_READ_BUF_SIZE 8192
947 #endif /* __ia64__ */
948 #endif
949 
950 /* Copy whatever the last rule matched to the standard output. */
951 #ifndef ECHO
952 /* This used to be an fputs(), but since the string might contain NUL's,
953  * we now use fwrite().
954  */
955 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
956 #endif
957 
958 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
959  * is returned in "result".
960  */
961 #ifndef YY_INPUT
962 #define YY_INPUT(buf,result,max_size) \
963  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
964  { \
965  int c = '*'; \
966  int n; \
967  for ( n = 0; n < max_size && \
968  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
969  buf[n] = (char) c; \
970  if ( c == '\n' ) \
971  buf[n++] = (char) c; \
972  if ( c == EOF && ferror( yyin ) ) \
973  YY_FATAL_ERROR( "input in flex scanner failed" ); \
974  result = n; \
975  } \
976  else \
977  { \
978  errno=0; \
979  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
980  { \
981  if( errno != EINTR) \
982  { \
983  YY_FATAL_ERROR( "input in flex scanner failed" ); \
984  break; \
985  } \
986  errno=0; \
987  clearerr(yyin); \
988  } \
989  }\
990 \
991 
992 #endif
993 
994 /* No semi-colon after return; correct usage is to write "yyterminate();" -
995  * we don't want an extra ';' after the "return" because that will cause
996  * some compilers to complain about unreachable statements.
997  */
998 #ifndef yyterminate
999 #define yyterminate() return YY_NULL
1000 #endif
1001 
1002 /* Number of entries by which start-condition stack grows. */
1003 #ifndef YY_START_STACK_INCR
1004 #define YY_START_STACK_INCR 25
1005 #endif
1006 
1007 /* Report a fatal error. */
1008 #ifndef YY_FATAL_ERROR
1009 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1010 #endif
1011 
1012 /* end tables serialization structures and prototypes */
1013 
1014 /* Default declaration of generated scanner - a define so the user can
1015  * easily add parameters.
1016  */
1017 #ifndef YY_DECL
1018 #define YY_DECL_IS_OURS 1
1019 
1020 extern int yylex (void);
1021 
1022 #define YY_DECL int yylex (void)
1023 #endif /* !YY_DECL */
1024 
1025 /* Code executed at the beginning of each rule, after yytext and yyleng
1026  * have been set up.
1027  */
1028 #ifndef YY_USER_ACTION
1029 #define YY_USER_ACTION
1030 #endif
1031 
1032 /* Code executed at the end of each rule. */
1033 #ifndef YY_BREAK
1034 #define YY_BREAK /*LINTED*/break;
1035 #endif
1036 
1037 #define YY_RULE_SETUP \
1038  YY_USER_ACTION
1039 
1043 {
1044  yy_state_type yy_current_state;
1045  char *yy_cp, *yy_bp;
1046  int yy_act;
1047 
1048  if ( !(yy_init) )
1049  {
1050  (yy_init) = 1;
1051 
1052 #ifdef YY_USER_INIT
1053  YY_USER_INIT;
1054 #endif
1055 
1056  if ( ! (yy_start) )
1057  (yy_start) = 1; /* first start state */
1058 
1059  if ( ! yyin )
1060  yyin = stdin;
1061 
1062  if ( ! yyout )
1063  yyout = stdout;
1064 
1065  if ( ! YY_CURRENT_BUFFER ) {
1069  }
1070 
1072  }
1073 
1074  {
1075 #line 62 "scanner.l"
1076 
1077 
1078 #line 1078 "xml_lex.yy.cpp"
1079 
1080  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1081  {
1082  yy_cp = (yy_c_buf_p);
1083 
1084  /* Support of yytext. */
1085  *yy_cp = (yy_hold_char);
1086 
1087  /* yy_bp points to the position in yy_ch_buf of the start of
1088  * the current run.
1089  */
1090  yy_bp = yy_cp;
1091 
1092  yy_current_state = (yy_start);
1093 yy_match:
1094  do
1095  {
1096  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1097  if ( yy_accept[yy_current_state] )
1098  {
1099  (yy_last_accepting_state) = yy_current_state;
1100  (yy_last_accepting_cpos) = yy_cp;
1101  }
1102  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1103  {
1104  yy_current_state = (int) yy_def[yy_current_state];
1105  if ( yy_current_state >= 108 )
1106  yy_c = yy_meta[yy_c];
1107  }
1108  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1109  ++yy_cp;
1110  }
1111  while ( yy_current_state != 107 );
1112  yy_cp = (yy_last_accepting_cpos);
1113  yy_current_state = (yy_last_accepting_state);
1114 
1115 yy_find_action:
1116  yy_act = yy_accept[yy_current_state];
1117 
1119 
1120 do_action: /* This label is used only to access EOF actions. */
1121 
1122  switch ( yy_act )
1123  { /* beginning of action switch */
1124  case 0: /* must back up */
1125  /* undo the effects of YY_DO_BEFORE_ACTION */
1126  *yy_cp = (yy_hold_char);
1127  yy_cp = (yy_last_accepting_cpos);
1128  yy_current_state = (yy_last_accepting_state);
1129  goto yy_find_action;
1130 
1131 case 1:
1132 /* rule 1 can match eol */
1134 #line 64 "scanner.l"
1135 {/* skip */}
1136  YY_BREAK
1137 case 2:
1139 #line 65 "scanner.l"
1140 {return SLASH;}
1141  YY_BREAK
1142 case 3:
1144 #line 66 "scanner.l"
1145 {return EQ;}
1146  YY_BREAK
1147 case 4:
1148 /* rule 4 can match eol */
1150 #line 67 "scanner.l"
1151 {BEGIN(CONTENT); return CLOSE;}
1152  YY_BREAK
1153 case 5:
1155 #line 68 "scanner.l"
1156 {yyxmllval.s=strdup(yytext); return NAME;}
1157  YY_BREAK
1158 case 6:
1159 /* rule 6 can match eol */
1161 #line 69 "scanner.l"
1162 {yyxmllval.s=strdup(yytext); return VALUE;}
1163  YY_BREAK
1164 case 7:
1165 /* rule 7 can match eol */
1167 #line 70 "scanner.l"
1168 {BEGIN(INITIAL); return ENDPI;}
1169  YY_BREAK
1170 case 8:
1171 /* rule 8 can match eol */
1173 #line 72 "scanner.l"
1174 {BEGIN(INITIAL); yyxmllval.s=word(yytext); return START;}
1175  YY_BREAK
1176 case 9:
1177 /* rule 9 can match eol */
1179 #line 73 "scanner.l"
1180 {BEGIN(INITIAL); return END;}
1181  YY_BREAK
1182 case 10:
1183 /* rule 10 can match eol */
1185 #line 74 "scanner.l"
1186 {BEGIN(INITIAL); return STARTXMLDECL;}
1187  YY_BREAK
1188 case 11:
1189 /* rule 11 can match eol */
1191 #line 75 "scanner.l"
1192 {BEGIN(PI); yyxmllval.s=word(yytext); return STARTPI;}
1193  YY_BREAK
1194 case 12:
1195 /* rule 12 can match eol */
1197 #line 76 "scanner.l"
1198 {yyxmllval.s=strdup(yytext); return COMMENT;}
1199  YY_BREAK
1200 case 13:
1201 /* rule 13 can match eol */
1203 #line 78 "scanner.l"
1204 {yyxmllval.s=strdup(yytext); return DATA;}
1205  YY_BREAK
1206 case 14:
1207 /* rule 14 can match eol */
1209 #line 80 "scanner.l"
1210 {BEGIN(DTD); /* skip */}
1211  YY_BREAK
1212 case 15:
1214 #line 81 "scanner.l"
1215 {/* skip */}
1216  YY_BREAK
1217 case 16:
1218 /* rule 16 can match eol */
1220 #line 82 "scanner.l"
1221 {BEGIN(INITIAL); /* skip */}
1222  YY_BREAK
1223 case 17:
1225 #line 84 "scanner.l"
1226 { yyxmlerror("unexpected character"); }
1227  YY_BREAK
1228 case 18:
1229 /* rule 18 can match eol */
1231 #line 85 "scanner.l"
1232 {/* skip, must be an extra one at EOF */;}
1233  YY_BREAK
1234 case 19:
1236 #line 87 "scanner.l"
1237 YY_FATAL_ERROR( "flex scanner jammed" );
1238  YY_BREAK
1239 #line 1239 "xml_lex.yy.cpp"
1240 case YY_STATE_EOF(INITIAL):
1241 case YY_STATE_EOF(CONTENT):
1242 case YY_STATE_EOF(PI):
1243 case YY_STATE_EOF(DTD):
1244  yyterminate();
1245 
1246  case YY_END_OF_BUFFER:
1247  {
1248  /* Amount of text matched not including the EOB char. */
1249  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1250 
1251  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1252  *yy_cp = (yy_hold_char);
1254 
1255  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1256  {
1257  /* We're scanning a new file or input source. It's
1258  * possible that this happened because the user
1259  * just pointed yyin at a new source and called
1260  * yylex(). If so, then we have to assure
1261  * consistency between YY_CURRENT_BUFFER and our
1262  * globals. Here is the right place to do so, because
1263  * this is the first action (other than possibly a
1264  * back-up) that will match for the new input source.
1265  */
1266  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1267  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1268  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1269  }
1270 
1271  /* Note that here we test for yy_c_buf_p "<=" to the position
1272  * of the first EOB in the buffer, since yy_c_buf_p will
1273  * already have been incremented past the NUL character
1274  * (since all states make transitions on EOB to the
1275  * end-of-buffer state). Contrast this with the test
1276  * in input().
1277  */
1278  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1279  { /* This was really a NUL. */
1280  yy_state_type yy_next_state;
1281 
1282  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1283 
1284  yy_current_state = yy_get_previous_state( );
1285 
1286  /* Okay, we're now positioned to make the NUL
1287  * transition. We couldn't have
1288  * yy_get_previous_state() go ahead and do it
1289  * for us because it doesn't know how to deal
1290  * with the possibility of jamming (and we don't
1291  * want to build jamming into it because then it
1292  * will run more slowly).
1293  */
1294 
1295  yy_next_state = yy_try_NUL_trans( yy_current_state );
1296 
1297  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1298 
1299  if ( yy_next_state )
1300  {
1301  /* Consume the NUL. */
1302  yy_cp = ++(yy_c_buf_p);
1303  yy_current_state = yy_next_state;
1304  goto yy_match;
1305  }
1306 
1307  else
1308  {
1309  yy_cp = (yy_last_accepting_cpos);
1310  yy_current_state = (yy_last_accepting_state);
1311  goto yy_find_action;
1312  }
1313  }
1314 
1315  else switch ( yy_get_next_buffer( ) )
1316  {
1317  case EOB_ACT_END_OF_FILE:
1318  {
1320 
1321  if ( yywrap( ) )
1322  {
1323  /* Note: because we've taken care in
1324  * yy_get_next_buffer() to have set up
1325  * yytext, we can now set up
1326  * yy_c_buf_p so that if some total
1327  * hoser (like flex itself) wants to
1328  * call the scanner after we return the
1329  * YY_NULL, it'll still work - another
1330  * YY_NULL will get returned.
1331  */
1333 
1334  yy_act = YY_STATE_EOF(YY_START);
1335  goto do_action;
1336  }
1337 
1338  else
1339  {
1340  if ( ! (yy_did_buffer_switch_on_eof) )
1341  YY_NEW_FILE;
1342  }
1343  break;
1344  }
1345 
1346  case EOB_ACT_CONTINUE_SCAN:
1347  (yy_c_buf_p) =
1348  (yytext_ptr) + yy_amount_of_matched_text;
1349 
1350  yy_current_state = yy_get_previous_state( );
1351 
1352  yy_cp = (yy_c_buf_p);
1353  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1354  goto yy_match;
1355 
1356  case EOB_ACT_LAST_MATCH:
1357  (yy_c_buf_p) =
1358  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1359 
1360  yy_current_state = yy_get_previous_state( );
1361 
1362  yy_cp = (yy_c_buf_p);
1363  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1364  goto yy_find_action;
1365  }
1366  break;
1367  }
1368 
1369  default:
1371  "fatal flex scanner internal error--no action found" );
1372  } /* end of action switch */
1373  } /* end of scanning one token */
1374  } /* end of user's declarations */
1375 } /* end of yylex */
1376 
1377 /* yy_get_next_buffer - try to read in a new buffer
1378  *
1379  * Returns a code representing an action:
1380  * EOB_ACT_LAST_MATCH -
1381  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1382  * EOB_ACT_END_OF_FILE - end of file
1383  */
1384 static int yy_get_next_buffer (void)
1385 {
1386  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1387  char *source = (yytext_ptr);
1388  int number_to_move, i;
1389  int ret_val;
1390 
1391  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1393  "fatal flex scanner internal error--end of buffer missed" );
1394 
1395  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1396  { /* Don't try to fill the buffer, so this is an EOF. */
1397  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1398  {
1399  /* We matched a single character, the EOB, so
1400  * treat this as a final EOF.
1401  */
1402  return EOB_ACT_END_OF_FILE;
1403  }
1404 
1405  else
1406  {
1407  /* We matched some text prior to the EOB, first
1408  * process it.
1409  */
1410  return EOB_ACT_LAST_MATCH;
1411  }
1412  }
1413 
1414  /* Try to read more data. */
1415 
1416  /* First move last chars to start of buffer. */
1417  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1418 
1419  for ( i = 0; i < number_to_move; ++i )
1420  *(dest++) = *(source++);
1421 
1422  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1423  /* don't do the read, it's not guaranteed to return an EOF,
1424  * just force an EOF
1425  */
1426  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1427 
1428  else
1429  {
1430  int num_to_read =
1431  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1432 
1433  while ( num_to_read <= 0 )
1434  { /* Not enough room in the buffer - grow it. */
1435 
1436  /* just a shorter name for the current buffer */
1438 
1439  int yy_c_buf_p_offset =
1440  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1441 
1442  if ( b->yy_is_our_buffer )
1443  {
1444  int new_size = b->yy_buf_size * 2;
1445 
1446  if ( new_size <= 0 )
1447  b->yy_buf_size += b->yy_buf_size / 8;
1448  else
1449  b->yy_buf_size *= 2;
1450 
1451  b->yy_ch_buf = (char *)
1452  /* Include room in for 2 EOB chars. */
1453  yyrealloc( (void *) b->yy_ch_buf,
1454  (yy_size_t) (b->yy_buf_size + 2) );
1455  }
1456  else
1457  /* Can't grow it, we don't own it. */
1458  b->yy_ch_buf = NULL;
1459 
1460  if ( ! b->yy_ch_buf )
1462  "fatal error - scanner input buffer overflow" );
1463 
1464  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1465 
1466  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1467  number_to_move - 1;
1468 
1469  }
1470 
1471  if ( num_to_read > YY_READ_BUF_SIZE )
1472  num_to_read = YY_READ_BUF_SIZE;
1473 
1474  /* Read in more data. */
1475  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1476  (yy_n_chars), num_to_read );
1477 
1478  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1479  }
1480 
1481  if ( (yy_n_chars) == 0 )
1482  {
1483  if ( number_to_move == YY_MORE_ADJ )
1484  {
1485  ret_val = EOB_ACT_END_OF_FILE;
1486  yyrestart( yyin );
1487  }
1488 
1489  else
1490  {
1491  ret_val = EOB_ACT_LAST_MATCH;
1492  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1494  }
1495  }
1496 
1497  else
1498  ret_val = EOB_ACT_CONTINUE_SCAN;
1499 
1500  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1501  /* Extend the array by 50%, plus the number we really need. */
1502  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1503  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1504  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1505  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1506  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1507  /* "- 2" to take care of EOB's */
1508  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1509  }
1510 
1511  (yy_n_chars) += number_to_move;
1514 
1515  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1516 
1517  return ret_val;
1518 }
1519 
1520 /* yy_get_previous_state - get the state just before the EOB char was reached */
1521 
1523 {
1524  yy_state_type yy_current_state;
1525  char *yy_cp;
1526 
1527  yy_current_state = (yy_start);
1528 
1529  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1530  {
1531  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1532  if ( yy_accept[yy_current_state] )
1533  {
1534  (yy_last_accepting_state) = yy_current_state;
1535  (yy_last_accepting_cpos) = yy_cp;
1536  }
1537  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1538  {
1539  yy_current_state = (int) yy_def[yy_current_state];
1540  if ( yy_current_state >= 108 )
1541  yy_c = yy_meta[yy_c];
1542  }
1543  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1544  }
1545 
1546  return yy_current_state;
1547 }
1548 
1549 /* yy_try_NUL_trans - try to make a transition on the NUL character
1550  *
1551  * synopsis
1552  * next_state = yy_try_NUL_trans( current_state );
1553  */
1554  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1555 {
1556  int yy_is_jam;
1557  char *yy_cp = (yy_c_buf_p);
1558 
1559  YY_CHAR yy_c = 1;
1560  if ( yy_accept[yy_current_state] )
1561  {
1562  (yy_last_accepting_state) = yy_current_state;
1563  (yy_last_accepting_cpos) = yy_cp;
1564  }
1565  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1566  {
1567  yy_current_state = (int) yy_def[yy_current_state];
1568  if ( yy_current_state >= 108 )
1569  yy_c = yy_meta[yy_c];
1570  }
1571  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1572  yy_is_jam = (yy_current_state == 107);
1573 
1574  return yy_is_jam ? 0 : yy_current_state;
1575 }
1576 
1577 #ifndef YY_NO_UNPUT
1578 
1579 #endif
1580 
1581 #ifndef YY_NO_INPUT
1582 #ifdef __cplusplus
1583  static int yyinput (void)
1584 #else
1585  static int input (void)
1586 #endif
1587 
1588 {
1589  int c;
1590 
1591  *(yy_c_buf_p) = (yy_hold_char);
1592 
1593  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1594  {
1595  /* yy_c_buf_p now points to the character we want to return.
1596  * If this occurs *before* the EOB characters, then it's a
1597  * valid NUL; if not, then we've hit the end of the buffer.
1598  */
1599  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1600  /* This was really a NUL. */
1601  *(yy_c_buf_p) = '\0';
1602 
1603  else
1604  { /* need more input */
1605  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1606  ++(yy_c_buf_p);
1607 
1608  switch ( yy_get_next_buffer( ) )
1609  {
1610  case EOB_ACT_LAST_MATCH:
1611  /* This happens because yy_g_n_b()
1612  * sees that we've accumulated a
1613  * token and flags that we need to
1614  * try matching the token before
1615  * proceeding. But for input(),
1616  * there's no matching to consider.
1617  * So convert the EOB_ACT_LAST_MATCH
1618  * to EOB_ACT_END_OF_FILE.
1619  */
1620 
1621  /* Reset buffer status. */
1622  yyrestart( yyin );
1623 
1624  /*FALLTHROUGH*/
1625 
1626  case EOB_ACT_END_OF_FILE:
1627  {
1628  if ( yywrap( ) )
1629  return 0;
1630 
1631  if ( ! (yy_did_buffer_switch_on_eof) )
1632  YY_NEW_FILE;
1633 #ifdef __cplusplus
1634  return yyinput();
1635 #else
1636  return input();
1637 #endif
1638  }
1639 
1640  case EOB_ACT_CONTINUE_SCAN:
1641  (yy_c_buf_p) = (yytext_ptr) + offset;
1642  break;
1643  }
1644  }
1645  }
1646 
1647  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1648  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1649  (yy_hold_char) = *++(yy_c_buf_p);
1650 
1651  return c;
1652 }
1653 #endif /* ifndef YY_NO_INPUT */
1654 
1660  void yyrestart (FILE * input_file )
1661 {
1662 
1663  if ( ! YY_CURRENT_BUFFER ){
1667  }
1668 
1669  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1671 }
1672 
1678 {
1679 
1680  /* TODO. We should be able to replace this entire function body
1681  * with
1682  * yypop_buffer_state();
1683  * yypush_buffer_state(new_buffer);
1684  */
1686  if ( YY_CURRENT_BUFFER == new_buffer )
1687  return;
1688 
1689  if ( YY_CURRENT_BUFFER )
1690  {
1691  /* Flush out information for old buffer. */
1692  *(yy_c_buf_p) = (yy_hold_char);
1693  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1694  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1695  }
1696 
1697  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1699 
1700  /* We don't actually know whether we did this switch during
1701  * EOF (yywrap()) processing, but the only time this flag
1702  * is looked at is after yywrap() is called, so it's safe
1703  * to go ahead and always set it.
1704  */
1706 }
1707 
1708 static void yy_load_buffer_state (void)
1709 {
1710  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1711  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1712  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1713  (yy_hold_char) = *(yy_c_buf_p);
1714 }
1715 
1723 {
1724  YY_BUFFER_STATE b;
1725 
1726  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1727  if ( ! b )
1728  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1729 
1730  b->yy_buf_size = size;
1731 
1732  /* yy_ch_buf has to be 2 characters longer than the size given because
1733  * we need to put in 2 end-of-buffer characters.
1734  */
1735  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1736  if ( ! b->yy_ch_buf )
1737  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1738 
1739  b->yy_is_our_buffer = 1;
1740 
1741  yy_init_buffer( b, file );
1742 
1743  return b;
1744 }
1745 
1751 {
1752 
1753  if ( ! b )
1754  return;
1755 
1756  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1758 
1759  if ( b->yy_is_our_buffer )
1760  yyfree( (void *) b->yy_ch_buf );
1761 
1762  yyfree( (void *) b );
1763 }
1764 
1765 /* Initializes or reinitializes a buffer.
1766  * This function is sometimes called more than once on the same buffer,
1767  * such as during a yyrestart() or at EOF.
1768  */
1769  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1770 
1771 {
1772  int oerrno = errno;
1773 
1774  yy_flush_buffer( b );
1775 
1776  b->yy_input_file = file;
1777  b->yy_fill_buffer = 1;
1778 
1779  /* If b is the current buffer, then yy_init_buffer was _probably_
1780  * called from yyrestart() or through yy_get_next_buffer.
1781  * In that case, we don't want to reset the lineno or column.
1782  */
1783  if (b != YY_CURRENT_BUFFER){
1784  b->yy_bs_lineno = 1;
1785  b->yy_bs_column = 0;
1786  }
1787 
1788  b->yy_is_interactive = 0;
1789 
1790  errno = oerrno;
1791 }
1792 
1798 {
1799  if ( ! b )
1800  return;
1801 
1802  b->yy_n_chars = 0;
1803 
1804  /* We always need two end-of-buffer characters. The first causes
1805  * a transition to the end-of-buffer state. The second causes
1806  * a jam in that state.
1807  */
1810 
1811  b->yy_buf_pos = &b->yy_ch_buf[0];
1812 
1813  b->yy_at_bol = 1;
1815 
1816  if ( b == YY_CURRENT_BUFFER )
1818 }
1819 
1827 {
1828  if (new_buffer == NULL)
1829  return;
1830 
1832 
1833  /* This block is copied from yy_switch_to_buffer. */
1834  if ( YY_CURRENT_BUFFER )
1835  {
1836  /* Flush out information for old buffer. */
1837  *(yy_c_buf_p) = (yy_hold_char);
1838  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1839  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1840  }
1841 
1842  /* Only push if top exists. Otherwise, replace top. */
1843  if (YY_CURRENT_BUFFER)
1844  (yy_buffer_stack_top)++;
1845  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1846 
1847  /* copied from yy_switch_to_buffer. */
1850 }
1851 
1857 {
1858  if (!YY_CURRENT_BUFFER)
1859  return;
1860 
1862  YY_CURRENT_BUFFER_LVALUE = NULL;
1863  if ((yy_buffer_stack_top) > 0)
1864  --(yy_buffer_stack_top);
1865 
1866  if (YY_CURRENT_BUFFER) {
1869  }
1870 }
1871 
1872 /* Allocates the stack if it does not exist.
1873  * Guarantees space for at least one push.
1874  */
1875 static void yyensure_buffer_stack (void)
1876 {
1877  yy_size_t num_to_alloc;
1878 
1879  if (!(yy_buffer_stack)) {
1880 
1881  /* First allocation is just for 2 elements, since we don't know if this
1882  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1883  * immediate realloc on the next call.
1884  */
1885  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1887  (num_to_alloc * sizeof(struct yy_buffer_state*)
1888  );
1889  if ( ! (yy_buffer_stack) )
1890  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1891 
1892  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1893 
1894  (yy_buffer_stack_max) = num_to_alloc;
1895  (yy_buffer_stack_top) = 0;
1896  return;
1897  }
1898 
1899  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1900 
1901  /* Increase the buffer to prepare for a possible push. */
1902  yy_size_t grow_size = 8 /* arbitrary grow size */;
1903 
1904  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1906  ((yy_buffer_stack),
1907  num_to_alloc * sizeof(struct yy_buffer_state*)
1908  );
1909  if ( ! (yy_buffer_stack) )
1910  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1911 
1912  /* zero only the new slots.*/
1913  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1914  (yy_buffer_stack_max) = num_to_alloc;
1915  }
1916 }
1917 
1925 {
1926  YY_BUFFER_STATE b;
1927 
1928  if ( size < 2 ||
1929  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1930  base[size-1] != YY_END_OF_BUFFER_CHAR )
1931  /* They forgot to leave room for the EOB's. */
1932  return NULL;
1933 
1934  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1935  if ( ! b )
1936  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1937 
1938  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1939  b->yy_buf_pos = b->yy_ch_buf = base;
1940  b->yy_is_our_buffer = 0;
1941  b->yy_input_file = NULL;
1942  b->yy_n_chars = b->yy_buf_size;
1943  b->yy_is_interactive = 0;
1944  b->yy_at_bol = 1;
1945  b->yy_fill_buffer = 0;
1947 
1948  yy_switch_to_buffer( b );
1949 
1950  return b;
1951 }
1952 
1961 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1962 {
1963 
1964  return yy_scan_bytes( yystr, (int) strlen(yystr) );
1965 }
1966 
1974 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1975 {
1976  YY_BUFFER_STATE b;
1977  char *buf;
1978  yy_size_t n;
1979  int i;
1980 
1981  /* Get memory for full buffer, including space for trailing EOB's. */
1982  n = (yy_size_t) (_yybytes_len + 2);
1983  buf = (char *) yyalloc( n );
1984  if ( ! buf )
1985  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1986 
1987  for ( i = 0; i < _yybytes_len; ++i )
1988  buf[i] = yybytes[i];
1989 
1990  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1991 
1992  b = yy_scan_buffer( buf, n );
1993  if ( ! b )
1994  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1995 
1996  /* It's okay to grow etc. this buffer, and we should throw it
1997  * away when we're done.
1998  */
1999  b->yy_is_our_buffer = 1;
2000 
2001  return b;
2002 }
2003 
2004 #ifndef YY_EXIT_FAILURE
2005 #define YY_EXIT_FAILURE 2
2006 #endif
2007 
2008 static void yynoreturn yy_fatal_error (const char* msg )
2009 {
2010  fprintf( stderr, "%s\n", msg );
2011  exit( YY_EXIT_FAILURE );
2012 }
2013 
2014 /* Redefine yyless() so it works in section 3 code. */
2015 
2016 #undef yyless
2017 #define yyless(n) \
2018  do \
2019  { \
2020  /* Undo effects of setting up yytext. */ \
2021  int yyless_macro_arg = (n); \
2022  YY_LESS_LINENO(yyless_macro_arg);\
2023  yytext[yyleng] = (yy_hold_char); \
2024  (yy_c_buf_p) = yytext + yyless_macro_arg; \
2025  (yy_hold_char) = *(yy_c_buf_p); \
2026  *(yy_c_buf_p) = '\0'; \
2027  yyleng = yyless_macro_arg; \
2028  } \
2029  while ( 0 )
2030 
2031 /* Accessor methods (get/set functions) to struct members. */
2032 
2036 int yyget_lineno (void)
2037 {
2038 
2039  return yylineno;
2040 }
2041 
2045 FILE *yyget_in (void)
2046 {
2047  return yyin;
2048 }
2049 
2053 FILE *yyget_out (void)
2054 {
2055  return yyout;
2056 }
2057 
2061 int yyget_leng (void)
2062 {
2063  return yyleng;
2064 }
2065 
2070 char *yyget_text (void)
2071 {
2072  return yytext;
2073 }
2074 
2079 void yyset_lineno (int _line_number )
2080 {
2081 
2082  yylineno = _line_number;
2083 }
2084 
2091 void yyset_in (FILE * _in_str )
2092 {
2093  yyin = _in_str ;
2094 }
2095 
2096 void yyset_out (FILE * _out_str )
2097 {
2098  yyout = _out_str ;
2099 }
2100 
2101 int yyget_debug (void)
2102 {
2103  return yy_flex_debug;
2104 }
2105 
2106 void yyset_debug (int _bdebug )
2107 {
2108  yy_flex_debug = _bdebug ;
2109 }
2110 
2111 static int yy_init_globals (void)
2112 {
2113  /* Initialization is the same as for the non-reentrant scanner.
2114  * This function is called from yylex_destroy(), so don't allocate here.
2115  */
2116 
2117  (yy_buffer_stack) = NULL;
2118  (yy_buffer_stack_top) = 0;
2119  (yy_buffer_stack_max) = 0;
2120  (yy_c_buf_p) = NULL;
2121  (yy_init) = 0;
2122  (yy_start) = 0;
2123 
2124 /* Defined in main.c */
2125 #ifdef YY_STDINIT
2126  yyin = stdin;
2127  yyout = stdout;
2128 #else
2129  yyin = NULL;
2130  yyout = NULL;
2131 #endif
2132 
2133  /* For future reference: Set errno on error, since we are called by
2134  * yylex_init()
2135  */
2136  return 0;
2137 }
2138 
2139 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2140 int yylex_destroy (void)
2141 {
2142 
2143  /* Pop the buffer stack, destroying each element. */
2144  while(YY_CURRENT_BUFFER){
2146  YY_CURRENT_BUFFER_LVALUE = NULL;
2148  }
2149 
2150  /* Destroy the stack itself. */
2151  yyfree((yy_buffer_stack) );
2152  (yy_buffer_stack) = NULL;
2153 
2154  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2155  * yylex() is called, initialization will occur. */
2156  yy_init_globals( );
2157 
2158  return 0;
2159 }
2160 
2161 /*
2162  * Internal utility routines.
2163  */
2164 
2165 #ifndef yytext_ptr
2166 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2167 {
2168 
2169  int i;
2170  for ( i = 0; i < n; ++i )
2171  s1[i] = s2[i];
2172 }
2173 #endif
2174 
2175 #ifdef YY_NEED_STRLEN
2176 static int yy_flex_strlen (const char * s )
2177 {
2178  int n;
2179  for ( n = 0; s[n]; ++n )
2180  ;
2181 
2182  return n;
2183 }
2184 #endif
2185 
2186 void *yyalloc (yy_size_t size )
2187 {
2188  return malloc(size);
2189 }
2190 
2191 void *yyrealloc (void * ptr, yy_size_t size )
2192 {
2193 
2194  /* The cast to (char *) in the following accommodates both
2195  * implementations that use char* generic pointers, and those
2196  * that use void* generic pointers. It works with the latter
2197  * because both ANSI C and C++ allow castless assignment from
2198  * any pointer type to void*, and deal with argument conversions
2199  * as though doing an assignment.
2200  */
2201  return realloc(ptr, size);
2202 }
2203 
2204 void yyfree (void * ptr )
2205 {
2206  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2207 }
2208 
2209 #define YYTABLES_NAME "yytables"
2210 
2211 #line 87 "scanner.l"
2212 
2213 
2214 int yywrap() { return 1; }
2215 
yy_start
static int yy_start
Definition: xml_lex.yy.cpp:535
yytext
#define yytext
Definition: xml_lex.yy.cpp:28
yy_init_buffer
#define yy_init_buffer
Definition: xml_lex.yy.cpp:14
YY_BREAK
#define YY_BREAK
Definition: xml_lex.yy.cpp:1034
YYSTYPE::s
char * s
Definition: xml_y.tab.cpp:177
yy_last_accepting_cpos
static char * yy_last_accepting_cpos
Definition: xml_lex.yy.cpp:804
flex_int32_t
int flex_int32_t
Definition: ansi_c_lex.yy.cpp:312
yyget_in
#define yyget_in
Definition: xml_lex.yy.cpp:171
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: xml_lex.yy.cpp:615
yyxmlerror
int yyxmlerror(const std::string &error)
Definition: xml_y.tab.cpp:85
flex_int32_t
int flex_int32_t
Definition: xml_lex.yy.cpp:312
yy_trans_info
Definition: ansi_c_lex.yy.cpp:618
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: xml_lex.yy.cpp:2005
yy_scan_buffer
#define yy_scan_buffer
Definition: xml_lex.yy.cpp:11
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: xml_lex.yy.cpp:519
yy_get_previous_state
static yy_state_type yy_get_previous_state(void)
Definition: xml_lex.yy.cpp:1522
yy_delete_buffer
#define yy_delete_buffer
Definition: xml_lex.yy.cpp:10
yy_buffer_state::yy_input_file
FILE * yy_input_file
Definition: ansi_c_lex.yy.cpp:447
yyget_leng
#define yyget_leng
Definition: xml_lex.yy.cpp:195
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: xml_lex.yy.cpp:423
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: xml_lex.yy.cpp:962
yy_buffer_state
Definition: ansi_c_lex.yy.cpp:445
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: xml_lex.yy.cpp:409
yyget_text
#define yyget_text
Definition: xml_lex.yy.cpp:201
file
Definition: kdev_t.h:19
s1
int8_t s1
Definition: bytecode_info.h:59
EQ
#define EQ
Definition: xml_y.tab.cpp:161
yyset_out
#define yyset_out
Definition: xml_lex.yy.cpp:189
YY_DECL
#define YY_DECL
Definition: xml_lex.yy.cpp:1022
yy_buffer_stack
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition: xml_lex.yy.cpp:511
yy_switch_to_buffer
#define yy_switch_to_buffer
Definition: xml_lex.yy.cpp:17
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: xml_lex.yy.cpp:815
NAME
#define NAME
Definition: xml_y.tab.cpp:166
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: ansi_c_lex.yy.cpp:479
SLASH
#define SLASH
Definition: xml_y.tab.cpp:162
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: xml_lex.yy.cpp:946
yyset_extra
#define yyset_extra
Definition: xml_lex.yy.cpp:165
yyout
#define yyout
Definition: xml_lex.yy.cpp:26
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: ansi_c_lex.yy.cpp:466
yytext_ptr
#define yytext_ptr
Definition: xml_lex.yy.cpp:598
yyalloc
#define yyalloc
Definition: xml_lex.yy.cpp:30
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: xml_lex.yy.cpp:491
yyget_lineno
#define yyget_lineno
Definition: xml_lex.yy.cpp:207
CONTENT
#define CONTENT
Definition: xml_lex.yy.cpp:860
yy_c_buf_p
static char * yy_c_buf_p
Definition: xml_lex.yy.cpp:533
BEGIN
#define BEGIN
Definition: xml_lex.yy.cpp:377
flex_uint32_t
unsigned int flex_uint32_t
Definition: xml_lex.yy.cpp:315
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: xml_lex.yy.cpp:492
yy_ec
static const YY_CHAR yy_ec[256]
Definition: xml_lex.yy.cpp:639
yyset_debug
#define yyset_debug
Definition: xml_lex.yy.cpp:153
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: xml_lex.yy.cpp:422
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: ansi_c_lex.yy.cpp:487
YY_NEW_FILE
#define YY_NEW_FILE
Definition: xml_lex.yy.cpp:387
yy_size_t
size_t yy_size_t
Definition: xml_lex.yy.cpp:414
YY_CHAR
flex_uint8_t YY_CHAR
Definition: xml_lex.yy.cpp:585
yyget_extra
#define yyget_extra
Definition: xml_lex.yy.cpp:159
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: xml_lex.yy.cpp:371
yy_state_type
int yy_state_type
Definition: xml_lex.yy.cpp:589
yy_meta
static const YY_CHAR yy_meta[33]
Definition: xml_lex.yy.cpp:671
yy_flush_buffer
#define yy_flush_buffer
Definition: xml_lex.yy.cpp:15
flex_int16_t
short int flex_int16_t
Definition: ansi_c_lex.yy.cpp:311
yyin
#define yyin
Definition: xml_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
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: xml_lex.yy.cpp:503
STARTXMLDECL
#define STARTXMLDECL
Definition: xml_y.tab.cpp:157
yyxmllval
YYSTYPE yyxmllval
Definition: xml_y.tab.cpp:1118
yyterminate
#define yyterminate()
Definition: xml_lex.yy.cpp:999
yylex
#define yylex
Definition: xml_lex.yy.cpp:24
CLOSE
#define CLOSE
Definition: xml_y.tab.cpp:163
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: xml_lex.yy.cpp:1037
yy_buffer_stack_max
static size_t yy_buffer_stack_max
capacity of stack.
Definition: xml_lex.yy.cpp:510
yyset_in
#define yyset_in
Definition: xml_lex.yy.cpp:177
yy_last_accepting_state
static yy_state_type yy_last_accepting_state
Definition: xml_lex.yy.cpp:803
yy_init_globals
static int yy_init_globals(void)
Definition: xml_lex.yy.cpp:2111
flex_int16_t
short int flex_int16_t
Definition: xml_lex.yy.cpp:311
DTD
#define DTD
Definition: xml_lex.yy.cpp:862
yy_accept
static const flex_int16_t yy_accept[108]
Definition: xml_lex.yy.cpp:623
INITIAL
#define INITIAL
Definition: xml_lex.yy.cpp:859
yy_load_buffer_state
#define yy_load_buffer_state
Definition: xml_lex.yy.cpp:16
yyget_debug
#define yyget_debug
Definition: xml_lex.yy.cpp:147
yy_chk
static const flex_int16_t yy_chk[363]
Definition: xml_lex.yy.cpp:759
yynoreturn
#define yynoreturn
Definition: xml_lex.yy.cpp:362
flex_uint8_t
unsigned char flex_uint8_t
Definition: xml_lex.yy.cpp:313
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: xml_lex.yy.cpp:385
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: ansi_c_lex.yy.cpp:489
YY_START
#define YY_START
Definition: xml_lex.yy.cpp:382
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: ansi_c_lex.yy.cpp:450
yyrealloc
#define yyrealloc
Definition: xml_lex.yy.cpp:31
yyensure_buffer_stack
#define yyensure_buffer_stack
Definition: xml_lex.yy.cpp:20
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: xml_lex.yy.cpp:388
xml_y.tab.h
yy_buffer_stack_top
static size_t yy_buffer_stack_top
index of top of stack.
Definition: xml_lex.yy.cpp:509
yy_trans_info::yy_nxt
flex_int32_t yy_nxt
Definition: ansi_c_lex.yy.cpp:621
START
#define START
Definition: xml_y.tab.cpp:170
ENDPI
#define ENDPI
Definition: xml_y.tab.cpp:160
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: xml_lex.yy.cpp:399
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: xml_lex.yy.cpp:540
yy_nxt
static const flex_int16_t yy_nxt[363]
Definition: xml_lex.yy.cpp:715
yy_trans_info::yy_verify
flex_int32_t yy_verify
Definition: ansi_c_lex.yy.cpp:620
yy_buffer_state::yy_bs_column
int yy_bs_column
The column count.
Definition: ansi_c_lex.yy.cpp:482
yy_scan_bytes
#define yy_scan_bytes
Definition: xml_lex.yy.cpp:13
yy_buffer_state::yy_n_chars
int yy_n_chars
Definition: ansi_c_lex.yy.cpp:460
YY_CHAR
flex_uint8_t YY_CHAR
Definition: ansi_c_lex.yy.cpp:585
STARTPI
#define STARTPI
Definition: xml_y.tab.cpp:159
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: ansi_c_lex.yy.cpp:473
malloc
void * malloc(unsigned)
flex_uint16_t
unsigned short int flex_uint16_t
Definition: xml_lex.yy.cpp:314
yyfree
#define yyfree
Definition: xml_lex.yy.cpp:32
yy_fatal_error
static void yy_fatal_error(const char *msg)
Definition: xml_lex.yy.cpp:2008
DATA
#define DATA
Definition: xml_y.tab.cpp:168
COMMENT
#define COMMENT
Definition: jsil_lex.yy.cpp:1529
yy_def
static const flex_int16_t yy_def[126]
Definition: xml_lex.yy.cpp:697
yywrap
#define yywrap
Definition: xml_lex.yy.cpp:29
yy_init
static int yy_init
Definition: xml_lex.yy.cpp:534
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: xml_lex.yy.cpp:421
flex_uint8_t
unsigned char flex_uint8_t
Definition: ansi_c_lex.yy.cpp:313
yy_get_next_buffer
static int yy_get_next_buffer(void)
Definition: xml_lex.yy.cpp:1384
yy_flex_debug
#define yy_flex_debug
Definition: xml_lex.yy.cpp:21
yy_scan_string
#define yy_scan_string
Definition: xml_lex.yy.cpp:12
yyset_lineno
#define yyset_lineno
Definition: xml_lex.yy.cpp:213
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: xml_lex.yy.cpp:1009
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: xml_lex.yy.cpp:873
yypush_buffer_state
#define yypush_buffer_state
Definition: xml_lex.yy.cpp:18
word
static char * word(char *s)
Definition: xml_lex.yy.cpp:833
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: xml_lex.yy.cpp:608
yy_create_buffer
#define yy_create_buffer
Definition: xml_lex.yy.cpp:9
s2
int16_t s2
Definition: bytecode_info.h:60
yy_n_chars
static int yy_n_chars
Definition: xml_lex.yy.cpp:529
yyget_out
#define yyget_out
Definition: xml_lex.yy.cpp:183
yy_size_t
size_t yy_size_t
Definition: ansi_c_lex.yy.cpp:414
END
#define END
Definition: xml_y.tab.cpp:164
yypop_buffer_state
#define yypop_buffer_state
Definition: xml_lex.yy.cpp:19
yylineno
#define yylineno
Definition: xml_lex.yy.cpp:25
free
void free(void *)
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: xml_lex.yy.cpp:525
xml_parser.h
yyleng
#define yyleng
Definition: xml_lex.yy.cpp:23
yyrestart
#define yyrestart
Definition: xml_lex.yy.cpp:27
flex_int8_t
signed char flex_int8_t
Definition: xml_lex.yy.cpp:310
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_hold_char
static char yy_hold_char
Definition: xml_lex.yy.cpp:528
yy_base
static const flex_int16_t yy_base[126]
Definition: xml_lex.yy.cpp:679
VALUE
#define VALUE
Definition: xml_y.tab.cpp:167
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: xml_lex.yy.cpp:1554
yylex_destroy
#define yylex_destroy
Definition: xml_lex.yy.cpp:141
PI
#define PI
Definition: xml_lex.yy.cpp:861
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: xml_lex.yy.cpp:814