scanner.cc
Go to the documentation of this file.
1 /* A lexical scanner generated by flex */
2 
3 /* Scanner skeleton version:
4  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
5  */
6 
7 #define FLEX_SCANNER
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
10 
11 #include <stdio.h>
12 
13 
14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
15 #ifdef c_plusplus
16 #ifndef __cplusplus
17 #define __cplusplus
18 #endif
19 #endif
20 
21 
22 #ifdef __cplusplus
23 
24 #include <stdlib.h>
25 #include <unistd.h>
26 
27 /* Use prototypes in function declarations. */
28 #define YY_USE_PROTOS
29 
30 /* The "const" storage-class-modifier is valid. */
31 #define YY_USE_CONST
32 
33 #else /* ! __cplusplus */
34 
35 #if __STDC__
36 
37 #define YY_USE_PROTOS
38 #define YY_USE_CONST
39 
40 #endif /* __STDC__ */
41 #endif /* ! __cplusplus */
42 
43 #ifdef __TURBOC__
44  #pragma warn -rch
45  #pragma warn -use
46 #include <io.h>
47 #include <stdlib.h>
48 #define YY_USE_CONST
49 #define YY_USE_PROTOS
50 #endif
51 
52 #ifdef YY_USE_CONST
53 #define yyconst const
54 #else
55 #define yyconst
56 #endif
57 
58 
59 #ifdef YY_USE_PROTOS
60 #define YY_PROTO(proto) proto
61 #else
62 #define YY_PROTO(proto) ()
63 #endif
64 
65 /* Returned upon end-of-file. */
66 #define YY_NULL 0
67 
68 /* Promotes a possibly negative, possibly signed char to an unsigned
69  * integer for use as an array index. If the signed char is negative,
70  * we want to instead treat it as an 8-bit unsigned char, hence the
71  * double cast.
72  */
73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
74 
75 /* Enter a start condition. This macro really ought to take a parameter,
76  * but we do it the disgusting crufty way forced on us by the ()-less
77  * definition of BEGIN.
78  */
79 #define BEGIN yy_start = 1 + 2 *
80 
81 /* Translate the current start state into a value that can be later handed
82  * to BEGIN to return to the state. The YYSTATE alias is for lex
83  * compatibility.
84  */
85 #define YY_START ((yy_start - 1) / 2)
86 #define YYSTATE YY_START
87 
88 /* Action number for EOF rule of a given start state. */
89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
90 
91 /* Special action meaning "start processing a new file". */
92 #define YY_NEW_FILE yyrestart( yyin )
93 
94 #define YY_END_OF_BUFFER_CHAR 0
95 
96 /* Size of default input buffer. */
97 #define YY_BUF_SIZE 16384
98 
99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
100 
101 extern int yyleng;
102 extern FILE *yyin, *yyout;
103 
104 #define EOB_ACT_CONTINUE_SCAN 0
105 #define EOB_ACT_END_OF_FILE 1
106 #define EOB_ACT_LAST_MATCH 2
107 
108 /* The funky do-while in the following #define is used to turn the definition
109  * int a single C statement (which needs a semi-colon terminator). This
110  * avoids problems with code like:
111  *
112  * if ( condition_holds )
113  * yyless( 5 );
114  * else
115  * do_something_else();
116  *
117  * Prior to using the do-while the compiler would get upset at the
118  * "else" because it interpreted the "if" statement as being all
119  * done when it reached the ';' after the yyless() call.
120  */
121 
122 /* Return all but the first 'n' matched characters back to the input stream. */
123 
124 #define yyless(n) \
125  do \
126  { \
127  /* Undo effects of setting up yytext. */ \
128  *yy_cp = yy_hold_char; \
129  YY_RESTORE_YY_MORE_OFFSET \
130  yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
131  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
132  } \
133  while ( 0 )
134 
135 #define unput(c) yyunput( c, yytext_ptr )
136 
137 /* The following is because we cannot portably get our hands on size_t
138  * (without autoconf's help, which isn't available because we want
139  * flex-generated scanners to compile on their own).
140  */
141 typedef unsigned int yy_size_t;
142 
143 
144 struct yy_buffer_state
145  {
146  FILE *yy_input_file;
147 
148  char *yy_ch_buf; /* input buffer */
149  char *yy_buf_pos; /* current position in input buffer */
150 
151  /* Size of input buffer in bytes, not including room for EOB
152  * characters.
153  */
155 
156  /* Number of characters read into yy_ch_buf, not including EOB
157  * characters.
158  */
159  int yy_n_chars;
160 
161  /* Whether we "own" the buffer - i.e., we know we created it,
162  * and can realloc() it to grow it, and should free() it to
163  * delete it.
164  */
165  int yy_is_our_buffer;
166 
167  /* Whether this is an "interactive" input source; if so, and
168  * if we're using stdio for input, then we want to use getc()
169  * instead of fread(), to make sure we stop fetching input after
170  * each newline.
171  */
172  int yy_is_interactive;
173 
174  /* Whether we're considered to be at the beginning of a line.
175  * If so, '^' rules will be active on the next match, otherwise
176  * not.
177  */
178  int yy_at_bol;
179 
180  /* Whether to try to fill the input buffer when we reach the
181  * end of it.
182  */
183  int yy_fill_buffer;
184 
185  int yy_buffer_status;
186 #define YY_BUFFER_NEW 0
187 #define YY_BUFFER_NORMAL 1
188  /* When an EOF's been seen but there's still some text to process
189  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
190  * shouldn't try reading from the input source any more. We might
191  * still have a bunch of tokens to match, though, because of
192  * possible backing-up.
193  *
194  * When we actually see the EOF, we change the status to "new"
195  * (via yyrestart()), so that the user can continue scanning by
196  * just pointing yyin at a new input file.
197  */
198 #define YY_BUFFER_EOF_PENDING 2
199  };
200 
201 static YY_BUFFER_STATE yy_current_buffer = 0;
202 
203 /* We provide macros for accessing buffer states in case in the
204  * future we want to put the buffer states in a more general
205  * "scanner state".
206  */
207 #define YY_CURRENT_BUFFER yy_current_buffer
208 
209 
210 /* yy_hold_char holds the character lost when yytext is formed. */
211 static char yy_hold_char;
212 
213 static int yy_n_chars; /* number of characters read into yy_ch_buf */
214 
215 
216 int yyleng;
217 
218 /* Points to current character in buffer. */
219 static char *yy_c_buf_p = (char *) 0;
220 static int yy_init = 1; /* whether we need to initialize */
221 static int yy_start = 0; /* start state number */
222 
223 /* Flag which is used to allow yywrap()'s to do buffer switches
224  * instead of setting up a fresh yyin. A bit of a hack ...
225  */
227 
228 void yyrestart YY_PROTO(( FILE *input_file ));
229 
230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
231 void yy_load_buffer_state YY_PROTO(( void ));
232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
237 
238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
241 
242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
244 static void yy_flex_free YY_PROTO(( void * ));
245 
246 #define yy_new_buffer yy_create_buffer
247 
248 #define yy_set_interactive(is_interactive) \
249  { \
250  if ( ! yy_current_buffer ) \
251  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
252  yy_current_buffer->yy_is_interactive = is_interactive; \
253  }
254 
255 #define yy_set_bol(at_bol) \
256  { \
257  if ( ! yy_current_buffer ) \
258  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
259  yy_current_buffer->yy_at_bol = at_bol; \
260  }
261 
262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
263 
264 typedef unsigned char YY_CHAR;
265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
266 typedef int yy_state_type;
267 extern char *yytext;
268 #define yytext_ptr yytext
269 
270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
272 static int yy_get_next_buffer YY_PROTO(( void ));
273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
274 
275 /* Done after the current pattern has been matched and before the
276  * corresponding action - sets up yytext.
277  */
278 #define YY_DO_BEFORE_ACTION \
279  yytext_ptr = yy_bp; \
280  yytext_ptr -= yy_more_len; \
281  yyleng = (int) (yy_cp - yytext_ptr); \
282  yy_hold_char = *yy_cp; \
283  *yy_cp = '\0'; \
284  yy_c_buf_p = yy_cp;
285 
286 #define YY_NUM_RULES 66
287 #define YY_END_OF_BUFFER 67
288 static yyconst short int yy_accept[171] =
289  { 0,
290  0, 0, 0, 0, 30, 30, 0, 0, 0, 0,
291  0, 0, 20, 20, 0, 0, 67, 65, 40, 40,
292  50, 34, 64, 59, 65, 64, 65, 65, 65, 65,
293  65, 57, 65, 65, 65, 65, 6, 55, 64, 64,
294  64, 64, 64, 64, 64, 24, 65, 35, 64, 36,
295  39, 36, 30, 25, 30, 32, 33, 26, 29, 26,
296  13, 11, 12, 15, 14, 17, 16, 21, 20, 21,
297  18, 23, 19, 9, 66, 10, 51, 46, 64, 64,
298  64, 53, 44, 43, 54, 41, 61, 3, 1, 61,
299  0, 0, 57, 42, 48, 52, 45, 49, 6, 64,
300 
301  64, 64, 64, 64, 64, 64, 47, 2, 38, 37,
302  30, 30, 28, 27, 21, 20, 21, 0, 21, 9,
303  0, 1, 61, 63, 61, 63, 58, 64, 64, 5,
304  64, 64, 64, 64, 64, 2, 30, 31, 22, 0,
305  0, 0, 64, 64, 6, 64, 64, 64, 61, 62,
306  0, 64, 0, 60, 64, 0, 4, 64, 64, 0,
307  0, 7, 56, 0, 0, 8, 0, 0, 7, 0
308  } ;
309 
310 static yyconst int yy_ec[256] =
311  { 0,
312  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
313  1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
314  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
315  1, 2, 5, 6, 7, 8, 1, 9, 10, 11,
316  12, 13, 14, 15, 16, 17, 18, 19, 19, 19,
317  19, 19, 19, 19, 19, 19, 19, 20, 21, 22,
318  23, 24, 25, 10, 10, 10, 10, 10, 10, 10,
319  10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
320  10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
321  1, 26, 1, 1, 27, 1, 28, 10, 29, 10,
322 
323  30, 31, 10, 32, 33, 10, 10, 34, 35, 36,
324  37, 38, 39, 40, 10, 41, 42, 10, 43, 44,
325  10, 10, 45, 46, 47, 48, 1, 1, 1, 1,
326  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
327  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
328  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
329  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
330  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
331  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
332  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
333 
334  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
335  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
336  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
337  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
338  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
339  1, 1, 1, 1, 1
340  } ;
341 
342 static yyconst int yy_meta[49] =
343  { 0,
344  1, 2, 3, 1, 1, 4, 1, 1, 1, 5,
345  6, 7, 1, 1, 7, 1, 8, 9, 10, 1,
346  11, 1, 1, 1, 1, 1, 12, 5, 5, 5,
347  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
348  5, 5, 5, 5, 4, 1, 4, 1
349  } ;
350 
351 static yyconst short int yy_base[192] =
352  { 0,
353  0, 299, 43, 44, 45, 46, 47, 48, 50, 54,
354  295, 294, 74, 92, 75, 76, 296, 561, 561, 561,
355  269, 561, 561, 561, 267, 40, 250, 229, 84, 38,
356  69, 92, 221, 60, 194, 181, 99, 561, 86, 87,
357  93, 98, 99, 100, 102, 561, 154, 561, 177, 561,
358  561, 62, 0, 561, 158, 561, 561, 561, 561, 109,
359  561, 561, 561, 561, 561, 561, 561, 0, 129, 134,
360  561, 561, 561, 0, 561, 561, 561, 561, 114, 124,
361  125, 561, 561, 561, 561, 561, 128, 561, 0, 136,
362  129, 149, 143, 561, 561, 561, 561, 561, 154, 144,
363 
364  146, 147, 148, 151, 136, 151, 561, 0, 561, 561,
365  0, 177, 561, 561, 0, 187, 190, 144, 0, 0,
366  171, 0, 180, 561, 176, 193, 193, 180, 186, 188,
367  190, 192, 201, 203, 204, 0, 236, 0, 561, 119,
368  103, 97, 207, 244, 246, 222, 231, 223, 80, 39,
369  243, 224, 266, 561, 238, 252, 242, 252, 256, 286,
370  70, 288, 245, 192, 291, 561, 292, 293, 296, 561,
371  320, 332, 344, 356, 368, 380, 392, 400, 408, 418,
372  430, 442, 454, 466, 478, 490, 502, 514, 526, 537,
373  548
374 
375  } ;
376 
377 static yyconst short int yy_def[192] =
378  { 0,
379  170, 1, 171, 171, 172, 172, 173, 173, 174, 174,
380  175, 175, 176, 176, 177, 177, 170, 170, 170, 170,
381  170, 170, 170, 170, 170, 178, 170, 170, 170, 170,
382  170, 179, 170, 170, 170, 170, 170, 170, 178, 178,
383  178, 178, 178, 178, 178, 170, 170, 170, 170, 170,
384  170, 170, 180, 170, 180, 170, 170, 170, 170, 170,
385  170, 170, 170, 170, 170, 170, 170, 181, 170, 182,
386  170, 170, 170, 183, 170, 170, 170, 170, 178, 178,
387  178, 170, 170, 170, 170, 170, 170, 170, 184, 179,
388  185, 170, 179, 170, 170, 170, 170, 170, 170, 178,
389 
390  178, 178, 178, 178, 100, 100, 170, 186, 170, 170,
391  180, 187, 170, 170, 181, 170, 182, 188, 181, 183,
392  170, 184, 179, 170, 170, 170, 179, 100, 100, 100,
393  100, 100, 100, 100, 100, 186, 187, 189, 170, 170,
394  170, 170, 100, 100, 144, 100, 100, 100, 170, 170,
395  179, 100, 170, 170, 100, 190, 100, 100, 100, 191,
396  170, 144, 100, 170, 191, 170, 191, 191, 170, 0,
397  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
398  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
399  170
400 
401  } ;
402 
403 static yyconst short int yy_nxt[610] =
404  { 0,
405  18, 19, 20, 19, 21, 22, 23, 24, 25, 26,
406  18, 18, 27, 28, 18, 29, 30, 31, 32, 33,
407  18, 34, 35, 36, 37, 38, 23, 26, 26, 39,
408  40, 41, 26, 26, 26, 42, 26, 43, 44, 26,
409  26, 26, 45, 26, 46, 47, 18, 48, 51, 51,
410  54, 54, 59, 59, 86, 62, 87, 150, 80, 62,
411  63, 64, 55, 55, 63, 64, 81, 109, 52, 52,
412  65, 164, 60, 60, 65, 69, 69, 75, 75, 70,
413  166, 88, 95, 96, 71, 72, 89, 110, 73, 56,
414  56, 57, 57, 69, 69, 76, 76, 70, 149, 84,
415 
416  99, 99, 71, 72, 80, 80, 73, 85, 91, 92,
417  93, 80, 81, 81, 113, 151, 80, 80, 80, 81,
418  80, 150, 102, 101, 81, 81, 81, 103, 81, 100,
419  116, 116, 80, 106, 114, 118, 118, 149, 104, 119,
420  81, 105, 80, 80, 118, 118, 87, 125, 118, 139,
421  81, 81, 170, 170, 123, 99, 99, 121, 126, 91,
422  92, 93, 80, 79, 80, 80, 80, 127, 134, 80,
423  81, 128, 81, 81, 81, 112, 129, 81, 79, 111,
424  131, 108, 138, 135, 140, 130, 140, 133, 116, 116,
425  132, 118, 118, 164, 87, 119, 170, 170, 123, 107,
426 
427  118, 118, 166, 98, 118, 121, 141, 79, 141, 170,
428  142, 127, 79, 79, 143, 79, 97, 79, 79, 79,
429  79, 138, 79, 138, 79, 146, 144, 145, 79, 147,
430  79, 79, 156, 79, 79, 79, 79, 148, 111, 79,
431  94, 138, 83, 144, 152, 153, 153, 99, 99, 79,
432  79, 79, 157, 156, 155, 79, 79, 158, 79, 170,
433  142, 151, 82, 79, 154, 79, 170, 153, 153, 79,
434  79, 79, 79, 159, 79, 78, 79, 79, 161, 79,
435  138, 162, 138, 79, 79, 163, 154, 164, 79, 169,
436  169, 77, 164, 164, 164, 170, 166, 169, 169, 67,
437 
438  67, 166, 166, 166, 167, 49, 170, 170, 170, 167,
439  167, 167, 168, 170, 170, 170, 170, 168, 168, 168,
440  50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
441  50, 50, 53, 53, 53, 53, 53, 53, 53, 53,
442  53, 53, 53, 53, 58, 58, 58, 58, 58, 58,
443  58, 58, 58, 58, 58, 58, 61, 61, 61, 61,
444  61, 61, 61, 61, 61, 61, 61, 61, 66, 66,
445  66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
446  68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
447  68, 68, 74, 74, 74, 74, 74, 74, 74, 74,
448 
449  74, 74, 74, 74, 79, 170, 170, 170, 170, 79,
450  170, 79, 90, 170, 170, 90, 90, 90, 111, 111,
451  111, 170, 111, 111, 111, 111, 111, 111, 111, 111,
452  115, 170, 170, 115, 115, 170, 170, 115, 115, 115,
453  115, 115, 117, 117, 117, 117, 117, 117, 117, 117,
454  117, 117, 117, 117, 120, 120, 170, 120, 120, 120,
455  120, 120, 120, 120, 170, 120, 122, 122, 170, 122,
456  122, 122, 122, 122, 122, 122, 122, 122, 124, 124,
457  124, 124, 124, 124, 124, 170, 124, 124, 124, 124,
458  136, 136, 170, 136, 136, 136, 136, 136, 136, 136,
459 
460  136, 136, 137, 137, 137, 137, 137, 137, 137, 137,
461  137, 137, 137, 137, 118, 118, 118, 118, 118, 118,
462  118, 118, 118, 118, 118, 118, 138, 138, 170, 138,
463  138, 138, 138, 138, 138, 138, 138, 138, 160, 170,
464  170, 160, 170, 170, 170, 170, 170, 170, 160, 165,
465  170, 170, 165, 165, 170, 170, 170, 165, 170, 165,
466  17, 170, 170, 170, 170, 170, 170, 170, 170, 170,
467  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
468  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
469  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
470 
471  170, 170, 170, 170, 170, 170, 170, 170, 170
472  } ;
473 
474 static yyconst short int yy_chk[610] =
475  { 0,
476  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
477  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
478  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
479  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
480  1, 1, 1, 1, 1, 1, 1, 1, 3, 4,
481  5, 6, 7, 8, 30, 9, 30, 150, 26, 10,
482  9, 9, 5, 6, 10, 10, 26, 52, 3, 4,
483  9, 161, 7, 8, 10, 13, 13, 15, 16, 13,
484  161, 31, 34, 34, 13, 13, 31, 52, 13, 5,
485  6, 5, 6, 14, 14, 15, 16, 14, 149, 29,
486 
487  37, 37, 14, 14, 39, 40, 14, 29, 32, 32,
488  32, 41, 39, 40, 60, 142, 42, 43, 44, 41,
489  45, 141, 41, 40, 42, 43, 44, 42, 45, 39,
490  69, 69, 79, 45, 60, 70, 70, 140, 43, 70,
491  79, 44, 80, 81, 70, 70, 87, 91, 70, 118,
492  80, 81, 90, 90, 90, 99, 99, 87, 91, 93,
493  93, 93, 100, 105, 101, 102, 103, 92, 105, 104,
494  100, 100, 101, 102, 103, 55, 100, 104, 106, 112,
495  102, 49, 112, 106, 121, 101, 121, 104, 116, 116,
496  103, 117, 117, 164, 125, 117, 123, 123, 123, 47,
497 
498  117, 117, 164, 36, 117, 125, 126, 128, 126, 127,
499  127, 127, 128, 129, 128, 130, 35, 131, 129, 132,
500  130, 112, 131, 112, 132, 132, 129, 131, 133, 133,
501  134, 135, 147, 133, 143, 134, 135, 135, 137, 143,
502  33, 137, 28, 134, 143, 144, 144, 145, 145, 146,
503  148, 152, 148, 156, 146, 148, 152, 152, 147, 151,
504  151, 151, 27, 147, 144, 155, 145, 153, 153, 157,
505  155, 144, 163, 155, 157, 25, 144, 163, 156, 158,
506  137, 158, 137, 159, 158, 159, 153, 160, 159, 162,
507  162, 21, 165, 167, 168, 17, 160, 169, 169, 12,
508 
509  11, 165, 167, 168, 160, 2, 0, 0, 162, 165,
510  167, 168, 160, 0, 0, 0, 0, 165, 167, 168,
511  171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
512  171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
513  172, 172, 172, 172, 173, 173, 173, 173, 173, 173,
514  173, 173, 173, 173, 173, 173, 174, 174, 174, 174,
515  174, 174, 174, 174, 174, 174, 174, 174, 175, 175,
516  175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
517  176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
518  176, 176, 177, 177, 177, 177, 177, 177, 177, 177,
519 
520  177, 177, 177, 177, 178, 0, 0, 0, 0, 178,
521  0, 178, 179, 0, 0, 179, 179, 179, 180, 180,
522  180, 0, 180, 180, 180, 180, 180, 180, 180, 180,
523  181, 0, 0, 181, 181, 0, 0, 181, 181, 181,
524  181, 181, 182, 182, 182, 182, 182, 182, 182, 182,
525  182, 182, 182, 182, 183, 183, 0, 183, 183, 183,
526  183, 183, 183, 183, 0, 183, 184, 184, 0, 184,
527  184, 184, 184, 184, 184, 184, 184, 184, 185, 185,
528  185, 185, 185, 185, 185, 0, 185, 185, 185, 185,
529  186, 186, 0, 186, 186, 186, 186, 186, 186, 186,
530 
531  186, 186, 187, 187, 187, 187, 187, 187, 187, 187,
532  187, 187, 187, 187, 188, 188, 188, 188, 188, 188,
533  188, 188, 188, 188, 188, 188, 189, 189, 0, 189,
534  189, 189, 189, 189, 189, 189, 189, 189, 190, 0,
535  0, 190, 0, 0, 0, 0, 0, 0, 190, 191,
536  0, 0, 191, 191, 0, 0, 0, 191, 0, 191,
537  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
538  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
539  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
540  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
541 
542  170, 170, 170, 170, 170, 170, 170, 170, 170
543  } ;
544 
545 static yy_state_type yy_last_accepting_state;
547 
548 /* The intent behind this definition is that it'll catch
549  * any uses of REJECT which flex missed.
550  */
551 #define REJECT reject_used_but_not_detected
552 static int yy_more_flag = 0;
553 static int yy_more_len = 0;
554 #define yymore() (yy_more_flag = 1)
555 #define YY_MORE_ADJ yy_more_len
556 #define YY_RESTORE_YY_MORE_OFFSET
557 char *yytext;
558 #line 1 "<stdin>"
559 #define INITIAL 0
560 #line 2 "<stdin>"
561 /****************************************
562 * Computer Algebra System SINGULAR *
563 ****************************************/
564 #include <stdio.h>
565 #include <string.h>
566 #include <stdlib.h>
567 #include <ctype.h>
568 
569 #include <kernel/mod2.h>
570 #include <omalloc/omalloc.h>
571 #include <Singular/tok.h>
572 #include <Singular/stype.h>
573 #include <Singular/ipshell.h>
574 #include <Singular/fevoices.h>
575 #include <kernel/oswrapper/feread.h>
576 
577 int feReadLine(char* b, int l);
578 #define ALLOC(a) omAlloc((a))
579 #ifndef NEW_FLEX
580 #endif /* NEW_LEX */
581 int blocknest = 0;
582 extern char * yytext;
583 //extern unsigned char * yytext;
584 extern int yyleng;
585 extern int inerror;
586 
587 // this is to shadow the malloc/realloc
588 // used by yy_flex_malloc/yy_flex_realloc
589 // so that we can mark stuff as static
590 static void* my_malloc(size_t size)
591 {
592  void* addr = omAlloc(size);
593  omMarkAsStaticAddr(addr);
594  return addr;
595 }
596 
597 static void* my_realloc(void* addr, size_t size)
598 {
599  void* new_addr = omRealloc(addr, size);
600  omMarkAsStaticAddr(new_addr);
601  return new_addr;
602 }
603 static void my_free(void* addr)
604 {
605  omFree(addr);
606 }
607 #undef malloc
608 #define malloc my_malloc
609 #undef realloc
610 #define realloc my_realloc
611 #undef free
612 #define free my_free
613 static char * dupyytext()
614 {
615  char* s;
616  if (yyleng>0) yytext[yyleng-1] = '\0';
617  s = omStrDup((char *)yytext);
619  return s;
620 }
621 
622 static char * dupyytextNL()
623 {
624  int i = yyleng;//strlen((char *)yytext);
625  char * rc = (char*)omAlloc( 3 + i );
626  omMarkAsStaticAddr(rc);
627  if (i>0)
628  {
629  strncpy( rc, (char *)yytext, i-1 );
630  }
631  else
632  {
633  i++;
634  }
635  rc[i-1] = '\n';
636  rc[i] = '\n';
637  rc[i+1] = '\0';
638  return rc;
639 }
640 
641  #undef YY_DECL
642  #define YY_DECL int yylex(YYSTYPE* lvalp)
643 
644  #undef yywrap
645  extern "C" {
646  int yywrap() { return exitVoice(); }
647  }
648 
649  #undef YY_INPUT
650  #define YY_INPUT(buf,result,max_size) \
651  result = feReadLine( (char *) (buf), (max_size) )
652 
653  #undef YY_USER_ACTION
654  #define YY_USER_ACTION \
655  if ((inerror==1)&&(*yytext>=' '))\
656  { Print(" skipping text from `%s`",yytext);inerror=2; }
657 
658 /* %start START */
659 #define YY_ALWAYS_INTERACTIVE 1
660 #define string 1
661 
662 #define block 2
663 
664 #define blockstr 3
665 
666 #define brace 4
667 
668 #define bracestr 5
669 
670 #define bracket 6
671 
672 #define asstring 7
673 
674 
675 /* Macros after this point can all be overridden by user definitions in
676  * section 1.
677  */
678 
679 #ifndef YY_SKIP_YYWRAP
680 #ifdef __cplusplus
681 extern "C" int yywrap YY_PROTO(( void ));
682 #else
683 extern int yywrap YY_PROTO(( void ));
684 #endif
685 #endif
686 
687 #ifndef YY_NO_UNPUT
688 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
689 #endif
690 
691 #ifndef yytext_ptr
692 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
693 #endif
694 
695 #ifdef YY_NEED_STRLEN
696 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
697 #endif
698 
699 #ifndef YY_NO_INPUT
700 #ifdef __cplusplus
701 static int yyinput YY_PROTO(( void ));
702 #else
703 static int input YY_PROTO(( void ));
704 #endif
705 #endif
706 
707 #if YY_STACK_USED
708 static int yy_start_stack_ptr = 0;
709 static int yy_start_stack_depth = 0;
710 static int *yy_start_stack = 0;
711 #ifndef YY_NO_PUSH_STATE
712 static void yy_push_state YY_PROTO(( int new_state ));
713 #endif
714 #ifndef YY_NO_POP_STATE
715 static void yy_pop_state YY_PROTO(( void ));
716 #endif
717 #ifndef YY_NO_TOP_STATE
718 static int yy_top_state YY_PROTO(( void ));
719 #endif
720 
721 #else
722 #define YY_NO_PUSH_STATE 1
723 #define YY_NO_POP_STATE 1
724 #define YY_NO_TOP_STATE 1
725 #endif
726 
727 #ifdef YY_MALLOC_DECL
728 YY_MALLOC_DECL
729 #else
730 #if __STDC__
731 #ifndef __cplusplus
732 #include <stdlib.h>
733 #endif
734 #else
735 /* Just try to get by without declaring the routines. This will fail
736  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
737  * or sizeof(void*) != sizeof(int).
738  */
739 #endif
740 #endif
741 
742 /* Amount of stuff to slurp up with each read. */
743 #ifndef YY_READ_BUF_SIZE
744 #define YY_READ_BUF_SIZE 8192
745 #endif
746 
747 /* Copy whatever the last rule matched to the standard output. */
748 
749 #ifndef ECHO
750 /* This used to be an fputs(), but since the string might contain NUL's,
751  * we now use fwrite().
752  */
753 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
754 #endif
755 
756 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
757  * is returned in "result".
758  */
759 #ifndef YY_INPUT
760 #define YY_INPUT(buf,result,max_size) \
761  if ( yy_current_buffer->yy_is_interactive ) \
762  { \
763  int c = '*', n; \
764  for ( n = 0; n < max_size && \
765  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
766  buf[n] = (char) c; \
767  if ( c == '\n' ) \
768  buf[n++] = (char) c; \
769  if ( c == EOF && ferror( yyin ) ) \
770  YY_FATAL_ERROR( "input in flex scanner failed" ); \
771  result = n; \
772  } \
773  else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
774  && ferror( yyin ) ) \
775  YY_FATAL_ERROR( "input in flex scanner failed" );
776 #endif
777 
778 /* No semi-colon after return; correct usage is to write "yyterminate();" -
779  * we don't want an extra ';' after the "return" because that will cause
780  * some compilers to complain about unreachable statements.
781  */
782 #ifndef yyterminate
783 #define yyterminate() return YY_NULL
784 #endif
785 
786 /* Number of entries by which start-condition stack grows. */
787 #ifndef YY_START_STACK_INCR
788 #define YY_START_STACK_INCR 25
789 #endif
790 
791 /* Report a fatal error. */
792 #ifndef YY_FATAL_ERROR
793 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
794 #endif
795 
796 /* Default declaration of generated scanner - a define so the user can
797  * easily add parameters.
798  */
799 #ifndef YY_DECL
800 #define YY_DECL int yylex YY_PROTO(( void ))
801 #endif
802 
803 /* Code executed at the beginning of each rule, after yytext and yyleng
804  * have been set up.
805  */
806 #ifndef YY_USER_ACTION
807 #define YY_USER_ACTION
808 #endif
809 
810 /* Code executed at the end of each rule. */
811 #ifndef YY_BREAK
812 #define YY_BREAK break;
813 #endif
814 
815 #define YY_RULE_SETUP \
816  if ( yyleng > 0 ) \
817  yy_current_buffer->yy_at_bol = \
818  (yytext[yyleng - 1] == '\n'); \
819  YY_USER_ACTION
820 
821 YY_DECL
822  {
823  register yy_state_type yy_current_state;
824  register char *yy_cp, *yy_bp;
825  register int yy_act;
826 
827 #line 121 "<stdin>"
828 
829 
830  if ( yy_init )
831  {
832  yy_init = 0;
833 
834 #ifdef YY_USER_INIT
835  YY_USER_INIT;
836 #endif
837 
838  if ( ! yy_start )
839  yy_start = 1; /* first start state */
840 
841  if ( ! yyin )
842  yyin = stdin;
843 
844  if ( ! yyout )
845  yyout = stdout;
846 
847  if ( ! yy_current_buffer )
849  yy_create_buffer( yyin, YY_BUF_SIZE );
850 
852  }
853 
854  while ( 1 ) /* loops until end-of-file is reached */
855  {
856  yy_more_len = 0;
857  if ( yy_more_flag )
858  {
859  yy_more_len = yy_c_buf_p - yytext_ptr;
860  yy_more_flag = 0;
861  }
862  yy_cp = yy_c_buf_p;
863 
864  /* Support of yytext. */
865  *yy_cp = yy_hold_char;
866 
867  /* yy_bp points to the position in yy_ch_buf of the start of
868  * the current run.
869  */
870  yy_bp = yy_cp;
871 
872  yy_current_state = yy_start;
873  yy_current_state += YY_AT_BOL();
874 yy_match:
875  do
876  {
877  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
878  if ( yy_accept[yy_current_state] )
879  {
880  yy_last_accepting_state = yy_current_state;
881  yy_last_accepting_cpos = yy_cp;
882  }
883  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
884  {
885  yy_current_state = (int) yy_def[yy_current_state];
886  if ( yy_current_state >= 171 )
887  yy_c = yy_meta[(unsigned int) yy_c];
888  }
889  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
890  ++yy_cp;
891  }
892  while ( yy_base[yy_current_state] != 561 );
893 
894 yy_find_action:
895  yy_act = yy_accept[yy_current_state];
896  if ( yy_act == 0 )
897  { /* have to back up */
898  yy_cp = yy_last_accepting_cpos;
899  yy_current_state = yy_last_accepting_state;
900  yy_act = yy_accept[yy_current_state];
901  }
902 
904 
905 
906 do_action: /* This label is used only to access EOF actions. */
907 
908 
909  switch ( yy_act )
910  { /* beginning of action switch */
911  case 0: /* must back up */
912  /* undo the effects of YY_DO_BEFORE_ACTION */
913  *yy_cp = yy_hold_char;
914  yy_cp = yy_last_accepting_cpos;
915  yy_current_state = yy_last_accepting_state;
916  goto yy_find_action;
917 
918 case 1:
920 #line 122 "<stdin>"
921 { }
922  YY_BREAK
923 case 2:
925 #line 123 "<stdin>"
926 { }
927  YY_BREAK
928 case 3:
930 #line 124 "<stdin>"
931 {
933  loop
934  {
935  register int c;
936  while ( (c = yyinput()) != '*' && c != EOF );
937  if ( c == '*' )
938  {
939  while ( (c = yyinput()) == '*' );
940  if ( c == '/' ) break; /* found the end */
941  }
942  else
943  {
944  break;
945  }
946  }
947  yy_noeof=0;
948  }
949  YY_BREAK
950 case 4:
952 #line 142 "<stdin>"
953 { prompt_char='.';
954  blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);
955  return WHILE_CMD;}
956  YY_BREAK
957 case 5:
959 #line 145 "<stdin>"
960 { prompt_char='.';
961  blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);
962  return FOR_CMD;}
963  YY_BREAK
964 case 6:
966 #line 149 "<stdin>"
968  BEGIN(asstring);
969  return HELP_CMD;
970  }
971  YY_BREAK
972 case 7:
974 #line 154 "<stdin>"
976  BEGIN(asstring);
977  return EXAMPLE_CMD;
978  }
979  YY_BREAK
980 case 8:
982 #line 159 "<stdin>"
983 {
984  char c; char *cp;
985  lvalp->name = omStrDup(iiProcName((char *)yytext,c,cp));
987  blocknest = 1;
988  BEGIN(brace);
989  return PROC_DEF;
990  }
991  YY_BREAK
992 case 9:
994 #line 167 "<stdin>"
995 {
996  lvalp->name = omStrDup((char *)yytext);
997  yy_noeof = 0; BEGIN(INITIAL);
998  return STRINGTOK;
999  }
1000  YY_BREAK
1001 case 10:
1003 #line 172 "<stdin>"
1004 {
1005  yy_noeof = 0; BEGIN(INITIAL);
1006  return *yytext;
1007  }
1008  YY_BREAK
1009 case 11:
1011 #line 177 "<stdin>"
1012 {
1014  BEGIN(bracestr);
1015  yymore();
1016  }
1017  YY_BREAK
1018 case 12:
1020 #line 182 "<stdin>"
1021 { if (blocknest++) yymore(); }
1022  YY_BREAK
1023 case 13:
1025 #line 183 "<stdin>"
1026 { if (blocknest) yymore(); }
1027  YY_BREAK
1028 case 14:
1030 #line 184 "<stdin>"
1031 {
1032  if (blocknest)
1033  {
1034  lvalp->name = dupyytext();
1035  return STRINGTOK;
1036  }
1037  }
1038  YY_BREAK
1039 case 15:
1041 #line 191 "<stdin>"
1042 {
1043  if (--blocknest <= 0)
1044  {
1045  yy_noeof = 0;
1046  BEGIN(INITIAL);
1047  lvalp->name = dupyytext();
1048  return STRINGTOK;
1049  }
1050  yymore();
1051  }
1052  YY_BREAK
1053 case 16:
1055 #line 201 "<stdin>"
1056 {
1058  BEGIN(brace);
1059  yymore();
1060  }
1061  YY_BREAK
1062 case 17:
1064 #line 206 "<stdin>"
1065 { yymore(); }
1066  YY_BREAK
1067 case 18:
1069 #line 207 "<stdin>"
1070 { return '('; }
1071  YY_BREAK
1072 case 19:
1074 #line 208 "<stdin>"
1075 { return ','; }
1076  YY_BREAK
1077 case 20:
1079 #line 209 "<stdin>"
1080 { ; }
1081  YY_BREAK
1082 case 21:
1084 #line 210 "<stdin>"
1085 {
1086  lvalp->name = omStrDup((char *)yytext);
1087  return STRINGTOK;
1088  }
1089  YY_BREAK
1090 case 22:
1092 #line 214 "<stdin>"
1093 {
1094  lvalp->name = omStrDup((char *)yytext);
1095  return STRINGTOK;
1096  }
1097  YY_BREAK
1098 case 23:
1100 #line 218 "<stdin>"
1101 {
1102  yy_noeof = 0; BEGIN(INITIAL);
1103  return ')';
1104  }
1105  YY_BREAK
1106 case 24:
1108 #line 223 "<stdin>"
1109 {
1111  blocknest = 1;
1113  BEGIN(block);
1114  }
1115  YY_BREAK
1116 case 25:
1118 #line 229 "<stdin>"
1119 {
1121  BEGIN(blockstr);
1122  yymore();
1123  }
1124  YY_BREAK
1125 case 26:
1127 #line 234 "<stdin>"
1128 { yymore(); }
1129  YY_BREAK
1130 case 27:
1132 #line 235 "<stdin>"
1133 { yymore(); }
1134  YY_BREAK
1135 case 28:
1137 #line 236 "<stdin>"
1138 { yymore(); }
1139  YY_BREAK
1140 case 29:
1142 #line 237 "<stdin>"
1143 {
1145  BEGIN(block);
1146  yymore();
1147  }
1148  YY_BREAK
1149 case 30:
1151 #line 242 "<stdin>"
1152 { yymore(); }
1153  YY_BREAK
1154 case 31:
1156 #line 243 "<stdin>"
1157 { yymore(); }
1158  YY_BREAK
1159 case 32:
1161 #line 244 "<stdin>"
1162 { blocknest++; yymore(); }
1163  YY_BREAK
1164 case 33:
1166 #line 245 "<stdin>"
1167 {
1168  if (--blocknest <= 0)
1169  {
1170  BEGIN(INITIAL);
1171  yy_noeof = 0;
1172  lvalp->name = dupyytextNL();
1173  return BLOCKTOK;
1174  }
1175  yymore();
1176  }
1177  YY_BREAK
1178 case 34:
1180 #line 255 "<stdin>"
1181 { BEGIN(string); yy_noeof = noeof_string;}
1182  YY_BREAK
1183 case 35:
1185 #line 256 "<stdin>"
1186 { return SYS_BREAK; }
1187  YY_BREAK
1188 case 36:
1190 #line 257 "<stdin>"
1191 { yymore(); }
1192  YY_BREAK
1193 case 37:
1195 #line 258 "<stdin>"
1196 { yymore(); }
1197  YY_BREAK
1198 case 38:
1200 #line 259 "<stdin>"
1201 { yymore(); }
1202  YY_BREAK
1203 case 39:
1205 #line 260 "<stdin>"
1206 {
1207  char * s;
1208  yy_noeof = 0;
1209  BEGIN(INITIAL);
1210  s = lvalp->name = dupyytext();
1211  while (*yytext)
1212  {
1213  if (*yytext == '\\') yytext++;
1214  *s++ = *yytext++;
1215  }
1216  *s++ = *yytext++;
1217  return STRINGTOK;
1218  }
1219  YY_BREAK
1220 case 40:
1222 #line 274 "<stdin>"
1223 /* skip whitespace */
1224  YY_BREAK
1225 case 41:
1227 #line 275 "<stdin>"
1228 { return DOTDOT; }
1229  YY_BREAK
1230 case 42:
1232 #line 276 "<stdin>"
1233 { return COLONCOLON; }
1234  YY_BREAK
1235 case 43:
1237 #line 277 "<stdin>"
1238 { return MINUSMINUS; }
1239  YY_BREAK
1240 case 44:
1242 #line 278 "<stdin>"
1243 { return PLUSPLUS ; }
1244  YY_BREAK
1245 case 45:
1247 #line 279 "<stdin>"
1248 { return EQUAL_EQUAL; }
1249  YY_BREAK
1250 case 46:
1252 #line 280 "<stdin>"
1253 { lvalp->i='&'; return LOGIC_OP; }
1254  YY_BREAK
1255 case 47:
1257 #line 281 "<stdin>"
1258 { lvalp->i='|'; return LOGIC_OP; }
1259  YY_BREAK
1260 case 48:
1262 #line 282 "<stdin>"
1263 { lvalp->i=LE; return COMP_OP; }
1264  YY_BREAK
1265 case 49:
1267 #line 283 "<stdin>"
1268 { lvalp->i=GE; return COMP_OP; }
1269  YY_BREAK
1270 case 50:
1272 #line 284 "<stdin>"
1273 { return NOT; }
1274  YY_BREAK
1275 case 51:
1277 #line 285 "<stdin>"
1278 { return NOTEQUAL; }
1279  YY_BREAK
1280 case 52:
1282 #line 286 "<stdin>"
1283 { return NOTEQUAL; }
1284  YY_BREAK
1285 case 53:
1287 #line 287 "<stdin>"
1288 { return '^'; }
1289  YY_BREAK
1290 case 54:
1292 #line 288 "<stdin>"
1293 { return ARROW; }
1294  YY_BREAK
1295 case 55:
1297 #line 289 "<stdin>"
1298 { return '\\'; }
1299  YY_BREAK
1300 case 56:
1302 #line 290 "<stdin>"
1303 {
1304  lvalp->name = omStrDup("\n");
1305  return STRINGTOK;
1306  }
1307  YY_BREAK
1308 case 57:
1310 #line 294 "<stdin>"
1311 {
1312  lvalp->name = (char *)yytext;
1313  return INT_CONST;
1314  }
1315  YY_BREAK
1316 case 58:
1318 #line 298 "<stdin>"
1319 {
1320  lvalp->name = (char *)yytext;
1321  return RINGVAR;
1322  }
1323  YY_BREAK
1324 case 59:
1326 #line 302 "<stdin>"
1327 {
1328  m2_end(-1);
1329  }
1330  YY_BREAK
1331 case 60:
1333 #line 305 "<stdin>"
1334 {
1335  #ifdef MM_STAT
1336  mmStat(-500);
1337  #endif
1338  #ifdef OM_TRACK
1339  #ifndef SING_NDEBUG
1340  omPrintUsedTrackAddrs(stdout, 10);
1341  #endif
1342  #endif
1343  m2_end(0);
1344  }
1345  YY_BREAK
1346 case 61:
1348 #line 317 "<stdin>"
1349 {
1350  lvalp->name = (char *)yytext;
1351  return RINGVAR;
1352  }
1353  YY_BREAK
1354 case 62:
1356 #line 321 "<stdin>"
1357 {
1358  lvalp->name = (char *)yytext;
1359  return RINGVAR;
1360  }
1361  YY_BREAK
1362 case 63:
1363 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1364 yy_c_buf_p = yy_cp -= 1;
1365 YY_DO_BEFORE_ACTION; /* set up yytext again */
1367 #line 325 "<stdin>"
1368 {
1369  lvalp->name = (char *)yytext;
1370  return RINGVAR;
1371  }
1372  YY_BREAK
1373 case 64:
1375 #line 330 "<stdin>"
1376 {
1377  /* {name} */
1378  int rc=0;
1379  if (yytext[strlen((char *)yytext)-1] == '\n')
1380  {
1381  yytext[strlen((char *)yytext)-1] = '\0';
1382  }
1383  if (yyleng > 1)
1384  {
1385  rc = IsCmd((char *)yytext,lvalp->i);
1386  if (rc) return rc;
1387  }
1388  lvalp->name = omStrDup((char *)yytext);
1389  return UNKNOWN_IDENT;
1390  }
1391  YY_BREAK
1392 case 65:
1394 #line 346 "<stdin>"
1395 {
1396  /*if (*yytext == '\n') REJECT;*/
1397  register char ch= *yytext;
1398  lvalp->i = ch;
1399  switch(ch)
1400  {
1401  /* case '&': */
1402  case '|':
1403  return LOGIC_OP;
1404  /* case '/': */
1405  case '%':
1406  case '*':
1407  return MULDIV_OP;
1408  /* case '<': */
1409  case '>':
1410  return COMP_OP;
1411  default:
1412  break;
1413  }
1414  return ch;
1415  }
1416  YY_BREAK
1417 case 66:
1419 #line 367 "<stdin>"
1420 YY_FATAL_ERROR( "flex scanner jammed" );
1421  YY_BREAK
1422 case YY_STATE_EOF(INITIAL):
1423 case YY_STATE_EOF(string):
1424 case YY_STATE_EOF(block):
1425 case YY_STATE_EOF(blockstr):
1426 case YY_STATE_EOF(brace):
1427 case YY_STATE_EOF(bracestr):
1428 case YY_STATE_EOF(bracket):
1429 case YY_STATE_EOF(asstring):
1430  yyterminate();
1431 
1432  case YY_END_OF_BUFFER:
1433  {
1434  /* Amount of text matched not including the EOB char. */
1435  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1436 
1437  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1438  *yy_cp = yy_hold_char;
1440 
1441  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1442  {
1443  /* We're scanning a new file or input source. It's
1444  * possible that this happened because the user
1445  * just pointed yyin at a new source and called
1446  * yylex(). If so, then we have to assure
1447  * consistency between yy_current_buffer and our
1448  * globals. Here is the right place to do so, because
1449  * this is the first action (other than possibly a
1450  * back-up) that will match for the new input source.
1451  */
1452  yy_n_chars = yy_current_buffer->yy_n_chars;
1453  yy_current_buffer->yy_input_file = yyin;
1454  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1455  }
1456 
1457  /* Note that here we test for yy_c_buf_p "<=" to the position
1458  * of the first EOB in the buffer, since yy_c_buf_p will
1459  * already have been incremented past the NUL character
1460  * (since all states make transitions on EOB to the
1461  * end-of-buffer state). Contrast this with the test
1462  * in input().
1463  */
1464  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1465  { /* This was really a NUL. */
1466  yy_state_type yy_next_state;
1467 
1468  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1469 
1470  yy_current_state = yy_get_previous_state();
1471 
1472  /* Okay, we're now positioned to make the NUL
1473  * transition. We couldn't have
1474  * yy_get_previous_state() go ahead and do it
1475  * for us because it doesn't know how to deal
1476  * with the possibility of jamming (and we don't
1477  * want to build jamming into it because then it
1478  * will run more slowly).
1479  */
1480 
1481  yy_next_state = yy_try_NUL_trans( yy_current_state );
1482 
1483  yy_bp = yytext_ptr + YY_MORE_ADJ;
1484 
1485  if ( yy_next_state )
1486  {
1487  /* Consume the NUL. */
1488  yy_cp = ++yy_c_buf_p;
1489  yy_current_state = yy_next_state;
1490  goto yy_match;
1491  }
1492 
1493  else
1494  {
1495  yy_cp = yy_c_buf_p;
1496  goto yy_find_action;
1497  }
1498  }
1499 
1500  else switch ( yy_get_next_buffer() )
1501  {
1502  case EOB_ACT_END_OF_FILE:
1503  {
1505 
1506  if ( yywrap() )
1507  {
1508  /* Note: because we've taken care in
1509  * yy_get_next_buffer() to have set up
1510  * yytext, we can now set up
1511  * yy_c_buf_p so that if some total
1512  * hoser (like flex itself) wants to
1513  * call the scanner after we return the
1514  * YY_NULL, it'll still work - another
1515  * YY_NULL will get returned.
1516  */
1518 
1519  yy_act = YY_STATE_EOF(YY_START);
1520  goto do_action;
1521  }
1522 
1523  else
1524  {
1526  YY_NEW_FILE;
1527  }
1528  break;
1529  }
1530 
1531  case EOB_ACT_CONTINUE_SCAN:
1532  yy_c_buf_p =
1533  yytext_ptr + yy_amount_of_matched_text;
1534 
1535  yy_current_state = yy_get_previous_state();
1536 
1537  yy_cp = yy_c_buf_p;
1538  yy_bp = yytext_ptr + YY_MORE_ADJ;
1539  goto yy_match;
1540 
1541  case EOB_ACT_LAST_MATCH:
1542  yy_c_buf_p =
1543  &yy_current_buffer->yy_ch_buf[yy_n_chars];
1544 
1545  yy_current_state = yy_get_previous_state();
1546 
1547  yy_cp = yy_c_buf_p;
1548  yy_bp = yytext_ptr + YY_MORE_ADJ;
1549  goto yy_find_action;
1550  }
1551  break;
1552  }
1553 
1554  default:
1556  "fatal flex scanner internal error--no action found" );
1557  } /* end of action switch */
1558  } /* end of scanning one token */
1559  } /* end of yylex */
1560 
1561 
1562 /* yy_get_next_buffer - try to read in a new buffer
1563  *
1564  * Returns a code representing an action:
1565  * EOB_ACT_LAST_MATCH -
1566  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1567  * EOB_ACT_END_OF_FILE - end of file
1568  */
1569 
1571  {
1572  register char *dest = yy_current_buffer->yy_ch_buf;
1573  register char *source = yytext_ptr;
1574  register int number_to_move, i;
1575  int ret_val;
1576 
1577  if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1579  "fatal flex scanner internal error--end of buffer missed" );
1580 
1581  if ( yy_current_buffer->yy_fill_buffer == 0 )
1582  { /* Don't try to fill the buffer, so this is an EOF. */
1583  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1584  {
1585  /* We matched a single character, the EOB, so
1586  * treat this as a final EOF.
1587  */
1588  return EOB_ACT_END_OF_FILE;
1589  }
1590 
1591  else
1592  {
1593  /* We matched some text prior to the EOB, first
1594  * process it.
1595  */
1596  return EOB_ACT_LAST_MATCH;
1597  }
1598  }
1599 
1600  /* Try to read more data. */
1601 
1602  /* First move last chars to start of buffer. */
1603  number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1604 
1605  for ( i = 0; i < number_to_move; ++i )
1606  *(dest++) = *(source++);
1607 
1608  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1609  /* don't do the read, it's not guaranteed to return an EOF,
1610  * just force an EOF
1611  */
1612  yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1613 
1614  else
1615  {
1616  int num_to_read =
1617  yy_current_buffer->yy_buf_size - number_to_move - 1;
1618 
1619  while ( num_to_read <= 0 )
1620  { /* Not enough room in the buffer - grow it. */
1621 #ifdef YY_USES_REJECT
1623 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1624 #else
1625 
1626  /* just a shorter name for the current buffer */
1627  YY_BUFFER_STATE b = yy_current_buffer;
1628 
1629  int yy_c_buf_p_offset =
1630  (int) (yy_c_buf_p - b->yy_ch_buf);
1631 
1632  if ( b->yy_is_our_buffer )
1633  {
1634  int new_size = b->yy_buf_size * 2;
1635 
1636  if ( new_size <= 0 )
1637  b->yy_buf_size += b->yy_buf_size / 8;
1638  else
1639  b->yy_buf_size *= 2;
1640 
1641  b->yy_ch_buf = (char *)
1642  /* Include room in for 2 EOB chars. */
1643  yy_flex_realloc( (void *) b->yy_ch_buf,
1644  b->yy_buf_size + 2 );
1645  }
1646  else
1647  /* Can't grow it, we don't own it. */
1648  b->yy_ch_buf = 0;
1649 
1650  if ( ! b->yy_ch_buf )
1652  "fatal error - scanner input buffer overflow" );
1653 
1654  yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1655 
1656  num_to_read = yy_current_buffer->yy_buf_size -
1657  number_to_move - 1;
1658 #endif
1659  }
1660 
1661  if ( num_to_read > YY_READ_BUF_SIZE )
1662  num_to_read = YY_READ_BUF_SIZE;
1663 
1664  /* Read in more data. */
1665  YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1666  yy_n_chars, num_to_read );
1667 
1668  yy_current_buffer->yy_n_chars = yy_n_chars;
1669  }
1670 
1671  if ( yy_n_chars == 0 )
1672  {
1673  if ( number_to_move == YY_MORE_ADJ )
1674  {
1675  ret_val = EOB_ACT_END_OF_FILE;
1676  yyrestart( yyin );
1677  }
1678 
1679  else
1680  {
1681  ret_val = EOB_ACT_LAST_MATCH;
1682  yy_current_buffer->yy_buffer_status =
1684  }
1685  }
1686 
1687  else
1688  ret_val = EOB_ACT_CONTINUE_SCAN;
1689 
1690  yy_n_chars += number_to_move;
1693 
1694  yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1695 
1696  return ret_val;
1697  }
1698 
1699 
1700 /* yy_get_previous_state - get the state just before the EOB char was reached */
1701 
1702 static yy_state_type yy_get_previous_state()
1703  {
1704  register yy_state_type yy_current_state;
1705  register char *yy_cp;
1706 
1707  yy_current_state = yy_start;
1708  yy_current_state += YY_AT_BOL();
1709 
1710  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1711  {
1712  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1713  if ( yy_accept[yy_current_state] )
1714  {
1715  yy_last_accepting_state = yy_current_state;
1716  yy_last_accepting_cpos = yy_cp;
1717  }
1718  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1719  {
1720  yy_current_state = (int) yy_def[yy_current_state];
1721  if ( yy_current_state >= 171 )
1722  yy_c = yy_meta[(unsigned int) yy_c];
1723  }
1724  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1725  }
1726 
1727  return yy_current_state;
1728  }
1729 
1730 
1731 /* yy_try_NUL_trans - try to make a transition on the NUL character
1732  *
1733  * synopsis
1734  * next_state = yy_try_NUL_trans( current_state );
1735  */
1736 
1737 #ifdef YY_USE_PROTOS
1738 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1739 #else
1740 static yy_state_type yy_try_NUL_trans( yy_current_state )
1741 yy_state_type yy_current_state;
1742 #endif
1743  {
1744  register int yy_is_jam;
1745  register char *yy_cp = yy_c_buf_p;
1746 
1747  register YY_CHAR yy_c = 1;
1748  if ( yy_accept[yy_current_state] )
1749  {
1750  yy_last_accepting_state = yy_current_state;
1751  yy_last_accepting_cpos = yy_cp;
1752  }
1753  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1754  {
1755  yy_current_state = (int) yy_def[yy_current_state];
1756  if ( yy_current_state >= 171 )
1757  yy_c = yy_meta[(unsigned int) yy_c];
1758  }
1759  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1760  yy_is_jam = (yy_current_state == 170);
1761 
1762  return yy_is_jam ? 0 : yy_current_state;
1763  }
1764 
1765 
1766 #ifndef YY_NO_UNPUT
1767 #ifdef YY_USE_PROTOS
1768 static void yyunput( int c, register char *yy_bp )
1769 #else
1770 static void yyunput( c, yy_bp )
1771 int c;
1772 register char *yy_bp;
1773 #endif
1774  {
1775  register char *yy_cp = yy_c_buf_p;
1776 
1777  /* undo effects of setting up yytext */
1778  *yy_cp = yy_hold_char;
1779 
1780  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1781  { /* need to shift things up to make room */
1782  /* +2 for EOB chars. */
1783  register int number_to_move = yy_n_chars + 2;
1784  register char *dest = &yy_current_buffer->yy_ch_buf[
1785  yy_current_buffer->yy_buf_size + 2];
1786  register char *source =
1787  &yy_current_buffer->yy_ch_buf[number_to_move];
1788 
1789  while ( source > yy_current_buffer->yy_ch_buf )
1790  *--dest = *--source;
1791 
1792  yy_cp += (int) (dest - source);
1793  yy_bp += (int) (dest - source);
1794  yy_current_buffer->yy_n_chars =
1795  yy_n_chars = yy_current_buffer->yy_buf_size;
1796 
1797  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1798  YY_FATAL_ERROR( "flex scanner push-back overflow" );
1799  }
1800 
1801  *--yy_cp = (char) c;
1802 
1803 
1804  yytext_ptr = yy_bp;
1805  yy_hold_char = *yy_cp;
1806  yy_c_buf_p = yy_cp;
1807  }
1808 #endif /* ifndef YY_NO_UNPUT */
1809 
1810 
1811 #ifdef __cplusplus
1812 static int yyinput()
1813 #else
1814 static int input()
1815 #endif
1816  {
1817  int c;
1818 
1820 
1822  {
1823  /* yy_c_buf_p now points to the character we want to return.
1824  * If this occurs *before* the EOB characters, then it's a
1825  * valid NUL; if not, then we've hit the end of the buffer.
1826  */
1827  if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1828  /* This was really a NUL. */
1829  *yy_c_buf_p = '\0';
1830 
1831  else
1832  { /* need more input */
1833  int offset = yy_c_buf_p - yytext_ptr;
1834  ++yy_c_buf_p;
1835 
1836  switch ( yy_get_next_buffer() )
1837  {
1838  case EOB_ACT_LAST_MATCH:
1839  /* This happens because yy_g_n_b()
1840  * sees that we've accumulated a
1841  * token and flags that we need to
1842  * try matching the token before
1843  * proceeding. But for input(),
1844  * there's no matching to consider.
1845  * So convert the EOB_ACT_LAST_MATCH
1846  * to EOB_ACT_END_OF_FILE.
1847  */
1848 
1849  /* Reset buffer status. */
1850  yyrestart( yyin );
1851 
1852  /* fall through */
1853 
1854  case EOB_ACT_END_OF_FILE:
1855  {
1856  if ( yywrap() )
1857  return EOF;
1858 
1860  YY_NEW_FILE;
1861 #ifdef __cplusplus
1862  return yyinput();
1863 #else
1864  return input();
1865 #endif
1866  }
1867 
1868  case EOB_ACT_CONTINUE_SCAN:
1869  yy_c_buf_p = yytext_ptr + offset;
1870  break;
1871  }
1872  }
1873  }
1874 
1875  c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1876  *yy_c_buf_p = '\0'; /* preserve yytext */
1877  yy_hold_char = *++yy_c_buf_p;
1878 
1879  yy_current_buffer->yy_at_bol = (c == '\n');
1880 
1881  return c;
1882  }
1883 
1884 
1885 #ifdef YY_USE_PROTOS
1886 void yyrestart( FILE *input_file )
1887 #else
1888 void yyrestart( input_file )
1889 FILE *input_file;
1890 #endif
1891  {
1892  if ( ! yy_current_buffer )
1894 
1895  yy_init_buffer( yy_current_buffer, input_file );
1897  }
1898 
1899 
1900 #ifdef YY_USE_PROTOS
1901 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1902 #else
1903 void yy_switch_to_buffer( new_buffer )
1904 YY_BUFFER_STATE new_buffer;
1905 #endif
1906  {
1907  if ( yy_current_buffer == new_buffer )
1908  return;
1909 
1910  if ( yy_current_buffer )
1911  {
1912  /* Flush out information for old buffer. */
1914  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1915  yy_current_buffer->yy_n_chars = yy_n_chars;
1916  }
1917 
1918  yy_current_buffer = new_buffer;
1920 
1921  /* We don't actually know whether we did this switch during
1922  * EOF (yywrap()) processing, but the only time this flag
1923  * is looked at is after yywrap() is called, so it's safe
1924  * to go ahead and always set it.
1925  */
1927  }
1928 
1929 
1930 #ifdef YY_USE_PROTOS
1932 #else
1933 void yy_load_buffer_state()
1934 #endif
1935  {
1936  yy_n_chars = yy_current_buffer->yy_n_chars;
1937  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1938  yyin = yy_current_buffer->yy_input_file;
1940  }
1941 
1942 
1943 #ifdef YY_USE_PROTOS
1944 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1945 #else
1946 YY_BUFFER_STATE yy_create_buffer( file, size )
1947 FILE *file;
1948 int size;
1949 #endif
1950  {
1951  YY_BUFFER_STATE b;
1952 
1953  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1954  if ( ! b )
1955  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1956 
1957  b->yy_buf_size = size;
1958 
1959  /* yy_ch_buf has to be 2 characters longer than the size given because
1960  * we need to put in 2 end-of-buffer characters.
1961  */
1962  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1963  if ( ! b->yy_ch_buf )
1964  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1965 
1966  b->yy_is_our_buffer = 1;
1967 
1968  yy_init_buffer( b, file );
1969 
1970  return b;
1971  }
1972 
1973 
1974 #ifdef YY_USE_PROTOS
1975 void yy_delete_buffer( YY_BUFFER_STATE b )
1976 #else
1977 void yy_delete_buffer( b )
1978 YY_BUFFER_STATE b;
1979 #endif
1980  {
1981  if ( ! b )
1982  return;
1983 
1984  if ( b == yy_current_buffer )
1985  yy_current_buffer = (YY_BUFFER_STATE) 0;
1986 
1987  if ( b->yy_is_our_buffer )
1988  yy_flex_free( (void *) b->yy_ch_buf );
1989 
1990  yy_flex_free( (void *) b );
1991  }
1992 
1993 
1994 #ifndef YY_ALWAYS_INTERACTIVE
1995 #ifndef YY_NEVER_INTERACTIVE
1996 extern int isatty YY_PROTO(( int ));
1997 #endif
1998 #endif
1999 
2000 #ifdef YY_USE_PROTOS
2001 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2002 #else
2003 void yy_init_buffer( b, file )
2004 YY_BUFFER_STATE b;
2005 FILE *file;
2006 #endif
2007 
2008 
2009  {
2010  yy_flush_buffer( b );
2011 
2012  b->yy_input_file = file;
2013  b->yy_fill_buffer = 1;
2014 
2015 #if YY_ALWAYS_INTERACTIVE
2016  b->yy_is_interactive = 1;
2017 #else
2018 #if YY_NEVER_INTERACTIVE
2019  b->yy_is_interactive = 0;
2020 #else
2021  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2022 #endif
2023 #endif
2024  }
2025 
2026 
2027 #ifdef YY_USE_PROTOS
2028 void yy_flush_buffer( YY_BUFFER_STATE b )
2029 #else
2030 void yy_flush_buffer( b )
2031 YY_BUFFER_STATE b;
2032 #endif
2033 
2034  {
2035  if ( ! b )
2036  return;
2037 
2038  b->yy_n_chars = 0;
2039 
2040  /* We always need two end-of-buffer characters. The first causes
2041  * a transition to the end-of-buffer state. The second causes
2042  * a jam in that state.
2043  */
2044  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2045  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2046 
2047  b->yy_buf_pos = &b->yy_ch_buf[0];
2048 
2049  b->yy_at_bol = 1;
2050  b->yy_buffer_status = YY_BUFFER_NEW;
2051 
2052  if ( b == yy_current_buffer )
2054  }
2055 
2056 
2057 #ifndef YY_NO_SCAN_BUFFER
2058 #ifdef YY_USE_PROTOS
2059 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2060 #else
2061 YY_BUFFER_STATE yy_scan_buffer( base, size )
2062 char *base;
2063 yy_size_t size;
2064 #endif
2065  {
2066  YY_BUFFER_STATE b;
2067 
2068  if ( size < 2 ||
2069  base[size-2] != YY_END_OF_BUFFER_CHAR ||
2070  base[size-1] != YY_END_OF_BUFFER_CHAR )
2071  /* They forgot to leave room for the EOB's. */
2072  return 0;
2073 
2074  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2075  if ( ! b )
2076  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2077 
2078  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2079  b->yy_buf_pos = b->yy_ch_buf = base;
2080  b->yy_is_our_buffer = 0;
2081  b->yy_input_file = 0;
2082  b->yy_n_chars = b->yy_buf_size;
2083  b->yy_is_interactive = 0;
2084  b->yy_at_bol = 1;
2085  b->yy_fill_buffer = 0;
2086  b->yy_buffer_status = YY_BUFFER_NEW;
2087 
2088  yy_switch_to_buffer( b );
2089 
2090  return b;
2091  }
2092 #endif
2093 
2094 
2095 #ifndef YY_NO_SCAN_STRING
2096 #ifdef YY_USE_PROTOS
2097 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2098 #else
2099 YY_BUFFER_STATE yy_scan_string( yy_str )
2100 yyconst char *yy_str;
2101 #endif
2102  {
2103  int len;
2104  for ( len = 0; yy_str[len]; ++len )
2105  ;
2106 
2107  return yy_scan_bytes( yy_str, len );
2108  }
2109 #endif
2110 
2111 
2112 #ifndef YY_NO_SCAN_BYTES
2113 #ifdef YY_USE_PROTOS
2114 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2115 #else
2116 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2117 yyconst char *bytes;
2118 int len;
2119 #endif
2120  {
2121  YY_BUFFER_STATE b;
2122  char *buf;
2123  yy_size_t n;
2124  int i;
2125 
2126  /* Get memory for full buffer, including space for trailing EOB's. */
2127  n = len + 2;
2128  buf = (char *) yy_flex_alloc( n );
2129  if ( ! buf )
2130  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2131 
2132  for ( i = 0; i < len; ++i )
2133  buf[i] = bytes[i];
2134 
2135  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2136 
2137  b = yy_scan_buffer( buf, n );
2138  if ( ! b )
2139  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2140 
2141  /* It's okay to grow etc. this buffer, and we should throw it
2142  * away when we're done.
2143  */
2144  b->yy_is_our_buffer = 1;
2145 
2146  return b;
2147  }
2148 #endif
2149 
2150 
2151 #ifndef YY_NO_PUSH_STATE
2152 #ifdef YY_USE_PROTOS
2153 static void yy_push_state( int new_state )
2154 #else
2155 static void yy_push_state( new_state )
2156 int new_state;
2157 #endif
2158  {
2159  if ( yy_start_stack_ptr >= yy_start_stack_depth )
2160  {
2161  yy_size_t new_size;
2162 
2163  yy_start_stack_depth += YY_START_STACK_INCR;
2164  new_size = yy_start_stack_depth * sizeof( int );
2165 
2166  if ( ! yy_start_stack )
2167  yy_start_stack = (int *) yy_flex_alloc( new_size );
2168 
2169  else
2170  yy_start_stack = (int *) yy_flex_realloc(
2171  (void *) yy_start_stack, new_size );
2172 
2173  if ( ! yy_start_stack )
2175  "out of memory expanding start-condition stack" );
2176  }
2177 
2178  yy_start_stack[yy_start_stack_ptr++] = YY_START;
2179 
2180  BEGIN(new_state);
2181  }
2182 #endif
2183 
2184 
2185 #ifndef YY_NO_POP_STATE
2186 static void yy_pop_state()
2187  {
2188  if ( --yy_start_stack_ptr < 0 )
2189  YY_FATAL_ERROR( "start-condition stack underflow" );
2190 
2191  BEGIN(yy_start_stack[yy_start_stack_ptr]);
2192  }
2193 #endif
2194 
2195 
2196 #ifndef YY_NO_TOP_STATE
2197 static int yy_top_state()
2198  {
2199  return yy_start_stack[yy_start_stack_ptr - 1];
2200  }
2201 #endif
2202 
2203 #ifndef YY_EXIT_FAILURE
2204 #define YY_EXIT_FAILURE 2
2205 #endif
2206 
2207 #ifdef YY_USE_PROTOS
2208 static void yy_fatal_error( yyconst char msg[] )
2209 #else
2210 static void yy_fatal_error( msg )
2211 char msg[];
2212 #endif
2213  {
2214  (void) fprintf( stderr, "%s\n", msg );
2215  exit( YY_EXIT_FAILURE );
2216  }
2217 
2218 
2219 
2220 /* Redefine yyless() so it works in section 3 code. */
2221 
2222 #undef yyless
2223 #define yyless(n) \
2224  do \
2225  { \
2226  /* Undo effects of setting up yytext. */ \
2227  yytext[yyleng] = yy_hold_char; \
2228  yy_c_buf_p = yytext + n; \
2229  yy_hold_char = *yy_c_buf_p; \
2230  *yy_c_buf_p = '\0'; \
2231  yyleng = n; \
2232  } \
2233  while ( 0 )
2234 
2235 
2236 /* Internal utility routines. */
2237 
2238 #ifndef yytext_ptr
2239 #ifdef YY_USE_PROTOS
2240 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2241 #else
2242 static void yy_flex_strncpy( s1, s2, n )
2243 char *s1;
2244 yyconst char *s2;
2245 int n;
2246 #endif
2247  {
2248  register int i;
2249  for ( i = 0; i < n; ++i )
2250  s1[i] = s2[i];
2251  }
2252 #endif
2253 
2254 #ifdef YY_NEED_STRLEN
2255 #ifdef YY_USE_PROTOS
2256 static int yy_flex_strlen( yyconst char *s )
2257 #else
2258 static int yy_flex_strlen( s )
2259 yyconst char *s;
2260 #endif
2261  {
2262  register int n;
2263  for ( n = 0; s[n]; ++n )
2264  ;
2265 
2266  return n;
2267  }
2268 #endif
2269 
2270 
2271 #ifdef YY_USE_PROTOS
2272 static void *yy_flex_alloc( yy_size_t size )
2273 #else
2274 static void *yy_flex_alloc( size )
2275 yy_size_t size;
2276 #endif
2277  {
2278  return (void *) malloc( size );
2279  }
2280 
2281 #ifdef YY_USE_PROTOS
2282 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2283 #else
2284 static void *yy_flex_realloc( ptr, size )
2285 void *ptr;
2286 yy_size_t size;
2287 #endif
2288  {
2289  /* The cast to (char *) in the following accommodates both
2290  * implementations that use char* generic pointers, and those
2291  * that use void* generic pointers. It works with the latter
2292  * because both ANSI C and C++ allow castless assignment from
2293  * any pointer type to void*, and deal with argument conversions
2294  * as though doing an assignment.
2295  */
2296  return (void *) realloc( (char *) ptr, size );
2297  }
2298 
2299 #ifdef YY_USE_PROTOS
2300 static void yy_flex_free( void *ptr )
2301 #else
2302 static void yy_flex_free( ptr )
2303 void *ptr;
2304 #endif
2305  {
2306  free( ptr );
2307  }
2308 
2309 #if YY_MAIN
2310 int main()
2311  {
2312  yylex();
2313  return 0;
2314  }
2315 #endif
2316 #line 367 "<stdin>"
2317 
2318 
2320 {
2321  void * oldb = YY_CURRENT_BUFFER;
2323  return oldb;
2324 }
2325 
2326 void myyoldbuffer(void * oldb)
2327 {
2329  yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
2330  //yy_flush_buffer((YY_BUFFER_STATE)oldb);
2331 }
2332 
2334 
register char * yy_bp
Definition: scanner.cc:824
static void * my_realloc(void *addr, size_t size)
Definition: scanner.cc:597
Definition: grammar.cc:273
#define YY_START
Definition: scanner.cc:85
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1944
#define YY_FLUSH_BUFFER
Definition: scanner.cc:236
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1901
#define YY_RULE_SETUP
Definition: scanner.cc:815
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define brace
Definition: scanner.cc:666
YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, int len)
Definition: scanner.cc:2114
unsigned int yy_size_t
Definition: libparse.cc:159
int feReadLine(char *b, int l)
Definition: fevoices.cc:497
#define EOB_ACT_LAST_MATCH
Definition: scanner.cc:106
static yyconst short int yy_chk[610]
Definition: scanner.cc:474
int yylineno
Definition: febase.cc:45
#define YY_BUFFER_EOF_PENDING
Definition: scanner.cc:198
static char yy_hold_char
Definition: scanner.cc:211
#define blockstr
Definition: scanner.cc:664
#define block
Definition: scanner.cc:662
int yy_buffer_status
Definition: libparse.cc:203
#define YY_RESTORE_YY_MORE_OFFSET
Definition: scanner.cc:556
void yy_load_buffer_state(void)
Definition: scanner.cc:1931
int main(int argc, char *argv[])
Definition: omTables.c:165
#define malloc
Definition: scanner.cc:608
int blocknest
Definition: scanner.cc:581
static yyconst short int yy_def[192]
Definition: scanner.cc:377
#define BEGIN
Definition: scanner.cc:79
loop
Definition: myNF.cc:98
#define INITIAL
Definition: scanner.cc:559
YY_BUFFER_STATE yy_scan_string(yyconst char *yy_str)
Definition: scanner.cc:2097
static char * dupyytext()
Definition: scanner.cc:613
static yyconst short int yy_nxt[610]
Definition: scanner.cc:403
#define YY_MORE_ADJ
Definition: scanner.cc:555
static int yy_did_buffer_switch_on_eof
Definition: scanner.cc:226
#define YY_INPUT(buf, result, max_size)
Definition: scanner.cc:650
static void yy_flex_free(void *ptr)
Definition: scanner.cc:2300
static int yy_more_flag
Definition: scanner.cc:552
char * yy_buf_pos
Definition: libparse.cc:167
char prompt_char
Definition: febase.cc:44
void myyoldbuffer(void *oldb)
Definition: scanner.cc:2326
static yyconst short int yy_accept[171]
Definition: scanner.cc:288
Definition: grammar.cc:271
#define COMP_OP
Definition: tok.h:31
void m2_end(int i)
Definition: misc_ip.cc:1069
char N base
Definition: ValueTraits.h:144
static yyconst short int yy_base[192]
Definition: scanner.cc:351
#define YY_DO_BEFORE_ACTION
Definition: scanner.cc:278
int yylex(MYYSTYPE *l)
#define YY_START_STACK_INCR
Definition: scanner.cc:788
#define YY_SC_TO_UI(c)
Definition: scanner.cc:73
#define MULDIV_OP
Definition: tok.h:30
#define YY_END_OF_BUFFER
Definition: scanner.cc:287
static void my_free(void *addr)
Definition: scanner.cc:603
void * myynewbuffer()
Definition: scanner.cc:2319
yy_size_t yy_buf_size
Definition: libparse.cc:172
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: scanner.cc:2282
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define YY_BUFFER_NORMAL
Definition: scanner.cc:187
unsigned int yy_size_t
Definition: scanner.cc:141
#define YY_AT_BOL()
Definition: scanner.cc:262
#define EOB_ACT_CONTINUE_SCAN
Definition: scanner.cc:104
int yy_is_interactive
Definition: libparse.cc:190
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: scanner.cc:2001
static int yy_init
Definition: scanner.cc:220
static void yyunput(int c, register char *yy_bp)
Definition: scanner.cc:1768
#define yyterminate()
Definition: scanner.cc:783
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
static int yy_more_len
Definition: scanner.cc:553
#define YY_CURRENT_BUFFER
Definition: scanner.cc:207
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
static int yy_start
Definition: scanner.cc:221
register int yy_act
Definition: scanner.cc:825
int yy_noeof
Definition: fevoices.cc:55
#define omFree(addr)
Definition: omAllocDecl.h:261
int yyleng
Definition: scanner.cc:216
int status int void * buf
Definition: si_signals.h:59
static yy_state_type yy_get_previous_state()
Definition: scanner.cc:1702
static char * yy_c_buf_p
Definition: scanner.cc:219
int inerror
Definition: grammar.cc:176
Definition: grammar.cc:270
#define YY_EXIT_FAILURE
Definition: scanner.cc:2204
BOOLEAN exitVoice()
Definition: fevoices.cc:346
#define YY_BREAK
Definition: scanner.cc:812
#define YY_BUFFER_NEW
Definition: scanner.cc:186
static yyconst int yy_meta[49]
Definition: scanner.cc:342
int i
Definition: cfEzgcd.cc:123
static yy_state_type yy_last_accepting_state
Definition: scanner.cc:545
char * iiProcName(char *buf, char &ct, char *&e)
Definition: iplib.cc:114
#define yytext_ptr
Definition: scanner.cc:268
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition: scanner.cc:1738
#define bracestr
Definition: scanner.cc:668
#define LOGIC_OP
Definition: tok.h:29
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
static int yy_get_next_buffer()
Definition: scanner.cc:1570
FILE * yy_input_file
Definition: libparse.cc:164
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
void yy_delete_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:1975
#define YY_BUF_SIZE
Definition: scanner.cc:97
int yy_is_our_buffer
Definition: libparse.cc:183
#define YY_PROTO(proto)
Definition: scanner.cc:60
#define NULL
Definition: omList.c:10
char * yy_ch_buf
Definition: libparse.cc:166
static int yyinput()
Definition: scanner.cc:1812
#define yymore()
Definition: scanner.cc:554
FILE * yyout
Definition: scanner.cc:265
#define realloc
Definition: scanner.cc:610
static void * my_malloc(size_t size)
Definition: scanner.cc:590
static yyconst int yy_ec[256]
Definition: scanner.cc:310
int yywrap()
Definition: scanner.cc:646
#define free
Definition: scanner.cc:612
register char * yy_cp
Definition: scanner.cc:824
static void * yy_flex_alloc(yy_size_t size)
Definition: scanner.cc:2272
int yy_blocklineno
Definition: fevoices.cc:56
unsigned char YY_CHAR
Definition: scanner.cc:264
FILE * yyin
Definition: scanner.cc:265
static void yy_fatal_error(yyconst char msg[])
Definition: scanner.cc:2208
#define YY_READ_BUF_SIZE
Definition: scanner.cc:744
static char * dupyytextNL()
Definition: scanner.cc:622
#define EOB_ACT_END_OF_FILE
Definition: scanner.cc:105
void omPrintUsedTrackAddrs(FILE *fd, int max_frames)
Definition: omDebugCheck.c:568
#define YY_STATE_EOF(state)
Definition: scanner.cc:89
void omMarkAsStaticAddr(void *addr)
void my_yy_flush()
Definition: scanner.cc:2333
#define YY_NEW_FILE
Definition: scanner.cc:92
void yy_flush_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:2028
void yyrestart(FILE *input_file)
Definition: scanner.cc:1886
int offset
Definition: libparse.cc:1091
#define yyconst
Definition: scanner.cc:53
#define asstring
Definition: scanner.cc:672
char * yytext
Definition: scanner.cc:557
const poly b
Definition: syzextra.cc:213
#define omRealloc(addr, size)
Definition: omAllocDecl.h:225
static char * yy_last_accepting_cpos
Definition: scanner.cc:546
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
Definition: scanner.cc:2059
#define YY_USER_INIT
Definition: libparse.cc:1208
int l
Definition: cfEzgcd.cc:94
#define YY_DECL
Definition: scanner.cc:642
int yy_state_type
Definition: scanner.cc:266
int IsCmd(const char *n, int &tok)
Definition: iparith.cc:8822
#define bracket
Definition: scanner.cc:670
#define omStrDup(s)
Definition: omAllocDecl.h:263