Line data Source code
1 :
2 : #define YY_INT_ALIGNED short int
3 :
4 : /* A lexical scanner generated by flex */
5 :
6 : #define FLEX_SCANNER
7 : #define YY_FLEX_MAJOR_VERSION 2
8 : #define YY_FLEX_MINOR_VERSION 6
9 : #define YY_FLEX_SUBMINOR_VERSION 4
10 : #if YY_FLEX_SUBMINOR_VERSION > 0
11 : #define FLEX_BETA
12 : #endif
13 :
14 : /* First, we deal with platform-specific or compiler-specific issues. */
15 :
16 : /* begin standard C headers. */
17 : #include <stdio.h>
18 : #include <string.h>
19 : #include <errno.h>
20 : #include <stdlib.h>
21 :
22 : /* end standard C headers. */
23 :
24 : /* flex integer type definitions */
25 :
26 : #ifndef FLEXINT_H
27 : #define FLEXINT_H
28 :
29 : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
30 :
31 : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
32 :
33 : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
34 : * if you want the limit (max/min) macros for int types.
35 : */
36 : #ifndef __STDC_LIMIT_MACROS
37 : #define __STDC_LIMIT_MACROS 1
38 : #endif
39 :
40 : #include <inttypes.h>
41 : typedef int8_t flex_int8_t;
42 : typedef uint8_t flex_uint8_t;
43 : typedef int16_t flex_int16_t;
44 : typedef uint16_t flex_uint16_t;
45 : typedef int32_t flex_int32_t;
46 : typedef uint32_t flex_uint32_t;
47 : #else
48 : typedef signed char flex_int8_t;
49 : typedef short int flex_int16_t;
50 : typedef int flex_int32_t;
51 : typedef unsigned char flex_uint8_t;
52 : typedef unsigned short int flex_uint16_t;
53 : typedef unsigned int flex_uint32_t;
54 :
55 : /* Limits of integral types. */
56 : #ifndef INT8_MIN
57 : #define INT8_MIN (-128)
58 : #endif
59 : #ifndef INT16_MIN
60 : #define INT16_MIN (-32767-1)
61 : #endif
62 : #ifndef INT32_MIN
63 : #define INT32_MIN (-2147483647-1)
64 : #endif
65 : #ifndef INT8_MAX
66 : #define INT8_MAX (127)
67 : #endif
68 : #ifndef INT16_MAX
69 : #define INT16_MAX (32767)
70 : #endif
71 : #ifndef INT32_MAX
72 : #define INT32_MAX (2147483647)
73 : #endif
74 : #ifndef UINT8_MAX
75 : #define UINT8_MAX (255U)
76 : #endif
77 : #ifndef UINT16_MAX
78 : #define UINT16_MAX (65535U)
79 : #endif
80 : #ifndef UINT32_MAX
81 : #define UINT32_MAX (4294967295U)
82 : #endif
83 :
84 : #ifndef SIZE_MAX
85 : #define SIZE_MAX (~(size_t)0)
86 : #endif
87 :
88 : #endif /* ! C99 */
89 :
90 : #endif /* ! FLEXINT_H */
91 :
92 : /* begin standard C++ headers. */
93 :
94 : /* TODO: this is always defined, so inline it */
95 : #define yyconst const
96 :
97 : #if defined(__GNUC__) && __GNUC__ >= 3
98 : #define yynoreturn __attribute__((__noreturn__))
99 : #else
100 : #define yynoreturn
101 : #endif
102 :
103 : /* Returned upon end-of-file. */
104 : #define YY_NULL 0
105 :
106 : /* Promotes a possibly negative, possibly signed char to an
107 : * integer in range [0..255] for use as an array index.
108 : */
109 : #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
110 :
111 : /* Enter a start condition. This macro really ought to take a parameter,
112 : * but we do it the disgusting crufty way forced on us by the ()-less
113 : * definition of BEGIN.
114 : */
115 : #define BEGIN (yy_start) = 1 + 2 *
116 : /* Translate the current start state into a value that can be later handed
117 : * to BEGIN to return to the state. The YYSTATE alias is for lex
118 : * compatibility.
119 : */
120 : #define YY_START (((yy_start) - 1) / 2)
121 : #define YYSTATE YY_START
122 : /* Action number for EOF rule of a given start state. */
123 : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
124 : /* Special action meaning "start processing a new file". */
125 : #define YY_NEW_FILE yyrestart( yyin )
126 : #define YY_END_OF_BUFFER_CHAR 0
127 :
128 : /* Size of default input buffer. */
129 : #ifndef YY_BUF_SIZE
130 : #ifdef __ia64__
131 : /* On IA-64, the buffer size is 16k, not 8k.
132 : * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
133 : * Ditto for the __ia64__ case accordingly.
134 : */
135 : #define YY_BUF_SIZE 32768
136 : #else
137 : #define YY_BUF_SIZE 16384
138 : #endif /* __ia64__ */
139 : #endif
140 :
141 : /* The state buf must be large enough to hold one state per character in the main buffer.
142 : */
143 : #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
144 :
145 : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
146 : #define YY_TYPEDEF_YY_BUFFER_STATE
147 : typedef struct yy_buffer_state *YY_BUFFER_STATE;
148 : #endif
149 :
150 : #ifndef YY_TYPEDEF_YY_SIZE_T
151 : #define YY_TYPEDEF_YY_SIZE_T
152 : typedef size_t yy_size_t;
153 : #endif
154 :
155 : extern int yyleng;
156 :
157 : extern FILE *yyin, *yyout;
158 :
159 : #define EOB_ACT_CONTINUE_SCAN 0
160 : #define EOB_ACT_END_OF_FILE 1
161 : #define EOB_ACT_LAST_MATCH 2
162 :
163 : #define YY_LESS_LINENO(n)
164 : #define YY_LINENO_REWIND_TO(ptr)
165 :
166 : /* Return all but the first "n" matched characters back to the input stream. */
167 : #define yyless(n) \
168 : do \
169 : { \
170 : /* Undo effects of setting up yytext. */ \
171 : int yyless_macro_arg = (n); \
172 : YY_LESS_LINENO(yyless_macro_arg);\
173 : *yy_cp = (yy_hold_char); \
174 : YY_RESTORE_YY_MORE_OFFSET \
175 : (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
176 : YY_DO_BEFORE_ACTION; /* set up yytext again */ \
177 : } \
178 : while ( 0 )
179 : #define unput(c) yyunput( c, (yytext_ptr) )
180 :
181 : #ifndef YY_STRUCT_YY_BUFFER_STATE
182 : #define YY_STRUCT_YY_BUFFER_STATE
183 : struct yy_buffer_state
184 : {
185 : FILE *yy_input_file;
186 :
187 : char *yy_ch_buf; /* input buffer */
188 : char *yy_buf_pos; /* current position in input buffer */
189 :
190 : /* Size of input buffer in bytes, not including room for EOB
191 : * characters.
192 : */
193 : int yy_buf_size;
194 :
195 : /* Number of characters read into yy_ch_buf, not including EOB
196 : * characters.
197 : */
198 : int yy_n_chars;
199 :
200 : /* Whether we "own" the buffer - i.e., we know we created it,
201 : * and can realloc() it to grow it, and should free() it to
202 : * delete it.
203 : */
204 : int yy_is_our_buffer;
205 :
206 : /* Whether this is an "interactive" input source; if so, and
207 : * if we're using stdio for input, then we want to use getc()
208 : * instead of fread(), to make sure we stop fetching input after
209 : * each newline.
210 : */
211 : int yy_is_interactive;
212 :
213 : /* Whether we're considered to be at the beginning of a line.
214 : * If so, '^' rules will be active on the next match, otherwise
215 : * not.
216 : */
217 : int yy_at_bol;
218 :
219 : int yy_bs_lineno; /**< The line count. */
220 : int yy_bs_column; /**< The column count. */
221 :
222 : /* Whether to try to fill the input buffer when we reach the
223 : * end of it.
224 : */
225 : int yy_fill_buffer;
226 :
227 : int yy_buffer_status;
228 :
229 : #define YY_BUFFER_NEW 0
230 : #define YY_BUFFER_NORMAL 1
231 : /* When an EOF's been seen but there's still some text to process
232 : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
233 : * shouldn't try reading from the input source any more. We might
234 : * still have a bunch of tokens to match, though, because of
235 : * possible backing-up.
236 : *
237 : * When we actually see the EOF, we change the status to "new"
238 : * (via yyrestart()), so that the user can continue scanning by
239 : * just pointing yyin at a new input file.
240 : */
241 : #define YY_BUFFER_EOF_PENDING 2
242 :
243 : };
244 : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
245 :
246 : /* Stack of input buffers. */
247 : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
248 : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
249 : static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
250 :
251 : /* We provide macros for accessing buffer states in case in the
252 : * future we want to put the buffer states in a more general
253 : * "scanner state".
254 : *
255 : * Returns the top of the stack, or NULL.
256 : */
257 : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
258 : ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
259 : : NULL)
260 : /* Same as previous macro, but useful when we know that the buffer stack is not
261 : * NULL or when we need an lvalue. For internal use only.
262 : */
263 : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
264 :
265 : /* yy_hold_char holds the character lost when yytext is formed. */
266 : static char yy_hold_char;
267 : static int yy_n_chars; /* number of characters read into yy_ch_buf */
268 : int yyleng;
269 :
270 : /* Points to current character in buffer. */
271 : static char *yy_c_buf_p = NULL;
272 : static int yy_init = 0; /* whether we need to initialize */
273 : static int yy_start = 0; /* start state number */
274 :
275 : /* Flag which is used to allow yywrap()'s to do buffer switches
276 : * instead of setting up a fresh yyin. A bit of a hack ...
277 : */
278 : static int yy_did_buffer_switch_on_eof;
279 :
280 : void yyrestart ( FILE *input_file );
281 : void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
282 : YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
283 : void yy_delete_buffer ( YY_BUFFER_STATE b );
284 : void yy_flush_buffer ( YY_BUFFER_STATE b );
285 : void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
286 : void yypop_buffer_state ( void );
287 :
288 : static void yyensure_buffer_stack ( void );
289 : static void yy_load_buffer_state ( void );
290 : static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
291 : #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
292 :
293 : YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
294 : YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
295 : YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
296 :
297 : void *yyalloc ( yy_size_t );
298 : void *yyrealloc ( void *, yy_size_t );
299 : void yyfree ( void * );
300 :
301 : #define yy_new_buffer yy_create_buffer
302 : #define yy_set_interactive(is_interactive) \
303 : { \
304 : if ( ! YY_CURRENT_BUFFER ){ \
305 : yyensure_buffer_stack (); \
306 : YY_CURRENT_BUFFER_LVALUE = \
307 : yy_create_buffer( yyin, YY_BUF_SIZE ); \
308 : } \
309 : YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
310 : }
311 : #define yy_set_bol(at_bol) \
312 : { \
313 : if ( ! YY_CURRENT_BUFFER ){\
314 : yyensure_buffer_stack (); \
315 : YY_CURRENT_BUFFER_LVALUE = \
316 : yy_create_buffer( yyin, YY_BUF_SIZE ); \
317 : } \
318 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
319 : }
320 : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
321 :
322 : /* Begin user sect3 */
323 : typedef flex_uint8_t YY_CHAR;
324 :
325 : FILE *yyin = NULL, *yyout = NULL;
326 :
327 : typedef int yy_state_type;
328 :
329 : extern int yylineno;
330 : int yylineno = 1;
331 :
332 : extern char *yytext;
333 : #ifdef yytext_ptr
334 : #undef yytext_ptr
335 : #endif
336 : #define yytext_ptr yytext
337 :
338 : static yy_state_type yy_get_previous_state ( void );
339 : static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
340 : static int yy_get_next_buffer ( void );
341 : static void yynoreturn yy_fatal_error ( const char* msg );
342 :
343 : /* Done after the current pattern has been matched and before the
344 : * corresponding action - sets up yytext.
345 : */
346 : #define YY_DO_BEFORE_ACTION \
347 : (yytext_ptr) = yy_bp; \
348 : yyleng = (int) (yy_cp - yy_bp); \
349 : (yy_hold_char) = *yy_cp; \
350 : *yy_cp = '\0'; \
351 : (yy_c_buf_p) = yy_cp;
352 : #define YY_NUM_RULES 101
353 : #define YY_END_OF_BUFFER 102
354 : /* This struct is not used in this scanner,
355 : but its presence is necessary. */
356 : struct yy_trans_info
357 : {
358 : flex_int32_t yy_verify;
359 : flex_int32_t yy_nxt;
360 : };
361 : static const flex_int16_t yy_accept[574] =
362 : { 0,
363 : 0, 0, 102, 100, 96, 97, 91, 84, 81, 81,
364 : 85, 100, 92, 92, 86, 87, 94, 94, 94, 94,
365 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
366 : 94, 94, 94, 94, 94, 82, 83, 93, 95, 89,
367 : 92, 92, 99, 90, 0, 0, 94, 94, 94, 94,
368 : 94, 94, 94, 94, 94, 10, 94, 94, 94, 94,
369 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
370 : 94, 94, 94, 94, 94, 94, 94, 94, 51, 94,
371 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
372 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
373 :
374 : 94, 93, 95, 98, 92, 88, 94, 3, 94, 94,
375 : 94, 7, 94, 94, 94, 94, 94, 94, 94, 94,
376 : 94, 94, 22, 94, 94, 94, 94, 94, 94, 94,
377 : 94, 94, 94, 94, 94, 94, 94, 94, 44, 45,
378 : 94, 94, 94, 94, 94, 94, 94, 55, 94, 94,
379 : 94, 94, 94, 94, 94, 63, 94, 94, 94, 94,
380 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
381 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
382 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
383 : 94, 94, 94, 94, 30, 94, 94, 94, 94, 94,
384 :
385 : 94, 94, 94, 94, 94, 94, 47, 94, 94, 94,
386 : 94, 94, 94, 94, 94, 94, 94, 60, 94, 94,
387 : 64, 94, 94, 94, 68, 69, 94, 94, 94, 94,
388 : 94, 94, 94, 94, 94, 94, 80, 94, 94, 94,
389 : 94, 6, 94, 94, 94, 94, 13, 94, 94, 94,
390 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
391 : 29, 94, 94, 94, 94, 94, 94, 94, 94, 94,
392 : 94, 94, 94, 94, 94, 50, 94, 94, 94, 94,
393 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
394 : 72, 94, 94, 94, 94, 94, 94, 94, 1, 94,
395 :
396 : 94, 94, 94, 94, 94, 12, 94, 94, 94, 94,
397 : 94, 94, 94, 94, 24, 94, 94, 94, 94, 94,
398 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
399 : 94, 94, 94, 49, 94, 94, 94, 94, 94, 94,
400 : 94, 94, 94, 65, 66, 94, 94, 94, 73, 94,
401 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 9,
402 : 94, 94, 94, 94, 18, 94, 94, 21, 94, 94,
403 : 26, 94, 94, 94, 94, 94, 94, 94, 37, 38,
404 : 94, 94, 41, 94, 94, 94, 94, 94, 94, 54,
405 : 94, 57, 58, 94, 94, 94, 94, 94, 94, 94,
406 :
407 : 75, 94, 94, 94, 94, 94, 94, 94, 94, 94,
408 : 94, 94, 94, 94, 20, 94, 25, 94, 28, 94,
409 : 94, 94, 94, 94, 36, 39, 40, 94, 94, 94,
410 : 94, 52, 94, 94, 94, 94, 62, 94, 94, 94,
411 : 94, 94, 94, 94, 94, 94, 94, 5, 8, 11,
412 : 14, 94, 94, 94, 94, 94, 94, 94, 94, 34,
413 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 67,
414 : 94, 94, 74, 94, 94, 94, 94, 94, 94, 15,
415 : 94, 17, 94, 23, 94, 94, 94, 94, 35, 94,
416 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 76,
417 :
418 : 94, 94, 94, 94, 4, 16, 19, 94, 94, 94,
419 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
420 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 42,
421 : 43, 94, 94, 94, 94, 94, 61, 94, 94, 94,
422 : 94, 94, 94, 27, 31, 94, 33, 94, 48, 94,
423 : 56, 94, 94, 71, 94, 94, 79, 94, 94, 46,
424 : 94, 94, 94, 94, 78, 2, 32, 94, 59, 70,
425 : 77, 53, 0
426 : } ;
427 :
428 : static const YY_CHAR yy_ec[256] =
429 : { 0,
430 : 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
431 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
432 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
433 : 1, 2, 1, 4, 1, 1, 1, 5, 1, 6,
434 : 6, 7, 1, 6, 8, 9, 10, 11, 12, 13,
435 : 13, 14, 15, 16, 13, 17, 13, 18, 6, 1,
436 : 19, 1, 1, 20, 21, 22, 23, 24, 25, 26,
437 : 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
438 : 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
439 : 47, 1, 48, 1, 49, 1, 50, 51, 52, 53,
440 :
441 : 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
442 : 64, 65, 60, 66, 67, 68, 69, 70, 60, 71,
443 : 60, 72, 6, 6, 6, 1, 1, 1, 1, 1,
444 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
450 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
451 :
452 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
453 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
454 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
455 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
456 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
457 : 1, 1, 1, 1, 1
458 : } ;
459 :
460 : static const YY_CHAR yy_meta[73] =
461 : { 0,
462 : 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
463 : 3, 3, 3, 3, 3, 3, 3, 1, 1, 1,
464 : 3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
465 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
466 : 2, 2, 2, 2, 2, 2, 1, 1, 4, 5,
467 : 5, 5, 5, 5, 5, 4, 4, 4, 4, 4,
468 : 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
469 : 4, 4
470 : } ;
471 :
472 : static const flex_int16_t yy_base[578] =
473 : { 0,
474 : 0, 0, 648, 649, 649, 649, 649, 649, 649, 65,
475 : 638, 639, 72, 79, 627, 649, 75, 73, 77, 619,
476 : 66, 82, 47, 0, 93, 94, 78, 99, 107, 618,
477 : 104, 120, 90, 584, 612, 649, 649, 0, 0, 649,
478 : 155, 164, 631, 649, 0, 620, 0, 599, 605, 600,
479 : 595, 607, 593, 596, 596, 0, 113, 609, 41, 603,
480 : 606, 114, 123, 595, 591, 562, 574, 608, 597, 585,
481 : 117, 585, 575, 584, 585, 554, 585, 574, 0, 573,
482 : 553, 571, 568, 568, 135, 550, 130, 145, 561, 568,
483 : 571, 592, 576, 561, 565, 539, 570, 160, 540, 131,
484 :
485 : 557, 0, 0, 649, 0, 649, 162, 0, 564, 560,
486 : 565, 0, 554, 560, 553, 561, 550, 552, 149, 170,
487 : 562, 551, 0, 552, 559, 158, 558, 543, 548, 526,
488 : 514, 539, 543, 160, 544, 535, 549, 557, 0, 531,
489 : 539, 516, 544, 543, 538, 512, 525, 0, 525, 524,
490 : 520, 498, 528, 538, 517, 0, 532, 527, 515, 515,
491 : 514, 527, 526, 496, 159, 509, 531, 477, 492, 487,
492 : 516, 509, 504, 512, 507, 505, 470, 512, 515, 512,
493 : 495, 498, 492, 510, 489, 495, 504, 503, 501, 489,
494 : 495, 485, 166, 497, 0, 455, 463, 451, 478, 488,
495 :
496 : 478, 474, 493, 170, 499, 473, 0, 445, 487, 469,
497 : 473, 455, 481, 497, 479, 482, 434, 0, 461, 475,
498 : 0, 465, 477, 429, 0, 0, 488, 427, 460, 452,
499 : 467, 433, 451, 435, 424, 436, 0, 446, 464, 461,
500 : 462, 0, 416, 460, 457, 454, 0, 444, 439, 447,
501 : 443, 445, 449, 447, 433, 430, 446, 428, 428, 432,
502 : 0, 415, 406, 397, 433, 129, 421, 436, 425, 433,
503 : 418, 440, 447, 396, 413, 0, 418, 383, 412, 420,
504 : 414, 407, 396, 416, 410, 416, 398, 375, 411, 385,
505 : 0, 413, 399, 374, 367, 368, 365, 371, 0, 408,
506 :
507 : 409, 389, 370, 393, 386, 0, 400, 403, 389, 382,
508 : 381, 395, 395, 397, 0, 388, 377, 386, 393, 352,
509 : 360, 353, 384, 380, 384, 368, 381, 382, 366, 378,
510 : 363, 372, 348, 0, 378, 374, 363, 362, 355, 369,
511 : 342, 350, 368, 0, 0, 332, 365, 317, 0, 348,
512 : 332, 319, 317, 329, 328, 341, 340, 350, 315, 0,
513 : 352, 342, 346, 345, 0, 344, 348, 0, 331, 330,
514 : 0, 347, 336, 103, 328, 303, 336, 324, 0, 0,
515 : 324, 337, 0, 338, 292, 325, 319, 325, 302, 0,
516 : 329, 0, 0, 293, 328, 327, 288, 325, 310, 327,
517 :
518 : 0, 289, 296, 274, 305, 335, 313, 318, 284, 301,
519 : 298, 303, 302, 300, 0, 309, 0, 304, 0, 264,
520 : 259, 262, 273, 303, 0, 0, 0, 287, 260, 299,
521 : 256, 0, 256, 293, 267, 271, 0, 263, 284, 249,
522 : 284, 252, 253, 274, 244, 272, 275, 0, 0, 0,
523 : 270, 283, 280, 272, 281, 272, 237, 248, 235, 0,
524 : 262, 270, 240, 268, 230, 243, 260, 254, 257, 0,
525 : 251, 224, 0, 233, 249, 219, 220, 240, 250, 0,
526 : 259, 0, 243, 0, 252, 222, 226, 220, 0, 242,
527 : 213, 241, 216, 207, 243, 203, 241, 240, 210, 0,
528 :
529 : 199, 200, 207, 230, 0, 0, 0, 223, 199, 221,
530 : 197, 225, 202, 228, 193, 197, 214, 187, 228, 225,
531 : 187, 183, 190, 184, 206, 200, 188, 185, 186, 0,
532 : 0, 201, 184, 173, 180, 166, 0, 194, 166, 163,
533 : 157, 163, 197, 0, 0, 155, 0, 171, 0, 147,
534 : 0, 151, 188, 0, 149, 155, 0, 166, 155, 0,
535 : 143, 150, 167, 147, 0, 0, 0, 38, 0, 0,
536 : 0, 0, 649, 225, 229, 231, 234
537 : } ;
538 :
539 : static const flex_int16_t yy_def[578] =
540 : { 0,
541 : 573, 1, 573, 573, 573, 573, 573, 573, 573, 573,
542 : 573, 573, 573, 573, 573, 573, 574, 574, 574, 574,
543 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
544 : 574, 574, 574, 574, 574, 573, 573, 575, 576, 573,
545 : 573, 573, 573, 573, 577, 573, 574, 574, 574, 574,
546 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
547 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
548 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
549 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
550 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
551 :
552 : 574, 575, 576, 573, 577, 573, 574, 574, 574, 574,
553 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
554 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
555 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
556 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
557 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
558 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
559 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
560 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
561 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
562 :
563 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
564 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
565 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
566 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
567 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
568 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
569 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
570 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
571 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
572 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
573 :
574 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
575 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
576 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
577 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
578 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
579 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
580 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
581 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
582 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
583 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
584 :
585 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
586 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
587 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
588 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
589 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
590 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
591 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
592 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
593 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
594 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
595 :
596 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
597 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
598 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
599 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
600 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
601 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
602 : 574, 574, 574, 574, 574, 574, 574, 574, 574, 574,
603 : 574, 574, 0, 573, 573, 573, 573
604 : } ;
605 :
606 : static const flex_int16_t yy_nxt[722] =
607 : { 0,
608 : 4, 5, 6, 7, 8, 9, 4, 10, 11, 12,
609 : 13, 14, 14, 14, 14, 14, 14, 15, 4, 16,
610 : 17, 18, 19, 20, 21, 22, 23, 24, 25, 24,
611 : 24, 24, 26, 27, 28, 29, 24, 30, 31, 32,
612 : 33, 34, 35, 24, 24, 24, 36, 37, 38, 39,
613 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
614 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
615 : 39, 39, 40, 118, 119, 41, 42, 42, 42, 42,
616 : 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
617 : 42, 42, 42, 42, 42, 42, 48, 52, 61, 62,
618 :
619 : 66, 53, 64, 572, 57, 54, 49, 55, 58, 63,
620 : 50, 59, 67, 68, 73, 51, 69, 56, 75, 65,
621 : 77, 78, 74, 97, 79, 70, 71, 82, 88, 98,
622 : 83, 72, 89, 115, 80, 92, 122, 123, 84, 135,
623 : 93, 420, 45, 90, 85, 125, 76, 116, 91, 81,
624 : 153, 324, 99, 325, 124, 136, 137, 94, 126, 150,
625 : 421, 154, 127, 151, 95, 42, 42, 42, 42, 42,
626 : 42, 42, 86, 96, 42, 42, 42, 42, 42, 42,
627 : 42, 155, 166, 169, 156, 167, 172, 183, 184, 191,
628 : 185, 200, 192, 229, 201, 230, 270, 170, 186, 259,
629 :
630 : 231, 173, 571, 260, 570, 569, 568, 271, 567, 566,
631 : 565, 564, 563, 562, 561, 560, 559, 558, 557, 556,
632 : 555, 554, 553, 552, 551, 45, 47, 47, 47, 47,
633 : 102, 102, 103, 103, 103, 103, 105, 550, 105, 549,
634 : 548, 547, 546, 545, 544, 543, 542, 541, 540, 539,
635 : 538, 537, 536, 535, 534, 533, 532, 531, 530, 529,
636 : 528, 527, 526, 525, 524, 523, 522, 521, 520, 519,
637 : 518, 517, 516, 515, 514, 513, 512, 511, 510, 509,
638 : 508, 507, 506, 505, 504, 503, 502, 501, 500, 499,
639 : 498, 497, 496, 495, 494, 493, 492, 491, 490, 489,
640 :
641 : 488, 487, 486, 485, 484, 483, 482, 481, 480, 479,
642 : 478, 477, 476, 475, 474, 473, 472, 471, 470, 469,
643 : 468, 467, 466, 465, 464, 463, 462, 461, 460, 459,
644 : 458, 457, 456, 455, 454, 453, 452, 451, 450, 449,
645 : 448, 447, 446, 445, 444, 443, 442, 441, 440, 439,
646 : 438, 437, 436, 435, 434, 433, 432, 431, 430, 429,
647 : 428, 427, 426, 425, 424, 423, 422, 419, 418, 417,
648 : 416, 415, 414, 413, 412, 411, 410, 409, 408, 407,
649 : 406, 405, 404, 403, 402, 401, 400, 399, 398, 397,
650 : 396, 395, 394, 393, 392, 391, 390, 389, 388, 387,
651 :
652 : 386, 385, 384, 383, 382, 381, 380, 379, 378, 377,
653 : 376, 375, 374, 373, 372, 371, 370, 369, 368, 367,
654 : 366, 365, 364, 363, 362, 361, 360, 359, 358, 357,
655 : 356, 355, 354, 353, 352, 351, 350, 349, 348, 347,
656 : 346, 345, 344, 343, 342, 341, 340, 339, 338, 337,
657 : 336, 335, 334, 333, 332, 331, 330, 329, 328, 327,
658 : 326, 323, 322, 321, 320, 319, 318, 317, 316, 315,
659 : 314, 313, 312, 311, 310, 309, 308, 307, 306, 305,
660 : 304, 303, 302, 301, 300, 299, 298, 297, 296, 295,
661 : 294, 293, 292, 291, 290, 289, 288, 287, 286, 285,
662 :
663 : 284, 283, 282, 281, 280, 279, 278, 277, 276, 275,
664 : 274, 273, 272, 269, 268, 267, 266, 265, 264, 263,
665 : 262, 261, 258, 257, 256, 255, 254, 253, 252, 251,
666 : 250, 249, 248, 247, 246, 245, 244, 243, 242, 241,
667 : 240, 239, 238, 237, 236, 235, 234, 233, 232, 228,
668 : 227, 226, 225, 224, 223, 222, 221, 220, 219, 218,
669 : 217, 216, 215, 214, 213, 212, 211, 210, 209, 208,
670 : 207, 206, 205, 204, 203, 202, 199, 198, 197, 196,
671 : 195, 194, 193, 190, 189, 188, 187, 182, 181, 180,
672 : 179, 178, 177, 176, 175, 174, 171, 168, 165, 164,
673 :
674 : 163, 162, 161, 160, 159, 158, 157, 152, 149, 148,
675 : 147, 146, 145, 144, 143, 142, 141, 140, 139, 138,
676 : 134, 133, 132, 131, 130, 129, 128, 121, 120, 117,
677 : 114, 113, 112, 111, 110, 109, 108, 107, 106, 104,
678 : 101, 100, 87, 60, 46, 44, 43, 573, 3, 573,
679 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
680 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
681 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
682 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
683 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
684 :
685 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
686 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
687 : 573
688 : } ;
689 :
690 : static const flex_int16_t yy_chk[722] =
691 : { 0,
692 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
693 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
694 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
695 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
696 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
697 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
698 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
699 : 1, 1, 10, 59, 59, 10, 10, 10, 10, 10,
700 : 10, 10, 13, 13, 13, 13, 13, 13, 13, 14,
701 : 14, 14, 14, 14, 14, 14, 17, 18, 21, 21,
702 :
703 : 23, 18, 22, 568, 19, 18, 17, 18, 19, 21,
704 : 17, 19, 23, 25, 26, 17, 25, 18, 27, 22,
705 : 28, 28, 26, 33, 28, 25, 25, 29, 31, 33,
706 : 29, 25, 31, 57, 28, 32, 62, 62, 29, 71,
707 : 32, 374, 13, 31, 29, 63, 27, 57, 31, 28,
708 : 87, 266, 33, 266, 62, 71, 71, 32, 63, 85,
709 : 374, 87, 63, 85, 32, 41, 41, 41, 41, 41,
710 : 41, 41, 29, 32, 42, 42, 42, 42, 42, 42,
711 : 42, 88, 98, 100, 88, 98, 107, 119, 119, 126,
712 : 120, 134, 126, 165, 134, 165, 204, 100, 120, 193,
713 :
714 : 165, 107, 564, 193, 563, 562, 561, 204, 559, 558,
715 : 556, 555, 553, 552, 550, 548, 546, 543, 542, 541,
716 : 540, 539, 538, 536, 535, 41, 574, 574, 574, 574,
717 : 575, 575, 576, 576, 576, 576, 577, 534, 577, 533,
718 : 532, 529, 528, 527, 526, 525, 524, 523, 522, 521,
719 : 520, 519, 518, 517, 516, 515, 514, 513, 512, 511,
720 : 510, 509, 508, 504, 503, 502, 501, 499, 498, 497,
721 : 496, 495, 494, 493, 492, 491, 490, 488, 487, 486,
722 : 485, 483, 481, 479, 478, 477, 476, 475, 474, 472,
723 : 471, 469, 468, 467, 466, 465, 464, 463, 462, 461,
724 :
725 : 459, 458, 457, 456, 455, 454, 453, 452, 451, 447,
726 : 446, 445, 444, 443, 442, 441, 440, 439, 438, 436,
727 : 435, 434, 433, 431, 430, 429, 428, 424, 423, 422,
728 : 421, 420, 418, 416, 414, 413, 412, 411, 410, 409,
729 : 408, 407, 406, 405, 404, 403, 402, 400, 399, 398,
730 : 397, 396, 395, 394, 391, 389, 388, 387, 386, 385,
731 : 384, 382, 381, 378, 377, 376, 375, 373, 372, 370,
732 : 369, 367, 366, 364, 363, 362, 361, 359, 358, 357,
733 : 356, 355, 354, 353, 352, 351, 350, 348, 347, 346,
734 : 343, 342, 341, 340, 339, 338, 337, 336, 335, 333,
735 :
736 : 332, 331, 330, 329, 328, 327, 326, 325, 324, 323,
737 : 322, 321, 320, 319, 318, 317, 316, 314, 313, 312,
738 : 311, 310, 309, 308, 307, 305, 304, 303, 302, 301,
739 : 300, 298, 297, 296, 295, 294, 293, 292, 290, 289,
740 : 288, 287, 286, 285, 284, 283, 282, 281, 280, 279,
741 : 278, 277, 275, 274, 273, 272, 271, 270, 269, 268,
742 : 267, 265, 264, 263, 262, 260, 259, 258, 257, 256,
743 : 255, 254, 253, 252, 251, 250, 249, 248, 246, 245,
744 : 244, 243, 241, 240, 239, 238, 236, 235, 234, 233,
745 : 232, 231, 230, 229, 228, 227, 224, 223, 222, 220,
746 :
747 : 219, 217, 216, 215, 214, 213, 212, 211, 210, 209,
748 : 208, 206, 205, 203, 202, 201, 200, 199, 198, 197,
749 : 196, 194, 192, 191, 190, 189, 188, 187, 186, 185,
750 : 184, 183, 182, 181, 180, 179, 178, 177, 176, 175,
751 : 174, 173, 172, 171, 170, 169, 168, 167, 166, 164,
752 : 163, 162, 161, 160, 159, 158, 157, 155, 154, 153,
753 : 152, 151, 150, 149, 147, 146, 145, 144, 143, 142,
754 : 141, 140, 138, 137, 136, 135, 133, 132, 131, 130,
755 : 129, 128, 127, 125, 124, 122, 121, 118, 117, 116,
756 : 115, 114, 113, 111, 110, 109, 101, 99, 97, 96,
757 :
758 : 95, 94, 93, 92, 91, 90, 89, 86, 84, 83,
759 : 82, 81, 80, 78, 77, 76, 75, 74, 73, 72,
760 : 70, 69, 68, 67, 66, 65, 64, 61, 60, 58,
761 : 55, 54, 53, 52, 51, 50, 49, 48, 46, 43,
762 : 35, 34, 30, 20, 15, 12, 11, 3, 573, 573,
763 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
764 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
765 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
766 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
767 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
768 :
769 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
770 : 573, 573, 573, 573, 573, 573, 573, 573, 573, 573,
771 : 573
772 : } ;
773 :
774 : static yy_state_type yy_last_accepting_state;
775 : static char *yy_last_accepting_cpos;
776 :
777 : extern int yy_flex_debug;
778 : int yy_flex_debug = 0;
779 :
780 : /* The intent behind this definition is that it'll catch
781 : * any uses of REJECT which flex missed.
782 : */
783 : #define REJECT reject_used_but_not_detected
784 : #define yymore() yymore_used_but_not_detected
785 : #define YY_MORE_ADJ 0
786 : #define YY_RESTORE_YY_MORE_OFFSET
787 : char *yytext;
788 : /*
789 : * Copyright (c) 1997 - 2017 Kungliga Tekniska Högskolan
790 : * (Royal Institute of Technology, Stockholm, Sweden).
791 : * All rights reserved.
792 : *
793 : * Redistribution and use in source and binary forms, with or without
794 : * modification, are permitted provided that the following conditions
795 : * are met:
796 : *
797 : * 1. Redistributions of source code must retain the above copyright
798 : * notice, this list of conditions and the following disclaimer.
799 : *
800 : * 2. Redistributions in binary form must reproduce the above copyright
801 : * notice, this list of conditions and the following disclaimer in the
802 : * documentation and/or other materials provided with the distribution.
803 : *
804 : * 3. Neither the name of the Institute nor the names of its contributors
805 : * may be used to endorse or promote products derived from this software
806 : * without specific prior written permission.
807 : *
808 : * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
809 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
810 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
811 : * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
812 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
813 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
814 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
815 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
816 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
817 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
818 : * SUCH DAMAGE.
819 : */
820 :
821 : /* $Id$ */
822 :
823 : #ifdef HAVE_CONFIG_H
824 : #include <config.h>
825 : #endif
826 : #include <stdio.h>
827 : #include <stdarg.h>
828 : #include <stdlib.h>
829 : #include <stdint.h>
830 : #include <string.h>
831 : #ifdef HAVE_UNISTD_H
832 : #include <unistd.h>
833 : #endif
834 : #undef ECHO
835 : #include "symbol.h"
836 : #include "asn1parse.h"
837 : #include "lex.h"
838 : #include "gen_locl.h"
839 :
840 : static unsigned lineno = 1;
841 :
842 : #undef ECHO
843 :
844 : static void unterminated(const char *, unsigned);
845 :
846 : /* This is for broken old lexes (solaris 10 and hpux) */
847 :
848 : #define INITIAL 0
849 :
850 : #ifndef YY_NO_UNISTD_H
851 : /* Special case for "unistd.h", since it is non-ANSI. We include it way
852 : * down here because we want the user's section 1 to have been scanned first.
853 : * The user has a chance to override it with an option.
854 : */
855 : #include <unistd.h>
856 : #endif
857 :
858 : #ifndef YY_EXTRA_TYPE
859 : #define YY_EXTRA_TYPE void *
860 : #endif
861 :
862 : static int yy_init_globals ( void );
863 :
864 : /* Accessor methods to globals.
865 : These are made visible to non-reentrant scanners for convenience. */
866 :
867 : int yylex_destroy ( void );
868 :
869 : int yyget_debug ( void );
870 :
871 : void yyset_debug ( int debug_flag );
872 :
873 : YY_EXTRA_TYPE yyget_extra ( void );
874 :
875 : void yyset_extra ( YY_EXTRA_TYPE user_defined );
876 :
877 : FILE *yyget_in ( void );
878 :
879 : void yyset_in ( FILE * _in_str );
880 :
881 : FILE *yyget_out ( void );
882 :
883 : void yyset_out ( FILE * _out_str );
884 :
885 : int yyget_leng ( void );
886 :
887 : char *yyget_text ( void );
888 :
889 : int yyget_lineno ( void );
890 :
891 : void yyset_lineno ( int _line_number );
892 :
893 : /* Macros after this point can all be overridden by user definitions in
894 : * section 1.
895 : */
896 :
897 : #ifndef YY_SKIP_YYWRAP
898 : #ifdef __cplusplus
899 : extern "C" int yywrap ( void );
900 : #else
901 : extern int yywrap ( void );
902 : #endif
903 : #endif
904 :
905 : #ifndef YY_NO_UNPUT
906 :
907 : static void yyunput ( int c, char *buf_ptr );
908 :
909 : #endif
910 :
911 : #ifndef yytext_ptr
912 : static void yy_flex_strncpy ( char *, const char *, int );
913 : #endif
914 :
915 : #ifdef YY_NEED_STRLEN
916 : static int yy_flex_strlen ( const char * );
917 : #endif
918 :
919 : #ifndef YY_NO_INPUT
920 : #ifdef __cplusplus
921 : static int yyinput ( void );
922 : #else
923 : static int input ( void );
924 : #endif
925 :
926 : #endif
927 :
928 : /* Amount of stuff to slurp up with each read. */
929 : #ifndef YY_READ_BUF_SIZE
930 : #ifdef __ia64__
931 : /* On IA-64, the buffer size is 16k, not 8k */
932 : #define YY_READ_BUF_SIZE 16384
933 : #else
934 : #define YY_READ_BUF_SIZE 8192
935 : #endif /* __ia64__ */
936 : #endif
937 :
938 : /* Copy whatever the last rule matched to the standard output. */
939 : #ifndef ECHO
940 : /* This used to be an fputs(), but since the string might contain NUL's,
941 : * we now use fwrite().
942 : */
943 : #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
944 : #endif
945 :
946 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
947 : * is returned in "result".
948 : */
949 : #ifndef YY_INPUT
950 : #define YY_INPUT(buf,result,max_size) \
951 : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
952 : { \
953 : int c = '*'; \
954 : int n; \
955 : for ( n = 0; n < max_size && \
956 : (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
957 : buf[n] = (char) c; \
958 : if ( c == '\n' ) \
959 : buf[n++] = (char) c; \
960 : if ( c == EOF && ferror( yyin ) ) \
961 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
962 : result = n; \
963 : } \
964 : else \
965 : { \
966 : errno=0; \
967 : while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
968 : { \
969 : if( errno != EINTR) \
970 : { \
971 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
972 : break; \
973 : } \
974 : errno=0; \
975 : clearerr(yyin); \
976 : } \
977 : }\
978 : \
979 :
980 : #endif
981 :
982 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
983 : * we don't want an extra ';' after the "return" because that will cause
984 : * some compilers to complain about unreachable statements.
985 : */
986 : #ifndef yyterminate
987 : #define yyterminate() return YY_NULL
988 : #endif
989 :
990 : /* Number of entries by which start-condition stack grows. */
991 : #ifndef YY_START_STACK_INCR
992 : #define YY_START_STACK_INCR 25
993 : #endif
994 :
995 : /* Report a fatal error. */
996 : #ifndef YY_FATAL_ERROR
997 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
998 : #endif
999 :
1000 : /* end tables serialization structures and prototypes */
1001 :
1002 : /* Default declaration of generated scanner - a define so the user can
1003 : * easily add parameters.
1004 : */
1005 : #ifndef YY_DECL
1006 : #define YY_DECL_IS_OURS 1
1007 :
1008 : extern int yylex (void);
1009 :
1010 : #define YY_DECL int yylex (void)
1011 : #endif /* !YY_DECL */
1012 :
1013 : /* Code executed at the beginning of each rule, after yytext and yyleng
1014 : * have been set up.
1015 : */
1016 : #ifndef YY_USER_ACTION
1017 : #define YY_USER_ACTION
1018 : #endif
1019 :
1020 : /* Code executed at the end of each rule. */
1021 : #ifndef YY_BREAK
1022 : #define YY_BREAK /*LINTED*/break;
1023 : #endif
1024 :
1025 : #define YY_RULE_SETUP \
1026 : YY_USER_ACTION
1027 :
1028 : /** The main scanner function which does all the work.
1029 : */
1030 271491 : YY_DECL
1031 : {
1032 14289 : yy_state_type yy_current_state;
1033 14289 : char *yy_cp, *yy_bp;
1034 14289 : int yy_act;
1035 :
1036 271491 : if ( !(yy_init) )
1037 : {
1038 304 : (yy_init) = 1;
1039 :
1040 : #ifdef YY_USER_INIT
1041 : YY_USER_INIT;
1042 : #endif
1043 :
1044 304 : if ( ! (yy_start) )
1045 304 : (yy_start) = 1; /* first start state */
1046 :
1047 304 : if ( ! yyin )
1048 0 : yyin = stdin;
1049 :
1050 304 : if ( ! yyout )
1051 304 : yyout = stdout;
1052 :
1053 304 : if ( ! YY_CURRENT_BUFFER ) {
1054 304 : yyensure_buffer_stack ();
1055 304 : YY_CURRENT_BUFFER_LVALUE =
1056 304 : yy_create_buffer( yyin, YY_BUF_SIZE );
1057 : }
1058 :
1059 304 : yy_load_buffer_state( );
1060 : }
1061 :
1062 : {
1063 :
1064 33720 : while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1065 : {
1066 640680 : yy_cp = (yy_c_buf_p);
1067 :
1068 : /* Support of yytext. */
1069 640680 : *yy_cp = (yy_hold_char);
1070 :
1071 : /* yy_bp points to the position in yy_ch_buf of the start of
1072 : * the current run.
1073 : */
1074 640680 : yy_bp = yy_cp;
1075 :
1076 640680 : yy_current_state = (yy_start);
1077 607356 : yy_match:
1078 102605 : do
1079 : {
1080 1949495 : YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1081 1949495 : if ( yy_accept[yy_current_state] )
1082 : {
1083 1293482 : (yy_last_accepting_state) = yy_current_state;
1084 1293482 : (yy_last_accepting_cpos) = yy_cp;
1085 : }
1086 3035915 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1087 : {
1088 1086420 : yy_current_state = (int) yy_def[yy_current_state];
1089 1086420 : if ( yy_current_state >= 574 )
1090 936282 : yy_c = yy_meta[yy_c];
1091 : }
1092 1949495 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1093 1949495 : ++yy_cp;
1094 : }
1095 1949495 : while ( yy_base[yy_current_state] != 649 );
1096 :
1097 641098 : yy_find_action:
1098 641098 : yy_act = yy_accept[yy_current_state];
1099 641098 : if ( yy_act == 0 )
1100 : { /* have to back up */
1101 150138 : yy_cp = (yy_last_accepting_cpos);
1102 150138 : yy_current_state = (yy_last_accepting_state);
1103 150138 : yy_act = yy_accept[yy_current_state];
1104 : }
1105 :
1106 641098 : YY_DO_BEFORE_ACTION;
1107 :
1108 641402 : do_action: /* This label is used only to access EOF actions. */
1109 :
1110 641402 : switch ( yy_act )
1111 : { /* beginning of action switch */
1112 0 : case 0: /* must back up */
1113 : /* undo the effects of YY_DO_BEFORE_ACTION */
1114 0 : *yy_cp = (yy_hold_char);
1115 0 : yy_cp = (yy_last_accepting_cpos);
1116 0 : yy_current_state = (yy_last_accepting_state);
1117 0 : goto yy_find_action;
1118 :
1119 0 : case 1:
1120 : YY_RULE_SETUP
1121 0 : { return kw_ABSENT; }
1122 0 : YY_BREAK
1123 0 : case 2:
1124 : YY_RULE_SETUP
1125 0 : { return kw_ABSTRACT_SYNTAX; }
1126 0 : YY_BREAK
1127 0 : case 3:
1128 : YY_RULE_SETUP
1129 0 : { return kw_ALL; }
1130 24 : YY_BREAK
1131 456 : case 4:
1132 : YY_RULE_SETUP
1133 456 : { return kw_APPLICATION; }
1134 0 : YY_BREAK
1135 0 : case 5:
1136 : YY_RULE_SETUP
1137 0 : { return kw_AUTOMATIC; }
1138 16 : YY_BREAK
1139 304 : case 6:
1140 : YY_RULE_SETUP
1141 304 : { return kw_BEGIN; }
1142 35 : YY_BREAK
1143 665 : case 7:
1144 : YY_RULE_SETUP
1145 665 : { return kw_BIT; }
1146 3 : YY_BREAK
1147 57 : case 8:
1148 : YY_RULE_SETUP
1149 57 : { return kw_BMPString; }
1150 16 : YY_BREAK
1151 304 : case 9:
1152 : YY_RULE_SETUP
1153 304 : { return kw_BOOLEAN; }
1154 0 : YY_BREAK
1155 0 : case 10:
1156 : YY_RULE_SETUP
1157 0 : { return kw_BY; }
1158 0 : YY_BREAK
1159 0 : case 11:
1160 : YY_RULE_SETUP
1161 0 : { return kw_CHARACTER; }
1162 31 : YY_BREAK
1163 589 : case 12:
1164 : YY_RULE_SETUP
1165 589 : { return kw_CHOICE; }
1166 5 : YY_BREAK
1167 95 : case 13:
1168 : YY_RULE_SETUP
1169 95 : { return kw_CLASS; }
1170 0 : YY_BREAK
1171 0 : case 14:
1172 : YY_RULE_SETUP
1173 0 : { return kw_COMPONENT; }
1174 0 : YY_BREAK
1175 0 : case 15:
1176 : YY_RULE_SETUP
1177 0 : { return kw_COMPONENTS; }
1178 0 : YY_BREAK
1179 0 : case 16:
1180 : YY_RULE_SETUP
1181 0 : { return kw_CONSTRAINED; }
1182 1 : YY_BREAK
1183 19 : case 17:
1184 : YY_RULE_SETUP
1185 19 : { return kw_CONTAINING; }
1186 14 : YY_BREAK
1187 266 : case 18:
1188 : YY_RULE_SETUP
1189 266 : { return kw_DEFAULT; }
1190 16 : YY_BREAK
1191 304 : case 19:
1192 : YY_RULE_SETUP
1193 304 : { return kw_DEFINITIONS; }
1194 0 : YY_BREAK
1195 0 : case 20:
1196 : YY_RULE_SETUP
1197 0 : { return kw_EMBEDDED; }
1198 0 : YY_BREAK
1199 0 : case 21:
1200 : YY_RULE_SETUP
1201 0 : { return kw_ENCODED; }
1202 16 : YY_BREAK
1203 304 : case 22:
1204 : YY_RULE_SETUP
1205 304 : { return kw_END; }
1206 10 : YY_BREAK
1207 190 : case 23:
1208 : YY_RULE_SETUP
1209 190 : { return kw_ENUMERATED; }
1210 0 : YY_BREAK
1211 0 : case 24:
1212 : YY_RULE_SETUP
1213 0 : { return kw_EXCEPT; }
1214 24 : YY_BREAK
1215 456 : case 25:
1216 : YY_RULE_SETUP
1217 456 : { return kw_EXPLICIT; }
1218 1 : YY_BREAK
1219 19 : case 26:
1220 : YY_RULE_SETUP
1221 19 : { return kw_EXPORTS; }
1222 0 : YY_BREAK
1223 0 : case 27:
1224 : YY_RULE_SETUP
1225 0 : { return kw_EXTENSIBILITY; }
1226 0 : YY_BREAK
1227 0 : case 28:
1228 : YY_RULE_SETUP
1229 0 : { return kw_EXTERNAL; }
1230 27 : YY_BREAK
1231 513 : case 29:
1232 : YY_RULE_SETUP
1233 513 : { return kw_FALSE; }
1234 23 : YY_BREAK
1235 437 : case 30:
1236 : YY_RULE_SETUP
1237 437 : { return kw_FROM; }
1238 14 : YY_BREAK
1239 266 : case 31:
1240 : YY_RULE_SETUP
1241 266 : { return kw_GeneralString; }
1242 9 : YY_BREAK
1243 171 : case 32:
1244 : YY_RULE_SETUP
1245 171 : { return kw_GeneralizedTime; }
1246 0 : YY_BREAK
1247 0 : case 33:
1248 : YY_RULE_SETUP
1249 0 : { return kw_GraphicString; }
1250 11 : YY_BREAK
1251 209 : case 34:
1252 : YY_RULE_SETUP
1253 209 : { return kw_IA5String; }
1254 278 : YY_BREAK
1255 5282 : case 35:
1256 : YY_RULE_SETUP
1257 5282 : { return kw_IDENTIFIER; }
1258 70 : YY_BREAK
1259 1330 : case 36:
1260 : YY_RULE_SETUP
1261 1330 : { return kw_IMPLICIT; }
1262 0 : YY_BREAK
1263 0 : case 37:
1264 : YY_RULE_SETUP
1265 0 : { return kw_IMPLIED; }
1266 13 : YY_BREAK
1267 247 : case 38:
1268 : YY_RULE_SETUP
1269 247 : { return kw_IMPORTS; }
1270 0 : YY_BREAK
1271 0 : case 39:
1272 : YY_RULE_SETUP
1273 0 : { return kw_INCLUDES; }
1274 0 : YY_BREAK
1275 0 : case 40:
1276 : YY_RULE_SETUP
1277 0 : { return kw_INSTANCE; }
1278 155 : YY_BREAK
1279 2945 : case 41:
1280 : YY_RULE_SETUP
1281 2945 : { return kw_INTEGER; }
1282 0 : YY_BREAK
1283 0 : case 42:
1284 : YY_RULE_SETUP
1285 0 : { return kw_INTERSECTION; }
1286 0 : YY_BREAK
1287 0 : case 43:
1288 : YY_RULE_SETUP
1289 0 : { return kw_ISO646String; }
1290 14 : YY_BREAK
1291 266 : case 44:
1292 : YY_RULE_SETUP
1293 266 : { return kw_MAX; }
1294 0 : YY_BREAK
1295 0 : case 45:
1296 : YY_RULE_SETUP
1297 0 : { return kw_MIN; }
1298 0 : YY_BREAK
1299 0 : case 46:
1300 : YY_RULE_SETUP
1301 0 : { return kw_MINUS_INFINITY; }
1302 5 : YY_BREAK
1303 95 : case 47:
1304 : YY_RULE_SETUP
1305 95 : { return kw_NULL; }
1306 0 : YY_BREAK
1307 0 : case 48:
1308 : YY_RULE_SETUP
1309 0 : { return kw_NumericString; }
1310 278 : YY_BREAK
1311 5282 : case 49:
1312 : YY_RULE_SETUP
1313 5282 : { return kw_OBJECT; }
1314 122 : YY_BREAK
1315 2318 : case 50:
1316 : YY_RULE_SETUP
1317 2318 : { return kw_OCTET; }
1318 91 : YY_BREAK
1319 1729 : case 51:
1320 : YY_RULE_SETUP
1321 1729 : { return kw_OF; }
1322 297 : YY_BREAK
1323 5643 : case 52:
1324 : YY_RULE_SETUP
1325 5643 : { return kw_OPTIONAL; }
1326 0 : YY_BREAK
1327 0 : case 53:
1328 : YY_RULE_SETUP
1329 0 : { return kw_ObjectDescriptor; }
1330 0 : YY_BREAK
1331 0 : case 54:
1332 : YY_RULE_SETUP
1333 0 : { return kw_PATTERN; }
1334 0 : YY_BREAK
1335 0 : case 55:
1336 : YY_RULE_SETUP
1337 0 : { return kw_PDV; }
1338 0 : YY_BREAK
1339 0 : case 56:
1340 : YY_RULE_SETUP
1341 0 : { return kw_PLUS_INFINITY; }
1342 0 : YY_BREAK
1343 0 : case 57:
1344 : YY_RULE_SETUP
1345 0 : { return kw_PRESENT; }
1346 0 : YY_BREAK
1347 0 : case 58:
1348 : YY_RULE_SETUP
1349 0 : { return kw_PRIVATE; }
1350 2 : YY_BREAK
1351 38 : case 59:
1352 : YY_RULE_SETUP
1353 38 : { return kw_PrintableString; }
1354 0 : YY_BREAK
1355 0 : case 60:
1356 : YY_RULE_SETUP
1357 0 : { return kw_REAL; }
1358 0 : YY_BREAK
1359 0 : case 61:
1360 : YY_RULE_SETUP
1361 0 : { return kw_RELATIVE_OID; }
1362 294 : YY_BREAK
1363 5586 : case 62:
1364 : YY_RULE_SETUP
1365 5586 : { return kw_SEQUENCE; }
1366 17 : YY_BREAK
1367 323 : case 63:
1368 : YY_RULE_SETUP
1369 323 : { return kw_SET; }
1370 17 : YY_BREAK
1371 323 : case 64:
1372 : YY_RULE_SETUP
1373 323 : { return kw_SIZE; }
1374 157 : YY_BREAK
1375 2983 : case 65:
1376 : YY_RULE_SETUP
1377 2983 : { return kw_STRING; }
1378 0 : YY_BREAK
1379 0 : case 66:
1380 : YY_RULE_SETUP
1381 0 : { return kw_SYNTAX; }
1382 0 : YY_BREAK
1383 0 : case 67:
1384 : YY_RULE_SETUP
1385 0 : { return kw_T61String; }
1386 2 : YY_BREAK
1387 38 : case 68:
1388 : YY_RULE_SETUP
1389 38 : { return kw_TAGS; }
1390 0 : YY_BREAK
1391 0 : case 69:
1392 : YY_RULE_SETUP
1393 0 : { return kw_TRUE; }
1394 0 : YY_BREAK
1395 0 : case 70:
1396 : YY_RULE_SETUP
1397 0 : { return kw_TYPE_IDENTIFIER; }
1398 1 : YY_BREAK
1399 19 : case 71:
1400 : YY_RULE_SETUP
1401 19 : { return kw_TeletexString; }
1402 0 : YY_BREAK
1403 0 : case 72:
1404 : YY_RULE_SETUP
1405 0 : { return kw_UNION; }
1406 5 : YY_BREAK
1407 95 : case 73:
1408 : YY_RULE_SETUP
1409 95 : { return kw_UNIQUE; }
1410 1 : YY_BREAK
1411 19 : case 74:
1412 : YY_RULE_SETUP
1413 19 : { return kw_UNIVERSAL; }
1414 1 : YY_BREAK
1415 19 : case 75:
1416 : YY_RULE_SETUP
1417 19 : { return kw_UTCTime; }
1418 46 : YY_BREAK
1419 874 : case 76:
1420 : YY_RULE_SETUP
1421 874 : { return kw_UTF8String; }
1422 1 : YY_BREAK
1423 19 : case 77:
1424 : YY_RULE_SETUP
1425 19 : { return kw_UniversalString; }
1426 0 : YY_BREAK
1427 0 : case 78:
1428 : YY_RULE_SETUP
1429 0 : { return kw_VideotexString; }
1430 2 : YY_BREAK
1431 38 : case 79:
1432 : YY_RULE_SETUP
1433 38 : { return kw_VisibleString; }
1434 0 : YY_BREAK
1435 0 : case 80:
1436 : YY_RULE_SETUP
1437 0 : { return kw_WITH; }
1438 4208 : YY_BREAK
1439 79952 : case 81:
1440 : YY_RULE_SETUP
1441 79952 : { return *yytext; }
1442 612 : YY_BREAK
1443 11628 : case 82:
1444 : YY_RULE_SETUP
1445 11628 : { return *yytext; }
1446 612 : YY_BREAK
1447 11628 : case 83:
1448 : YY_RULE_SETUP
1449 11628 : { return *yytext; }
1450 149 : YY_BREAK
1451 2831 : case 84:
1452 : YY_RULE_SETUP
1453 2831 : { return *yytext; }
1454 12 : YY_BREAK
1455 228 : case 85:
1456 : YY_RULE_SETUP
1457 228 : { return *yytext; }
1458 6 : YY_BREAK
1459 114 : case 86:
1460 : YY_RULE_SETUP
1461 114 : { return *yytext; }
1462 6 : YY_BREAK
1463 114 : case 87:
1464 : YY_RULE_SETUP
1465 114 : { return *yytext; }
1466 783 : YY_BREAK
1467 14877 : case 88:
1468 : YY_RULE_SETUP
1469 14877 : { return EEQUAL; }
1470 874 : YY_BREAK
1471 16606 : case 89:
1472 : YY_RULE_SETUP
1473 : {
1474 16606 : int c, start_lineno = lineno;
1475 16606 : int f = 0;
1476 541481 : while((c = input()) != EOF) {
1477 541481 : if(f && c == '-')
1478 1728 : break;
1479 539657 : if(c == '-') {
1480 9310 : f = 1;
1481 9310 : continue;
1482 : }
1483 530347 : if(c == '\n') {
1484 14782 : lineno++;
1485 14782 : break;
1486 : }
1487 488430 : f = 0;
1488 : }
1489 16606 : if(c == EOF)
1490 33720 : unterminated("comment", start_lineno);
1491 : }
1492 15732 : YY_BREAK
1493 0 : case 90:
1494 : YY_RULE_SETUP
1495 : {
1496 0 : int c, start_lineno = lineno;
1497 0 : int level = 1;
1498 0 : int seen_star = 0;
1499 0 : int seen_slash = 0;
1500 0 : while((c = input()) != EOF) {
1501 0 : if(c == '/') {
1502 0 : if(seen_star) {
1503 0 : if(--level == 0)
1504 0 : break;
1505 0 : seen_star = 0;
1506 0 : continue;
1507 : }
1508 0 : seen_slash = 1;
1509 0 : continue;
1510 : }
1511 0 : if(seen_star && c == '/') {
1512 0 : if(--level == 0)
1513 0 : break;
1514 0 : seen_star = 0;
1515 0 : continue;
1516 : }
1517 0 : if(c == '*') {
1518 0 : if(seen_slash) {
1519 0 : level++;
1520 0 : seen_star = seen_slash = 0;
1521 0 : continue;
1522 : }
1523 0 : seen_star = 1;
1524 0 : continue;
1525 : }
1526 0 : seen_star = seen_slash = 0;
1527 0 : if(c == '\n') {
1528 0 : lineno++;
1529 0 : continue;
1530 : }
1531 : }
1532 0 : if(c == EOF)
1533 33720 : unterminated("comment", start_lineno);
1534 : }
1535 0 : YY_BREAK
1536 0 : case 91:
1537 : YY_RULE_SETUP
1538 : {
1539 0 : int start_lineno = lineno;
1540 0 : int c;
1541 0 : char buf[1024];
1542 0 : char *p = buf;
1543 0 : int f = 0;
1544 0 : int skip_ws = 0;
1545 :
1546 0 : while((c = input()) != EOF) {
1547 0 : if(isspace(c) && skip_ws) {
1548 0 : if(c == '\n')
1549 0 : lineno++;
1550 0 : continue;
1551 : }
1552 0 : skip_ws = 0;
1553 :
1554 0 : if(c == '"') {
1555 0 : if(f) {
1556 0 : *p++ = '"';
1557 0 : f = 0;
1558 : } else
1559 0 : f = 1;
1560 0 : continue;
1561 : }
1562 0 : if(f == 1) {
1563 0 : unput(c);
1564 0 : break;
1565 : }
1566 0 : if(c == '\n') {
1567 0 : lineno++;
1568 0 : while(p > buf && isspace((unsigned char)p[-1]))
1569 0 : p--;
1570 0 : skip_ws = 1;
1571 0 : continue;
1572 : }
1573 0 : *p++ = c;
1574 : }
1575 0 : if(c == EOF)
1576 0 : unterminated("string", start_lineno);
1577 0 : *p++ = '\0';
1578 0 : yylval.name = estrdup(buf);
1579 0 : return STRING;
1580 : }
1581 1845 : YY_BREAK
1582 35055 : case 92:
1583 : YY_RULE_SETUP
1584 35055 : { char *e, *y = yytext;
1585 35055 : yylval.constant = strtoll((const char *)yytext,
1586 : &e, 0);
1587 35055 : if(e == y)
1588 0 : lex_error_message("malformed constant (%s)", yytext);
1589 : else
1590 35055 : return NUMBER;
1591 : }
1592 0 : YY_BREAK
1593 1501 : case 93:
1594 : YY_RULE_SETUP
1595 : {
1596 1501 : yylval.name = estrdup ((const char *)yytext);
1597 1501 : return CLASS_IDENTIFIER;
1598 : }
1599 1541 : YY_BREAK
1600 29279 : case 94:
1601 : YY_RULE_SETUP
1602 : {
1603 29279 : yylval.name = estrdup ((const char *)yytext);
1604 29279 : return TYPE_IDENTIFIER;
1605 : }
1606 2158 : YY_BREAK
1607 41002 : case 95:
1608 : YY_RULE_SETUP
1609 : {
1610 41002 : yylval.name = estrdup ((const char *)yytext);
1611 41002 : return VALUE_IDENTIFIER;
1612 : }
1613 : YY_BREAK
1614 276498 : case 96:
1615 : YY_RULE_SETUP
1616 : ;
1617 276498 : YY_BREAK
1618 60724 : case 97:
1619 : /* rule 97 can match eol */
1620 : YY_RULE_SETUP
1621 60724 : { ++lineno; }
1622 60724 : YY_BREAK
1623 741 : case 98:
1624 : YY_RULE_SETUP
1625 741 : { return ELLIPSIS; }
1626 58 : YY_BREAK
1627 1102 : case 99:
1628 : YY_RULE_SETUP
1629 1102 : { return RANGE; }
1630 0 : YY_BREAK
1631 0 : case 100:
1632 : YY_RULE_SETUP
1633 0 : { lex_error_message("Ignoring char(%c)\n", *yytext); }
1634 0 : YY_BREAK
1635 0 : case 101:
1636 : YY_RULE_SETUP
1637 0 : ECHO;
1638 0 : YY_BREAK
1639 304 : case YY_STATE_EOF(INITIAL):
1640 304 : yyterminate();
1641 :
1642 722 : case YY_END_OF_BUFFER:
1643 : {
1644 : /* Amount of text matched not including the EOB char. */
1645 722 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1646 :
1647 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1648 722 : *yy_cp = (yy_hold_char);
1649 : YY_RESTORE_YY_MORE_OFFSET
1650 :
1651 722 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1652 : {
1653 : /* We're scanning a new file or input source. It's
1654 : * possible that this happened because the user
1655 : * just pointed yyin at a new source and called
1656 : * yylex(). If so, then we have to assure
1657 : * consistency between YY_CURRENT_BUFFER and our
1658 : * globals. Here is the right place to do so, because
1659 : * this is the first action (other than possibly a
1660 : * back-up) that will match for the new input source.
1661 : */
1662 304 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1663 304 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1664 304 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1665 : }
1666 :
1667 : /* Note that here we test for yy_c_buf_p "<=" to the position
1668 : * of the first EOB in the buffer, since yy_c_buf_p will
1669 : * already have been incremented past the NUL character
1670 : * (since all states make transitions on EOB to the
1671 : * end-of-buffer state). Contrast this with the test
1672 : * in input().
1673 : */
1674 722 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1675 : { /* This was really a NUL. */
1676 0 : yy_state_type yy_next_state;
1677 :
1678 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1679 :
1680 0 : yy_current_state = yy_get_previous_state( );
1681 :
1682 : /* Okay, we're now positioned to make the NUL
1683 : * transition. We couldn't have
1684 : * yy_get_previous_state() go ahead and do it
1685 : * for us because it doesn't know how to deal
1686 : * with the possibility of jamming (and we don't
1687 : * want to build jamming into it because then it
1688 : * will run more slowly).
1689 : */
1690 :
1691 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
1692 :
1693 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1694 :
1695 0 : if ( yy_next_state )
1696 : {
1697 : /* Consume the NUL. */
1698 0 : yy_cp = ++(yy_c_buf_p);
1699 0 : yy_current_state = yy_next_state;
1700 0 : goto yy_match;
1701 : }
1702 :
1703 : else
1704 : {
1705 0 : yy_cp = (yy_c_buf_p);
1706 0 : goto yy_find_action;
1707 : }
1708 : }
1709 :
1710 722 : else switch ( yy_get_next_buffer( ) )
1711 : {
1712 304 : case EOB_ACT_END_OF_FILE:
1713 : {
1714 304 : (yy_did_buffer_switch_on_eof) = 0;
1715 :
1716 304 : if ( yywrap( ) )
1717 : {
1718 : /* Note: because we've taken care in
1719 : * yy_get_next_buffer() to have set up
1720 : * yytext, we can now set up
1721 : * yy_c_buf_p so that if some total
1722 : * hoser (like flex itself) wants to
1723 : * call the scanner after we return the
1724 : * YY_NULL, it'll still work - another
1725 : * YY_NULL will get returned.
1726 : */
1727 304 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1728 :
1729 304 : yy_act = YY_STATE_EOF(YY_START);
1730 304 : goto do_action;
1731 : }
1732 :
1733 : else
1734 : {
1735 0 : if ( ! (yy_did_buffer_switch_on_eof) )
1736 0 : YY_NEW_FILE;
1737 : }
1738 0 : break;
1739 : }
1740 :
1741 418 : case EOB_ACT_CONTINUE_SCAN:
1742 418 : (yy_c_buf_p) =
1743 418 : (yytext_ptr) + yy_amount_of_matched_text;
1744 :
1745 418 : yy_current_state = yy_get_previous_state( );
1746 :
1747 418 : yy_cp = (yy_c_buf_p);
1748 418 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1749 418 : goto yy_match;
1750 :
1751 0 : case EOB_ACT_LAST_MATCH:
1752 0 : (yy_c_buf_p) =
1753 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1754 :
1755 0 : yy_current_state = yy_get_previous_state( );
1756 :
1757 0 : yy_cp = (yy_c_buf_p);
1758 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1759 0 : goto yy_find_action;
1760 : }
1761 0 : break;
1762 : }
1763 :
1764 0 : default:
1765 0 : YY_FATAL_ERROR(
1766 : "fatal flex scanner internal error--no action found" );
1767 : } /* end of action switch */
1768 : } /* end of scanning one token */
1769 : } /* end of user's declarations */
1770 : } /* end of yylex */
1771 :
1772 : /* yy_get_next_buffer - try to read in a new buffer
1773 : *
1774 : * Returns a code representing an action:
1775 : * EOB_ACT_LAST_MATCH -
1776 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1777 : * EOB_ACT_END_OF_FILE - end of file
1778 : */
1779 779 : static int yy_get_next_buffer (void)
1780 : {
1781 779 : char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1782 779 : char *source = (yytext_ptr);
1783 41 : int number_to_move, i;
1784 41 : int ret_val;
1785 :
1786 779 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1787 0 : YY_FATAL_ERROR(
1788 : "fatal flex scanner internal error--end of buffer missed" );
1789 :
1790 779 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1791 : { /* Don't try to fill the buffer, so this is an EOF. */
1792 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1793 : {
1794 : /* We matched a single character, the EOB, so
1795 : * treat this as a final EOF.
1796 : */
1797 0 : return EOB_ACT_END_OF_FILE;
1798 : }
1799 :
1800 : else
1801 : {
1802 : /* We matched some text prior to the EOB, first
1803 : * process it.
1804 : */
1805 0 : return EOB_ACT_LAST_MATCH;
1806 : }
1807 : }
1808 :
1809 : /* Try to read more data. */
1810 :
1811 : /* First move last chars to start of buffer. */
1812 779 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1813 :
1814 2945 : for ( i = 0; i < number_to_move; ++i )
1815 2166 : *(dest++) = *(source++);
1816 :
1817 779 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1818 : /* don't do the read, it's not guaranteed to return an EOF,
1819 : * just force an EOF
1820 : */
1821 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1822 :
1823 : else
1824 : {
1825 779 : int num_to_read =
1826 779 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1827 :
1828 779 : while ( num_to_read <= 0 )
1829 : { /* Not enough room in the buffer - grow it. */
1830 :
1831 : /* just a shorter name for the current buffer */
1832 0 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1833 :
1834 0 : int yy_c_buf_p_offset =
1835 0 : (int) ((yy_c_buf_p) - b->yy_ch_buf);
1836 :
1837 0 : if ( b->yy_is_our_buffer )
1838 : {
1839 0 : int new_size = b->yy_buf_size * 2;
1840 :
1841 0 : if ( new_size <= 0 )
1842 0 : b->yy_buf_size += b->yy_buf_size / 8;
1843 : else
1844 0 : b->yy_buf_size *= 2;
1845 :
1846 0 : b->yy_ch_buf = (char *)
1847 : /* Include room in for 2 EOB chars. */
1848 0 : yyrealloc( (void *) b->yy_ch_buf,
1849 0 : (yy_size_t) (b->yy_buf_size + 2) );
1850 : }
1851 : else
1852 : /* Can't grow it, we don't own it. */
1853 0 : b->yy_ch_buf = NULL;
1854 :
1855 0 : if ( ! b->yy_ch_buf )
1856 0 : YY_FATAL_ERROR(
1857 : "fatal error - scanner input buffer overflow" );
1858 :
1859 0 : (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1860 :
1861 0 : num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1862 : number_to_move - 1;
1863 :
1864 : }
1865 :
1866 779 : if ( num_to_read > YY_READ_BUF_SIZE )
1867 738 : num_to_read = YY_READ_BUF_SIZE;
1868 :
1869 : /* Read in more data. */
1870 820 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1871 41 : (yy_n_chars), num_to_read );
1872 :
1873 779 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1874 : }
1875 :
1876 779 : if ( (yy_n_chars) == 0 )
1877 : {
1878 304 : if ( number_to_move == YY_MORE_ADJ )
1879 : {
1880 304 : ret_val = EOB_ACT_END_OF_FILE;
1881 304 : yyrestart( yyin );
1882 : }
1883 :
1884 : else
1885 : {
1886 0 : ret_val = EOB_ACT_LAST_MATCH;
1887 0 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1888 : YY_BUFFER_EOF_PENDING;
1889 : }
1890 : }
1891 :
1892 : else
1893 450 : ret_val = EOB_ACT_CONTINUE_SCAN;
1894 :
1895 779 : if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1896 : /* Extend the array by 50%, plus the number we really need. */
1897 0 : int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1898 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1899 0 : (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1900 0 : if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1901 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1902 : /* "- 2" to take care of EOB's */
1903 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1904 : }
1905 :
1906 779 : (yy_n_chars) += number_to_move;
1907 779 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1908 779 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1909 :
1910 779 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1911 :
1912 779 : return ret_val;
1913 : }
1914 :
1915 : /* yy_get_previous_state - get the state just before the EOB char was reached */
1916 :
1917 418 : static yy_state_type yy_get_previous_state (void)
1918 : {
1919 22 : yy_state_type yy_current_state;
1920 22 : char *yy_cp;
1921 :
1922 418 : yy_current_state = (yy_start);
1923 :
1924 969 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1925 : {
1926 551 : YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1927 551 : if ( yy_accept[yy_current_state] )
1928 : {
1929 456 : (yy_last_accepting_state) = yy_current_state;
1930 456 : (yy_last_accepting_cpos) = yy_cp;
1931 : }
1932 988 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1933 : {
1934 437 : yy_current_state = (int) yy_def[yy_current_state];
1935 437 : if ( yy_current_state >= 574 )
1936 437 : yy_c = yy_meta[yy_c];
1937 : }
1938 551 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1939 : }
1940 :
1941 418 : return yy_current_state;
1942 : }
1943 :
1944 : /* yy_try_NUL_trans - try to make a transition on the NUL character
1945 : *
1946 : * synopsis
1947 : * next_state = yy_try_NUL_trans( current_state );
1948 : */
1949 0 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1950 : {
1951 0 : int yy_is_jam;
1952 0 : char *yy_cp = (yy_c_buf_p);
1953 :
1954 0 : YY_CHAR yy_c = 1;
1955 0 : if ( yy_accept[yy_current_state] )
1956 : {
1957 0 : (yy_last_accepting_state) = yy_current_state;
1958 0 : (yy_last_accepting_cpos) = yy_cp;
1959 : }
1960 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1961 : {
1962 0 : yy_current_state = (int) yy_def[yy_current_state];
1963 0 : if ( yy_current_state >= 574 )
1964 0 : yy_c = yy_meta[yy_c];
1965 : }
1966 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1967 0 : yy_is_jam = (yy_current_state == 573);
1968 :
1969 0 : return yy_is_jam ? 0 : yy_current_state;
1970 : }
1971 :
1972 : #ifndef YY_NO_UNPUT
1973 :
1974 0 : static void yyunput (int c, char * yy_bp )
1975 : {
1976 0 : char *yy_cp;
1977 :
1978 0 : yy_cp = (yy_c_buf_p);
1979 :
1980 : /* undo effects of setting up yytext */
1981 0 : *yy_cp = (yy_hold_char);
1982 :
1983 0 : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1984 : { /* need to shift things up to make room */
1985 : /* +2 for EOB chars. */
1986 0 : int number_to_move = (yy_n_chars) + 2;
1987 0 : char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1988 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1989 0 : char *source =
1990 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1991 :
1992 0 : while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1993 0 : *--dest = *--source;
1994 :
1995 0 : yy_cp += (int) (dest - source);
1996 0 : yy_bp += (int) (dest - source);
1997 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1998 0 : (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1999 :
2000 0 : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2001 0 : YY_FATAL_ERROR( "flex scanner push-back overflow" );
2002 : }
2003 :
2004 0 : *--yy_cp = (char) c;
2005 :
2006 0 : (yytext_ptr) = yy_bp;
2007 0 : (yy_hold_char) = *yy_cp;
2008 0 : (yy_c_buf_p) = yy_cp;
2009 0 : }
2010 :
2011 : #endif
2012 :
2013 : #ifndef YY_NO_INPUT
2014 : #ifdef __cplusplus
2015 : static int yyinput (void)
2016 : #else
2017 541481 : static int input (void)
2018 : #endif
2019 :
2020 : {
2021 28499 : int c;
2022 :
2023 541481 : *(yy_c_buf_p) = (yy_hold_char);
2024 :
2025 541481 : if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2026 : {
2027 : /* yy_c_buf_p now points to the character we want to return.
2028 : * If this occurs *before* the EOB characters, then it's a
2029 : * valid NUL; if not, then we've hit the end of the buffer.
2030 : */
2031 57 : if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2032 : /* This was really a NUL. */
2033 0 : *(yy_c_buf_p) = '\0';
2034 :
2035 : else
2036 : { /* need more input */
2037 57 : int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
2038 57 : ++(yy_c_buf_p);
2039 :
2040 57 : switch ( yy_get_next_buffer( ) )
2041 : {
2042 0 : case EOB_ACT_LAST_MATCH:
2043 : /* This happens because yy_g_n_b()
2044 : * sees that we've accumulated a
2045 : * token and flags that we need to
2046 : * try matching the token before
2047 : * proceeding. But for input(),
2048 : * there's no matching to consider.
2049 : * So convert the EOB_ACT_LAST_MATCH
2050 : * to EOB_ACT_END_OF_FILE.
2051 : */
2052 :
2053 : /* Reset buffer status. */
2054 0 : yyrestart( yyin );
2055 :
2056 : /*FALLTHROUGH*/
2057 :
2058 0 : case EOB_ACT_END_OF_FILE:
2059 : {
2060 0 : if ( yywrap( ) )
2061 0 : return 0;
2062 :
2063 0 : if ( ! (yy_did_buffer_switch_on_eof) )
2064 0 : YY_NEW_FILE;
2065 : #ifdef __cplusplus
2066 : return yyinput();
2067 : #else
2068 0 : return input();
2069 : #endif
2070 : }
2071 :
2072 57 : case EOB_ACT_CONTINUE_SCAN:
2073 57 : (yy_c_buf_p) = (yytext_ptr) + offset;
2074 57 : break;
2075 : }
2076 : }
2077 : }
2078 :
2079 541481 : c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2080 541481 : *(yy_c_buf_p) = '\0'; /* preserve yytext */
2081 541481 : (yy_hold_char) = *++(yy_c_buf_p);
2082 :
2083 541481 : return c;
2084 : }
2085 : #endif /* ifndef YY_NO_INPUT */
2086 :
2087 : /** Immediately switch to a different input stream.
2088 : * @param input_file A readable stream.
2089 : *
2090 : * @note This function does not reset the start condition to @c INITIAL .
2091 : */
2092 304 : void yyrestart (FILE * input_file )
2093 : {
2094 :
2095 304 : if ( ! YY_CURRENT_BUFFER ){
2096 0 : yyensure_buffer_stack ();
2097 0 : YY_CURRENT_BUFFER_LVALUE =
2098 0 : yy_create_buffer( yyin, YY_BUF_SIZE );
2099 : }
2100 :
2101 304 : yy_init_buffer( YY_CURRENT_BUFFER, input_file );
2102 304 : yy_load_buffer_state( );
2103 304 : }
2104 :
2105 : /** Switch to a different input buffer.
2106 : * @param new_buffer The new input buffer.
2107 : *
2108 : */
2109 0 : void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
2110 : {
2111 :
2112 : /* TODO. We should be able to replace this entire function body
2113 : * with
2114 : * yypop_buffer_state();
2115 : * yypush_buffer_state(new_buffer);
2116 : */
2117 0 : yyensure_buffer_stack ();
2118 0 : if ( YY_CURRENT_BUFFER == new_buffer )
2119 0 : return;
2120 :
2121 0 : if ( YY_CURRENT_BUFFER )
2122 : {
2123 : /* Flush out information for old buffer. */
2124 0 : *(yy_c_buf_p) = (yy_hold_char);
2125 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2126 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2127 : }
2128 :
2129 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
2130 0 : yy_load_buffer_state( );
2131 :
2132 : /* We don't actually know whether we did this switch during
2133 : * EOF (yywrap()) processing, but the only time this flag
2134 : * is looked at is after yywrap() is called, so it's safe
2135 : * to go ahead and always set it.
2136 : */
2137 0 : (yy_did_buffer_switch_on_eof) = 1;
2138 : }
2139 :
2140 912 : static void yy_load_buffer_state (void)
2141 : {
2142 912 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2143 912 : (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2144 912 : yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2145 864 : (yy_hold_char) = *(yy_c_buf_p);
2146 880 : }
2147 :
2148 : /** Allocate and initialize an input buffer state.
2149 : * @param file A readable stream.
2150 : * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2151 : *
2152 : * @return the allocated buffer state.
2153 : */
2154 304 : YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
2155 : {
2156 16 : YY_BUFFER_STATE b;
2157 :
2158 304 : b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
2159 304 : if ( ! b )
2160 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2161 :
2162 304 : b->yy_buf_size = size;
2163 :
2164 : /* yy_ch_buf has to be 2 characters longer than the size given because
2165 : * we need to put in 2 end-of-buffer characters.
2166 : */
2167 304 : b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
2168 304 : if ( ! b->yy_ch_buf )
2169 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2170 :
2171 304 : b->yy_is_our_buffer = 1;
2172 :
2173 304 : yy_init_buffer( b, file );
2174 :
2175 304 : return b;
2176 : }
2177 :
2178 : /** Destroy the buffer.
2179 : * @param b a buffer created with yy_create_buffer()
2180 : *
2181 : */
2182 0 : void yy_delete_buffer (YY_BUFFER_STATE b )
2183 : {
2184 :
2185 0 : if ( ! b )
2186 0 : return;
2187 :
2188 0 : if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2189 0 : YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2190 :
2191 0 : if ( b->yy_is_our_buffer )
2192 0 : yyfree( (void *) b->yy_ch_buf );
2193 :
2194 0 : yyfree( (void *) b );
2195 : }
2196 :
2197 : /* Initializes or reinitializes a buffer.
2198 : * This function is sometimes called more than once on the same buffer,
2199 : * such as during a yyrestart() or at EOF.
2200 : */
2201 608 : static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
2202 :
2203 : {
2204 608 : int oerrno = errno;
2205 :
2206 608 : yy_flush_buffer( b );
2207 :
2208 608 : b->yy_input_file = file;
2209 608 : b->yy_fill_buffer = 1;
2210 :
2211 : /* If b is the current buffer, then yy_init_buffer was _probably_
2212 : * called from yyrestart() or through yy_get_next_buffer.
2213 : * In that case, we don't want to reset the lineno or column.
2214 : */
2215 608 : if (b != YY_CURRENT_BUFFER){
2216 304 : b->yy_bs_lineno = 1;
2217 304 : b->yy_bs_column = 0;
2218 : }
2219 :
2220 608 : b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2221 :
2222 608 : errno = oerrno;
2223 608 : }
2224 :
2225 : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2226 : * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2227 : *
2228 : */
2229 608 : void yy_flush_buffer (YY_BUFFER_STATE b )
2230 : {
2231 608 : if ( ! b )
2232 0 : return;
2233 :
2234 608 : b->yy_n_chars = 0;
2235 :
2236 : /* We always need two end-of-buffer characters. The first causes
2237 : * a transition to the end-of-buffer state. The second causes
2238 : * a jam in that state.
2239 : */
2240 608 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2241 608 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2242 :
2243 608 : b->yy_buf_pos = &b->yy_ch_buf[0];
2244 :
2245 608 : b->yy_at_bol = 1;
2246 608 : b->yy_buffer_status = YY_BUFFER_NEW;
2247 :
2248 608 : if ( b == YY_CURRENT_BUFFER )
2249 304 : yy_load_buffer_state( );
2250 : }
2251 :
2252 : /** Pushes the new state onto the stack. The new state becomes
2253 : * the current state. This function will allocate the stack
2254 : * if necessary.
2255 : * @param new_buffer The new state.
2256 : *
2257 : */
2258 0 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2259 : {
2260 0 : if (new_buffer == NULL)
2261 0 : return;
2262 :
2263 0 : yyensure_buffer_stack();
2264 :
2265 : /* This block is copied from yy_switch_to_buffer. */
2266 0 : if ( YY_CURRENT_BUFFER )
2267 : {
2268 : /* Flush out information for old buffer. */
2269 0 : *(yy_c_buf_p) = (yy_hold_char);
2270 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2271 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2272 : }
2273 :
2274 : /* Only push if top exists. Otherwise, replace top. */
2275 0 : if (YY_CURRENT_BUFFER)
2276 0 : (yy_buffer_stack_top)++;
2277 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
2278 :
2279 : /* copied from yy_switch_to_buffer. */
2280 0 : yy_load_buffer_state( );
2281 0 : (yy_did_buffer_switch_on_eof) = 1;
2282 : }
2283 :
2284 : /** Removes and deletes the top of the stack, if present.
2285 : * The next element becomes the new top.
2286 : *
2287 : */
2288 0 : void yypop_buffer_state (void)
2289 : {
2290 0 : if (!YY_CURRENT_BUFFER)
2291 0 : return;
2292 :
2293 0 : yy_delete_buffer(YY_CURRENT_BUFFER );
2294 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2295 0 : if ((yy_buffer_stack_top) > 0)
2296 0 : --(yy_buffer_stack_top);
2297 :
2298 0 : if (YY_CURRENT_BUFFER) {
2299 0 : yy_load_buffer_state( );
2300 0 : (yy_did_buffer_switch_on_eof) = 1;
2301 : }
2302 : }
2303 :
2304 : /* Allocates the stack if it does not exist.
2305 : * Guarantees space for at least one push.
2306 : */
2307 304 : static void yyensure_buffer_stack (void)
2308 : {
2309 16 : yy_size_t num_to_alloc;
2310 :
2311 304 : if (!(yy_buffer_stack)) {
2312 :
2313 : /* First allocation is just for 2 elements, since we don't know if this
2314 : * scanner will even need a stack. We use 2 instead of 1 to avoid an
2315 : * immediate realloc on the next call.
2316 : */
2317 304 : num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2318 304 : (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2319 : (num_to_alloc * sizeof(struct yy_buffer_state*)
2320 : );
2321 304 : if ( ! (yy_buffer_stack) )
2322 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2323 :
2324 304 : memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2325 :
2326 304 : (yy_buffer_stack_max) = num_to_alloc;
2327 304 : (yy_buffer_stack_top) = 0;
2328 304 : return;
2329 : }
2330 :
2331 0 : if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2332 :
2333 : /* Increase the buffer to prepare for a possible push. */
2334 0 : yy_size_t grow_size = 8 /* arbitrary grow size */;
2335 :
2336 0 : num_to_alloc = (yy_buffer_stack_max) + grow_size;
2337 0 : (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2338 : ((yy_buffer_stack),
2339 : num_to_alloc * sizeof(struct yy_buffer_state*)
2340 : );
2341 0 : if ( ! (yy_buffer_stack) )
2342 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2343 :
2344 : /* zero only the new slots.*/
2345 0 : memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2346 0 : (yy_buffer_stack_max) = num_to_alloc;
2347 : }
2348 : }
2349 :
2350 : /** Setup the input buffer state to scan directly from a user-specified character buffer.
2351 : * @param base the character buffer
2352 : * @param size the size in bytes of the character buffer
2353 : *
2354 : * @return the newly allocated buffer state object.
2355 : */
2356 0 : YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
2357 : {
2358 0 : YY_BUFFER_STATE b;
2359 :
2360 0 : if ( size < 2 ||
2361 0 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
2362 0 : base[size-1] != YY_END_OF_BUFFER_CHAR )
2363 : /* They forgot to leave room for the EOB's. */
2364 0 : return NULL;
2365 :
2366 0 : b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
2367 0 : if ( ! b )
2368 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2369 :
2370 0 : b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
2371 0 : b->yy_buf_pos = b->yy_ch_buf = base;
2372 0 : b->yy_is_our_buffer = 0;
2373 0 : b->yy_input_file = NULL;
2374 0 : b->yy_n_chars = b->yy_buf_size;
2375 0 : b->yy_is_interactive = 0;
2376 0 : b->yy_at_bol = 1;
2377 0 : b->yy_fill_buffer = 0;
2378 0 : b->yy_buffer_status = YY_BUFFER_NEW;
2379 :
2380 0 : yy_switch_to_buffer( b );
2381 :
2382 0 : return b;
2383 : }
2384 :
2385 : /** Setup the input buffer state to scan a string. The next call to yylex() will
2386 : * scan from a @e copy of @a str.
2387 : * @param yystr a NUL-terminated string to scan
2388 : *
2389 : * @return the newly allocated buffer state object.
2390 : * @note If you want to scan bytes that may contain NUL values, then use
2391 : * yy_scan_bytes() instead.
2392 : */
2393 0 : YY_BUFFER_STATE yy_scan_string (const char * yystr )
2394 : {
2395 :
2396 0 : return yy_scan_bytes( yystr, (int) strlen(yystr) );
2397 : }
2398 :
2399 : /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2400 : * scan from a @e copy of @a bytes.
2401 : * @param yybytes the byte buffer to scan
2402 : * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2403 : *
2404 : * @return the newly allocated buffer state object.
2405 : */
2406 0 : YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
2407 : {
2408 0 : YY_BUFFER_STATE b;
2409 0 : char *buf;
2410 0 : yy_size_t n;
2411 0 : int i;
2412 :
2413 : /* Get memory for full buffer, including space for trailing EOB's. */
2414 0 : n = (yy_size_t) (_yybytes_len + 2);
2415 0 : buf = (char *) yyalloc( n );
2416 0 : if ( ! buf )
2417 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2418 :
2419 0 : for ( i = 0; i < _yybytes_len; ++i )
2420 0 : buf[i] = yybytes[i];
2421 :
2422 0 : buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2423 :
2424 0 : b = yy_scan_buffer( buf, n );
2425 0 : if ( ! b )
2426 0 : YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2427 :
2428 : /* It's okay to grow etc. this buffer, and we should throw it
2429 : * away when we're done.
2430 : */
2431 0 : b->yy_is_our_buffer = 1;
2432 :
2433 0 : return b;
2434 : }
2435 :
2436 : #ifndef YY_EXIT_FAILURE
2437 : #define YY_EXIT_FAILURE 2
2438 : #endif
2439 :
2440 0 : static void yynoreturn yy_fatal_error (const char* msg )
2441 : {
2442 0 : fprintf( stderr, "%s\n", msg );
2443 0 : exit( YY_EXIT_FAILURE );
2444 : }
2445 :
2446 : /* Redefine yyless() so it works in section 3 code. */
2447 :
2448 : #undef yyless
2449 : #define yyless(n) \
2450 : do \
2451 : { \
2452 : /* Undo effects of setting up yytext. */ \
2453 : int yyless_macro_arg = (n); \
2454 : YY_LESS_LINENO(yyless_macro_arg);\
2455 : yytext[yyleng] = (yy_hold_char); \
2456 : (yy_c_buf_p) = yytext + yyless_macro_arg; \
2457 : (yy_hold_char) = *(yy_c_buf_p); \
2458 : *(yy_c_buf_p) = '\0'; \
2459 : yyleng = yyless_macro_arg; \
2460 : } \
2461 : while ( 0 )
2462 :
2463 : /* Accessor methods (get/set functions) to struct members. */
2464 :
2465 : /** Get the current line number.
2466 : *
2467 : */
2468 0 : int yyget_lineno (void)
2469 : {
2470 :
2471 0 : return yylineno;
2472 : }
2473 :
2474 : /** Get the input stream.
2475 : *
2476 : */
2477 0 : FILE *yyget_in (void)
2478 : {
2479 0 : return yyin;
2480 : }
2481 :
2482 : /** Get the output stream.
2483 : *
2484 : */
2485 0 : FILE *yyget_out (void)
2486 : {
2487 0 : return yyout;
2488 : }
2489 :
2490 : /** Get the length of the current token.
2491 : *
2492 : */
2493 0 : int yyget_leng (void)
2494 : {
2495 0 : return yyleng;
2496 : }
2497 :
2498 : /** Get the current token.
2499 : *
2500 : */
2501 :
2502 0 : char *yyget_text (void)
2503 : {
2504 0 : return yytext;
2505 : }
2506 :
2507 : /** Set the current line number.
2508 : * @param _line_number line number
2509 : *
2510 : */
2511 0 : void yyset_lineno (int _line_number )
2512 : {
2513 :
2514 0 : yylineno = _line_number;
2515 0 : }
2516 :
2517 : /** Set the input stream. This does not discard the current
2518 : * input buffer.
2519 : * @param _in_str A readable stream.
2520 : *
2521 : * @see yy_switch_to_buffer
2522 : */
2523 0 : void yyset_in (FILE * _in_str )
2524 : {
2525 0 : yyin = _in_str ;
2526 0 : }
2527 :
2528 0 : void yyset_out (FILE * _out_str )
2529 : {
2530 0 : yyout = _out_str ;
2531 0 : }
2532 :
2533 0 : int yyget_debug (void)
2534 : {
2535 0 : return yy_flex_debug;
2536 : }
2537 :
2538 0 : void yyset_debug (int _bdebug )
2539 : {
2540 0 : yy_flex_debug = _bdebug ;
2541 0 : }
2542 :
2543 0 : static int yy_init_globals (void)
2544 : {
2545 : /* Initialization is the same as for the non-reentrant scanner.
2546 : * This function is called from yylex_destroy(), so don't allocate here.
2547 : */
2548 :
2549 0 : (yy_buffer_stack) = NULL;
2550 0 : (yy_buffer_stack_top) = 0;
2551 0 : (yy_buffer_stack_max) = 0;
2552 0 : (yy_c_buf_p) = NULL;
2553 0 : (yy_init) = 0;
2554 0 : (yy_start) = 0;
2555 :
2556 : /* Defined in main.c */
2557 : #ifdef YY_STDINIT
2558 : yyin = stdin;
2559 : yyout = stdout;
2560 : #else
2561 0 : yyin = NULL;
2562 0 : yyout = NULL;
2563 : #endif
2564 :
2565 : /* For future reference: Set errno on error, since we are called by
2566 : * yylex_init()
2567 : */
2568 0 : return 0;
2569 : }
2570 :
2571 : /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2572 0 : int yylex_destroy (void)
2573 : {
2574 :
2575 : /* Pop the buffer stack, destroying each element. */
2576 0 : while(YY_CURRENT_BUFFER){
2577 0 : yy_delete_buffer( YY_CURRENT_BUFFER );
2578 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2579 0 : yypop_buffer_state();
2580 : }
2581 :
2582 : /* Destroy the stack itself. */
2583 0 : yyfree((yy_buffer_stack) );
2584 0 : (yy_buffer_stack) = NULL;
2585 :
2586 : /* Reset the globals. This is important in a non-reentrant scanner so the next time
2587 : * yylex() is called, initialization will occur. */
2588 0 : yy_init_globals( );
2589 :
2590 0 : return 0;
2591 : }
2592 :
2593 : /*
2594 : * Internal utility routines.
2595 : */
2596 :
2597 : #ifndef yytext_ptr
2598 : static void yy_flex_strncpy (char* s1, const char * s2, int n )
2599 : {
2600 :
2601 : int i;
2602 : for ( i = 0; i < n; ++i )
2603 : s1[i] = s2[i];
2604 : }
2605 : #endif
2606 :
2607 : #ifdef YY_NEED_STRLEN
2608 : static int yy_flex_strlen (const char * s )
2609 : {
2610 : int n;
2611 : for ( n = 0; s[n]; ++n )
2612 : ;
2613 :
2614 : return n;
2615 : }
2616 : #endif
2617 :
2618 912 : void *yyalloc (yy_size_t size )
2619 : {
2620 912 : return malloc(size);
2621 : }
2622 :
2623 0 : void *yyrealloc (void * ptr, yy_size_t size )
2624 : {
2625 :
2626 : /* The cast to (char *) in the following accommodates both
2627 : * implementations that use char* generic pointers, and those
2628 : * that use void* generic pointers. It works with the latter
2629 : * because both ANSI C and C++ allow castless assignment from
2630 : * any pointer type to void*, and deal with argument conversions
2631 : * as though doing an assignment.
2632 : */
2633 0 : return realloc(ptr, size);
2634 : }
2635 :
2636 0 : void yyfree (void * ptr )
2637 : {
2638 0 : free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2639 0 : }
2640 :
2641 : #define YYTABLES_NAME "yytables"
2642 :
2643 : int
2644 304 : yywrap ()
2645 : {
2646 304 : return 1;
2647 : }
2648 :
2649 : void
2650 0 : lex_error_message (const char *format, ...)
2651 : {
2652 0 : va_list args;
2653 :
2654 0 : va_start (args, format);
2655 0 : fprintf (stderr, "%s:%d: ", get_filename(), lineno);
2656 0 : vfprintf (stderr, format, args);
2657 0 : va_end (args);
2658 0 : error_flag++;
2659 0 : }
2660 :
2661 : static void
2662 0 : unterminated(const char *type, unsigned start_lineno)
2663 : {
2664 0 : lex_error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
2665 0 : }
2666 :
|
