Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/RenderSystems/GL/src/nvparse/_ps1.0_lexer.cpp @ 3

Last change on this file since 3 was 3, checked in by anonymous, 17 years ago
=update
File size: 48.4 KB

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

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

Download in other formats: