Context Navigation

source: OGRE/trunk/ogrenew/RenderSystems/GL/src/nvparse/_ts1.0_lexer.cpp @ 657

Revision 657, 63.6 KB checked in by mattausch, 18 years ago (diff)
added ogre dependencies and patched ogre sources

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

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

Download in other formats: