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