Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

_rc1.0_lexer.cpp @ 5

Last change on this file since 5 was 5, checked in by anonymous, 17 years ago
=hoffentlich gehts jetzt
File size: 61.7 KB

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

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

Context Navigation

source: downloads/RenderSystems/GL/src/nvparse/_rc1.0_lexer.cpp @ 5

Download in other formats: