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