Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

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

File size: 128.7 KB

Line
1	#include <ctype.h>
2
3	#define yy_create_buffer vs10__create_buffer
4	#define yy_delete_buffer vs10__delete_buffer
5	#define yy_scan_buffer vs10__scan_buffer
6	#define yy_scan_string vs10__scan_string
7	#define yy_scan_bytes vs10__scan_bytes
8	#define yy_flex_debug vs10__flex_debug
9	#define yy_init_buffer vs10__init_buffer
10	#define yy_flush_buffer vs10__flush_buffer
11	#define yy_load_buffer_state vs10__load_buffer_state
12	#define yy_switch_to_buffer vs10__switch_to_buffer
13	#define yyin vs10_in
14	#define yyleng vs10_leng
15	#define yylex vs10_lex
16	#define yyout vs10_out
17	#define yyrestart vs10_restart
18	#define yytext vs10_text
19	#define yywrap vs10_wrap
20
21	#line 20 "_vs1.0_lexer.cpp"
22	/* A lexical scanner generated by flex */
23
24	/* Scanner skeleton version:
25	* $Header: /cvsroot/ogre/ogrenew/RenderSystems/GL/src/nvparse/_vs1.0_lexer.cpp,v 1.4 2005/11/10 07:24:20 nfz Exp $
26	*/
27
28	#define FLEX_SCANNER
29	#define YY_FLEX_MAJOR_VERSION 2
30	#define YY_FLEX_MINOR_VERSION 5
31
32	#include <stdio.h>
33	#include <unistd.h>
34
35
36	/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
37	#ifdef c_plusplus
38	#ifndef __cplusplus
39	#define __cplusplus
40	#endif
41	#endif
42
43
44	#ifdef __cplusplus
45
46	#include <stdlib.h>
47
48	/* Use prototypes in function declarations. */
49	#define YY_USE_PROTOS
50
51	/* The "const" storage-class-modifier is valid. */
52	#define YY_USE_CONST
53
54	#else /* ! __cplusplus */
55
56	#if __STDC__
57
58	#define YY_USE_PROTOS
59	#define YY_USE_CONST
60
61	#endif /* __STDC__ */
62	#endif /* ! __cplusplus */
63
64	#ifdef __TURBOC__
65	#pragma warn -rch
66	#pragma warn -use
67	#include <io.h>
68	#include <stdlib.h>
69	#define YY_USE_CONST
70	#define YY_USE_PROTOS
71	#endif
72
73	#ifdef YY_USE_CONST
74	#define yyconst const
75	#else
76	#define yyconst
77	#endif
78
79
80	#ifdef YY_USE_PROTOS
81	#define YY_PROTO(proto) proto
82	#else
83	#define YY_PROTO(proto) ()
84	#endif
85
86	/* Returned upon end-of-file. */
87	#define YY_NULL 0
88
89	/* Promotes a possibly negative, possibly signed char to an unsigned
90	* integer for use as an array index. If the signed char is negative,
91	* we want to instead treat it as an 8-bit unsigned char, hence the
92	* double cast.
93	*/
94	#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
95
96	/* Enter a start condition. This macro really ought to take a parameter,
97	* but we do it the disgusting crufty way forced on us by the ()-less
98	* definition of BEGIN.
99	*/
100	#define BEGIN yy_start = 1 + 2 *
101
102	/* Translate the current start state into a value that can be later handed
103	* to BEGIN to return to the state. The YYSTATE alias is for lex
104	* compatibility.
105	*/
106	#define YY_START ((yy_start - 1) / 2)
107	#define YYSTATE YY_START
108
109	/* Action number for EOF rule of a given start state. */
110	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
111
112	/* Special action meaning "start processing a new file". */
113	#define YY_NEW_FILE yyrestart( yyin )
114
115	#define YY_END_OF_BUFFER_CHAR 0
116
117	/* Size of default input buffer. */
118	#define YY_BUF_SIZE 16384
119
120	typedef struct yy_buffer_state *YY_BUFFER_STATE;
121
122	extern int yyleng;
123	extern FILE yyin, yyout;
124
125	#define EOB_ACT_CONTINUE_SCAN 0
126	#define EOB_ACT_END_OF_FILE 1
127	#define EOB_ACT_LAST_MATCH 2
128
129	/* The funky do-while in the following #define is used to turn the definition
130	* int a single C statement (which needs a semi-colon terminator). This
131	* avoids problems with code like:
132	*
133	* if ( condition_holds )
134	* yyless( 5 );
135	* else
136	* do_something_else();
137	*
138	* Prior to using the do-while the compiler would get upset at the
139	* "else" because it interpreted the "if" statement as being all
140	* done when it reached the ';' after the yyless() call.
141	*/
142
143	/* Return all but the first 'n' matched characters back to the input stream. */
144
145	#define yyless(n) \
146	do \
147	{ \
148	/* Undo effects of setting up yytext. */ \
149	*yy_cp = yy_hold_char; \
150	YY_RESTORE_YY_MORE_OFFSET \
151	yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
152	YY_DO_BEFORE_ACTION; /* set up yytext again */ \
153	} \
154	while ( 0 )
155
156	#define unput(c) yyunput( c, yytext_ptr )
157
158	/* The following is because we cannot portably get our hands on size_t
159	* (without autoconf's help, which isn't available because we want
160	* flex-generated scanners to compile on their own).
161	*/
162	typedef unsigned int yy_size_t;
163
164
165	struct yy_buffer_state
166	{
167	FILE *yy_input_file;
168
169	char yy_ch_buf; / input buffer */
170	char yy_buf_pos; / current position in input buffer */
171
172	/* Size of input buffer in bytes, not including room for EOB
173	* characters.
174	*/
175	yy_size_t yy_buf_size;
176
177	/* Number of characters read into yy_ch_buf, not including EOB
178	* characters.
179	*/
180	int yy_n_chars;
181
182	/* Whether we "own" the buffer - i.e., we know we created it,
183	* and can realloc() it to grow it, and should free() it to
184	* delete it.
185	*/
186	int yy_is_our_buffer;
187
188	/* Whether this is an "interactive" input source; if so, and
189	* if we're using stdio for input, then we want to use getc()
190	* instead of fread(), to make sure we stop fetching input after
191	* each newline.
192	*/
193	int yy_is_interactive;
194
195	/* Whether we're considered to be at the beginning of a line.
196	* If so, '^' rules will be active on the next match, otherwise
197	* not.
198	*/
199	int yy_at_bol;
200
201	/* Whether to try to fill the input buffer when we reach the
202	* end of it.
203	*/
204	int yy_fill_buffer;
205
206	int yy_buffer_status;
207	#define YY_BUFFER_NEW 0
208	#define YY_BUFFER_NORMAL 1
209	/* When an EOF's been seen but there's still some text to process
210	* then we mark the buffer as YY_EOF_PENDING, to indicate that we
211	* shouldn't try reading from the input source any more. We might
212	* still have a bunch of tokens to match, though, because of
213	* possible backing-up.
214	*
215	* When we actually see the EOF, we change the status to "new"
216	* (via yyrestart()), so that the user can continue scanning by
217	* just pointing yyin at a new input file.
218	*/
219	#define YY_BUFFER_EOF_PENDING 2
220	};
221
222	static YY_BUFFER_STATE yy_current_buffer = 0;
223
224	/* We provide macros for accessing buffer states in case in the
225	* future we want to put the buffer states in a more general
226	* "scanner state".
227	*/
228	#define YY_CURRENT_BUFFER yy_current_buffer
229
230
231	/* yy_hold_char holds the character lost when yytext is formed. */
232	static char yy_hold_char;
233
234	static int yy_n_chars; /* number of characters read into yy_ch_buf */
235
236
237	int yyleng;
238
239	/* Points to current character in buffer. */
240	static char yy_c_buf_p = (char ) 0;
241	static int yy_init = 1; /* whether we need to initialize */
242	static int yy_start = 0; /* start state number */
243
244	/* Flag which is used to allow yywrap()'s to do buffer switches
245	* instead of setting up a fresh yyin. A bit of a hack ...
246	*/
247	static int yy_did_buffer_switch_on_eof;
248
249	void yyrestart YY_PROTO(( FILE *input_file ));
250
251	void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
252	void yy_load_buffer_state YY_PROTO(( void ));
253	YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
254	void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
255	void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
256	void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
257	#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
258
259	YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
260	YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
261	YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
262
263	static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
264	static void yy_flex_realloc YY_PROTO(( void , yy_size_t ));
265	static void yy_flex_free YY_PROTO(( void * ));
266
267	#define yy_new_buffer yy_create_buffer
268
269	#define yy_set_interactive(is_interactive) \
270	{ \
271	if ( ! yy_current_buffer ) \
272	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
273	yy_current_buffer->yy_is_interactive = is_interactive; \
274	}
275
276	#define yy_set_bol(at_bol) \
277	{ \
278	if ( ! yy_current_buffer ) \
279	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
280	yy_current_buffer->yy_at_bol = at_bol; \
281	}
282
283	#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
284
285
286	#define YY_USES_REJECT
287	typedef unsigned char YY_CHAR;
288	FILE yyin = (FILE ) 0, yyout = (FILE ) 0;
289	typedef int yy_state_type;
290	extern char *yytext;
291	#define yytext_ptr yytext
292
293	static yy_state_type yy_get_previous_state YY_PROTO(( void ));
294	static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
295	static int yy_get_next_buffer YY_PROTO(( void ));
296	static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
297
298	/* Done after the current pattern has been matched and before the
299	* corresponding action - sets up yytext.
300	*/
301	#define YY_DO_BEFORE_ACTION \
302	yytext_ptr = yy_bp; \
303	yyleng = (int) (yy_cp - yy_bp); \
304	yy_hold_char = *yy_cp; \
305	*yy_cp = '\0'; \
306	yy_c_buf_p = yy_cp;
307
308	#define YY_NUM_RULES 72
309	#define YY_END_OF_BUFFER 73
310	static yyconst short int yy_acclist[406] =
311	{ 0,
312	2, 2, 56, 56, 46, 46, 31, 31, 29, 29,
313	73, 69, 71, 72, 64, 69, 71, 72, 66, 69,
314	72, 71, 72, 71, 72, 63, 71, 72, 63, 71,
315	72, 37, 63, 71, 72, 63, 71, 72, 36, 71,
316	72, 13, 71, 72, 62, 71, 72, 62, 63, 71,
317	72, 62, 71, 72, 62, 71, 72, 62, 71, 72,
318	62, 71, 72, 62, 71, 72, 64, 69, 71, 72,
319	16, 63, 71, 72, 72, 72, 22, 65, 72, 21,
320	72, 23, 72, 72, 34, 72, 72, 20, 72, 68,
321	70, 72, 68, 72, 70, 72, 67, 70, 72, 2,
322
323	72, 1, 72, 41, 72, 41, 42, 72, 56, 72,
324	56, 72, 57, 72, 56, 72, 56, 72, 56, 72,
325	50, 72, 46, 50, 72, 49, 72, 48, 72, 50,
326	72, 47, 50, 72, 72, 72, 59, 72, 72, 72,
327	61, 72, 72, 40, 72, 40, 62, 72, 39, 40,
328	62, 72, 45, 72, 44, 45, 72, 43, 45, 72,
329	72, 27, 72, 31, 72, 31, 72, 32, 72, 31,
330	72, 29, 72, 30, 72, 51, 72, 64, 15, 17,
331	14, 36, 13, 62, 62, 3, 62, 6, 62, 62,
332	62, 62, 62, 5, 62, 4, 62, 62, 64, 16,
333
334	16, 19, 34, 20, 67, 2, 1, 41, 56, 56,
335	56, 56, 17, 56, 56, 54, 56, 50, 46, 50,
336	47, 50, 47, 50, 47, 59, 61, 60, 61, 39,
337	39, 39, 62, 44, 27, 31, 31, 31, 31, 29,
338	51, 53, 51, 51, 14, 12, 12, 62, 3, 12,
339	3, 12, 6, 12, 6, 12, 8, 62, 62, 62,
340	62, 7, 62, 5, 12, 5, 12, 4, 12, 4,
341	12, 16, 56, 39, 62, 31, 31, 31, 52, 3,
342	3, 6, 6, 8, 12, 8, 12, 9, 62, 10,
343	62, 11, 62, 7, 12, 7, 12, 5, 5, 4,
344
345	4, 55, 56, 38, 39, 62, 31, 31, 26, 8,
346	8, 9, 12, 9, 12, 10, 12, 10, 12, 11,
347	12, 11, 12, 7, 7, 55, 56, 56, 55, 56,
348	58, 59, 38, 39, 38, 39, 26, 31, 31, 26,
349	26, 28, 9, 9, 10, 10, 11, 11, 35, 55,
350	56, 55, 56, 55, 56, 55, 56, 26, 31, 31,
351	26, 31, 28, 31, 26, 26, 26, 28, 28, 24,
352	35, 35, 55, 56, 55, 56, 26, 31, 26, 31,
353	26, 31, 28, 31, 31, 28, 31, 33, 26, 28,
354	28, 28, 25, 26, 31, 28, 31, 28, 31, 28,
355
356	31, 28, 18, 28, 31
357	} ;
358
359	static yyconst short int yy_accept[330] =
360	{ 0,
361	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
362	1, 1, 1, 1, 1, 1, 1, 2, 3, 3,
363	3, 4, 5, 6, 7, 7, 7, 7, 7, 7,
364	7, 7, 7, 7, 7, 8, 9, 10, 11, 11,
365	11, 12, 15, 19, 22, 24, 26, 29, 32, 36,
366	39, 42, 45, 48, 52, 55, 58, 61, 64, 67,
367	71, 75, 76, 77, 80, 82, 84, 85, 87, 88,
368	90, 93, 95, 97, 100, 102, 104, 106, 109, 111,
369	113, 115, 117, 119, 121, 123, 126, 128, 130, 132,
370	135, 136, 137, 139, 140, 141, 143, 144, 146, 149,
371
372	153, 155, 158, 161, 162, 164, 166, 168, 170, 172,
373	174, 176, 178, 179, 179, 179, 179, 179, 179, 180,
374	181, 182, 183, 184, 185, 186, 188, 190, 191, 192,
375	193, 194, 196, 198, 199, 200, 201, 202, 202, 203,
376	203, 204, 204, 205, 206, 207, 208, 209, 210, 211,
377	212, 213, 215, 216, 217, 218, 219, 221, 223, 225,
378	226, 226, 227, 227, 227, 227, 227, 228, 228, 230,
379	231, 232, 234, 235, 235, 236, 237, 238, 239, 240,
380	241, 243, 244, 244, 244, 245, 245, 245, 245, 245,
381	245, 245, 246, 247, 249, 251, 253, 255, 257, 259,
382
383	260, 261, 262, 264, 266, 268, 270, 272, 272, 273,
384	274, 274, 276, 277, 278, 279, 279, 280, 280, 280,
385	280, 280, 280, 280, 281, 282, 283, 284, 286, 288,
386	290, 292, 294, 296, 298, 299, 300, 301, 302, 302,
387	304, 304, 307, 308, 309, 309, 310, 310, 310, 310,
388	310, 311, 312, 314, 316, 318, 320, 322, 324, 325,
389	326, 326, 328, 329, 331, 331, 333, 335, 337, 339,
390	340, 340, 341, 341, 342, 343, 343, 343, 343, 344,
391	345, 346, 347, 348, 349, 350, 352, 354, 356, 358,
392	360, 361, 363, 365, 365, 366, 367, 368, 369, 369,
393
394	370, 371, 371, 371, 372, 373, 375, 377, 379, 381,
395	383, 385, 386, 388, 389, 390, 391, 392, 393, 394,
396	394, 396, 398, 400, 402, 403, 404, 406, 406
397	} ;
398
399	static yyconst int yy_ec[256] =
400	{ 0,
401	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
402	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
404	1, 2, 4, 4, 5, 4, 6, 4, 4, 7,
405	8, 9, 10, 11, 6, 12, 13, 14, 14, 14,
406	14, 14, 14, 14, 14, 14, 14, 4, 15, 6,
407	4, 6, 4, 4, 16, 16, 16, 17, 16, 18,
408	16, 16, 16, 16, 16, 16, 16, 16, 16, 19,
409	16, 16, 16, 20, 16, 16, 16, 16, 16, 16,
410	6, 21, 6, 4, 22, 4, 23, 16, 24, 25,
411
412	26, 27, 28, 16, 29, 16, 16, 30, 31, 32,
413	33, 16, 16, 34, 35, 36, 37, 38, 39, 39,
414	39, 39, 4, 4, 4, 4, 4, 4, 4, 4,
415	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
416	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
417	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
418	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
419	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
420	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
421	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
422
423	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
424	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
425	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
426	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
427	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
428	4, 4, 4, 4, 4
429	} ;
430
431	static yyconst int yy_meta[40] =
432	{ 0,
433	1, 2, 3, 1, 1, 1, 2, 1, 1, 1,
434	4, 1, 1, 5, 1, 5, 5, 5, 5, 5,
435	1, 5, 5, 5, 5, 5, 5, 5, 5, 5,
436	5, 5, 5, 5, 5, 5, 5, 5, 5
437	} ;
438
439	static yyconst short int yy_base[369] =
440	{ 0,
441	0, 38, 764, 763, 761, 760, 759, 758, 757, 756,
442	755, 754, 753, 752, 48, 69, 751, 750, 39, 84,
443	86, 90, 93, 107, 41, 95, 44, 80, 122, 0,
444	112, 160, 749, 748, 163, 167, 747, 746, 740, 739,
445	746, 767, 100, 767, 767, 148, 767, 173, 767, 53,
446	731, 0, 722, 0, 157, 164, 163, 170, 173, 186,
447	187, 740, 767, 767, 767, 767, 739, 767, 738, 767,
448	767, 767, 767, 0, 737, 767, 0, 0, 718, 191,
449	767, 185, 195, 178, 0, 736, 767, 767, 724, 725,
450	732, 198, 767, 199, 200, 767, 201, 767, 0, 211,
451
452	767, 732, 767, 730, 767, 0, 213, 767, 706, 0,
453	767, 217, 221, 705, 704, 175, 201, 232, 767, 767,
454	0, 715, 0, 234, 0, 237, 239, 241, 243, 245,
455	255, 268, 270, 277, 281, 726, 272, 724, 767, 723,
456	767, 722, 767, 0, 721, 767, 0, 702, 285, 283,
457	228, 701, 291, 767, 43, 0, 719, 709, 708, 0,
458	715, 767, 293, 222, 295, 206, 767, 208, 767, 298,
459	767, 300, 715, 713, 767, 0, 303, 689, 232, 0,
460	308, 711, 700, 709, 294, 679, 683, 674, 683, 282,
461	683, 0, 767, 0, 314, 767, 322, 767, 324, 328,
462
463	330, 332, 339, 334, 767, 341, 767, 692, 703, 297,
464	82, 345, 672, 668, 675, 692, 767, 661, 659, 651,
465	644, 640, 630, 355, 767, 357, 767, 360, 767, 366,
466	368, 370, 372, 767, 374, 767, 376, 767, 254, 378,
467	379, 383, 629, 606, 599, 381, 603, 598, 593, 558,
468	395, 767, 398, 767, 400, 767, 402, 767, 404, 767,
469	502, 406, 374, 396, 410, 767, 412, 767, 416, 453,
470	439, 420, 445, 336, 421, 452, 423, 395, 422, 767,
471	435, 767, 437, 767, 439, 430, 431, 434, 454, 446,
472	403, 351, 458, 408, 413, 417, 449, 461, 376, 453,
473
474	353, 343, 314, 475, 767, 466, 480, 457, 471, 475,
475	483, 309, 476, 311, 479, 484, 487, 490, 250, 162,
476	491, 494, 495, 498, 499, 115, 502, 767, 517, 522,
477	527, 532, 537, 542, 547, 552, 557, 562, 567, 572,
478	577, 582, 587, 592, 95, 89, 597, 602, 607, 40,
479	612, 617, 622, 627, 632, 637, 642, 647, 652, 657,
480	662, 667, 672, 677, 682, 687, 692, 697
481	} ;
482
483	static yyconst short int yy_def[369] =
484	{ 0,
485	328, 1, 329, 329, 330, 330, 330, 330, 330, 330,
486	331, 331, 332, 332, 333, 333, 334, 334, 335, 335,
487	336, 336, 337, 337, 338, 338, 339, 339, 328, 29,
488	340, 340, 341, 341, 342, 342, 343, 343, 330, 330,
489	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
490	328, 344, 345, 346, 345, 345, 345, 345, 345, 328,
491	328, 347, 328, 328, 328, 328, 348, 328, 349, 328,
492	328, 328, 328, 350, 351, 328, 352, 352, 353, 353,
493	328, 353, 353, 353, 354, 354, 328, 328, 354, 355,
494	356, 356, 328, 356, 357, 328, 357, 328, 346, 346,
495
496	328, 328, 328, 358, 328, 359, 359, 328, 359, 360,
497	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
498	361, 328, 344, 345, 346, 345, 345, 345, 345, 345,
499	345, 345, 345, 345, 328, 328, 328, 347, 328, 348,
500	328, 349, 328, 350, 351, 328, 352, 353, 353, 353,
501	353, 353, 353, 328, 353, 354, 354, 355, 355, 362,
502	356, 328, 356, 356, 356, 357, 328, 357, 328, 328,
503	328, 346, 328, 358, 328, 359, 359, 359, 359, 360,
504	328, 328, 328, 363, 328, 328, 328, 328, 328, 328,
505	328, 361, 328, 346, 328, 328, 328, 328, 345, 345,
506
507	345, 345, 345, 328, 328, 328, 328, 328, 328, 353,
508	356, 346, 359, 359, 359, 363, 328, 328, 328, 328,
509	328, 328, 328, 328, 328, 328, 328, 328, 328, 345,
510	345, 345, 328, 328, 328, 328, 328, 328, 328, 353,
511	356, 346, 359, 359, 328, 328, 328, 328, 328, 328,
512	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
513	328, 353, 353, 364, 356, 328, 328, 328, 359, 359,
514	328, 328, 328, 365, 328, 328, 328, 328, 328, 328,
515	328, 328, 328, 328, 328, 364, 364, 364, 364, 359,
516	359, 366, 359, 328, 365, 365, 365, 328, 328, 367,
517
518	328, 328, 328, 328, 328, 364, 364, 366, 366, 366,
519	359, 359, 368, 328, 365, 367, 367, 367, 328, 328,
520	366, 368, 368, 368, 367, 328, 368, 0, 328, 328,
521	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
522	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
523	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
524	328, 328, 328, 328, 328, 328, 328, 328
525	} ;
526
527	static yyconst short int yy_nxt[807] =
528	{ 0,
529	42, 43, 44, 45, 46, 47, 47, 47, 47, 48,
530	47, 49, 50, 51, 52, 53, 53, 53, 53, 53,
531	45, 54, 55, 56, 53, 53, 53, 53, 53, 53,
532	53, 53, 57, 58, 53, 53, 53, 59, 53, 60,
533	63, 78, 92, 93, 144, 63, 96, 61, 71, 71,
534	72, 73, 73, 73, 73, 73, 73, 73, 73, 73,
535	73, 120, 73, 149, 97, 121, 94, 210, 73, 71,
536	71, 72, 73, 73, 73, 73, 73, 73, 73, 73,
537	73, 73, 96, 73, 162, 63, 78, 80, 81, 73,
538	63, 80, 81, 125, 86, 87, 92, 93, 82, 124,
539
540	97, 113, 82, 88, 114, 89, 83, 90, 86, 87,
541	83, 84, 241, 102, 63, 84, 326, 88, 103, 89,
542	94, 90, 98, 98, 63, 98, 98, 98, 98, 98,
543	98, 98, 98, 98, 98, 98, 98, 99, 99, 99,
544	99, 99, 98, 99, 99, 99, 99, 99, 99, 99,
545	99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
546	100, 102, 63, 326, 107, 108, 103, 109, 107, 108,
547	126, 109, 115, 116, 118, 119, 117, 127, 125, 128,
548	129, 130, 131, 132, 125, 125, 133, 135, 137, 119,
549	114, 125, 150, 152, 125, 136, 153, 154, 149, 163,
550
551	162, 162, 167, 169, 188, 149, 189, 134, 167, 155,
552	169, 149, 170, 171, 177, 149, 151, 178, 181, 182,
553	168, 168, 113, 164, 162, 114, 168, 190, 168, 183,
554	165, 184, 191, 118, 119, 193, 193, 185, 195, 196,
555	197, 198, 193, 193, 193, 193, 193, 193, 149, 172,
556	126, 319, 127, 165, 199, 194, 193, 193, 194, 155,
557	194, 214, 194, 215, 194, 261, 194, 239, 203, 204,
558	205, 206, 207, 137, 119, 200, 194, 201, 193, 193,
559	202, 132, 135, 133, 150, 114, 153, 154, 208, 194,
560	136, 194, 153, 154, 163, 162, 182, 162, 194, 170,
561
562	171, 170, 171, 149, 177, 149, 221, 178, 151, 181,
563	182, 149, 314, 222, 185, 224, 225, 149, 164, 211,
564	183, 313, 184, 226, 227, 228, 229, 240, 185, 193,
565	193, 193, 193, 193, 193, 235, 236, 199, 212, 320,
566	233, 234, 237, 238, 319, 194, 170, 171, 296, 194,
567	297, 194, 203, 194, 301, 230, 224, 225, 226, 227,
568	194, 251, 252, 309, 231, 310, 232, 253, 254, 255,
569	256, 257, 258, 259, 260, 235, 236, 237, 238, 262,
570	265, 266, 272, 242, 267, 268, 264, 194, 300, 194,
571	263, 194, 264, 273, 149, 274, 251, 252, 149, 279,
572
573	280, 281, 282, 283, 284, 259, 260, 262, 287, 314,
574	288, 265, 266, 267, 268, 292, 289, 290, 263, 303,
575	264, 272, 298, 279, 280, 296, 149, 297, 291, 315,
576	292, 297, 273, 299, 274, 300, 281, 282, 283, 284,
577	304, 305, 287, 306, 288, 288, 287, 290, 288, 302,
578	289, 289, 285, 301, 289, 307, 154, 274, 291, 311,
579	292, 296, 298, 297, 294, 317, 287, 318, 288, 309,
580	312, 310, 313, 299, 289, 300, 304, 305, 306, 293,
581	288, 307, 154, 321, 311, 310, 289, 309, 323, 310,
582	324, 315, 287, 297, 288, 312, 317, 313, 318, 325,
583
584	289, 318, 317, 321, 318, 310, 323, 327, 324, 324,
585	323, 325, 324, 318, 327, 285, 324, 62, 62, 62,
586	62, 62, 63, 63, 63, 63, 63, 67, 67, 67,
587	67, 67, 69, 69, 69, 69, 69, 74, 74, 74,
588	74, 74, 75, 75, 75, 75, 75, 77, 77, 77,
589	77, 77, 79, 79, 79, 79, 79, 85, 85, 85,
590	85, 85, 91, 91, 91, 91, 91, 95, 95, 95,
591	95, 95, 101, 101, 101, 101, 101, 104, 104, 104,
592	104, 104, 106, 106, 106, 106, 106, 110, 110, 110,
593	110, 110, 123, 123, 278, 123, 123, 138, 138, 138,
594
595	138, 138, 140, 140, 140, 140, 140, 142, 142, 142,
596	142, 142, 145, 145, 145, 145, 145, 147, 277, 147,
597	147, 147, 148, 148, 276, 148, 148, 156, 156, 275,
598	271, 156, 159, 159, 270, 159, 159, 161, 161, 161,
599	161, 161, 166, 166, 166, 166, 166, 174, 174, 174,
600	174, 174, 176, 176, 269, 176, 176, 180, 180, 250,
601	180, 180, 192, 192, 249, 192, 192, 160, 160, 248,
602	160, 160, 216, 216, 216, 216, 216, 286, 286, 247,
603	286, 286, 295, 295, 246, 295, 295, 308, 308, 245,
604	308, 308, 316, 316, 217, 316, 316, 322, 322, 244,
605
606	322, 322, 243, 215, 209, 239, 223, 220, 219, 218,
607	189, 217, 184, 182, 213, 175, 173, 162, 160, 160,
608	157, 149, 149, 146, 143, 141, 139, 209, 122, 187,
609	186, 179, 175, 173, 162, 160, 158, 157, 149, 146,
610	143, 141, 139, 125, 122, 328, 112, 112, 111, 111,
611	105, 105, 76, 76, 70, 70, 68, 68, 66, 66,
612	65, 65, 64, 64, 63, 63, 41, 328, 328, 328,
613	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
614	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
615	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
616
617	328, 328, 328, 328, 328, 328
618	} ;
619
620	static yyconst short int yy_chk[807] =
621	{ 0,
622	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
623	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
624	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
625	1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
626	19, 19, 25, 25, 350, 19, 27, 2, 15, 15,
627	15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
628	15, 50, 15, 155, 27, 50, 25, 155, 15, 16,
629	16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
630	16, 16, 28, 16, 211, 20, 20, 21, 21, 16,
631	20, 22, 22, 346, 23, 23, 26, 26, 21, 345,
632
633	28, 43, 22, 23, 43, 23, 21, 23, 24, 24,
634	22, 21, 211, 31, 31, 22, 326, 24, 31, 24,
635	26, 24, 29, 29, 29, 29, 29, 29, 29, 29,
636	29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
637	29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
638	29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
639	29, 32, 32, 320, 35, 35, 32, 35, 36, 36,
640	55, 36, 46, 46, 48, 48, 46, 56, 55, 57,
641	57, 57, 57, 58, 57, 56, 59, 60, 61, 61,
642	60, 58, 80, 82, 59, 60, 83, 83, 84, 92,
643
644	92, 94, 95, 97, 116, 82, 116, 59, 166, 84,
645	168, 80, 100, 100, 107, 83, 80, 107, 112, 112,
646	95, 97, 113, 92, 164, 113, 166, 117, 168, 112,
647	94, 112, 117, 118, 118, 124, 124, 112, 126, 126,
648	127, 127, 128, 128, 129, 129, 130, 130, 151, 100,
649	126, 319, 127, 164, 128, 124, 131, 131, 126, 151,
650	127, 179, 128, 179, 129, 239, 130, 239, 131, 132,
651	132, 133, 133, 137, 137, 129, 131, 130, 134, 134,
652	130, 132, 135, 133, 150, 135, 149, 149, 134, 132,
653	135, 133, 153, 153, 163, 163, 185, 165, 134, 170,
654
655	170, 172, 172, 150, 177, 149, 190, 177, 150, 181,
656	181, 153, 314, 190, 185, 195, 195, 210, 163, 165,
657	181, 312, 181, 197, 197, 199, 199, 210, 181, 200,
658	200, 201, 201, 202, 202, 204, 204, 199, 172, 303,
659	203, 203, 206, 206, 302, 199, 212, 212, 274, 200,
660	274, 201, 203, 202, 301, 200, 224, 224, 226, 226,
661	203, 228, 228, 292, 201, 292, 202, 230, 230, 231,
662	231, 232, 232, 233, 233, 235, 235, 237, 237, 240,
663	241, 241, 246, 212, 242, 242, 263, 230, 299, 231,
664	240, 232, 240, 246, 263, 246, 251, 251, 240, 253,
665
666	253, 255, 255, 257, 257, 259, 259, 262, 264, 294,
667	264, 265, 265, 267, 267, 291, 264, 269, 262, 278,
668	262, 272, 275, 279, 279, 295, 262, 295, 269, 296,
669	269, 296, 272, 275, 272, 275, 281, 281, 283, 283,
670	285, 285, 286, 287, 286, 287, 288, 290, 288, 277,
671	286, 287, 285, 276, 288, 289, 289, 273, 290, 293,
672	290, 297, 298, 297, 271, 300, 289, 300, 289, 308,
673	293, 308, 293, 298, 289, 298, 304, 304, 306, 270,
674	306, 307, 307, 309, 311, 309, 306, 310, 313, 310,
675	313, 315, 307, 315, 307, 311, 316, 311, 316, 317,
676
677	307, 317, 318, 321, 318, 321, 322, 323, 322, 323,
678	324, 325, 324, 325, 327, 261, 327, 329, 329, 329,
679	329, 329, 330, 330, 330, 330, 330, 331, 331, 331,
680	331, 331, 332, 332, 332, 332, 332, 333, 333, 333,
681	333, 333, 334, 334, 334, 334, 334, 335, 335, 335,
682	335, 335, 336, 336, 336, 336, 336, 337, 337, 337,
683	337, 337, 338, 338, 338, 338, 338, 339, 339, 339,
684	339, 339, 340, 340, 340, 340, 340, 341, 341, 341,
685	341, 341, 342, 342, 342, 342, 342, 343, 343, 343,
686	343, 343, 344, 344, 250, 344, 344, 347, 347, 347,
687
688	347, 347, 348, 348, 348, 348, 348, 349, 349, 349,
689	349, 349, 351, 351, 351, 351, 351, 352, 249, 352,
690	352, 352, 353, 353, 248, 353, 353, 354, 354, 247,
691	245, 354, 355, 355, 244, 355, 355, 356, 356, 356,
692	356, 356, 357, 357, 357, 357, 357, 358, 358, 358,
693	358, 358, 359, 359, 243, 359, 359, 360, 360, 223,
694	360, 360, 361, 361, 222, 361, 361, 362, 362, 221,
695	362, 362, 363, 363, 363, 363, 363, 364, 364, 220,
696	364, 364, 365, 365, 219, 365, 365, 366, 366, 218,
697	366, 366, 367, 367, 216, 367, 367, 368, 368, 215,
698
699	368, 368, 214, 213, 209, 208, 191, 189, 188, 187,
700	186, 184, 183, 182, 178, 174, 173, 161, 159, 158,
701	157, 152, 148, 145, 142, 140, 138, 136, 122, 115,
702	114, 109, 104, 102, 91, 90, 89, 86, 79, 75,
703	69, 67, 62, 53, 51, 41, 40, 39, 38, 37,
704	34, 33, 18, 17, 14, 13, 12, 11, 10, 9,
705	8, 7, 6, 5, 4, 3, 328, 328, 328, 328,
706	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
707	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
708	328, 328, 328, 328, 328, 328, 328, 328, 328, 328,
709
710	328, 328, 328, 328, 328, 328
711	} ;
712
713	static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
714	static char *yy_full_match;
715	static int yy_lp;
716	#define REJECT \
717	{ \
718	yy_cp = yy_hold_char; / undo effects of setting up yytext */ \
719	yy_cp = yy_full_match; /* restore poss. backed-over text */ \
720	++yy_lp; \
721	goto find_rule; \
722	}
723	#define yymore() yymore_used_but_not_detected
724	#define YY_MORE_ADJ 0
725	#define YY_RESTORE_YY_MORE_OFFSET
726	char *yytext;
727	#line 1 "vs1.0_tokens.l"
728	#define INITIAL 0
729	#define INCLUDE 1
730	#define DEFINE 2
731	#define DEFSTR 3
732	#define DEFSPACE 4
733	#define SKIPLINE 5
734	#define EATCOMMENT 6
735	#define EATSTRING 7
736	#define SAVELINE 8
737
738	#define MACRONAME 9
739	#define MACROBODY 10
740	#define MACROPARM 11
741	#define EATMACRO 12
742	#define EATDEFINE 13
743	#define MODIFIER 14
744	#define MACROPARMSTART 15
745
746	#define IFDEFNAME 16
747	#define IFDEFBODY 17
748	#define ENDMACRO 18
749	#define MACROPARMEND 19
750
751	#line 8 "vs1.0_tokens.l"
752
753	#include <stdarg.h>
754	#include <stdlib.h>
755	#ifdef _WIN32
756	#include <io.h>
757	# ifdef __GNUC__
758	# include <sys/types.h>
759	# include <ctype.h>
760	# endif
761	#else
762	#include <sys/types.h>
763	#include <ctype.h>
764	#define _stat stat
765	#define _open open
766	#define _O_RDONLY O_RDONLY
767	#define _fstat fstat
768	#define _close close
769	#define stricmp strcasecmp
770
771	#endif
772	#include <sys/stat.h>
773	#include <fcntl.h>
774	#include <string.h>
775	#include "macro.h"
776	#include "nvparse_errors.h"
777	#include "vs1.0_inst_list.h"
778	#include "_vs1.0_parser.h"
779	#define yylineno line_number
780	#include "nvparse_externs.h"
781
782	#define yylineno line_number
783	int line_incr;
784	void LexError(char *format, ...);
785	void LexWarning(char *format, ...);
786	char ReadTextFile(const char filename);
787
788	unsigned int MakeRegisterMask(char *findName);
789	unsigned int FindSwizzleValue(char *swizzleText);
790
791
792	enum ERROR_VALUES {
793	ERROR_NONE = 0,
794	ERROR_MEMORY_ALLOC,
795	ERROR_FILE_OPEN,
796	ERROR_UNSUCCESSFUL_ASSEMBLE,
797	ERROR_TOO_MANY_PARMS,
798	ERROR_DEST_WRITE,
799	ERROR_LIST_OPEN,
800	ERROR_DEST_OPEN,
801	ERROR_NO_ARGUMENTS,
802	ERROR_MACRO_OVERRUN
803	};
804
805
806
807	//extern void GenSwitchFileNames(char *fileName);
808	//extern unsigned int gLinesAssembled;
809	unsigned int gLinesAssembled;
810
811	#define YY_INPUT(buf,result,max_size) \
812	{ \
813	int c = *myin++; \
814	result = (c == 0) ? YY_NULL : (buf[0] = c, 1); \
815	}
816
817	#define SAFEDELETEARRAY(x) if ((x) != NULL) \
818	delete [] (x)
819	#define SAFEFREE(x) if ((x) != NULL) \
820	free((x))
821
822	#define MAXREPLACESTRING 255
823
824	char gReplaceText[MAXREPLACESTRING+1];
825
826	//
827	// forward prototypes for macro functions
828	//
829	void MacroIncFunction(char , unsigned int , char **);
830	void MacroDecFunction(char , unsigned int , char **);
831	void MacroAddFunction(char , unsigned int , char **);
832	void MacroSubFunction(char , unsigned int , char **);
833
834	MACROFUNCTIONS gMacroFunctions[] = {
835	{ "inc(", MacroIncFunction },
836	{ "dec(", MacroDecFunction },
837	{ "add(", MacroAddFunction },
838	{ "sub(", MacroSubFunction }
839	};
840
841	#define NUM_MACRO_FUNCTIONS (sizeof(gMacroFunctions) / sizeof(MACROFUNCTIONS))
842
843	#define MAX_INCLUDE_DEPTH 1024
844	typedef struct INCLUDEINFO
845	{
846	char *fileName;
847	unsigned int lineNo;
848	YY_BUFFER_STATE buffer;
849	MACROENTRY *lastInvokeMacro; // save off in case nested macros.
850	MACROENTRY *lastParseMacro; // recursive macros
851	MACROTEXT *lastMacroLineParse; // save off for recursive lines of macros working on.
852	bool lastbInsideMacro; // save off for recursive macros
853	bool lastbInsideDefine; // save off for recursive macros/defines
854	bool lastbInsideInclude;
855	bool lastbProcessingIFDEF; // save off #define information
856	// FILE *fileHandle;
857	char *prevString;
858	char *nextString;
859	} INCLUDEINFO;
860
861	INCLUDEINFO gIncludeStack[MAX_INCLUDE_DEPTH];
862	int gIncludeStackIndex = 0;
863
864	IFDEFINFO gIfDefStack[MAX_IFDEF_DEPTH];
865	int gIfDefStackIndex = 0;
866
867	unsigned int &base_linenumber = gIncludeStack[0].lineNo;
868
869	bool gbInsideInclude = false;
870	bool gbProcessingBuiltIn = false;
871	bool gbProcessingDefine = false;
872	unsigned int gCountParen = 0;
873
874	bool gbProcessingIFDEF = false;
875	bool gbIFDEF = false;
876	bool gbCompareDefine = false;
877	unsigned int gIfDefStartLine;
878
879
880	MACROENTRY *gLastMacro;
881	MACROENTRY *gInvokeMacro;
882	MACROENTRY *gTempMacro; // until all the parameters are read
883	MACROENTRY FindMacro(char macroName);
884	MACROENTRY FindNMacro(char macroName, unsigned int sLen);
885
886	MACROFUNCTIONPTR gMacroCallFunction;
887
888	char *builtInMacros = "macro m3x2 reg1, reg2, reg3\n"
889	" dp3 %reg1.x, %reg2, %reg3\n"
890	" dp3 %reg1.y, %reg2, %inc(%reg3)\n"
891	"endm";
892
893	//
894	// local prototypes
895	//
896	void CleanUp();
897	void ReplaceMacroParms(char srcLine, char destLine,
898	MACROENTRY srcParms, MACROENTRY invParms);
899
900	MACROTEXT SaveMacroText(char srcText, MACROTEXT *lastMacroText);
901	void FreeMacroEntry(MACROENTRY *macEntry);
902	void EndMacroParms();
903	char FindAlphaNum(char srcStr, unsigned int *sLen);
904	void DebugUnhandledState();
905
906
907	unsigned int gCommentStartLine;
908	unsigned int gMacroStartLine;
909
910	char *gCurFileName = NULL;
911
912	#define MAXSAVELINE 4095
913
914	char gSaveLine[MAXSAVELINE+1];
915	char gMacroLine[MAXSAVELINE+1];
916
917	#if 1
918	#ifdef _DEBUG
919	#define ECHO DebugUnhandledState();
920	#else
921	#define ECHO
922	#endif
923	#endif
924
925	bool gbInsideMacro = false; // flag if we are doing a macro replace or not.
926	bool gbTempInsideMacro = false;
927	unsigned int gInvokeState = INITIAL;
928
929
930	MACROENTRY *gParseMacro; // which source macro entry we are using
931	MACROENTRY *gTempParseMacro; // temporary holder until parameters are received.
932	MACROTEXT *gMacroLineParse; // which line we are currently parsing inside the macro invocation
933
934	typedef enum OPCODETYPE
935	{
936	TYPE_NONE = 0,
937	TYPE_VERTEX_SHADER = 1,
938	TYPE_PIXEL_SHADER = 2
939	};
940	typedef struct OPCODEMAP
941	{
942	char *string; // string for opcode
943	int tokenName; // name of the corresponding token
944	int numArguments; // number of arguments for opcode
945	float version; // minimum version supported in.
946	int opcodeTypeFlags; // whether opcode can be used in vertex shader or pixel shader
947	bool opcodeModify; // if opcode modifiers can be used
948	bool textureOpcode; // only outputs to the texture unit
949	} OPCODEMAP;
950
951	#ifndef TRUE
952	#define TRUE true
953	#endif
954	#ifndef FALSE
955	#define FALSE false
956	#endif
957
958	OPCODEMAP theOpcodes[] = {
959	{ "add", ADD_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
960	{ "dp3", DP3_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
961	{ "dp4", DP4_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
962	{ "dst", DST_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
963	{ "exp", EXP_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
964	{ "expp", EXPP_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
965	{ "frc", FRC_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
966	{ "lit", LIT_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
967	{ "log", LOG_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
968	{ "logp", LOGP_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
969	{ "m3x2", M3X2_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
970	{ "m3x3", M3X3_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
971	{ "m3x4", M3X4_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
972	{ "m4x3", M4X3_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
973	{ "m4x4", M4X4_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
974	{ "mad", MAD_INSTR, 4, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
975	{ "max", MAX_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
976	{ "min", MIN_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
977	{ "mov", MOV_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
978	{ "mul", MUL_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
979	{ "nop", NOP_INSTR, 0, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
980	{ "rcp", RCP_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
981	{ "rsq", RSQ_INSTR, 2, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
982	{ "sge", SGE_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
983	{ "slt", SLT_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER, FALSE, FALSE },
984	{ "sub", SUB_INSTR, 3, 1.0f, TYPE_VERTEX_SHADER \| TYPE_PIXEL_SHADER, TRUE, FALSE },
985	};
986
987	#define NUMOPCODES (sizeof(theOpcodes) / sizeof(OPCODEMAP))
988	OPCODEMAP FindOpcode(char findName);
989
990
991	#line 990 "_vs1.0_lexer.cpp"
992
993	/* Macros after this point can all be overridden by user definitions in
994	* section 1.
995	*/
996
997	#ifndef YY_SKIP_YYWRAP
998	#ifdef __cplusplus
999	extern "C" int yywrap YY_PROTO(( void ));
1000	#else
1001	extern int yywrap YY_PROTO(( void ));
1002	#endif
1003	#endif
1004
1005	#ifndef YY_NO_UNPUT
1006	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1007	#endif
1008
1009	#ifndef yytext_ptr
1010	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
1011	#endif
1012
1013	#ifdef YY_NEED_STRLEN
1014	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1015	#endif
1016
1017	#ifndef YY_NO_INPUT
1018	#ifdef __cplusplus
1019	static int yyinput YY_PROTO(( void ));
1020	#else
1021	static int input YY_PROTO(( void ));
1022	#endif
1023	#endif
1024
1025	#if YY_STACK_USED
1026	static int yy_start_stack_ptr = 0;
1027	static int yy_start_stack_depth = 0;
1028	static int *yy_start_stack = 0;
1029	#ifndef YY_NO_PUSH_STATE
1030	static void yy_push_state YY_PROTO(( int new_state ));
1031	#endif
1032	#ifndef YY_NO_POP_STATE
1033	static void yy_pop_state YY_PROTO(( void ));
1034	#endif
1035	#ifndef YY_NO_TOP_STATE
1036	static int yy_top_state YY_PROTO(( void ));
1037	#endif
1038
1039	#else
1040	#define YY_NO_PUSH_STATE 1
1041	#define YY_NO_POP_STATE 1
1042	#define YY_NO_TOP_STATE 1
1043	#endif
1044
1045	#ifdef YY_MALLOC_DECL
1046	YY_MALLOC_DECL
1047	#else
1048	#if __STDC__
1049	#ifndef __cplusplus
1050	#include <stdlib.h>
1051	#endif
1052	#else
1053	/* Just try to get by without declaring the routines. This will fail
1054	* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1055	* or sizeof(void*) != sizeof(int).
1056	*/
1057	#endif
1058	#endif
1059
1060	/* Amount of stuff to slurp up with each read. */
1061	#ifndef YY_READ_BUF_SIZE
1062	#define YY_READ_BUF_SIZE 8192
1063	#endif
1064
1065	/* Copy whatever the last rule matched to the standard output. */
1066
1067	#ifndef ECHO
1068	/* This used to be an fputs(), but since the string might contain NUL's,
1069	* we now use fwrite().
1070	*/
1071	#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1072	#endif
1073
1074	/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1075	* is returned in "result".
1076	*/
1077	#ifndef YY_INPUT
1078	#define YY_INPUT(buf,result,max_size) \
1079	if ( yy_current_buffer->yy_is_interactive ) \
1080	{ \
1081	int c = '*', n; \
1082	for ( n = 0; n < max_size && \
1083	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1084	buf[n] = (char) c; \
1085	if ( c == '\n' ) \
1086	buf[n++] = (char) c; \
1087	if ( c == EOF && ferror( yyin ) ) \
1088	YY_FATAL_ERROR( "input in flex scanner failed" ); \
1089	result = n; \
1090	} \
1091	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1092	&& ferror( yyin ) ) \
1093	YY_FATAL_ERROR( "input in flex scanner failed" );
1094	#endif
1095
1096	/* No semi-colon after return; correct usage is to write "yyterminate();" -
1097	* we don't want an extra ';' after the "return" because that will cause
1098	* some compilers to complain about unreachable statements.
1099	*/
1100	#ifndef yyterminate
1101	#define yyterminate() return YY_NULL
1102	#endif
1103
1104	/* Number of entries by which start-condition stack grows. */
1105	#ifndef YY_START_STACK_INCR
1106	#define YY_START_STACK_INCR 25
1107	#endif
1108
1109	/* Report a fatal error. */
1110	#ifndef YY_FATAL_ERROR
1111	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1112	#endif
1113
1114	/* Default declaration of generated scanner - a define so the user can
1115	* easily add parameters.
1116	*/
1117	#ifndef YY_DECL
1118	#define YY_DECL int yylex YY_PROTO(( void ))
1119	#endif
1120
1121	/* Code executed at the beginning of each rule, after yytext and yyleng
1122	* have been set up.
1123	*/
1124	#ifndef YY_USER_ACTION
1125	#define YY_USER_ACTION
1126	#endif
1127
1128	/* Code executed at the end of each rule. */
1129	#ifndef YY_BREAK
1130	#define YY_BREAK break;
1131	#endif
1132
1133	#define YY_RULE_SETUP \
1134	if ( yyleng > 0 ) \
1135	yy_current_buffer->yy_at_bol = \
1136	(yytext[yyleng - 1] == '\n'); \
1137	YY_USER_ACTION
1138
1139	YY_DECL
1140	{
1141	register yy_state_type yy_current_state;
1142	register char yy_cp = NULL, yy_bp = NULL;
1143	register int yy_act;
1144
1145	#line 261 "vs1.0_tokens.l"
1146
1147
1148	#line 1147 "_vs1.0_lexer.cpp"
1149
1150	if ( yy_init )
1151	{
1152	yy_init = 0;
1153
1154	#ifdef YY_USER_INIT
1155	YY_USER_INIT;
1156	#endif
1157
1158	if ( ! yy_start )
1159	yy_start = 1; /* first start state */
1160
1161	if ( ! yyin )
1162	yyin = stdin;
1163
1164	if ( ! yyout )
1165	yyout = stdout;
1166
1167	if ( ! yy_current_buffer )
1168	yy_current_buffer =
1169	yy_create_buffer( yyin, YY_BUF_SIZE );
1170
1171	yy_load_buffer_state();
1172	}
1173
1174	while ( 1 ) /* loops until end-of-file is reached */
1175	{
1176	yy_cp = yy_c_buf_p;
1177
1178	/* Support of yytext. */
1179	*yy_cp = yy_hold_char;
1180
1181	/* yy_bp points to the position in yy_ch_buf of the start of
1182	* the current run.
1183	*/
1184	yy_bp = yy_cp;
1185
1186	yy_current_state = yy_start;
1187	yy_current_state += YY_AT_BOL();
1188	yy_state_ptr = yy_state_buf;
1189	*yy_state_ptr++ = yy_current_state;
1190	yy_match:
1191	do
1192	{
1193	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1194	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1195	{
1196	yy_current_state = (int) yy_def[yy_current_state];
1197	if ( yy_current_state >= 329 )
1198	yy_c = yy_meta[(unsigned int) yy_c];
1199	}
1200	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1201	*yy_state_ptr++ = yy_current_state;
1202	++yy_cp;
1203	}
1204	while ( yy_base[yy_current_state] != 767 );
1205
1206	yy_find_action:
1207	yy_current_state = *--yy_state_ptr;
1208	yy_lp = yy_accept[yy_current_state];
1209	find_rule: /* we branch to this label when backing up */
1210	for ( ; ; ) /* until we find what rule we matched */
1211	{
1212	if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1213	{
1214	yy_act = yy_acclist[yy_lp];
1215	{
1216	yy_full_match = yy_cp;
1217	break;
1218	}
1219	}
1220	--yy_cp;
1221	yy_current_state = *--yy_state_ptr;
1222	yy_lp = yy_accept[yy_current_state];
1223	}
1224
1225	YY_DO_BEFORE_ACTION;
1226
1227
1228	do_action: /* This label is used only to access EOF actions. */
1229
1230
1231	switch ( yy_act )
1232	{ /* beginning of action switch */
1233	case 1:
1234	YY_RULE_SETUP
1235	#line 263 "vs1.0_tokens.l"
1236	{
1237	gbProcessingDefine = false;
1238	gSaveLine[0] = '\0';
1239	strncat(gSaveLine, yytext, MAXSAVELINE);
1240	// GenDebugLine();
1241	if (gbProcessingIFDEF && (gbCompareDefine != gbIFDEF))
1242	{
1243	BEGIN(IFDEFBODY);
1244	}
1245	else
1246	{
1247	BEGIN(INITIAL);
1248	}
1249	yyless(0);
1250	}
1251	YY_BREAK
1252	case 2:
1253	YY_RULE_SETUP
1254	#line 279 "vs1.0_tokens.l"
1255	{
1256	gbProcessingDefine = false;
1257	gSaveLine[0] = '\0';
1258	strncat(gSaveLine, yytext, MAXSAVELINE);
1259	// GenDebugLine();
1260	if (gbProcessingIFDEF && (gbCompareDefine != gbIFDEF))
1261	{
1262	BEGIN(IFDEFBODY);
1263	}
1264	else
1265	{
1266	BEGIN(INITIAL);
1267	}
1268	yyless(0);
1269	}
1270	YY_BREAK
1271	case 3:
1272	YY_RULE_SETUP
1273	#line 295 "vs1.0_tokens.l"
1274	{
1275	// fprintf( stderr, "%s", yytext );
1276	vs10_lval.reg.type = TYPE_ADDRESS_REG;
1277	vs10_lval.reg.index = atoi(&yytext[1]);
1278	if ( yytext[yyleng-1] == '\n' )
1279	line_incr = 1;
1280	return REGISTER;
1281	}
1282	YY_BREAK
1283	case 4:
1284	YY_RULE_SETUP
1285	#line 304 "vs1.0_tokens.l"
1286	{
1287	// fprintf( stderr, "%s", yytext );
1288	vs10_lval.reg.type = TYPE_VERTEX_ATTRIB_REG;
1289	vs10_lval.reg.index = atoi(&yytext[1]);
1290	if ( yytext[yyleng-1] == '\n' )
1291	line_incr = 1;
1292	return REGISTER;
1293	}
1294	YY_BREAK
1295	case 5:
1296	YY_RULE_SETUP
1297	#line 313 "vs1.0_tokens.l"
1298	{
1299	// fprintf( stderr, "%s", yytext );
1300	vs10_lval.reg.type = TYPE_TEMPORARY_REG;
1301	vs10_lval.reg.index = atoi(&yytext[1]);
1302	if ( yytext[yyleng-1] == '\n' )
1303	line_incr = 1;
1304	return REGISTER;
1305	}
1306	YY_BREAK
1307	case 6:
1308	YY_RULE_SETUP
1309	#line 322 "vs1.0_tokens.l"
1310	{
1311	// fprintf( stderr, "%s", yytext );
1312	vs10_lval.reg.type = TYPE_CONSTANT_MEM_REG;
1313	vs10_lval.reg.index = atoi(&yytext[1]);
1314	if ( yytext[yyleng-1] == '\n' )
1315	line_incr = 1;
1316	return REGISTER;
1317	}
1318	YY_BREAK
1319	case 7:
1320	YY_RULE_SETUP
1321	#line 331 "vs1.0_tokens.l"
1322	{
1323	// fprintf( stderr, "%s", yytext );
1324	vs10_lval.reg.type = TYPE_TEXTURE_RESULT_REG;
1325	vs10_lval.reg.index = atoi(&yytext[2]);
1326	if ( yytext[yyleng-1] == '\n' )
1327	line_incr = 1;
1328	return REGISTER;
1329	}
1330	YY_BREAK
1331	case 8:
1332	YY_RULE_SETUP
1333	#line 340 "vs1.0_tokens.l"
1334	{
1335	// fprintf( stderr, "%s", yytext );
1336	vs10_lval.reg.type = TYPE_COLOR_RESULT_REG;
1337	vs10_lval.reg.index = atoi(&yytext[2]);
1338	if ( yytext[yyleng-1] == '\n' )
1339	line_incr = 1;
1340	return REGISTER;
1341	}
1342	YY_BREAK
1343	case 9:
1344	YY_RULE_SETUP
1345	#line 349 "vs1.0_tokens.l"
1346	{
1347	// fprintf( stderr, "%s", yytext );
1348	vs10_lval.reg.type = TYPE_FOG_RESULT_REG;
1349	if ( yytext[yyleng-1] == '\n' )
1350	line_incr = 1;
1351	return REGISTER;
1352	}
1353	YY_BREAK
1354	case 10:
1355	YY_RULE_SETUP
1356	#line 357 "vs1.0_tokens.l"
1357	{
1358	// fprintf( stderr, "%s", yytext );
1359	vs10_lval.reg.type = TYPE_POSITION_RESULT_REG;
1360	if ( yytext[yyleng-1] == '\n' )
1361	line_incr = 1;
1362	return REGISTER;
1363	}
1364	YY_BREAK
1365	case 11:
1366	YY_RULE_SETUP
1367	#line 365 "vs1.0_tokens.l"
1368	{
1369	// fprintf( stderr, "%s", yytext );
1370	vs10_lval.reg.type = TYPE_POINTS_RESULT_REG;
1371	if ( yytext[yyleng-1] == '\n' )
1372	line_incr = 1;
1373	return REGISTER;
1374	}
1375	YY_BREAK
1376	case 12:
1377	YY_RULE_SETUP
1378	#line 373 "vs1.0_tokens.l"
1379	{
1380
1381	unsigned int offset;
1382
1383	offset = strcspn(yytext, " \t\n_");
1384	yyless(offset);
1385
1386	OPCODEMAP *opcodeMap = FindOpcode(yytext);
1387	if ( opcodeMap != NULL )
1388	{
1389	// fprintf( stderr, "%s\t", opcodeMap->string );
1390	return( opcodeMap->tokenName );
1391	}
1392	else
1393	{
1394	gTempParseMacro = FindMacro(yytext);
1395
1396	if (gTempParseMacro != NULL)
1397	{
1398	if (gIncludeStackIndex >= MAX_INCLUDE_DEPTH )
1399	{
1400	LexError("macros nested too deeply");
1401	exit( 1 );
1402	}
1403
1404	if (gTempParseMacro->firstMacroLines != NULL)
1405	{
1406
1407	gTempMacro = (MACROENTRY *)malloc(sizeof(MACROENTRY));
1408	if (gTempMacro == NULL)
1409	{
1410	LexError("Out of memory allocating MACROENTRY structure.\n");
1411	}
1412	else
1413	{
1414
1415	gTempMacro->next = NULL;
1416	gTempMacro->prev = NULL;
1417	gTempMacro->macroName = NULL;
1418	gTempMacro->firstMacroParms = NULL;
1419	gTempMacro->lastMacroParms = NULL;
1420	gTempMacro->firstMacroLines = NULL;
1421	gTempMacro->lastMacroLines = NULL;
1422	gTempMacro->numParms = 0;
1423	gTempMacro->nLines = 0;
1424
1425	gbTempInsideMacro = true; // flag we are currently doing a macro replace.
1426	gInvokeState = YYSTATE;
1427	if (gTempParseMacro->numParms > 0)
1428	{
1429	BEGIN(MACROPARMSTART);
1430	}
1431	else
1432	{
1433	EndMacroParms();
1434	gbTempInsideMacro = false; // no longer waiting for macro invocation
1435	}
1436
1437
1438	}
1439	}
1440	}
1441	else
1442	{
1443	// fprintf( stderr, "Opcode: \"%s\" not found\n", yytext );
1444	REJECT;
1445	}
1446	}
1447
1448	//unsigned int offset;
1449	//
1450	//INSTRMAP *opcodeMap;
1451	//
1452	//offset = strcspn(yytext, " \t\n_");
1453	//yyless(offset);
1454	//opcodeMap = FindInstruction(yytext);
1455	//if (opcodeMap == NULL)
1456	//{
1457	// REJECT;
1458	//}
1459	//
1460	//yylval.opcodeInfo.opcodeMap = opcodeMap;
1461	//
1462	//return OPCODE;
1463	}
1464	YY_BREAK
1465	case 13:
1466	YY_RULE_SETUP
1467	#line 460 "vs1.0_tokens.l"
1468	{
1469	// fprintf( stderr, "%s", yytext );
1470	char *cmt = new char[yyleng+1];
1471	strncpy( cmt, yytext, yyleng );
1472	cmt[0] = '#';
1473	cmt[yyleng] = '\0';
1474	vs10_lval.comment = cmt;
1475	return COMMENT;
1476	}
1477	YY_BREAK
1478	case 14:
1479	YY_RULE_SETUP
1480	#line 470 "vs1.0_tokens.l"
1481	{
1482	// fprintf( stderr, "%s", yytext );
1483	char *cmt = new char[yyleng+1];
1484	strncpy( cmt+1, yytext+1, yyleng-1 );
1485	cmt[0] = '#';
1486	cmt[1] = ' ';
1487	cmt[yyleng] = '\0';
1488	vs10_lval.comment = cmt;
1489	return COMMENT;
1490	}
1491	YY_BREAK
1492	case 15:
1493	YY_RULE_SETUP
1494	#line 481 "vs1.0_tokens.l"
1495	{
1496	fprintf( stderr, "COISSUE found\n" );
1497	yyless(yyleng-1);
1498	//return COISSUE;
1499	}
1500	YY_BREAK
1501	case 16:
1502	YY_RULE_SETUP
1503	#line 487 "vs1.0_tokens.l"
1504	{
1505	fprintf( stderr, "COISSUE found\n" );
1506	//return COISSUE;
1507	}
1508	YY_BREAK
1509	case 17:
1510	YY_RULE_SETUP
1511	#line 492 "vs1.0_tokens.l"
1512	{
1513	gCommentStartLine = yylineno;
1514	yyless(0);
1515	BEGIN(EATCOMMENT);
1516	}
1517	YY_BREAK
1518	case 18:
1519	YY_RULE_SETUP
1520	#line 498 "vs1.0_tokens.l"
1521	{
1522	BEGIN(INCLUDE);
1523	}
1524	YY_BREAK
1525	case 19:
1526	YY_RULE_SETUP
1527	#line 502 "vs1.0_tokens.l"
1528	{ /* got the include file name */
1529
1530	// FILE *newyyin;
1531	char *newyyin;
1532	char incFileName[1024];
1533	unsigned long sLen;
1534	bool validFileName;
1535
1536	if ( gIncludeStackIndex >= MAX_INCLUDE_DEPTH )
1537	{
1538	LexError("Includes nested too deeply, aborting\n");
1539	exit( 1 );
1540	}
1541
1542	// GenDebugLine();
1543	// GenListString();
1544	yylineno++;
1545	gLinesAssembled++;
1546
1547	validFileName = true;
1548	// zap "" and <>
1549	if ((yytext[0] == '"') \|\| (yytext[0] == '<'))
1550	{
1551	char *endQuote;
1552	endQuote = strchr(&yytext[1], yytext[0]);
1553	sLen = (endQuote - yytext)-1;
1554	if (endQuote == NULL)
1555	{
1556	LexError("Unable to open include file %s\n", incFileName);
1557	BEGIN(INITIAL);
1558	validFileName = false;
1559	}
1560	else
1561	{
1562	incFileName[0] ='\0';
1563	strncat(incFileName, &yytext[1], sLen);
1564	}
1565	}
1566	else
1567	{
1568	strcpy(incFileName, yytext);
1569	}
1570
1571	if (validFileName)
1572	{
1573	sLen = strlen(incFileName);
1574	if ((incFileName[sLen-1] == '"') \|\| (incFileName[sLen-1] == '>'))
1575	{
1576	incFileName[sLen-1] = '\0';
1577	}
1578
1579
1580	newyyin = ReadTextFile( incFileName );
1581	// newyyin = fopen( incFileName, "r" );
1582
1583	if ( ! newyyin )
1584	{
1585	LexError("Unable to open include file %s\n", incFileName);
1586	BEGIN(SAVELINE);
1587	}
1588	else
1589	{
1590	gIncludeStack[gIncludeStackIndex].fileName = gCurFileName;
1591	gIncludeStack[gIncludeStackIndex].lineNo = yylineno;
1592	// gIncludeStack[gIncludeStackIndex].fileHandle = yyin;
1593	gIncludeStack[gIncludeStackIndex].prevString = myin;
1594	gIncludeStack[gIncludeStackIndex].nextString = newyyin;
1595	gIncludeStack[gIncludeStackIndex].lastInvokeMacro = gInvokeMacro;
1596	gIncludeStack[gIncludeStackIndex].lastParseMacro = gParseMacro;
1597	gIncludeStack[gIncludeStackIndex].lastMacroLineParse = gMacroLineParse;
1598	gIncludeStack[gIncludeStackIndex].lastbInsideMacro = gbInsideMacro;
1599	gIncludeStack[gIncludeStackIndex].lastbInsideInclude = gbInsideInclude;
1600	gIncludeStack[gIncludeStackIndex].buffer = YY_CURRENT_BUFFER;
1601	gIncludeStack[gIncludeStackIndex].lastbProcessingIFDEF = gbProcessingIFDEF;
1602	gIncludeStackIndex++;
1603
1604	gbProcessingIFDEF = false;
1605
1606	gCurFileName = strdup(incFileName);
1607	// yyin = newyyin;
1608	myin = newyyin;
1609
1610	// GenSwitchFileNames(gCurFileName);
1611
1612	yylineno = 1;
1613
1614	yy_switch_to_buffer(yy_create_buffer( yyin, YY_BUF_SIZE ) );
1615
1616	gbInsideInclude = true;
1617
1618	BEGIN(SAVELINE);
1619	}
1620	}
1621	}
1622	YY_BREAK
1623	case YY_STATE_EOF(EATCOMMENT):
1624	#line 597 "vs1.0_tokens.l"
1625	{
1626	LexError("End of file reached before end of comment started on line %d.\n", gCommentStartLine);
1627	BEGIN(INITIAL);
1628	}
1629	YY_BREAK
1630	case 20:
1631	YY_RULE_SETUP
1632	#line 602 "vs1.0_tokens.l"
1633	{
1634	char *endComment;
1635	unsigned int keepSize;
1636
1637	strcpy(gSaveLine, yytext);
1638	endComment = strstr(yytext, "*/");
1639
1640	char *cmt;
1641	if (endComment != NULL)
1642	{
1643	keepSize = (endComment - yytext+2);
1644	yyless(keepSize);
1645	BEGIN(INITIAL);
1646
1647	if ( yytext[0] == '/' && yytext[1] == '*' )
1648	{
1649	cmt = new char[yyleng];
1650	strncpy( cmt+3, yytext+2, yyleng-2 );
1651	cmt[0] = '#';
1652	cmt[1] = ' ';
1653	cmt[2] = ' ';
1654	cmt[yyleng-1] = '\0';
1655	}
1656	else
1657	{
1658	cmt = new char[yyleng];
1659	strncpy( cmt+1, yytext, yyleng-2 );
1660	cmt[0] = '#';
1661	cmt[yyleng-1] = '\0';
1662	}
1663	vs10_lval.comment = cmt;
1664	return COMMENT;
1665	}
1666	else
1667	{
1668	// GenDebugLine();
1669	// GenListString();
1670	gLinesAssembled++;
1671	yylineno++;
1672
1673	if ( yytext[0] == '/' && yytext[1] == '*' )
1674	{
1675	cmt = new char[yyleng+2];
1676	strncpy( cmt+3, yytext+2, yyleng-2 );
1677	cmt[0] = '#';
1678	cmt[1] = ' ';
1679	cmt[2] = ' ';
1680	cmt[yyleng+1] = '\0';
1681	}
1682	else
1683	{
1684	cmt = new char[yyleng+2];
1685	strncpy( cmt+1, yytext, yyleng );
1686	cmt[0] = '#';
1687	cmt[yyleng+1] = '\0';
1688	}
1689	vs10_lval.comment = cmt;
1690	return COMMENT;
1691	}
1692	}
1693	YY_BREAK
1694	case YY_STATE_EOF(DEFSTR):
1695	#line 663 "vs1.0_tokens.l"
1696	{
1697	LexError("#define was incomplete before end of file\n");
1698	BEGIN(INITIAL);
1699	}
1700	YY_BREAK
1701	case YY_STATE_EOF(DEFINE):
1702	#line 668 "vs1.0_tokens.l"
1703	{
1704	LexError("#define was incomplete before end of file\n");
1705	BEGIN(INITIAL);
1706	}
1707	YY_BREAK
1708	case YY_STATE_EOF(DEFSPACE):
1709	#line 673 "vs1.0_tokens.l"
1710	{
1711	LexError("#define was incomplete before end of file\n");
1712	BEGIN(INITIAL);
1713	}
1714	YY_BREAK
1715	case YY_STATE_EOF(INCLUDE):
1716	#line 678 "vs1.0_tokens.l"
1717	{
1718	LexError("#include was incomplete before end of file\n");
1719	BEGIN(INITIAL);
1720	}
1721	YY_BREAK
1722	case YY_STATE_EOF(MACROBODY):
1723	#line 683 "vs1.0_tokens.l"
1724	{
1725	LexError("End of file reached before end of #define or endm was found, macro started on line %d.\n", gMacroStartLine);
1726	BEGIN(INITIAL);
1727	}
1728	YY_BREAK
1729	case YY_STATE_EOF(IFDEFBODY):
1730	#line 688 "vs1.0_tokens.l"
1731	{
1732	LexError("End of file reached before #endif found, macro started on line %d.\n", gIfDefStartLine);
1733	BEGIN(INITIAL);
1734	}
1735	YY_BREAK
1736	case 21:
1737	YY_RULE_SETUP
1738	#line 693 "vs1.0_tokens.l"
1739	{
1740	LexError("#define was incomplete before end of line\n");
1741	BEGIN(SAVELINE);
1742	// GenDebugLine();
1743	// GenListString();
1744	gLinesAssembled++;
1745	yylineno++;
1746	}
1747	YY_BREAK
1748	case 22:
1749	YY_RULE_SETUP
1750	#line 702 "vs1.0_tokens.l"
1751	{
1752	LexError("#define was incomplete before end of line\n");
1753	BEGIN(SAVELINE);
1754	// GenDebugLine();
1755	// GenListString();
1756	gLinesAssembled++;
1757	yylineno++;
1758	}
1759	YY_BREAK
1760	case 23:
1761	YY_RULE_SETUP
1762	#line 711 "vs1.0_tokens.l"
1763	{
1764	LexError("#define was incomplete before end of line\n");
1765	BEGIN(SAVELINE);
1766	// GenDebugLine();
1767	// GenListString();
1768	gLinesAssembled++;
1769	yylineno++;
1770	}
1771	YY_BREAK
1772	case 24:
1773	YY_RULE_SETUP
1774	#line 720 "vs1.0_tokens.l"
1775	{
1776	if (gIfDefStackIndex >= MAX_IFDEF_DEPTH)
1777	{
1778	LexError("Out of stack space for #ifdef, aborting.\n");
1779	exit( 1 );
1780	}
1781	else
1782	{
1783	gIfDefStack[gIfDefStackIndex].lastbProcessingIFDEF = gbProcessingIFDEF;
1784	gIfDefStack[gIfDefStackIndex].lastbIFDEF = gbIFDEF;
1785	gIfDefStack[gIfDefStackIndex].lastbCompareDefine = gbCompareDefine;
1786	gIfDefStack[gIfDefStackIndex].lastIfDefStartLine = gIfDefStartLine;
1787	gIfDefStackIndex++;
1788	gIfDefStartLine = yylineno;
1789
1790	gbCompareDefine = true;
1791	BEGIN(IFDEFNAME);
1792	}
1793	}
1794	YY_BREAK
1795	case 25:
1796	YY_RULE_SETUP
1797	#line 740 "vs1.0_tokens.l"
1798	{
1799	if (gIfDefStackIndex >= MAX_IFDEF_DEPTH)
1800	{
1801	LexError("Out of stack space for #ifdef, aborting.\n");
1802	exit( 1 );
1803	}
1804	else
1805	{
1806	gIfDefStack[gIfDefStackIndex].lastbProcessingIFDEF = gbProcessingIFDEF;
1807	gIfDefStack[gIfDefStackIndex].lastbIFDEF = gbIFDEF;
1808	gIfDefStack[gIfDefStackIndex].lastbCompareDefine = gbCompareDefine;
1809	gIfDefStack[gIfDefStackIndex].lastIfDefStartLine = gIfDefStartLine;
1810	gIfDefStackIndex++;
1811	gIfDefStartLine = yylineno;
1812
1813	gbCompareDefine = false;
1814	BEGIN(IFDEFNAME);
1815	}
1816	}
1817	YY_BREAK
1818	case 26:
1819	YY_RULE_SETUP
1820	#line 760 "vs1.0_tokens.l"
1821	{
1822	if (!gbProcessingIFDEF)
1823	{
1824	LexError("Unexpected #else found at line %d, skipping.\n", yylineno);
1825	}
1826	else
1827	{
1828	gbCompareDefine = !gbCompareDefine;
1829	BEGIN(INITIAL);
1830	}
1831	}
1832	YY_BREAK
1833	case 27:
1834	YY_RULE_SETUP
1835	#line 772 "vs1.0_tokens.l"
1836	{
1837	char *defineName;
1838	unsigned int sLen;
1839
1840
1841	defineName = FindAlphaNum(yytext, &sLen);
1842	if (defineName == NULL)
1843	{
1844	defineName = strdup(yytext);
1845	defineName[yyleng-1] = '\0'; // kill \n
1846	LexWarning("Mangled name (%s) for #ifdef, assuming not defined.\n", defineName);
1847	free(defineName);
1848	gbIFDEF = false;
1849	}
1850	else
1851	{
1852	if (FindNMacro(defineName, sLen) != NULL)
1853	{
1854	gbIFDEF = true;
1855	}
1856	else
1857	{
1858	gbIFDEF = false;
1859	}
1860	}
1861
1862	gbProcessingIFDEF = true;
1863	if (gbIFDEF != gbCompareDefine)
1864	{
1865	BEGIN(IFDEFBODY);
1866	}
1867	else
1868	{
1869	BEGIN(SAVELINE);
1870	}
1871
1872	// GenDebugLine();
1873	// GenListString();
1874	gLinesAssembled++;
1875	yylineno++;
1876	}
1877	YY_BREAK
1878	case 28:
1879	YY_RULE_SETUP
1880	#line 814 "vs1.0_tokens.l"
1881	{
1882	if (!gbProcessingIFDEF)
1883	{
1884	LexError("Unexpected #endif found at line %d, skipping.\n", yylineno);
1885	}
1886	else
1887	{
1888	gIfDefStackIndex--;
1889	gbProcessingIFDEF = gIfDefStack[gIfDefStackIndex].lastbProcessingIFDEF;
1890	gbIFDEF = gIfDefStack[gIfDefStackIndex].lastbIFDEF;
1891	gbCompareDefine = gIfDefStack[gIfDefStackIndex].lastbCompareDefine;
1892	gIfDefStartLine = gIfDefStack[gIfDefStackIndex].lastIfDefStartLine;
1893
1894	}
1895
1896	if (YYSTATE == IFDEFBODY)
1897	{
1898	strncpy(gSaveLine, yytext, MAXSAVELINE);
1899	}
1900
1901	BEGIN(ENDMACRO);
1902
1903	}
1904	YY_BREAK
1905	case 29:
1906	YY_RULE_SETUP
1907	#line 838 "vs1.0_tokens.l"
1908	{
1909	LexWarning("Garbage at end of #endif or endm will be ignored.\n");
1910	}
1911	YY_BREAK
1912	case 30:
1913	YY_RULE_SETUP
1914	#line 842 "vs1.0_tokens.l"
1915	{
1916	BEGIN(SAVELINE);
1917	return '\n';
1918	}
1919	YY_BREAK
1920	case YY_STATE_EOF(ENDMACRO):
1921	#line 847 "vs1.0_tokens.l"
1922	{
1923	BEGIN(INITIAL);
1924	}
1925	YY_BREAK
1926	case 31:
1927	YY_RULE_SETUP
1928	#line 851 "vs1.0_tokens.l"
1929	{
1930	// eat line, because we are not in a TRUE #ifdef, or FALSE #ifndef
1931	strncpy(gSaveLine, yytext, MAXSAVELINE);
1932	}
1933	YY_BREAK
1934	case 32:
1935	YY_RULE_SETUP
1936	#line 856 "vs1.0_tokens.l"
1937	{
1938	strcat(gSaveLine, yytext);
1939	// GenDebugLine();
1940	// GenListString();
1941	yylineno++;
1942	gLinesAssembled++;
1943	}
1944	YY_BREAK
1945	case 33:
1946	YY_RULE_SETUP
1947	#line 864 "vs1.0_tokens.l"
1948	{
1949	gbProcessingDefine = true;
1950	gMacroStartLine = yylineno;
1951	gCountParen = 0;
1952	BEGIN(MACRONAME);
1953	}
1954	YY_BREAK
1955	case 34:
1956	YY_RULE_SETUP
1957	#line 871 "vs1.0_tokens.l"
1958	{
1959	BEGIN(SAVELINE);
1960	// GenDebugLine();
1961	// GenListString();
1962	gLinesAssembled++;
1963	yylineno++;
1964	}
1965	YY_BREAK
1966	case 35:
1967	YY_RULE_SETUP
1968	#line 879 "vs1.0_tokens.l"
1969	{
1970	// unsigned int majorVersion;
1971	// unsigned int minorVersion;
1972	// int minorOffset;
1973	//
1974	//
1975	// majorVersion = (unsigned int)(atoi(&yytext[3]));
1976	// // skip "ps." + second '.'
1977	// minorOffset = strcspn(&yytext[3], ".")+4;
1978	// minorVersion = (unsigned int)(atoi(&yytext[minorOffset]));
1979	// yylval.ival = D3DVS_VERSION(majorVersion, minorVersion);
1980	//
1981
1982	// fprintf( stderr, "%s", yytext );
1983	if ( yytext[yyleng-1] == '\n' )
1984	line_incr = 1;
1985	return VERTEX_SHADER;
1986	}
1987	YY_BREAK
1988	case 36:
1989	YY_RULE_SETUP
1990	#line 898 "vs1.0_tokens.l"
1991	{
1992	// fprintf( stderr, "%s", yytext );
1993	vs10_lval.ival = atoi(yytext);
1994	return INTVAL;
1995	}
1996	YY_BREAK
1997	case 37:
1998	YY_RULE_SETUP
1999	#line 905 "vs1.0_tokens.l"
2000	{
2001	BEGIN(MODIFIER);
2002	//fprintf( stderr, "." );
2003	return yytext[0];
2004	}
2005	YY_BREAK
2006	case 38:
2007	YY_RULE_SETUP
2008	#line 911 "vs1.0_tokens.l"
2009	{
2010	// fprintf( stderr, "%s", yytext );
2011	BEGIN(INITIAL);
2012
2013	vs10_lval.mask[0] = tolower(yytext[0]);
2014	vs10_lval.mask[1] = tolower(yytext[1]);
2015	vs10_lval.mask[2] = tolower(yytext[2]);
2016	vs10_lval.mask[3] = tolower(yytext[3]);
2017
2018	if ( yytext[yyleng-1] == '\n' )
2019	line_incr = 1;
2020
2021	return XYZW_MODIFIER;
2022
2023	#if 0
2024	char temp[6];
2025
2026	temp[0] = '\0';
2027	strncat(temp, yytext, 4);
2028	strlwr(temp);
2029	vs10_lval.lval = FindSwizzleValue(temp);
2030
2031	BEGIN(INITIAL);
2032	return SWIZZLE_MODIFIER;
2033	#endif
2034
2035	}
2036	YY_BREAK
2037	case 39:
2038	YY_RULE_SETUP
2039	#line 939 "vs1.0_tokens.l"
2040	{
2041	// fprintf( stderr, "%s", yytext );
2042	BEGIN(INITIAL);
2043
2044	int validLen = strspn(yytext, "xyzw");
2045	int i;
2046	for ( i = 0; i < validLen; i++ )
2047	vs10_lval.mask[i] = tolower( yytext[i] );
2048	while ( i < 4 )
2049	{
2050	vs10_lval.mask[i] = 0;
2051	i++;
2052	}
2053
2054	if ( yytext[yyleng-1] == '\n' )
2055	line_incr = 1;
2056
2057	return XYZW_MODIFIER;
2058
2059	#if 0
2060	//char temp[6];
2061	char *temp = new char[6];
2062	unsigned int registerMask;
2063	unsigned int validLen;
2064
2065	temp[0] = '\0';
2066	validLen = strspn(yytext, "xyzw");
2067	strncat(temp, yytext, validLen);
2068	for ( int i = 0; i < validLen; i++ )
2069	temp[i] = tolower( temp[i] );
2070	registerMask = MakeRegisterMask(temp);
2071
2072	if (registerMask != 0)
2073	{
2074	//vs10_lval.sval = temp;
2075	vs10_lval.lval = registerMask;
2076	BEGIN(INITIAL);
2077	return XYZW_MODIFIER;
2078	}
2079	else
2080	{
2081	//vs10_lval.sval = temp;
2082	vs10_lval.lval = FindSwizzleValue(temp);
2083	BEGIN(INITIAL);
2084	return SWIZZLE_MODIFIER;
2085	}
2086	#endif
2087	}
2088	YY_BREAK
2089	case 40:
2090	YY_RULE_SETUP
2091	#line 988 "vs1.0_tokens.l"
2092	{
2093	BEGIN(INITIAL);
2094	yyless(0);
2095	}
2096	YY_BREAK
2097	case 41:
2098	YY_RULE_SETUP
2099	#line 993 "vs1.0_tokens.l"
2100	{
2101	/* setup and save off #define/macro name */
2102	if (FindMacro(yytext) != NULL)
2103	{
2104	LexWarning("Redefinition of #define/macro %s, ignoring.\n", yytext);
2105	if (gbProcessingDefine)
2106	{
2107	BEGIN(EATDEFINE);
2108	}
2109	else
2110	{
2111	BEGIN(EATMACRO);
2112	}
2113	}
2114	else
2115	{
2116
2117	BEGIN(MACROPARMSTART);
2118	// %%%%% This should be setup to use memory pools
2119	gTempMacro = (MACROENTRY *)malloc(sizeof(MACROENTRY));
2120	if (gTempMacro == NULL)
2121	{
2122	LexError("Out of memory for macro table.\n");
2123	if (gbProcessingDefine)
2124	{
2125	BEGIN(EATDEFINE);
2126	}
2127	else
2128	{
2129	BEGIN(EATMACRO);
2130	}
2131	}
2132	else
2133	{
2134	gTempMacro->prev = gLastMacro;
2135	gTempMacro->next = NULL;
2136
2137	gTempMacro->firstMacroParms = NULL;
2138	gTempMacro->lastMacroParms = NULL;
2139	gTempMacro->firstMacroLines = NULL;
2140	gTempMacro->lastMacroLines = NULL;
2141	gTempMacro->numParms = 0;
2142	gTempMacro->bIsDefine = gbProcessingDefine;
2143	gTempMacro->nLines = 0;
2144
2145	if (gCurFileName != NULL)
2146	{
2147	gTempMacro->fileName = strdup(gCurFileName);
2148	}
2149	else
2150	{
2151	gTempMacro->fileName = NULL;
2152	}
2153
2154	gTempMacro->lineNo = yylineno;
2155
2156	/* %%%%% this should be set up in memory pools. */
2157	gTempMacro->macroName = (char *)malloc(strlen(yytext)+1);
2158	if (gTempMacro->macroName == NULL)
2159	{
2160	LexError("Out of memory for string table.\n");
2161	SAFEFREE(gTempMacro);
2162	if (gbProcessingDefine)
2163	{
2164	BEGIN(EATDEFINE);
2165	}
2166	else
2167	{
2168	BEGIN(EATMACRO);
2169	}
2170	}
2171	else
2172	{
2173	strcpy(gTempMacro->macroName, yytext);
2174	}
2175	}
2176	}
2177	}
2178	YY_BREAK
2179	case 42:
2180	YY_RULE_SETUP
2181	#line 1072 "vs1.0_tokens.l"
2182	{
2183	LexError("No macro name specified, skipping macro definition.\n");
2184	SAFEFREE(gTempMacro->fileName);
2185	SAFEFREE(gTempMacro);
2186	if (gbProcessingDefine)
2187	{
2188	BEGIN(EATDEFINE);
2189	}
2190	else
2191	{
2192	BEGIN(EATMACRO);
2193	}
2194
2195	// GenDebugLine();
2196	// GenListString();
2197	gLinesAssembled++;
2198	yylineno++;
2199	}
2200	YY_BREAK
2201	case 43:
2202	YY_RULE_SETUP
2203	#line 1091 "vs1.0_tokens.l"
2204	{
2205	gCountParen++;
2206	}
2207	YY_BREAK
2208	case 44:
2209	YY_RULE_SETUP
2210	#line 1095 "vs1.0_tokens.l"
2211	{}
2212	YY_BREAK
2213	case 45:
2214	YY_RULE_SETUP
2215	#line 1097 "vs1.0_tokens.l"
2216	{
2217	if (gbProcessingDefine && (gCountParen == 0))
2218	{
2219	EndMacroParms();
2220	}
2221	else
2222	{
2223	BEGIN(MACROPARM);
2224	}
2225	yyless(0);
2226	}
2227	YY_BREAK
2228	case 46:
2229	YY_RULE_SETUP
2230	#line 1109 "vs1.0_tokens.l"
2231	{
2232	if ((gCountParen == 0) && gbProcessingDefine)
2233	{
2234	EndMacroParms();
2235	}
2236	}
2237	YY_BREAK
2238	case 47:
2239	YY_RULE_SETUP
2240	#line 1116 "vs1.0_tokens.l"
2241	{
2242	if (gCountParen == 0)
2243	{
2244	EndMacroParms();
2245	}
2246	}
2247	YY_BREAK
2248	case 48:
2249	YY_RULE_SETUP
2250	#line 1123 "vs1.0_tokens.l"
2251	{}
2252	YY_BREAK
2253	case YY_STATE_EOF(MACROPARM):
2254	#line 1125 "vs1.0_tokens.l"
2255	{
2256	EndMacroParms();
2257	// GenDebugLine();
2258	// GenListString();
2259	yylineno++;
2260	gLinesAssembled++;
2261	BEGIN(INITIAL);
2262	}
2263	YY_BREAK
2264	case 49:
2265	YY_RULE_SETUP
2266	#line 1134 "vs1.0_tokens.l"
2267	{
2268	if (gbProcessingDefine && (gCountParen > 0))
2269	{
2270	LexError("Malformed #define, skipping.\n");
2271	BEGIN(SAVELINE);
2272	}
2273	else
2274	{
2275	EndMacroParms();
2276	// GenDebugLine();
2277	// GenListString();
2278	yylineno++;
2279	gLinesAssembled++;
2280	if (gbProcessingDefine)
2281	{
2282	gbProcessingDefine = false;
2283	BEGIN(SAVELINE);
2284	}
2285	}
2286	}
2287	YY_BREAK
2288	case 50:
2289	YY_RULE_SETUP
2290	#line 1156 "vs1.0_tokens.l"
2291	{
2292
2293	MACROTEXT *tMacro;
2294	char *macroParmEnd;
2295	unsigned int startOffset;
2296	bool bFoundEndParen;
2297	unsigned int leftParenCount;
2298	unsigned int rightParenCount;
2299
2300	bFoundEndParen = false;
2301
2302	// sheesh, we gotta count the parenthesis....
2303	macroParmEnd = yytext;
2304	leftParenCount = 0;
2305	rightParenCount = 0;
2306	while (*macroParmEnd)
2307	{
2308	if (*macroParmEnd == ')')
2309	{
2310	rightParenCount++;
2311	}
2312	if (*macroParmEnd == '(')
2313	{
2314	leftParenCount++;
2315	}
2316
2317	macroParmEnd++;
2318	}
2319
2320	// if we found the last right parenthesis.
2321	if (rightParenCount == leftParenCount+1)
2322	{
2323	// find if we got the last parenthesis on this line
2324	macroParmEnd = strrchr(yytext, ')');
2325	yyless((macroParmEnd - yytext));
2326	BEGIN(MACROPARMEND);
2327	}
2328
2329	startOffset = strspn(yytext, " \t");
2330
2331	tMacro = SaveMacroText(&yytext[startOffset], gTempMacro->lastMacroParms);
2332	if (tMacro == NULL)
2333	{
2334	LexError("Out of memory for string table for macro parameter(s).\n");
2335	FreeMacroEntry(gTempMacro);
2336	BEGIN(EATMACRO);
2337	}
2338	else
2339	{
2340	// if first one wasn't set then set it
2341	if (gTempMacro->firstMacroParms == NULL)
2342	{
2343	gTempMacro->firstMacroParms = tMacro;
2344	}
2345
2346	gTempMacro->lastMacroParms = tMacro;
2347
2348	gTempMacro->numParms++;
2349	}
2350
2351	}
2352	YY_BREAK
2353	case 51:
2354	YY_RULE_SETUP
2355	#line 1218 "vs1.0_tokens.l"
2356	{
2357	if (!gbProcessingDefine && !gbTempInsideMacro)
2358	{
2359	LexError("Malformed macro, skipping.\n");
2360	BEGIN(EATMACRO);
2361	}
2362	else
2363	{
2364	gCountParen--;
2365
2366	// we can get multiple \n's here
2367	while (yytext[yyleng-2] == '\n')
2368	{
2369	yyleng--;
2370	}
2371	yyless(yyleng);
2372
2373	// if there isn't a \n on this line, macro starts on this line,
2374	// not next, like in a macro definition
2375	if (yytext[yyleng-1] != '\n')
2376	{
2377	EndMacroParms();
2378	}
2379	else
2380	{
2381	if (yytext[yyleng-1] == '\n')
2382	{
2383	gTempMacro->lineNo++;
2384	}
2385	// count this line
2386	gTempMacro->nLines++;
2387	// GenDebugLine();
2388	// GenListString();
2389	EndMacroParms();
2390	if (!gbInsideMacro)
2391	{
2392	yylineno++;
2393	}
2394
2395	gLinesAssembled++;
2396	}
2397
2398	}
2399	}
2400	YY_BREAK
2401	case 52:
2402	YY_RULE_SETUP
2403	#line 1263 "vs1.0_tokens.l"
2404	{
2405	if (!gbProcessingDefine && !gbTempInsideMacro)
2406	{
2407	LexError("Malformed macro, skipping.\n");
2408	BEGIN(EATMACRO);
2409	}
2410	else
2411	{
2412
2413	// no matter what count this line
2414	gTempMacro->nLines++;
2415	gCountParen--;
2416	EndMacroParms();
2417	if (!gbInsideMacro)
2418	{
2419	yylineno++;
2420	}
2421
2422	gLinesAssembled++;
2423	}
2424	}
2425	YY_BREAK
2426	case 53:
2427	YY_RULE_SETUP
2428	#line 1285 "vs1.0_tokens.l"
2429	{
2430	if (!gbProcessingDefine && !gbTempInsideMacro)
2431	{
2432	LexError("Malformed macro, skipping.\n");
2433	BEGIN(EATMACRO);
2434	}
2435	else
2436	{
2437	gCountParen--;
2438	if (gCountParen == 0)
2439	{
2440	// no matter what count this line
2441	gTempMacro->nLines++;
2442	EndMacroParms();
2443	if (!gbInsideMacro)
2444	{
2445	yylineno++;
2446	}
2447
2448	gLinesAssembled++;
2449	}
2450	else
2451	{
2452	REJECT;
2453	}
2454	}
2455	}
2456	YY_BREAK
2457	case 54:
2458	YY_RULE_SETUP
2459	#line 1313 "vs1.0_tokens.l"
2460	{
2461	MACROTEXT *tMacro;
2462	unsigned int copyLen;
2463	char *endLine;
2464
2465	gSaveLine[0] ='\0';
2466	endLine = strchr(yytext, '\\');
2467	copyLen = (endLine - yytext);
2468	if (copyLen > MAXSAVELINE)
2469	{
2470	copyLen = MAXSAVELINE;
2471	}
2472
2473	strncat(gSaveLine, yytext, copyLen);
2474	strcat(gSaveLine, "\n");
2475	tMacro = SaveMacroText(gSaveLine, gLastMacro->lastMacroLines);
2476	if (tMacro == NULL)
2477	{
2478	LexError("Out of memory for string table for macro parameter(s).\n");
2479	BEGIN(EATDEFINE);
2480	}
2481	else
2482	{
2483	gLastMacro->nLines++;
2484	// if first one wasn't set then set it
2485	if (gLastMacro->firstMacroLines == NULL)
2486	{
2487	gLastMacro->firstMacroLines = tMacro;
2488	}
2489
2490	gLastMacro->lastMacroLines = tMacro;
2491	}
2492
2493	// GenDebugLine();
2494	// GenListString();
2495	yylineno++;
2496	gLinesAssembled++;
2497	}
2498	YY_BREAK
2499	case 55:
2500	YY_RULE_SETUP
2501	#line 1352 "vs1.0_tokens.l"
2502	{
2503
2504	strncpy(gSaveLine, yytext, MAXSAVELINE);
2505	if (gbProcessingDefine)
2506	{
2507	LexError("Malformed #define, skipping.\n");
2508	}
2509
2510	BEGIN(ENDMACRO);
2511	}
2512	YY_BREAK
2513	case 56:
2514	YY_RULE_SETUP
2515	#line 1363 "vs1.0_tokens.l"
2516	{
2517	MACROTEXT *tMacro;
2518
2519	// check if processing #define and only one line, if not then append \n
2520	if (!gbProcessingDefine \|\| (gLastMacro->nLines >= 1))
2521	{
2522	gSaveLine[0] = '\0';
2523	strncat(gSaveLine, yytext, MAXSAVELINE);
2524	strcat(gSaveLine, "\n");
2525	tMacro = SaveMacroText(gSaveLine, gLastMacro->lastMacroLines);
2526	gLastMacro->nLines++;
2527	}
2528	else if (gLastMacro->numParms > 0) // check if parameters were there
2529	{
2530	// if so, we need the '\n' appended
2531	gMacroLine[0] = '\0';
2532	strncat(gMacroLine, yytext, MAXSAVELINE);
2533	strcat(gMacroLine, "\n");
2534	tMacro = SaveMacroText(gMacroLine, gLastMacro->lastMacroLines);
2535	gLastMacro->nLines++;
2536	}
2537	else // straight no newline macro replace
2538	{
2539	tMacro = SaveMacroText(yytext, gLastMacro->lastMacroLines);
2540	}
2541
2542	if (tMacro == NULL)
2543	{
2544	LexError("Out of memory for string table for macro parameter(s).\n");
2545	BEGIN(EATMACRO);
2546	}
2547	else
2548	{
2549	// if first one wasn't set then set it
2550	if (gLastMacro->firstMacroLines == NULL)
2551	{
2552	gLastMacro->firstMacroLines = tMacro;
2553	}
2554
2555	gLastMacro->lastMacroLines = tMacro;
2556	}
2557	}
2558	YY_BREAK
2559	case 57:
2560	YY_RULE_SETUP
2561	#line 1406 "vs1.0_tokens.l"
2562	{
2563
2564	MACROTEXT *tMacro;
2565	// GenDebugLine();
2566	// GenListString();
2567	yylineno++;
2568	gLinesAssembled++;
2569	if (gbProcessingDefine)
2570	{
2571	gbProcessingDefine = false;
2572	BEGIN(SAVELINE);
2573	}
2574	else
2575	{
2576	// this means \n by itself inside macro body
2577	if (((yylineno-1) - gLastMacro->lineNo) != gLastMacro->nLines)
2578	{
2579	strcpy(gMacroLine, "\n");
2580	tMacro = SaveMacroText(gMacroLine, gLastMacro->lastMacroLines);
2581	gLastMacro->nLines++;
2582
2583	if (tMacro == NULL)
2584	{
2585	LexError("Out of memory for string table for macro parameter(s).\n");
2586	BEGIN(EATMACRO);
2587	}
2588	else
2589	{
2590	// if first one wasn't set then set it
2591	if (gLastMacro->firstMacroLines == NULL)
2592	{
2593	gLastMacro->firstMacroLines = tMacro;
2594	}
2595
2596	gLastMacro->lastMacroLines = tMacro;
2597	}
2598	}
2599	}
2600	}
2601	YY_BREAK
2602	case 58:
2603	YY_RULE_SETUP
2604	#line 1446 "vs1.0_tokens.l"
2605	{
2606	BEGIN(SAVELINE);
2607	// GenDebugLine();
2608	// GenListString();
2609	gLinesAssembled++;
2610	yylineno++;
2611	}
2612	YY_BREAK
2613	case 59:
2614	YY_RULE_SETUP
2615	#line 1454 "vs1.0_tokens.l"
2616	{
2617	strncpy(gSaveLine, yytext, MAXSAVELINE);
2618	// GenDebugLine();
2619	// GenListString();
2620	gLinesAssembled++;
2621	yylineno++;
2622	}
2623	YY_BREAK
2624	case 60:
2625	YY_RULE_SETUP
2626	#line 1462 "vs1.0_tokens.l"
2627	{
2628	strncpy(gSaveLine, yytext, MAXSAVELINE);
2629	// GenDebugLine();
2630	// GenListString();
2631	gLinesAssembled++;
2632	yylineno++;
2633	}
2634	YY_BREAK
2635	case 61:
2636	YY_RULE_SETUP
2637	#line 1470 "vs1.0_tokens.l"
2638	{
2639	strncpy(gSaveLine, yytext, MAXSAVELINE);
2640	// GenDebugLine();
2641	// GenListString();
2642	gLinesAssembled++;
2643	yylineno++;
2644	BEGIN(SAVELINE);
2645	}
2646	YY_BREAK
2647	case 62:
2648	YY_RULE_SETUP
2649	#line 1479 "vs1.0_tokens.l"
2650	{
2651
2652	gTempParseMacro = FindMacro(yytext);
2653
2654	if (gTempParseMacro != NULL)
2655	{
2656	if (gIncludeStackIndex >= MAX_INCLUDE_DEPTH )
2657	{
2658	LexError("macros nested too deeply");
2659	exit( 1 );
2660	}
2661
2662	if (gTempParseMacro->firstMacroLines != NULL)
2663	{
2664
2665	gTempMacro = (MACROENTRY *)malloc(sizeof(MACROENTRY));
2666	if (gTempMacro == NULL)
2667	{
2668	LexError("Out of memory allocating MACROENTRY structure.\n");
2669	}
2670	else
2671	{
2672
2673	gTempMacro->next = NULL;
2674	gTempMacro->prev = NULL;
2675	gTempMacro->macroName = NULL;
2676	gTempMacro->firstMacroParms = NULL;
2677	gTempMacro->lastMacroParms = NULL;
2678	gTempMacro->firstMacroLines = NULL;
2679	gTempMacro->lastMacroLines = NULL;
2680	gTempMacro->numParms = 0;
2681	gTempMacro->nLines = 0;
2682
2683	gbTempInsideMacro = true; // flag we are currently doing a macro replace.
2684	gInvokeState = YYSTATE;
2685	if (gTempParseMacro->numParms > 0)
2686	{
2687	BEGIN(MACROPARMSTART);
2688	}
2689	else
2690	{
2691	EndMacroParms();
2692	gbTempInsideMacro = false; // no longer waiting for macro invocation
2693	}
2694	}
2695	}
2696	}
2697	else
2698	{
2699	BEGIN(INITIAL);
2700	REJECT;
2701	}
2702	}
2703	YY_BREAK
2704	case 63:
2705	YY_RULE_SETUP
2706	#line 1533 "vs1.0_tokens.l"
2707	{
2708	// fprintf( stderr, "%c ", yytext[0] );
2709	return yytext[0];
2710	}
2711	YY_BREAK
2712	case 64:
2713	YY_RULE_SETUP
2714	#line 1539 "vs1.0_tokens.l"
2715	{}
2716	YY_BREAK
2717	case 65:
2718	YY_RULE_SETUP
2719	#line 1541 "vs1.0_tokens.l"
2720	{
2721	LexError("Didn't find label string for #define.\n");
2722	BEGIN(SAVELINE);
2723	// return '\n';
2724	}
2725	YY_BREAK
2726	case 66:
2727	YY_RULE_SETUP
2728	#line 1547 "vs1.0_tokens.l"
2729	{
2730	//fprintf(stderr, "\n");
2731	// line_incr = 1;
2732	line_incr++;
2733	BEGIN(SAVELINE);
2734	return '\n';
2735	}
2736	YY_BREAK
2737	case 67:
2738	YY_RULE_SETUP
2739	#line 1555 "vs1.0_tokens.l"
2740	{
2741	BEGIN(INITIAL);
2742	// fprintf( stderr, "%s", yytext );
2743	if (yyleng == 1)
2744	return yytext[0];
2745	else
2746	LexError("Unrecognized Token: %s\n", yytext);
2747	return UNKNOWN_STRING;
2748	}
2749	YY_BREAK
2750	case 68:
2751	YY_RULE_SETUP
2752	#line 1565 "vs1.0_tokens.l"
2753	{
2754	// vs10_lval.ival = yytext[0];
2755	LexError("Illegal character: %d decimal.\n", yytext[0]);
2756	return(ILLEGAL);
2757	}
2758	YY_BREAK
2759	case 69:
2760	YY_RULE_SETUP
2761	#line 1571 "vs1.0_tokens.l"
2762	{
2763	// vs10_lval.ival = yytext[0];
2764	LexError("Illegal character: %d decimal.\n", yytext[0]);
2765	return(ILLEGAL);
2766	}
2767	YY_BREAK
2768	case 70:
2769	YY_RULE_SETUP
2770	#line 1577 "vs1.0_tokens.l"
2771	{
2772	return yytext[0];
2773	}
2774	YY_BREAK
2775	case 71:
2776	YY_RULE_SETUP
2777	#line 1581 "vs1.0_tokens.l"
2778	{
2779	BEGIN(EATSTRING);
2780	yyless(0);
2781	}
2782	YY_BREAK
2783	case YY_STATE_EOF(INITIAL):
2784	case YY_STATE_EOF(SKIPLINE):
2785	case YY_STATE_EOF(EATSTRING):
2786	case YY_STATE_EOF(SAVELINE):
2787	case YY_STATE_EOF(MACRONAME):
2788	case YY_STATE_EOF(EATMACRO):
2789	case YY_STATE_EOF(EATDEFINE):
2790	case YY_STATE_EOF(MODIFIER):
2791	case YY_STATE_EOF(MACROPARMSTART):
2792	case YY_STATE_EOF(IFDEFNAME):
2793	case YY_STATE_EOF(MACROPARMEND):
2794	#line 1586 "vs1.0_tokens.l"
2795	{
2796	bool wasInMacro;
2797	bool oneLiner;
2798	char *macroText;
2799
2800	wasInMacro = gbInsideMacro;
2801	oneLiner = false;
2802
2803
2804	// if we are inside the macro then do next line until their are no more
2805	if (gbInsideMacro)
2806	{
2807	oneLiner = (gParseMacro->nLines == 0);
2808
2809	// free the temporary parameter replaced line we were working on.
2810	// get next line in macro text, if any
2811	gMacroLineParse = gMacroLineParse->next;
2812	// more lines to parse?
2813	if (gMacroLineParse != NULL)
2814	{
2815	macroText = gMacroLine;
2816	// if no replacement text, just use source line
2817	if (gParseMacro->firstMacroParms == NULL)
2818	{
2819	macroText = gMacroLineParse->macroText;
2820	}
2821	else
2822	{
2823	// replace the macro parameters
2824	ReplaceMacroParms(gMacroLineParse->macroText, gMacroLine, gParseMacro, gInvokeMacro);
2825	}
2826
2827	// if (gExpandMacros)
2828	// {
2829	// strcpy(gSaveLine, macroText);
2830	// }
2831
2832	BEGIN(INITIAL);
2833	// and lex it.
2834	yy_scan_string(macroText);
2835	}
2836	else
2837	{
2838	// no more lines in this macro, so free the working macro
2839	SAFEFREE(gInvokeMacro);
2840	// shut off flag for inside a macro replacement state.
2841	gbInsideMacro = false;
2842	}
2843	}
2844
2845	if (gbProcessingIFDEF && !wasInMacro)
2846	{
2847	LexError("End of file reached before #endif found, macro started on line %d.\n", gIfDefStartLine);
2848	}
2849
2850	if (!gbInsideMacro)
2851	{
2852	if ( gIncludeStackIndex == 0 )
2853	{
2854	if (!gbProcessingBuiltIn)
2855	CleanUp();
2856	return 0;
2857	// return TOKEN_EOF;
2858	}
2859	else
2860	{
2861	yy_delete_buffer( YY_CURRENT_BUFFER );
2862	SAFEFREE(gCurFileName);
2863	// SAFEDELETE(myin);
2864	// SAFECLOSE(yyin);
2865	}
2866
2867	gIncludeStackIndex--;
2868	SAFEDELETEARRAY( gIncludeStack[gIncludeStackIndex].nextString );
2869	yy_switch_to_buffer(gIncludeStack[gIncludeStackIndex].buffer );
2870	gCurFileName = gIncludeStack[gIncludeStackIndex].fileName;
2871	// yyin = gIncludeStack[gIncludeStackIndex].fileHandle;
2872	myin = gIncludeStack[gIncludeStackIndex].prevString;
2873	yylineno = gIncludeStack[gIncludeStackIndex].lineNo;
2874	gInvokeMacro = gIncludeStack[gIncludeStackIndex].lastInvokeMacro;
2875	gParseMacro = gIncludeStack[gIncludeStackIndex].lastParseMacro;
2876	gMacroLineParse = gIncludeStack[gIncludeStackIndex].lastMacroLineParse;
2877	gbInsideInclude = gIncludeStack[gIncludeStackIndex].lastbInsideInclude;
2878	gbInsideMacro = gIncludeStack[gIncludeStackIndex].lastbInsideMacro;
2879	gbProcessingIFDEF = gIncludeStack[gIncludeStackIndex].lastbProcessingIFDEF;
2880
2881	if (!gbInsideMacro && !oneLiner)
2882	{
2883	// GenSwitchFileNames(gCurFileName);
2884	BEGIN(SAVELINE);
2885	}
2886	else
2887	{
2888	BEGIN(INITIAL);
2889	}
2890
2891	// gSaveLine was last line saved, before macro invocation
2892	if (wasInMacro && !gbInsideMacro && !oneLiner)
2893	{
2894	// GenDebugLine();
2895	// GenListString();
2896	gLinesAssembled++;
2897	yylineno++;
2898	}
2899
2900	}
2901
2902	}
2903	YY_BREAK
2904	case 72:
2905	YY_RULE_SETUP
2906	#line 1695 "vs1.0_tokens.l"
2907	ECHO;
2908	YY_BREAK
2909	#line 2908 "_vs1.0_lexer.cpp"
2910
2911	case YY_END_OF_BUFFER:
2912	{
2913	/* Amount of text matched not including the EOB char. */
2914	int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2915
2916	/* Undo the effects of YY_DO_BEFORE_ACTION. */
2917	*yy_cp = yy_hold_char;
2918	YY_RESTORE_YY_MORE_OFFSET
2919
2920	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2921	{
2922	/* We're scanning a new file or input source. It's
2923	* possible that this happened because the user
2924	* just pointed yyin at a new source and called
2925	* yylex(). If so, then we have to assure
2926	* consistency between yy_current_buffer and our
2927	* globals. Here is the right place to do so, because
2928	* this is the first action (other than possibly a
2929	* back-up) that will match for the new input source.
2930	*/
2931	yy_n_chars = yy_current_buffer->yy_n_chars;
2932	yy_current_buffer->yy_input_file = yyin;
2933	yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2934	}
2935
2936	/* Note that here we test for yy_c_buf_p "<=" to the position
2937	* of the first EOB in the buffer, since yy_c_buf_p will
2938	* already have been incremented past the NUL character
2939	* (since all states make transitions on EOB to the
2940	* end-of-buffer state). Contrast this with the test
2941	* in input().
2942	*/
2943	if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2944	{ /* This was really a NUL. */
2945	yy_state_type yy_next_state;
2946
2947	yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2948
2949	yy_current_state = yy_get_previous_state();
2950
2951	/* Okay, we're now positioned to make the NUL
2952	* transition. We couldn't have
2953	* yy_get_previous_state() go ahead and do it
2954	* for us because it doesn't know how to deal
2955	* with the possibility of jamming (and we don't
2956	* want to build jamming into it because then it
2957	* will run more slowly).
2958	*/
2959
2960	yy_next_state = yy_try_NUL_trans( yy_current_state );
2961
2962	yy_bp = yytext_ptr + YY_MORE_ADJ;
2963
2964	if ( yy_next_state )
2965	{
2966	/* Consume the NUL. */
2967	yy_cp = ++yy_c_buf_p;
2968	yy_current_state = yy_next_state;
2969	goto yy_match;
2970	}
2971
2972	else
2973	{
2974	yy_cp = yy_c_buf_p;
2975	goto yy_find_action;
2976	}
2977	}
2978
2979	else switch ( yy_get_next_buffer() )
2980	{
2981	case EOB_ACT_END_OF_FILE:
2982	{
2983	yy_did_buffer_switch_on_eof = 0;
2984
2985	if ( yywrap() )
2986	{
2987	/* Note: because we've taken care in
2988	* yy_get_next_buffer() to have set up
2989	* yytext, we can now set up
2990	* yy_c_buf_p so that if some total
2991	* hoser (like flex itself) wants to
2992	* call the scanner after we return the
2993	* YY_NULL, it'll still work - another
2994	* YY_NULL will get returned.
2995	*/
2996	yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2997
2998	yy_act = YY_STATE_EOF(YY_START);
2999	goto do_action;
3000	}
3001
3002	else
3003	{
3004	if ( ! yy_did_buffer_switch_on_eof )
3005	YY_NEW_FILE;
3006	}
3007	break;
3008	}
3009
3010	case EOB_ACT_CONTINUE_SCAN:
3011	yy_c_buf_p =
3012	yytext_ptr + yy_amount_of_matched_text;
3013
3014	yy_current_state = yy_get_previous_state();
3015
3016	yy_cp = yy_c_buf_p;
3017	yy_bp = yytext_ptr + YY_MORE_ADJ;
3018	goto yy_match;
3019
3020	case EOB_ACT_LAST_MATCH:
3021	yy_c_buf_p =
3022	&yy_current_buffer->yy_ch_buf[yy_n_chars];
3023
3024	yy_current_state = yy_get_previous_state();
3025
3026	yy_cp = yy_c_buf_p;
3027	yy_bp = yytext_ptr + YY_MORE_ADJ;
3028	goto yy_find_action;
3029	}
3030	break;
3031	}
3032
3033	default:
3034	YY_FATAL_ERROR(
3035	"fatal flex scanner internal error--no action found" );
3036	} /* end of action switch */
3037	} /* end of scanning one token */
3038	} /* end of yylex */
3039
3040
3041	/* yy_get_next_buffer - try to read in a new buffer
3042	*
3043	* Returns a code representing an action:
3044	* EOB_ACT_LAST_MATCH -
3045	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3046	* EOB_ACT_END_OF_FILE - end of file
3047	*/
3048
3049	static int yy_get_next_buffer()
3050	{
3051	register char *dest = yy_current_buffer->yy_ch_buf;
3052	register char *source = yytext_ptr;
3053	register int number_to_move, i;
3054	int ret_val;
3055
3056	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
3057	YY_FATAL_ERROR(
3058	"fatal flex scanner internal error--end of buffer missed" );
3059
3060	if ( yy_current_buffer->yy_fill_buffer == 0 )
3061	{ /* Don't try to fill the buffer, so this is an EOF. */
3062	if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
3063	{
3064	/* We matched a single character, the EOB, so
3065	* treat this as a final EOF.
3066	*/
3067	return EOB_ACT_END_OF_FILE;
3068	}
3069
3070	else
3071	{
3072	/* We matched some text prior to the EOB, first
3073	* process it.
3074	*/
3075	return EOB_ACT_LAST_MATCH;
3076	}
3077	}
3078
3079	/* Try to read more data. */
3080
3081	/* First move last chars to start of buffer. */
3082	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
3083
3084	for ( i = 0; i < number_to_move; ++i )
3085	(dest++) = (source++);
3086
3087	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3088	/* don't do the read, it's not guaranteed to return an EOF,
3089	* just force an EOF
3090	*/
3091	yy_current_buffer->yy_n_chars = yy_n_chars = 0;
3092
3093	else
3094	{
3095	int num_to_read =
3096	yy_current_buffer->yy_buf_size - number_to_move - 1;
3097
3098	while ( num_to_read <= 0 )
3099	{ /* Not enough room in the buffer - grow it. */
3100	#ifdef YY_USES_REJECT
3101	YY_FATAL_ERROR(
3102	"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
3103	#else
3104
3105	/* just a shorter name for the current buffer */
3106	YY_BUFFER_STATE b = yy_current_buffer;
3107
3108	int yy_c_buf_p_offset =
3109	(int) (yy_c_buf_p - b->yy_ch_buf);
3110
3111	if ( b->yy_is_our_buffer )
3112	{
3113	int new_size = b->yy_buf_size * 2;
3114
3115	if ( new_size <= 0 )
3116	b->yy_buf_size += b->yy_buf_size / 8;
3117	else
3118	b->yy_buf_size *= 2;
3119
3120	b->yy_ch_buf = (char *)
3121	/* Include room in for 2 EOB chars. */
3122	yy_flex_realloc( (void *) b->yy_ch_buf,
3123	b->yy_buf_size + 2 );
3124	}
3125	else
3126	/* Can't grow it, we don't own it. */
3127	b->yy_ch_buf = 0;
3128
3129	if ( ! b->yy_ch_buf )
3130	YY_FATAL_ERROR(
3131	"fatal error - scanner input buffer overflow" );
3132
3133	yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
3134
3135	num_to_read = yy_current_buffer->yy_buf_size -
3136	number_to_move - 1;
3137	#endif
3138	}
3139
3140	if ( num_to_read > YY_READ_BUF_SIZE )
3141	num_to_read = YY_READ_BUF_SIZE;
3142
3143	/* Read in more data. */
3144	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
3145	yy_n_chars, num_to_read );
3146
3147	yy_current_buffer->yy_n_chars = yy_n_chars;
3148	}
3149
3150	if ( yy_n_chars == 0 )
3151	{
3152	if ( number_to_move == YY_MORE_ADJ )
3153	{
3154	ret_val = EOB_ACT_END_OF_FILE;
3155	yyrestart( yyin );
3156	}
3157
3158	else
3159	{
3160	ret_val = EOB_ACT_LAST_MATCH;
3161	yy_current_buffer->yy_buffer_status =
3162	YY_BUFFER_EOF_PENDING;
3163	}
3164	}
3165
3166	else
3167	ret_val = EOB_ACT_CONTINUE_SCAN;
3168
3169	yy_n_chars += number_to_move;
3170	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
3171	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
3172
3173	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
3174
3175	return ret_val;
3176	}
3177
3178
3179	/* yy_get_previous_state - get the state just before the EOB char was reached */
3180
3181	static yy_state_type yy_get_previous_state()
3182	{
3183	register yy_state_type yy_current_state;
3184	register char *yy_cp;
3185
3186	yy_current_state = yy_start;
3187	yy_current_state += YY_AT_BOL();
3188	yy_state_ptr = yy_state_buf;
3189	*yy_state_ptr++ = yy_current_state;
3190
3191	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
3192	{
3193	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 4);
3194	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3195	{
3196	yy_current_state = (int) yy_def[yy_current_state];
3197	if ( yy_current_state >= 329 )
3198	yy_c = yy_meta[(unsigned int) yy_c];
3199	}
3200	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3201	*yy_state_ptr++ = yy_current_state;
3202	}
3203
3204	return yy_current_state;
3205	}
3206
3207
3208	/* yy_try_NUL_trans - try to make a transition on the NUL character
3209	*
3210	* synopsis
3211	* next_state = yy_try_NUL_trans( current_state );
3212	*/
3213
3214	#ifdef YY_USE_PROTOS
3215	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
3216	#else
3217	static yy_state_type yy_try_NUL_trans( yy_current_state )
3218	yy_state_type yy_current_state;
3219	#endif
3220	{
3221	register int yy_is_jam;
3222
3223	register YY_CHAR yy_c = 4;
3224	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3225	{
3226	yy_current_state = (int) yy_def[yy_current_state];
3227	if ( yy_current_state >= 329 )
3228	yy_c = yy_meta[(unsigned int) yy_c];
3229	}
3230	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3231	yy_is_jam = (yy_current_state == 328);
3232	if ( ! yy_is_jam )
3233	*yy_state_ptr++ = yy_current_state;
3234
3235	return yy_is_jam ? 0 : yy_current_state;
3236	}
3237
3238
3239	#ifndef YY_NO_UNPUT
3240	#ifdef YY_USE_PROTOS
3241	static void yyunput( int c, register char *yy_bp )
3242	#else
3243	static void yyunput( c, yy_bp )
3244	int c;
3245	register char *yy_bp;
3246	#endif
3247	{
3248	register char *yy_cp = yy_c_buf_p;
3249
3250	/* undo effects of setting up yytext */
3251	*yy_cp = yy_hold_char;
3252
3253	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
3254	{ /* need to shift things up to make room */
3255	/* +2 for EOB chars. */
3256	register int number_to_move = yy_n_chars + 2;
3257	register char *dest = &yy_current_buffer->yy_ch_buf[
3258	yy_current_buffer->yy_buf_size + 2];
3259	register char *source =
3260	&yy_current_buffer->yy_ch_buf[number_to_move];
3261
3262	while ( source > yy_current_buffer->yy_ch_buf )
3263	--dest = --source;
3264
3265	yy_cp += (int) (dest - source);
3266	yy_bp += (int) (dest - source);
3267	yy_current_buffer->yy_n_chars =
3268	yy_n_chars = yy_current_buffer->yy_buf_size;
3269
3270	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
3271	YY_FATAL_ERROR( "flex scanner push-back overflow" );
3272	}
3273
3274	*--yy_cp = (char) c;
3275
3276
3277	yytext_ptr = yy_bp;
3278	yy_hold_char = *yy_cp;
3279	yy_c_buf_p = yy_cp;
3280	}
3281	#endif /* ifndef YY_NO_UNPUT */
3282
3283
3284	#ifdef __cplusplus
3285	static int yyinput()
3286	#else
3287	static int input()
3288	#endif
3289	{
3290	int c;
3291
3292	*yy_c_buf_p = yy_hold_char;
3293
3294	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
3295	{
3296	/* yy_c_buf_p now points to the character we want to return.
3297	* If this occurs before the EOB characters, then it's a
3298	* valid NUL; if not, then we've hit the end of the buffer.
3299	*/
3300	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
3301	/* This was really a NUL. */
3302	*yy_c_buf_p = '\0';
3303
3304	else
3305	{ /* need more input */
3306	int offset = yy_c_buf_p - yytext_ptr;
3307	++yy_c_buf_p;
3308
3309	switch ( yy_get_next_buffer() )
3310	{
3311	case EOB_ACT_LAST_MATCH:
3312	/* This happens because yy_g_n_b()
3313	* sees that we've accumulated a
3314	* token and flags that we need to
3315	* try matching the token before
3316	* proceeding. But for input(),
3317	* there's no matching to consider.
3318	* So convert the EOB_ACT_LAST_MATCH
3319	* to EOB_ACT_END_OF_FILE.
3320	*/
3321
3322	/* Reset buffer status. */
3323	yyrestart( yyin );
3324
3325	/* fall through */
3326
3327	case EOB_ACT_END_OF_FILE:
3328	{
3329	if ( yywrap() )
3330	return EOF;
3331
3332	if ( ! yy_did_buffer_switch_on_eof )
3333	YY_NEW_FILE;
3334	#ifdef __cplusplus
3335	return yyinput();
3336	#else
3337	return input();
3338	#endif
3339	}
3340
3341	case EOB_ACT_CONTINUE_SCAN:
3342	yy_c_buf_p = yytext_ptr + offset;
3343	break;
3344	}
3345	}
3346	}
3347
3348	c = (unsigned char ) yy_c_buf_p; /* cast for 8-bit char's */
3349	yy_c_buf_p = '\0'; / preserve yytext */
3350	yy_hold_char = *++yy_c_buf_p;
3351
3352	yy_current_buffer->yy_at_bol = (c == '\n');
3353
3354	return c;
3355	}
3356
3357
3358	#ifdef YY_USE_PROTOS
3359	void yyrestart( FILE *input_file )
3360	#else
3361	void yyrestart( input_file )
3362	FILE *input_file;
3363	#endif
3364	{
3365	if ( ! yy_current_buffer )
3366	yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
3367
3368	yy_init_buffer( yy_current_buffer, input_file );
3369	yy_load_buffer_state();
3370	}
3371
3372
3373	#ifdef YY_USE_PROTOS
3374	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
3375	#else
3376	void yy_switch_to_buffer( new_buffer )
3377	YY_BUFFER_STATE new_buffer;
3378	#endif
3379	{
3380	if ( yy_current_buffer == new_buffer )
3381	return;
3382
3383	if ( yy_current_buffer )
3384	{
3385	/* Flush out information for old buffer. */
3386	*yy_c_buf_p = yy_hold_char;
3387	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
3388	yy_current_buffer->yy_n_chars = yy_n_chars;
3389	}
3390
3391	yy_current_buffer = new_buffer;
3392	yy_load_buffer_state();
3393
3394	/* We don't actually know whether we did this switch during
3395	* EOF (yywrap()) processing, but the only time this flag
3396	* is looked at is after yywrap() is called, so it's safe
3397	* to go ahead and always set it.
3398	*/
3399	yy_did_buffer_switch_on_eof = 1;
3400	}
3401
3402
3403	#ifdef YY_USE_PROTOS
3404	void yy_load_buffer_state( void )
3405	#else
3406	void yy_load_buffer_state()
3407	#endif
3408	{
3409	yy_n_chars = yy_current_buffer->yy_n_chars;
3410	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
3411	yyin = yy_current_buffer->yy_input_file;
3412	yy_hold_char = *yy_c_buf_p;
3413	}
3414
3415
3416	#ifdef YY_USE_PROTOS
3417	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
3418	#else
3419	YY_BUFFER_STATE yy_create_buffer( file, size )
3420	FILE *file;
3421	int size;
3422	#endif
3423	{
3424	YY_BUFFER_STATE b;
3425
3426	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
3427	if ( ! b )
3428	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3429
3430	b->yy_buf_size = size;
3431
3432	/* yy_ch_buf has to be 2 characters longer than the size given because
3433	* we need to put in 2 end-of-buffer characters.
3434	*/
3435	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
3436	if ( ! b->yy_ch_buf )
3437	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3438
3439	b->yy_is_our_buffer = 1;
3440
3441	yy_init_buffer( b, file );
3442
3443	return b;
3444	}
3445
3446
3447	#ifdef YY_USE_PROTOS
3448	void yy_delete_buffer( YY_BUFFER_STATE b )
3449	#else
3450	void yy_delete_buffer( b )
3451	YY_BUFFER_STATE b;
3452	#endif
3453	{
3454	if ( ! b )
3455	return;
3456
3457	if ( b == yy_current_buffer )
3458	yy_current_buffer = (YY_BUFFER_STATE) 0;
3459
3460	if ( b->yy_is_our_buffer )
3461	yy_flex_free( (void *) b->yy_ch_buf );
3462
3463	yy_flex_free( (void *) b );
3464	}
3465
3466
3467
3468	#ifdef YY_USE_PROTOS
3469	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
3470	#else
3471	void yy_init_buffer( b, file )
3472	YY_BUFFER_STATE b;
3473	FILE *file;
3474	#endif
3475
3476
3477	{
3478	yy_flush_buffer( b );
3479
3480	b->yy_input_file = file;
3481	b->yy_fill_buffer = 1;
3482
3483	#if YY_ALWAYS_INTERACTIVE
3484	b->yy_is_interactive = 1;
3485	#else
3486	#if YY_NEVER_INTERACTIVE
3487	b->yy_is_interactive = 0;
3488	#else
3489	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3490	#endif
3491	#endif
3492	}
3493
3494
3495	#ifdef YY_USE_PROTOS
3496	void yy_flush_buffer( YY_BUFFER_STATE b )
3497	#else
3498	void yy_flush_buffer( b )
3499	YY_BUFFER_STATE b;
3500	#endif
3501
3502	{
3503	if ( ! b )
3504	return;
3505
3506	b->yy_n_chars = 0;
3507
3508	/* We always need two end-of-buffer characters. The first causes
3509	* a transition to the end-of-buffer state. The second causes
3510	* a jam in that state.
3511	*/
3512	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3513	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3514
3515	b->yy_buf_pos = &b->yy_ch_buf[0];
3516
3517	b->yy_at_bol = 1;
3518	b->yy_buffer_status = YY_BUFFER_NEW;
3519
3520	if ( b == yy_current_buffer )
3521	yy_load_buffer_state();
3522	}
3523
3524
3525	#ifndef YY_NO_SCAN_BUFFER
3526	#ifdef YY_USE_PROTOS
3527	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
3528	#else
3529	YY_BUFFER_STATE yy_scan_buffer( base, size )
3530	char *base;
3531	yy_size_t size;
3532	#endif
3533	{
3534	YY_BUFFER_STATE b;
3535
3536	if ( size < 2 \|\|
3537	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
3538	base[size-1] != YY_END_OF_BUFFER_CHAR )
3539	/* They forgot to leave room for the EOB's. */
3540	return 0;
3541
3542	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
3543	if ( ! b )
3544	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3545
3546	b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3547	b->yy_buf_pos = b->yy_ch_buf = base;
3548	b->yy_is_our_buffer = 0;
3549	b->yy_input_file = 0;
3550	b->yy_n_chars = b->yy_buf_size;
3551	b->yy_is_interactive = 0;
3552	b->yy_at_bol = 1;
3553	b->yy_fill_buffer = 0;
3554	b->yy_buffer_status = YY_BUFFER_NEW;
3555
3556	yy_switch_to_buffer( b );
3557
3558	return b;
3559	}
3560	#endif
3561
3562
3563	#ifndef YY_NO_SCAN_STRING
3564	#ifdef YY_USE_PROTOS
3565	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
3566	#else
3567	YY_BUFFER_STATE yy_scan_string( yy_str )
3568	yyconst char *yy_str;
3569	#endif
3570	{
3571	int len;
3572	for ( len = 0; yy_str[len]; ++len )
3573	;
3574
3575	return yy_scan_bytes( yy_str, len );
3576	}
3577	#endif
3578
3579
3580	#ifndef YY_NO_SCAN_BYTES
3581	#ifdef YY_USE_PROTOS
3582	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
3583	#else
3584	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
3585	yyconst char *bytes;
3586	int len;
3587	#endif
3588	{
3589	YY_BUFFER_STATE b;
3590	char *buf;
3591	yy_size_t n;
3592	int i;
3593
3594	/* Get memory for full buffer, including space for trailing EOB's. */
3595	n = len + 2;
3596	buf = (char *) yy_flex_alloc( n );
3597	if ( ! buf )
3598	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3599
3600	for ( i = 0; i < len; ++i )
3601	buf[i] = bytes[i];
3602
3603	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
3604
3605	b = yy_scan_buffer( buf, n );
3606	if ( ! b )
3607	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3608
3609	/* It's okay to grow etc. this buffer, and we should throw it
3610	* away when we're done.
3611	*/
3612	b->yy_is_our_buffer = 1;
3613
3614	return b;
3615	}
3616	#endif
3617
3618
3619	#ifndef YY_NO_PUSH_STATE
3620	#ifdef YY_USE_PROTOS
3621	static void yy_push_state( int new_state )
3622	#else
3623	static void yy_push_state( new_state )
3624	int new_state;
3625	#endif
3626	{
3627	if ( yy_start_stack_ptr >= yy_start_stack_depth )
3628	{
3629	yy_size_t new_size;
3630
3631	yy_start_stack_depth += YY_START_STACK_INCR;
3632	new_size = yy_start_stack_depth * sizeof( int );
3633
3634	if ( ! yy_start_stack )
3635	yy_start_stack = (int *) yy_flex_alloc( new_size );
3636
3637	else
3638	yy_start_stack = (int *) yy_flex_realloc(
3639	(void *) yy_start_stack, new_size );
3640
3641	if ( ! yy_start_stack )
3642	YY_FATAL_ERROR(
3643	"out of memory expanding start-condition stack" );
3644	}
3645
3646	yy_start_stack[yy_start_stack_ptr++] = YY_START;
3647
3648	BEGIN(new_state);
3649	}
3650	#endif
3651
3652
3653	#ifndef YY_NO_POP_STATE
3654	static void yy_pop_state()
3655	{
3656	if ( --yy_start_stack_ptr < 0 )
3657	YY_FATAL_ERROR( "start-condition stack underflow" );
3658
3659	BEGIN(yy_start_stack[yy_start_stack_ptr]);
3660	}
3661	#endif
3662
3663
3664	#ifndef YY_NO_TOP_STATE
3665	static int yy_top_state()
3666	{
3667	return yy_start_stack[yy_start_stack_ptr - 1];
3668	}
3669	#endif
3670
3671	#ifndef YY_EXIT_FAILURE
3672	#define YY_EXIT_FAILURE 2
3673	#endif
3674
3675	#ifdef YY_USE_PROTOS
3676	static void yy_fatal_error( yyconst char msg[] )
3677	#else
3678	static void yy_fatal_error( msg )
3679	char msg[];
3680	#endif
3681	{
3682	(void) fprintf( stderr, "%s\n", msg );
3683	exit( YY_EXIT_FAILURE );
3684	}
3685
3686
3687
3688	/* Redefine yyless() so it works in section 3 code. */
3689
3690	#undef yyless
3691	#define yyless(n) \
3692	do \
3693	{ \
3694	/* Undo effects of setting up yytext. */ \
3695	yytext[yyleng] = yy_hold_char; \
3696	yy_c_buf_p = yytext + n; \
3697	yy_hold_char = *yy_c_buf_p; \
3698	*yy_c_buf_p = '\0'; \
3699	yyleng = n; \
3700	} \
3701	while ( 0 )
3702
3703
3704	/* Internal utility routines. */
3705
3706	#ifndef yytext_ptr
3707	#ifdef YY_USE_PROTOS
3708	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
3709	#else
3710	static void yy_flex_strncpy( s1, s2, n )
3711	char *s1;
3712	yyconst char *s2;
3713	int n;
3714	#endif
3715	{
3716	register int i;
3717	for ( i = 0; i < n; ++i )
3718	s1[i] = s2[i];
3719	}
3720	#endif
3721
3722	#ifdef YY_NEED_STRLEN
3723	#ifdef YY_USE_PROTOS
3724	static int yy_flex_strlen( yyconst char *s )
3725	#else
3726	static int yy_flex_strlen( s )
3727	yyconst char *s;
3728	#endif
3729	{
3730	register int n;
3731	for ( n = 0; s[n]; ++n )
3732	;
3733
3734	return n;
3735	}
3736	#endif
3737
3738
3739	#ifdef YY_USE_PROTOS
3740	static void *yy_flex_alloc( yy_size_t size )
3741	#else
3742	static void *yy_flex_alloc( size )
3743	yy_size_t size;
3744	#endif
3745	{
3746	return (void *) malloc( size );
3747	}
3748
3749	#ifdef YY_USE_PROTOS
3750	static void yy_flex_realloc( void ptr, yy_size_t size )
3751	#else
3752	static void *yy_flex_realloc( ptr, size )
3753	void *ptr;
3754	yy_size_t size;
3755	#endif
3756	{
3757	/* The cast to (char *) in the following accommodates both
3758	* implementations that use char* generic pointers, and those
3759	* that use void* generic pointers. It works with the latter
3760	* because both ANSI C and C++ allow castless assignment from
3761	* any pointer type to void*, and deal with argument conversions
3762	* as though doing an assignment.
3763	*/
3764	return (void ) realloc( (char ) ptr, size );
3765	}
3766
3767	#ifdef YY_USE_PROTOS
3768	static void yy_flex_free( void *ptr )
3769	#else
3770	static void yy_flex_free( ptr )
3771	void *ptr;
3772	#endif
3773	{
3774	free( ptr );
3775	}
3776
3777	#if YY_MAIN
3778	int main()
3779	{
3780	yylex();
3781	return 0;
3782	}
3783	#endif
3784	#line 1695 "vs1.0_tokens.l"
3785
3786
3787
3788	//=====================================================================
3789	// Function: FindNMacro
3790	// Description: Look through macros and see if it had been predefined
3791	// Parameters: findName = name to lookup
3792	// sLen = # characters valid in source (findName)
3793	// Returns: MACROENTRY * = pointer to macro entry if found
3794	//=====================================================================
3795	MACROENTRY FindNMacro(char findName, unsigned int sLen)
3796	{
3797	MACROENTRY *curEntry;
3798
3799	curEntry = gLastMacro;
3800	while (curEntry != NULL)
3801	{
3802	if (strlen(curEntry->macroName) == sLen)
3803	{
3804	if (!strncmp(curEntry->macroName, findName, sLen))
3805	{
3806	break;
3807	}
3808	}
3809
3810	curEntry = curEntry->prev;
3811	}
3812
3813	return curEntry;
3814
3815	}
3816
3817	//=====================================================================
3818	// Function: FindMacro
3819	// Description: Look through macros and see if it had been predefined
3820	// Parameters: findName = name to lookup
3821	// Returns: MACROENTRY * = pointer to macro entry if found
3822	//=====================================================================
3823	MACROENTRY FindMacro(char findName)
3824	{
3825	MACROENTRY *curEntry;
3826
3827	curEntry = gLastMacro;
3828	while (curEntry != NULL)
3829	{
3830	if (!strcmp(curEntry->macroName, findName))
3831	{
3832	break;
3833	}
3834
3835	curEntry = curEntry->prev;
3836	}
3837
3838	return curEntry;
3839
3840	}
3841
3842	//=====================================================================
3843	// Function: CleanUp
3844	// Description: Clean up the #define strings
3845	// Parameters: .
3846	// Returns: .
3847	//=====================================================================
3848	void CleanUp()
3849	{
3850	void *tPtr;
3851
3852	// free up the macros that were alloced
3853	while (gLastMacro != NULL)
3854	{
3855
3856	FreeMacroEntry(gLastMacro);
3857
3858	tPtr = gLastMacro;
3859	gLastMacro = gLastMacro->prev;
3860	SAFEFREE(tPtr);
3861	}
3862
3863	}
3864
3865	//=====================================================================
3866	// Function: FreeMacroEntry
3867	// Description: Frees up the macro entry data, (parms, lines of text)
3868	// Parameters: macEntry = pointer to the MACROENTRY structure
3869	// Returns: .
3870	//=====================================================================
3871	void FreeMacroEntry(MACROENTRY *macEntry)
3872	{
3873	MACROTEXT *tText;
3874	MACROTEXT *tNext;
3875
3876	SAFEFREE(macEntry->macroName);
3877	SAFEFREE(macEntry->fileName);
3878	// free the macro lines that were alloced
3879	tText = macEntry->lastMacroLines;
3880	while (tText != NULL)
3881	{
3882	tNext = tText->prev;
3883	SAFEFREE(tText);
3884	tText = tNext;
3885	}
3886
3887	// free the text of the macro parms that were alloced
3888	tText = macEntry->lastMacroParms;
3889	while (tText != NULL)
3890	{
3891	tNext = tText->prev;
3892	SAFEFREE(tText);
3893	tText = tNext;
3894	}
3895	}
3896
3897	//=====================================================================
3898	// Function: CheckMacroFunctions
3899	// Description: Find if this text is a builtin macro function
3900	// Parameters: lookString = non-null terminated string of possible
3901	// and if found set global macro function call
3902	// Returns: .
3903	//=====================================================================
3904	void CheckMacroFunctions(char lookString, unsigned int recognizedLen, char **invString)
3905	{
3906
3907	unsigned int i;
3908	unsigned int sLen;
3909
3910	for (i=0; i< NUM_MACRO_FUNCTIONS; i++)
3911	{
3912	sLen = strlen(gMacroFunctions[i].name);
3913	if (!strncmp(gMacroFunctions[i].name, lookString, sLen))
3914	{
3915	gMacroCallFunction = gMacroFunctions[i].function;
3916	*recognizedLen = sLen;
3917	*invString = NULL;
3918	return;
3919	}
3920	}
3921	}
3922
3923	//=====================================================================
3924	// Function: FindAlphaNum
3925	// Description: Find a whole alpha numeric string, ie consists of
3926	// [A-Za-z0-9_] only
3927	// Parameters: srcStr = source string to search through.
3928	// sLen = unsinged int pointer to length of string found
3929	// Returns: pointer to found start of string.
3930	// NULL if none.
3931	//=====================================================================
3932	char FindAlphaNum(char srcStr, unsigned int *sLen)
3933	{
3934	char curChar;
3935	char *foundStr;
3936
3937	while (*srcStr != '\0')
3938	{
3939	curChar = toupper(*srcStr);
3940	if ((curChar >= 'A') && (curChar <= 'Z'))
3941	break;
3942
3943	if ((curChar >= '0') && (curChar <='9'))
3944	break;
3945
3946	if (curChar == '_')
3947	break;
3948
3949	srcStr++;
3950	}
3951
3952	if (*srcStr == '\0')
3953	{
3954	return NULL;
3955	}
3956
3957	foundStr = srcStr;
3958
3959	*sLen = 0;
3960	// now search for end of string of [A-Za-z0-9_]
3961	while (*srcStr != '\0')
3962	{
3963	curChar = toupper(*srcStr);
3964	if ((curChar < 'A') \|\| (curChar > 'Z'))
3965	{
3966	if ((curChar < '0') \|\| (curChar > '9'))
3967	{
3968	if (curChar != '_')
3969	break;
3970	}
3971	}
3972
3973	(*sLen)++;
3974	srcStr++;
3975	}
3976
3977	return foundStr;
3978
3979	}
3980
3981	//=====================================================================
3982	// Function: FindDefineParm
3983	// Description: Find if the MACROENTRY->macroText linked list contains
3984	// replaceable parameters.
3985	// Parameters: srcParms = pointer to MACROENTRY structure for source
3986	// parameters
3987	// invParms = MACROENTRY pointer to invocation parameters
3988	// lookString = non-null terminated string of possible
3989	// replaceable string
3990	// recognizedLen = replacement string matched length
3991	// invString = invocation string to replace with
3992	// Returns: pointer to first character found in lookstring
3993	//=====================================================================
3994	char FindDefineParm(MACROENTRY srcParms, MACROENTRY *invParms,
3995	char lookString, unsigned int recognizedLen, char **invString)
3996	{
3997	MACROTEXT *srcText;
3998	MACROTEXT *invText;
3999	char *checkStr;
4000	unsigned int checkLen;
4001	unsigned int sLen;
4002
4003	checkStr = lookString;
4004	*invString = NULL;
4005
4006	// first search for first [A-Za-z0-9_] only string
4007	checkStr = FindAlphaNum(lookString, &checkLen);
4008
4009	while (checkStr != NULL)
4010	{
4011	// check all the #define parameters for match
4012	srcText = srcParms->firstMacroParms;
4013	invText = invParms->firstMacroParms;
4014	while (srcText)
4015	{
4016	sLen = strlen(srcText->macroText);
4017	// lengths should match
4018	if (sLen == checkLen)
4019	{
4020	if (!strncmp(checkStr, srcText->macroText, checkLen))
4021	{
4022	// it matched so return replacement text
4023	*invString = invText->macroText;
4024	// and length that we reconized
4025	*recognizedLen = checkLen;
4026	return checkStr;
4027	}
4028	}
4029
4030	srcText = srcText->next;
4031	invText = invText->next;
4032	}
4033
4034	// not found yet, so go to next string.
4035	checkStr = FindAlphaNum(checkStr+checkLen, &checkLen);
4036	}
4037
4038	return NULL;
4039	}
4040
4041	//=====================================================================
4042	// Function: FindReplaceParm
4043	// Description: Find if the MACROENTRY->macroText linked list contains
4044	// a replaceable parameters.
4045	// Parameters: srcParms = pointer to MACROENTRY structure for source
4046	// parameters
4047	// invParms = MACROENTRY pointer to invocation parameters
4048	// lookString = non-null terminated string of possible
4049	// replaceable string
4050	// recognizedLen = replacement string matched length
4051	// invString = invocation string to replace with
4052	// Returns: .
4053	//=====================================================================
4054	void FindReplaceParm(MACROENTRY srcParms, MACROENTRY invParms,
4055	char lookString, unsigned int recognizedLen, char **invString)
4056	{
4057	unsigned int sLen;
4058	MACROTEXT *srcText;
4059	MACROTEXT *invText;
4060
4061	*recognizedLen = 0;
4062	*invString = NULL;
4063
4064	srcText = srcParms->firstMacroParms;
4065	invText = invParms->firstMacroParms;
4066
4067	if (srcText != NULL)
4068	{
4069	// go until srcText # strings ends
4070	while (srcText != NULL)
4071	{
4072	sLen = strlen(srcText->macroText);
4073	if (!strncmp(srcText->macroText, lookString, sLen))
4074	{
4075	// found it so return src, replacement string
4076	*recognizedLen = strlen(srcText->macroText);
4077	*invString = invText->macroText;
4078	// call function macro if it was invoked prior.
4079	if (gMacroCallFunction != NULL)
4080	{
4081	gMacroCallFunction(lookString, recognizedLen, invString);
4082	gMacroCallFunction = NULL;
4083	}
4084	return;
4085	}
4086
4087	srcText = srcText->next;
4088	invText = invText->next;
4089	}
4090	}
4091
4092	// ok, it wasn't found, look through builtin macro functions
4093	CheckMacroFunctions(lookString, recognizedLen, invString);
4094	}
4095
4096	//=====================================================================
4097	// Function: ReplaceMacroParms
4098	// Description: Replace macro parameters when macro was defined, with
4099	// those specified on the macro invocation line
4100	// Parameters: srcLine = source line to replace src macro parms with
4101	// destLine = destination line save to.
4102	// invocation macro parameters.
4103	// parseMacro = currently parsing macro entry
4104	// invParms = invocation macro entry
4105	// Returns: .
4106	//=====================================================================
4107	void ReplaceMacroParms(char srcLine, char destLine,
4108	MACROENTRY srcParms, MACROENTRY invParms)
4109	{
4110	char *findReplace;
4111	char *invString;
4112	unsigned int sLen;
4113	unsigned int dLen;
4114	unsigned int copyLen;
4115	unsigned int subLen;
4116	unsigned int recognizedLen;
4117
4118	destLine[0]= '\0';
4119
4120	sLen = strlen(srcLine);
4121	dLen = 0;
4122
4123	while (sLen > 0)
4124	{
4125	// strtok might work better except it modifies the string, so
4126	// kind of do my own....
4127	if (!srcParms->bIsDefine)
4128	{
4129	findReplace = strchr(srcLine, '%');
4130	if (findReplace != NULL)
4131	{
4132	// bypass % sign in findReplacement
4133	findReplace++;
4134	// figure out length of source before %
4135	copyLen = (findReplace - srcLine)-1;
4136	// check if there is a replacement string
4137	FindReplaceParm(srcParms, invParms, findReplace, &recognizedLen, &invString);
4138	}
4139	else
4140	{
4141	strcat(destLine, srcLine);
4142	return;
4143	}
4144	}
4145	else
4146	{
4147	findReplace = FindDefineParm(srcParms, invParms, srcLine, &recognizedLen, &invString);
4148	if (findReplace != NULL)
4149	{
4150	// figure out length of source before %
4151	copyLen = findReplace - srcLine;
4152	}
4153	else
4154	{
4155	strcat(destLine, srcLine);
4156	return;
4157	}
4158	}
4159
4160
4161	if (invString != NULL)
4162	{
4163	// figure out how much we are going to substitute
4164	subLen = strlen(invString);
4165	}
4166	else
4167	{
4168	subLen = 0;
4169	}
4170
4171	if ((dLen + copyLen + subLen) > MAXSAVELINE)
4172	{
4173	LexError("Macro string overrun.\n");
4174	CleanUp();
4175	exit(ERROR_MACRO_OVERRUN);
4176	}
4177
4178	if (copyLen > 0)
4179	{
4180	strncat(destLine, srcLine, copyLen);
4181	dLen += copyLen;
4182	}
4183
4184	srcLine += copyLen;
4185	sLen -= copyLen;
4186	// in macro so skip % part of variable
4187	if (!srcParms->bIsDefine)
4188	{
4189	// skip %, also
4190	srcLine++;
4191	sLen--;
4192	}
4193
4194	if (invString != NULL)
4195	{
4196	strcat(destLine, invString);
4197	dLen += strlen(invString);
4198	}
4199
4200	srcLine += recognizedLen;
4201	sLen -= recognizedLen;
4202	}
4203
4204	}
4205
4206	//=====================================================================
4207	// Function: SaveMacroText
4208	// Description: Adds a string to a linked list of MACROTEXT structures
4209	// Parameters: srcText = pointer to source text to save
4210	// lastMacroText = last allocated, or NULL
4211	// Returns: newly allocated MACROTEXT structure, or NULL
4212	//=====================================================================
4213	MACROTEXT SaveMacroText(char srcText, MACROTEXT *lastMacroText)
4214	{
4215	MACROTEXT *curMacroText;
4216
4217	curMacroText = (MACROTEXT *)malloc(sizeof(MACROTEXT));
4218	if (curMacroText == NULL)
4219	{
4220	return NULL;
4221	}
4222	else
4223	{
4224	// no next entry but set up previous with previously alloced macro parameter
4225	curMacroText->next = NULL;
4226	curMacroText->prev = lastMacroText;
4227
4228	// if the macroParm pointer is null then we are the first allocated
4229	// so if not set the last one allocate next pointer to newly allocated structure
4230	if (lastMacroText != NULL)
4231	{
4232	lastMacroText->next = curMacroText;
4233	}
4234
4235	/* %%%%% this should be set up in memory pools. */
4236	curMacroText->macroText = strdup(srcText);
4237	if (curMacroText->macroText == NULL)
4238	{
4239	SAFEFREE(curMacroText);
4240	return NULL;
4241	}
4242	}
4243
4244	return curMacroText;
4245	}
4246
4247	//=====================================================================
4248	// Function: ParseBuiltInMacroParms
4249	// Description: parse parameters of string and fill in MACROENTRY
4250	// structure.
4251	// Parameters: parsedMacro = pointer to MACROENTRY structure that gets
4252	// filled in with parameter pointers and count
4253	// parmStr = string to parse parameters from
4254	// Returns: false if error
4255	//=====================================================================
4256	bool ParseBuiltInMacroParms(MACROENTRY parsedMacro, char parmStr)
4257	{
4258	char *endStr;
4259	char *foundParm;
4260	MACROTEXT *prevMT;
4261	MACROTEXT *curMT;
4262
4263	parsedMacro->numParms = 0;
4264	parsedMacro->firstMacroParms = NULL;
4265
4266	foundParm = strdup(parmStr);
4267	if (foundParm == NULL)
4268	{
4269	LexError("Out of memory parsing bultin macro parameters.\n");
4270	return false;
4271	}
4272
4273	// assume a ')' is on the end.
4274	endStr = strrchr(foundParm, ')');
4275	if (endStr == NULL)
4276	{
4277	LexWarning("Ending parenthesis not found for macro %s.\n", parsedMacro->macroName);
4278	endStr = foundParm + strlen(foundParm);
4279	}
4280
4281	prevMT = NULL;
4282	// strip out and seperate parameters
4283	while (foundParm < endStr)
4284	{
4285	// allocate a macro text structure
4286	curMT = (MACROTEXT *)malloc(sizeof(MACROTEXT));
4287	if (curMT == NULL)
4288	{
4289	free(parmStr);
4290	LexError("Out of memory parsing bultin macro parameters.\n");
4291	return false;
4292	}
4293	curMT->next = NULL;
4294	curMT->prev = prevMT;
4295	parsedMacro->numParms++;
4296
4297	if (prevMT != NULL)
4298	{
4299	prevMT->next = curMT;
4300	}
4301	else
4302	{
4303	parsedMacro->firstMacroParms = curMT;
4304	}
4305
4306	curMT->macroText = foundParm;
4307	// search for next parameters, delimited by comma
4308	foundParm = strchr(foundParm, ',');
4309	if (foundParm == NULL)
4310	{
4311	foundParm = endStr;
4312	*foundParm = '\0';
4313	}
4314	else
4315	{
4316	// skip comma
4317	*foundParm = '\0';
4318	foundParm++;
4319	}
4320	prevMT = curMT;
4321	}
4322
4323	return true;
4324	}
4325
4326	//=====================================================================
4327	// Function: MacroMathFunction
4328	// Description: Comes here after macro replacement is done to perform
4329	// some mathematic function on parameter (macro replacement
4330	// string (ie, register))
4331	// Parameters: invMacro = macroentry pointer containing macro information
4332	// recognizedLen = # characters recoginized so far
4333	// invStr = invoked replacement string so far
4334	// mathStr = "-", "+", etc for mathematic function
4335	// Returns: new recognizedLen, invStr, with incremented #
4336	//=====================================================================
4337	void MacroMathFunction(MACROENTRY invMacro, unsigned int recognizedLen, char **invStr,
4338	char *mathStr)
4339	{
4340	char *numStartStr;
4341	unsigned int sLen;
4342	char numberStr[256];
4343	unsigned int number;
4344	char *operand;
4345
4346
4347	// verify enough paramters to complete operation
4348	if (invMacro->numParms != 2)
4349	{
4350	LexError("Two parameters are required for %s macro\n", invMacro->macroName);
4351	return;
4352	}
4353
4354	// get second macro parm, which is add by amount.
4355	operand = invMacro->firstMacroParms->next->macroText;
4356
4357	// first find inner most bracket if any
4358	numStartStr = strrchr(*invStr, ']');
4359	if (numStartStr == NULL)
4360	{
4361	numStartStr = strrchr(*invStr, ')');
4362	}
4363
4364	if (numStartStr != NULL)
4365	{
4366	if ((strlen(*invStr)+strlen(operand)+1) > MAXREPLACESTRING)
4367	{
4368	LexError("Out of Temporary string replacement memory inside builtin macro %s\n",
4369	invMacro->macroName);
4370	}
4371	else
4372	{
4373	sLen = (numStartStr - *invStr);
4374	gReplaceText[0] = '\0';
4375	strncat(gReplaceText, *invStr, sLen);
4376	strcat(gReplaceText, mathStr);
4377	strcat(gReplaceText, operand);
4378	strcat(gReplaceText, numStartStr);
4379	*invStr = gReplaceText;
4380	}
4381	}
4382	else
4383	{
4384	numStartStr = strpbrk(*invStr, "0123456789");
4385	if (numStartStr != NULL)
4386	{
4387	// put up to number we found
4388	sLen = numStartStr - *invStr;
4389	if (sLen > MAXREPLACESTRING)
4390	goto ErrOut;
4391
4392	gReplaceText[0] = '\0';
4393	strncat(gReplaceText, *invStr, sLen);
4394
4395	switch (mathStr[0])
4396	{
4397	case '-':
4398	number = atoi(numStartStr)-atoi(operand);
4399	break;
4400	case '+':
4401	number = atoi(numStartStr)+atoi(operand);
4402	break;
4403	}
4404	sprintf(numberStr, "%d", number);
4405
4406	if ((strlen(gReplaceText) + strlen(numberStr)) > MAXREPLACESTRING)
4407	goto ErrOut;
4408
4409	strcat(gReplaceText, numberStr);
4410
4411	while ((numStartStr != '\0') && (numStartStr >= '0' && *numStartStr <= '9'))
4412	numStartStr++;
4413
4414	if ((strlen(gReplaceText) + strlen(numStartStr)) > MAXREPLACESTRING)
4415	goto ErrOut;
4416
4417	strcat(gReplaceText, numStartStr);
4418
4419	*invStr = gReplaceText;
4420	}
4421	else
4422	{
4423	if ((strlen(*invStr)+strlen(operand)+1) > MAXREPLACESTRING)
4424	{
4425	LexError("Out of Temporary string replacement memory inside builtin macro %s\n",
4426	invMacro->macroName);
4427	}
4428	else
4429	{
4430	sprintf(gReplaceText, "%s%s%s", *invStr, mathStr, operand);
4431	*invStr = gReplaceText;
4432	}
4433	}
4434	}
4435
4436
4437	return;
4438
4439	ErrOut:
4440	LexError("Out of Temporary string replacement memory inside builtin macro %s\n",
4441	invMacro->macroName);
4442	// skip ')'
4443	(*recognizedLen)++;
4444	}
4445
4446	//=====================================================================
4447	// Function: MacroIncFunction
4448	// Description: Comes here after macro replacement is done to increment
4449	// macro replacement string (ie, register)
4450	// Parameters: lookStr = string after '(', so we can get parameters
4451	// recognizedLen = # characters recoginized so far
4452	// invStr = invoked replacement string so far
4453	// Returns: new recognizedLen, invStr, with incremented #
4454	//=====================================================================
4455	void MacroIncFunction(char lookStr, unsigned int recognizedLen, char **invStr)
4456	{
4457	MACROENTRY tMEntry;
4458	MACROTEXT parm1;
4459	MACROTEXT parm2;
4460
4461	tMEntry.macroName = "%inc()";
4462	tMEntry.numParms = 2;
4463	tMEntry.firstMacroParms = &parm1;
4464	parm1.prev = NULL;
4465	parm1.next = &parm2;
4466	parm1.macroText = *invStr;
4467	parm2.prev = &parm1;
4468	parm2.next = NULL;
4469	parm2.macroText = "1";
4470
4471	MacroMathFunction(&tMEntry, recognizedLen, invStr, "+");
4472	// skip ')'
4473	(*recognizedLen)++;
4474	}
4475
4476	//=====================================================================
4477	// Function: MacroDecFunction
4478	// Description: Comes here after macro replacement is done to decrement
4479	// macro replacement string (ie, register)
4480	// Parameters: lookStr = string after '(', so we can get parameters
4481	// recognizedLen = # characters recoginized so far
4482	// invStr = invoked replacement string so far
4483	// Returns: new recognizedLen, invStr, with decremented #
4484	//=====================================================================
4485	void MacroDecFunction(char lookStr, unsigned int recognizedLen, char **invStr)
4486	{
4487	MACROENTRY tMEntry;
4488	MACROTEXT parm1;
4489	MACROTEXT parm2;
4490
4491	tMEntry.macroName = "%dec()";
4492	tMEntry.numParms = 2;
4493	tMEntry.firstMacroParms = &parm1;
4494	parm1.prev = NULL;
4495	parm1.next = &parm2;
4496	parm1.macroText = *invStr;
4497	parm2.prev = &parm1;
4498	parm2.next = NULL;
4499	parm2.macroText = "1";
4500
4501	MacroMathFunction(&tMEntry, recognizedLen, invStr, "-");
4502	// skip ')'
4503	(*recognizedLen)++;
4504	}
4505
4506	//=====================================================================
4507	// Function: MacroAddFunction
4508	// Description: Comes here after macro replacement is done to add
4509	// macro replacement string (ie, register)
4510	// Parameters: lookStr = string after '(', so we can get parameters
4511	// recognizedLen = # characters recoginized so far
4512	// invStr = invoked replacement string so far
4513	// Returns: new recognizedLen, invStr, with incremented #
4514	//=====================================================================
4515	void MacroAddFunction(char lookStr, unsigned int recognizedLen, char **invStr)
4516	{
4517	MACROENTRY tMEntry;
4518	MACROTEXT *curMT;
4519	MACROTEXT *nextMT;
4520	unsigned int i;
4521
4522	tMEntry.macroName = "%add()";
4523	if (strlen(lookStr) > MAXREPLACESTRING)
4524	{
4525	LexError("Out of Temporary string replacement memory inside builtin macro %add()\n");
4526	return;
4527	}
4528	if (ParseBuiltInMacroParms(&tMEntry, lookStr))
4529	{
4530	MacroMathFunction(&tMEntry, recognizedLen, invStr, "+");
4531	// skip ',' strlen(parm2)+ ')'
4532	(*recognizedLen) += strlen(tMEntry.firstMacroParms->next->macroText)+2;
4533	}
4534
4535	curMT = tMEntry.firstMacroParms;
4536	// in this case only one string was allocated
4537	free(curMT->macroText);
4538	for (i=0; i<tMEntry.numParms; i++)
4539	{
4540	nextMT = curMT->next;
4541	free(curMT);
4542	curMT = nextMT;
4543	}
4544	}
4545
4546	//=====================================================================
4547	// Function: MacroSubFunction
4548	// Description: Comes here after macro replacement is done to subtract
4549	// macro replacement string (ie, register)
4550	// Parameters: invParms, parameters that macro was invoked with
4551	// recognizedLen = # characters recoginized so far
4552	// invStr = invoked replacement string so far
4553	// Returns: new recognizedLen, invStr, with incremented #
4554	//=====================================================================
4555	void MacroSubFunction(char lookStr, unsigned int recognizedLen, char **invStr)
4556	{
4557	MACROENTRY tMEntry;
4558	MACROTEXT *curMT;
4559	MACROTEXT *nextMT;
4560	unsigned int i;
4561
4562	tMEntry.macroName = "%sub()";
4563	if (ParseBuiltInMacroParms(&tMEntry, lookStr))
4564	{
4565	MacroMathFunction(&tMEntry, recognizedLen, invStr, "-");
4566	// skip ',' strlen(parm2)+ ')'
4567	(*recognizedLen) += strlen(tMEntry.firstMacroParms->next->macroText)+2;
4568	}
4569	curMT = tMEntry.firstMacroParms;
4570	// in this case only one string was allocated
4571	free(curMT->macroText);
4572	for (i=0; i<tMEntry.numParms; i++)
4573	{
4574	nextMT = curMT->next;
4575	free(curMT);
4576	curMT = nextMT;
4577	}
4578	}
4579
4580	//=====================================================================
4581	// Function: EndMacroParms
4582	// Description: Does update and cleanup one end of macro parameters
4583	// is reached
4584	// Parameters: .
4585	// Returns: .
4586	//=====================================================================
4587	void EndMacroParms()
4588	{
4589	char *curFileName;
4590	char *macroFileName;
4591	char tempStr[1024];
4592	char *macroText;
4593
4594	if (gbTempInsideMacro)
4595	{
4596	if (gTempParseMacro->numParms != gTempMacro->numParms)
4597	{
4598	LexError("Macro invocation number of parameters do not match macro definition, skipping\n");
4599	BEGIN(INITIAL);
4600	SAFEFREE(gTempMacro);
4601	}
4602	else
4603	{
4604	// we got all the parameters for the MACRO invocation, so start inside
4605	// the macro now, by saving off current state on stack
4606	gIncludeStack[gIncludeStackIndex].lineNo = yylineno;
4607	gIncludeStack[gIncludeStackIndex].fileName = gCurFileName;
4608	// gIncludeStack[gIncludeStackIndex].fileHandle = yyin;
4609	//fprintf( stderr, "Chris fix this code with myin stuff\n" );
4610	gIncludeStack[gIncludeStackIndex].prevString = myin;
4611	gIncludeStack[gIncludeStackIndex].nextString = NULL;
4612	gIncludeStack[gIncludeStackIndex].lastInvokeMacro = gInvokeMacro;
4613	gIncludeStack[gIncludeStackIndex].lastParseMacro = gParseMacro;
4614	gIncludeStack[gIncludeStackIndex].lastMacroLineParse = gMacroLineParse;
4615	gIncludeStack[gIncludeStackIndex].lastbInsideMacro = gbInsideMacro;
4616	gIncludeStack[gIncludeStackIndex].lastbInsideInclude = gbInsideInclude;
4617	gIncludeStack[gIncludeStackIndex].buffer = YY_CURRENT_BUFFER;
4618	gIncludeStack[gIncludeStackIndex].lastbProcessingIFDEF = gbProcessingIFDEF;
4619	gIncludeStackIndex++;
4620
4621	gParseMacro = gTempParseMacro;
4622	gInvokeMacro = gTempMacro;
4623	gbInsideMacro = gbTempInsideMacro;
4624
4625	gbTempInsideMacro = false;
4626
4627	// yyin = NULL;
4628	myin = NULL;
4629	curFileName = gCurFileName;
4630	if (curFileName == NULL)
4631	curFileName = "";
4632
4633	macroFileName = gParseMacro->fileName;
4634	if (macroFileName == NULL)
4635	macroFileName = "";
4636
4637	sprintf(tempStr, "%s(%d) : References ->\n%s", curFileName, yylineno, macroFileName);
4638	gCurFileName = strdup(tempStr);
4639	gMacroLineParse = gParseMacro->firstMacroLines;
4640
4641	macroText = gMacroLine;
4642	// if no replacement text, just use source line
4643	if (gParseMacro->firstMacroParms == NULL)
4644	{
4645	macroText = gMacroLineParse->macroText;
4646	}
4647	else
4648	{
4649	// replace the macro parameters
4650	ReplaceMacroParms(gMacroLineParse->macroText, gMacroLine, gParseMacro, gInvokeMacro);
4651	}
4652
4653	yylineno = gParseMacro->lineNo;
4654	if (gParseMacro->nLines >= 1)
4655	{
4656	strcpy(gSaveLine, macroText);
4657	}
4658
4659	// if (gExpandMacros && (gParseMacro->nLines >= 1))
4660	// {
4661	// // in case there is anything there dump it out
4662	// GenDebugLine();
4663	// GenListString();
4664	// if (gInvokeMacro->nLines >= 1)
4665	// GenSwitchFileNames(macroFileName);
4666	// }
4667
4668	BEGIN(gInvokeState);
4669	yy_scan_string(macroText);
4670	gInvokeState = INITIAL;
4671	}
4672	}
4673	else
4674	{
4675	if (gLastMacro != NULL)
4676	{
4677	gLastMacro->next = gTempMacro;
4678	}
4679	gLastMacro = gTempMacro;
4680	BEGIN(MACROBODY);
4681	}
4682	}
4683
4684	//=====================================================================
4685	// Function: FindSwizzleValue
4686	// Description: see if valid swizzle value and return the bits
4687	// Parameters: swizzleTex = pointer to characters to analyze
4688	// Returns: unsigned int = bits for swizzle values, or 0 for error
4689	//=====================================================================
4690	unsigned int FindSwizzleValue(char *swizzleText)
4691	{
4692	unsigned int swizzleBits;
4693	unsigned int sLen;
4694	unsigned int i;
4695	unsigned int lastMask;
4696
4697	sLen = strlen(swizzleText);
4698	swizzleBits = 0;
4699	lastMask = 0;
4700
4701	for (i=0; i<sLen; i++)
4702	{
4703	switch (swizzleText[i])
4704	{
4705	case 'x':
4706	swizzleBits \|= (WRITEMASK_X << (4*(3-i)));
4707	lastMask = WRITEMASK_X;
4708	break;
4709	case 'y':
4710	swizzleBits \|= (WRITEMASK_Y << (4*(3-i)));
4711	lastMask = WRITEMASK_Y;
4712	break;
4713	case 'z':
4714	swizzleBits \|= (WRITEMASK_Z << (4*(3-i)));
4715	lastMask = WRITEMASK_Z;
4716	break;
4717	case 'w':
4718	swizzleBits \|= (WRITEMASK_W << (4*(3-i)));
4719	lastMask = WRITEMASK_W;
4720	break;
4721	}
4722	}
4723
4724	for (; i<4; i++)
4725	{
4726	swizzleBits \|= (lastMask << (4*(3-i)));
4727	}
4728
4729	return swizzleBits;
4730	}
4731
4732	#if 0
4733	unsigned int FindSwizzleValue(char *swizzleText)
4734	{
4735
4736	DWORD swizzleBits;
4737	DWORD sLen;
4738	DWORD i;
4739	DWORD lastIndex;
4740
4741	sLen = strlen(swizzleText);
4742	swizzleBits = 0;
4743	lastIndex = 0;
4744
4745	for (i=0; i<sLen; i++)
4746	{
4747	switch (swizzleText[i])
4748	{
4749	case 'x':
4750	swizzleBits \|= (0 << (D3DVS_SWIZZLE_SHIFT + (i * 2)));
4751	lastIndex = 0;
4752	break;
4753	case 'y':
4754	swizzleBits \|= (1 << (D3DVS_SWIZZLE_SHIFT + (i * 2)));
4755	lastIndex = 1;
4756	break;
4757	case 'z':
4758	swizzleBits \|= (2 << (D3DVS_SWIZZLE_SHIFT + (i * 2)));
4759	lastIndex = 2;
4760	break;
4761	case 'w':
4762	swizzleBits \|= (3 << (D3DVS_SWIZZLE_SHIFT + (i * 2)));
4763	lastIndex = 3;
4764	break;
4765	}
4766	}
4767
4768	for (; i<4; i++)
4769	{
4770	swizzleBits \|= (lastIndex << (D3DVS_SWIZZLE_SHIFT + (i * 2)));
4771	}
4772
4773	return swizzleBits;
4774
4775
4776	}
4777	#endif
4778
4779	//=====================================================================
4780	// Function: FindRegisterMask
4781	// Description: Look through register mask strings
4782	// Parameters: findName = name to lookup
4783	// Returns: unsigned int with token value
4784	//=====================================================================
4785	unsigned int MakeRegisterMask(char *findName)
4786	{
4787
4788	unsigned int regMask;
4789	char *findFirst;
4790
4791	regMask = 0;
4792
4793	findFirst = strchr(findName, 'x');
4794	if (findFirst != NULL)
4795	{
4796	if (strchr(findFirst+1, 'x') != NULL)
4797	{
4798	return 0;
4799	}
4800
4801	regMask \|= WRITEMASK_X;
4802	}
4803
4804	findFirst = strchr(findName, 'y');
4805	if (findFirst != NULL)
4806	{
4807	regMask \|= WRITEMASK_Y;
4808	// invalide write mask, must be swizzle
4809	if (strchr(findFirst+1, 'x') != NULL)
4810	{
4811	return 0;
4812	}
4813
4814	if (strchr(findFirst+1, 'y') != NULL)
4815	{
4816	return 0;
4817	}
4818
4819	}
4820
4821	findFirst = strchr(findName, 'z');
4822	if (findFirst != NULL)
4823	{
4824	regMask \|= WRITEMASK_Z;
4825	if (strchr(findFirst+1, 'x') != NULL)
4826	{
4827	return 0;
4828	}
4829
4830	if (strchr(findFirst+1, 'y') != NULL)
4831	{
4832	return 0;
4833	}
4834
4835	if (strchr(findFirst+1, 'z') != NULL)
4836	{
4837	return 0;
4838	}
4839	}
4840
4841	findFirst = strchr(findName, 'w');
4842	if (findFirst != NULL)
4843	{
4844
4845	regMask \|= WRITEMASK_W;
4846	if (strchr(findFirst+1, 'x') != NULL)
4847	{
4848	return 0;
4849	}
4850
4851	if (strchr(findFirst+1, 'y') != NULL)
4852	{
4853	return 0;
4854	}
4855
4856	if (strchr(findFirst+1, 'z') != NULL)
4857	{
4858	return 0;
4859	}
4860
4861	if (strchr(findFirst+1, 'w') != NULL)
4862	{
4863	return 0;
4864	}
4865	}
4866
4867	return regMask;
4868
4869	}
4870
4871	//=====================================================================
4872	// Function: LexError
4873	// Description: output an error to the stdout
4874	// Parameters: typical printf like format
4875	// Returns: .
4876	//=====================================================================
4877	void LexError(char *format, ...)
4878	{
4879	char errstring[4096];
4880	va_list marker;
4881
4882	// fprintf( stderr,"(%d) : Error : ", yylineno);
4883	if ( gbInsideInclude )
4884	{
4885	sprintf( errstring, "%s", gCurFileName );
4886	sprintf( errstring+strlen(errstring),"(%d) : Error : ", yylineno);
4887	}
4888	else
4889	{
4890	sprintf( errstring,"(%d) : Error : ", yylineno);
4891	}
4892
4893	va_start(marker, format);
4894	// vprintf(format, marker);
4895	vsprintf(errstring+strlen(errstring), format, marker);
4896	va_end(marker);
4897	errors.set( errstring );
4898	}
4899
4900	//=====================================================================
4901	// Function: LexWarning
4902	// Description: output a warning to the stdout
4903	// Parameters: typical printf like format
4904	// Returns: .
4905	//=====================================================================
4906	void LexWarning(char *format, ...)
4907	{
4908	char errstring[4096];
4909	va_list marker;
4910
4911	// fprintf( stderr,"(%d) : warning : ", yylineno);
4912	if ( gbInsideInclude )
4913	sprintf( errstring, "%s", gCurFileName );
4914	sprintf( errstring+strlen(errstring),"(%d) : Warning : ", yylineno);
4915	// sprintf( errstring,"(%d) : Warning : ", yylineno);
4916
4917	va_start(marker, format);
4918	// vprintf(format, marker);
4919	vsprintf(errstring+strlen(errstring), format, marker);
4920	va_end(marker);
4921	errors.set( errstring );
4922	}
4923
4924	//=====================================================================
4925	// Function: DebugUnhandledState
4926	// Description: Come here in debug mode, when a state isn't handled
4927	// for the Lexer
4928	// Parameters: .
4929	// Returns: .
4930	//=====================================================================
4931	void DebugUnhandledState()
4932	{
4933	fprintf( stderr,"Unhandled state reached, with %s text.\n", yytext);
4934	}
4935
4936	//=====================================================================
4937	// Function: FindOpcode
4938	// Description: Look through opcodes and see if in the table
4939	// Parameters: findName = name to lookup
4940	// Returns: OPCODEMAP * = pointer to opcode map entry, if found
4941	//=====================================================================
4942	OPCODEMAP FindOpcode(char findName)
4943	{
4944
4945	unsigned i;
4946
4947	// just do linear search for now
4948	for (i=0; i<NUMOPCODES; i++)
4949	{
4950	if (!stricmp(theOpcodes[i].string, findName))
4951	{
4952	return &theOpcodes[i];
4953	}
4954
4955	}
4956
4957	return NULL;
4958	}
4959
4960	char ReadTextFile(const char filename)
4961	{
4962	char path[3][32] = { ".\0",
4963	"../../data/programs\0",
4964	"../../../data/programs\0" };
4965	char name[8192];
4966	int i;
4967
4968	if (!filename) return 0;
4969
4970	struct _stat status;
4971	int found = 0;
4972	for ( i = 0; i < 3; i++ )
4973	{
4974	sprintf( name, "%s/%s", path[i], filename );
4975
4976	int fh = ::_open(name, _O_RDONLY);
4977
4978	if(fh != -1)
4979	{
4980	int result = _fstat( fh, &status );
4981	if( result != 0 )
4982	{
4983	fprintf( stderr, "An fstat error occurred.\n" );
4984	break;
4985	}
4986	::_close( fh );
4987	found = i+1;
4988	break;
4989	}
4990	}
4991
4992	if ( 0 == found )
4993	{
4994	fprintf(stderr,"Cannot open \"%s\" for stat read!\n", filename);
4995	return NULL;
4996	}
4997	long size = status.st_size;
4998
4999	char * buf = new char[size+1];
5000
5001	FILE *fp = 0;
5002	if (!(fp = fopen(name, "r")))
5003	{
5004	fprintf(stderr,"Cannot open \"%s\" for read!\n", name);
5005	return NULL;
5006	}
5007
5008	int bytes;
5009	bytes = fread(buf, 1, size, fp);
5010
5011	buf[bytes] = 0;
5012
5013	fclose(fp);
5014	return buf;
5015	}
5016
5017	bool vs10_init_more();
5018
5019	bool vs10_init(char* inputString)
5020	{
5021	BEGIN(SAVELINE);
5022	myin = inputString;
5023	line_incr = 0;
5024	return vs10_init_more();
5025	}
5026
5027	#ifndef vs10_wrap
5028	int vs10_wrap(void)
5029	{
5030	return(1);
5031	}
5032	#endif

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

Download in other formats: