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