Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/RenderSystems/GL/src/nvparse/_ts1.0_lexer.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 17 years ago

File size: 63.5 KB

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.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 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 7 "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	#include <GL/glew.h>
724	#include "nvparse_errors.h"
725	#include "nvparse_externs.h"
726
727
728	#define YY_INPUT(buf,result,max_size) \
729	{ \
730	int c = *myin++; \
731	result = (c == 0) ? YY_NULL : (buf[0] = c, 1); \
732	}
733
734	#define YY_ALWAYS_INTERACTIVE 1
735
736	/* end of definitions */
737	#line 738 "_ts1.0_lexer.cpp"
738
739	/* Macros after this point can all be overridden by user definitions in
740	* section 1.
741	*/
742
743	#ifndef YY_SKIP_YYWRAP
744	#ifdef __cplusplus
745	extern "C" int yywrap YY_PROTO(( void ));
746	#else
747	extern int yywrap YY_PROTO(( void ));
748	#endif
749	#endif
750
751	#ifndef YY_NO_UNPUT
752	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
753	#endif
754
755	#ifndef yytext_ptr
756	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
757	#endif
758
759	#ifdef YY_NEED_STRLEN
760	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
761	#endif
762
763	#ifndef YY_NO_INPUT
764	#ifdef __cplusplus
765	static int yyinput YY_PROTO(( void ));
766	#else
767	static int input YY_PROTO(( void ));
768	#endif
769	#endif
770
771	#if YY_STACK_USED
772	static int yy_start_stack_ptr = 0;
773	static int yy_start_stack_depth = 0;
774	static int *yy_start_stack = 0;
775	#ifndef YY_NO_PUSH_STATE
776	static void yy_push_state YY_PROTO(( int new_state ));
777	#endif
778	#ifndef YY_NO_POP_STATE
779	static void yy_pop_state YY_PROTO(( void ));
780	#endif
781	#ifndef YY_NO_TOP_STATE
782	static int yy_top_state YY_PROTO(( void ));
783	#endif
784
785	#else
786	#define YY_NO_PUSH_STATE 1
787	#define YY_NO_POP_STATE 1
788	#define YY_NO_TOP_STATE 1
789	#endif
790
791	#ifdef YY_MALLOC_DECL
792	YY_MALLOC_DECL
793	#else
794	#if __STDC__
795	#ifndef __cplusplus
796	#include <stdlib.h>
797	#endif
798	#else
799	/* Just try to get by without declaring the routines. This will fail
800	* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
801	* or sizeof(void*) != sizeof(int).
802	*/
803	#endif
804	#endif
805
806	/* Amount of stuff to slurp up with each read. */
807	#ifndef YY_READ_BUF_SIZE
808	#define YY_READ_BUF_SIZE 8192
809	#endif
810
811	/* Copy whatever the last rule matched to the standard output. */
812
813	#ifndef ECHO
814	/* This used to be an fputs(), but since the string might contain NUL's,
815	* we now use fwrite().
816	*/
817	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
818	#endif
819
820	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
821	* is returned in "result".
822	*/
823	#ifndef YY_INPUT
824	#define YY_INPUT(buf,result,max_size) \
825	if ( yy_current_buffer->yy_is_interactive ) \
826	{ \
827	int c = '*', n; \
828	for ( n = 0; n < max_size && \
829	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
830	buf[n] = (char) c; \
831	if ( c == '\n' ) \
832	buf[n++] = (char) c; \
833	if ( c == EOF && ferror( yyin ) ) \
834	YY_FATAL_ERROR( "input in flex scanner failed" ); \
835	result = n; \
836	} \
837	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
838	&& ferror( yyin ) ) \
839	YY_FATAL_ERROR( "input in flex scanner failed" );
840	#endif
841
842	/* No semi-colon after return; correct usage is to write "yyterminate();" -
843	* we don't want an extra ';' after the "return" because that will cause
844	* some compilers to complain about unreachable statements.
845	*/
846	#ifndef yyterminate
847	#define yyterminate() return YY_NULL
848	#endif
849
850	/* Number of entries by which start-condition stack grows. */
851	#ifndef YY_START_STACK_INCR
852	#define YY_START_STACK_INCR 25
853	#endif
854
855	/* Report a fatal error. */
856	#ifndef YY_FATAL_ERROR
857	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
858	#endif
859
860	/* Default declaration of generated scanner - a define so the user can
861	* easily add parameters.
862	*/
863	#ifndef YY_DECL
864	#define YY_DECL int yylex YY_PROTO(( void ))
865	#endif
866
867	/* Code executed at the beginning of each rule, after yytext and yyleng
868	* have been set up.
869	*/
870	#ifndef YY_USER_ACTION
871	#define YY_USER_ACTION
872	#endif
873
874	/* Code executed at the end of each rule. */
875	#ifndef YY_BREAK
876	#define YY_BREAK break;
877	#endif
878
879	#define YY_RULE_SETUP \
880	YY_USER_ACTION
881
882	YY_DECL
883	{
884	register yy_state_type yy_current_state;
885	register char yy_cp = NULL, yy_bp = NULL;
886	register int yy_act;
887
888	#line 29 "ts1.0_tokens.l"
889
890
891	#line 892 "_ts1.0_lexer.cpp"
892
893	if ( yy_init )
894	{
895	yy_init = 0;
896
897	#ifdef YY_USER_INIT
898	YY_USER_INIT;
899	#endif
900
901	if ( ! yy_start )
902	yy_start = 1; /* first start state */
903
904	if ( ! yyin )
905	yyin = stdin;
906
907	if ( ! yyout )
908	yyout = stdout;
909
910	if ( ! yy_current_buffer )
911	yy_current_buffer =
912	yy_create_buffer( yyin, YY_BUF_SIZE );
913
914	yy_load_buffer_state();
915	}
916
917	while ( 1 ) /* loops until end-of-file is reached */
918	{
919	yy_cp = yy_c_buf_p;
920
921	/* Support of yytext. */
922	*yy_cp = yy_hold_char;
923
924	/* yy_bp points to the position in yy_ch_buf of the start of
925	* the current run.
926	*/
927	yy_bp = yy_cp;
928
929	yy_current_state = yy_start;
930	yy_match:
931	do
932	{
933	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
934	if ( yy_accept[yy_current_state] )
935	{
936	yy_last_accepting_state = yy_current_state;
937	yy_last_accepting_cpos = yy_cp;
938	}
939	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
940	{
941	yy_current_state = (int) yy_def[yy_current_state];
942	if ( yy_current_state >= 404 )
943	yy_c = yy_meta[(unsigned int) yy_c];
944	}
945	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
946	++yy_cp;
947	}
948	while ( yy_base[yy_current_state] != 845 );
949
950	yy_find_action:
951	yy_act = yy_accept[yy_current_state];
952	if ( yy_act == 0 )
953	{ /* have to back up */
954	yy_cp = yy_last_accepting_cpos;
955	yy_current_state = yy_last_accepting_state;
956	yy_act = yy_accept[yy_current_state];
957	}
958
959	YY_DO_BEFORE_ACTION;
960
961
962	do_action: /* This label is used only to access EOF actions. */
963
964
965	switch ( yy_act )
966	{ /* beginning of action switch */
967	case 0: /* must back up */
968	/* undo the effects of YY_DO_BEFORE_ACTION */
969	*yy_cp = yy_hold_char;
970	yy_cp = yy_last_accepting_cpos;
971	yy_current_state = yy_last_accepting_state;
972	goto yy_find_action;
973
974	case 1:
975	YY_RULE_SETUP
976	#line 31 "ts1.0_tokens.l"
977	{
978	A:
979	switch (yyinput()) {
980	case '*': goto B;
981	case 0: errors.set("end-of-file in comment", line_number); break;
982	case '\n': line_number++;
983	default: goto A;
984	}
985	B:
986	switch (yyinput()) {
987	case '*': goto B;
988	case '/': break;
989	case 0: errors.set("end-of-file in comment", line_number); break;
990	case '\n': line_number++;
991	default: goto A;
992	}
993	}
994	YY_BREAK
995	case 2:
996	YY_RULE_SETUP
997	#line 49 "ts1.0_tokens.l"
998	{
999	char ch;
1000	while ((ch = yyinput()) != '\n');
1001	if (ch == '\n') line_number++;
1002	}
1003	YY_BREAK
1004	case 3:
1005	YY_RULE_SETUP
1006	#line 55 "ts1.0_tokens.l"
1007	{
1008	char ch;
1009	while ((ch = yyinput()) != '\n');
1010	if (ch == '\n') line_number++;
1011	}
1012	YY_BREAK
1013	case 4:
1014	YY_RULE_SETUP
1015	#line 61 "ts1.0_tokens.l"
1016	return(openParen);
1017	YY_BREAK
1018	case 5:
1019	YY_RULE_SETUP
1020	#line 62 "ts1.0_tokens.l"
1021	return(closeParen);
1022	YY_BREAK
1023	case 6:
1024	YY_RULE_SETUP
1025	#line 63 "ts1.0_tokens.l"
1026	return(semicolon);
1027	YY_BREAK
1028	case 7:
1029	YY_RULE_SETUP
1030	#line 64 "ts1.0_tokens.l"
1031	return(comma);
1032	YY_BREAK
1033	case 8:
1034	YY_RULE_SETUP
1035	#line 66 "ts1.0_tokens.l"
1036	{ /* eat header */ }
1037	YY_BREAK
1038	case 9:
1039	YY_RULE_SETUP
1040	#line 68 "ts1.0_tokens.l"
1041	{
1042	ts10_lval.fval = (float)0;
1043	return(texVariable);
1044	}
1045	YY_BREAK
1046	case 10:
1047	YY_RULE_SETUP
1048	#line 73 "ts1.0_tokens.l"
1049	{
1050	ts10_lval.fval = (float)1;
1051	return(texVariable);
1052	}
1053	YY_BREAK
1054	case 11:
1055	YY_RULE_SETUP
1056	#line 78 "ts1.0_tokens.l"
1057	{
1058	ts10_lval.fval = (float)2;
1059	return(texVariable);
1060	}
1061	YY_BREAK
1062	case 12:
1063	YY_RULE_SETUP
1064	#line 83 "ts1.0_tokens.l"
1065	return(expandString);
1066	YY_BREAK
1067	case 13:
1068	YY_RULE_SETUP
1069	#line 85 "ts1.0_tokens.l"
1070	{
1071	ts10_lval.fval = (float)GL_GEQUAL;
1072	return (gequal);
1073	}
1074	YY_BREAK
1075	case 14:
1076	YY_RULE_SETUP
1077	#line 90 "ts1.0_tokens.l"
1078	{
1079	ts10_lval.fval = (float)GL_LESS;
1080	return(less);
1081	}
1082	YY_BREAK
1083	case 15:
1084	YY_RULE_SETUP
1085	#line 95 "ts1.0_tokens.l"
1086	return(nop);
1087	YY_BREAK
1088	case 16:
1089	YY_RULE_SETUP
1090	#line 96 "ts1.0_tokens.l"
1091	return(texture_1d);
1092	YY_BREAK
1093	case 17:
1094	YY_RULE_SETUP
1095	#line 97 "ts1.0_tokens.l"
1096	return(texture_2d);
1097	YY_BREAK
1098	case 18:
1099	YY_RULE_SETUP
1100	#line 98 "ts1.0_tokens.l"
1101	return(texture_rectangle);
1102	YY_BREAK
1103	case 19:
1104	YY_RULE_SETUP
1105	#line 99 "ts1.0_tokens.l"
1106	return(texture_3d);
1107	YY_BREAK
1108	case 20:
1109	YY_RULE_SETUP
1110	#line 100 "ts1.0_tokens.l"
1111	return(texture_cube_map);
1112	YY_BREAK
1113	case 21:
1114	YY_RULE_SETUP
1115	#line 101 "ts1.0_tokens.l"
1116	return(cull_fragment);
1117	YY_BREAK
1118	case 22:
1119	YY_RULE_SETUP
1120	#line 102 "ts1.0_tokens.l"
1121	return(pass_through);
1122	YY_BREAK
1123	case 23:
1124	YY_RULE_SETUP
1125	#line 103 "ts1.0_tokens.l"
1126	return(offset_2d_scale);
1127	YY_BREAK
1128	case 24:
1129	YY_RULE_SETUP
1130	#line 104 "ts1.0_tokens.l"
1131	return(offset_2d);
1132	YY_BREAK
1133	case 25:
1134	YY_RULE_SETUP
1135	#line 105 "ts1.0_tokens.l"
1136	return(offset_rectangle_scale);
1137	YY_BREAK
1138	case 26:
1139	YY_RULE_SETUP
1140	#line 106 "ts1.0_tokens.l"
1141	return(offset_rectangle);
1142	YY_BREAK
1143	case 27:
1144	YY_RULE_SETUP
1145	#line 107 "ts1.0_tokens.l"
1146	return(dependent_ar);
1147	YY_BREAK
1148	case 28:
1149	YY_RULE_SETUP
1150	#line 108 "ts1.0_tokens.l"
1151	return(dependent_gb);
1152	YY_BREAK
1153	case 29:
1154	YY_RULE_SETUP
1155	#line 110 "ts1.0_tokens.l"
1156	return(dot_product_2d_1of2);
1157	YY_BREAK
1158	case 30:
1159	YY_RULE_SETUP
1160	#line 111 "ts1.0_tokens.l"
1161	return(dot_product_2d_2of2);
1162	YY_BREAK
1163	case 31:
1164	YY_RULE_SETUP
1165	#line 113 "ts1.0_tokens.l"
1166	return(dot_product_rectangle_1of2);
1167	YY_BREAK
1168	case 32:
1169	YY_RULE_SETUP
1170	#line 114 "ts1.0_tokens.l"
1171	return(dot_product_rectangle_2of2);
1172	YY_BREAK
1173	case 33:
1174	YY_RULE_SETUP
1175	#line 116 "ts1.0_tokens.l"
1176	return(dot_product_depth_replace_1of2);
1177	YY_BREAK
1178	case 34:
1179	YY_RULE_SETUP
1180	#line 117 "ts1.0_tokens.l"
1181	return(dot_product_depth_replace_2of2);
1182	YY_BREAK
1183	case 35:
1184	YY_RULE_SETUP
1185	#line 119 "ts1.0_tokens.l"
1186	return(dot_product_3d_1of3);
1187	YY_BREAK
1188	case 36:
1189	YY_RULE_SETUP
1190	#line 120 "ts1.0_tokens.l"
1191	return(dot_product_3d_2of3);
1192	YY_BREAK
1193	case 37:
1194	YY_RULE_SETUP
1195	#line 121 "ts1.0_tokens.l"
1196	return(dot_product_3d_3of3);
1197	YY_BREAK
1198	case 38:
1199	YY_RULE_SETUP
1200	#line 123 "ts1.0_tokens.l"
1201	return(dot_product_cube_map_1of3);
1202	YY_BREAK
1203	case 39:
1204	YY_RULE_SETUP
1205	#line 124 "ts1.0_tokens.l"
1206	return(dot_product_cube_map_2of3);
1207	YY_BREAK
1208	case 40:
1209	YY_RULE_SETUP
1210	#line 125 "ts1.0_tokens.l"
1211	return(dot_product_cube_map_3of3);
1212	YY_BREAK
1213	case 41:
1214	YY_RULE_SETUP
1215	#line 127 "ts1.0_tokens.l"
1216	return(dot_product_reflect_cube_map_eye_from_qs_1of3);
1217	YY_BREAK
1218	case 42:
1219	YY_RULE_SETUP
1220	#line 128 "ts1.0_tokens.l"
1221	return(dot_product_reflect_cube_map_eye_from_qs_2of3);
1222	YY_BREAK
1223	case 43:
1224	YY_RULE_SETUP
1225	#line 129 "ts1.0_tokens.l"
1226	return(dot_product_reflect_cube_map_eye_from_qs_3of3);
1227	YY_BREAK
1228	case 44:
1229	YY_RULE_SETUP
1230	#line 131 "ts1.0_tokens.l"
1231	return(dot_product_reflect_cube_map_const_eye_1of3);
1232	YY_BREAK
1233	case 45:
1234	YY_RULE_SETUP
1235	#line 132 "ts1.0_tokens.l"
1236	return(dot_product_reflect_cube_map_const_eye_2of3);
1237	YY_BREAK
1238	case 46:
1239	YY_RULE_SETUP
1240	#line 133 "ts1.0_tokens.l"
1241	return(dot_product_reflect_cube_map_const_eye_3of3);
1242	YY_BREAK
1243	case 47:
1244	YY_RULE_SETUP
1245	#line 135 "ts1.0_tokens.l"
1246	return(dot_product_cube_map_and_reflect_cube_map_eye_from_qs_1of3);
1247	YY_BREAK
1248	case 48:
1249	YY_RULE_SETUP
1250	#line 136 "ts1.0_tokens.l"
1251	return(dot_product_cube_map_and_reflect_cube_map_eye_from_qs_2of3);
1252	YY_BREAK
1253	case 49:
1254	YY_RULE_SETUP
1255	#line 137 "ts1.0_tokens.l"
1256	return(dot_product_cube_map_and_reflect_cube_map_eye_from_qs_3of3);
1257	YY_BREAK
1258	case 50:
1259	YY_RULE_SETUP
1260	#line 139 "ts1.0_tokens.l"
1261	return(dot_product_cube_map_and_reflect_cube_map_const_eye_1of3);
1262	YY_BREAK
1263	case 51:
1264	YY_RULE_SETUP
1265	#line 140 "ts1.0_tokens.l"
1266	return(dot_product_cube_map_and_reflect_cube_map_const_eye_2of3);
1267	YY_BREAK
1268	case 52:
1269	YY_RULE_SETUP
1270	#line 141 "ts1.0_tokens.l"
1271	return(dot_product_cube_map_and_reflect_cube_map_const_eye_3of3);
1272	YY_BREAK
1273	case 53:
1274	YY_RULE_SETUP
1275	#line 143 "ts1.0_tokens.l"
1276	{
1277	ts10_lval.fval = (float)atof(yytext);
1278	return(floatValue);
1279	}
1280	YY_BREAK
1281	case 54:
1282	YY_RULE_SETUP
1283	#line 148 "ts1.0_tokens.l"
1284	{
1285	ts10_lval.fval = (float)atof(yytext);
1286	return(floatValue);
1287	}
1288	YY_BREAK
1289	case 55:
1290	YY_RULE_SETUP
1291	#line 153 "ts1.0_tokens.l"
1292	{
1293	ts10_lval.fval = (float)atof(yytext);
1294	return(floatValue);
1295	}
1296	YY_BREAK
1297	case 56:
1298	YY_RULE_SETUP
1299	#line 158 "ts1.0_tokens.l"
1300	{
1301	line_number++;
1302	}
1303	YY_BREAK
1304	case 57:
1305	YY_RULE_SETUP
1306	#line 162 "ts1.0_tokens.l"
1307	{}
1308	YY_BREAK
1309	case 58:
1310	YY_RULE_SETUP
1311	#line 164 "ts1.0_tokens.l"
1312	{
1313	errors.set("unrecognized token", line_number);
1314	}
1315	YY_BREAK
1316	case 59:
1317	YY_RULE_SETUP
1318	#line 169 "ts1.0_tokens.l"
1319	ECHO;
1320	YY_BREAK
1321	#line 1322 "_ts1.0_lexer.cpp"
1322	case YY_STATE_EOF(INITIAL):
1323	yyterminate();
1324
1325	case YY_END_OF_BUFFER:
1326	{
1327	/* Amount of text matched not including the EOB char. */
1328	int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1329
1330	/* Undo the effects of YY_DO_BEFORE_ACTION. */
1331	*yy_cp = yy_hold_char;
1332	YY_RESTORE_YY_MORE_OFFSET
1333
1334	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1335	{
1336	/* We're scanning a new file or input source. It's
1337	* possible that this happened because the user
1338	* just pointed yyin at a new source and called
1339	* yylex(). If so, then we have to assure
1340	* consistency between yy_current_buffer and our
1341	* globals. Here is the right place to do so, because
1342	* this is the first action (other than possibly a
1343	* back-up) that will match for the new input source.
1344	*/
1345	yy_n_chars = yy_current_buffer->yy_n_chars;
1346	yy_current_buffer->yy_input_file = yyin;
1347	yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1348	}
1349
1350	/* Note that here we test for yy_c_buf_p "<=" to the position
1351	* of the first EOB in the buffer, since yy_c_buf_p will
1352	* already have been incremented past the NUL character
1353	* (since all states make transitions on EOB to the
1354	* end-of-buffer state). Contrast this with the test
1355	* in input().
1356	*/
1357	if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1358	{ /* This was really a NUL. */
1359	yy_state_type yy_next_state;
1360
1361	yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1362
1363	yy_current_state = yy_get_previous_state();
1364
1365	/* Okay, we're now positioned to make the NUL
1366	* transition. We couldn't have
1367	* yy_get_previous_state() go ahead and do it
1368	* for us because it doesn't know how to deal
1369	* with the possibility of jamming (and we don't
1370	* want to build jamming into it because then it
1371	* will run more slowly).
1372	*/
1373
1374	yy_next_state = yy_try_NUL_trans( yy_current_state );
1375
1376	yy_bp = yytext_ptr + YY_MORE_ADJ;
1377
1378	if ( yy_next_state )
1379	{
1380	/* Consume the NUL. */
1381	yy_cp = ++yy_c_buf_p;
1382	yy_current_state = yy_next_state;
1383	goto yy_match;
1384	}
1385
1386	else
1387	{
1388	yy_cp = yy_c_buf_p;
1389	goto yy_find_action;
1390	}
1391	}
1392
1393	else switch ( yy_get_next_buffer() )
1394	{
1395	case EOB_ACT_END_OF_FILE:
1396	{
1397	yy_did_buffer_switch_on_eof = 0;
1398
1399	if ( yywrap() )
1400	{
1401	/* Note: because we've taken care in
1402	* yy_get_next_buffer() to have set up
1403	* yytext, we can now set up
1404	* yy_c_buf_p so that if some total
1405	* hoser (like flex itself) wants to
1406	* call the scanner after we return the
1407	* YY_NULL, it'll still work - another
1408	* YY_NULL will get returned.
1409	*/
1410	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1411
1412	yy_act = YY_STATE_EOF(YY_START);
1413	goto do_action;
1414	}
1415
1416	else
1417	{
1418	if ( ! yy_did_buffer_switch_on_eof )
1419	YY_NEW_FILE;
1420	}
1421	break;
1422	}
1423
1424	case EOB_ACT_CONTINUE_SCAN:
1425	yy_c_buf_p =
1426	yytext_ptr + yy_amount_of_matched_text;
1427
1428	yy_current_state = yy_get_previous_state();
1429
1430	yy_cp = yy_c_buf_p;
1431	yy_bp = yytext_ptr + YY_MORE_ADJ;
1432	goto yy_match;
1433
1434	case EOB_ACT_LAST_MATCH:
1435	yy_c_buf_p =
1436	&yy_current_buffer->yy_ch_buf[yy_n_chars];
1437
1438	yy_current_state = yy_get_previous_state();
1439
1440	yy_cp = yy_c_buf_p;
1441	yy_bp = yytext_ptr + YY_MORE_ADJ;
1442	goto yy_find_action;
1443	}
1444	break;
1445	}
1446
1447	default:
1448	YY_FATAL_ERROR(
1449	"fatal flex scanner internal error--no action found" );
1450	} /* end of action switch */
1451	} /* end of scanning one token */
1452	} /* end of yylex */
1453
1454
1455	/* yy_get_next_buffer - try to read in a new buffer
1456	*
1457	* Returns a code representing an action:
1458	* EOB_ACT_LAST_MATCH -
1459	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1460	* EOB_ACT_END_OF_FILE - end of file
1461	*/
1462
1463	static int yy_get_next_buffer()
1464	{
1465	register char *dest = yy_current_buffer->yy_ch_buf;
1466	register char *source = yytext_ptr;
1467	register int number_to_move, i;
1468	int ret_val;
1469
1470	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1471	YY_FATAL_ERROR(
1472	"fatal flex scanner internal error--end of buffer missed" );
1473
1474	if ( yy_current_buffer->yy_fill_buffer == 0 )
1475	{ /* Don't try to fill the buffer, so this is an EOF. */
1476	if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1477	{
1478	/* We matched a single character, the EOB, so
1479	* treat this as a final EOF.
1480	*/
1481	return EOB_ACT_END_OF_FILE;
1482	}
1483
1484	else
1485	{
1486	/* We matched some text prior to the EOB, first
1487	* process it.
1488	*/
1489	return EOB_ACT_LAST_MATCH;
1490	}
1491	}
1492
1493	/* Try to read more data. */
1494
1495	/* First move last chars to start of buffer. */
1496	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1497
1498	for ( i = 0; i < number_to_move; ++i )
1499	(dest++) = (source++);
1500
1501	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1502	/* don't do the read, it's not guaranteed to return an EOF,
1503	* just force an EOF
1504	*/
1505	yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1506
1507	else
1508	{
1509	int num_to_read =
1510	yy_current_buffer->yy_buf_size - number_to_move - 1;
1511
1512	while ( num_to_read <= 0 )
1513	{ /* Not enough room in the buffer - grow it. */
1514	#ifdef YY_USES_REJECT
1515	YY_FATAL_ERROR(
1516	"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1517	#else
1518
1519	/* just a shorter name for the current buffer */
1520	YY_BUFFER_STATE b = yy_current_buffer;
1521
1522	int yy_c_buf_p_offset =
1523	(int) (yy_c_buf_p - b->yy_ch_buf);
1524
1525	if ( b->yy_is_our_buffer )
1526	{
1527	int new_size = b->yy_buf_size * 2;
1528
1529	if ( new_size <= 0 )
1530	b->yy_buf_size += b->yy_buf_size / 8;
1531	else
1532	b->yy_buf_size *= 2;
1533
1534	b->yy_ch_buf = (char *)
1535	/* Include room in for 2 EOB chars. */
1536	yy_flex_realloc( (void *) b->yy_ch_buf,
1537	b->yy_buf_size + 2 );
1538	}
1539	else
1540	/* Can't grow it, we don't own it. */
1541	b->yy_ch_buf = 0;
1542
1543	if ( ! b->yy_ch_buf )
1544	YY_FATAL_ERROR(
1545	"fatal error - scanner input buffer overflow" );
1546
1547	yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1548
1549	num_to_read = yy_current_buffer->yy_buf_size -
1550	number_to_move - 1;
1551	#endif
1552	}
1553
1554	if ( num_to_read > YY_READ_BUF_SIZE )
1555	num_to_read = YY_READ_BUF_SIZE;
1556
1557	/* Read in more data. */
1558	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1559	yy_n_chars, num_to_read );
1560
1561	yy_current_buffer->yy_n_chars = yy_n_chars;
1562	}
1563
1564	if ( yy_n_chars == 0 )
1565	{
1566	if ( number_to_move == YY_MORE_ADJ )
1567	{
1568	ret_val = EOB_ACT_END_OF_FILE;
1569	yyrestart( yyin );
1570	}
1571
1572	else
1573	{
1574	ret_val = EOB_ACT_LAST_MATCH;
1575	yy_current_buffer->yy_buffer_status =
1576	YY_BUFFER_EOF_PENDING;
1577	}
1578	}
1579
1580	else
1581	ret_val = EOB_ACT_CONTINUE_SCAN;
1582
1583	yy_n_chars += number_to_move;
1584	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1585	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1586
1587	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1588
1589	return ret_val;
1590	}
1591
1592
1593	/* yy_get_previous_state - get the state just before the EOB char was reached */
1594
1595	static yy_state_type yy_get_previous_state()
1596	{
1597	register yy_state_type yy_current_state;
1598	register char *yy_cp;
1599
1600	yy_current_state = yy_start;
1601
1602	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1603	{
1604	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
1605	if ( yy_accept[yy_current_state] )
1606	{
1607	yy_last_accepting_state = yy_current_state;
1608	yy_last_accepting_cpos = yy_cp;
1609	}
1610	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1611	{
1612	yy_current_state = (int) yy_def[yy_current_state];
1613	if ( yy_current_state >= 404 )
1614	yy_c = yy_meta[(unsigned int) yy_c];
1615	}
1616	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1617	}
1618
1619	return yy_current_state;
1620	}
1621
1622
1623	/* yy_try_NUL_trans - try to make a transition on the NUL character
1624	*
1625	* synopsis
1626	* next_state = yy_try_NUL_trans( current_state );
1627	*/
1628
1629	#ifdef YY_USE_PROTOS
1630	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1631	#else
1632	static yy_state_type yy_try_NUL_trans( yy_current_state )
1633	yy_state_type yy_current_state;
1634	#endif
1635	{
1636	register int yy_is_jam;
1637	register char *yy_cp = yy_c_buf_p;
1638
1639	register YY_CHAR yy_c = 1;
1640	if ( yy_accept[yy_current_state] )
1641	{
1642	yy_last_accepting_state = yy_current_state;
1643	yy_last_accepting_cpos = yy_cp;
1644	}
1645	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1646	{
1647	yy_current_state = (int) yy_def[yy_current_state];
1648	if ( yy_current_state >= 404 )
1649	yy_c = yy_meta[(unsigned int) yy_c];
1650	}
1651	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1652	yy_is_jam = (yy_current_state == 403);
1653
1654	return yy_is_jam ? 0 : yy_current_state;
1655	}
1656
1657
1658	#ifndef YY_NO_UNPUT
1659	#ifdef YY_USE_PROTOS
1660	static void yyunput( int c, register char *yy_bp )
1661	#else
1662	static void yyunput( c, yy_bp )
1663	int c;
1664	register char *yy_bp;
1665	#endif
1666	{
1667	register char *yy_cp = yy_c_buf_p;
1668
1669	/* undo effects of setting up yytext */
1670	*yy_cp = yy_hold_char;
1671
1672	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1673	{ /* need to shift things up to make room */
1674	/* +2 for EOB chars. */
1675	register int number_to_move = yy_n_chars + 2;
1676	register char *dest = &yy_current_buffer->yy_ch_buf[
1677	yy_current_buffer->yy_buf_size + 2];
1678	register char *source =
1679	&yy_current_buffer->yy_ch_buf[number_to_move];
1680
1681	while ( source > yy_current_buffer->yy_ch_buf )
1682	--dest = --source;
1683
1684	yy_cp += (int) (dest - source);
1685	yy_bp += (int) (dest - source);
1686	yy_current_buffer->yy_n_chars =
1687	yy_n_chars = yy_current_buffer->yy_buf_size;
1688
1689	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1690	YY_FATAL_ERROR( "flex scanner push-back overflow" );
1691	}
1692
1693	*--yy_cp = (char) c;
1694
1695
1696	yytext_ptr = yy_bp;
1697	yy_hold_char = *yy_cp;
1698	yy_c_buf_p = yy_cp;
1699	}
1700	#endif /* ifndef YY_NO_UNPUT */
1701
1702
1703	#ifdef __cplusplus
1704	static int yyinput()
1705	#else
1706	static int input()
1707	#endif
1708	{
1709	int c;
1710
1711	*yy_c_buf_p = yy_hold_char;
1712
1713	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1714	{
1715	/* yy_c_buf_p now points to the character we want to return.
1716	* If this occurs before the EOB characters, then it's a
1717	* valid NUL; if not, then we've hit the end of the buffer.
1718	*/
1719	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1720	/* This was really a NUL. */
1721	*yy_c_buf_p = '\0';
1722
1723	else
1724	{ /* need more input */
1725	int offset = yy_c_buf_p - yytext_ptr;
1726	++yy_c_buf_p;
1727
1728	switch ( yy_get_next_buffer() )
1729	{
1730	case EOB_ACT_LAST_MATCH:
1731	/* This happens because yy_g_n_b()
1732	* sees that we've accumulated a
1733	* token and flags that we need to
1734	* try matching the token before
1735	* proceeding. But for input(),
1736	* there's no matching to consider.
1737	* So convert the EOB_ACT_LAST_MATCH
1738	* to EOB_ACT_END_OF_FILE.
1739	*/
1740
1741	/* Reset buffer status. */
1742	yyrestart( yyin );
1743
1744	/* fall through */
1745
1746	case EOB_ACT_END_OF_FILE:
1747	{
1748	if ( yywrap() )
1749	return EOF;
1750
1751	if ( ! yy_did_buffer_switch_on_eof )
1752	YY_NEW_FILE;
1753	#ifdef __cplusplus
1754	return yyinput();
1755	#else
1756	return input();
1757	#endif
1758	}
1759
1760	case EOB_ACT_CONTINUE_SCAN:
1761	yy_c_buf_p = yytext_ptr + offset;
1762	break;
1763	}
1764	}
1765	}
1766
1767	c = (unsigned char ) yy_c_buf_p; /* cast for 8-bit char's */
1768	yy_c_buf_p = '\0'; / preserve yytext */
1769	yy_hold_char = *++yy_c_buf_p;
1770
1771
1772	return c;
1773	}
1774
1775
1776	#ifdef YY_USE_PROTOS
1777	void yyrestart( FILE *input_file )
1778	#else
1779	void yyrestart( input_file )
1780	FILE *input_file;
1781	#endif
1782	{
1783	if ( ! yy_current_buffer )
1784	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1785
1786	yy_init_buffer( yy_current_buffer, input_file );
1787	yy_load_buffer_state();
1788	}
1789
1790
1791	#ifdef YY_USE_PROTOS
1792	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1793	#else
1794	void yy_switch_to_buffer( new_buffer )
1795	YY_BUFFER_STATE new_buffer;
1796	#endif
1797	{
1798	if ( yy_current_buffer == new_buffer )
1799	return;
1800
1801	if ( yy_current_buffer )
1802	{
1803	/* Flush out information for old buffer. */
1804	*yy_c_buf_p = yy_hold_char;
1805	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1806	yy_current_buffer->yy_n_chars = yy_n_chars;
1807	}
1808
1809	yy_current_buffer = new_buffer;
1810	yy_load_buffer_state();
1811
1812	/* We don't actually know whether we did this switch during
1813	* EOF (yywrap()) processing, but the only time this flag
1814	* is looked at is after yywrap() is called, so it's safe
1815	* to go ahead and always set it.
1816	*/
1817	yy_did_buffer_switch_on_eof = 1;
1818	}
1819
1820
1821	#ifdef YY_USE_PROTOS
1822	void yy_load_buffer_state( void )
1823	#else
1824	void yy_load_buffer_state()
1825	#endif
1826	{
1827	yy_n_chars = yy_current_buffer->yy_n_chars;
1828	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1829	yyin = yy_current_buffer->yy_input_file;
1830	yy_hold_char = *yy_c_buf_p;
1831	}
1832
1833
1834	#ifdef YY_USE_PROTOS
1835	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1836	#else
1837	YY_BUFFER_STATE yy_create_buffer( file, size )
1838	FILE *file;
1839	int size;
1840	#endif
1841	{
1842	YY_BUFFER_STATE b;
1843
1844	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1845	if ( ! b )
1846	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1847
1848	b->yy_buf_size = size;
1849
1850	/* yy_ch_buf has to be 2 characters longer than the size given because
1851	* we need to put in 2 end-of-buffer characters.
1852	*/
1853	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1854	if ( ! b->yy_ch_buf )
1855	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1856
1857	b->yy_is_our_buffer = 1;
1858
1859	yy_init_buffer( b, file );
1860
1861	return b;
1862	}
1863
1864
1865	#ifdef YY_USE_PROTOS
1866	void yy_delete_buffer( YY_BUFFER_STATE b )
1867	#else
1868	void yy_delete_buffer( b )
1869	YY_BUFFER_STATE b;
1870	#endif
1871	{
1872	if ( ! b )
1873	return;
1874
1875	if ( b == yy_current_buffer )
1876	yy_current_buffer = (YY_BUFFER_STATE) 0;
1877
1878	if ( b->yy_is_our_buffer )
1879	yy_flex_free( (void *) b->yy_ch_buf );
1880
1881	yy_flex_free( (void *) b );
1882	}
1883
1884
1885
1886	#ifdef YY_USE_PROTOS
1887	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1888	#else
1889	void yy_init_buffer( b, file )
1890	YY_BUFFER_STATE b;
1891	FILE *file;
1892	#endif
1893
1894
1895	{
1896	yy_flush_buffer( b );
1897
1898	b->yy_input_file = file;
1899	b->yy_fill_buffer = 1;
1900
1901	#if YY_ALWAYS_INTERACTIVE
1902	b->yy_is_interactive = 1;
1903	#else
1904	#if YY_NEVER_INTERACTIVE
1905	b->yy_is_interactive = 0;
1906	#else
1907	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1908	#endif
1909	#endif
1910	}
1911
1912
1913	#ifdef YY_USE_PROTOS
1914	void yy_flush_buffer( YY_BUFFER_STATE b )
1915	#else
1916	void yy_flush_buffer( b )
1917	YY_BUFFER_STATE b;
1918	#endif
1919
1920	{
1921	if ( ! b )
1922	return;
1923
1924	b->yy_n_chars = 0;
1925
1926	/* We always need two end-of-buffer characters. The first causes
1927	* a transition to the end-of-buffer state. The second causes
1928	* a jam in that state.
1929	*/
1930	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1931	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1932
1933	b->yy_buf_pos = &b->yy_ch_buf[0];
1934
1935	b->yy_at_bol = 1;
1936	b->yy_buffer_status = YY_BUFFER_NEW;
1937
1938	if ( b == yy_current_buffer )
1939	yy_load_buffer_state();
1940	}
1941
1942
1943	#ifndef YY_NO_SCAN_BUFFER
1944	#ifdef YY_USE_PROTOS
1945	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1946	#else
1947	YY_BUFFER_STATE yy_scan_buffer( base, size )
1948	char *base;
1949	yy_size_t size;
1950	#endif
1951	{
1952	YY_BUFFER_STATE b;
1953
1954	if ( size < 2 \|\|
1955	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
1956	base[size-1] != YY_END_OF_BUFFER_CHAR )
1957	/* They forgot to leave room for the EOB's. */
1958	return 0;
1959
1960	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1961	if ( ! b )
1962	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1963
1964	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1965	b->yy_buf_pos = b->yy_ch_buf = base;
1966	b->yy_is_our_buffer = 0;
1967	b->yy_input_file = 0;
1968	b->yy_n_chars = b->yy_buf_size;
1969	b->yy_is_interactive = 0;
1970	b->yy_at_bol = 1;
1971	b->yy_fill_buffer = 0;
1972	b->yy_buffer_status = YY_BUFFER_NEW;
1973
1974	yy_switch_to_buffer( b );
1975
1976	return b;
1977	}
1978	#endif
1979
1980
1981	#ifndef YY_NO_SCAN_STRING
1982	#ifdef YY_USE_PROTOS
1983	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1984	#else
1985	YY_BUFFER_STATE yy_scan_string( yy_str )
1986	yyconst char *yy_str;
1987	#endif
1988	{
1989	int len;
1990	for ( len = 0; yy_str[len]; ++len )
1991	;
1992
1993	return yy_scan_bytes( yy_str, len );
1994	}
1995	#endif
1996
1997
1998	#ifndef YY_NO_SCAN_BYTES
1999	#ifdef YY_USE_PROTOS
2000	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2001	#else
2002	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2003	yyconst char *bytes;
2004	int len;
2005	#endif
2006	{
2007	YY_BUFFER_STATE b;
2008	char *buf;
2009	yy_size_t n;
2010	int i;
2011
2012	/* Get memory for full buffer, including space for trailing EOB's. */
2013	n = len + 2;
2014	buf = (char *) yy_flex_alloc( n );
2015	if ( ! buf )
2016	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2017
2018	for ( i = 0; i < len; ++i )
2019	buf[i] = bytes[i];
2020
2021	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2022
2023	b = yy_scan_buffer( buf, n );
2024	if ( ! b )
2025	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2026
2027	/* It's okay to grow etc. this buffer, and we should throw it
2028	* away when we're done.
2029	*/
2030	b->yy_is_our_buffer = 1;
2031
2032	return b;
2033	}
2034	#endif
2035
2036
2037	#ifndef YY_NO_PUSH_STATE
2038	#ifdef YY_USE_PROTOS
2039	static void yy_push_state( int new_state )
2040	#else
2041	static void yy_push_state( new_state )
2042	int new_state;
2043	#endif
2044	{
2045	if ( yy_start_stack_ptr >= yy_start_stack_depth )
2046	{
2047	yy_size_t new_size;
2048
2049	yy_start_stack_depth += YY_START_STACK_INCR;
2050	new_size = yy_start_stack_depth * sizeof( int );
2051
2052	if ( ! yy_start_stack )
2053	yy_start_stack = (int *) yy_flex_alloc( new_size );
2054
2055	else
2056	yy_start_stack = (int *) yy_flex_realloc(
2057	(void *) yy_start_stack, new_size );
2058
2059	if ( ! yy_start_stack )
2060	YY_FATAL_ERROR(
2061	"out of memory expanding start-condition stack" );
2062	}
2063
2064	yy_start_stack[yy_start_stack_ptr++] = YY_START;
2065
2066	BEGIN(new_state);
2067	}
2068	#endif
2069
2070
2071	#ifndef YY_NO_POP_STATE
2072	static void yy_pop_state()
2073	{
2074	if ( --yy_start_stack_ptr < 0 )
2075	YY_FATAL_ERROR( "start-condition stack underflow" );
2076
2077	BEGIN(yy_start_stack[yy_start_stack_ptr]);
2078	}
2079	#endif
2080
2081
2082	#ifndef YY_NO_TOP_STATE
2083	static int yy_top_state()
2084	{
2085	return yy_start_stack[yy_start_stack_ptr - 1];
2086	}
2087	#endif
2088
2089	#ifndef YY_EXIT_FAILURE
2090	#define YY_EXIT_FAILURE 2
2091	#endif
2092
2093	#ifdef YY_USE_PROTOS
2094	static void yy_fatal_error( yyconst char msg[] )
2095	#else
2096	static void yy_fatal_error( msg )
2097	char msg[];
2098	#endif
2099	{
2100	(void) fprintf( stderr, "%s\n", msg );
2101	exit( YY_EXIT_FAILURE );
2102	}
2103
2104
2105
2106	/* Redefine yyless() so it works in section 3 code. */
2107
2108	#undef yyless
2109	#define yyless(n) \
2110	do \
2111	{ \
2112	/* Undo effects of setting up yytext. */ \
2113	yytext[yyleng] = yy_hold_char; \
2114	yy_c_buf_p = yytext + n; \
2115	yy_hold_char = *yy_c_buf_p; \
2116	*yy_c_buf_p = '\0'; \
2117	yyleng = n; \
2118	} \
2119	while ( 0 )
2120
2121
2122	/* Internal utility routines. */
2123
2124	#ifndef yytext_ptr
2125	#ifdef YY_USE_PROTOS
2126	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
2127	#else
2128	static void yy_flex_strncpy( s1, s2, n )
2129	char *s1;
2130	yyconst char *s2;
2131	int n;
2132	#endif
2133	{
2134	register int i;
2135	for ( i = 0; i < n; ++i )
2136	s1[i] = s2[i];
2137	}
2138	#endif
2139
2140	#ifdef YY_NEED_STRLEN
2141	#ifdef YY_USE_PROTOS
2142	static int yy_flex_strlen( yyconst char *s )
2143	#else
2144	static int yy_flex_strlen( s )
2145	yyconst char *s;
2146	#endif
2147	{
2148	register int n;
2149	for ( n = 0; s[n]; ++n )
2150	;
2151
2152	return n;
2153	}
2154	#endif
2155
2156
2157	#ifdef YY_USE_PROTOS
2158	static void *yy_flex_alloc( yy_size_t size )
2159	#else
2160	static void *yy_flex_alloc( size )
2161	yy_size_t size;
2162	#endif
2163	{
2164	return (void *) malloc( size );
2165	}
2166
2167	#ifdef YY_USE_PROTOS
2168	static void yy_flex_realloc( void ptr, yy_size_t size )
2169	#else
2170	static void *yy_flex_realloc( ptr, size )
2171	void *ptr;
2172	yy_size_t size;
2173	#endif
2174	{
2175	/* The cast to (char *) in the following accommodates both
2176	* implementations that use char* generic pointers, and those
2177	* that use void* generic pointers. It works with the latter
2178	* because both ANSI C and C++ allow castless assignment from
2179	* any pointer type to void*, and deal with argument conversions
2180	* as though doing an assignment.
2181	*/
2182	return (void ) realloc( (char ) ptr, size );
2183	}
2184
2185	#ifdef YY_USE_PROTOS
2186	static void yy_flex_free( void *ptr )
2187	#else
2188	static void yy_flex_free( ptr )
2189	void *ptr;
2190	#endif
2191	{
2192	free( ptr );
2193	}
2194
2195	#if YY_MAIN
2196	int main()
2197	{
2198	yylex();
2199	return 0;
2200	}
2201	#endif
2202	#line 169 "ts1.0_tokens.l"
2203
2204
2205	bool ts10_init_more();
2206
2207	bool ts10_init(char* inputString)
2208	{
2209	myin = inputString;
2210	return ts10_init_more();
2211	}
2212
2213
2214	#ifndef ts10_wrap
2215	int ts10_wrap(void)
2216	{
2217	return(1);
2218	}
2219	#endif

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

Download in other formats: