Context Navigation

source: git/Singular/scanner.cc @ 92e132

fieker-DuValspielwiese

Last change on this file since 92e132 was 250d2e, checked in by Hans Schoenemann <hannes@…>, 8 years ago
flex stuff: libparse is non-interactive
Property mode set to `100644`
File size: 60.6 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
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	*/
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
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	*/
226	static int yy_did_buffer_switch_on_eof;
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;
546	static char *yy_last_accepting_cpos;
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 "scanner.l"
559	#define INITIAL 0
560	#line 2 "scanner.l"
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);
618	omMarkAsStaticAddr(s);
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 "scanner.l"
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 )
848	yy_current_buffer =
849	yy_create_buffer( yyin, YY_BUF_SIZE );
850
851	yy_load_buffer_state();
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
903	YY_DO_BEFORE_ACTION;
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:
919	YY_RULE_SETUP
920	#line 122 "scanner.l"
921	{ }
922	YY_BREAK
923	case 2:
924	YY_RULE_SETUP
925	#line 123 "scanner.l"
926	{ }
927	YY_BREAK
928	case 3:
929	YY_RULE_SETUP
930	#line 124 "scanner.l"
931	{
932	yy_noeof=noeof_comment;
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:
951	YY_RULE_SETUP
952	#line 142 "scanner.l"
953	{ prompt_char='.';
954	blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);
955	return WHILE_CMD;}
956	YY_BREAK
957	case 5:
958	YY_RULE_SETUP
959	#line 145 "scanner.l"
960	{ prompt_char='.';
961	blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);
962	return FOR_CMD;}
963	YY_BREAK
964	case 6:
965	YY_RULE_SETUP
966	#line 149 "scanner.l"
967	{ yy_noeof = noeof_asstring;
968	BEGIN(asstring);
969	return HELP_CMD;
970	}
971	YY_BREAK
972	case 7:
973	YY_RULE_SETUP
974	#line 154 "scanner.l"
975	{ yy_noeof = noeof_asstring;
976	BEGIN(asstring);
977	return EXAMPLE_CMD;
978	}
979	YY_BREAK
980	case 8:
981	YY_RULE_SETUP
982	#line 159 "scanner.l"
983	{
984	char c; char *cp;
985	lvalp->name = omStrDup(iiProcName((char *)yytext,c,cp));
986	yy_noeof = noeof_procname;
987	blocknest = 1;
988	BEGIN(brace);
989	return PROC_DEF;
990	}
991	YY_BREAK
992	case 9:
993	YY_RULE_SETUP
994	#line 167 "scanner.l"
995	{
996	lvalp->name = omStrDup((char *)yytext);
997	yy_noeof = 0; BEGIN(INITIAL);
998	return STRINGTOK;
999	}
1000	YY_BREAK
1001	case 10:
1002	YY_RULE_SETUP
1003	#line 172 "scanner.l"
1004	{
1005	yy_noeof = 0; BEGIN(INITIAL);
1006	return *yytext;
1007	}
1008	YY_BREAK
1009	case 11:
1010	YY_RULE_SETUP
1011	#line 177 "scanner.l"
1012	{
1013	yy_noeof = noeof_string;
1014	BEGIN(bracestr);
1015	yymore();
1016	}
1017	YY_BREAK
1018	case 12:
1019	YY_RULE_SETUP
1020	#line 182 "scanner.l"
1021	{ if (blocknest++) yymore(); }
1022	YY_BREAK
1023	case 13:
1024	YY_RULE_SETUP
1025	#line 183 "scanner.l"
1026	{ if (blocknest) yymore(); }
1027	YY_BREAK
1028	case 14:
1029	YY_RULE_SETUP
1030	#line 184 "scanner.l"
1031	{
1032	if (blocknest)
1033	{
1034	lvalp->name = dupyytext();
1035	return STRINGTOK;
1036	}
1037	}
1038	YY_BREAK
1039	case 15:
1040	YY_RULE_SETUP
1041	#line 191 "scanner.l"
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:
1054	YY_RULE_SETUP
1055	#line 201 "scanner.l"
1056	{
1057	yy_noeof = noeof_brace;
1058	BEGIN(brace);
1059	yymore();
1060	}
1061	YY_BREAK
1062	case 17:
1063	YY_RULE_SETUP
1064	#line 206 "scanner.l"
1065	{ yymore(); }
1066	YY_BREAK
1067	case 18:
1068	YY_RULE_SETUP
1069	#line 207 "scanner.l"
1070	{ return '('; }
1071	YY_BREAK
1072	case 19:
1073	YY_RULE_SETUP
1074	#line 208 "scanner.l"
1075	{ return ','; }
1076	YY_BREAK
1077	case 20:
1078	YY_RULE_SETUP
1079	#line 209 "scanner.l"
1080	{ ; }
1081	YY_BREAK
1082	case 21:
1083	YY_RULE_SETUP
1084	#line 210 "scanner.l"
1085	{
1086	lvalp->name = omStrDup((char *)yytext);
1087	return STRINGTOK;
1088	}
1089	YY_BREAK
1090	case 22:
1091	YY_RULE_SETUP
1092	#line 214 "scanner.l"
1093	{
1094	lvalp->name = omStrDup((char *)yytext);
1095	return STRINGTOK;
1096	}
1097	YY_BREAK
1098	case 23:
1099	YY_RULE_SETUP
1100	#line 218 "scanner.l"
1101	{
1102	yy_noeof = 0; BEGIN(INITIAL);
1103	return ')';
1104	}
1105	YY_BREAK
1106	case 24:
1107	YY_RULE_SETUP
1108	#line 223 "scanner.l"
1109	{
1110	yy_blocklineno = yylineno;
1111	blocknest = 1;
1112	yy_noeof = noeof_block;
1113	BEGIN(block);
1114	}
1115	YY_BREAK
1116	case 25:
1117	YY_RULE_SETUP
1118	#line 229 "scanner.l"
1119	{
1120	yy_noeof = noeof_string;
1121	BEGIN(blockstr);
1122	yymore();
1123	}
1124	YY_BREAK
1125	case 26:
1126	YY_RULE_SETUP
1127	#line 234 "scanner.l"
1128	{ yymore(); }
1129	YY_BREAK
1130	case 27:
1131	YY_RULE_SETUP
1132	#line 235 "scanner.l"
1133	{ yymore(); }
1134	YY_BREAK
1135	case 28:
1136	YY_RULE_SETUP
1137	#line 236 "scanner.l"
1138	{ yymore(); }
1139	YY_BREAK
1140	case 29:
1141	YY_RULE_SETUP
1142	#line 237 "scanner.l"
1143	{
1144	yy_noeof = noeof_block;
1145	BEGIN(block);
1146	yymore();
1147	}
1148	YY_BREAK
1149	case 30:
1150	YY_RULE_SETUP
1151	#line 242 "scanner.l"
1152	{ yymore(); }
1153	YY_BREAK
1154	case 31:
1155	YY_RULE_SETUP
1156	#line 243 "scanner.l"
1157	{ yymore(); }
1158	YY_BREAK
1159	case 32:
1160	YY_RULE_SETUP
1161	#line 244 "scanner.l"
1162	{ blocknest++; yymore(); }
1163	YY_BREAK
1164	case 33:
1165	YY_RULE_SETUP
1166	#line 245 "scanner.l"
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:
1179	YY_RULE_SETUP
1180	#line 255 "scanner.l"
1181	{ BEGIN(string); yy_noeof = noeof_string;}
1182	YY_BREAK
1183	case 35:
1184	YY_RULE_SETUP
1185	#line 256 "scanner.l"
1186	{ return SYS_BREAK; }
1187	YY_BREAK
1188	case 36:
1189	YY_RULE_SETUP
1190	#line 257 "scanner.l"
1191	{ yymore(); }
1192	YY_BREAK
1193	case 37:
1194	YY_RULE_SETUP
1195	#line 258 "scanner.l"
1196	{ yymore(); }
1197	YY_BREAK
1198	case 38:
1199	YY_RULE_SETUP
1200	#line 259 "scanner.l"
1201	{ yymore(); }
1202	YY_BREAK
1203	case 39:
1204	YY_RULE_SETUP
1205	#line 260 "scanner.l"
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:
1221	YY_RULE_SETUP
1222	#line 274 "scanner.l"
1223	/* skip whitespace */
1224	YY_BREAK
1225	case 41:
1226	YY_RULE_SETUP
1227	#line 275 "scanner.l"
1228	{ return DOTDOT; }
1229	YY_BREAK
1230	case 42:
1231	YY_RULE_SETUP
1232	#line 276 "scanner.l"
1233	{ return COLONCOLON; }
1234	YY_BREAK
1235	case 43:
1236	YY_RULE_SETUP
1237	#line 277 "scanner.l"
1238	{ return MINUSMINUS; }
1239	YY_BREAK
1240	case 44:
1241	YY_RULE_SETUP
1242	#line 278 "scanner.l"
1243	{ return PLUSPLUS ; }
1244	YY_BREAK
1245	case 45:
1246	YY_RULE_SETUP
1247	#line 279 "scanner.l"
1248	{ return EQUAL_EQUAL; }
1249	YY_BREAK
1250	case 46:
1251	YY_RULE_SETUP
1252	#line 280 "scanner.l"
1253	{ lvalp->i='&'; return LOGIC_OP; }
1254	YY_BREAK
1255	case 47:
1256	YY_RULE_SETUP
1257	#line 281 "scanner.l"
1258	{ lvalp->i='\|'; return LOGIC_OP; }
1259	YY_BREAK
1260	case 48:
1261	YY_RULE_SETUP
1262	#line 282 "scanner.l"
1263	{ lvalp->i=LE; return COMP_OP; }
1264	YY_BREAK
1265	case 49:
1266	YY_RULE_SETUP
1267	#line 283 "scanner.l"
1268	{ lvalp->i=GE; return COMP_OP; }
1269	YY_BREAK
1270	case 50:
1271	YY_RULE_SETUP
1272	#line 284 "scanner.l"
1273	{ return NOT; }
1274	YY_BREAK
1275	case 51:
1276	YY_RULE_SETUP
1277	#line 285 "scanner.l"
1278	{ return NOTEQUAL; }
1279	YY_BREAK
1280	case 52:
1281	YY_RULE_SETUP
1282	#line 286 "scanner.l"
1283	{ return NOTEQUAL; }
1284	YY_BREAK
1285	case 53:
1286	YY_RULE_SETUP
1287	#line 287 "scanner.l"
1288	{ return '^'; }
1289	YY_BREAK
1290	case 54:
1291	YY_RULE_SETUP
1292	#line 288 "scanner.l"
1293	{ return ARROW; }
1294	YY_BREAK
1295	case 55:
1296	YY_RULE_SETUP
1297	#line 289 "scanner.l"
1298	{ return '\\'; }
1299	YY_BREAK
1300	case 56:
1301	YY_RULE_SETUP
1302	#line 290 "scanner.l"
1303	{
1304	lvalp->name = omStrDup("\n");
1305	return STRINGTOK;
1306	}
1307	YY_BREAK
1308	case 57:
1309	YY_RULE_SETUP
1310	#line 294 "scanner.l"
1311	{
1312	lvalp->name = (char *)yytext;
1313	return INT_CONST;
1314	}
1315	YY_BREAK
1316	case 58:
1317	YY_RULE_SETUP
1318	#line 298 "scanner.l"
1319	{
1320	lvalp->name = (char *)yytext;
1321	return RINGVAR;
1322	}
1323	YY_BREAK
1324	case 59:
1325	YY_RULE_SETUP
1326	#line 302 "scanner.l"
1327	{
1328	m2_end(-1);
1329	}
1330	YY_BREAK
1331	case 60:
1332	YY_RULE_SETUP
1333	#line 305 "scanner.l"
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:
1347	YY_RULE_SETUP
1348	#line 317 "scanner.l"
1349	{
1350	lvalp->name = (char *)yytext;
1351	return RINGVAR;
1352	}
1353	YY_BREAK
1354	case 62:
1355	YY_RULE_SETUP
1356	#line 321 "scanner.l"
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 */
1366	YY_RULE_SETUP
1367	#line 325 "scanner.l"
1368	{
1369	lvalp->name = (char *)yytext;
1370	return RINGVAR;
1371	}
1372	YY_BREAK
1373	case 64:
1374	YY_RULE_SETUP
1375	#line 330 "scanner.l"
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:
1393	YY_RULE_SETUP
1394	#line 346 "scanner.l"
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:
1418	YY_RULE_SETUP
1419	#line 367 "scanner.l"
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;
1439	YY_RESTORE_YY_MORE_OFFSET
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	{
1504	yy_did_buffer_switch_on_eof = 0;
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	*/
1517	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1518
1519	yy_act = YY_STATE_EOF(YY_START);
1520	goto do_action;
1521	}
1522
1523	else
1524	{
1525	if ( ! yy_did_buffer_switch_on_eof )
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:
1555	YY_FATAL_ERROR(
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
1570	static int yy_get_next_buffer()
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] )
1578	YY_FATAL_ERROR(
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
1622	YY_FATAL_ERROR(
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 )
1651	YY_FATAL_ERROR(
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 =
1683	YY_BUFFER_EOF_PENDING;
1684	}
1685	}
1686
1687	else
1688	ret_val = EOB_ACT_CONTINUE_SCAN;
1689
1690	yy_n_chars += number_to_move;
1691	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1692	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
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
1819	*yy_c_buf_p = yy_hold_char;
1820
1821	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
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
1859	if ( ! yy_did_buffer_switch_on_eof )
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 )
1893	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1894
1895	yy_init_buffer( yy_current_buffer, input_file );
1896	yy_load_buffer_state();
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. */
1913	*yy_c_buf_p = yy_hold_char;
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;
1919	yy_load_buffer_state();
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	*/
1926	yy_did_buffer_switch_on_eof = 1;
1927	}
1928
1929
1930	#ifdef YY_USE_PROTOS
1931	void yy_load_buffer_state( void )
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;
1939	yy_hold_char = *yy_c_buf_p;
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 )
2053	yy_load_buffer_state();
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 )
2174	YY_FATAL_ERROR(
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 "scanner.l"
2317
2318
2319	void * myynewbuffer()
2320	{
2321	void * oldb = YY_CURRENT_BUFFER;
2322	yy_switch_to_buffer(yy_create_buffer(NULL, YY_BUF_SIZE));
2323	return oldb;
2324	}
2325
2326	void myyoldbuffer(void * oldb)
2327	{
2328	yy_delete_buffer(YY_CURRENT_BUFFER);
2329	yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
2330	//yy_flush_buffer((YY_BUFFER_STATE)oldb);
2331	}
2332
2333	void my_yy_flush() { YY_FLUSH_BUFFER;BEGIN(0); }

Note: See TracBrowser for help on using the repository browser.

Download in other formats: