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