source: git/Singular/scanner.cc @ b0732eb

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