1 :
2 : #line 3 "lex.yy.c"
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 33
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 __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 : #if __STDC__
97 :
98 : #define YY_USE_CONST
99 :
100 : #endif /* __STDC__ */
101 : #endif /* ! __cplusplus */
102 :
103 : #ifdef YY_USE_CONST
104 : #define yyconst const
105 : #else
106 : #define yyconst
107 : #endif
108 :
109 : /* Returned upon end-of-file. */
110 : #define YY_NULL 0
111 :
112 : /* Promotes a possibly negative, possibly signed char to an unsigned
113 : * integer for use as an array index. If the signed char is negative,
114 : * we want to instead treat it as an 8-bit unsigned char, hence the
115 : * double cast.
116 : */
117 : #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
118 :
119 : /* Enter a start condition. This macro really ought to take a parameter,
120 : * but we do it the disgusting crufty way forced on us by the ()-less
121 : * definition of BEGIN.
122 : */
123 : #define BEGIN (yy_start) = 1 + 2 *
124 :
125 : /* Translate the current start state into a value that can be later handed
126 : * to BEGIN to return to the state. The YYSTATE alias is for lex
127 : * compatibility.
128 : */
129 : #define YY_START (((yy_start) - 1) / 2)
130 : #define YYSTATE YY_START
131 :
132 : /* Action number for EOF rule of a given start state. */
133 : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
134 :
135 : /* Special action meaning "start processing a new file". */
136 : #define YY_NEW_FILE yyrestart(yyin )
137 :
138 : #define YY_END_OF_BUFFER_CHAR 0
139 :
140 : /* Size of default input buffer. */
141 : #ifndef YY_BUF_SIZE
142 : #define YY_BUF_SIZE 16384
143 : #endif
144 :
145 : /* The state buf must be large enough to hold one state per character in the main buffer.
146 : */
147 : #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
148 :
149 : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
150 : #define YY_TYPEDEF_YY_BUFFER_STATE
151 : typedef struct yy_buffer_state *YY_BUFFER_STATE;
152 : #endif
153 :
154 : extern int yyleng;
155 :
156 : extern FILE *yyin, *yyout;
157 :
158 : #define EOB_ACT_CONTINUE_SCAN 0
159 : #define EOB_ACT_END_OF_FILE 1
160 : #define EOB_ACT_LAST_MATCH 2
161 :
162 : #define YY_LESS_LINENO(n)
163 :
164 : /* Return all but the first "n" matched characters back to the input stream. */
165 : #define yyless(n) \
166 : do \
167 : { \
168 : /* Undo effects of setting up yytext. */ \
169 : int yyless_macro_arg = (n); \
170 : YY_LESS_LINENO(yyless_macro_arg);\
171 : *yy_cp = (yy_hold_char); \
172 : YY_RESTORE_YY_MORE_OFFSET \
173 : (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
174 : YY_DO_BEFORE_ACTION; /* set up yytext again */ \
175 : } \
176 : while ( 0 )
177 :
178 : #define unput(c) yyunput( c, (yytext_ptr) )
179 :
180 : /* The following is because we cannot portably get our hands on size_t
181 : * (without autoconf's help, which isn't available because we want
182 : * flex-generated scanners to compile on their own).
183 : */
184 :
185 : #ifndef YY_TYPEDEF_YY_SIZE_T
186 : #define YY_TYPEDEF_YY_SIZE_T
187 : typedef unsigned int yy_size_t;
188 : #endif
189 :
190 : #ifndef YY_STRUCT_YY_BUFFER_STATE
191 : #define YY_STRUCT_YY_BUFFER_STATE
192 : struct yy_buffer_state
193 : {
194 : FILE *yy_input_file;
195 :
196 : char *yy_ch_buf; /* input buffer */
197 : char *yy_buf_pos; /* current position in input buffer */
198 :
199 : /* Size of input buffer in bytes, not including room for EOB
200 : * characters.
201 : */
202 : yy_size_t yy_buf_size;
203 :
204 : /* Number of characters read into yy_ch_buf, not including EOB
205 : * characters.
206 : */
207 : int yy_n_chars;
208 :
209 : /* Whether we "own" the buffer - i.e., we know we created it,
210 : * and can realloc() it to grow it, and should free() it to
211 : * delete it.
212 : */
213 : int yy_is_our_buffer;
214 :
215 : /* Whether this is an "interactive" input source; if so, and
216 : * if we're using stdio for input, then we want to use getc()
217 : * instead of fread(), to make sure we stop fetching input after
218 : * each newline.
219 : */
220 : int yy_is_interactive;
221 :
222 : /* Whether we're considered to be at the beginning of a line.
223 : * If so, '^' rules will be active on the next match, otherwise
224 : * not.
225 : */
226 : int yy_at_bol;
227 :
228 : int yy_bs_lineno; /**< The line count. */
229 : int yy_bs_column; /**< The column count. */
230 :
231 : /* Whether to try to fill the input buffer when we reach the
232 : * end of it.
233 : */
234 : int yy_fill_buffer;
235 :
236 : int yy_buffer_status;
237 :
238 : #define YY_BUFFER_NEW 0
239 : #define YY_BUFFER_NORMAL 1
240 : /* When an EOF's been seen but there's still some text to process
241 : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
242 : * shouldn't try reading from the input source any more. We might
243 : * still have a bunch of tokens to match, though, because of
244 : * possible backing-up.
245 : *
246 : * When we actually see the EOF, we change the status to "new"
247 : * (via yyrestart()), so that the user can continue scanning by
248 : * just pointing yyin at a new input file.
249 : */
250 : #define YY_BUFFER_EOF_PENDING 2
251 :
252 : };
253 : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
254 :
255 : /* Stack of input buffers. */
256 : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
257 : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
258 : static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
259 :
260 : /* We provide macros for accessing buffer states in case in the
261 : * future we want to put the buffer states in a more general
262 : * "scanner state".
263 : *
264 : * Returns the top of the stack, or NULL.
265 : */
266 : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
267 : ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
268 : : NULL)
269 :
270 : /* Same as previous macro, but useful when we know that the buffer stack is not
271 : * NULL or when we need an lvalue. For internal use only.
272 : */
273 : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
274 :
275 : /* yy_hold_char holds the character lost when yytext is formed. */
276 : static char yy_hold_char;
277 : static int yy_n_chars; /* number of characters read into yy_ch_buf */
278 : int yyleng;
279 :
280 : /* Points to current character in buffer. */
281 : static char *yy_c_buf_p = (char *) 0;
282 : static int yy_init = 0; /* whether we need to initialize */
283 : static int yy_start = 0; /* start state number */
284 :
285 : /* Flag which is used to allow yywrap()'s to do buffer switches
286 : * instead of setting up a fresh yyin. A bit of a hack ...
287 : */
288 : static int yy_did_buffer_switch_on_eof;
289 :
290 : void yyrestart (FILE *input_file );
291 : void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
292 : YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
293 : void yy_delete_buffer (YY_BUFFER_STATE b );
294 : void yy_flush_buffer (YY_BUFFER_STATE b );
295 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
296 : void yypop_buffer_state (void );
297 :
298 : static void yyensure_buffer_stack (void );
299 : static void yy_load_buffer_state (void );
300 : static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
301 :
302 : #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
303 :
304 : YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
305 : YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
306 : YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len );
307 :
308 : void *yyalloc (yy_size_t );
309 : void *yyrealloc (void *,yy_size_t );
310 : void yyfree (void * );
311 :
312 : #define yy_new_buffer yy_create_buffer
313 :
314 : #define yy_set_interactive(is_interactive) \
315 : { \
316 : if ( ! YY_CURRENT_BUFFER ){ \
317 : yyensure_buffer_stack (); \
318 : YY_CURRENT_BUFFER_LVALUE = \
319 : yy_create_buffer(yyin,YY_BUF_SIZE ); \
320 : } \
321 : YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
322 : }
323 :
324 : #define yy_set_bol(at_bol) \
325 : { \
326 : if ( ! YY_CURRENT_BUFFER ){\
327 : yyensure_buffer_stack (); \
328 : YY_CURRENT_BUFFER_LVALUE = \
329 : yy_create_buffer(yyin,YY_BUF_SIZE ); \
330 : } \
331 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
332 : }
333 :
334 : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
335 :
336 : /* Begin user sect3 */
337 :
338 : typedef unsigned char YY_CHAR;
339 :
340 : FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
341 :
342 : typedef int yy_state_type;
343 :
344 : extern int yylineno;
345 :
346 : int yylineno = 1;
347 :
348 : extern char *yytext;
349 : #define yytext_ptr yytext
350 :
351 : static yy_state_type yy_get_previous_state (void );
352 : static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
353 : static int yy_get_next_buffer (void );
354 : static void yy_fatal_error (yyconst char msg[] );
355 :
356 : /* Done after the current pattern has been matched and before the
357 : * corresponding action - sets up yytext.
358 : */
359 : #define YY_DO_BEFORE_ACTION \
360 : (yytext_ptr) = yy_bp; \
361 : yyleng = (size_t) (yy_cp - yy_bp); \
362 : (yy_hold_char) = *yy_cp; \
363 : *yy_cp = '\0'; \
364 : (yy_c_buf_p) = yy_cp;
365 :
366 : #define YY_NUM_RULES 33
367 : #define YY_END_OF_BUFFER 34
368 : /* This struct is not used in this scanner,
369 : but its presence is necessary. */
370 : struct yy_trans_info
371 : {
372 : flex_int32_t yy_verify;
373 : flex_int32_t yy_nxt;
374 : };
375 : static yyconst flex_int16_t yy_accept[107] =
376 : { 0,
377 : 0, 0, 34, 32, 2, 32, 32, 4, 5, 21,
378 : 31, 26, 27, 25, 24, 30, 23, 29, 28, 6,
379 : 32, 7, 31, 31, 31, 31, 31, 31, 31, 31,
380 : 31, 31, 0, 22, 0, 0, 1, 21, 31, 3,
381 : 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
382 : 31, 31, 31, 31, 31, 31, 31, 31, 8, 31,
383 : 18, 31, 31, 31, 31, 31, 31, 31, 31, 31,
384 : 31, 31, 31, 31, 17, 31, 14, 31, 31, 31,
385 : 31, 31, 20, 13, 31, 31, 31, 31, 11, 15,
386 : 31, 31, 9, 31, 10, 31, 31, 31, 12, 31,
387 :
388 : 31, 31, 16, 31, 19, 0
389 : } ;
390 :
391 : static yyconst flex_int32_t yy_ec[256] =
392 : { 0,
393 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
394 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396 : 1, 1, 1, 3, 4, 1, 1, 1, 1, 5,
397 : 6, 1, 1, 1, 1, 1, 1, 7, 7, 7,
398 : 7, 7, 7, 7, 7, 7, 7, 1, 1, 1,
399 : 1, 1, 1, 1, 8, 9, 10, 8, 8, 8,
400 : 8, 8, 11, 8, 12, 8, 13, 8, 8, 8,
401 : 8, 8, 14, 15, 8, 8, 16, 8, 8, 8,
402 : 17, 18, 19, 1, 20, 1, 21, 22, 23, 24,
403 :
404 : 25, 26, 27, 8, 28, 8, 29, 30, 31, 32,
405 : 33, 34, 8, 35, 36, 37, 38, 8, 8, 8,
406 : 39, 40, 1, 1, 1, 1, 1, 1, 1, 1,
407 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
410 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
414 :
415 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
416 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
419 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420 : 1, 1, 1, 1, 1
421 : } ;
422 :
423 : static yyconst flex_int32_t yy_meta[41] =
424 : { 0,
425 : 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
426 : 2, 2, 2, 2, 2, 2, 1, 1, 1, 2,
427 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
429 : } ;
430 :
431 : static yyconst flex_int16_t yy_base[110] =
432 : { 0,
433 : 0, 0, 125, 126, 126, 38, 122, 126, 126, 116,
434 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 126,
435 : 120, 126, 99, 83, 9, 94, 88, 82, 83, 90,
436 : 77, 15, 41, 126, 111, 110, 126, 104, 0, 126,
437 : 74, 78, 70, 72, 23, 85, 65, 83, 79, 77,
438 : 70, 25, 65, 62, 69, 65, 61, 57, 66, 71,
439 : 0, 68, 53, 56, 64, 65, 56, 54, 50, 47,
440 : 44, 55, 49, 47, 0, 56, 0, 19, 53, 43,
441 : 51, 54, 0, 0, 49, 38, 47, 33, 0, 0,
442 : 35, 46, 0, 47, 0, 30, 29, 28, 0, 36,
443 :
444 : 32, 22, 0, 19, 0, 126, 59, 61, 46
445 : } ;
446 :
447 : static yyconst flex_int16_t yy_def[110] =
448 : { 0,
449 : 106, 1, 106, 106, 106, 107, 108, 106, 106, 106,
450 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 106,
451 : 106, 106, 109, 109, 109, 109, 109, 109, 109, 109,
452 : 109, 109, 107, 106, 107, 108, 106, 106, 109, 106,
453 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
454 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
455 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
456 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
457 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
458 : 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
459 :
460 : 109, 109, 109, 109, 109, 0, 106, 106, 106
461 : } ;
462 :
463 : static yyconst flex_int16_t yy_nxt[167] =
464 : { 0,
465 : 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
466 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 4,
467 : 23, 24, 25, 26, 27, 11, 28, 11, 11, 29,
468 : 11, 11, 11, 11, 30, 31, 32, 11, 11, 11,
469 : 34, 43, 51, 34, 58, 66, 44, 39, 59, 52,
470 : 105, 88, 53, 89, 104, 35, 103, 67, 35, 33,
471 : 33, 36, 36, 102, 101, 100, 99, 98, 97, 61,
472 : 96, 95, 94, 93, 92, 91, 61, 90, 87, 86,
473 : 85, 84, 61, 83, 82, 81, 80, 79, 78, 77,
474 : 76, 75, 74, 73, 72, 71, 70, 61, 69, 68,
475 :
476 : 65, 64, 63, 62, 61, 60, 57, 56, 55, 54,
477 : 38, 37, 106, 50, 49, 48, 47, 46, 45, 42,
478 : 41, 40, 38, 37, 106, 3, 106, 106, 106, 106,
479 : 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
480 : 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
481 : 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
482 : 106, 106, 106, 106, 106, 106
483 : } ;
484 :
485 : static yyconst flex_int16_t yy_chk[167] =
486 : { 0,
487 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
488 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
489 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
490 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
491 : 6, 25, 32, 33, 45, 52, 25, 109, 45, 32,
492 : 104, 78, 32, 78, 102, 6, 101, 52, 33, 107,
493 : 107, 108, 108, 100, 98, 97, 96, 94, 92, 91,
494 : 88, 87, 86, 85, 82, 81, 80, 79, 76, 74,
495 : 73, 72, 71, 70, 69, 68, 67, 66, 65, 64,
496 : 63, 62, 60, 59, 58, 57, 56, 55, 54, 53,
497 :
498 : 51, 50, 49, 48, 47, 46, 44, 43, 42, 41,
499 : 38, 36, 35, 31, 30, 29, 28, 27, 26, 24,
500 : 23, 21, 10, 7, 3, 106, 106, 106, 106, 106,
501 : 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
502 : 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
503 : 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
504 : 106, 106, 106, 106, 106, 106
505 : } ;
506 :
507 : static yy_state_type yy_last_accepting_state;
508 : static char *yy_last_accepting_cpos;
509 :
510 : extern int yy_flex_debug;
511 : int yy_flex_debug = 0;
512 :
513 : /* The intent behind this definition is that it'll catch
514 : * any uses of REJECT which flex missed.
515 : */
516 : #define REJECT reject_used_but_not_detected
517 : #define yymore() yymore_used_but_not_detected
518 : #define YY_MORE_ADJ 0
519 : #define YY_RESTORE_YY_MORE_OFFSET
520 : char *yytext;
521 : #line 1 "lex.l"
522 : #line 2 "lex.l"
523 : /*
524 : Copyright (C) 2007, Bruce Ediger
525 :
526 : This file is part of cl.
527 :
528 : cl is free software; you can redistribute it and/or modify
529 : it under the terms of the GNU General Public License as published by
530 : the Free Software Foundation; either version 2 of the License, or
531 : (at your option) any later version.
532 :
533 : cl is distributed in the hope that it will be useful,
534 : but WITHOUT ANY WARRANTY; without even the implied warranty of
535 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
536 : GNU General Public License for more details.
537 :
538 : You should have received a copy of the GNU General Public License
539 : along with cl; if not, write to the Free Software
540 : Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
541 :
542 : */
543 :
544 : #include <stdio.h>
545 : #include <stdlib.h>
546 : #include <errno.h> /* errno */
547 : #include <string.h> /* strlen(), strerror() */
548 :
549 : #include <hashtable.h>
550 : #include <atom.h>
551 : #include <node.h>
552 :
553 : #include "y.tab.h"
554 : int lineno = 0;
555 :
556 : const char *current_input_stream;
557 :
558 : char *unescape_string(char *s);
559 : void push_and_open(const char *filename);
560 :
561 : struct stream_node {
562 : #ifdef FLEX_SCANNER
563 : YY_BUFFER_STATE stream;
564 : #else
565 : FILE *stream;
566 : #endif
567 : struct stream_node *next;
568 : const char *old_filename;
569 : int old_lineno;
570 : };
571 :
572 : struct stream_node *file_stack = NULL;
573 :
574 : void set_yyin_stdin(void);
575 :
576 : extern int S_as_combinator;
577 : extern int K_as_combinator;
578 : extern int I_as_combinator;
579 : extern int B_as_combinator;
580 : extern int C_as_combinator;
581 : extern int W_as_combinator;
582 : extern int T_as_combinator;
583 : extern int M_as_combinator;
584 :
585 : extern int prompting;
586 : int old_prompting = -1;
587 :
588 :
589 : #line 590 "lex.yy.c"
590 :
591 : #define INITIAL 0
592 :
593 : #ifndef YY_NO_UNISTD_H
594 : /* Special case for "unistd.h", since it is non-ANSI. We include it way
595 : * down here because we want the user's section 1 to have been scanned first.
596 : * The user has a chance to override it with an option.
597 : */
598 : #include <unistd.h>
599 : #endif
600 :
601 : #ifndef YY_EXTRA_TYPE
602 : #define YY_EXTRA_TYPE void *
603 : #endif
604 :
605 : static int yy_init_globals (void );
606 :
607 : /* Macros after this point can all be overridden by user definitions in
608 : * section 1.
609 : */
610 :
611 : #ifndef YY_SKIP_YYWRAP
612 : #ifdef __cplusplus
613 : extern "C" int yywrap (void );
614 : #else
615 : extern int yywrap (void );
616 : #endif
617 : #endif
618 :
619 : static void yyunput (int c,char *buf_ptr );
620 :
621 : #ifndef yytext_ptr
622 : static void yy_flex_strncpy (char *,yyconst char *,int );
623 : #endif
624 :
625 : #ifdef YY_NEED_STRLEN
626 : static int yy_flex_strlen (yyconst char * );
627 : #endif
628 :
629 : #ifndef YY_NO_INPUT
630 :
631 : #ifdef __cplusplus
632 : static int yyinput (void );
633 : #else
634 : static int input (void );
635 : #endif
636 :
637 : #endif
638 :
639 : /* Amount of stuff to slurp up with each read. */
640 : #ifndef YY_READ_BUF_SIZE
641 : #define YY_READ_BUF_SIZE 8192
642 : #endif
643 :
644 : /* Copy whatever the last rule matched to the standard output. */
645 : #ifndef ECHO
646 : /* This used to be an fputs(), but since the string might contain NUL's,
647 : * we now use fwrite().
648 : */
649 : #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
650 : #endif
651 :
652 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
653 : * is returned in "result".
654 : */
655 : #ifndef YY_INPUT
656 : #define YY_INPUT(buf,result,max_size) \
657 : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
658 : { \
659 : int c = '*'; \
660 : size_t n; \
661 : for ( n = 0; n < max_size && \
662 : (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
663 : buf[n] = (char) c; \
664 : if ( c == '\n' ) \
665 : buf[n++] = (char) c; \
666 : if ( c == EOF && ferror( yyin ) ) \
667 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
668 : result = n; \
669 : } \
670 : else \
671 : { \
672 : errno=0; \
673 : while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
674 : { \
675 : if( errno != EINTR) \
676 : { \
677 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
678 : break; \
679 : } \
680 : errno=0; \
681 : clearerr(yyin); \
682 : } \
683 : }\
684 : \
685 :
686 : #endif
687 :
688 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
689 : * we don't want an extra ';' after the "return" because that will cause
690 : * some compilers to complain about unreachable statements.
691 : */
692 : #ifndef yyterminate
693 : #define yyterminate() return YY_NULL
694 : #endif
695 :
696 : /* Number of entries by which start-condition stack grows. */
697 : #ifndef YY_START_STACK_INCR
698 : #define YY_START_STACK_INCR 25
699 : #endif
700 :
701 : /* Report a fatal error. */
702 : #ifndef YY_FATAL_ERROR
703 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
704 : #endif
705 :
706 : /* end tables serialization structures and prototypes */
707 :
708 : /* Default declaration of generated scanner - a define so the user can
709 : * easily add parameters.
710 : */
711 : #ifndef YY_DECL
712 : #define YY_DECL_IS_OURS 1
713 :
714 : extern int yylex (void);
715 :
716 : #define YY_DECL int yylex (void)
717 : #endif /* !YY_DECL */
718 :
719 : /* Code executed at the beginning of each rule, after yytext and yyleng
720 : * have been set up.
721 : */
722 : #ifndef YY_USER_ACTION
723 : #define YY_USER_ACTION
724 : #endif
725 :
726 : /* Code executed at the end of each rule. */
727 : #ifndef YY_BREAK
728 : #define YY_BREAK break;
729 : #endif
730 :
731 : #define YY_RULE_SETUP \
732 : YY_USER_ACTION
733 :
734 : /** The main scanner function which does all the work.
735 : */
736 : YY_DECL
737 132113 : {
738 : register yy_state_type yy_current_state;
739 : register char *yy_cp, *yy_bp;
740 : register int yy_act;
741 :
742 : #line 70 "lex.l"
743 :
744 :
745 : #line 746 "lex.yy.c"
746 :
747 132113 : if ( !(yy_init) )
748 : {
749 70 : (yy_init) = 1;
750 :
751 : #ifdef YY_USER_INIT
752 : YY_USER_INIT;
753 : #endif
754 :
755 70 : if ( ! (yy_start) )
756 70 : (yy_start) = 1; /* first start state */
757 :
758 70 : if ( ! yyin )
759 0 : yyin = stdin;
760 :
761 70 : if ( ! yyout )
762 70 : yyout = stdout;
763 :
764 70 : if ( ! YY_CURRENT_BUFFER ) {
765 0 : yyensure_buffer_stack ();
766 0 : YY_CURRENT_BUFFER_LVALUE =
767 : yy_create_buffer(yyin,YY_BUF_SIZE );
768 : }
769 :
770 70 : yy_load_buffer_state( );
771 : }
772 :
773 : while ( 1 ) /* loops until end-of-file is reached */
774 : {
775 224105 : yy_cp = (yy_c_buf_p);
776 :
777 : /* Support of yytext. */
778 224105 : *yy_cp = (yy_hold_char);
779 :
780 : /* yy_bp points to the position in yy_ch_buf of the start of
781 : * the current run.
782 : */
783 224105 : yy_bp = yy_cp;
784 :
785 224105 : yy_current_state = (yy_start);
786 353967 : yy_match:
787 : do
788 : {
789 353967 : register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
790 353967 : if ( yy_accept[yy_current_state] )
791 : {
792 125639 : (yy_last_accepting_state) = yy_current_state;
793 125639 : (yy_last_accepting_cpos) = yy_cp;
794 : }
795 918687 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
796 : {
797 210753 : yy_current_state = (int) yy_def[yy_current_state];
798 210753 : if ( yy_current_state >= 107 )
799 118001 : yy_c = yy_meta[(unsigned int) yy_c];
800 : }
801 353967 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
802 353967 : ++yy_cp;
803 : }
804 353967 : while ( yy_base[yy_current_state] != 126 );
805 :
806 224231 : yy_find_action:
807 224231 : yy_act = yy_accept[yy_current_state];
808 224231 : if ( yy_act == 0 )
809 : { /* have to back up */
810 92752 : yy_cp = (yy_last_accepting_cpos);
811 92752 : yy_current_state = (yy_last_accepting_state);
812 92752 : yy_act = yy_accept[yy_current_state];
813 : }
814 :
815 224231 : YY_DO_BEFORE_ACTION;
816 :
817 224302 : do_action: /* This label is used only to access EOF actions. */
818 :
819 224302 : switch ( yy_act )
820 : { /* beginning of action switch */
821 : case 0: /* must back up */
822 : /* undo the effects of YY_DO_BEFORE_ACTION */
823 0 : *yy_cp = (yy_hold_char);
824 0 : yy_cp = (yy_last_accepting_cpos);
825 0 : yy_current_state = (yy_last_accepting_state);
826 0 : goto yy_find_action;
827 :
828 : case 1:
829 137 : *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
830 137 : (yy_c_buf_p) = yy_cp -= 1;
831 137 : YY_DO_BEFORE_ACTION; /* set up yytext again */
832 : YY_RULE_SETUP
833 : #line 72 "lex.l"
834 : { return TK_EOL; }
835 : YY_BREAK
836 : case 2:
837 : /* rule 2 can match eol */
838 : YY_RULE_SETUP
839 : #line 73 "lex.l"
840 : { return TK_EOL; }
841 : YY_BREAK
842 : case 3:
843 : /* rule 3 can match eol */
844 : YY_RULE_SETUP
845 : #line 74 "lex.l"
846 : { /* Just eat it. */ }
847 : YY_BREAK
848 : case 4:
849 : YY_RULE_SETUP
850 : #line 75 "lex.l"
851 : { return TK_LPAREN; }
852 : YY_BREAK
853 : case 5:
854 : YY_RULE_SETUP
855 : #line 76 "lex.l"
856 : { return TK_RPAREN; }
857 : YY_BREAK
858 : case 6:
859 : YY_RULE_SETUP
860 : #line 77 "lex.l"
861 : { return TK_LBRACK; }
862 : YY_BREAK
863 : case 7:
864 : YY_RULE_SETUP
865 : #line 78 "lex.l"
866 : { return TK_RBRACK; }
867 : YY_BREAK
868 : case 8:
869 : YY_RULE_SETUP
870 : #line 79 "lex.l"
871 : { return TK_DEF; }
872 : YY_BREAK
873 : case 9:
874 : YY_RULE_SETUP
875 : #line 80 "lex.l"
876 : { return TK_DEF; }
877 : YY_BREAK
878 : case 10:
879 : YY_RULE_SETUP
880 : #line 81 "lex.l"
881 : { return TK_REDUCE; }
882 : YY_BREAK
883 : case 11:
884 : YY_RULE_SETUP
885 : #line 82 "lex.l"
886 : { return TK_TIME; }
887 : YY_BREAK
888 : case 12:
889 : YY_RULE_SETUP
890 : #line 83 "lex.l"
891 : { return TK_TIMEOUT; }
892 : YY_BREAK
893 : case 13:
894 : YY_RULE_SETUP
895 : #line 84 "lex.l"
896 : { return TK_DEBUG; }
897 : YY_BREAK
898 : case 14:
899 : YY_RULE_SETUP
900 : #line 85 "lex.l"
901 : { return TK_SINGLE_STEP; }
902 : YY_BREAK
903 : case 15:
904 : YY_RULE_SETUP
905 : #line 86 "lex.l"
906 : { return TK_TRACE; }
907 : YY_BREAK
908 : case 16:
909 : YY_RULE_SETUP
910 : #line 87 "lex.l"
911 : { return TK_ELABORATE; }
912 : YY_BREAK
913 : case 17:
914 : YY_RULE_SETUP
915 : #line 88 "lex.l"
916 : { return TK_LOAD; }
917 : YY_BREAK
918 : case 18:
919 : YY_RULE_SETUP
920 : #line 89 "lex.l"
921 : {
922 : yylval.identifier = Atom_string(yytext);
923 : return TK_ALGORITHM_NAME;
924 : }
925 : YY_BREAK
926 : case 19:
927 : YY_RULE_SETUP
928 : #line 93 "lex.l"
929 : { return TK_SET_BRACKET_ABSTRACTION; }
930 : YY_BREAK
931 : case 20:
932 : YY_RULE_SETUP
933 : #line 94 "lex.l"
934 : { return TK_MAX_COUNT; }
935 : YY_BREAK
936 : case 21:
937 : YY_RULE_SETUP
938 : #line 95 "lex.l"
939 : { yylval.numerical_constant = strtol(yytext, NULL, 10);
940 : return NUMERICAL_CONSTANT; }
941 : YY_BREAK
942 : case 22:
943 : /* rule 22 can match eol */
944 : YY_RULE_SETUP
945 : #line 97 "lex.l"
946 : {
947 : char *tmp;
948 : tmp = unescape_string(yytext);
949 : yylval.string_constant = Atom_string(tmp);
950 : free(tmp);
951 : return STRING_LITERAL;
952 : }
953 : YY_BREAK
954 : case 23:
955 : YY_RULE_SETUP
956 : #line 104 "lex.l"
957 : { if (S_as_combinator) { yylval.cn = COMB_S; return TK_PRIMITIVE;}
958 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
959 : }
960 : YY_BREAK
961 : case 24:
962 : YY_RULE_SETUP
963 : #line 107 "lex.l"
964 : { if (K_as_combinator) { yylval.cn = COMB_K; return TK_PRIMITIVE;}
965 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
966 : }
967 : YY_BREAK
968 : case 25:
969 : YY_RULE_SETUP
970 : #line 110 "lex.l"
971 : { if (I_as_combinator) {yylval.cn = COMB_I; return TK_PRIMITIVE;}
972 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
973 : }
974 : YY_BREAK
975 : case 26:
976 : YY_RULE_SETUP
977 : #line 113 "lex.l"
978 : { if (B_as_combinator) {yylval.cn = COMB_B; return TK_PRIMITIVE;}
979 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
980 : }
981 : YY_BREAK
982 : case 27:
983 : YY_RULE_SETUP
984 : #line 116 "lex.l"
985 : { if (C_as_combinator) {yylval.cn = COMB_C; return TK_PRIMITIVE;}
986 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
987 : }
988 : YY_BREAK
989 : case 28:
990 : YY_RULE_SETUP
991 : #line 119 "lex.l"
992 : { if (W_as_combinator) {yylval.cn = COMB_W; return TK_PRIMITIVE;}
993 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
994 : }
995 : YY_BREAK
996 : case 29:
997 : YY_RULE_SETUP
998 : #line 122 "lex.l"
999 : { if (T_as_combinator) {yylval.cn = COMB_T; return TK_PRIMITIVE;}
1000 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
1001 : }
1002 : YY_BREAK
1003 : case 30:
1004 : YY_RULE_SETUP
1005 : #line 125 "lex.l"
1006 : { if (M_as_combinator) {yylval.cn = COMB_M; return TK_PRIMITIVE;}
1007 : else {yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER;}
1008 : }
1009 : YY_BREAK
1010 : case 31:
1011 : YY_RULE_SETUP
1012 : #line 128 "lex.l"
1013 : { yylval.identifier = Atom_string(yytext); return TK_IDENTIFIER; }
1014 : YY_BREAK
1015 : case 32:
1016 : YY_RULE_SETUP
1017 : #line 129 "lex.l"
1018 : { /* Just eat it. */ }
1019 : YY_BREAK
1020 : case 33:
1021 : YY_RULE_SETUP
1022 : #line 131 "lex.l"
1023 : ECHO;
1024 : YY_BREAK
1025 : #line 1026 "lex.yy.c"
1026 : case YY_STATE_EOF(INITIAL):
1027 71 : yyterminate();
1028 :
1029 : case YY_END_OF_BUFFER:
1030 : {
1031 : /* Amount of text matched not including the EOB char. */
1032 198 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1033 :
1034 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1035 198 : *yy_cp = (yy_hold_char);
1036 : YY_RESTORE_YY_MORE_OFFSET
1037 :
1038 198 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1039 : {
1040 : /* We're scanning a new file or input source. It's
1041 : * possible that this happened because the user
1042 : * just pointed yyin at a new source and called
1043 : * yylex(). If so, then we have to assure
1044 : * consistency between YY_CURRENT_BUFFER and our
1045 : * globals. Here is the right place to do so, because
1046 : * this is the first action (other than possibly a
1047 : * back-up) that will match for the new input source.
1048 : */
1049 73 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1050 73 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1051 73 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1052 : }
1053 :
1054 : /* Note that here we test for yy_c_buf_p "<=" to the position
1055 : * of the first EOB in the buffer, since yy_c_buf_p will
1056 : * already have been incremented past the NUL character
1057 : * (since all states make transitions on EOB to the
1058 : * end-of-buffer state). Contrast this with the test
1059 : * in input().
1060 : */
1061 198 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1062 : { /* This was really a NUL. */
1063 : yy_state_type yy_next_state;
1064 :
1065 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1066 :
1067 0 : yy_current_state = yy_get_previous_state( );
1068 :
1069 : /* Okay, we're now positioned to make the NUL
1070 : * transition. We couldn't have
1071 : * yy_get_previous_state() go ahead and do it
1072 : * for us because it doesn't know how to deal
1073 : * with the possibility of jamming (and we don't
1074 : * want to build jamming into it because then it
1075 : * will run more slowly).
1076 : */
1077 :
1078 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
1079 :
1080 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1081 :
1082 0 : if ( yy_next_state )
1083 : {
1084 : /* Consume the NUL. */
1085 0 : yy_cp = ++(yy_c_buf_p);
1086 0 : yy_current_state = yy_next_state;
1087 0 : goto yy_match;
1088 : }
1089 :
1090 : else
1091 : {
1092 0 : yy_cp = (yy_c_buf_p);
1093 0 : goto yy_find_action;
1094 : }
1095 : }
1096 :
1097 198 : else switch ( yy_get_next_buffer( ) )
1098 : {
1099 : case EOB_ACT_END_OF_FILE:
1100 : {
1101 72 : (yy_did_buffer_switch_on_eof) = 0;
1102 :
1103 72 : if ( yywrap( ) )
1104 : {
1105 : /* Note: because we've taken care in
1106 : * yy_get_next_buffer() to have set up
1107 : * yytext, we can now set up
1108 : * yy_c_buf_p so that if some total
1109 : * hoser (like flex itself) wants to
1110 : * call the scanner after we return the
1111 : * YY_NULL, it'll still work - another
1112 : * YY_NULL will get returned.
1113 : */
1114 71 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1115 :
1116 71 : yy_act = YY_STATE_EOF(YY_START);
1117 71 : goto do_action;
1118 : }
1119 :
1120 : else
1121 : {
1122 1 : if ( ! (yy_did_buffer_switch_on_eof) )
1123 0 : YY_NEW_FILE;
1124 : }
1125 1 : break;
1126 : }
1127 :
1128 : case EOB_ACT_CONTINUE_SCAN:
1129 126 : (yy_c_buf_p) =
1130 : (yytext_ptr) + yy_amount_of_matched_text;
1131 :
1132 126 : yy_current_state = yy_get_previous_state( );
1133 :
1134 126 : yy_cp = (yy_c_buf_p);
1135 126 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1136 126 : goto yy_match;
1137 :
1138 : case EOB_ACT_LAST_MATCH:
1139 0 : (yy_c_buf_p) =
1140 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1141 :
1142 0 : yy_current_state = yy_get_previous_state( );
1143 :
1144 0 : yy_cp = (yy_c_buf_p);
1145 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1146 0 : goto yy_find_action;
1147 : }
1148 1 : break;
1149 : }
1150 :
1151 : default:
1152 0 : YY_FATAL_ERROR(
1153 : "fatal flex scanner internal error--no action found" );
1154 : } /* end of action switch */
1155 91992 : } /* end of scanning one token */
1156 : } /* end of yylex */
1157 :
1158 : /* yy_get_next_buffer - try to read in a new buffer
1159 : *
1160 : * Returns a code representing an action:
1161 : * EOB_ACT_LAST_MATCH -
1162 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1163 : * EOB_ACT_END_OF_FILE - end of file
1164 : */
1165 : static int yy_get_next_buffer (void)
1166 198 : {
1167 198 : register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1168 198 : register char *source = (yytext_ptr);
1169 : register int number_to_move, i;
1170 : int ret_val;
1171 :
1172 198 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1173 0 : YY_FATAL_ERROR(
1174 : "fatal flex scanner internal error--end of buffer missed" );
1175 :
1176 198 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1177 : { /* Don't try to fill the buffer, so this is an EOF. */
1178 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1179 : {
1180 : /* We matched a single character, the EOB, so
1181 : * treat this as a final EOF.
1182 : */
1183 0 : return EOB_ACT_END_OF_FILE;
1184 : }
1185 :
1186 : else
1187 : {
1188 : /* We matched some text prior to the EOB, first
1189 : * process it.
1190 : */
1191 0 : return EOB_ACT_LAST_MATCH;
1192 : }
1193 : }
1194 :
1195 : /* Try to read more data. */
1196 :
1197 : /* First move last chars to start of buffer. */
1198 198 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1199 :
1200 225 : for ( i = 0; i < number_to_move; ++i )
1201 27 : *(dest++) = *(source++);
1202 :
1203 198 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1204 : /* don't do the read, it's not guaranteed to return an EOF,
1205 : * just force an EOF
1206 : */
1207 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1208 :
1209 : else
1210 : {
1211 : int num_to_read =
1212 198 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1213 :
1214 396 : while ( num_to_read <= 0 )
1215 : { /* Not enough room in the buffer - grow it. */
1216 :
1217 : /* just a shorter name for the current buffer */
1218 0 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1219 :
1220 : int yy_c_buf_p_offset =
1221 0 : (int) ((yy_c_buf_p) - b->yy_ch_buf);
1222 :
1223 0 : if ( b->yy_is_our_buffer )
1224 : {
1225 0 : int new_size = b->yy_buf_size * 2;
1226 :
1227 0 : if ( new_size <= 0 )
1228 0 : b->yy_buf_size += b->yy_buf_size / 8;
1229 : else
1230 0 : b->yy_buf_size *= 2;
1231 :
1232 0 : b->yy_ch_buf = (char *)
1233 : /* Include room in for 2 EOB chars. */
1234 : yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1235 : }
1236 : else
1237 : /* Can't grow it, we don't own it. */
1238 0 : b->yy_ch_buf = 0;
1239 :
1240 0 : if ( ! b->yy_ch_buf )
1241 0 : YY_FATAL_ERROR(
1242 : "fatal error - scanner input buffer overflow" );
1243 :
1244 0 : (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1245 :
1246 0 : num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1247 : number_to_move - 1;
1248 :
1249 : }
1250 :
1251 198 : if ( num_to_read > YY_READ_BUF_SIZE )
1252 198 : num_to_read = YY_READ_BUF_SIZE;
1253 :
1254 : /* Read in more data. */
1255 198 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1256 : (yy_n_chars), num_to_read );
1257 :
1258 198 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1259 : }
1260 :
1261 198 : if ( (yy_n_chars) == 0 )
1262 : {
1263 72 : if ( number_to_move == YY_MORE_ADJ )
1264 : {
1265 72 : ret_val = EOB_ACT_END_OF_FILE;
1266 72 : yyrestart(yyin );
1267 : }
1268 :
1269 : else
1270 : {
1271 0 : ret_val = EOB_ACT_LAST_MATCH;
1272 0 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1273 : YY_BUFFER_EOF_PENDING;
1274 : }
1275 : }
1276 :
1277 : else
1278 126 : ret_val = EOB_ACT_CONTINUE_SCAN;
1279 :
1280 198 : (yy_n_chars) += number_to_move;
1281 198 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1282 198 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1283 :
1284 198 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1285 :
1286 198 : return ret_val;
1287 : }
1288 :
1289 : /* yy_get_previous_state - get the state just before the EOB char was reached */
1290 :
1291 : static yy_state_type yy_get_previous_state (void)
1292 126 : {
1293 : register yy_state_type yy_current_state;
1294 : register char *yy_cp;
1295 :
1296 126 : yy_current_state = (yy_start);
1297 :
1298 153 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1299 : {
1300 27 : register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1301 27 : if ( yy_accept[yy_current_state] )
1302 : {
1303 13 : (yy_last_accepting_state) = yy_current_state;
1304 13 : (yy_last_accepting_cpos) = yy_cp;
1305 : }
1306 65 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1307 : {
1308 11 : yy_current_state = (int) yy_def[yy_current_state];
1309 11 : if ( yy_current_state >= 107 )
1310 11 : yy_c = yy_meta[(unsigned int) yy_c];
1311 : }
1312 27 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1313 : }
1314 :
1315 126 : return yy_current_state;
1316 : }
1317 :
1318 : /* yy_try_NUL_trans - try to make a transition on the NUL character
1319 : *
1320 : * synopsis
1321 : * next_state = yy_try_NUL_trans( current_state );
1322 : */
1323 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1324 0 : {
1325 : register int yy_is_jam;
1326 0 : register char *yy_cp = (yy_c_buf_p);
1327 :
1328 0 : register YY_CHAR yy_c = 1;
1329 0 : if ( yy_accept[yy_current_state] )
1330 : {
1331 0 : (yy_last_accepting_state) = yy_current_state;
1332 0 : (yy_last_accepting_cpos) = yy_cp;
1333 : }
1334 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1335 : {
1336 0 : yy_current_state = (int) yy_def[yy_current_state];
1337 0 : if ( yy_current_state >= 107 )
1338 0 : yy_c = yy_meta[(unsigned int) yy_c];
1339 : }
1340 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1341 0 : yy_is_jam = (yy_current_state == 106);
1342 :
1343 0 : return yy_is_jam ? 0 : yy_current_state;
1344 : }
1345 :
1346 : static void yyunput (int c, register char * yy_bp )
1347 0 : {
1348 : register char *yy_cp;
1349 :
1350 0 : yy_cp = (yy_c_buf_p);
1351 :
1352 : /* undo effects of setting up yytext */
1353 0 : *yy_cp = (yy_hold_char);
1354 :
1355 0 : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1356 : { /* need to shift things up to make room */
1357 : /* +2 for EOB chars. */
1358 0 : register int number_to_move = (yy_n_chars) + 2;
1359 : register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1360 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1361 : register char *source =
1362 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1363 :
1364 0 : while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1365 0 : *--dest = *--source;
1366 :
1367 0 : yy_cp += (int) (dest - source);
1368 0 : yy_bp += (int) (dest - source);
1369 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1370 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1371 :
1372 0 : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1373 0 : YY_FATAL_ERROR( "flex scanner push-back overflow" );
1374 : }
1375 :
1376 0 : *--yy_cp = (char) c;
1377 :
1378 0 : (yytext_ptr) = yy_bp;
1379 0 : (yy_hold_char) = *yy_cp;
1380 0 : (yy_c_buf_p) = yy_cp;
1381 0 : }
1382 :
1383 : #ifndef YY_NO_INPUT
1384 : #ifdef __cplusplus
1385 |
