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