WebSVN – Kolibri OS – Blame – /programs/develop/libraries/Mesa/src/mesa/program/lex.yy.c

Rev	Author	Line No.	Line
1901	serge	1
		2
		3
		4
		5
		6
		7
		8	#define YY_FLEX_MAJOR_VERSION 2
		9	#define YY_FLEX_MINOR_VERSION 5
		10	#define YY_FLEX_SUBMINOR_VERSION 35
		11	#if YY_FLEX_SUBMINOR_VERSION > 0
		12	#define FLEX_BETA
		13	#endif
		14
		15
		16
		17
		18	#include
		19	#include
		20	#include
		21	#include
		22
		23
		24
		25
		26
		27
		28	#define FLEXINT_H
		29
		30
		31
		32
		33
		34
		35	* if you want the limit (max/min) macros for int types.
		36	*/
		37	#ifndef __STDC_LIMIT_MACROS
		38	#define __STDC_LIMIT_MACROS 1
		39	#endif
		40
		41
		42	typedef int8_t flex_int8_t;
		43	typedef uint8_t flex_uint8_t;
		44	typedef int16_t flex_int16_t;
		45	typedef uint16_t flex_uint16_t;
		46	typedef int32_t flex_int32_t;
		47	typedef uint32_t flex_uint32_t;
		48	#else
		49	typedef signed char flex_int8_t;
		50	typedef short int flex_int16_t;
		51	typedef int flex_int32_t;
		52	typedef unsigned char flex_uint8_t;
		53	typedef unsigned short int flex_uint16_t;
		54	typedef unsigned int flex_uint32_t;
		55
		56
		57	#ifndef INT8_MIN
		58	#define INT8_MIN (-128)
		59	#endif
		60	#ifndef INT16_MIN
		61	#define INT16_MIN (-32767-1)
		62	#endif
		63	#ifndef INT32_MIN
		64	#define INT32_MIN (-2147483647-1)
		65	#endif
		66	#ifndef INT8_MAX
		67	#define INT8_MAX (127)
		68	#endif
		69	#ifndef INT16_MAX
		70	#define INT16_MAX (32767)
		71	#endif
		72	#ifndef INT32_MAX
		73	#define INT32_MAX (2147483647)
		74	#endif
		75	#ifndef UINT8_MAX
		76	#define UINT8_MAX (255U)
		77	#endif
		78	#ifndef UINT16_MAX
		79	#define UINT16_MAX (65535U)
		80	#endif
		81	#ifndef UINT32_MAX
		82	#define UINT32_MAX (4294967295U)
		83	#endif
		84
		85
		86
		87
		88
		89
		90
		91
		92	#define YY_USE_CONST
		93
		94
		95
		96
		97	#if defined (__STDC__)
		98
		99
		100
		101
		102	#endif /* ! __cplusplus */
		103
		104
		105	#define yyconst const
		106	#else
		107	#define yyconst
		108	#endif
		109
		110
		111	#define YY_NULL 0
		112
		113
		114	* integer for use as an array index. If the signed char is negative,
		115	* we want to instead treat it as an 8-bit unsigned char, hence the
		116	* double cast.
		117	*/
		118	#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
		119
		120
		121	#ifndef YY_TYPEDEF_YY_SCANNER_T
		122	#define YY_TYPEDEF_YY_SCANNER_T
		123	typedef void* yyscan_t;
		124	#endif
		125
		126
		127	are macros in the reentrant scanner. */
		128	#define yyin yyg->yyin_r
		129	#define yyout yyg->yyout_r
		130	#define yyextra yyg->yyextra_r
		131	#define yyleng yyg->yyleng_r
		132	#define yytext yyg->yytext_r
		133	#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
		134	#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
		135	#define yy_flex_debug yyg->yy_flex_debug_r
		136
		137
		138	* but we do it the disgusting crufty way forced on us by the ()-less
		139	* definition of BEGIN.
		140	*/
		141	#define BEGIN yyg->yy_start = 1 + 2 *
		142
		143
		144	* to BEGIN to return to the state. The YYSTATE alias is for lex
		145	* compatibility.
		146	*/
		147	#define YY_START ((yyg->yy_start - 1) / 2)
		148	#define YYSTATE YY_START
		149
		150
		151	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
		152
		153
		154	#define YY_NEW_FILE yyrestart(yyin ,yyscanner )
		155
		156
		157
		158
		159	#ifndef YY_BUF_SIZE
		160	#ifdef __ia64__
		161	/* On IA-64, the buffer size is 16k, not 8k.
		162	* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
		163	* Ditto for the __ia64__ case accordingly.
		164	*/
		165	#define YY_BUF_SIZE 32768
		166	#else
		167	#define YY_BUF_SIZE 16384
		168	#endif /* __ia64__ */
		169	#endif
		170
		171
		172	*/
		173	#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
		174
		175
		176	#define YY_TYPEDEF_YY_BUFFER_STATE
		177	typedef struct yy_buffer_state *YY_BUFFER_STATE;
		178	#endif
		179
		180
		181	#define EOB_ACT_END_OF_FILE 1
		182	#define EOB_ACT_LAST_MATCH 2
		183
		184
		185
		186
		187	#define yyless(n) \
		188	do \
		189	{ \
		190	/* Undo effects of setting up yytext. */ \
		191	int yyless_macro_arg = (n); \
		192	YY_LESS_LINENO(yyless_macro_arg);\
		193	*yy_cp = yyg->yy_hold_char; \
		194	YY_RESTORE_YY_MORE_OFFSET \
		195	yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		196	YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		197	} \
		198	while ( 0 )
		199
		200
		201
		202
		203	#define YY_TYPEDEF_YY_SIZE_T
		204	typedef size_t yy_size_t;
		205	#endif
		206
		207
		208	#define YY_STRUCT_YY_BUFFER_STATE
		209	struct yy_buffer_state
		210	{
		211	FILE *yy_input_file;
		212
		213
		214	char yy_buf_pos; / current position in input buffer */
		215
		216
		217	* characters.
		218	*/
		219	yy_size_t yy_buf_size;
		220
		221
		222	* characters.
		223	*/
		224	int yy_n_chars;
		225
		226
		227	* and can realloc() it to grow it, and should free() it to
		228	* delete it.
		229	*/
		230	int yy_is_our_buffer;
		231
		232
		233	* if we're using stdio for input, then we want to use getc()
		234	* instead of fread(), to make sure we stop fetching input after
		235	* each newline.
		236	*/
		237	int yy_is_interactive;
		238
		239
		240	* If so, '^' rules will be active on the next match, otherwise
		241	* not.
		242	*/
		243	int yy_at_bol;
		244
		245
		246	int yy_bs_column; /*< The column count. /
		247
		248
		249	* end of it.
		250	*/
		251	int yy_fill_buffer;
		252
		253
		254
		255
		256	#define YY_BUFFER_NORMAL 1
		257	/* When an EOF's been seen but there's still some text to process
		258	* then we mark the buffer as YY_EOF_PENDING, to indicate that we
		259	* shouldn't try reading from the input source any more. We might
		260	* still have a bunch of tokens to match, though, because of
		261	* possible backing-up.
		262	*
		263	* When we actually see the EOF, we change the status to "new"
		264	* (via yyrestart()), so that the user can continue scanning by
		265	* just pointing yyin at a new input file.
		266	*/
		267	#define YY_BUFFER_EOF_PENDING 2
		268
		269
		270	#endif /* !YY_STRUCT_YY_BUFFER_STATE */
		271
		272
		273	* future we want to put the buffer states in a more general
		274	* "scanner state".
		275	*
		276	* Returns the top of the stack, or NULL.
		277	*/
		278	#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
		279	? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
		280	: NULL)
		281
		282
		283	* NULL or when we need an lvalue. For internal use only.
		284	*/
		285	#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
		286
		287
		288	void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
		289	YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
		290	void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
		291	void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
		292	void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
		293	void yypop_buffer_state (yyscan_t yyscanner );
		294
		295
		296	static void yy_load_buffer_state (yyscan_t yyscanner );
		297	static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
		298
		299
		300
		301
		302	YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
		303	YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
		304
		305
		306	void yyrealloc (void ,yy_size_t ,yyscan_t yyscanner );
		307	void yyfree (void * ,yyscan_t yyscanner );
		308
		309
		310
		311
		312	{ \
		313	if ( ! YY_CURRENT_BUFFER ){ \
		314	yyensure_buffer_stack (yyscanner); \
		315	YY_CURRENT_BUFFER_LVALUE = \
		316	yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
		317	} \
		318	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
		319	}
		320
		321
		322	{ \
		323	if ( ! YY_CURRENT_BUFFER ){\
		324	yyensure_buffer_stack (yyscanner); \
		325	YY_CURRENT_BUFFER_LVALUE = \
		326	yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
		327	} \
		328	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
		329	}
		330
		331
		332
		333
		334
		335
		336	#define YY_SKIP_YYWRAP
		337
		338
		339
		340
		341
		342
		343
		344
		345	static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
		346	static int yy_get_next_buffer (yyscan_t yyscanner );
		347	static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
		348
		349
		350	* corresponding action - sets up yytext.
		351	*/
		352	#define YY_DO_BEFORE_ACTION \
		353	yyg->yytext_ptr = yy_bp; \
		354	yyleng = (size_t) (yy_cp - yy_bp); \
		355	yyg->yy_hold_char = *yy_cp; \
		356	*yy_cp = '\0'; \
		357	yyg->yy_c_buf_p = yy_cp;
		358
		359
		360	#define YY_END_OF_BUFFER 171
		361	/* This struct is not used in this scanner,
		362	but its presence is necessary. */
		363	struct yy_trans_info
		364	{
		365	flex_int32_t yy_verify;
		366	flex_int32_t yy_nxt;
		367	};
		368	static yyconst flex_int16_t yy_accept[850] =
		369	{ 0,
		370	0, 0, 171, 169, 167, 166, 169, 169, 139, 165,
		371	141, 141, 141, 141, 139, 139, 139, 139, 139, 139,
		372	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		373	139, 139, 139, 139, 139, 167, 0, 0, 168, 139,
		374	0, 140, 142, 162, 162, 0, 0, 0, 0, 162,
		375	0, 0, 0, 0, 0, 0, 0, 119, 163, 120,
		376	121, 153, 153, 153, 153, 0, 141, 0, 127, 128,
		377	129, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		378	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		379	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		380
		381
		382	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		383	139, 139, 139, 139, 139, 139, 0, 0, 0, 0,
		384	0, 0, 0, 0, 0, 161, 0, 0, 0, 0,
		385	0, 0, 0, 0, 0, 160, 160, 0, 0, 0,
		386	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		387	159, 159, 159, 0, 0, 0, 0, 0, 0, 0,
		388	0, 0, 0, 150, 150, 150, 151, 151, 152, 143,
		389	142, 143, 0, 144, 11, 12, 139, 13, 139, 139,
		390	14, 15, 139, 16, 17, 18, 19, 20, 21, 6,
		391
		392
		393	32, 33, 34, 35, 139, 139, 139, 139, 139, 40,
		394	41, 139, 42, 43, 44, 45, 46, 47, 48, 139,
		395	49, 50, 51, 52, 53, 54, 55, 139, 56, 57,
		396	58, 59, 139, 139, 64, 65, 139, 139, 139, 139,
		397	139, 139, 0, 0, 0, 0, 142, 0, 0, 0,
		398	0, 0, 0, 0, 0, 0, 0, 80, 81, 83,
		399	0, 158, 0, 0, 0, 0, 0, 0, 97, 0,
		400	0, 0, 0, 0, 0, 0, 0, 0, 0, 157,
		401	156, 156, 109, 0, 0, 0, 0, 0, 0, 0,
		402
		403
		404	11, 139, 12, 12, 12, 139, 139, 139, 139, 139,
		405	15, 15, 139, 130, 16, 16, 139, 17, 17, 139,
		406	18, 18, 139, 19, 19, 139, 20, 20, 139, 21,
		407	21, 139, 22, 22, 139, 24, 24, 139, 25, 25,
		408	139, 28, 28, 139, 27, 27, 139, 30, 30, 139,
		409	31, 31, 139, 32, 32, 139, 33, 33, 139, 34,
		410	34, 139, 35, 35, 139, 139, 139, 139, 36, 139,
		411	38, 139, 40, 40, 139, 41, 41, 139, 131, 42,
		412	42, 139, 43, 43, 139, 139, 45, 45, 139, 46,
		413
		414
		415	49, 139, 50, 50, 139, 51, 51, 139, 52, 52,
		416	139, 53, 53, 139, 54, 54, 139, 139, 10, 56,
		417	139, 57, 139, 58, 139, 59, 139, 60, 139, 62,
		418	139, 64, 64, 139, 139, 139, 139, 139, 139, 139,
		419	139, 0, 164, 0, 0, 0, 73, 74, 0, 0,
		420	0, 0, 0, 0, 0, 85, 0, 0, 0, 0,
		421	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		422	0, 0, 0, 0, 155, 0, 0, 0, 113, 0,
		423	115, 0, 0, 0, 0, 0, 0, 154, 146, 139,
		424
		425
		426	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		427	139, 139, 139, 139, 139, 139, 9, 37, 39, 139,
		428	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		429	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		430	60, 139, 61, 62, 139, 63, 139, 139, 139, 139,
		431	139, 69, 139, 139, 0, 0, 0, 0, 0, 75,
		432	76, 0, 0, 0, 0, 84, 0, 0, 88, 91,
		433	0, 0, 0, 0, 0, 0, 0, 102, 103, 0,
		434	0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
		435
		436
		437	5, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		438	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		439	7, 8, 139, 139, 139, 139, 139, 139, 139, 139,
		440	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
		441	139, 139, 139, 139, 61, 139, 139, 63, 139, 139,
		442	139, 139, 139, 70, 139, 66, 0, 0, 0, 0,
		443	124, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		444	94, 0, 98, 99, 0, 101, 0, 0, 0, 0,
		445	0, 0, 0, 0, 0, 0, 117, 118, 0, 0,
		446
		447
		448	17, 18, 19, 20, 21, 22, 24, 25, 28, 27,
		449	30, 31, 32, 33, 34, 35, 40, 41, 42, 43,
		450	44, 45, 46, 47, 48, 139, 139, 139, 49, 50,
		451	51, 52, 53, 54, 55, 56, 57, 58, 59, 139,
		452	139, 139, 139, 64, 65, 139, 68, 126, 0, 0,
		453	71, 0, 77, 0, 0, 0, 86, 0, 0, 0,
		454	0, 0, 0, 100, 0, 0, 106, 93, 0, 0,
		455	0, 0, 0, 0, 122, 0, 139, 132, 133, 139,
		456	60, 139, 62, 139, 67, 0, 0, 0, 0, 79,
		457
		458
		459	0, 0, 0, 114, 116, 0, 139, 139, 61, 63,
		460	2, 1, 0, 78, 0, 90, 0, 96, 104, 0,
		461	0, 111, 112, 123, 139, 134, 0, 89, 0, 107,
		462	110, 139, 72, 95, 139, 139, 137, 138, 0
		463	} ;
		464
		465
		466	{ 0,
		467	1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
		468	1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
		469	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		470	1, 2, 5, 1, 6, 7, 1, 1, 1, 1,
		471	1, 1, 8, 1, 8, 9, 1, 10, 11, 12,
		472	13, 14, 15, 15, 15, 15, 15, 1, 1, 1,
		473	1, 1, 1, 1, 16, 17, 18, 19, 20, 21,
		474	22, 23, 24, 7, 25, 26, 27, 28, 29, 30,
		475	31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
		476	1, 1, 1, 1, 41, 1, 42, 43, 44, 45,
		477
		478
		479	56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
		480	66, 67, 1, 1, 1, 1, 1, 1, 1, 1,
		481	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		482	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		483	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		484	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		485	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		486	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		487	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		488
		489
		490	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		491	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		492	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		493	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		494	1, 1, 1, 1, 1
		495	} ;
		496
		497
		498	{ 0,
		499	1, 1, 1, 1, 1, 1, 2, 1, 3, 2,
		500	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		501	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		502	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		503	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		504	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		505	2, 2, 2, 2, 2, 2, 2
		506	} ;
		507
		508
		509	{ 0,
		510	0, 0, 1299, 1300, 66, 1300, 1293, 1294, 0, 69,
		511	85, 128, 140, 152, 151, 58, 56, 63, 76, 1272,
		512	158, 160, 39, 163, 173, 189, 52, 1265, 76, 1235,
		513	1234, 1246, 1230, 1244, 1243, 105, 1272, 1284, 1300, 0,
		514	225, 1300, 218, 160, 157, 20, 123, 66, 119, 192,
		515	1244, 1230, 54, 162, 1228, 1240, 194, 1300, 200, 195,
		516	98, 227, 196, 231, 235, 293, 305, 316, 1300, 1300,
		517	1300, 1249, 1262, 1256, 223, 1245, 1248, 1244, 1259, 107,
		518	298, 1241, 1255, 246, 1241, 1254, 1245, 1258, 1235, 1246,
		519	1237, 182, 1238, 1229, 1238, 1229, 1228, 1229, 144, 1223,
		520
		521
		522	302, 1230, 1217, 1231, 1207, 65, 315, 276, 1227, 1226,
		523	1202, 1187, 1182, 1199, 1175, 1180, 1206, 279, 1195, 293,
		524	1190, 342, 299, 1192, 1173, 317, 1183, 1179, 1174, 207,
		525	1180, 1166, 1182, 1179, 1170, 320, 324, 1172, 1161, 1175,
		526	1178, 1160, 1175, 1162, 1159, 1166, 284, 1174, 227, 288,
		527	327, 342, 345, 1151, 1168, 1169, 1162, 1144, 318, 1145,
		528	1167, 1158, 330, 341, 345, 349, 353, 357, 361, 1300,
		529	419, 430, 436, 442, 440, 441, 1191, 0, 1190, 1173,
		530	1163, 443, 1183, 444, 451, 468, 470, 472, 471, 0,
		531
		532
		533	526, 536, 537, 553, 1178, 1171, 1184, 354, 356, 561,
		534	563, 1165, 564, 565, 1157, 580, 590, 591, 592, 1178,
		535	593, 617, 618, 619, 629, 630, 1155, 1165, 330, 362,
		536	419, 483, 445, 364, 646, 1153, 1145, 1144, 1129, 1129,
		537	1128, 1127, 1170, 1142, 1130, 662, 669, 643, 1134, 487,
		538	1131, 1125, 1125, 1119, 1132, 1132, 1117, 1300, 1300, 1132,
		539	1120, 646, 1127, 135, 1124, 1130, 561, 1125, 1300, 1116,
		540	1123, 1122, 1125, 1111, 1110, 1114, 1109, 448, 1114, 650,
		541	653, 665, 1300, 1106, 1104, 1104, 1112, 1113, 1095, 670,
		542
		543
		544	682, 1119, 1110, 688, 730, 1117, 1116, 1109, 1123, 1113,
		545	1104, 712, 1111, 0, 1102, 731, 1109, 1100, 733, 1107,
		546	1098, 734, 1105, 1096, 736, 1103, 1094, 737, 1101, 1092,
		547	738, 1099, 1090, 739, 1097, 1088, 740, 1095, 1086, 741,
		548	1093, 1084, 742, 1091, 1082, 743, 1089, 1080, 744, 1087,
		549	1078, 745, 1085, 1076, 746, 1083, 1074, 747, 1081, 1072,
		550	748, 1079, 1070, 749, 1077, 1080, 1073, 1080, 0, 1073,
		551	0, 1088, 1063, 750, 1070, 1061, 751, 1068, 0, 1059,
		552	752, 1066, 1057, 755, 1064, 1063, 1054, 758, 1061, 1052,
		553
		554
		555	780, 1052, 1043, 782, 1050, 1041, 783, 1048, 1039, 784,
		556	1046, 1037, 785, 1044, 1035, 786, 1042, 1041, 0, 1032,
		557	1039, 1030, 1037, 1028, 1035, 1026, 1033, 787, 1032, 788,
		558	1047, 1022, 789, 1029, 1028, 1006, 1000, 1005, 1011, 994,
		559	1009, 424, 1300, 1008, 998, 1002, 1300, 1300, 992, 1001,
		560	987, 1004, 987, 990, 984, 1300, 985, 984, 981, 988,
		561	981, 989, 985, 995, 992, 974, 980, 987, 971, 970,
		562	988, 970, 982, 981, 1300, 980, 970, 974, 1300, 961,
		563	1300, 966, 966, 974, 957, 958, 968, 1300, 1300, 1000,
		564
		565
		566	991, 990, 989, 988, 987, 986, 985, 984, 983, 982,
		567	981, 980, 979, 978, 965, 958, 0, 0, 0, 975,
		568	974, 973, 972, 971, 970, 969, 968, 967, 945, 965,
		569	964, 963, 962, 961, 960, 959, 958, 957, 956, 955,
		570	929, 936, 793, 927, 934, 794, 950, 949, 918, 921,
		571	901, 0, 902, 895, 902, 901, 902, 894, 912, 1300,
		572	1300, 894, 892, 902, 895, 1300, 890, 907, 516, 1300,
		573	898, 882, 883, 892, 883, 882, 882, 1300, 881, 890,
		574	880, 896, 893, 1300, 892, 890, 879, 880, 876, 868,
		575
		576
		577	0, 886, 885, 884, 883, 882, 881, 880, 879, 878,
		578	877, 876, 875, 874, 873, 872, 871, 870, 869, 868,
		579	0, 0, 867, 866, 865, 864, 863, 862, 861, 860,
		580	859, 804, 858, 857, 856, 855, 854, 853, 852, 851,
		581	850, 849, 848, 865, 839, 846, 862, 836, 843, 841,
		582	840, 818, 818, 0, 825, 0, 859, 858, 807, 825,
		583	1300, 820, 815, 808, 804, 816, 806, 804, 800, 816,
		584	807, 806, 1300, 1300, 809, 1300, 804, 797, 786, 797,
		585	789, 793, 806, 801, 804, 786, 1300, 1300, 798, 787,
		586
		587
		588	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		589	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		590	0, 0, 0, 0, 0, 814, 813, 802, 0, 0,
		591	0, 0, 0, 0, 0, 0, 0, 0, 0, 785,
		592	798, 779, 792, 0, 0, 656, 0, 0, 706, 702,
		593	1300, 649, 1300, 648, 648, 654, 1300, 637, 645, 610,
		594	612, 608, 608, 1300, 572, 583, 1300, 1300, 577, 573,
		595	560, 557, 542, 555, 1300, 539, 573, 0, 0, 572,
		596	0, 555, 0, 546, 0, 562, 551, 495, 479, 1300,
		597
		598
		599	166, 171, 186, 1300, 1300, 211, 236, 276, 0, 0,
		600	1300, 1300, 290, 1300, 325, 1300, 346, 1300, 1300, 343,
		601	341, 1300, 1300, 1300, 365, 0, 380, 1300, 371, 1300,
		602	1300, 486, 1300, 1300, 451, 458, 0, 0, 1300, 836,
		603	503, 839
		604	} ;
		605
		606
		607	{ 0,
		608	849, 1, 849, 849, 849, 849, 849, 850, 851, 849,
		609	849, 849, 849, 849, 851, 851, 851, 851, 851, 851,
		610	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		611	851, 851, 851, 851, 851, 849, 849, 850, 849, 851,
		612	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		613	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		614	849, 849, 849, 849, 849, 852, 849, 849, 849, 849,
		615	849, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		616	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		617	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		618
		619
		620	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		621	851, 851, 851, 851, 851, 851, 849, 849, 849, 849,
		622	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		623	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		624	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		625	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		626	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		627	849, 849, 849, 849, 851, 851, 851, 851, 851, 851,
		628	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		629
		630
		631	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		632	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		633	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		634	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		635	851, 851, 849, 849, 849, 849, 849, 849, 849, 849,
		636	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		637	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		638	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		639	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		640
		641
		642	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		643	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		644	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		645	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		646	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		647	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		648	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		649	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		650	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		651
		652
		653	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		654	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		655	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		656	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		657	851, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		658	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		659	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		660	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		661	849, 849, 849, 849, 849, 849, 849, 849, 849, 851,
		662
		663
		664	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		665	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		666	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		667	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		668	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		669	851, 851, 851, 851, 849, 849, 849, 849, 849, 849,
		670	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		671	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		672	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		673
		674
		675	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		676	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		677	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		678	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		679	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		680	851, 851, 851, 851, 851, 851, 849, 849, 849, 849,
		681	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		682	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		683	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		684
		685
		686	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		687	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		688	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		689	851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
		690	851, 851, 851, 851, 851, 851, 851, 851, 849, 849,
		691	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		692	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		693	849, 849, 849, 849, 849, 849, 851, 851, 851, 851,
		694	851, 851, 851, 851, 851, 849, 849, 849, 849, 849,
		695
		696
		697	849, 849, 849, 849, 849, 849, 851, 851, 851, 851,
		698	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		699	849, 849, 849, 849, 851, 851, 849, 849, 849, 849,
		700	849, 851, 849, 849, 851, 851, 851, 851, 0, 849,
		701	849, 849
		702	} ;
		703
		704
		705	{ 0,
		706	4, 5, 6, 5, 7, 8, 9, 4, 10, 11,
		707	12, 13, 14, 11, 11, 15, 9, 16, 17, 18,
		708	19, 9, 9, 9, 20, 21, 22, 9, 23, 24,
		709	9, 25, 26, 27, 28, 9, 9, 29, 9, 9,
		710	9, 9, 9, 9, 9, 9, 30, 9, 9, 9,
		711	9, 9, 9, 9, 9, 9, 31, 9, 32, 33,
		712	34, 9, 35, 9, 9, 9, 9, 36, 96, 36,
		713	41, 116, 137, 97, 80, 138, 829, 42, 43, 43,
		714	43, 43, 43, 43, 77, 81, 78, 119, 82, 117,
		715	83, 238, 79, 66, 67, 67, 67, 67, 67, 67,
		716
		717
		718	44, 45, 46, 47, 48, 49, 50, 51, 52, 141,
		719	142, 53, 54, 55, 56, 57, 58, 59, 60, 61,
		720	68, 143, 62, 63, 64, 65, 66, 67, 67, 67,
		721	67, 67, 67, 170, 194, 195, 69, 68, 66, 67,
		722	67, 67, 67, 67, 67, 218, 171, 219, 70, 68,
		723	66, 67, 67, 67, 67, 67, 67, 72, 139, 73,
		724	71, 68, 140, 68, 144, 92, 74, 145, 98, 88,
		725	467, 89, 75, 93, 76, 68, 90, 99, 94, 91,
		726	101, 100, 102, 103, 95, 468, 830, 68, 136, 133,
		727
		728
		729	108, 109, 110, 134, 111, 133, 112, 153, 133, 211,
		730	135, 831, 113, 114, 154, 115, 41, 43, 43, 43,
		731	43, 43, 43, 146, 147, 157, 832, 132, 165, 133,
		732	166, 161, 162, 167, 168, 833, 158, 163, 188, 159,
		733	133, 169, 160, 265, 189, 164, 834, 201, 133, 174,
		734	173, 175, 176, 132, 835, 266, 128, 129, 46, 47,
		735	48, 49, 172, 51, 52, 202, 285, 53, 54, 55,
		736	56, 57, 58, 130, 60, 61, 286, 243, 131, 244,
		737	173, 173, 173, 173, 177, 173, 173, 178, 179, 173,
		738
		739
		740	196, 197, 182, 66, 67, 67, 67, 67, 67, 67,
		741	198, 232, 229, 183, 68, 184, 184, 184, 184, 184,
		742	184, 240, 134, 241, 255, 233, 282, 287, 182, 135,
		743	258, 258, 283, 288, 242, 837, 258, 430, 164, 256,
		744	68, 257, 257, 257, 257, 257, 257, 258, 258, 258,
		745	261, 258, 258, 298, 258, 272, 258, 258, 258, 258,
		746	431, 258, 381, 299, 258, 258, 379, 838, 258, 432,
		747	440, 289, 258, 290, 258, 258, 291, 292, 380, 258,
		748	382, 839, 258, 303, 303, 303, 303, 840, 441, 841,
		749
		750
		751	303, 305, 306, 303, 303, 303, 303, 303, 303, 303,
		752	307, 303, 303, 303, 303, 303, 303, 303, 43, 43,
		753	43, 43, 43, 43, 843, 844, 434, 308, 132, 309,
		754	309, 309, 309, 309, 309, 184, 184, 184, 184, 184,
		755	184, 184, 184, 184, 184, 184, 184, 310, 313, 435,
		756	321, 325, 311, 314, 132, 322, 326, 438, 328, 847,
		757	565, 311, 315, 329, 322, 326, 848, 311, 314, 439,
		758	312, 316, 329, 323, 327, 331, 566, 334, 340, 337,
		759	332, 330, 335, 341, 338, 482, 845, 846, 483, 332,
		760
		761
		762	336, 342, 339, 343, 346, 349, 352, 355, 344, 347,
		763	350, 353, 356, 437, 827, 826, 825, 344, 347, 350,
		764	353, 356, 455, 824, 347, 350, 345, 348, 351, 354,
		765	357, 358, 361, 364, 823, 456, 359, 362, 365, 498,
		766	498, 498, 498, 367, 370, 359, 362, 365, 368, 371,
		767	822, 359, 362, 365, 360, 363, 366, 368, 371, 678,
		768	373, 821, 679, 368, 371, 374, 369, 372, 383, 820,
		769	386, 390, 393, 384, 374, 387, 391, 394, 819, 818,
		770	374, 817, 384, 375, 387, 391, 394, 397, 816, 815,
		771
		772
		773	410, 398, 401, 404, 407, 411, 813, 398, 812, 472,
		774	399, 401, 404, 407, 411, 811, 810, 401, 404, 407,
		775	402, 405, 408, 412, 413, 416, 419, 809, 808, 414,
		776	417, 420, 498, 498, 498, 498, 422, 425, 414, 417,
		777	420, 423, 426, 807, 414, 417, 420, 415, 418, 421,
		778	423, 426, 806, 442, 805, 804, 423, 426, 443, 424,
		779	427, 257, 257, 257, 257, 257, 257, 443, 257, 257,
		780	257, 257, 257, 257, 453, 453, 444, 453, 453, 803,
		781	453, 453, 453, 453, 453, 453, 802, 453, 801, 310,
		782
		783
		784	797, 453, 453, 492, 796, 493, 795, 494, 499, 498,
		785	498, 498, 312, 453, 498, 498, 498, 498, 316, 321,
		786	495, 498, 498, 498, 498, 309, 309, 309, 309, 309,
		787	309, 309, 309, 309, 309, 309, 309, 313, 325, 501,
		788	328, 331, 323, 334, 337, 340, 343, 346, 349, 352,
		789	355, 358, 361, 364, 367, 370, 373, 383, 386, 390,
		790	316, 327, 393, 330, 333, 397, 336, 339, 342, 345,
		791	348, 351, 354, 357, 360, 363, 366, 369, 372, 375,
		792	385, 388, 392, 400, 403, 395, 406, 410, 399, 413,
		793
		794
		795	655, 658, 793, 792, 736, 737, 402, 405, 791, 408,
		796	412, 790, 415, 418, 421, 424, 427, 552, 555, 444,
		797	610, 789, 788, 656, 659, 738, 38, 38, 38, 180,
		798	180, 787, 786, 785, 784, 783, 782, 781, 780, 779,
		799	778, 777, 776, 775, 774, 773, 772, 771, 770, 769,
		800	768, 767, 766, 765, 764, 763, 762, 761, 760, 759,
		801	758, 757, 756, 755, 754, 753, 659, 752, 751, 656,
		802	750, 749, 748, 747, 746, 745, 744, 743, 742, 741,
		803	740, 739, 735, 734, 733, 732, 731, 730, 729, 728,
		804
		805
		806	717, 716, 715, 714, 713, 712, 711, 710, 709, 708,
		807	707, 706, 705, 704, 703, 702, 701, 700, 699, 698,
		808	697, 696, 695, 694, 693, 692, 691, 690, 689, 688,
		809	687, 686, 685, 684, 683, 682, 681, 680, 677, 676,
		810	675, 674, 673, 672, 671, 670, 669, 668, 667, 666,
		811	665, 664, 663, 662, 661, 660, 657, 555, 654, 552,
		812	653, 652, 651, 650, 649, 648, 647, 646, 645, 644,
		813	643, 642, 641, 640, 639, 638, 637, 636, 635, 634,
		814	633, 632, 631, 630, 629, 628, 627, 626, 625, 624,
		815
		816
		817	613, 612, 611, 607, 606, 605, 604, 603, 602, 601,
		818	600, 599, 598, 597, 596, 595, 594, 593, 592, 591,
		819	590, 589, 588, 587, 586, 585, 584, 583, 582, 581,
		820	580, 579, 578, 577, 576, 575, 574, 573, 572, 571,
		821	570, 569, 568, 567, 564, 563, 562, 561, 560, 559,
		822	558, 557, 444, 556, 553, 550, 437, 549, 435, 548,
		823	433, 547, 431, 546, 545, 427, 544, 424, 543, 421,
		824	542, 418, 541, 415, 540, 412, 539, 538, 408, 537,
		825	405, 536, 402, 535, 399, 534, 533, 395, 532, 392,
		826
		827
		828	375, 523, 372, 522, 369, 521, 366, 520, 363, 519,
		829	360, 518, 357, 517, 354, 516, 351, 515, 348, 514,
		830	345, 513, 342, 512, 339, 511, 336, 510, 333, 509,
		831	330, 508, 327, 507, 323, 506, 505, 504, 503, 502,
		832	316, 500, 312, 497, 496, 491, 490, 489, 488, 487,
		833	486, 484, 481, 480, 479, 478, 477, 476, 475, 474,
		834	473, 470, 469, 466, 465, 464, 463, 462, 461, 460,
		835	459, 458, 457, 454, 289, 261, 452, 451, 450, 449,
		836	448, 447, 446, 445, 429, 428, 409, 396, 389, 378,
		837
		838
		839	297, 296, 295, 294, 293, 284, 281, 280, 279, 278,
		840	277, 276, 275, 274, 273, 271, 270, 269, 268, 267,
		841	264, 263, 262, 260, 259, 172, 254, 253, 252, 251,
		842	250, 249, 248, 247, 246, 245, 237, 236, 235, 234,
		843	231, 230, 227, 226, 225, 224, 223, 222, 221, 220,
		844	217, 216, 215, 214, 213, 212, 209, 208, 207, 206,
		845	205, 204, 203, 200, 199, 193, 192, 191, 190, 187,
		846	186, 185, 156, 155, 149, 148, 39, 127, 126, 125,
		847	124, 123, 122, 121, 118, 87, 39, 37, 849, 3,
		848
		849
		850	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		851	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		852	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		853	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		854	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		855	849, 849, 849, 849, 849, 849, 849
		856	} ;
		857
		858
		859	{ 0,
		860	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		861	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		862	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		863	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		864	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		865	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		866	1, 1, 1, 1, 1, 1, 1, 5, 23, 5,
		867	10, 27, 46, 23, 17, 46, 808, 10, 10, 10,
		868	10, 10, 10, 10, 16, 17, 16, 29, 17, 27,
		869	18, 116, 16, 11, 11, 11, 11, 11, 11, 11,
		870
		871
		872	10, 10, 10, 10, 10, 10, 10, 10, 10, 48,
		873	48, 10, 10, 10, 10, 10, 10, 10, 10, 10,
		874	11, 48, 10, 10, 10, 10, 12, 12, 12, 12,
		875	12, 12, 12, 61, 80, 80, 12, 12, 13, 13,
		876	13, 13, 13, 13, 13, 99, 61, 99, 13, 13,
		877	14, 14, 14, 14, 14, 14, 14, 15, 47, 15,
		878	14, 14, 47, 12, 49, 22, 15, 49, 24, 21,
		879	274, 21, 15, 22, 15, 13, 21, 24, 22, 21,
		880	25, 24, 25, 25, 22, 274, 810, 14, 45, 45,
		881
		882
		883	26, 26, 26, 44, 26, 45, 26, 54, 44, 92,
		884	44, 811, 26, 26, 54, 26, 41, 43, 43, 43,
		885	43, 43, 43, 50, 50, 57, 812, 43, 60, 50,
		886	60, 59, 59, 60, 60, 813, 57, 59, 75, 57,
		887	50, 60, 57, 140, 75, 59, 816, 84, 59, 63,
		888	63, 63, 63, 43, 817, 140, 41, 41, 41, 41,
		889	41, 41, 62, 41, 41, 84, 159, 41, 41, 41,
		890	41, 41, 41, 41, 41, 41, 159, 118, 41, 118,
		891	62, 62, 62, 62, 64, 64, 64, 64, 65, 65,
		892
		893
		894	81, 81, 66, 67, 67, 67, 67, 67, 67, 67,
		895	81, 111, 108, 68, 67, 68, 68, 68, 68, 68,
		896	68, 117, 128, 117, 130, 111, 157, 160, 66, 128,
		897	133, 133, 157, 160, 117, 823, 133, 239, 130, 132,
		898	67, 132, 132, 132, 132, 132, 132, 133, 136, 136,
		899	136, 146, 146, 169, 136, 147, 147, 146, 161, 161,
		900	239, 147, 219, 169, 161, 136, 218, 825, 146, 240,
		901	244, 161, 147, 162, 162, 161, 163, 163, 218, 162,
		902	219, 827, 163, 173, 173, 173, 173, 830, 244, 831,
		903
		904
		905	175, 175, 176, 176, 176, 176, 177, 177, 177, 177,
		906	178, 178, 178, 178, 179, 179, 179, 179, 181, 181,
		907	181, 181, 181, 181, 837, 839, 241, 182, 181, 182,
		908	182, 182, 182, 182, 182, 183, 183, 183, 183, 183,
		909	183, 184, 184, 184, 184, 184, 184, 185, 186, 241,
		910	192, 194, 185, 186, 181, 192, 194, 243, 195, 845,
		911	452, 185, 186, 195, 192, 194, 846, 185, 186, 243,
		912	185, 186, 195, 192, 194, 196, 452, 197, 199, 198,
		913	196, 195, 197, 199, 198, 288, 842, 842, 288, 196,
		914
		915
		916	197, 199, 198, 201, 203, 204, 206, 207, 201, 203,
		917	204, 206, 207, 242, 806, 804, 803, 201, 203, 204,
		918	206, 207, 260, 799, 203, 204, 201, 203, 204, 206,
		919	207, 209, 210, 211, 798, 260, 209, 210, 211, 303,
		920	303, 303, 303, 212, 213, 209, 210, 211, 212, 213,
		921	797, 209, 210, 211, 209, 210, 211, 212, 213, 579,
		922	214, 796, 579, 212, 213, 214, 212, 213, 220, 794,
		923	221, 223, 224, 220, 214, 221, 223, 224, 792, 790,
		924	214, 787, 220, 214, 221, 223, 224, 226, 786, 784,
		925
		926
		927	231, 226, 227, 228, 229, 231, 782, 226, 781, 277,
		928	226, 227, 228, 229, 231, 780, 779, 227, 228, 229,
		929	227, 228, 229, 231, 232, 233, 234, 776, 775, 232,
		930	233, 234, 304, 304, 304, 304, 235, 236, 232, 233,
		931	234, 235, 236, 773, 232, 233, 234, 232, 233, 234,
		932	235, 236, 772, 245, 771, 770, 235, 236, 245, 235,
		933	236, 256, 256, 256, 256, 256, 256, 245, 257, 257,
		934	257, 257, 257, 257, 258, 258, 245, 272, 272, 769,
		935	258, 290, 290, 272, 291, 291, 768, 290, 766, 311,
		936
		937
		938	760, 291, 292, 300, 759, 300, 756, 300, 305, 305,
		939	305, 305, 311, 292, 306, 306, 306, 306, 314, 322,
		940	300, 307, 307, 307, 307, 308, 308, 308, 308, 308,
		941	308, 309, 309, 309, 309, 309, 309, 315, 326, 315,
		942	329, 332, 322, 335, 338, 341, 344, 347, 350, 353,
		943	356, 359, 362, 365, 368, 371, 374, 384, 387, 391,
		944	315, 326, 394, 329, 332, 398, 335, 338, 341, 344,
		945	347, 350, 353, 356, 359, 362, 365, 368, 371, 374,
		946	384, 387, 391, 401, 404, 394, 407, 411, 398, 414,
		947
		948
		949	553, 556, 752, 751, 642, 642, 401, 404, 750, 407,
		950	411, 738, 414, 417, 420, 423, 426, 438, 440, 443,
		951	504, 737, 736, 553, 556, 642, 850, 850, 850, 852,
		952	852, 707, 700, 699, 696, 695, 694, 693, 692, 691,
		953	690, 689, 688, 687, 685, 682, 681, 680, 679, 678,
		954	677, 676, 675, 674, 673, 672, 670, 669, 668, 667,
		955	665, 663, 662, 661, 660, 659, 658, 657, 656, 655,
		956	654, 653, 652, 651, 650, 649, 648, 647, 646, 645,
		957	644, 643, 641, 640, 639, 638, 637, 636, 635, 634,
		958
		959
		960	621, 620, 619, 618, 617, 616, 615, 614, 613, 612,
		961	610, 609, 608, 607, 606, 605, 604, 603, 602, 601,
		962	600, 599, 598, 597, 596, 595, 593, 592, 591, 590,
		963	589, 587, 586, 585, 584, 583, 582, 581, 578, 577,
		964	575, 574, 573, 572, 569, 568, 567, 566, 565, 564,
		965	563, 561, 560, 559, 558, 557, 555, 554, 552, 551,
		966	550, 549, 548, 547, 546, 545, 544, 543, 542, 541,
		967	540, 539, 538, 537, 536, 535, 534, 533, 532, 531,
		968	530, 526, 525, 524, 523, 522, 521, 520, 519, 518,
		969
		970
		971	507, 506, 505, 502, 501, 500, 497, 496, 495, 494,
		972	493, 492, 490, 488, 487, 486, 484, 483, 482, 481,
		973	480, 479, 478, 477, 476, 475, 474, 473, 472, 471,
		974	470, 469, 468, 467, 465, 464, 463, 462, 461, 460,
		975	459, 456, 455, 454, 451, 450, 449, 448, 447, 446,
		976	445, 444, 442, 441, 439, 437, 436, 435, 434, 433,
		977	432, 431, 430, 428, 427, 425, 424, 422, 421, 419,
		978	418, 416, 415, 413, 412, 410, 409, 408, 406, 405,
		979	403, 402, 400, 399, 397, 396, 395, 393, 392, 390,
		980
		981
		982	373, 372, 370, 369, 367, 366, 364, 363, 361, 360,
		983	358, 357, 355, 354, 352, 351, 349, 348, 346, 345,
		984	343, 342, 340, 339, 337, 336, 334, 333, 331, 330,
		985	328, 327, 325, 323, 321, 320, 319, 318, 317, 316,
		986	313, 312, 310, 302, 301, 299, 298, 297, 296, 295,
		987	294, 289, 287, 286, 285, 284, 283, 282, 281, 280,
		988	278, 276, 275, 273, 271, 270, 267, 266, 265, 264,
		989	263, 262, 261, 259, 255, 254, 253, 252, 251, 250,
		990	249, 248, 247, 246, 238, 237, 230, 225, 222, 217,
		991
		992
		993	168, 167, 166, 165, 164, 158, 156, 155, 154, 153,
		994	152, 151, 150, 149, 148, 145, 144, 143, 142, 141,
		995	139, 138, 137, 135, 134, 131, 129, 127, 126, 125,
		996	124, 123, 122, 121, 120, 119, 115, 114, 113, 112,
		997	110, 109, 107, 106, 105, 104, 103, 102, 101, 100,
		998	98, 97, 96, 95, 94, 93, 91, 90, 89, 88,
		999	87, 86, 85, 83, 82, 79, 78, 77, 76, 74,
		1000	73, 72, 56, 55, 52, 51, 38, 37, 35, 34,
		1001	33, 32, 31, 30, 28, 20, 8, 7, 3, 849,
		1002
		1003
		1004	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		1005	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		1006	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		1007	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		1008	849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
		1009	849, 849, 849, 849, 849, 849, 849
		1010	} ;
		1011
		1012
		1013	* any uses of REJECT which flex missed.
		1014	*/
		1015	#define REJECT reject_used_but_not_detected
		1016	#define yymore() yymore_used_but_not_detected
		1017	#define YY_MORE_ADJ 0
		1018	#define YY_RESTORE_YY_MORE_OFFSET
		1019	#line 1 "program_lexer.l"
		1020	#line 2 "program_lexer.l"
		1021	/*
		1022	* Copyright © 2009 Intel Corporation
		1023	*
		1024	* Permission is hereby granted, free of charge, to any person obtaining a
		1025	* copy of this software and associated documentation files (the "Software"),
		1026	* to deal in the Software without restriction, including without limitation
		1027	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		1028	* and/or sell copies of the Software, and to permit persons to whom the
		1029	* Software is furnished to do so, subject to the following conditions:
		1030	*
		1031	* The above copyright notice and this permission notice (including the next
		1032	* paragraph) shall be included in all copies or substantial portions of the
		1033	* Software.
		1034	*
		1035	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		1036	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		1037	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		1038	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		1039	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
		1040	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
		1041	* DEALINGS IN THE SOFTWARE.
		1042	*/
		1043	#include "main/glheader.h"
		1044	#include "main/imports.h"
		1045	#include "program/prog_instruction.h"
		1046	#include "program/prog_statevars.h"
		1047	#include "program/symbol_table.h"
		1048	#include "program/program_parser.h"
		1049	#include "program/program_parse.tab.h"
		1050
		1051
		1052	#define require_ARB_fp (yyextra->mode == ARB_fragment)
		1053	#define require_NV_fp (yyextra->option.NV_fragment)
		1054	#define require_shadow (yyextra->option.Shadow)
		1055	#define require_rect (yyextra->option.TexRect)
		1056	#define require_texarray (yyextra->option.TexArray)
		1057
		1058
		1059	#define YY_NO_UNISTD_H
		1060	#endif
		1061
		1062
		1063	do { \
		1064	if (condition) { \
		1065	return token; \
		1066	} else { \
		1067	return handle_ident(yyextra, yytext, yylval); \
		1068	} \
		1069	} while (0)
		1070
		1071
		1072	do { \
		1073	if (condition) { \
		1074	return token; \
		1075	} else { \
		1076	yyless(1); \
		1077	return DOT; \
		1078	} \
		1079	} while (0)
		1080
		1081
		1082
		1083	do { \
		1084	if (condition && \
		1085	_mesa_parse_instruction_suffix(yyextra, \
		1086	yytext + len, \
		1087	& yylval->temp_inst)) { \
		1088	yylval->temp_inst.Opcode = OPCODE_ ## opcode; \
		1089	return token; \
		1090	} else { \
		1091	return handle_ident(yyextra, yytext, yylval); \
		1092	} \
		1093	} while (0)
		1094
		1095
		1096	SWIZZLE_NIL, SWIZZLE_NIL)
		1097
		1098
		1099	mask_from_char(char c)
		1100	{
		1101	switch (c) {
		1102	case 'x':
		1103	case 'r':
		1104	return WRITEMASK_X;
		1105	case 'y':
		1106	case 'g':
		1107	return WRITEMASK_Y;
		1108	case 'z':
		1109	case 'b':
		1110	return WRITEMASK_Z;
		1111	case 'w':
		1112	case 'a':
		1113	return WRITEMASK_W;
		1114	}
		1115
		1116
		1117	}
		1118
		1119
		1120	swiz_from_char(char c)
		1121	{
		1122	switch (c) {
		1123	case 'x':
		1124	case 'r':
		1125	return SWIZZLE_X;
		1126	case 'y':
		1127	case 'g':
		1128	return SWIZZLE_Y;
		1129	case 'z':
		1130	case 'b':
		1131	return SWIZZLE_Z;
		1132	case 'w':
		1133	case 'a':
		1134	return SWIZZLE_W;
		1135	}
		1136
		1137
		1138	}
		1139
		1140
		1141	handle_ident(struct asm_parser_state state, const char text, YYSTYPE *lval)
		1142	{
		1143	lval->string = strdup(text);
		1144
		1145
		1146	? IDENTIFIER : USED_IDENTIFIER;
		1147	}
		1148
		1149
		1150	do { \
		1151	yylloc->first_column = yylloc->last_column; \
		1152	yylloc->last_column += yyleng; \
		1153	if ((yylloc->first_line == 1) \
		1154	&& (yylloc->first_column == 1)) { \
		1155	yylloc->position = 1; \
		1156	} else { \
		1157	yylloc->position += yylloc->last_column - yylloc->first_column; \
		1158	} \
		1159	} while(0);
		1160
		1161
		1162
		1163
		1164	here only to avoid the compiler complaining about an unput function
		1165	that is defined, but never called. */
		1166	#define YY_USER_INIT while (0) { unput(0); }
		1167
		1168
		1169
		1170
		1171	static keyword. Declare them here to avoid a compiler warning. */
		1172	int yyget_column (yyscan_t yyscanner);
		1173	void yyset_column (int column_no , yyscan_t yyscanner);
		1174
		1175
		1176
		1177
		1178
		1179
		1180	/* Special case for "unistd.h", since it is non-ANSI. We include it way
		1181	* down here because we want the user's section 1 to have been scanned first.
		1182	* The user has a chance to override it with an option.
		1183	*/
		1184	#include
		1185	#endif
		1186
		1187
		1188	#define YY_EXTRA_TYPE void *
		1189	#endif
		1190
		1191
		1192	struct yyguts_t
		1193	{
		1194
		1195
		1196	YY_EXTRA_TYPE yyextra_r;
		1197
		1198
		1199	FILE yyin_r, yyout_r;
		1200	size_t yy_buffer_stack_top; /*< index of top of stack. /
		1201	size_t yy_buffer_stack_max; /*< capacity of stack. /
		1202	YY_BUFFER_STATE * yy_buffer_stack; /*< Stack as an array. /
		1203	char yy_hold_char;
		1204	int yy_n_chars;
		1205	int yyleng_r;
		1206	char *yy_c_buf_p;
		1207	int yy_init;
		1208	int yy_start;
		1209	int yy_did_buffer_switch_on_eof;
		1210	int yy_start_stack_ptr;
		1211	int yy_start_stack_depth;
		1212	int *yy_start_stack;
		1213	yy_state_type yy_last_accepting_state;
		1214	char* yy_last_accepting_cpos;
		1215
		1216
		1217	int yy_flex_debug_r;
		1218
		1219
		1220	int yy_more_flag;
		1221	int yy_more_len;
		1222
		1223
		1224
		1225
		1226
		1227
		1228
		1229
		1230
		1231
		1232	* from bison output in section 1.*/
		1233	# define yylval yyg->yylval_r
		1234
		1235
		1236
		1237
		1238
		1239
		1240
		1241
		1242	These are made visible to non-reentrant scanners for convenience. */
		1243
		1244
		1245
		1246
		1247
		1248
		1249
		1250
		1251
		1252
		1253
		1254
		1255
		1256
		1257
		1258
		1259
		1260
		1261
		1262
		1263
		1264
		1265
		1266
		1267
		1268
		1269
		1270
		1271
		1272
		1273
		1274
		1275
		1276
		1277
		1278
		1279	* section 1.
		1280	*/
		1281
		1282
		1283	#ifdef __cplusplus
		1284	extern "C" int yywrap (yyscan_t yyscanner );
		1285	#else
		1286	extern int yywrap (yyscan_t yyscanner );
		1287	#endif
		1288	#endif
		1289
		1290
		1291
		1292
		1293	static void yy_flex_strncpy (char ,yyconst char ,int ,yyscan_t yyscanner);
		1294	#endif
		1295
		1296
		1297	static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
		1298	#endif
		1299
		1300
		1301
		1302
		1303	static int yyinput (yyscan_t yyscanner );
		1304	#else
		1305	static int input (yyscan_t yyscanner );
		1306	#endif
		1307
		1308
		1309
		1310
		1311	#ifndef YY_READ_BUF_SIZE
		1312	#ifdef __ia64__
		1313	/* On IA-64, the buffer size is 16k, not 8k */
		1314	#define YY_READ_BUF_SIZE 16384
		1315	#else
		1316	#define YY_READ_BUF_SIZE 8192
		1317	#endif /* __ia64__ */
		1318	#endif
		1319
		1320
		1321	#ifndef ECHO
		1322	/* This used to be an fputs(), but since the string might contain NUL's,
		1323	* we now use fwrite().
		1324	*/
		1325	#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
		1326	#endif
		1327
		1328
		1329	* is returned in "result".
		1330	*/
		1331	#ifndef YY_INPUT
		1332	#define YY_INPUT(buf,result,max_size) \
		1333	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		1334	{ \
		1335	int c = '*'; \
		1336	size_t n; \
		1337	for ( n = 0; n < max_size && \
		1338	(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
		1339	buf[n] = (char) c; \
		1340	if ( c == '\n' ) \
		1341	buf[n++] = (char) c; \
		1342	if ( c == EOF && ferror( yyin ) ) \
		1343	YY_FATAL_ERROR( "input in flex scanner failed" ); \
		1344	result = n; \
		1345	} \
		1346	else \
		1347	{ \
		1348	errno=0; \
		1349	while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
		1350	{ \
		1351	if( errno != EINTR) \
		1352	{ \
		1353	YY_FATAL_ERROR( "input in flex scanner failed" ); \
		1354	break; \
		1355	} \
		1356	errno=0; \
		1357	clearerr(yyin); \
		1358	} \
		1359	}\
		1360	\
		1361
		1362
		1363
		1364
		1365	* we don't want an extra ';' after the "return" because that will cause
		1366	* some compilers to complain about unreachable statements.
		1367	*/
		1368	#ifndef yyterminate
		1369	#define yyterminate() return YY_NULL
		1370	#endif
		1371
		1372
		1373	#ifndef YY_START_STACK_INCR
		1374	#define YY_START_STACK_INCR 25
		1375	#endif
		1376
		1377
		1378	#ifndef YY_FATAL_ERROR
		1379	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
		1380	#endif
		1381
		1382
		1383
		1384
		1385	* easily add parameters.
		1386	*/
		1387	#ifndef YY_DECL
		1388	#define YY_DECL_IS_OURS 1
		1389
		1390
		1391	(YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
		1392
		1393
		1394	(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
		1395	#endif /* !YY_DECL */
		1396
		1397
		1398	* have been set up.
		1399	*/
		1400	#ifndef YY_USER_ACTION
		1401	#define YY_USER_ACTION
		1402	#endif
		1403
		1404
		1405	#ifndef YY_BREAK
		1406	#define YY_BREAK break;
		1407	#endif
		1408
		1409
		1410	YY_USER_ACTION
		1411
		1412
		1413	*/
		1414	YY_DECL
		1415	{
		1416	register yy_state_type yy_current_state;
		1417	register char yy_cp, yy_bp;
		1418	register int yy_act;
		1419	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		1420
		1421
		1422
		1423
		1424
		1425
		1426
		1427
		1428
		1429
		1430
		1431	{
		1432	yyg->yy_init = 1;
		1433
		1434
		1435	YY_USER_INIT;
		1436	#endif
		1437
		1438
		1439	yyg->yy_start = 1; /* first start state */
		1440
		1441
		1442	yyin = stdin;
		1443
		1444
		1445	yyout = stdout;
		1446
		1447
		1448	yyensure_buffer_stack (yyscanner);
		1449	YY_CURRENT_BUFFER_LVALUE =
		1450	yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
		1451	}
		1452
		1453
		1454	}
		1455
		1456
		1457	{
		1458	yy_cp = yyg->yy_c_buf_p;
		1459
		1460
		1461	*yy_cp = yyg->yy_hold_char;
		1462
		1463
		1464	* the current run.
		1465	*/
		1466	yy_bp = yy_cp;
		1467
		1468
		1469	yy_match:
		1470	do
		1471	{
		1472	register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
		1473	if ( yy_accept[yy_current_state] )
		1474	{
		1475	yyg->yy_last_accepting_state = yy_current_state;
		1476	yyg->yy_last_accepting_cpos = yy_cp;
		1477	}
		1478	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		1479	{
		1480	yy_current_state = (int) yy_def[yy_current_state];
		1481	if ( yy_current_state >= 850 )
		1482	yy_c = yy_meta[(unsigned int) yy_c];
		1483	}
		1484	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
		1485	++yy_cp;
		1486	}
		1487	while ( yy_base[yy_current_state] != 1300 );
		1488
		1489
		1490	yy_act = yy_accept[yy_current_state];
		1491	if ( yy_act == 0 )
		1492	{ /* have to back up */
		1493	yy_cp = yyg->yy_last_accepting_cpos;
		1494	yy_current_state = yyg->yy_last_accepting_state;
		1495	yy_act = yy_accept[yy_current_state];
		1496	}
		1497
		1498
		1499
		1500
		1501
		1502
		1503	{ /* beginning of action switch */
		1504	case 0: /* must back up */
		1505	/* undo the effects of YY_DO_BEFORE_ACTION */
		1506	*yy_cp = yyg->yy_hold_char;
		1507	yy_cp = yyg->yy_last_accepting_cpos;
		1508	yy_current_state = yyg->yy_last_accepting_state;
		1509	goto yy_find_action;
		1510
		1511
		1512	YY_RULE_SETUP
		1513	#line 171 "program_lexer.l"
		1514	{ return ARBvp_10; }
		1515	YY_BREAK
		1516	case 2:
		1517	YY_RULE_SETUP
		1518	#line 172 "program_lexer.l"
		1519	{ return ARBfp_10; }
		1520	YY_BREAK
		1521	case 3:
		1522	YY_RULE_SETUP
		1523	#line 173 "program_lexer.l"
		1524	{
		1525	yylval->integer = at_address;
		1526	return_token_or_IDENTIFIER(require_ARB_vp, ADDRESS);
		1527	}
		1528	YY_BREAK
		1529	case 4:
		1530	YY_RULE_SETUP
		1531	#line 177 "program_lexer.l"
		1532	{ return ALIAS; }
		1533	YY_BREAK
		1534	case 5:
		1535	YY_RULE_SETUP
		1536	#line 178 "program_lexer.l"
		1537	{ return ATTRIB; }
		1538	YY_BREAK
		1539	case 6:
		1540	YY_RULE_SETUP
		1541	#line 179 "program_lexer.l"
		1542	{ return END; }
		1543	YY_BREAK
		1544	case 7:
		1545	YY_RULE_SETUP
		1546	#line 180 "program_lexer.l"
		1547	{ return OPTION; }
		1548	YY_BREAK
		1549	case 8:
		1550	YY_RULE_SETUP
		1551	#line 181 "program_lexer.l"
		1552	{ return OUTPUT; }
		1553	YY_BREAK
		1554	case 9:
		1555	YY_RULE_SETUP
		1556	#line 182 "program_lexer.l"
		1557	{ return PARAM; }
		1558	YY_BREAK
		1559	case 10:
		1560	YY_RULE_SETUP
		1561	#line 183 "program_lexer.l"
		1562	{ yylval->integer = at_temp; return TEMP; }
		1563	YY_BREAK
		1564	case 11:
		1565	YY_RULE_SETUP
		1566	#line 185 "program_lexer.l"
		1567	{ return_opcode( 1, VECTOR_OP, ABS, 3); }
		1568	YY_BREAK
		1569	case 12:
		1570	YY_RULE_SETUP
		1571	#line 186 "program_lexer.l"
		1572	{ return_opcode( 1, BIN_OP, ADD, 3); }
		1573	YY_BREAK
		1574	case 13:
		1575	YY_RULE_SETUP
		1576	#line 187 "program_lexer.l"
		1577	{ return_opcode(require_ARB_vp, ARL, ARL, 3); }
		1578	YY_BREAK
		1579	case 14:
		1580	YY_RULE_SETUP
		1581	#line 189 "program_lexer.l"
		1582	{ return_opcode(require_ARB_fp, TRI_OP, CMP, 3); }
		1583	YY_BREAK
		1584	case 15:
		1585	YY_RULE_SETUP
		1586	#line 190 "program_lexer.l"
		1587	{ return_opcode(require_ARB_fp, SCALAR_OP, COS, 3); }
		1588	YY_BREAK
		1589	case 16:
		1590	YY_RULE_SETUP
		1591	#line 192 "program_lexer.l"
		1592	{ return_opcode(require_NV_fp, VECTOR_OP, DDX, 3); }
		1593	YY_BREAK
		1594	case 17:
		1595	YY_RULE_SETUP
		1596	#line 193 "program_lexer.l"
		1597	{ return_opcode(require_NV_fp, VECTOR_OP, DDY, 3); }
		1598	YY_BREAK
		1599	case 18:
		1600	YY_RULE_SETUP
		1601	#line 194 "program_lexer.l"
		1602	{ return_opcode( 1, BIN_OP, DP3, 3); }
		1603	YY_BREAK
		1604	case 19:
		1605	YY_RULE_SETUP
		1606	#line 195 "program_lexer.l"
		1607	{ return_opcode( 1, BIN_OP, DP4, 3); }
		1608	YY_BREAK
		1609	case 20:
		1610	YY_RULE_SETUP
		1611	#line 196 "program_lexer.l"
		1612	{ return_opcode( 1, BIN_OP, DPH, 3); }
		1613	YY_BREAK
		1614	case 21:
		1615	YY_RULE_SETUP
		1616	#line 197 "program_lexer.l"
		1617	{ return_opcode( 1, BIN_OP, DST, 3); }
		1618	YY_BREAK
		1619	case 22:
		1620	YY_RULE_SETUP
		1621	#line 199 "program_lexer.l"
		1622	{ return_opcode( 1, SCALAR_OP, EX2, 3); }
		1623	YY_BREAK
		1624	case 23:
		1625	YY_RULE_SETUP
		1626	#line 200 "program_lexer.l"
		1627	{ return_opcode(require_ARB_vp, SCALAR_OP, EXP, 3); }
		1628	YY_BREAK
		1629	case 24:
		1630	YY_RULE_SETUP
		1631	#line 202 "program_lexer.l"
		1632	{ return_opcode( 1, VECTOR_OP, FLR, 3); }
		1633	YY_BREAK
		1634	case 25:
		1635	YY_RULE_SETUP
		1636	#line 203 "program_lexer.l"
		1637	{ return_opcode( 1, VECTOR_OP, FRC, 3); }
		1638	YY_BREAK
		1639	case 26:
		1640	YY_RULE_SETUP
		1641	#line 205 "program_lexer.l"
		1642	{ return_opcode(require_ARB_fp, KIL, KIL, 3); }
		1643	YY_BREAK
		1644	case 27:
		1645	YY_RULE_SETUP
		1646	#line 207 "program_lexer.l"
		1647	{ return_opcode( 1, VECTOR_OP, LIT, 3); }
		1648	YY_BREAK
		1649	case 28:
		1650	YY_RULE_SETUP
		1651	#line 208 "program_lexer.l"
		1652	{ return_opcode( 1, SCALAR_OP, LG2, 3); }
		1653	YY_BREAK
		1654	case 29:
		1655	YY_RULE_SETUP
		1656	#line 209 "program_lexer.l"
		1657	{ return_opcode(require_ARB_vp, SCALAR_OP, LOG, 3); }
		1658	YY_BREAK
		1659	case 30:
		1660	YY_RULE_SETUP
		1661	#line 210 "program_lexer.l"
		1662	{ return_opcode(require_ARB_fp, TRI_OP, LRP, 3); }
		1663	YY_BREAK
		1664	case 31:
		1665	YY_RULE_SETUP
		1666	#line 212 "program_lexer.l"
		1667	{ return_opcode( 1, TRI_OP, MAD, 3); }
		1668	YY_BREAK
		1669	case 32:
		1670	YY_RULE_SETUP
		1671	#line 213 "program_lexer.l"
		1672	{ return_opcode( 1, BIN_OP, MAX, 3); }
		1673	YY_BREAK
		1674	case 33:
		1675	YY_RULE_SETUP
		1676	#line 214 "program_lexer.l"
		1677	{ return_opcode( 1, BIN_OP, MIN, 3); }
		1678	YY_BREAK
		1679	case 34:
		1680	YY_RULE_SETUP
		1681	#line 215 "program_lexer.l"
		1682	{ return_opcode( 1, VECTOR_OP, MOV, 3); }
		1683	YY_BREAK
		1684	case 35:
		1685	YY_RULE_SETUP
		1686	#line 216 "program_lexer.l"
		1687	{ return_opcode( 1, BIN_OP, MUL, 3); }
		1688	YY_BREAK
		1689	case 36:
		1690	YY_RULE_SETUP
		1691	#line 218 "program_lexer.l"
		1692	{ return_opcode(require_NV_fp, VECTOR_OP, PK2H, 4); }
		1693	YY_BREAK
		1694	case 37:
		1695	YY_RULE_SETUP
		1696	#line 219 "program_lexer.l"
		1697	{ return_opcode(require_NV_fp, VECTOR_OP, PK2US, 5); }
		1698	YY_BREAK
		1699	case 38:
		1700	YY_RULE_SETUP
		1701	#line 220 "program_lexer.l"
		1702	{ return_opcode(require_NV_fp, VECTOR_OP, PK4B, 4); }
		1703	YY_BREAK
		1704	case 39:
		1705	YY_RULE_SETUP
		1706	#line 221 "program_lexer.l"
		1707	{ return_opcode(require_NV_fp, VECTOR_OP, PK4UB, 5); }
		1708	YY_BREAK
		1709	case 40:
		1710	YY_RULE_SETUP
		1711	#line 222 "program_lexer.l"
		1712	{ return_opcode( 1, BINSC_OP, POW, 3); }
		1713	YY_BREAK
		1714	case 41:
		1715	YY_RULE_SETUP
		1716	#line 224 "program_lexer.l"
		1717	{ return_opcode( 1, SCALAR_OP, RCP, 3); }
		1718	YY_BREAK
		1719	case 42:
		1720	YY_RULE_SETUP
		1721	#line 225 "program_lexer.l"
		1722	{ return_opcode(require_NV_fp, BIN_OP, RFL, 3); }
		1723	YY_BREAK
		1724	case 43:
		1725	YY_RULE_SETUP
		1726	#line 226 "program_lexer.l"
		1727	{ return_opcode( 1, SCALAR_OP, RSQ, 3); }
		1728	YY_BREAK
		1729	case 44:
		1730	YY_RULE_SETUP
		1731	#line 228 "program_lexer.l"
		1732	{ return_opcode(require_ARB_fp, SCALAR_OP, SCS, 3); }
		1733	YY_BREAK
		1734	case 45:
		1735	YY_RULE_SETUP
		1736	#line 229 "program_lexer.l"
		1737	{ return_opcode(require_NV_fp, BIN_OP, SEQ, 3); }
		1738	YY_BREAK
		1739	case 46:
		1740	YY_RULE_SETUP
		1741	#line 230 "program_lexer.l"
		1742	{ return_opcode(require_NV_fp, BIN_OP, SFL, 3); }
		1743	YY_BREAK
		1744	case 47:
		1745	YY_RULE_SETUP
		1746	#line 231 "program_lexer.l"
		1747	{ return_opcode( 1, BIN_OP, SGE, 3); }
		1748	YY_BREAK
		1749	case 48:
		1750	YY_RULE_SETUP
		1751	#line 232 "program_lexer.l"
		1752	{ return_opcode(require_NV_fp, BIN_OP, SGT, 3); }
		1753	YY_BREAK
		1754	case 49:
		1755	YY_RULE_SETUP
		1756	#line 233 "program_lexer.l"
		1757	{ return_opcode(require_ARB_fp, SCALAR_OP, SIN, 3); }
		1758	YY_BREAK
		1759	case 50:
		1760	YY_RULE_SETUP
		1761	#line 234 "program_lexer.l"
		1762	{ return_opcode(require_NV_fp, BIN_OP, SLE, 3); }
		1763	YY_BREAK
		1764	case 51:
		1765	YY_RULE_SETUP
		1766	#line 235 "program_lexer.l"
		1767	{ return_opcode( 1, BIN_OP, SLT, 3); }
		1768	YY_BREAK
		1769	case 52:
		1770	YY_RULE_SETUP
		1771	#line 236 "program_lexer.l"
		1772	{ return_opcode(require_NV_fp, BIN_OP, SNE, 3); }
		1773	YY_BREAK
		1774	case 53:
		1775	YY_RULE_SETUP
		1776	#line 237 "program_lexer.l"
		1777	{ return_opcode(require_NV_fp, BIN_OP, STR, 3); }
		1778	YY_BREAK
		1779	case 54:
		1780	YY_RULE_SETUP
		1781	#line 238 "program_lexer.l"
		1782	{ return_opcode( 1, BIN_OP, SUB, 3); }
		1783	YY_BREAK
		1784	case 55:
		1785	YY_RULE_SETUP
		1786	#line 239 "program_lexer.l"
		1787	{ return_opcode( 1, SWZ, SWZ, 3); }
		1788	YY_BREAK
		1789	case 56:
		1790	YY_RULE_SETUP
		1791	#line 241 "program_lexer.l"
		1792	{ return_opcode(require_ARB_fp, SAMPLE_OP, TEX, 3); }
		1793	YY_BREAK
		1794	case 57:
		1795	YY_RULE_SETUP
		1796	#line 242 "program_lexer.l"
		1797	{ return_opcode(require_ARB_fp, SAMPLE_OP, TXB, 3); }
		1798	YY_BREAK
		1799	case 58:
		1800	YY_RULE_SETUP
		1801	#line 243 "program_lexer.l"
		1802	{ return_opcode(require_NV_fp, TXD_OP, TXD, 3); }
		1803	YY_BREAK
		1804	case 59:
		1805	YY_RULE_SETUP
		1806	#line 244 "program_lexer.l"
		1807	{ return_opcode(require_ARB_fp, SAMPLE_OP, TXP, 3); }
		1808	YY_BREAK
		1809	case 60:
		1810	YY_RULE_SETUP
		1811	#line 246 "program_lexer.l"
		1812	{ return_opcode(require_NV_fp, SCALAR_OP, UP2H, 4); }
		1813	YY_BREAK
		1814	case 61:
		1815	YY_RULE_SETUP
		1816	#line 247 "program_lexer.l"
		1817	{ return_opcode(require_NV_fp, SCALAR_OP, UP2US, 5); }
		1818	YY_BREAK
		1819	case 62:
		1820	YY_RULE_SETUP
		1821	#line 248 "program_lexer.l"
		1822	{ return_opcode(require_NV_fp, SCALAR_OP, UP4B, 4); }
		1823	YY_BREAK
		1824	case 63:
		1825	YY_RULE_SETUP
		1826	#line 249 "program_lexer.l"
		1827	{ return_opcode(require_NV_fp, SCALAR_OP, UP4UB, 5); }
		1828	YY_BREAK
		1829	case 64:
		1830	YY_RULE_SETUP
		1831	#line 251 "program_lexer.l"
		1832	{ return_opcode(require_NV_fp, TRI_OP, X2D, 3); }
		1833	YY_BREAK
		1834	case 65:
		1835	YY_RULE_SETUP
		1836	#line 252 "program_lexer.l"
		1837	{ return_opcode( 1, BIN_OP, XPD, 3); }
		1838	YY_BREAK
		1839	case 66:
		1840	YY_RULE_SETUP
		1841	#line 254 "program_lexer.l"
		1842	{ return_token_or_IDENTIFIER(require_ARB_vp, VERTEX); }
		1843	YY_BREAK
		1844	case 67:
		1845	YY_RULE_SETUP
		1846	#line 255 "program_lexer.l"
		1847	{ return_token_or_IDENTIFIER(require_ARB_fp, FRAGMENT); }
		1848	YY_BREAK
		1849	case 68:
		1850	YY_RULE_SETUP
		1851	#line 256 "program_lexer.l"
		1852	{ return PROGRAM; }
		1853	YY_BREAK
		1854	case 69:
		1855	YY_RULE_SETUP
		1856	#line 257 "program_lexer.l"
		1857	{ return STATE; }
		1858	YY_BREAK
		1859	case 70:
		1860	YY_RULE_SETUP
		1861	#line 258 "program_lexer.l"
		1862	{ return RESULT; }
		1863	YY_BREAK
		1864	case 71:
		1865	YY_RULE_SETUP
		1866	#line 260 "program_lexer.l"
		1867	{ return AMBIENT; }
		1868	YY_BREAK
		1869	case 72:
		1870	YY_RULE_SETUP
		1871	#line 261 "program_lexer.l"
		1872	{ return ATTENUATION; }
		1873	YY_BREAK
		1874	case 73:
		1875	YY_RULE_SETUP
		1876	#line 262 "program_lexer.l"
		1877	{ return BACK; }
		1878	YY_BREAK
		1879	case 74:
		1880	YY_RULE_SETUP
		1881	#line 263 "program_lexer.l"
		1882	{ return_token_or_DOT(require_ARB_vp, CLIP); }
		1883	YY_BREAK
		1884	case 75:
		1885	YY_RULE_SETUP
		1886	#line 264 "program_lexer.l"
		1887	{ return COLOR; }
		1888	YY_BREAK
		1889	case 76:
		1890	YY_RULE_SETUP
		1891	#line 265 "program_lexer.l"
		1892	{ return_token_or_DOT(require_ARB_fp, DEPTH); }
		1893	YY_BREAK
		1894	case 77:
		1895	YY_RULE_SETUP
		1896	#line 266 "program_lexer.l"
		1897	{ return DIFFUSE; }
		1898	YY_BREAK
		1899	case 78:
		1900	YY_RULE_SETUP
		1901	#line 267 "program_lexer.l"
		1902	{ return DIRECTION; }
		1903	YY_BREAK
		1904	case 79:
		1905	YY_RULE_SETUP
		1906	#line 268 "program_lexer.l"
		1907	{ return EMISSION; }
		1908	YY_BREAK
		1909	case 80:
		1910	YY_RULE_SETUP
		1911	#line 269 "program_lexer.l"
		1912	{ return ENV; }
		1913	YY_BREAK
		1914	case 81:
		1915	YY_RULE_SETUP
		1916	#line 270 "program_lexer.l"
		1917	{ return EYE; }
		1918	YY_BREAK
		1919	case 82:
		1920	YY_RULE_SETUP
		1921	#line 271 "program_lexer.l"
		1922	{ return FOGCOORD; }
		1923	YY_BREAK
		1924	case 83:
		1925	YY_RULE_SETUP
		1926	#line 272 "program_lexer.l"
		1927	{ return FOG; }
		1928	YY_BREAK
		1929	case 84:
		1930	YY_RULE_SETUP
		1931	#line 273 "program_lexer.l"
		1932	{ return FRONT; }
		1933	YY_BREAK
		1934	case 85:
		1935	YY_RULE_SETUP
		1936	#line 274 "program_lexer.l"
		1937	{ return HALF; }
		1938	YY_BREAK
		1939	case 86:
		1940	YY_RULE_SETUP
		1941	#line 275 "program_lexer.l"
		1942	{ return INVERSE; }
		1943	YY_BREAK
		1944	case 87:
		1945	YY_RULE_SETUP
		1946	#line 276 "program_lexer.l"
		1947	{ return INVTRANS; }
		1948	YY_BREAK
		1949	case 88:
		1950	YY_RULE_SETUP
		1951	#line 277 "program_lexer.l"
		1952	{ return LIGHT; }
		1953	YY_BREAK
		1954	case 89:
		1955	YY_RULE_SETUP
		1956	#line 278 "program_lexer.l"
		1957	{ return LIGHTMODEL; }
		1958	YY_BREAK
		1959	case 90:
		1960	YY_RULE_SETUP
		1961	#line 279 "program_lexer.l"
		1962	{ return LIGHTPROD; }
		1963	YY_BREAK
		1964	case 91:
		1965	YY_RULE_SETUP
		1966	#line 280 "program_lexer.l"
		1967	{ return LOCAL; }
		1968	YY_BREAK
		1969	case 92:
		1970	YY_RULE_SETUP
		1971	#line 281 "program_lexer.l"
		1972	{ return MATERIAL; }
		1973	YY_BREAK
		1974	case 93:
		1975	YY_RULE_SETUP
		1976	#line 282 "program_lexer.l"
		1977	{ return MAT_PROGRAM; }
		1978	YY_BREAK
		1979	case 94:
		1980	YY_RULE_SETUP
		1981	#line 283 "program_lexer.l"
		1982	{ return MATRIX; }
		1983	YY_BREAK
		1984	case 95:
		1985	YY_RULE_SETUP
		1986	#line 284 "program_lexer.l"
		1987	{ return_token_or_DOT(require_ARB_vp, MATRIXINDEX); }
		1988	YY_BREAK
		1989	case 96:
		1990	YY_RULE_SETUP
		1991	#line 285 "program_lexer.l"
		1992	{ return MODELVIEW; }
		1993	YY_BREAK
		1994	case 97:
		1995	YY_RULE_SETUP
		1996	#line 286 "program_lexer.l"
		1997	{ return MVP; }
		1998	YY_BREAK
		1999	case 98:
		2000	YY_RULE_SETUP
		2001	#line 287 "program_lexer.l"
		2002	{ return_token_or_DOT(require_ARB_vp, NORMAL); }
		2003	YY_BREAK
		2004	case 99:
		2005	YY_RULE_SETUP
		2006	#line 288 "program_lexer.l"
		2007	{ return OBJECT; }
		2008	YY_BREAK
		2009	case 100:
		2010	YY_RULE_SETUP
		2011	#line 289 "program_lexer.l"
		2012	{ return PALETTE; }
		2013	YY_BREAK
		2014	case 101:
		2015	YY_RULE_SETUP
		2016	#line 290 "program_lexer.l"
		2017	{ return PARAMS; }
		2018	YY_BREAK
		2019	case 102:
		2020	YY_RULE_SETUP
		2021	#line 291 "program_lexer.l"
		2022	{ return PLANE; }
		2023	YY_BREAK
		2024	case 103:
		2025	YY_RULE_SETUP
		2026	#line 292 "program_lexer.l"
		2027	{ return_token_or_DOT(require_ARB_vp, POINT_TOK); }
		2028	YY_BREAK
		2029	case 104:
		2030	YY_RULE_SETUP
		2031	#line 293 "program_lexer.l"
		2032	{ return_token_or_DOT(require_ARB_vp, POINTSIZE); }
		2033	YY_BREAK
		2034	case 105:
		2035	YY_RULE_SETUP
		2036	#line 294 "program_lexer.l"
		2037	{ return POSITION; }
		2038	YY_BREAK
		2039	case 106:
		2040	YY_RULE_SETUP
		2041	#line 295 "program_lexer.l"
		2042	{ return PRIMARY; }
		2043	YY_BREAK
		2044	case 107:
		2045	YY_RULE_SETUP
		2046	#line 296 "program_lexer.l"
		2047	{ return PROJECTION; }
		2048	YY_BREAK
		2049	case 108:
		2050	YY_RULE_SETUP
		2051	#line 297 "program_lexer.l"
		2052	{ return_token_or_DOT(require_ARB_fp, RANGE); }
		2053	YY_BREAK
		2054	case 109:
		2055	YY_RULE_SETUP
		2056	#line 298 "program_lexer.l"
		2057	{ return ROW; }
		2058	YY_BREAK
		2059	case 110:
		2060	YY_RULE_SETUP
		2061	#line 299 "program_lexer.l"
		2062	{ return SCENECOLOR; }
		2063	YY_BREAK
		2064	case 111:
		2065	YY_RULE_SETUP
		2066	#line 300 "program_lexer.l"
		2067	{ return SECONDARY; }
		2068	YY_BREAK
		2069	case 112:
		2070	YY_RULE_SETUP
		2071	#line 301 "program_lexer.l"
		2072	{ return SHININESS; }
		2073	YY_BREAK
		2074	case 113:
		2075	YY_RULE_SETUP
		2076	#line 302 "program_lexer.l"
		2077	{ return_token_or_DOT(require_ARB_vp, SIZE_TOK); }
		2078	YY_BREAK
		2079	case 114:
		2080	YY_RULE_SETUP
		2081	#line 303 "program_lexer.l"
		2082	{ return SPECULAR; }
		2083	YY_BREAK
		2084	case 115:
		2085	YY_RULE_SETUP
		2086	#line 304 "program_lexer.l"
		2087	{ return SPOT; }
		2088	YY_BREAK
		2089	case 116:
		2090	YY_RULE_SETUP
		2091	#line 305 "program_lexer.l"
		2092	{ return TEXCOORD; }
		2093	YY_BREAK
		2094	case 117:
		2095	YY_RULE_SETUP
		2096	#line 306 "program_lexer.l"
		2097	{ return_token_or_DOT(require_ARB_fp, TEXENV); }
		2098	YY_BREAK
		2099	case 118:
		2100	YY_RULE_SETUP
		2101	#line 307 "program_lexer.l"
		2102	{ return_token_or_DOT(require_ARB_vp, TEXGEN); }
		2103	YY_BREAK
		2104	case 119:
		2105	YY_RULE_SETUP
		2106	#line 308 "program_lexer.l"
		2107	{ return_token_or_DOT(require_ARB_vp, TEXGEN_Q); }
		2108	YY_BREAK
		2109	case 120:
		2110	YY_RULE_SETUP
		2111	#line 309 "program_lexer.l"
		2112	{ return_token_or_DOT(require_ARB_vp, TEXGEN_S); }
		2113	YY_BREAK
		2114	case 121:
		2115	YY_RULE_SETUP
		2116	#line 310 "program_lexer.l"
		2117	{ return_token_or_DOT(require_ARB_vp, TEXGEN_T); }
		2118	YY_BREAK
		2119	case 122:
		2120	YY_RULE_SETUP
		2121	#line 311 "program_lexer.l"
		2122	{ return TEXTURE; }
		2123	YY_BREAK
		2124	case 123:
		2125	YY_RULE_SETUP
		2126	#line 312 "program_lexer.l"
		2127	{ return TRANSPOSE; }
		2128	YY_BREAK
		2129	case 124:
		2130	YY_RULE_SETUP
		2131	#line 313 "program_lexer.l"
		2132	{ return_token_or_DOT(require_ARB_vp, VTXATTRIB); }
		2133	YY_BREAK
		2134	case 125:
		2135	YY_RULE_SETUP
		2136	#line 314 "program_lexer.l"
		2137	{ return_token_or_DOT(require_ARB_vp, WEIGHT); }
		2138	YY_BREAK
		2139	case 126:
		2140	YY_RULE_SETUP
		2141	#line 316 "program_lexer.l"
		2142	{ return_token_or_IDENTIFIER(require_ARB_fp, TEXTURE_UNIT); }
		2143	YY_BREAK
		2144	case 127:
		2145	YY_RULE_SETUP
		2146	#line 317 "program_lexer.l"
		2147	{ return_token_or_IDENTIFIER(require_ARB_fp, TEX_1D); }
		2148	YY_BREAK
		2149	case 128:
		2150	YY_RULE_SETUP
		2151	#line 318 "program_lexer.l"
		2152	{ return_token_or_IDENTIFIER(require_ARB_fp, TEX_2D); }
		2153	YY_BREAK
		2154	case 129:
		2155	YY_RULE_SETUP
		2156	#line 319 "program_lexer.l"
		2157	{ return_token_or_IDENTIFIER(require_ARB_fp, TEX_3D); }
		2158	YY_BREAK
		2159	case 130:
		2160	YY_RULE_SETUP
		2161	#line 320 "program_lexer.l"
		2162	{ return_token_or_IDENTIFIER(require_ARB_fp, TEX_CUBE); }
		2163	YY_BREAK
		2164	case 131:
		2165	YY_RULE_SETUP
		2166	#line 321 "program_lexer.l"
		2167	{ return_token_or_IDENTIFIER(require_ARB_fp && require_rect, TEX_RECT); }
		2168	YY_BREAK
		2169	case 132:
		2170	YY_RULE_SETUP
		2171	#line 322 "program_lexer.l"
		2172	{ return_token_or_IDENTIFIER(require_ARB_fp && require_shadow, TEX_SHADOW1D); }
		2173	YY_BREAK
		2174	case 133:
		2175	YY_RULE_SETUP
		2176	#line 323 "program_lexer.l"
		2177	{ return_token_or_IDENTIFIER(require_ARB_fp && require_shadow, TEX_SHADOW2D); }
		2178	YY_BREAK
		2179	case 134:
		2180	YY_RULE_SETUP
		2181	#line 324 "program_lexer.l"
		2182	{ return_token_or_IDENTIFIER(require_ARB_fp && require_shadow && require_rect, TEX_SHADOWRECT); }
		2183	YY_BREAK
		2184	case 135:
		2185	YY_RULE_SETUP
		2186	#line 325 "program_lexer.l"
		2187	{ return_token_or_IDENTIFIER(require_ARB_fp && require_texarray, TEX_ARRAY1D); }
		2188	YY_BREAK
		2189	case 136:
		2190	YY_RULE_SETUP
		2191	#line 326 "program_lexer.l"
		2192	{ return_token_or_IDENTIFIER(require_ARB_fp && require_texarray, TEX_ARRAY2D); }
		2193	YY_BREAK
		2194	case 137:
		2195	YY_RULE_SETUP
		2196	#line 327 "program_lexer.l"
		2197	{ return_token_or_IDENTIFIER(require_ARB_fp && require_shadow && require_texarray, TEX_ARRAYSHADOW1D); }
		2198	YY_BREAK
		2199	case 138:
		2200	YY_RULE_SETUP
		2201	#line 328 "program_lexer.l"
		2202	{ return_token_or_IDENTIFIER(require_ARB_fp && require_shadow && require_texarray, TEX_ARRAYSHADOW2D); }
		2203	YY_BREAK
		2204	case 139:
		2205	YY_RULE_SETUP
		2206	#line 330 "program_lexer.l"
		2207	{ return handle_ident(yyextra, yytext, yylval); }
		2208	YY_BREAK
		2209	case 140:
		2210	YY_RULE_SETUP
		2211	#line 332 "program_lexer.l"
		2212	{ return DOT_DOT; }
		2213	YY_BREAK
		2214	case 141:
		2215	YY_RULE_SETUP
		2216	#line 334 "program_lexer.l"
		2217	{
		2218	yylval->integer = strtol(yytext, NULL, 10);
		2219	return INTEGER;
		2220	}
		2221	YY_BREAK
		2222	case 142:
		2223	YY_RULE_SETUP
		2224	#line 338 "program_lexer.l"
		2225	{
		2226	yylval->real = _mesa_strtof(yytext, NULL);
		2227	return REAL;
		2228	}
		2229	YY_BREAK
		2230	case 143:
		2231	/* rule 143 can match eol */
		2232	yy_cp = yyg->yy_hold_char; / undo effects of setting up yytext */
		2233	yyg->yy_c_buf_p = yy_cp -= 1;
		2234	YY_DO_BEFORE_ACTION; /* set up yytext again */
		2235	YY_RULE_SETUP
		2236	#line 342 "program_lexer.l"
		2237	{
		2238	yylval->real = _mesa_strtof(yytext, NULL);
		2239	return REAL;
		2240	}
		2241	YY_BREAK
		2242	case 144:
		2243	YY_RULE_SETUP
		2244	#line 346 "program_lexer.l"
		2245	{
		2246	yylval->real = _mesa_strtof(yytext, NULL);
		2247	return REAL;
		2248	}
		2249	YY_BREAK
		2250	case 145:
		2251	YY_RULE_SETUP
		2252	#line 350 "program_lexer.l"
		2253	{
		2254	yylval->real = _mesa_strtof(yytext, NULL);
		2255	return REAL;
		2256	}
		2257	YY_BREAK
		2258	case 146:
		2259	YY_RULE_SETUP
		2260	#line 355 "program_lexer.l"
		2261	{
		2262	yylval->swiz_mask.swizzle = SWIZZLE_NOOP;
		2263	yylval->swiz_mask.mask = WRITEMASK_XYZW;
		2264	return MASK4;
		2265	}
		2266	YY_BREAK
		2267	case 147:
		2268	YY_RULE_SETUP
		2269	#line 361 "program_lexer.l"
		2270	{
		2271	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2272	yylval->swiz_mask.mask = WRITEMASK_XY
		2273	\| mask_from_char(yytext[3]);
		2274	return MASK3;
		2275	}
		2276	YY_BREAK
		2277	case 148:
		2278	YY_RULE_SETUP
		2279	#line 367 "program_lexer.l"
		2280	{
		2281	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2282	yylval->swiz_mask.mask = WRITEMASK_XZW;
		2283	return MASK3;
		2284	}
		2285	YY_BREAK
		2286	case 149:
		2287	YY_RULE_SETUP
		2288	#line 372 "program_lexer.l"
		2289	{
		2290	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2291	yylval->swiz_mask.mask = WRITEMASK_YZW;
		2292	return MASK3;
		2293	}
		2294	YY_BREAK
		2295	case 150:
		2296	YY_RULE_SETUP
		2297	#line 378 "program_lexer.l"
		2298	{
		2299	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2300	yylval->swiz_mask.mask = WRITEMASK_X
		2301	\| mask_from_char(yytext[2]);
		2302	return MASK2;
		2303	}
		2304	YY_BREAK
		2305	case 151:
		2306	YY_RULE_SETUP
		2307	#line 384 "program_lexer.l"
		2308	{
		2309	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2310	yylval->swiz_mask.mask = WRITEMASK_Y
		2311	\| mask_from_char(yytext[2]);
		2312	return MASK2;
		2313	}
		2314	YY_BREAK
		2315	case 152:
		2316	YY_RULE_SETUP
		2317	#line 390 "program_lexer.l"
		2318	{
		2319	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2320	yylval->swiz_mask.mask = WRITEMASK_ZW;
		2321	return MASK2;
		2322	}
		2323	YY_BREAK
		2324	case 153:
		2325	YY_RULE_SETUP
		2326	#line 396 "program_lexer.l"
		2327	{
		2328	const unsigned s = swiz_from_char(yytext[1]);
		2329	yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(s, s, s, s);
		2330	yylval->swiz_mask.mask = mask_from_char(yytext[1]);
		2331	return MASK1;
		2332	}
		2333	YY_BREAK
		2334	case 154:
		2335	YY_RULE_SETUP
		2336	#line 403 "program_lexer.l"
		2337	{
		2338	yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(swiz_from_char(yytext[1]),
		2339	swiz_from_char(yytext[2]),
		2340	swiz_from_char(yytext[3]),
		2341	swiz_from_char(yytext[4]));
		2342	yylval->swiz_mask.mask = 0;
		2343	return SWIZZLE;
		2344	}
		2345	YY_BREAK
		2346	case 155:
		2347	YY_RULE_SETUP
		2348	#line 412 "program_lexer.l"
		2349	{
		2350	yylval->swiz_mask.swizzle = SWIZZLE_NOOP;
		2351	yylval->swiz_mask.mask = WRITEMASK_XYZW;
		2352	return_token_or_DOT(require_ARB_fp, MASK4);
		2353	}
		2354	YY_BREAK
		2355	case 156:
		2356	YY_RULE_SETUP
		2357	#line 418 "program_lexer.l"
		2358	{
		2359	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2360	yylval->swiz_mask.mask = WRITEMASK_XY
		2361	\| mask_from_char(yytext[3]);
		2362	return_token_or_DOT(require_ARB_fp, MASK3);
		2363	}
		2364	YY_BREAK
		2365	case 157:
		2366	YY_RULE_SETUP
		2367	#line 424 "program_lexer.l"
		2368	{
		2369	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2370	yylval->swiz_mask.mask = WRITEMASK_XZW;
		2371	return_token_or_DOT(require_ARB_fp, MASK3);
		2372	}
		2373	YY_BREAK
		2374	case 158:
		2375	YY_RULE_SETUP
		2376	#line 429 "program_lexer.l"
		2377	{
		2378	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2379	yylval->swiz_mask.mask = WRITEMASK_YZW;
		2380	return_token_or_DOT(require_ARB_fp, MASK3);
		2381	}
		2382	YY_BREAK
		2383	case 159:
		2384	YY_RULE_SETUP
		2385	#line 435 "program_lexer.l"
		2386	{
		2387	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2388	yylval->swiz_mask.mask = WRITEMASK_X
		2389	\| mask_from_char(yytext[2]);
		2390	return_token_or_DOT(require_ARB_fp, MASK2);
		2391	}
		2392	YY_BREAK
		2393	case 160:
		2394	YY_RULE_SETUP
		2395	#line 441 "program_lexer.l"
		2396	{
		2397	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2398	yylval->swiz_mask.mask = WRITEMASK_Y
		2399	\| mask_from_char(yytext[2]);
		2400	return_token_or_DOT(require_ARB_fp, MASK2);
		2401	}
		2402	YY_BREAK
		2403	case 161:
		2404	YY_RULE_SETUP
		2405	#line 447 "program_lexer.l"
		2406	{
		2407	yylval->swiz_mask.swizzle = SWIZZLE_INVAL;
		2408	yylval->swiz_mask.mask = WRITEMASK_ZW;
		2409	return_token_or_DOT(require_ARB_fp, MASK2);
		2410	}
		2411	YY_BREAK
		2412	case 162:
		2413	YY_RULE_SETUP
		2414	#line 453 "program_lexer.l"
		2415	{
		2416	const unsigned s = swiz_from_char(yytext[1]);
		2417	yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(s, s, s, s);
		2418	yylval->swiz_mask.mask = mask_from_char(yytext[1]);
		2419	return_token_or_DOT(require_ARB_fp, MASK1);
		2420	}
		2421	YY_BREAK
		2422	case 163:
		2423	YY_RULE_SETUP
		2424	#line 461 "program_lexer.l"
		2425	{
		2426	if (require_ARB_vp) {
		2427	return TEXGEN_R;
		2428	} else {
		2429	yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X,
		2430	SWIZZLE_X, SWIZZLE_X);
		2431	yylval->swiz_mask.mask = WRITEMASK_X;
		2432	return MASK1;
		2433	}
		2434	}
		2435	YY_BREAK
		2436	case 164:
		2437	YY_RULE_SETUP
		2438	#line 472 "program_lexer.l"
		2439	{
		2440	yylval->swiz_mask.swizzle = MAKE_SWIZZLE4(swiz_from_char(yytext[1]),
		2441	swiz_from_char(yytext[2]),
		2442	swiz_from_char(yytext[3]),
		2443	swiz_from_char(yytext[4]));
		2444	yylval->swiz_mask.mask = 0;
		2445	return_token_or_DOT(require_ARB_fp, SWIZZLE);
		2446	}
		2447	YY_BREAK
		2448	case 165:
		2449	YY_RULE_SETUP
		2450	#line 481 "program_lexer.l"
		2451	{ return DOT; }
		2452	YY_BREAK
		2453	case 166:
		2454	/* rule 166 can match eol */
		2455	YY_RULE_SETUP
		2456	#line 483 "program_lexer.l"
		2457	{
		2458	yylloc->first_line++;
		2459	yylloc->first_column = 1;
		2460	yylloc->last_line++;
		2461	yylloc->last_column = 1;
		2462	yylloc->position++;
		2463	}
		2464	YY_BREAK
		2465	case 167:
		2466	YY_RULE_SETUP
		2467	#line 490 "program_lexer.l"
		2468	/* eat whitespace */ ;
		2469	YY_BREAK
		2470	case 168:
		2471	yy_cp = yyg->yy_hold_char; / undo effects of setting up yytext */
		2472	yyg->yy_c_buf_p = yy_cp -= 1;
		2473	YY_DO_BEFORE_ACTION; /* set up yytext again */
		2474	YY_RULE_SETUP
		2475	#line 491 "program_lexer.l"
		2476	/* eat comments */ ;
		2477	YY_BREAK
		2478	case 169:
		2479	YY_RULE_SETUP
		2480	#line 492 "program_lexer.l"
		2481	{ return yytext[0]; }
		2482	YY_BREAK
		2483	case 170:
		2484	YY_RULE_SETUP
		2485	#line 493 "program_lexer.l"
		2486	ECHO;
		2487	YY_BREAK
		2488	#line 2490 "lex.yy.c"
		2489	case YY_STATE_EOF(INITIAL):
		2490	yyterminate();
		2491
		2492
		2493	{
		2494	/* Amount of text matched not including the EOB char. */
		2495	int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
		2496
		2497
		2498	*yy_cp = yyg->yy_hold_char;
		2499	YY_RESTORE_YY_MORE_OFFSET
		2500
		2501
		2502	{
		2503	/* We're scanning a new file or input source. It's
		2504	* possible that this happened because the user
		2505	* just pointed yyin at a new source and called
		2506	* yylex(). If so, then we have to assure
		2507	* consistency between YY_CURRENT_BUFFER and our
		2508	* globals. Here is the right place to do so, because
		2509	* this is the first action (other than possibly a
		2510	* back-up) that will match for the new input source.
		2511	*/
		2512	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
		2513	YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
		2514	YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
		2515	}
		2516
		2517
		2518	* of the first EOB in the buffer, since yy_c_buf_p will
		2519	* already have been incremented past the NUL character
		2520	* (since all states make transitions on EOB to the
		2521	* end-of-buffer state). Contrast this with the test
		2522	* in input().
		2523	*/
		2524	if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
		2525	{ /* This was really a NUL. */
		2526	yy_state_type yy_next_state;
		2527
		2528
		2529
		2530
		2531
		2532
		2533	* transition. We couldn't have
		2534	* yy_get_previous_state() go ahead and do it
		2535	* for us because it doesn't know how to deal
		2536	* with the possibility of jamming (and we don't
		2537	* want to build jamming into it because then it
		2538	* will run more slowly).
		2539	*/
		2540
		2541
		2542
		2543
		2544
		2545
		2546	{
		2547	/* Consume the NUL. */
		2548	yy_cp = ++yyg->yy_c_buf_p;
		2549	yy_current_state = yy_next_state;
		2550	goto yy_match;
		2551	}
		2552
		2553
		2554	{
		2555	yy_cp = yyg->yy_c_buf_p;
		2556	goto yy_find_action;
		2557	}
		2558	}
		2559
		2560
		2561	{
		2562	case EOB_ACT_END_OF_FILE:
		2563	{
		2564	yyg->yy_did_buffer_switch_on_eof = 0;
		2565
		2566
		2567	{
		2568	/* Note: because we've taken care in
		2569	* yy_get_next_buffer() to have set up
		2570	* yytext, we can now set up
		2571	* yy_c_buf_p so that if some total
		2572	* hoser (like flex itself) wants to
		2573	* call the scanner after we return the
		2574	* YY_NULL, it'll still work - another
		2575	* YY_NULL will get returned.
		2576	*/
		2577	yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
		2578
		2579
		2580	goto do_action;
		2581	}
		2582
		2583
		2584	{
		2585	if ( ! yyg->yy_did_buffer_switch_on_eof )
		2586	YY_NEW_FILE;
		2587	}
		2588	break;
		2589	}
		2590
		2591
		2592	yyg->yy_c_buf_p =
		2593	yyg->yytext_ptr + yy_amount_of_matched_text;
		2594
		2595
		2596
		2597
		2598	yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
		2599	goto yy_match;
		2600
		2601
		2602	yyg->yy_c_buf_p =
		2603	&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
		2604
		2605
		2606
		2607
		2608	yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
		2609	goto yy_find_action;
		2610	}
		2611	break;
		2612	}
		2613
		2614
		2615	YY_FATAL_ERROR(
		2616	"fatal flex scanner internal error--no action found" );
		2617	} /* end of action switch */
		2618	} /* end of scanning one token */
		2619	} /* end of yylex */
		2620
		2621
		2622	*
		2623	* Returns a code representing an action:
		2624	* EOB_ACT_LAST_MATCH -
		2625	* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
		2626	* EOB_ACT_END_OF_FILE - end of file
		2627	*/
		2628	static int yy_get_next_buffer (yyscan_t yyscanner)
		2629	{
		2630	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2631	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
		2632	register char *source = yyg->yytext_ptr;
		2633	register int number_to_move, i;
		2634	int ret_val;
		2635
		2636
		2637	YY_FATAL_ERROR(
		2638	"fatal flex scanner internal error--end of buffer missed" );
		2639
		2640
		2641	{ /* Don't try to fill the buffer, so this is an EOF. */
		2642	if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
		2643	{
		2644	/* We matched a single character, the EOB, so
		2645	* treat this as a final EOF.
		2646	*/
		2647	return EOB_ACT_END_OF_FILE;
		2648	}
		2649
		2650
		2651	{
		2652	/* We matched some text prior to the EOB, first
		2653	* process it.
		2654	*/
		2655	return EOB_ACT_LAST_MATCH;
		2656	}
		2657	}
		2658
		2659
		2660
		2661
		2662	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
		2663
		2664
		2665	(dest++) = (source++);
		2666
		2667
		2668	/* don't do the read, it's not guaranteed to return an EOF,
		2669	* just force an EOF
		2670	*/
		2671	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
		2672
		2673
		2674	{
		2675	int num_to_read =
		2676	YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
		2677
		2678
		2679	{ /* Not enough room in the buffer - grow it. */
		2680
		2681
		2682	YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
		2683
		2684
		2685	(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
		2686
		2687
		2688	{
		2689	int new_size = b->yy_buf_size * 2;
		2690
		2691
		2692	b->yy_buf_size += b->yy_buf_size / 8;
		2693	else
		2694	b->yy_buf_size *= 2;
		2695
		2696
		2697	/* Include room in for 2 EOB chars. */
		2698	yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
		2699	}
		2700	else
		2701	/* Can't grow it, we don't own it. */
		2702	b->yy_ch_buf = 0;
		2703
		2704
		2705	YY_FATAL_ERROR(
		2706	"fatal error - scanner input buffer overflow" );
		2707
		2708
		2709
		2710
		2711	number_to_move - 1;
		2712
		2713
		2714
		2715
		2716	num_to_read = YY_READ_BUF_SIZE;
		2717
		2718
		2719	YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
		2720	yyg->yy_n_chars, (size_t) num_to_read );
		2721
		2722
		2723	}
		2724
		2725
		2726	{
		2727	if ( number_to_move == YY_MORE_ADJ )
		2728	{
		2729	ret_val = EOB_ACT_END_OF_FILE;
		2730	yyrestart(yyin ,yyscanner);
		2731	}
		2732
		2733
		2734	{
		2735	ret_val = EOB_ACT_LAST_MATCH;
		2736	YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
		2737	YY_BUFFER_EOF_PENDING;
		2738	}
		2739	}
		2740
		2741
		2742	ret_val = EOB_ACT_CONTINUE_SCAN;
		2743
		2744
		2745	/* Extend the array by 50%, plus the number we really need. */
		2746	yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
		2747	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char ) yyrealloc((void ) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
		2748	if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
		2749	YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
		2750	}
		2751
		2752
		2753	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
		2754	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
		2755
		2756
		2757
		2758
		2759	}
		2760
		2761
		2762
		2763
		2764	{
		2765	register yy_state_type yy_current_state;
		2766	register char *yy_cp;
		2767	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2768
		2769
		2770
		2771
		2772	{
		2773	register YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
		2774	if ( yy_accept[yy_current_state] )
		2775	{
		2776	yyg->yy_last_accepting_state = yy_current_state;
		2777	yyg->yy_last_accepting_cpos = yy_cp;
		2778	}
		2779	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		2780	{
		2781	yy_current_state = (int) yy_def[yy_current_state];
		2782	if ( yy_current_state >= 850 )
		2783	yy_c = yy_meta[(unsigned int) yy_c];
		2784	}
		2785	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
		2786	}
		2787
		2788
		2789	}
		2790
		2791
		2792	*
		2793	* synopsis
		2794	* next_state = yy_try_NUL_trans( current_state );
		2795	*/
		2796	static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
		2797	{
		2798	register int yy_is_jam;
		2799	struct yyguts_t * yyg = (struct yyguts_t)yyscanner; / This var may be unused depending upon options. */
		2800	register char *yy_cp = yyg->yy_c_buf_p;
		2801
		2802
		2803	if ( yy_accept[yy_current_state] )
		2804	{
		2805	yyg->yy_last_accepting_state = yy_current_state;
		2806	yyg->yy_last_accepting_cpos = yy_cp;
		2807	}
		2808	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		2809	{
		2810	yy_current_state = (int) yy_def[yy_current_state];
		2811	if ( yy_current_state >= 850 )
		2812	yy_c = yy_meta[(unsigned int) yy_c];
		2813	}
		2814	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
		2815	yy_is_jam = (yy_current_state == 849);
		2816
		2817
		2818	}
		2819
		2820
		2821	{
		2822	register char *yy_cp;
		2823	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2824
		2825
		2826
		2827
		2828	*yy_cp = yyg->yy_hold_char;
		2829
		2830
		2831	{ /* need to shift things up to make room */
		2832	/* +2 for EOB chars. */
		2833	register int number_to_move = yyg->yy_n_chars + 2;
		2834	register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
		2835	YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
		2836	register char *source =
		2837	&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
		2838
		2839
		2840	--dest = --source;
		2841
		2842
		2843	yy_bp += (int) (dest - source);
		2844	YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
		2845	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
		2846
		2847
		2848	YY_FATAL_ERROR( "flex scanner push-back overflow" );
		2849	}
		2850
		2851
		2852
		2853
		2854	yyg->yy_hold_char = *yy_cp;
		2855	yyg->yy_c_buf_p = yy_cp;
		2856	}
		2857
		2858
		2859	#ifdef __cplusplus
		2860	static int yyinput (yyscan_t yyscanner)
		2861	#else
		2862	static int input (yyscan_t yyscanner)
		2863	#endif
		2864
		2865
		2866	int c;
		2867	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2868
		2869
		2870
		2871
		2872	{
		2873	/* yy_c_buf_p now points to the character we want to return.
		2874	* If this occurs before the EOB characters, then it's a
		2875	* valid NUL; if not, then we've hit the end of the buffer.
		2876	*/
		2877	if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
		2878	/* This was really a NUL. */
		2879	*yyg->yy_c_buf_p = '\0';
		2880
		2881
		2882	{ /* need more input */
		2883	int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
		2884	++yyg->yy_c_buf_p;
		2885
		2886
		2887	{
		2888	case EOB_ACT_LAST_MATCH:
		2889	/* This happens because yy_g_n_b()
		2890	* sees that we've accumulated a
		2891	* token and flags that we need to
		2892	* try matching the token before
		2893	* proceeding. But for input(),
		2894	* there's no matching to consider.
		2895	* So convert the EOB_ACT_LAST_MATCH
		2896	* to EOB_ACT_END_OF_FILE.
		2897	*/
		2898
		2899
		2900	yyrestart(yyin ,yyscanner);
		2901
		2902
		2903
		2904
		2905	{
		2906	if ( yywrap(yyscanner ) )
		2907	return EOF;
		2908
		2909
		2910	YY_NEW_FILE;
		2911	#ifdef __cplusplus
		2912	return yyinput(yyscanner);
		2913	#else
		2914	return input(yyscanner);
		2915	#endif
		2916	}
		2917
		2918
		2919	yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
		2920	break;
		2921	}
		2922	}
		2923	}
		2924
		2925
		2926	yyg->yy_c_buf_p = '\0'; / preserve yytext */
		2927	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
		2928
		2929
		2930	}
		2931	#endif /* ifndef YY_NO_INPUT */
		2932
		2933
		2934	* @param input_file A readable stream.
		2935	* @param yyscanner The scanner object.
		2936	* @note This function does not reset the start condition to @c INITIAL .
		2937	*/
		2938	void yyrestart (FILE * input_file , yyscan_t yyscanner)
		2939	{
		2940	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2941
		2942
		2943	yyensure_buffer_stack (yyscanner);
		2944	YY_CURRENT_BUFFER_LVALUE =
		2945	yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
		2946	}
		2947
		2948
		2949	yy_load_buffer_state(yyscanner );
		2950	}
		2951
		2952
		2953	* @param new_buffer The new input buffer.
		2954	* @param yyscanner The scanner object.
		2955	*/
		2956	void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
		2957	{
		2958	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2959
		2960
		2961	* with
		2962	* yypop_buffer_state();
		2963	* yypush_buffer_state(new_buffer);
		2964	*/
		2965	yyensure_buffer_stack (yyscanner);
		2966	if ( YY_CURRENT_BUFFER == new_buffer )
		2967	return;
		2968
		2969
		2970	{
		2971	/* Flush out information for old buffer. */
		2972	*yyg->yy_c_buf_p = yyg->yy_hold_char;
		2973	YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		2974	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		2975	}
		2976
		2977
		2978	yy_load_buffer_state(yyscanner );
		2979
		2980
		2981	* EOF (yywrap()) processing, but the only time this flag
		2982	* is looked at is after yywrap() is called, so it's safe
		2983	* to go ahead and always set it.
		2984	*/
		2985	yyg->yy_did_buffer_switch_on_eof = 1;
		2986	}
		2987
		2988
		2989	{
		2990	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		2991	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
		2992	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
		2993	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
		2994	yyg->yy_hold_char = *yyg->yy_c_buf_p;
		2995	}
		2996
		2997
		2998	* @param file A readable stream.
		2999	* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
		3000	* @param yyscanner The scanner object.
		3001	* @return the allocated buffer state.
		3002	*/
		3003	YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
		3004	{
		3005	YY_BUFFER_STATE b;
		3006
		3007
		3008	if ( ! b )
		3009	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
		3010
		3011
		3012
		3013
		3014	* we need to put in 2 end-of-buffer characters.
		3015	*/
		3016	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
		3017	if ( ! b->yy_ch_buf )
		3018	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
		3019
		3020
		3021
		3022
		3023
		3024
		3025	}
		3026
		3027
		3028	* @param b a buffer created with yy_create_buffer()
		3029	* @param yyscanner The scanner object.
		3030	*/
		3031	void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
		3032	{
		3033	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3034
		3035
		3036	return;
		3037
		3038
		3039	YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
		3040
		3041
		3042	yyfree((void *) b->yy_ch_buf ,yyscanner );
		3043
		3044
		3045	}
		3046
		3047
		3048	* This function is sometimes called more than once on the same buffer,
		3049	* such as during a yyrestart() or at EOF.
		3050	*/
		3051	static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
		3052
		3053
		3054	int oerrno = errno;
		3055	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3056
		3057
		3058
		3059
		3060	b->yy_fill_buffer = 1;
		3061
		3062
		3063	* called from yyrestart() or through yy_get_next_buffer.
		3064	* In that case, we don't want to reset the lineno or column.
		3065	*/
		3066	if (b != YY_CURRENT_BUFFER){
		3067	b->yy_bs_lineno = 1;
		3068	b->yy_bs_column = 0;
		3069	}
		3070
		3071
		3072
		3073
		3074	}
		3075
		3076
		3077	* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
		3078	* @param yyscanner The scanner object.
		3079	*/
		3080	void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
		3081	{
		3082	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3083	if ( ! b )
		3084	return;
		3085
		3086
		3087
		3088
		3089	* a transition to the end-of-buffer state. The second causes
		3090	* a jam in that state.
		3091	*/
		3092	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
		3093	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
		3094
		3095
		3096
		3097
		3098	b->yy_buffer_status = YY_BUFFER_NEW;
		3099
		3100
		3101	yy_load_buffer_state(yyscanner );
		3102	}
		3103
		3104
		3105	* the current state. This function will allocate the stack
		3106	* if necessary.
		3107	* @param new_buffer The new state.
		3108	* @param yyscanner The scanner object.
		3109	*/
		3110	void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
		3111	{
		3112	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3113	if (new_buffer == NULL)
		3114	return;
		3115
		3116
		3117
		3118
		3119	if ( YY_CURRENT_BUFFER )
		3120	{
		3121	/* Flush out information for old buffer. */
		3122	*yyg->yy_c_buf_p = yyg->yy_hold_char;
		3123	YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		3124	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		3125	}
		3126
		3127
		3128	if (YY_CURRENT_BUFFER)
		3129	yyg->yy_buffer_stack_top++;
		3130	YY_CURRENT_BUFFER_LVALUE = new_buffer;
		3131
		3132
		3133	yy_load_buffer_state(yyscanner );
		3134	yyg->yy_did_buffer_switch_on_eof = 1;
		3135	}
		3136
		3137
		3138	* The next element becomes the new top.
		3139	* @param yyscanner The scanner object.
		3140	*/
		3141	void yypop_buffer_state (yyscan_t yyscanner)
		3142	{
		3143	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3144	if (!YY_CURRENT_BUFFER)
		3145	return;
		3146
		3147
		3148	YY_CURRENT_BUFFER_LVALUE = NULL;
		3149	if (yyg->yy_buffer_stack_top > 0)
		3150	--yyg->yy_buffer_stack_top;
		3151
		3152
		3153	yy_load_buffer_state(yyscanner );
		3154	yyg->yy_did_buffer_switch_on_eof = 1;
		3155	}
		3156	}
		3157
		3158
		3159	* Guarantees space for at least one push.
		3160	*/
		3161	static void yyensure_buffer_stack (yyscan_t yyscanner)
		3162	{
		3163	int num_to_alloc;
		3164	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3165
		3166
		3167
		3168
		3169	* scanner will even need a stack. We use 2 instead of 1 to avoid an
		3170	* immediate realloc on the next call.
		3171	*/
		3172	num_to_alloc = 1;
		3173	yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
		3174	(num_to_alloc * sizeof(struct yy_buffer_state*)
		3175	, yyscanner);
		3176	if ( ! yyg->yy_buffer_stack )
		3177	YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
		3178
		3179
		3180
		3181
		3182	yyg->yy_buffer_stack_top = 0;
		3183	return;
		3184	}
		3185
		3186
		3187
		3188
		3189	int grow_size = 8 /* arbitrary grow size */;
		3190
		3191
		3192	yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
		3193	(yyg->yy_buffer_stack,
		3194	num_to_alloc * sizeof(struct yy_buffer_state*)
		3195	, yyscanner);
		3196	if ( ! yyg->yy_buffer_stack )
		3197	YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
		3198
		3199
		3200	memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
		3201	yyg->yy_buffer_stack_max = num_to_alloc;
		3202	}
		3203	}
		3204
		3205
		3206	* @param base the character buffer
		3207	* @param size the size in bytes of the character buffer
		3208	* @param yyscanner The scanner object.
		3209	* @return the newly allocated buffer state object.
		3210	*/
		3211	YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
		3212	{
		3213	YY_BUFFER_STATE b;
		3214
		3215
		3216	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
		3217	base[size-1] != YY_END_OF_BUFFER_CHAR )
		3218	/* They forgot to leave room for the EOB's. */
		3219	return 0;
		3220
		3221
		3222	if ( ! b )
		3223	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
		3224
		3225
		3226	b->yy_buf_pos = b->yy_ch_buf = base;
		3227	b->yy_is_our_buffer = 0;
		3228	b->yy_input_file = 0;
		3229	b->yy_n_chars = b->yy_buf_size;
		3230	b->yy_is_interactive = 0;
		3231	b->yy_at_bol = 1;
		3232	b->yy_fill_buffer = 0;
		3233	b->yy_buffer_status = YY_BUFFER_NEW;
		3234
		3235
		3236
		3237
		3238	}
		3239
		3240
		3241	* scan from a @e copy of @a str.
		3242	* @param yystr a NUL-terminated string to scan
		3243	* @param yyscanner The scanner object.
		3244	* @return the newly allocated buffer state object.
		3245	* @note If you want to scan bytes that may contain NUL values, then use
		3246	* yy_scan_bytes() instead.
		3247	*/
		3248	YY_BUFFER_STATE yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
		3249	{
		3250
		3251
		3252	}
		3253
		3254
		3255	* scan from a @e copy of @a bytes.
		3256	* @param yybytes the byte buffer to scan
		3257	* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
		3258	* @param yyscanner The scanner object.
		3259	* @return the newly allocated buffer state object.
		3260	*/
		3261	YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
		3262	{
		3263	YY_BUFFER_STATE b;
		3264	char *buf;
		3265	yy_size_t n;
		3266	int i;
		3267
		3268
		3269	n = _yybytes_len + 2;
		3270	buf = (char *) yyalloc(n ,yyscanner );
		3271	if ( ! buf )
		3272	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
		3273
		3274
		3275	buf[i] = yybytes[i];
		3276
		3277
		3278
		3279
		3280	if ( ! b )
		3281	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
		3282
		3283
		3284	* away when we're done.
		3285	*/
		3286	b->yy_is_our_buffer = 1;
		3287
		3288
		3289	}
		3290
		3291
		3292	#define YY_EXIT_FAILURE 2
		3293	#endif
		3294
		3295
		3296	{
		3297	(void) fprintf( stderr, "%s\n", msg );
		3298	exit( YY_EXIT_FAILURE );
		3299	}
		3300
		3301
		3302
		3303
		3304	#define yyless(n) \
		3305	do \
		3306	{ \
		3307	/* Undo effects of setting up yytext. */ \
		3308	int yyless_macro_arg = (n); \
		3309	YY_LESS_LINENO(yyless_macro_arg);\
		3310	yytext[yyleng] = yyg->yy_hold_char; \
		3311	yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
		3312	yyg->yy_hold_char = *yyg->yy_c_buf_p; \
		3313	*yyg->yy_c_buf_p = '\0'; \
		3314	yyleng = yyless_macro_arg; \
		3315	} \
		3316	while ( 0 )
		3317
		3318
		3319
		3320
		3321	* @param yyscanner The scanner object.
		3322	*/
		3323	YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
		3324	{
		3325	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3326	return yyextra;
		3327	}
		3328
		3329
		3330	* @param yyscanner The scanner object.
		3331	*/
		3332	int yyget_lineno (yyscan_t yyscanner)
		3333	{
		3334	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3335
		3336
		3337	return 0;
		3338
		3339
		3340	}
		3341
		3342
		3343	* @param yyscanner The scanner object.
		3344	*/
		3345	int yyget_column (yyscan_t yyscanner)
		3346	{
		3347	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3348
		3349
		3350	return 0;
		3351
		3352
		3353	}
		3354
		3355
		3356	* @param yyscanner The scanner object.
		3357	*/
		3358	FILE *yyget_in (yyscan_t yyscanner)
		3359	{
		3360	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3361	return yyin;
		3362	}
		3363
		3364
		3365	* @param yyscanner The scanner object.
		3366	*/
		3367	FILE *yyget_out (yyscan_t yyscanner)
		3368	{
		3369	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3370	return yyout;
		3371	}
		3372
		3373
		3374	* @param yyscanner The scanner object.
		3375	*/
		3376	int yyget_leng (yyscan_t yyscanner)
		3377	{
		3378	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3379	return yyleng;
		3380	}
		3381
		3382
		3383	* @param yyscanner The scanner object.
		3384	*/
		3385
		3386
		3387	{
		3388	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3389	return yytext;
		3390	}
		3391
		3392
		3393	* @param user_defined The data to be associated with this scanner.
		3394	* @param yyscanner The scanner object.
		3395	*/
		3396	void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
		3397	{
		3398	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3399	yyextra = user_defined ;
		3400	}
		3401
		3402
		3403	* @param line_number
		3404	* @param yyscanner The scanner object.
		3405	*/
		3406	void yyset_lineno (int line_number , yyscan_t yyscanner)
		3407	{
		3408	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3409
		3410
		3411	if (! YY_CURRENT_BUFFER )
		3412	yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner);
		3413
		3414
		3415	}
		3416
		3417
		3418	* @param line_number
		3419	* @param yyscanner The scanner object.
		3420	*/
		3421	void yyset_column (int column_no , yyscan_t yyscanner)
		3422	{
		3423	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3424
		3425
		3426	if (! YY_CURRENT_BUFFER )
		3427	yy_fatal_error( "yyset_column called with no buffer" , yyscanner);
		3428
		3429
		3430	}
		3431
		3432
		3433	* input buffer.
		3434	* @param in_str A readable stream.
		3435	* @param yyscanner The scanner object.
		3436	* @see yy_switch_to_buffer
		3437	*/
		3438	void yyset_in (FILE * in_str , yyscan_t yyscanner)
		3439	{
		3440	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3441	yyin = in_str ;
		3442	}
		3443
		3444
		3445	{
		3446	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3447	yyout = out_str ;
		3448	}
		3449
		3450
		3451	{
		3452	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3453	return yy_flex_debug;
		3454	}
		3455
		3456
		3457	{
		3458	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3459	yy_flex_debug = bdebug ;
		3460	}
		3461
		3462
		3463
		3464
		3465	{
		3466	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3467	return yylval;
		3468	}
		3469
		3470
		3471	{
		3472	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3473	yylval = yylval_param;
		3474	}
		3475
		3476
		3477	{
		3478	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3479	return yylloc;
		3480	}
		3481
		3482
		3483	{
		3484	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3485	yylloc = yylloc_param;
		3486	}
		3487
		3488
		3489
		3490
		3491	* the ONLY reentrant function that doesn't take the scanner as the last argument.
		3492	* That's why we explicitly handle the declaration, instead of using our macros.
		3493	*/
		3494
		3495
		3496
		3497
		3498	if (ptr_yy_globals == NULL){
		3499	errno = EINVAL;
		3500	return 1;
		3501	}
		3502
		3503
		3504
		3505
		3506	errno = ENOMEM;
		3507	return 1;
		3508	}
		3509
		3510
		3511	memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
		3512
		3513
		3514	}
		3515
		3516
		3517	* convention of taking the scanner as the last argument. Note however, that
		3518	* this is a pointer to a scanner, as it will be allocated by this call (and
		3519	* is the reason, too, why this function also must handle its own declaration).
		3520	* The user defined value in the first argument will be available to yyalloc in
		3521	* the yyextra field.
		3522	*/
		3523
		3524
		3525
		3526
		3527	struct yyguts_t dummy_yyguts;
		3528
		3529
		3530
		3531
		3532	errno = EINVAL;
		3533	return 1;
		3534	}
		3535
		3536
		3537
		3538
		3539	errno = ENOMEM;
		3540	return 1;
		3541	}
		3542
		3543
		3544	yy_init_globals. Leave at 0x00 for releases. */
		3545	memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
		3546
		3547
		3548
		3549
		3550	}
		3551
		3552
		3553	{
		3554	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3555	/* Initialization is the same as for the non-reentrant scanner.
		3556	* This function is called from yylex_destroy(), so don't allocate here.
		3557	*/
		3558
		3559
		3560	yyg->yy_buffer_stack_top = 0;
		3561	yyg->yy_buffer_stack_max = 0;
		3562	yyg->yy_c_buf_p = (char *) 0;
		3563	yyg->yy_init = 0;
		3564	yyg->yy_start = 0;
		3565
		3566
		3567	yyg->yy_start_stack_depth = 0;
		3568	yyg->yy_start_stack = NULL;
		3569
		3570
		3571	#ifdef YY_STDINIT
		3572	yyin = stdin;
		3573	yyout = stdout;
		3574	#else
		3575	yyin = (FILE *) 0;
		3576	yyout = (FILE *) 0;
		3577	#endif
		3578
		3579
		3580	* yylex_init()
		3581	*/
		3582	return 0;
		3583	}
		3584
		3585
		3586	int yylex_destroy (yyscan_t yyscanner)
		3587	{
		3588	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
		3589
		3590
		3591	while(YY_CURRENT_BUFFER){
		3592	yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
		3593	YY_CURRENT_BUFFER_LVALUE = NULL;
		3594	yypop_buffer_state(yyscanner);
		3595	}
		3596
		3597
		3598	yyfree(yyg->yy_buffer_stack ,yyscanner);
		3599	yyg->yy_buffer_stack = NULL;
		3600
		3601
		3602	yyfree(yyg->yy_start_stack ,yyscanner );
		3603	yyg->yy_start_stack = NULL;
		3604
		3605
		3606	* yylex() is called, initialization will occur. */
		3607	yy_init_globals( yyscanner);
		3608
		3609
		3610	yyfree ( yyscanner , yyscanner );
		3611	yyscanner = NULL;
		3612	return 0;
		3613	}
		3614
		3615
		3616	* Internal utility routines.
		3617	*/
		3618
		3619
		3620	static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
		3621	{
		3622	register int i;
		3623	for ( i = 0; i < n; ++i )
		3624	s1[i] = s2[i];
		3625	}
		3626	#endif
		3627
		3628
		3629	static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
		3630	{
		3631	register int n;
		3632	for ( n = 0; s[n]; ++n )
		3633	;
		3634
		3635
		3636	}
		3637	#endif
		3638
		3639
		3640	{
		3641	return (void *) malloc( size );
		3642	}
		3643
		3644
		3645	{
		3646	/* The cast to (char *) in the following accommodates both
		3647	* implementations that use char* generic pointers, and those
		3648	* that use void* generic pointers. It works with the latter
		3649	* because both ANSI C and C++ allow castless assignment from
		3650	* any pointer type to void*, and deal with argument conversions
		3651	* as though doing an assignment.
		3652	*/
		3653	return (void ) realloc( (char ) ptr, size );
		3654	}
		3655
		3656
		3657	{
		3658	free( (char ) ptr ); / see yyrealloc() for (char ) cast /
		3659	}
		3660
		3661
		3662
		3663
		3664
		3665
		3666
		3667
		3668	_mesa_program_lexer_ctor(void *scanner, struct asm_parser_state state,
		3669	const char *string, size_t len)
		3670	{
		3671	yylex_init_extra(state,scanner);
		3672	yy_scan_bytes(string,len,*scanner);
		3673	}
		3674
		3675
		3676	_mesa_program_lexer_dtor(void *scanner)
		3677	{
		3678	yylex_destroy(scanner);
		3679	}
		3680

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/mesa/program/lex.yy.c – Rev 1901