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
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 #if defined _MSC_VER
823 // signed/unsigned mismatch
824 #pragma warning(disable:4365)
825 // macro re-definition: flex conditonally defines INT32_MAX et al. and thus
826 // they are set before library headers get to define them
827 #pragma warning(disable:4005)
828 #endif
829 
830 #include <cctype>
831 #include <cstring>
832 #include <cstdlib>
833 
834 #include "xml_parser.h"
835 #include "xml_y.tab.h"
836 
837 #define PARSER xml_parser
838 
839 //static int keep; /* To store start condition */
840 
841 static char *word(char *s)
842 {
843  char *buf;
844  int i, k;
845  for (k = 0; isspace(s[k]) || s[k] == '<'; k++) ;
846  for (i = k; s[i] && ! isspace(s[i]); i++) ;
847  buf = (char *)malloc((i - k + 1) * sizeof(char));
848  strncpy(buf, &s[k], i - k);
849  buf[i - k] = '\0';
850  return buf;
851 }
852 
853 #include <util/pragma_wsign_compare.def>
854 #include <util/pragma_wnull_conversion.def>
855 #include <util/pragma_wdeprecated_register.def>
856 
857 #line 857 "xml_lex.yy.cpp"
858 /*
859  * The CONTENT mode is used for the content of elements, i.e.,
860  * between the ">" and "<" of element tags.
861  * The INITIAL mode is used outside the top level element
862  * and inside markup.
863  */
864 
865 #line 865 "xml_lex.yy.cpp"
866 
867 #define INITIAL 0
868 #define CONTENT 1
869 #define PI 2
870 #define DTD 3
871 
872 #ifndef YY_NO_UNISTD_H
873 /* Special case for "unistd.h", since it is non-ANSI. We include it way
874  * down here because we want the user's section 1 to have been scanned first.
875  * The user has a chance to override it with an option.
876  */
877 #include <unistd.h>
878 #endif
879 
880 #ifndef YY_EXTRA_TYPE
881 #define YY_EXTRA_TYPE void *
882 #endif
883 
884 static int yy_init_globals ( void );
885 
886 /* Accessor methods to globals.
887  These are made visible to non-reentrant scanners for convenience. */
888 
889 int yylex_destroy ( void );
890 
891 int yyget_debug ( void );
892 
893 void yyset_debug ( int debug_flag );
894 
896 
897 void yyset_extra ( YY_EXTRA_TYPE user_defined );
898 
899 FILE *yyget_in ( void );
900 
901 void yyset_in ( FILE * _in_str );
902 
903 FILE *yyget_out ( void );
904 
905 void yyset_out ( FILE * _out_str );
906 
907  int yyget_leng ( void );
908 
909 char *yyget_text ( void );
910 
911 int yyget_lineno ( void );
912 
913 void yyset_lineno ( int _line_number );
914 
915 /* Macros after this point can all be overridden by user definitions in
916  * section 1.
917  */
918 
919 #ifndef YY_SKIP_YYWRAP
920 #ifdef __cplusplus
921 extern "C" int yywrap ( void );
922 #else
923 extern int yywrap ( void );
924 #endif
925 #endif
926 
927 #ifndef YY_NO_UNPUT
928 
929 #endif
930 
931 #ifndef yytext_ptr
932 static void yy_flex_strncpy ( char *, const char *, int );
933 #endif
934 
935 #ifdef YY_NEED_STRLEN
936 static int yy_flex_strlen ( const char * );
937 #endif
938 
939 #ifndef YY_NO_INPUT
940 #ifdef __cplusplus
941 static int yyinput ( void );
942 #else
943 static int input ( void );
944 #endif
945 
946 #endif
947 
948 /* Amount of stuff to slurp up with each read. */
949 #ifndef YY_READ_BUF_SIZE
950 #ifdef __ia64__
951 /* On IA-64, the buffer size is 16k, not 8k */
952 #define YY_READ_BUF_SIZE 16384
953 #else
954 #define YY_READ_BUF_SIZE 8192
955 #endif /* __ia64__ */
956 #endif
957 
958 /* Copy whatever the last rule matched to the standard output. */
959 #ifndef ECHO
960 /* This used to be an fputs(), but since the string might contain NUL's,
961  * we now use fwrite().
962  */
963 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
964 #endif
965 
966 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
967  * is returned in "result".
968  */
969 #ifndef YY_INPUT
970 #define YY_INPUT(buf,result,max_size) \
971  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
972  { \
973  int c = '*'; \
974  int n; \
975  for ( n = 0; n < max_size && \
976  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
977  buf[n] = (char) c; \
978  if ( c == '\n' ) \
979  buf[n++] = (char) c; \
980  if ( c == EOF && ferror( yyin ) ) \
981  YY_FATAL_ERROR( "input in flex scanner failed" ); \
982  result = n; \
983  } \
984  else \
985  { \
986  errno=0; \
987  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
988  { \
989  if( errno != EINTR) \
990  { \
991  YY_FATAL_ERROR( "input in flex scanner failed" ); \
992  break; \
993  } \
994  errno=0; \
995  clearerr(yyin); \
996  } \
997  }\
998 \
999 
1000 #endif
1001 
1002 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1003  * we don't want an extra ';' after the "return" because that will cause
1004  * some compilers to complain about unreachable statements.
1005  */
1006 #ifndef yyterminate
1007 #define yyterminate() return YY_NULL
1008 #endif
1009 
1010 /* Number of entries by which start-condition stack grows. */
1011 #ifndef YY_START_STACK_INCR
1012 #define YY_START_STACK_INCR 25
1013 #endif
1014 
1015 /* Report a fatal error. */
1016 #ifndef YY_FATAL_ERROR
1017 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1018 #endif
1019 
1020 /* end tables serialization structures and prototypes */
1021 
1022 /* Default declaration of generated scanner - a define so the user can
1023  * easily add parameters.
1024  */
1025 #ifndef YY_DECL
1026 #define YY_DECL_IS_OURS 1
1028 extern int yylex (void);
1029 
1030 #define YY_DECL int yylex (void)
1031 #endif /* !YY_DECL */
1032 
1033 /* Code executed at the beginning of each rule, after yytext and yyleng
1034  * have been set up.
1035  */
1036 #ifndef YY_USER_ACTION
1037 #define YY_USER_ACTION
1038 #endif
1039 
1040 /* Code executed at the end of each rule. */
1041 #ifndef YY_BREAK
1042 #define YY_BREAK /*LINTED*/break;
1043 #endif
1044 
1045 #define YY_RULE_SETUP \
1046  YY_USER_ACTION
1047 
1051 {
1052  yy_state_type yy_current_state;
1053  char *yy_cp, *yy_bp;
1054  int yy_act;
1055 
1056  if ( !(yy_init) )
1057  {
1058  (yy_init) = 1;
1059 
1060 #ifdef YY_USER_INIT
1061  YY_USER_INIT;
1062 #endif
1063 
1064  if ( ! (yy_start) )
1065  (yy_start) = 1; /* first start state */
1066 
1067  if ( ! yyin )
1068  yyin = stdin;
1069 
1070  if ( ! yyout )
1071  yyout = stdout;
1072 
1073  if ( ! YY_CURRENT_BUFFER ) {
1077  }
1078 
1080  }
1081 
1082  {
1083 #line 70 "scanner.l"
1084 
1085 
1086 #line 1086 "xml_lex.yy.cpp"
1087 
1088  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1089  {
1090  yy_cp = (yy_c_buf_p);
1091 
1092  /* Support of yytext. */
1093  *yy_cp = (yy_hold_char);
1094 
1095  /* yy_bp points to the position in yy_ch_buf of the start of
1096  * the current run.
1097  */
1098  yy_bp = yy_cp;
1099 
1100  yy_current_state = (yy_start);
1101 yy_match:
1102  do
1103  {
1104  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1105  if ( yy_accept[yy_current_state] )
1106  {
1107  (yy_last_accepting_state) = yy_current_state;
1108  (yy_last_accepting_cpos) = yy_cp;
1109  }
1110  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1111  {
1112  yy_current_state = (int) yy_def[yy_current_state];
1113  if ( yy_current_state >= 108 )
1114  yy_c = yy_meta[yy_c];
1115  }
1116  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1117  ++yy_cp;
1118  }
1119  while ( yy_current_state != 107 );
1120  yy_cp = (yy_last_accepting_cpos);
1121  yy_current_state = (yy_last_accepting_state);
1122 
1123 yy_find_action:
1124  yy_act = yy_accept[yy_current_state];
1125 
1127 
1128 do_action: /* This label is used only to access EOF actions. */
1129 
1130  switch ( yy_act )
1131  { /* beginning of action switch */
1132  case 0: /* must back up */
1133  /* undo the effects of YY_DO_BEFORE_ACTION */
1134  *yy_cp = (yy_hold_char);
1135  yy_cp = (yy_last_accepting_cpos);
1136  yy_current_state = (yy_last_accepting_state);
1137  goto yy_find_action;
1138 
1139 case 1:
1140 /* rule 1 can match eol */
1142 #line 72 "scanner.l"
1143 {/* skip */}
1144  YY_BREAK
1145 case 2:
1147 #line 73 "scanner.l"
1148 {return SLASH;}
1149  YY_BREAK
1150 case 3:
1152 #line 74 "scanner.l"
1153 {return EQ;}
1154  YY_BREAK
1155 case 4:
1156 /* rule 4 can match eol */
1158 #line 75 "scanner.l"
1159 {BEGIN(CONTENT); return CLOSE;}
1160  YY_BREAK
1161 case 5:
1163 #line 76 "scanner.l"
1164 {yyxmllval.s=strdup(yytext); return NAME;}
1165  YY_BREAK
1166 case 6:
1167 /* rule 6 can match eol */
1169 #line 77 "scanner.l"
1170 {yyxmllval.s=strdup(yytext); return VALUE;}
1171  YY_BREAK
1172 case 7:
1173 /* rule 7 can match eol */
1175 #line 78 "scanner.l"
1176 {BEGIN(INITIAL); return ENDPI;}
1177  YY_BREAK
1178 case 8:
1179 /* rule 8 can match eol */
1181 #line 80 "scanner.l"
1182 {BEGIN(INITIAL); yyxmllval.s=word(yytext); return START;}
1183  YY_BREAK
1184 case 9:
1185 /* rule 9 can match eol */
1187 #line 81 "scanner.l"
1188 {BEGIN(INITIAL); return END;}
1189  YY_BREAK
1190 case 10:
1191 /* rule 10 can match eol */
1193 #line 82 "scanner.l"
1194 {BEGIN(INITIAL); return STARTXMLDECL;}
1195  YY_BREAK
1196 case 11:
1197 /* rule 11 can match eol */
1199 #line 83 "scanner.l"
1200 {BEGIN(PI); yyxmllval.s=word(yytext); return STARTPI;}
1201  YY_BREAK
1202 case 12:
1203 /* rule 12 can match eol */
1205 #line 84 "scanner.l"
1206 {yyxmllval.s=strdup(yytext); return COMMENT;}
1207  YY_BREAK
1208 case 13:
1209 /* rule 13 can match eol */
1211 #line 86 "scanner.l"
1212 {yyxmllval.s=strdup(yytext); return DATA;}
1213  YY_BREAK
1214 case 14:
1215 /* rule 14 can match eol */
1217 #line 88 "scanner.l"
1218 {BEGIN(DTD); /* skip */}
1219  YY_BREAK
1220 case 15:
1222 #line 89 "scanner.l"
1223 {/* skip */}
1224  YY_BREAK
1225 case 16:
1226 /* rule 16 can match eol */
1228 #line 90 "scanner.l"
1229 {BEGIN(INITIAL); /* skip */}
1230  YY_BREAK
1231 case 17:
1233 #line 92 "scanner.l"
1234 { yyxmlerror("unexpected character"); }
1235  YY_BREAK
1236 case 18:
1237 /* rule 18 can match eol */
1239 #line 93 "scanner.l"
1240 {/* skip, must be an extra one at EOF */;}
1241  YY_BREAK
1242 case 19:
1244 #line 95 "scanner.l"
1245 YY_FATAL_ERROR( "flex scanner jammed" );
1246  YY_BREAK
1247 #line 1247 "xml_lex.yy.cpp"
1248 case YY_STATE_EOF(INITIAL):
1249 case YY_STATE_EOF(CONTENT):
1250 case YY_STATE_EOF(PI):
1251 case YY_STATE_EOF(DTD):
1252  yyterminate();
1253 
1254  case YY_END_OF_BUFFER:
1255  {
1256  /* Amount of text matched not including the EOB char. */
1257  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1258 
1259  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1260  *yy_cp = (yy_hold_char);
1262 
1263  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1264  {
1265  /* We're scanning a new file or input source. It's
1266  * possible that this happened because the user
1267  * just pointed yyin at a new source and called
1268  * yylex(). If so, then we have to assure
1269  * consistency between YY_CURRENT_BUFFER and our
1270  * globals. Here is the right place to do so, because
1271  * this is the first action (other than possibly a
1272  * back-up) that will match for the new input source.
1273  */
1274  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1275  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1276  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1277  }
1278 
1279  /* Note that here we test for yy_c_buf_p "<=" to the position
1280  * of the first EOB in the buffer, since yy_c_buf_p will
1281  * already have been incremented past the NUL character
1282  * (since all states make transitions on EOB to the
1283  * end-of-buffer state). Contrast this with the test
1284  * in input().
1285  */
1286  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1287  { /* This was really a NUL. */
1288  yy_state_type yy_next_state;
1289 
1290  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1291 
1292  yy_current_state = yy_get_previous_state( );
1293 
1294  /* Okay, we're now positioned to make the NUL
1295  * transition. We couldn't have
1296  * yy_get_previous_state() go ahead and do it
1297  * for us because it doesn't know how to deal
1298  * with the possibility of jamming (and we don't
1299  * want to build jamming into it because then it
1300  * will run more slowly).
1301  */
1302 
1303  yy_next_state = yy_try_NUL_trans( yy_current_state );
1304 
1305  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1306 
1307  if ( yy_next_state )
1308  {
1309  /* Consume the NUL. */
1310  yy_cp = ++(yy_c_buf_p);
1311  yy_current_state = yy_next_state;
1312  goto yy_match;
1313  }
1314 
1315  else
1316  {
1317  yy_cp = (yy_last_accepting_cpos);
1318  yy_current_state = (yy_last_accepting_state);
1319  goto yy_find_action;
1320  }
1321  }
1322 
1323  else switch ( yy_get_next_buffer( ) )
1324  {
1325  case EOB_ACT_END_OF_FILE:
1326  {
1328 
1329  if ( yywrap( ) )
1330  {
1331  /* Note: because we've taken care in
1332  * yy_get_next_buffer() to have set up
1333  * yytext, we can now set up
1334  * yy_c_buf_p so that if some total
1335  * hoser (like flex itself) wants to
1336  * call the scanner after we return the
1337  * YY_NULL, it'll still work - another
1338  * YY_NULL will get returned.
1339  */
1341 
1342  yy_act = YY_STATE_EOF(YY_START);
1343  goto do_action;
1344  }
1345 
1346  else
1347  {
1348  if ( ! (yy_did_buffer_switch_on_eof) )
1349  YY_NEW_FILE;
1350  }
1351  break;
1352  }
1353 
1354  case EOB_ACT_CONTINUE_SCAN:
1355  (yy_c_buf_p) =
1356  (yytext_ptr) + yy_amount_of_matched_text;
1357 
1358  yy_current_state = yy_get_previous_state( );
1359 
1360  yy_cp = (yy_c_buf_p);
1361  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1362  goto yy_match;
1363 
1364  case EOB_ACT_LAST_MATCH:
1365  (yy_c_buf_p) =
1366  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1367 
1368  yy_current_state = yy_get_previous_state( );
1369 
1370  yy_cp = (yy_c_buf_p);
1371  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1372  goto yy_find_action;
1373  }
1374  break;
1375  }
1376 
1377  default:
1379  "fatal flex scanner internal error--no action found" );
1380  } /* end of action switch */
1381  } /* end of scanning one token */
1382  } /* end of user's declarations */
1383 } /* end of yylex */
1384 
1385 /* yy_get_next_buffer - try to read in a new buffer
1386  *
1387  * Returns a code representing an action:
1388  * EOB_ACT_LAST_MATCH -
1389  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1390  * EOB_ACT_END_OF_FILE - end of file
1391  */
1392 static int yy_get_next_buffer (void)
1393 {
1394  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1395  char *source = (yytext_ptr);
1396  int number_to_move, i;
1397  int ret_val;
1398 
1399  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1401  "fatal flex scanner internal error--end of buffer missed" );
1402 
1403  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1404  { /* Don't try to fill the buffer, so this is an EOF. */
1405  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1406  {
1407  /* We matched a single character, the EOB, so
1408  * treat this as a final EOF.
1409  */
1410  return EOB_ACT_END_OF_FILE;
1411  }
1412 
1413  else
1414  {
1415  /* We matched some text prior to the EOB, first
1416  * process it.
1417  */
1418  return EOB_ACT_LAST_MATCH;
1419  }
1420  }
1421 
1422  /* Try to read more data. */
1423 
1424  /* First move last chars to start of buffer. */
1425  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1426 
1427  for ( i = 0; i < number_to_move; ++i )
1428  *(dest++) = *(source++);
1429 
1430  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1431  /* don't do the read, it's not guaranteed to return an EOF,
1432  * just force an EOF
1433  */
1434  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1435 
1436  else
1437  {
1438  int num_to_read =
1439  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1440 
1441  while ( num_to_read <= 0 )
1442  { /* Not enough room in the buffer - grow it. */
1443 
1444  /* just a shorter name for the current buffer */
1446 
1447  int yy_c_buf_p_offset =
1448  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1449 
1450  if ( b->yy_is_our_buffer )
1451  {
1452  int new_size = b->yy_buf_size * 2;
1453 
1454  if ( new_size <= 0 )
1455  b->yy_buf_size += b->yy_buf_size / 8;
1456  else
1457  b->yy_buf_size *= 2;
1458 
1459  b->yy_ch_buf = (char *)
1460  /* Include room in for 2 EOB chars. */
1461  yyrealloc( (void *) b->yy_ch_buf,
1462  (yy_size_t) (b->yy_buf_size + 2) );
1463  }
1464  else
1465  /* Can't grow it, we don't own it. */
1466  b->yy_ch_buf = NULL;
1467 
1468  if ( ! b->yy_ch_buf )
1470  "fatal error - scanner input buffer overflow" );
1471 
1472  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1473 
1474  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1475  number_to_move - 1;
1476 
1477  }
1478 
1479  if ( num_to_read > YY_READ_BUF_SIZE )
1480  num_to_read = YY_READ_BUF_SIZE;
1481 
1482  /* Read in more data. */
1483  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1484  (yy_n_chars), num_to_read );
1485 
1486  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1487  }
1488 
1489  if ( (yy_n_chars) == 0 )
1490  {
1491  if ( number_to_move == YY_MORE_ADJ )
1492  {
1493  ret_val = EOB_ACT_END_OF_FILE;
1494  yyrestart( yyin );
1495  }
1496 
1497  else
1498  {
1499  ret_val = EOB_ACT_LAST_MATCH;
1500  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1502  }
1503  }
1504 
1505  else
1506  ret_val = EOB_ACT_CONTINUE_SCAN;
1507 
1508  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1509  /* Extend the array by 50%, plus the number we really need. */
1510  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1511  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1512  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1513  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1514  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1515  /* "- 2" to take care of EOB's */
1516  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1517  }
1518 
1519  (yy_n_chars) += number_to_move;
1522 
1523  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1524 
1525  return ret_val;
1526 }
1527 
1528 /* yy_get_previous_state - get the state just before the EOB char was reached */
1529 
1531 {
1532  yy_state_type yy_current_state;
1533  char *yy_cp;
1534 
1535  yy_current_state = (yy_start);
1536 
1537  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1538  {
1539  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1540  if ( yy_accept[yy_current_state] )
1541  {
1542  (yy_last_accepting_state) = yy_current_state;
1543  (yy_last_accepting_cpos) = yy_cp;
1544  }
1545  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1546  {
1547  yy_current_state = (int) yy_def[yy_current_state];
1548  if ( yy_current_state >= 108 )
1549  yy_c = yy_meta[yy_c];
1550  }
1551  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1552  }
1553 
1554  return yy_current_state;
1555 }
1556 
1557 /* yy_try_NUL_trans - try to make a transition on the NUL character
1558  *
1559  * synopsis
1560  * next_state = yy_try_NUL_trans( current_state );
1561  */
1562  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1563 {
1564  int yy_is_jam;
1565  char *yy_cp = (yy_c_buf_p);
1566 
1567  YY_CHAR yy_c = 1;
1568  if ( yy_accept[yy_current_state] )
1569  {
1570  (yy_last_accepting_state) = yy_current_state;
1571  (yy_last_accepting_cpos) = yy_cp;
1572  }
1573  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1574  {
1575  yy_current_state = (int) yy_def[yy_current_state];
1576  if ( yy_current_state >= 108 )
1577  yy_c = yy_meta[yy_c];
1578  }
1579  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1580  yy_is_jam = (yy_current_state == 107);
1581 
1582  return yy_is_jam ? 0 : yy_current_state;
1583 }
1584 
1585 #ifndef YY_NO_UNPUT
1586 
1587 #endif
1588 
1589 #ifndef YY_NO_INPUT
1590 #ifdef __cplusplus
1591  static int yyinput (void)
1592 #else
1593  static int input (void)
1594 #endif
1595 
1596 {
1597  int c;
1598 
1599  *(yy_c_buf_p) = (yy_hold_char);
1600 
1601  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1602  {
1603  /* yy_c_buf_p now points to the character we want to return.
1604  * If this occurs *before* the EOB characters, then it's a
1605  * valid NUL; if not, then we've hit the end of the buffer.
1606  */
1607  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1608  /* This was really a NUL. */
1609  *(yy_c_buf_p) = '\0';
1610 
1611  else
1612  { /* need more input */
1613  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1614  ++(yy_c_buf_p);
1615 
1616  switch ( yy_get_next_buffer( ) )
1617  {
1618  case EOB_ACT_LAST_MATCH:
1619  /* This happens because yy_g_n_b()
1620  * sees that we've accumulated a
1621  * token and flags that we need to
1622  * try matching the token before
1623  * proceeding. But for input(),
1624  * there's no matching to consider.
1625  * So convert the EOB_ACT_LAST_MATCH
1626  * to EOB_ACT_END_OF_FILE.
1627  */
1628 
1629  /* Reset buffer status. */
1630  yyrestart( yyin );
1631 
1632  /*FALLTHROUGH*/
1633 
1634  case EOB_ACT_END_OF_FILE:
1635  {
1636  if ( yywrap( ) )
1637  return 0;
1638 
1639  if ( ! (yy_did_buffer_switch_on_eof) )
1640  YY_NEW_FILE;
1641 #ifdef __cplusplus
1642  return yyinput();
1643 #else
1644  return input();
1645 #endif
1646  }
1647 
1648  case EOB_ACT_CONTINUE_SCAN:
1649  (yy_c_buf_p) = (yytext_ptr) + offset;
1650  break;
1651  }
1652  }
1653  }
1654 
1655  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1656  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1657  (yy_hold_char) = *++(yy_c_buf_p);
1658 
1659  return c;
1660 }
1661 #endif /* ifndef YY_NO_INPUT */
1662 
1668  void yyrestart (FILE * input_file )
1669 {
1670 
1671  if ( ! YY_CURRENT_BUFFER ){
1675  }
1676 
1677  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1679 }
1680 
1686 {
1687 
1688  /* TODO. We should be able to replace this entire function body
1689  * with
1690  * yypop_buffer_state();
1691  * yypush_buffer_state(new_buffer);
1692  */
1694  if ( YY_CURRENT_BUFFER == new_buffer )
1695  return;
1696 
1697  if ( YY_CURRENT_BUFFER )
1698  {
1699  /* Flush out information for old buffer. */
1700  *(yy_c_buf_p) = (yy_hold_char);
1701  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1702  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1703  }
1704 
1705  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1707 
1708  /* We don't actually know whether we did this switch during
1709  * EOF (yywrap()) processing, but the only time this flag
1710  * is looked at is after yywrap() is called, so it's safe
1711  * to go ahead and always set it.
1712  */
1714 }
1715 
1716 static void yy_load_buffer_state (void)
1717 {
1718  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1719  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1720  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1721  (yy_hold_char) = *(yy_c_buf_p);
1722 }
1723 
1731 {
1732  YY_BUFFER_STATE b;
1733 
1734  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1735  if ( ! b )
1736  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1737 
1738  b->yy_buf_size = size;
1739 
1740  /* yy_ch_buf has to be 2 characters longer than the size given because
1741  * we need to put in 2 end-of-buffer characters.
1742  */
1743  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1744  if ( ! b->yy_ch_buf )
1745  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1746 
1747  b->yy_is_our_buffer = 1;
1748 
1749  yy_init_buffer( b, file );
1750 
1751  return b;
1752 }
1753 
1759 {
1760 
1761  if ( ! b )
1762  return;
1763 
1764  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1766 
1767  if ( b->yy_is_our_buffer )
1768  yyfree( (void *) b->yy_ch_buf );
1769 
1770  yyfree( (void *) b );
1771 }
1772 
1773 /* Initializes or reinitializes a buffer.
1774  * This function is sometimes called more than once on the same buffer,
1775  * such as during a yyrestart() or at EOF.
1776  */
1777  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1778 
1779 {
1780  int oerrno = errno;
1781 
1782  yy_flush_buffer( b );
1783 
1784  b->yy_input_file = file;
1785  b->yy_fill_buffer = 1;
1786 
1787  /* If b is the current buffer, then yy_init_buffer was _probably_
1788  * called from yyrestart() or through yy_get_next_buffer.
1789  * In that case, we don't want to reset the lineno or column.
1790  */
1791  if (b != YY_CURRENT_BUFFER){
1792  b->yy_bs_lineno = 1;
1793  b->yy_bs_column = 0;
1794  }
1795 
1796  b->yy_is_interactive = 0;
1797 
1798  errno = oerrno;
1799 }
1800 
1806 {
1807  if ( ! b )
1808  return;
1809 
1810  b->yy_n_chars = 0;
1811 
1812  /* We always need two end-of-buffer characters. The first causes
1813  * a transition to the end-of-buffer state. The second causes
1814  * a jam in that state.
1815  */
1818 
1819  b->yy_buf_pos = &b->yy_ch_buf[0];
1820 
1821  b->yy_at_bol = 1;
1823 
1824  if ( b == YY_CURRENT_BUFFER )
1826 }
1827 
1835 {
1836  if (new_buffer == NULL)
1837  return;
1838 
1840 
1841  /* This block is copied from yy_switch_to_buffer. */
1842  if ( YY_CURRENT_BUFFER )
1843  {
1844  /* Flush out information for old buffer. */
1845  *(yy_c_buf_p) = (yy_hold_char);
1846  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1847  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1848  }
1849 
1850  /* Only push if top exists. Otherwise, replace top. */
1851  if (YY_CURRENT_BUFFER)
1852  (yy_buffer_stack_top)++;
1853  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1854 
1855  /* copied from yy_switch_to_buffer. */
1858 }
1859 
1865 {
1866  if (!YY_CURRENT_BUFFER)
1867  return;
1868 
1870  YY_CURRENT_BUFFER_LVALUE = NULL;
1871  if ((yy_buffer_stack_top) > 0)
1872  --(yy_buffer_stack_top);
1873 
1874  if (YY_CURRENT_BUFFER) {
1877  }
1878 }
1879 
1880 /* Allocates the stack if it does not exist.
1881  * Guarantees space for at least one push.
1882  */
1883 static void yyensure_buffer_stack (void)
1884 {
1885  yy_size_t num_to_alloc;
1886 
1887  if (!(yy_buffer_stack)) {
1888 
1889  /* First allocation is just for 2 elements, since we don't know if this
1890  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1891  * immediate realloc on the next call.
1892  */
1893  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1895  (num_to_alloc * sizeof(struct yy_buffer_state*)
1896  );
1897  if ( ! (yy_buffer_stack) )
1898  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1899 
1900  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1901 
1902  (yy_buffer_stack_max) = num_to_alloc;
1903  (yy_buffer_stack_top) = 0;
1904  return;
1905  }
1906 
1907  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1908 
1909  /* Increase the buffer to prepare for a possible push. */
1910  yy_size_t grow_size = 8 /* arbitrary grow size */;
1911 
1912  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1914  ((yy_buffer_stack),
1915  num_to_alloc * sizeof(struct yy_buffer_state*)
1916  );
1917  if ( ! (yy_buffer_stack) )
1918  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1919 
1920  /* zero only the new slots.*/
1921  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1922  (yy_buffer_stack_max) = num_to_alloc;
1923  }
1924 }
1925 
1933 {
1934  YY_BUFFER_STATE b;
1935 
1936  if ( size < 2 ||
1937  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1938  base[size-1] != YY_END_OF_BUFFER_CHAR )
1939  /* They forgot to leave room for the EOB's. */
1940  return NULL;
1941 
1942  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1943  if ( ! b )
1944  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1945 
1946  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1947  b->yy_buf_pos = b->yy_ch_buf = base;
1948  b->yy_is_our_buffer = 0;
1949  b->yy_input_file = NULL;
1950  b->yy_n_chars = b->yy_buf_size;
1951  b->yy_is_interactive = 0;
1952  b->yy_at_bol = 1;
1953  b->yy_fill_buffer = 0;
1955 
1956  yy_switch_to_buffer( b );
1957 
1958  return b;
1959 }
1960 
1969 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1970 {
1971 
1972  return yy_scan_bytes( yystr, (int) strlen(yystr) );
1973 }
1974 
1982 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1983 {
1984  YY_BUFFER_STATE b;
1985  char *buf;
1986  yy_size_t n;
1987  int i;
1988 
1989  /* Get memory for full buffer, including space for trailing EOB's. */
1990  n = (yy_size_t) (_yybytes_len + 2);
1991  buf = (char *) yyalloc( n );
1992  if ( ! buf )
1993  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1994 
1995  for ( i = 0; i < _yybytes_len; ++i )
1996  buf[i] = yybytes[i];
1997 
1998  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1999 
2000  b = yy_scan_buffer( buf, n );
2001  if ( ! b )
2002  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2003 
2004  /* It's okay to grow etc. this buffer, and we should throw it
2005  * away when we're done.
2006  */
2007  b->yy_is_our_buffer = 1;
2008 
2009  return b;
2010 }
2011 
2012 #ifndef YY_EXIT_FAILURE
2013 #define YY_EXIT_FAILURE 2
2014 #endif
2015 
2016 static void yynoreturn yy_fatal_error (const char* msg )
2017 {
2018  fprintf( stderr, "%s\n", msg );
2019  exit( YY_EXIT_FAILURE );
2020 }
2021 
2022 /* Redefine yyless() so it works in section 3 code. */
2023 
2024 #undef yyless
2025 #define yyless(n) \
2026  do \
2027  { \
2028  /* Undo effects of setting up yytext. */ \
2029  int yyless_macro_arg = (n); \
2030  YY_LESS_LINENO(yyless_macro_arg);\
2031  yytext[yyleng] = (yy_hold_char); \
2032  (yy_c_buf_p) = yytext + yyless_macro_arg; \
2033  (yy_hold_char) = *(yy_c_buf_p); \
2034  *(yy_c_buf_p) = '\0'; \
2035  yyleng = yyless_macro_arg; \
2036  } \
2037  while ( 0 )
2038 
2039 /* Accessor methods (get/set functions) to struct members. */
2040 
2044 int yyget_lineno (void)
2045 {
2046 
2047  return yylineno;
2048 }
2049 
2053 FILE *yyget_in (void)
2054 {
2055  return yyin;
2056 }
2057 
2061 FILE *yyget_out (void)
2062 {
2063  return yyout;
2064 }
2065 
2069 int yyget_leng (void)
2070 {
2071  return yyleng;
2072 }
2073 
2078 char *yyget_text (void)
2079 {
2080  return yytext;
2081 }
2082 
2087 void yyset_lineno (int _line_number )
2088 {
2089 
2090  yylineno = _line_number;
2091 }
2092 
2099 void yyset_in (FILE * _in_str )
2100 {
2101  yyin = _in_str ;
2102 }
2103 
2104 void yyset_out (FILE * _out_str )
2105 {
2106  yyout = _out_str ;
2107 }
2108 
2109 int yyget_debug (void)
2110 {
2111  return yy_flex_debug;
2112 }
2113 
2114 void yyset_debug (int _bdebug )
2115 {
2116  yy_flex_debug = _bdebug ;
2117 }
2118 
2119 static int yy_init_globals (void)
2120 {
2121  /* Initialization is the same as for the non-reentrant scanner.
2122  * This function is called from yylex_destroy(), so don't allocate here.
2123  */
2124 
2125  (yy_buffer_stack) = NULL;
2126  (yy_buffer_stack_top) = 0;
2127  (yy_buffer_stack_max) = 0;
2128  (yy_c_buf_p) = NULL;
2129  (yy_init) = 0;
2130  (yy_start) = 0;
2131 
2132 /* Defined in main.c */
2133 #ifdef YY_STDINIT
2134  yyin = stdin;
2135  yyout = stdout;
2136 #else
2137  yyin = NULL;
2138  yyout = NULL;
2139 #endif
2140 
2141  /* For future reference: Set errno on error, since we are called by
2142  * yylex_init()
2143  */
2144  return 0;
2145 }
2146 
2147 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2148 int yylex_destroy (void)
2149 {
2150 
2151  /* Pop the buffer stack, destroying each element. */
2152  while(YY_CURRENT_BUFFER){
2154  YY_CURRENT_BUFFER_LVALUE = NULL;
2156  }
2157 
2158  /* Destroy the stack itself. */
2159  yyfree((yy_buffer_stack) );
2160  (yy_buffer_stack) = NULL;
2161 
2162  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2163  * yylex() is called, initialization will occur. */
2164  yy_init_globals( );
2165 
2166  return 0;
2167 }
2168 
2169 /*
2170  * Internal utility routines.
2171  */
2172 
2173 #ifndef yytext_ptr
2174 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2175 {
2176 
2177  int i;
2178  for ( i = 0; i < n; ++i )
2179  s1[i] = s2[i];
2180 }
2181 #endif
2182 
2183 #ifdef YY_NEED_STRLEN
2184 static int yy_flex_strlen (const char * s )
2185 {
2186  int n;
2187  for ( n = 0; s[n]; ++n )
2188  ;
2189 
2190  return n;
2191 }
2192 #endif
2193 
2194 void *yyalloc (yy_size_t size )
2195 {
2196  return malloc(size);
2197 }
2198 
2199 void *yyrealloc (void * ptr, yy_size_t size )
2200 {
2201 
2202  /* The cast to (char *) in the following accommodates both
2203  * implementations that use char* generic pointers, and those
2204  * that use void* generic pointers. It works with the latter
2205  * because both ANSI C and C++ allow castless assignment from
2206  * any pointer type to void*, and deal with argument conversions
2207  * as though doing an assignment.
2208  */
2209  return realloc(ptr, size);
2210 }
2211 
2212 void yyfree (void * ptr )
2213 {
2214  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2215 }
2216 
2217 #define YYTABLES_NAME "yytables"
2219 #line 95 "scanner.l"
2220 
2221 
2222 int yywrap() { return 1; }
2223 
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:1042
YYSTYPE::s
char * s
Definition: xml_y.tab.cpp:172
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:86
flex_int32_t
int flex_int32_t
Definition: xml_lex.yy.cpp:312
yy_trans_info
Definition: ansi_c_lex.yy.cpp:619
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: xml_lex.yy.cpp:2013
STARTXMLDECL
@ STARTXMLDECL
Definition: xml_y.tab.cpp:149
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:1530
yy_delete_buffer
#define yy_delete_buffer
Definition: xml_lex.yy.cpp:10
EQ
@ EQ
Definition: xml_y.tab.cpp:153
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:970
yy_buffer_state
Definition: ansi_c_lex.yy.cpp:446
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
SLASH
@ SLASH
Definition: xml_y.tab.cpp:154
s1
int8_t s1
Definition: bytecode_info.h:59
yyset_out
#define yyset_out
Definition: xml_lex.yy.cpp:189
YY_DECL
#define YY_DECL
Definition: xml_lex.yy.cpp:1030
yy_buffer_stack
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition: xml_lex.yy.cpp:511
CLOSE
@ CLOSE
Definition: xml_y.tab.cpp:155
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
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: ansi_c_lex.yy.cpp:479
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: xml_lex.yy.cpp:954
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
STARTPI
@ STARTPI
Definition: xml_y.tab.cpp:151
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
VALUE
@ VALUE
Definition: xml_y.tab.cpp:159
CONTENT
#define CONTENT
Definition: xml_lex.yy.cpp:868
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
DATA
@ DATA
Definition: xml_y.tab.cpp:160
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
yyxmllval
YYSTYPE yyxmllval
Definition: xml_y.tab.cpp:944
START
@ START
Definition: xml_y.tab.cpp:162
yyterminate
#define yyterminate()
Definition: xml_lex.yy.cpp:1007
yylex
#define yylex
Definition: xml_lex.yy.cpp:24
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: xml_lex.yy.cpp:1045
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:2119
flex_int16_t
short int flex_int16_t
Definition: xml_lex.yy.cpp:311
DTD
#define DTD
Definition: xml_lex.yy.cpp:870
yy_accept
static const flex_int16_t yy_accept[108]
Definition: xml_lex.yy.cpp:623
INITIAL
#define INITIAL
Definition: xml_lex.yy.cpp:867
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
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
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:2016
COMMENT
#define COMMENT
Definition: jsil_lex.yy.cpp:1537
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:1392
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
ENDPI
@ ENDPI
Definition: xml_y.tab.cpp:152
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: xml_lex.yy.cpp:1017
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: xml_lex.yy.cpp:881
END
@ END
Definition: xml_y.tab.cpp:156
yypush_buffer_state
#define yypush_buffer_state
Definition: xml_lex.yy.cpp:18
word
static char * word(char *s)
Definition: xml_lex.yy.cpp:841
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
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
NAME
@ NAME
Definition: xml_y.tab.cpp:158
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
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: xml_lex.yy.cpp:1562
yylex_destroy
#define yylex_destroy
Definition: xml_lex.yy.cpp:141
PI
#define PI
Definition: xml_lex.yy.cpp:869
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: xml_lex.yy.cpp:814