Rev 5563 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5563 | serge | 1 | |
7195 | punk_joker | 2 | |
5563 | serge | 3 | |
4 | |||
5 | |||
6 | |||
7 | |||
8 | #define YY_FLEX_MAJOR_VERSION 2 |
||
9 | #define YY_FLEX_MINOR_VERSION 6 |
||
7195 | punk_joker | 10 | #define YY_FLEX_SUBMINOR_VERSION 4 |
11 | #if YY_FLEX_SUBMINOR_VERSION > 0 |
||
5563 | serge | 12 | #define FLEX_BETA |
13 | #endif |
||
14 | |||
15 | |||
7195 | punk_joker | 16 | #define glcpp__create_buffer_ALREADY_DEFINED |
17 | #else |
||
18 | #define yy_create_buffer glcpp__create_buffer |
||
19 | #endif |
||
20 | |||
21 | |||
22 | #define glcpp__delete_buffer_ALREADY_DEFINED |
||
23 | #else |
||
24 | #define yy_delete_buffer glcpp__delete_buffer |
||
25 | #endif |
||
26 | |||
27 | |||
28 | #define glcpp__scan_buffer_ALREADY_DEFINED |
||
29 | #else |
||
30 | #define yy_scan_buffer glcpp__scan_buffer |
||
31 | #endif |
||
32 | |||
33 | |||
34 | #define glcpp__scan_string_ALREADY_DEFINED |
||
35 | #else |
||
36 | #define yy_scan_string glcpp__scan_string |
||
37 | #endif |
||
38 | |||
39 | |||
40 | #define glcpp__scan_bytes_ALREADY_DEFINED |
||
41 | #else |
||
42 | #define yy_scan_bytes glcpp__scan_bytes |
||
43 | #endif |
||
44 | |||
45 | |||
46 | #define glcpp__init_buffer_ALREADY_DEFINED |
||
47 | #else |
||
48 | #define yy_init_buffer glcpp__init_buffer |
||
49 | #endif |
||
50 | |||
51 | |||
52 | #define glcpp__flush_buffer_ALREADY_DEFINED |
||
53 | #else |
||
54 | #define yy_flush_buffer glcpp__flush_buffer |
||
55 | #endif |
||
56 | |||
57 | |||
58 | #define glcpp__load_buffer_state_ALREADY_DEFINED |
||
59 | #else |
||
60 | #define yy_load_buffer_state glcpp__load_buffer_state |
||
61 | #endif |
||
62 | |||
63 | |||
64 | #define glcpp__switch_to_buffer_ALREADY_DEFINED |
||
65 | #else |
||
66 | #define yy_switch_to_buffer glcpp__switch_to_buffer |
||
67 | #endif |
||
68 | |||
69 | |||
70 | #define glcpp_push_buffer_state_ALREADY_DEFINED |
||
71 | #else |
||
72 | #define yypush_buffer_state glcpp_push_buffer_state |
||
73 | #endif |
||
74 | |||
75 | |||
76 | #define glcpp_pop_buffer_state_ALREADY_DEFINED |
||
77 | #else |
||
78 | #define yypop_buffer_state glcpp_pop_buffer_state |
||
79 | #endif |
||
80 | |||
81 | |||
82 | #define glcpp_ensure_buffer_stack_ALREADY_DEFINED |
||
83 | #else |
||
84 | #define yyensure_buffer_stack glcpp_ensure_buffer_stack |
||
85 | #endif |
||
86 | |||
87 | |||
88 | #define glcpp_lex_ALREADY_DEFINED |
||
89 | #else |
||
90 | #define yylex glcpp_lex |
||
91 | #endif |
||
92 | |||
93 | |||
94 | #define glcpp_restart_ALREADY_DEFINED |
||
95 | #else |
||
96 | #define yyrestart glcpp_restart |
||
97 | #endif |
||
98 | |||
99 | |||
100 | #define glcpp_lex_init_ALREADY_DEFINED |
||
101 | #else |
||
102 | #define yylex_init glcpp_lex_init |
||
103 | #endif |
||
104 | |||
105 | |||
106 | #define glcpp_lex_init_extra_ALREADY_DEFINED |
||
107 | #else |
||
108 | #define yylex_init_extra glcpp_lex_init_extra |
||
109 | #endif |
||
110 | |||
111 | |||
112 | #define glcpp_lex_destroy_ALREADY_DEFINED |
||
113 | #else |
||
114 | #define yylex_destroy glcpp_lex_destroy |
||
115 | #endif |
||
116 | |||
117 | |||
118 | #define glcpp_get_debug_ALREADY_DEFINED |
||
119 | #else |
||
120 | #define yyget_debug glcpp_get_debug |
||
121 | #endif |
||
122 | |||
123 | |||
124 | #define glcpp_set_debug_ALREADY_DEFINED |
||
125 | #else |
||
126 | #define yyset_debug glcpp_set_debug |
||
127 | #endif |
||
128 | |||
129 | |||
130 | #define glcpp_get_extra_ALREADY_DEFINED |
||
131 | #else |
||
132 | #define yyget_extra glcpp_get_extra |
||
133 | #endif |
||
134 | |||
135 | |||
136 | #define glcpp_set_extra_ALREADY_DEFINED |
||
137 | #else |
||
138 | #define yyset_extra glcpp_set_extra |
||
139 | #endif |
||
140 | |||
141 | |||
142 | #define glcpp_get_in_ALREADY_DEFINED |
||
143 | #else |
||
144 | #define yyget_in glcpp_get_in |
||
145 | #endif |
||
146 | |||
147 | |||
148 | #define glcpp_set_in_ALREADY_DEFINED |
||
149 | #else |
||
150 | #define yyset_in glcpp_set_in |
||
151 | #endif |
||
152 | |||
153 | |||
154 | #define glcpp_get_out_ALREADY_DEFINED |
||
155 | #else |
||
156 | #define yyget_out glcpp_get_out |
||
157 | #endif |
||
158 | |||
159 | |||
160 | #define glcpp_set_out_ALREADY_DEFINED |
||
161 | #else |
||
162 | #define yyset_out glcpp_set_out |
||
163 | #endif |
||
164 | |||
165 | |||
166 | #define glcpp_get_leng_ALREADY_DEFINED |
||
167 | #else |
||
168 | #define yyget_leng glcpp_get_leng |
||
169 | #endif |
||
170 | |||
171 | |||
172 | #define glcpp_get_text_ALREADY_DEFINED |
||
173 | #else |
||
174 | #define yyget_text glcpp_get_text |
||
175 | #endif |
||
176 | |||
177 | |||
178 | #define glcpp_get_lineno_ALREADY_DEFINED |
||
179 | #else |
||
180 | #define yyget_lineno glcpp_get_lineno |
||
181 | #endif |
||
182 | |||
183 | |||
184 | #define glcpp_set_lineno_ALREADY_DEFINED |
||
185 | #else |
||
186 | #define yyset_lineno glcpp_set_lineno |
||
187 | #endif |
||
188 | |||
189 | |||
190 | #define glcpp_get_column_ALREADY_DEFINED |
||
191 | #else |
||
192 | #define yyget_column glcpp_get_column |
||
193 | #endif |
||
194 | |||
195 | |||
196 | #define glcpp_set_column_ALREADY_DEFINED |
||
197 | #else |
||
198 | #define yyset_column glcpp_set_column |
||
199 | #endif |
||
200 | |||
201 | |||
202 | #define glcpp_wrap_ALREADY_DEFINED |
||
203 | #else |
||
204 | #define yywrap glcpp_wrap |
||
205 | #endif |
||
206 | |||
207 | |||
208 | #define glcpp_get_lval_ALREADY_DEFINED |
||
209 | #else |
||
210 | #define yyget_lval glcpp_get_lval |
||
211 | #endif |
||
212 | |||
213 | |||
214 | #define glcpp_set_lval_ALREADY_DEFINED |
||
215 | #else |
||
216 | #define yyset_lval glcpp_set_lval |
||
217 | #endif |
||
218 | |||
219 | |||
220 | #define glcpp_get_lloc_ALREADY_DEFINED |
||
221 | #else |
||
222 | #define yyget_lloc glcpp_get_lloc |
||
223 | #endif |
||
224 | |||
225 | |||
226 | #define glcpp_set_lloc_ALREADY_DEFINED |
||
227 | #else |
||
228 | #define yyset_lloc glcpp_set_lloc |
||
229 | #endif |
||
230 | |||
231 | |||
232 | #define glcpp_alloc_ALREADY_DEFINED |
||
233 | #else |
||
234 | #define yyalloc glcpp_alloc |
||
235 | #endif |
||
236 | |||
237 | |||
238 | #define glcpp_realloc_ALREADY_DEFINED |
||
239 | #else |
||
240 | #define yyrealloc glcpp_realloc |
||
241 | #endif |
||
242 | |||
243 | |||
244 | #define glcpp_free_ALREADY_DEFINED |
||
245 | #else |
||
246 | #define yyfree glcpp_free |
||
247 | #endif |
||
248 | |||
249 | |||
5563 | serge | 250 | |
251 | |||
252 | #include |
||
253 | #include |
||
254 | #include |
||
255 | #include |
||
256 | |||
257 | |||
258 | |||
259 | |||
260 | |||
261 | |||
262 | #define FLEXINT_H |
||
263 | |||
264 | |||
265 | |||
266 | |||
267 | |||
268 | |||
269 | * if you want the limit (max/min) macros for int types. |
||
270 | */ |
||
271 | #ifndef __STDC_LIMIT_MACROS |
||
272 | #define __STDC_LIMIT_MACROS 1 |
||
273 | #endif |
||
274 | |||
275 | |||
276 | typedef int8_t flex_int8_t; |
||
277 | typedef uint8_t flex_uint8_t; |
||
278 | typedef int16_t flex_int16_t; |
||
279 | typedef uint16_t flex_uint16_t; |
||
280 | typedef int32_t flex_int32_t; |
||
281 | typedef uint32_t flex_uint32_t; |
||
282 | #else |
||
283 | typedef signed char flex_int8_t; |
||
284 | typedef short int flex_int16_t; |
||
285 | typedef int flex_int32_t; |
||
286 | typedef unsigned char flex_uint8_t; |
||
287 | typedef unsigned short int flex_uint16_t; |
||
288 | typedef unsigned int flex_uint32_t; |
||
289 | |||
290 | |||
291 | #ifndef INT8_MIN |
||
292 | #define INT8_MIN (-128) |
||
293 | #endif |
||
294 | #ifndef INT16_MIN |
||
295 | #define INT16_MIN (-32767-1) |
||
296 | #endif |
||
297 | #ifndef INT32_MIN |
||
298 | #define INT32_MIN (-2147483647-1) |
||
299 | #endif |
||
300 | #ifndef INT8_MAX |
||
301 | #define INT8_MAX (127) |
||
302 | #endif |
||
303 | #ifndef INT16_MAX |
||
304 | #define INT16_MAX (32767) |
||
305 | #endif |
||
306 | #ifndef INT32_MAX |
||
307 | #define INT32_MAX (2147483647) |
||
308 | #endif |
||
309 | #ifndef UINT8_MAX |
||
310 | #define UINT8_MAX (255U) |
||
311 | #endif |
||
312 | #ifndef UINT16_MAX |
||
313 | #define UINT16_MAX (65535U) |
||
314 | #endif |
||
315 | #ifndef UINT32_MAX |
||
316 | #define UINT32_MAX (4294967295U) |
||
317 | #endif |
||
318 | |||
319 | |||
7195 | punk_joker | 320 | #define SIZE_MAX (~(size_t)0) |
321 | #endif |
||
322 | |||
323 | |||
5563 | serge | 324 | |
325 | |||
326 | |||
327 | |||
7195 | punk_joker | 328 | |
5563 | serge | 329 | |
7195 | punk_joker | 330 | #define yyconst const |
331 | |||
5563 | serge | 332 | |
7195 | punk_joker | 333 | #define yynoreturn __attribute__((__noreturn__)) |
334 | #else |
||
5563 | serge | 335 | #define yynoreturn |
7195 | punk_joker | 336 | #endif |
5563 | serge | 337 | |
338 | |||
339 | #define YY_NULL 0 |
||
340 | |||
341 | |||
7195 | punk_joker | 342 | * integer in range [0..255] for use as an array index. |
343 | */ |
||
5563 | serge | 344 | #define YY_SC_TO_UI(c) ((YY_CHAR) (c)) |
7195 | punk_joker | 345 | |
5563 | serge | 346 | |
347 | #ifndef YY_TYPEDEF_YY_SCANNER_T |
||
348 | #define YY_TYPEDEF_YY_SCANNER_T |
||
349 | typedef void* yyscan_t; |
||
350 | #endif |
||
351 | |||
352 | |||
353 | are macros in the reentrant scanner. */ |
||
354 | #define yyin yyg->yyin_r |
||
355 | #define yyout yyg->yyout_r |
||
356 | #define yyextra yyg->yyextra_r |
||
357 | #define yyleng yyg->yyleng_r |
||
358 | #define yytext yyg->yytext_r |
||
359 | #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) |
||
360 | #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) |
||
361 | #define yy_flex_debug yyg->yy_flex_debug_r |
||
362 | |||
363 | |||
364 | * but we do it the disgusting crufty way forced on us by the ()-less |
||
365 | * definition of BEGIN. |
||
366 | */ |
||
367 | #define BEGIN yyg->yy_start = 1 + 2 * |
||
368 | /* Translate the current start state into a value that can be later handed |
||
369 | * to BEGIN to return to the state. The YYSTATE alias is for lex |
||
370 | * compatibility. |
||
371 | */ |
||
372 | #define YY_START ((yyg->yy_start - 1) / 2) |
||
373 | #define YYSTATE YY_START |
||
374 | /* Action number for EOF rule of a given start state. */ |
||
375 | #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) |
||
376 | /* Special action meaning "start processing a new file". */ |
||
377 | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) |
||
7195 | punk_joker | 378 | #define YY_END_OF_BUFFER_CHAR 0 |
5563 | serge | 379 | |
380 | |||
381 | #ifndef YY_BUF_SIZE |
||
382 | #ifdef __ia64__ |
||
383 | /* On IA-64, the buffer size is 16k, not 8k. |
||
384 | * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. |
||
385 | * Ditto for the __ia64__ case accordingly. |
||
386 | */ |
||
387 | #define YY_BUF_SIZE 32768 |
||
388 | #else |
||
389 | #define YY_BUF_SIZE 16384 |
||
390 | #endif /* __ia64__ */ |
||
391 | #endif |
||
392 | |||
393 | |||
394 | */ |
||
395 | #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) |
||
396 | |||
397 | |||
398 | #define YY_TYPEDEF_YY_BUFFER_STATE |
||
399 | typedef struct yy_buffer_state *YY_BUFFER_STATE; |
||
400 | #endif |
||
401 | |||
402 | |||
7195 | punk_joker | 403 | #define YY_TYPEDEF_YY_SIZE_T |
404 | typedef size_t yy_size_t; |
||
405 | #endif |
||
406 | |||
407 | |||
5563 | serge | 408 | #define EOB_ACT_END_OF_FILE 1 |
409 | #define EOB_ACT_LAST_MATCH 2 |
||
410 | |||
7195 | punk_joker | 411 | |
5563 | serge | 412 | #define YY_LINENO_REWIND_TO(ptr) |
7195 | punk_joker | 413 | |
5563 | serge | 414 | |
415 | #define yyless(n) \ |
||
416 | do \ |
||
417 | { \ |
||
418 | /* Undo effects of setting up yytext. */ \ |
||
419 | int yyless_macro_arg = (n); \ |
||
420 | YY_LESS_LINENO(yyless_macro_arg);\ |
||
421 | *yy_cp = yyg->yy_hold_char; \ |
||
422 | YY_RESTORE_YY_MORE_OFFSET \ |
||
423 | yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ |
||
424 | YY_DO_BEFORE_ACTION; /* set up yytext again */ \ |
||
425 | } \ |
||
426 | while ( 0 ) |
||
427 | #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) |
||
428 | |||
429 | |||
430 | #define YY_STRUCT_YY_BUFFER_STATE |
||
431 | struct yy_buffer_state |
||
432 | { |
||
433 | FILE *yy_input_file; |
||
434 | |||
435 | |||
436 | char *yy_buf_pos; /* current position in input buffer */ |
||
437 | |||
438 | |||
439 | * characters. |
||
440 | */ |
||
441 | int yy_buf_size; |
||
7195 | punk_joker | 442 | |
5563 | serge | 443 | |
444 | * characters. |
||
445 | */ |
||
446 | int yy_n_chars; |
||
447 | |||
448 | |||
449 | * and can realloc() it to grow it, and should free() it to |
||
450 | * delete it. |
||
451 | */ |
||
452 | int yy_is_our_buffer; |
||
453 | |||
454 | |||
455 | * if we're using stdio for input, then we want to use getc() |
||
456 | * instead of fread(), to make sure we stop fetching input after |
||
457 | * each newline. |
||
458 | */ |
||
459 | int yy_is_interactive; |
||
460 | |||
461 | |||
462 | * If so, '^' rules will be active on the next match, otherwise |
||
463 | * not. |
||
464 | */ |
||
465 | int yy_at_bol; |
||
466 | |||
467 | |||
468 | int yy_bs_column; /**< The column count. */ |
||
469 | |||
7195 | punk_joker | 470 | |
5563 | serge | 471 | * end of it. |
472 | */ |
||
473 | int yy_fill_buffer; |
||
474 | |||
475 | |||
476 | |||
477 | |||
478 | #define YY_BUFFER_NORMAL 1 |
||
479 | /* When an EOF's been seen but there's still some text to process |
||
480 | * then we mark the buffer as YY_EOF_PENDING, to indicate that we |
||
481 | * shouldn't try reading from the input source any more. We might |
||
482 | * still have a bunch of tokens to match, though, because of |
||
483 | * possible backing-up. |
||
484 | * |
||
485 | * When we actually see the EOF, we change the status to "new" |
||
486 | * (via yyrestart()), so that the user can continue scanning by |
||
7195 | punk_joker | 487 | * just pointing yyin at a new input file. |
5563 | serge | 488 | */ |
489 | #define YY_BUFFER_EOF_PENDING 2 |
||
490 | |||
491 | |||
492 | #endif /* !YY_STRUCT_YY_BUFFER_STATE */ |
||
493 | |||
494 | |||
495 | * future we want to put the buffer states in a more general |
||
496 | * "scanner state". |
||
497 | * |
||
498 | * Returns the top of the stack, or NULL. |
||
499 | */ |
||
500 | #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ |
||
501 | ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ |
||
502 | : NULL) |
||
503 | /* Same as previous macro, but useful when we know that the buffer stack is not |
||
504 | * NULL or when we need an lvalue. For internal use only. |
||
505 | */ |
||
506 | #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] |
||
507 | |||
508 | |||
7195 | punk_joker | 509 | void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); |
510 | YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); |
||
511 | void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); |
||
512 | void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); |
||
513 | void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); |
||
514 | void yypop_buffer_state ( yyscan_t yyscanner ); |
||
515 | |||
5563 | serge | 516 | |
7195 | punk_joker | 517 | static void yy_load_buffer_state ( yyscan_t yyscanner ); |
518 | static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner ); |
||
519 | #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner) |
||
520 | |||
5563 | serge | 521 | |
7195 | punk_joker | 522 | YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); |
523 | YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); |
||
524 | |||
5563 | serge | 525 | |
7195 | punk_joker | 526 | void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); |
527 | void yyfree ( void * , yyscan_t yyscanner ); |
||
528 | |||
5563 | serge | 529 | |
7195 | punk_joker | 530 | #define yy_set_interactive(is_interactive) \ |
5563 | serge | 531 | { \ |
532 | if ( ! YY_CURRENT_BUFFER ){ \ |
||
533 | yyensure_buffer_stack (yyscanner); \ |
||
7195 | punk_joker | 534 | YY_CURRENT_BUFFER_LVALUE = \ |
5563 | serge | 535 | yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ |
7195 | punk_joker | 536 | } \ |
5563 | serge | 537 | YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ |
538 | } |
||
539 | #define yy_set_bol(at_bol) \ |
||
540 | { \ |
||
541 | if ( ! YY_CURRENT_BUFFER ){\ |
||
542 | yyensure_buffer_stack (yyscanner); \ |
||
7195 | punk_joker | 543 | YY_CURRENT_BUFFER_LVALUE = \ |
5563 | serge | 544 | yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ |
7195 | punk_joker | 545 | } \ |
5563 | serge | 546 | YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ |
547 | } |
||
548 | #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) |
||
549 | |||
550 | |||
551 | |||
552 | |||
7195 | punk_joker | 553 | #define YY_SKIP_YYWRAP |
5563 | serge | 554 | typedef flex_uint8_t YY_CHAR; |
7195 | punk_joker | 555 | |
5563 | serge | 556 | |
557 | |||
558 | |||
559 | |||
560 | |||
7195 | punk_joker | 561 | static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner); |
562 | static int yy_get_next_buffer ( yyscan_t yyscanner ); |
||
563 | static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); |
||
564 | |||
5563 | serge | 565 | |
566 | * corresponding action - sets up yytext. |
||
567 | */ |
||
568 | #define YY_DO_BEFORE_ACTION \ |
||
569 | yyg->yytext_ptr = yy_bp; \ |
||
570 | yyleng = (int) (yy_cp - yy_bp); \ |
||
7195 | punk_joker | 571 | yyg->yy_hold_char = *yy_cp; \ |
5563 | serge | 572 | *yy_cp = '\0'; \ |
573 | yyg->yy_c_buf_p = yy_cp; |
||
574 | #define YY_NUM_RULES 43 |
||
575 | #define YY_END_OF_BUFFER 44 |
||
576 | /* This struct is not used in this scanner, |
||
577 | but its presence is necessary. */ |
||
578 | struct yy_trans_info |
||
579 | { |
||
580 | flex_int32_t yy_verify; |
||
581 | flex_int32_t yy_nxt; |
||
582 | }; |
||
583 | static const flex_int16_t yy_accept[150] = |
||
7195 | punk_joker | 584 | { 0, |
5563 | serge | 585 | 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, |
586 | 0, 0, 44, 39, 40, 41, 43, 38, 43, 38, |
||
587 | 38, 38, 25, 24, 38, 38, 38, 37, 37, 38, |
||
588 | 40, 23, 3, 4, 5, 42, 17, 17, 17, 21, |
||
589 | 39, 40, 32, 35, 33, 2, 1, 25, 25, 0, |
||
590 | 24, 24, 27, 29, 31, 30, 28, 37, 37, 34, |
||
591 | 40, 23, 23, 0, 0, 0, 0, 0, 0, 0, |
||
592 | 3, 4, 5, 6, 5, 7, 0, 0, 0, 0, |
||
593 | 20, 21, 1, 26, 37, 0, 0, 0, 0, 0, |
||
594 | 0, 0, 0, 0, 0, 26, 37, 0, 0, 0, |
||
595 | |||
596 | |||
597 | 37, 0, 0, 15, 0, 0, 0, 0, 0, 0, |
||
598 | 0, 0, 0, 37, 0, 14, 16, 18, 0, 11, |
||
599 | 0, 10, 0, 22, 0, 36, 0, 18, 0, 12, |
||
600 | 0, 0, 19, 0, 9, 0, 0, 8, 0 |
||
601 | } ; |
||
602 | |||
603 | |||
7195 | punk_joker | 604 | { 0, |
5563 | serge | 605 | 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, |
606 | 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, |
||
607 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
608 | 1, 2, 5, 1, 6, 1, 7, 8, 1, 9, |
||
609 | 7, 10, 7, 7, 7, 7, 11, 12, 13, 13, |
||
610 | 13, 13, 13, 13, 13, 14, 14, 1, 7, 15, |
||
611 | 16, 17, 1, 1, 18, 18, 18, 18, 18, 18, |
||
612 | 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, |
||
613 | 19, 19, 19, 19, 20, 19, 19, 21, 19, 19, |
||
614 | 7, 1, 7, 7, 19, 1, 22, 18, 18, 23, |
||
615 | |||
616 | |||
617 | 31, 32, 19, 33, 34, 35, 36, 37, 19, 38, |
||
618 | 19, 19, 7, 39, 7, 7, 1, 1, 1, 1, |
||
619 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
620 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
621 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
622 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
623 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
624 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
625 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
626 | |||
627 | |||
628 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
629 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
630 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
631 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
632 | 1, 1, 1, 1, 1 |
||
633 | } ; |
||
634 | |||
635 | |||
7195 | punk_joker | 636 | { 0, |
5563 | serge | 637 | 1, 1, 2, 1, 1, 1, 1, 1, 3, 4, |
638 | 1, 5, 5, 5, 1, 1, 1, 5, 6, 6, |
||
639 | 6, 5, 7, 5, 5, 6, 6, 6, 6, 8, |
||
640 | 6, 6, 6, 6, 6, 6, 6, 6, 1 |
||
641 | } ; |
||
642 | |||
643 | |||
7195 | punk_joker | 644 | { 0, |
5563 | serge | 645 | 0, 38, 0, 0, 38, 39, 321, 320, 319, 44, |
646 | 50, 0, 321, 319, 317, 325, 325, 302, 311, 325, |
||
647 | 308, 80, 80, 83, 83, 299, 88, 0, 290, 274, |
||
648 | 100, 118, 309, 325, 104, 325, 325, 106, 107, 302, |
||
649 | 309, 307, 325, 325, 325, 325, 0, 113, 325, 0, |
||
650 | 115, 325, 325, 325, 325, 325, 325, 0, 283, 325, |
||
651 | 111, 301, 300, 281, 110, 279, 276, 269, 271, 276, |
||
652 | 296, 325, 149, 325, 153, 325, 130, 120, 151, 15, |
||
653 | 325, 289, 0, 74, 270, 271, 96, 272, 261, 258, |
||
654 | 135, 262, 269, 267, 256, 325, 258, 260, 261, 261, |
||
655 | |||
656 | |||
657 | 245, 231, 0, 325, 228, 219, 216, 213, 208, 216, |
||
658 | 148, 151, 147, 150, 148, 325, 325, 0, 137, 325, |
||
659 | 145, 167, 146, 325, 136, 0, 164, 0, 135, 325, |
||
660 | 0, 131, 155, 108, 0, 135, 91, 109, 325, 178, |
||
661 | 186, 194, 202, 206, 214, 222, 228, 236, 240, 247, |
||
662 | 255, 259, 267 |
||
663 | } ; |
||
664 | |||
665 | |||
7195 | punk_joker | 666 | { 0, |
5563 | serge | 667 | 149, 1, 150, 150, 151, 151, 152, 152, 153, 153, |
668 | 149, 11, 149, 149, 149, 149, 149, 149, 149, 149, |
||
669 | 149, 149, 149, 149, 149, 149, 149, 154, 154, 149, |
||
670 | 149, 149, 155, 149, 156, 149, 149, 149, 149, 157, |
||
671 | 149, 149, 149, 149, 149, 149, 158, 149, 149, 159, |
||
672 | 149, 149, 149, 149, 149, 149, 149, 154, 154, 149, |
||
673 | 149, 32, 32, 149, 149, 149, 149, 149, 149, 149, |
||
674 | 155, 149, 156, 149, 156, 149, 149, 149, 149, 149, |
||
675 | 149, 157, 158, 159, 154, 149, 149, 149, 149, 149, |
||
676 | 160, 149, 149, 149, 149, 149, 154, 149, 149, 149, |
||
677 | |||
678 | |||
679 | 154, 149, 161, 149, 149, 149, 149, 149, 149, 149, |
||
680 | 149, 149, 149, 154, 149, 149, 149, 162, 149, 149, |
||
681 | 149, 149, 149, 149, 149, 154, 149, 162, 149, 149, |
||
682 | 163, 149, 149, 149, 163, 149, 149, 149, 0, 149, |
||
683 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
684 | 149, 149, 149 |
||
685 | } ; |
||
686 | |||
687 | |||
7195 | punk_joker | 688 | { 0, |
5563 | serge | 689 | 14, 15, 16, 17, 18, 19, 20, 21, 20, 20, |
690 | 22, 23, 24, 24, 25, 26, 27, 28, 28, 28, |
||
691 | 28, 28, 29, 28, 28, 28, 28, 28, 28, 28, |
||
692 | 28, 28, 28, 28, 28, 28, 28, 28, 30, 31, |
||
693 | 34, 34, 87, 32, 88, 38, 16, 35, 35, 39, |
||
694 | 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, |
||
695 | 17, 17, 17, 17, 17, 17, 17, 40, 40, 40, |
||
696 | 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, |
||
697 | 40, 40, 40, 40, 40, 40, 40, 40, 17, 46, |
||
698 | 47, 48, 48, 96, 51, 51, 51, 53, 54, 49, |
||
699 | |||
700 | |||
701 | 148, 78, 61, 75, 76, 49, 62, 50, 52, 63, |
||
702 | 141, 79, 99, 44, 48, 48, 51, 51, 51, 100, |
||
703 | 80, 77, 49, 66, 52, 78, 148, 87, 147, 88, |
||
704 | 64, 65, 89, 80, 66, 67, 66, 90, 49, 68, |
||
705 | 52, 74, 79, 69, 70, 74, 143, 105, 149, 149, |
||
706 | 146, 144, 75, 76, 106, 143, 142, 141, 132, 140, |
||
707 | 139, 137, 136, 135, 80, 134, 133, 66, 17, 17, |
||
708 | 17, 17, 17, 17, 17, 17, 33, 33, 33, 33, |
||
709 | 33, 33, 33, 33, 36, 36, 36, 36, 36, 36, |
||
710 | |||
711 | |||
712 | 58, 58, 58, 58, 71, 71, 71, 132, 71, 71, |
||
713 | 71, 71, 73, 73, 73, 73, 73, 73, 73, 73, |
||
714 | 82, 131, 82, 82, 82, 82, 83, 130, 83, 83, |
||
715 | 83, 83, 83, 83, 84, 129, 84, 104, 104, 104, |
||
716 | 104, 128, 127, 104, 104, 126, 126, 126, 126, 138, |
||
717 | 125, 138, 138, 138, 138, 138, 138, 145, 124, 145, |
||
718 | 145, 145, 145, 145, 145, 123, 122, 121, 120, 119, |
||
719 | 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, |
||
720 | 108, 107, 103, 102, 101, 98, 97, 81, 72, 95, |
||
721 | |||
722 | |||
723 | 81, 72, 60, 59, 55, 45, 44, 43, 42, 41, |
||
724 | 149, 16, 17, 17, 13, 149, 149, 149, 149, 149, |
||
725 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
726 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
727 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
728 | 149, 149, 149, 149 |
||
729 | } ; |
||
730 | |||
731 | |||
7195 | punk_joker | 732 | { 0, |
5563 | serge | 733 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
734 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
735 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
||
736 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, |
||
737 | 5, 6, 80, 2, 80, 10, 10, 5, 6, 10, |
||
738 | 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, |
||
739 | 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, |
||
740 | 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, |
||
741 | 11, 11, 11, 11, 11, 11, 11, 11, 11, 22, |
||
742 | 22, 23, 23, 84, 24, 24, 24, 25, 25, 23, |
||
743 | |||
744 | |||
745 | 148, 38, 61, 35, 35, 23, 61, 23, 24, 32, |
||
746 | 147, 78, 87, 32, 48, 48, 51, 51, 51, 87, |
||
747 | 39, 77, 48, 39, 51, 77, 146, 65, 144, 65, |
||
748 | 32, 32, 65, 78, 32, 32, 78, 65, 48, 32, |
||
749 | 51, 73, 79, 32, 32, 75, 143, 91, 73, 73, |
||
750 | 142, 139, 75, 75, 91, 137, 135, 133, 132, 131, |
||
751 | 129, 125, 124, 123, 79, 122, 121, 79, 150, 150, |
||
752 | 150, 150, 150, 150, 150, 150, 151, 151, 151, 151, |
||
753 | 151, 151, 151, 151, 152, 152, 152, 152, 152, 152, |
||
754 | |||
755 | |||
756 | 154, 154, 154, 154, 155, 155, 155, 120, 155, 155, |
||
757 | 155, 155, 156, 156, 156, 156, 156, 156, 156, 156, |
||
758 | 157, 119, 157, 157, 157, 157, 158, 118, 158, 158, |
||
759 | 158, 158, 158, 158, 159, 117, 159, 160, 160, 160, |
||
760 | 160, 116, 115, 160, 160, 161, 161, 161, 161, 162, |
||
761 | 112, 162, 162, 162, 162, 162, 162, 163, 111, 163, |
||
762 | 163, 163, 163, 163, 163, 110, 109, 108, 107, 106, |
||
763 | 105, 103, 102, 101, 100, 99, 98, 97, 95, 94, |
||
764 | 93, 92, 90, 89, 88, 86, 85, 82, 71, 70, |
||
765 | |||
766 | |||
767 | 40, 33, 30, 29, 26, 21, 19, 18, 15, 14, |
||
768 | 13, 9, 8, 7, 149, 149, 149, 149, 149, 149, |
||
769 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
770 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
771 | 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, |
||
772 | 149, 149, 149, 149 |
||
773 | } ; |
||
774 | |||
775 | |||
776 | * any uses of REJECT which flex missed. |
||
777 | */ |
||
778 | #define REJECT reject_used_but_not_detected |
||
779 | #define yymore() yymore_used_but_not_detected |
||
780 | #define YY_MORE_ADJ 0 |
||
781 | #define YY_RESTORE_YY_MORE_OFFSET |
||
782 | #line 1 "glcpp/glcpp-lex.l" |
||
783 | #line 2 "glcpp/glcpp-lex.l" |
||
784 | /* |
||
785 | * Copyright © 2010 Intel Corporation |
||
786 | * |
||
787 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
788 | * copy of this software and associated documentation files (the "Software"), |
||
789 | * to deal in the Software without restriction, including without limitation |
||
790 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
791 | * and/or sell copies of the Software, and to permit persons to whom the |
||
792 | * Software is furnished to do so, subject to the following conditions: |
||
793 | * |
||
794 | * The above copyright notice and this permission notice (including the next |
||
795 | * paragraph) shall be included in all copies or substantial portions of the |
||
796 | * Software. |
||
797 | * |
||
798 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
799 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
800 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
801 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||
802 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||
803 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||
804 | * DEALINGS IN THE SOFTWARE. |
||
805 | */ |
||
806 | |||
807 | |||
808 | #include |
||
809 | #include |
||
810 | |||
811 | |||
812 | #include "glcpp-parse.h" |
||
813 | |||
814 | |||
815 | * static. Let's declare them here. */ |
||
816 | int glcpp_get_column (yyscan_t yyscanner); |
||
817 | void glcpp_set_column (int column_no , yyscan_t yyscanner); |
||
818 | |||
819 | |||
820 | #define YY_NO_UNISTD_H |
||
821 | #endif |
||
822 | |||
823 | |||
824 | |||
825 | |||
826 | do { \ |
||
827 | if (parser->has_new_line_number) \ |
||
828 | yylineno = parser->new_line_number; \ |
||
829 | if (parser->has_new_source_number) \ |
||
830 | yylloc->source = parser->new_source_number; \ |
||
831 | yylloc->first_column = yycolumn + 1; \ |
||
832 | yylloc->first_line = yylineno; \ |
||
833 | yycolumn += yyleng; \ |
||
834 | parser->has_new_line_number = 0; \ |
||
835 | parser->has_new_source_number = 0; \ |
||
836 | } while(0); |
||
837 | |||
838 | |||
839 | do { \ |
||
840 | yylineno = 1; \ |
||
841 | yycolumn = 1; \ |
||
842 | yylloc->source = 0; \ |
||
843 | } while(0) |
||
844 | #line 845 " |
||
7195 | punk_joker | 845 | |
5563 | serge | 846 | |
847 | parser just doesn't care about. Since flex regular expressions that |
||
848 | match longer strings take priority over those matching shorter |
||
849 | strings, we have to be careful to avoid OTHER matching and hiding |
||
850 | something that CPP does care about. So we simply exclude all |
||
851 | characters that appear in any other expressions. */ |
||
852 | #line 853 " |
||
7195 | punk_joker | 853 | |
5563 | serge | 854 | |
855 | #define DONE 1 |
||
856 | #define COMMENT 2 |
||
857 | #define UNREACHABLE 3 |
||
858 | #define SKIP 4 |
||
859 | #define DEFINE 5 |
||
860 | |||
861 | |||
862 | /* Special case for "unistd.h", since it is non-ANSI. We include it way |
||
863 | * down here because we want the user's section 1 to have been scanned first. |
||
864 | * The user has a chance to override it with an option. |
||
865 | */ |
||
866 | #include |
||
867 | #endif |
||
868 | |||
869 | |||
870 | |||
871 | |||
872 | struct yyguts_t |
||
873 | { |
||
874 | |||
875 | |||
876 | YY_EXTRA_TYPE yyextra_r; |
||
877 | |||
878 | |||
879 | FILE *yyin_r, *yyout_r; |
||
880 | size_t yy_buffer_stack_top; /**< index of top of stack. */ |
||
881 | size_t yy_buffer_stack_max; /**< capacity of stack. */ |
||
882 | YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ |
||
883 | char yy_hold_char; |
||
884 | int yy_n_chars; |
||
885 | int yyleng_r; |
||
886 | char *yy_c_buf_p; |
||
887 | int yy_init; |
||
888 | int yy_start; |
||
889 | int yy_did_buffer_switch_on_eof; |
||
890 | int yy_start_stack_ptr; |
||
891 | int yy_start_stack_depth; |
||
892 | int *yy_start_stack; |
||
893 | yy_state_type yy_last_accepting_state; |
||
894 | char* yy_last_accepting_cpos; |
||
895 | |||
896 | |||
897 | int yy_flex_debug_r; |
||
898 | |||
899 | |||
900 | int yy_more_flag; |
||
901 | int yy_more_len; |
||
902 | |||
903 | |||
904 | |||
905 | |||
906 | |||
907 | |||
908 | |||
909 | |||
7195 | punk_joker | 910 | |
5563 | serge | 911 | |
912 | * from bison output in section 1.*/ |
||
913 | # define yylval yyg->yylval_r |
||
914 | |||
915 | |||
916 | |||
917 | |||
7195 | punk_joker | 918 | |
5563 | serge | 919 | |
7195 | punk_joker | 920 | |
5563 | serge | 921 | |
922 | These are made visible to non-reentrant scanners for convenience. */ |
||
923 | |||
924 | |||
7195 | punk_joker | 925 | |
5563 | serge | 926 | |
7195 | punk_joker | 927 | |
5563 | serge | 928 | |
7195 | punk_joker | 929 | |
5563 | serge | 930 | |
7195 | punk_joker | 931 | |
5563 | serge | 932 | |
7195 | punk_joker | 933 | |
5563 | serge | 934 | |
7195 | punk_joker | 935 | |
5563 | serge | 936 | |
7195 | punk_joker | 937 | |
5563 | serge | 938 | |
7195 | punk_joker | 939 | |
5563 | serge | 940 | |
7195 | punk_joker | 941 | |
5563 | serge | 942 | |
7195 | punk_joker | 943 | |
5563 | serge | 944 | |
7195 | punk_joker | 945 | |
5563 | serge | 946 | |
7195 | punk_joker | 947 | |
5563 | serge | 948 | |
7195 | punk_joker | 949 | |
5563 | serge | 950 | |
7195 | punk_joker | 951 | |
5563 | serge | 952 | |
7195 | punk_joker | 953 | |
5563 | serge | 954 | |
7195 | punk_joker | 955 | |
5563 | serge | 956 | |
7195 | punk_joker | 957 | |
5563 | serge | 958 | |
7195 | punk_joker | 959 | |
5563 | serge | 960 | |
7195 | punk_joker | 961 | |
5563 | serge | 962 | |
963 | * section 1. |
||
964 | */ |
||
965 | |||
966 | |||
967 | #ifdef __cplusplus |
||
968 | extern "C" int yywrap ( yyscan_t yyscanner ); |
||
7195 | punk_joker | 969 | #else |
5563 | serge | 970 | extern int yywrap ( yyscan_t yyscanner ); |
7195 | punk_joker | 971 | #endif |
5563 | serge | 972 | #endif |
973 | |||
974 | |||
7195 | punk_joker | 975 | |
5563 | serge | 976 | |
7195 | punk_joker | 977 | |
978 | |||
979 | |||
980 | |||
5563 | serge | 981 | static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); |
7195 | punk_joker | 982 | #endif |
5563 | serge | 983 | |
984 | |||
985 | static int yy_flex_strlen ( const char * , yyscan_t yyscanner); |
||
7195 | punk_joker | 986 | #endif |
5563 | serge | 987 | |
988 | |||
989 | #ifdef __cplusplus |
||
990 | static int yyinput ( yyscan_t yyscanner ); |
||
7195 | punk_joker | 991 | #else |
5563 | serge | 992 | static int input ( yyscan_t yyscanner ); |
7195 | punk_joker | 993 | #endif |
5563 | serge | 994 | |
995 | |||
996 | |||
997 | |||
7195 | punk_joker | 998 | |
5563 | serge | 999 | |
7195 | punk_joker | 1000 | |
5563 | serge | 1001 | |
7195 | punk_joker | 1002 | |
5563 | serge | 1003 | |
1004 | #ifndef YY_READ_BUF_SIZE |
||
1005 | #ifdef __ia64__ |
||
1006 | /* On IA-64, the buffer size is 16k, not 8k */ |
||
1007 | #define YY_READ_BUF_SIZE 16384 |
||
1008 | #else |
||
1009 | #define YY_READ_BUF_SIZE 8192 |
||
1010 | #endif /* __ia64__ */ |
||
1011 | #endif |
||
1012 | |||
1013 | |||
1014 | #ifndef ECHO |
||
1015 | /* This used to be an fputs(), but since the string might contain NUL's, |
||
1016 | * we now use fwrite(). |
||
1017 | */ |
||
1018 | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) |
||
7195 | punk_joker | 1019 | #endif |
5563 | serge | 1020 | |
1021 | |||
1022 | * is returned in "result". |
||
1023 | */ |
||
1024 | #ifndef YY_INPUT |
||
1025 | #define YY_INPUT(buf,result,max_size) \ |
||
1026 | if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ |
||
1027 | { \ |
||
1028 | int c = '*'; \ |
||
1029 | int n; \ |
||
7195 | punk_joker | 1030 | for ( n = 0; n < max_size && \ |
5563 | serge | 1031 | (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ |
1032 | buf[n] = (char) c; \ |
||
1033 | if ( c == '\n' ) \ |
||
1034 | buf[n++] = (char) c; \ |
||
1035 | if ( c == EOF && ferror( yyin ) ) \ |
||
1036 | YY_FATAL_ERROR( "input in flex scanner failed" ); \ |
||
1037 | result = n; \ |
||
1038 | } \ |
||
1039 | else \ |
||
1040 | { \ |
||
1041 | errno=0; \ |
||
1042 | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ |
||
7195 | punk_joker | 1043 | { \ |
5563 | serge | 1044 | if( errno != EINTR) \ |
1045 | { \ |
||
1046 | YY_FATAL_ERROR( "input in flex scanner failed" ); \ |
||
1047 | break; \ |
||
1048 | } \ |
||
1049 | errno=0; \ |
||
1050 | clearerr(yyin); \ |
||
1051 | } \ |
||
1052 | }\ |
||
1053 | \ |
||
1054 | |||
1055 | |||
1056 | |||
1057 | |||
1058 | * we don't want an extra ';' after the "return" because that will cause |
||
1059 | * some compilers to complain about unreachable statements. |
||
1060 | */ |
||
1061 | #ifndef yyterminate |
||
1062 | #define yyterminate() return YY_NULL |
||
1063 | #endif |
||
1064 | |||
1065 | |||
1066 | #ifndef YY_START_STACK_INCR |
||
1067 | #define YY_START_STACK_INCR 25 |
||
1068 | #endif |
||
1069 | |||
1070 | |||
1071 | #ifndef YY_FATAL_ERROR |
||
1072 | #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) |
||
1073 | #endif |
||
1074 | |||
1075 | |||
1076 | |||
1077 | |||
1078 | * easily add parameters. |
||
1079 | */ |
||
1080 | #ifndef YY_DECL |
||
1081 | #define YY_DECL_IS_OURS 1 |
||
1082 | |||
1083 | |||
7195 | punk_joker | 1084 | (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner); |
1085 | |||
5563 | serge | 1086 | |
7195 | punk_joker | 1087 | (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) |
5563 | serge | 1088 | #endif /* !YY_DECL */ |
1089 | |||
1090 | |||
1091 | * have been set up. |
||
1092 | */ |
||
1093 | #ifndef YY_USER_ACTION |
||
1094 | #define YY_USER_ACTION |
||
1095 | #endif |
||
1096 | |||
1097 | |||
1098 | #ifndef YY_BREAK |
||
1099 | #define YY_BREAK /*LINTED*/break; |
||
7195 | punk_joker | 1100 | #endif |
5563 | serge | 1101 | |
1102 | |||
1103 | if ( yyleng > 0 ) \ |
||
1104 | YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ |
||
1105 | (yytext[yyleng - 1] == '\n'); \ |
||
1106 | YY_USER_ACTION |
||
1107 | |||
1108 | |||
1109 | */ |
||
1110 | YY_DECL |
||
1111 | { |
||
1112 | yy_state_type yy_current_state; |
||
7195 | punk_joker | 1113 | char *yy_cp, *yy_bp; |
1114 | int yy_act; |
||
1115 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
5563 | serge | 1116 | |
1117 | |||
1118 | |||
1119 | |||
1120 | |||
1121 | |||
1122 | { |
||
1123 | yyg->yy_init = 1; |
||
1124 | |||
1125 | |||
1126 | YY_USER_INIT; |
||
1127 | #endif |
||
1128 | |||
1129 | |||
1130 | yyg->yy_start = 1; /* first start state */ |
||
1131 | |||
1132 | |||
1133 | yyin = stdin; |
||
1134 | |||
1135 | |||
1136 | yyout = stdout; |
||
1137 | |||
1138 | |||
1139 | yyensure_buffer_stack (yyscanner); |
||
7195 | punk_joker | 1140 | YY_CURRENT_BUFFER_LVALUE = |
5563 | serge | 1141 | yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); |
7195 | punk_joker | 1142 | } |
5563 | serge | 1143 | |
1144 | |||
7195 | punk_joker | 1145 | } |
5563 | serge | 1146 | |
1147 | |||
7195 | punk_joker | 1148 | #line 94 "glcpp/glcpp-lex.l" |
1149 | |||
1150 | |||
1151 | /* Implicitly switch between SKIP and INITIAL (non-skipping); |
||
1152 | * don't switch if some other state was explicitly set. |
||
1153 | */ |
||
1154 | glcpp_parser_t *parser = yyextra; |
||
1155 | if (YY_START == 0 || YY_START == SKIP) { |
||
1156 | if (parser->lexing_if || parser->skip_stack == NULL || parser->skip_stack->type == SKIP_NO_SKIP) { |
||
1157 | BEGIN 0; |
||
1158 | } else { |
||
1159 | BEGIN SKIP; |
||
1160 | } |
||
1161 | } |
||
1162 | |||
1163 | |||
1164 | #line 1165 " |
||
1165 | |||
1166 | |||
1167 | { |
||
5563 | serge | 1168 | yy_cp = yyg->yy_c_buf_p; |
1169 | |||
1170 | |||
1171 | *yy_cp = yyg->yy_hold_char; |
||
1172 | |||
1173 | |||
1174 | * the current run. |
||
1175 | */ |
||
1176 | yy_bp = yy_cp; |
||
1177 | |||
1178 | |||
1179 | yy_current_state += YY_AT_BOL(); |
||
1180 | yy_match: |
||
1181 | do |
||
1182 | { |
||
1183 | YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; |
||
7195 | punk_joker | 1184 | if ( yy_accept[yy_current_state] ) |
5563 | serge | 1185 | { |
1186 | yyg->yy_last_accepting_state = yy_current_state; |
||
1187 | yyg->yy_last_accepting_cpos = yy_cp; |
||
1188 | } |
||
1189 | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) |
||
1190 | { |
||
1191 | yy_current_state = (int) yy_def[yy_current_state]; |
||
1192 | if ( yy_current_state >= 150 ) |
||
1193 | yy_c = yy_meta[yy_c]; |
||
7195 | punk_joker | 1194 | } |
5563 | serge | 1195 | yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; |
7195 | punk_joker | 1196 | ++yy_cp; |
5563 | serge | 1197 | } |
1198 | while ( yy_current_state != 149 ); |
||
1199 | yy_cp = yyg->yy_last_accepting_cpos; |
||
1200 | yy_current_state = yyg->yy_last_accepting_state; |
||
1201 | |||
1202 | |||
1203 | yy_act = yy_accept[yy_current_state]; |
||
1204 | |||
1205 | |||
1206 | |||
1207 | |||
1208 | |||
1209 | |||
1210 | { /* beginning of action switch */ |
||
1211 | case 0: /* must back up */ |
||
1212 | /* undo the effects of YY_DO_BEFORE_ACTION */ |
||
1213 | *yy_cp = yyg->yy_hold_char; |
||
1214 | yy_cp = yyg->yy_last_accepting_cpos; |
||
1215 | yy_current_state = yyg->yy_last_accepting_state; |
||
1216 | goto yy_find_action; |
||
1217 | |||
1218 | |||
1219 | YY_RULE_SETUP |
||
1220 | #line 109 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1221 | { |
5563 | serge | 1222 | } |
1223 | YY_BREAK |
||
1224 | /* Multi-line comments */ |
||
1225 | case 2: |
||
1226 | YY_RULE_SETUP |
||
1227 | #line 113 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1228 | { yy_push_state(COMMENT, yyscanner); } |
5563 | serge | 1229 | YY_BREAK |
1230 | case 3: |
||
1231 | YY_RULE_SETUP |
||
1232 | #line 114 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1233 | |
5563 | serge | 1234 | |
1235 | case 4: |
||
1236 | /* rule 4 can match eol */ |
||
1237 | YY_RULE_SETUP |
||
1238 | #line 115 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1239 | { yylineno++; yycolumn = 0; return NEWLINE; } |
5563 | serge | 1240 | YY_BREAK |
1241 | case 5: |
||
1242 | YY_RULE_SETUP |
||
1243 | #line 116 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1244 | |
5563 | serge | 1245 | |
1246 | case 6: |
||
1247 | /* rule 6 can match eol */ |
||
1248 | YY_RULE_SETUP |
||
1249 | #line 117 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1250 | { yylineno++; yycolumn = 0; return NEWLINE; } |
5563 | serge | 1251 | YY_BREAK |
1252 | case 7: |
||
1253 | YY_RULE_SETUP |
||
1254 | #line 118 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1255 | { |
5563 | serge | 1256 | yy_pop_state(yyscanner); |
1257 | if (yyextra->space_tokens) |
||
1258 | return SPACE; |
||
1259 | } |
||
1260 | YY_BREAK |
||
1261 | case 8: |
||
1262 | YY_RULE_SETUP |
||
1263 | #line 124 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1264 | { |
5563 | serge | 1265 | yylval->str = ralloc_strdup (yyextra, yytext); |
1266 | yyextra->space_tokens = 0; |
||
1267 | return HASH_VERSION; |
||
1268 | } |
||
1269 | YY_BREAK |
||
1270 | /* glcpp doesn't handle #extension, #version, or #pragma directives. |
||
1271 | * Simply pass them through to the main compiler's lexer/parser. */ |
||
1272 | case 9: |
||
1273 | YY_RULE_SETUP |
||
1274 | #line 132 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1275 | { |
5563 | serge | 1276 | yylval->str = ralloc_strdup (yyextra, yytext); |
1277 | yylineno++; |
||
1278 | yycolumn = 0; |
||
1279 | return OTHER; |
||
1280 | } |
||
1281 | YY_BREAK |
||
1282 | case 10: |
||
1283 | YY_RULE_SETUP |
||
1284 | #line 139 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1285 | { |
5563 | serge | 1286 | return HASH_LINE; |
1287 | } |
||
1288 | YY_BREAK |
||
1289 | |||
1290 | |||
1291 | YY_RULE_SETUP |
||
1292 | #line 144 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1293 | { |
5563 | serge | 1294 | yyextra->lexing_if = 1; |
1295 | yyextra->space_tokens = 0; |
||
1296 | return HASH_IFDEF; |
||
1297 | } |
||
1298 | YY_BREAK |
||
1299 | case 12: |
||
1300 | YY_RULE_SETUP |
||
1301 | #line 150 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1302 | { |
5563 | serge | 1303 | yyextra->lexing_if = 1; |
1304 | yyextra->space_tokens = 0; |
||
1305 | return HASH_IFNDEF; |
||
1306 | } |
||
1307 | YY_BREAK |
||
1308 | case 13: |
||
1309 | /* rule 13 can match eol */ |
||
1310 | *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ |
||
1311 | YY_LINENO_REWIND_TO(yy_cp - 1); |
||
7195 | punk_joker | 1312 | yyg->yy_c_buf_p = yy_cp -= 1; |
5563 | serge | 1313 | YY_DO_BEFORE_ACTION; /* set up yytext again */ |
1314 | YY_RULE_SETUP |
||
1315 | #line 156 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1316 | { |
5563 | serge | 1317 | yyextra->lexing_if = 1; |
1318 | yyextra->space_tokens = 0; |
||
1319 | return HASH_IF; |
||
1320 | } |
||
1321 | YY_BREAK |
||
1322 | case 14: |
||
1323 | /* rule 14 can match eol */ |
||
1324 | *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ |
||
1325 | YY_LINENO_REWIND_TO(yy_cp - 1); |
||
7195 | punk_joker | 1326 | yyg->yy_c_buf_p = yy_cp -= 1; |
5563 | serge | 1327 | YY_DO_BEFORE_ACTION; /* set up yytext again */ |
1328 | YY_RULE_SETUP |
||
1329 | #line 162 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1330 | { |
5563 | serge | 1331 | yyextra->lexing_if = 1; |
1332 | yyextra->space_tokens = 0; |
||
1333 | return HASH_ELIF; |
||
1334 | } |
||
1335 | YY_BREAK |
||
1336 | case 15: |
||
1337 | YY_RULE_SETUP |
||
1338 | #line 168 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1339 | { |
5563 | serge | 1340 | yyextra->space_tokens = 0; |
1341 | return HASH_ELSE; |
||
1342 | } |
||
1343 | YY_BREAK |
||
1344 | case 16: |
||
1345 | YY_RULE_SETUP |
||
1346 | #line 173 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1347 | { |
5563 | serge | 1348 | yyextra->space_tokens = 0; |
1349 | return HASH_ENDIF; |
||
1350 | } |
||
1351 | YY_BREAK |
||
1352 | |||
1353 | |||
1354 | YY_RULE_SETUP |
||
1355 | #line 179 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1356 | ; |
5563 | serge | 1357 | YY_BREAK |
1358 | case 18: |
||
1359 | YY_RULE_SETUP |
||
1360 | #line 181 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1361 | { |
5563 | serge | 1362 | char *p; |
1363 | for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ |
||
1364 | p += 5; /* skip "error" */ |
||
1365 | glcpp_error(yylloc, yyextra, "#error%s", p); |
||
1366 | } |
||
1367 | YY_BREAK |
||
1368 | case 19: |
||
1369 | YY_RULE_SETUP |
||
1370 | #line 188 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1371 | { |
5563 | serge | 1372 | yyextra->space_tokens = 0; |
1373 | yy_push_state(DEFINE, yyscanner); |
||
1374 | return HASH_DEFINE; |
||
1375 | } |
||
1376 | YY_BREAK |
||
1377 | case 20: |
||
1378 | *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ |
||
1379 | yyg->yy_c_buf_p = yy_cp -= 1; |
||
1380 | YY_DO_BEFORE_ACTION; /* set up yytext again */ |
||
1381 | YY_RULE_SETUP |
||
1382 | #line 194 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1383 | { |
5563 | serge | 1384 | yy_pop_state(yyscanner); |
1385 | yylval->str = ralloc_strdup (yyextra, yytext); |
||
1386 | return FUNC_IDENTIFIER; |
||
1387 | } |
||
1388 | YY_BREAK |
||
1389 | case 21: |
||
1390 | YY_RULE_SETUP |
||
1391 | #line 200 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1392 | { |
5563 | serge | 1393 | yy_pop_state(yyscanner); |
1394 | yylval->str = ralloc_strdup (yyextra, yytext); |
||
1395 | return OBJ_IDENTIFIER; |
||
1396 | } |
||
1397 | YY_BREAK |
||
1398 | case 22: |
||
1399 | YY_RULE_SETUP |
||
1400 | #line 206 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1401 | { |
5563 | serge | 1402 | yyextra->space_tokens = 0; |
1403 | return HASH_UNDEF; |
||
1404 | } |
||
1405 | YY_BREAK |
||
1406 | case 23: |
||
1407 | YY_RULE_SETUP |
||
1408 | #line 211 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1409 | { |
5563 | serge | 1410 | yyextra->space_tokens = 0; |
1411 | return HASH; |
||
1412 | } |
||
1413 | YY_BREAK |
||
1414 | case 24: |
||
1415 | YY_RULE_SETUP |
||
1416 | #line 216 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1417 | { |
5563 | serge | 1418 | yylval->str = ralloc_strdup (yyextra, yytext); |
1419 | return INTEGER_STRING; |
||
1420 | } |
||
1421 | YY_BREAK |
||
1422 | case 25: |
||
1423 | YY_RULE_SETUP |
||
1424 | #line 221 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1425 | { |
5563 | serge | 1426 | yylval->str = ralloc_strdup (yyextra, yytext); |
1427 | return INTEGER_STRING; |
||
1428 | } |
||
1429 | YY_BREAK |
||
1430 | case 26: |
||
1431 | YY_RULE_SETUP |
||
1432 | #line 226 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1433 | { |
5563 | serge | 1434 | yylval->str = ralloc_strdup (yyextra, yytext); |
1435 | return INTEGER_STRING; |
||
1436 | } |
||
1437 | YY_BREAK |
||
1438 | case 27: |
||
1439 | YY_RULE_SETUP |
||
1440 | #line 231 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1441 | { |
5563 | serge | 1442 | return LEFT_SHIFT; |
1443 | } |
||
1444 | YY_BREAK |
||
1445 | case 28: |
||
1446 | YY_RULE_SETUP |
||
1447 | #line 235 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1448 | { |
5563 | serge | 1449 | return RIGHT_SHIFT; |
1450 | } |
||
1451 | YY_BREAK |
||
1452 | case 29: |
||
1453 | YY_RULE_SETUP |
||
1454 | #line 239 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1455 | { |
5563 | serge | 1456 | return LESS_OR_EQUAL; |
1457 | } |
||
1458 | YY_BREAK |
||
1459 | case 30: |
||
1460 | YY_RULE_SETUP |
||
1461 | #line 243 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1462 | { |
5563 | serge | 1463 | return GREATER_OR_EQUAL; |
1464 | } |
||
1465 | YY_BREAK |
||
1466 | case 31: |
||
1467 | YY_RULE_SETUP |
||
1468 | #line 247 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1469 | { |
5563 | serge | 1470 | return EQUAL; |
1471 | } |
||
1472 | YY_BREAK |
||
1473 | case 32: |
||
1474 | YY_RULE_SETUP |
||
1475 | #line 251 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1476 | { |
5563 | serge | 1477 | return NOT_EQUAL; |
1478 | } |
||
1479 | YY_BREAK |
||
1480 | case 33: |
||
1481 | YY_RULE_SETUP |
||
1482 | #line 255 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1483 | { |
5563 | serge | 1484 | return AND; |
1485 | } |
||
1486 | YY_BREAK |
||
1487 | case 34: |
||
1488 | YY_RULE_SETUP |
||
1489 | #line 259 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1490 | { |
5563 | serge | 1491 | return OR; |
1492 | } |
||
1493 | YY_BREAK |
||
1494 | case 35: |
||
1495 | YY_RULE_SETUP |
||
1496 | #line 263 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1497 | { |
5563 | serge | 1498 | if (parser->is_gles) |
1499 | glcpp_error(yylloc, yyextra, "Token pasting (##) is illegal in GLES"); |
||
1500 | return PASTE; |
||
1501 | } |
||
1502 | YY_BREAK |
||
1503 | case 36: |
||
1504 | YY_RULE_SETUP |
||
1505 | #line 269 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1506 | { |
5563 | serge | 1507 | return DEFINED; |
1508 | } |
||
1509 | YY_BREAK |
||
1510 | case 37: |
||
1511 | YY_RULE_SETUP |
||
1512 | #line 273 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1513 | { |
5563 | serge | 1514 | yylval->str = ralloc_strdup (yyextra, yytext); |
1515 | return IDENTIFIER; |
||
1516 | } |
||
1517 | YY_BREAK |
||
1518 | case 38: |
||
1519 | YY_RULE_SETUP |
||
1520 | #line 278 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1521 | { |
5563 | serge | 1522 | return yytext[0]; |
1523 | } |
||
1524 | YY_BREAK |
||
1525 | case 39: |
||
1526 | YY_RULE_SETUP |
||
1527 | #line 282 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1528 | { |
5563 | serge | 1529 | yylval->str = ralloc_strdup (yyextra, yytext); |
1530 | return OTHER; |
||
1531 | } |
||
1532 | YY_BREAK |
||
1533 | case 40: |
||
1534 | YY_RULE_SETUP |
||
1535 | #line 287 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1536 | { |
5563 | serge | 1537 | if (yyextra->space_tokens) { |
1538 | return SPACE; |
||
1539 | } |
||
1540 | } |
||
1541 | YY_BREAK |
||
1542 | case 41: |
||
1543 | /* rule 41 can match eol */ |
||
1544 | YY_RULE_SETUP |
||
1545 | #line 293 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1546 | { |
5563 | serge | 1547 | yyextra->lexing_if = 0; |
1548 | yylineno++; |
||
1549 | yycolumn = 0; |
||
1550 | return NEWLINE; |
||
1551 | } |
||
1552 | YY_BREAK |
||
1553 | /* Handle missing newline at EOF. */ |
||
1554 | case YY_STATE_EOF(INITIAL): |
||
1555 | #line 301 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1556 | { |
5563 | serge | 1557 | BEGIN DONE; /* Don't keep matching this rule forever. */ |
1558 | yyextra->lexing_if = 0; |
||
1559 | return NEWLINE; |
||
1560 | } |
||
1561 | YY_BREAK |
||
1562 | /* We don't actually use the UNREACHABLE start condition. We |
||
1563 | only have this action here so that we can pretend to call some |
||
1564 | generated functions, (to avoid "defined but not used" |
||
1565 | warnings. */ |
||
1566 | case 42: |
||
1567 | YY_RULE_SETUP |
||
1568 | #line 311 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1569 | { |
5563 | serge | 1570 | unput('.'); |
1571 | yy_top_state(yyextra); |
||
1572 | } |
||
1573 | YY_BREAK |
||
1574 | case 43: |
||
1575 | YY_RULE_SETUP |
||
1576 | #line 316 "glcpp/glcpp-lex.l" |
||
7195 | punk_joker | 1577 | ECHO; |
5563 | serge | 1578 | YY_BREAK |
1579 | #line 1580 " |
||
7195 | punk_joker | 1580 | case YY_STATE_EOF(DONE): |
5563 | serge | 1581 | case YY_STATE_EOF(COMMENT): |
1582 | case YY_STATE_EOF(UNREACHABLE): |
||
1583 | case YY_STATE_EOF(SKIP): |
||
1584 | case YY_STATE_EOF(DEFINE): |
||
1585 | yyterminate(); |
||
1586 | |||
1587 | |||
1588 | { |
||
1589 | /* Amount of text matched not including the EOB char. */ |
||
1590 | int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; |
||
1591 | |||
1592 | |||
1593 | *yy_cp = yyg->yy_hold_char; |
||
1594 | YY_RESTORE_YY_MORE_OFFSET |
||
1595 | |||
1596 | |||
1597 | { |
||
1598 | /* We're scanning a new file or input source. It's |
||
1599 | * possible that this happened because the user |
||
1600 | * just pointed yyin at a new source and called |
||
1601 | * yylex(). If so, then we have to assure |
||
7195 | punk_joker | 1602 | * consistency between YY_CURRENT_BUFFER and our |
5563 | serge | 1603 | * globals. Here is the right place to do so, because |
1604 | * this is the first action (other than possibly a |
||
1605 | * back-up) that will match for the new input source. |
||
1606 | */ |
||
1607 | yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
||
1608 | YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; |
||
1609 | YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; |
||
1610 | } |
||
1611 | |||
1612 | |||
1613 | * of the first EOB in the buffer, since yy_c_buf_p will |
||
1614 | * already have been incremented past the NUL character |
||
1615 | * (since all states make transitions on EOB to the |
||
1616 | * end-of-buffer state). Contrast this with the test |
||
1617 | * in input(). |
||
1618 | */ |
||
1619 | if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) |
||
1620 | { /* This was really a NUL. */ |
||
1621 | yy_state_type yy_next_state; |
||
1622 | |||
1623 | |||
1624 | |||
1625 | |||
1626 | |||
1627 | |||
1628 | * transition. We couldn't have |
||
1629 | * yy_get_previous_state() go ahead and do it |
||
1630 | * for us because it doesn't know how to deal |
||
1631 | * with the possibility of jamming (and we don't |
||
1632 | * want to build jamming into it because then it |
||
1633 | * will run more slowly). |
||
1634 | */ |
||
1635 | |||
1636 | |||
1637 | |||
1638 | |||
1639 | |||
1640 | |||
1641 | { |
||
1642 | /* Consume the NUL. */ |
||
1643 | yy_cp = ++yyg->yy_c_buf_p; |
||
1644 | yy_current_state = yy_next_state; |
||
1645 | goto yy_match; |
||
1646 | } |
||
1647 | |||
1648 | |||
1649 | { |
||
1650 | yy_cp = yyg->yy_last_accepting_cpos; |
||
1651 | yy_current_state = yyg->yy_last_accepting_state; |
||
1652 | goto yy_find_action; |
||
1653 | } |
||
1654 | } |
||
1655 | |||
1656 | |||
1657 | { |
||
1658 | case EOB_ACT_END_OF_FILE: |
||
1659 | { |
||
1660 | yyg->yy_did_buffer_switch_on_eof = 0; |
||
1661 | |||
1662 | |||
7195 | punk_joker | 1663 | { |
5563 | serge | 1664 | /* Note: because we've taken care in |
1665 | * yy_get_next_buffer() to have set up |
||
1666 | * yytext, we can now set up |
||
1667 | * yy_c_buf_p so that if some total |
||
1668 | * hoser (like flex itself) wants to |
||
1669 | * call the scanner after we return the |
||
1670 | * YY_NULL, it'll still work - another |
||
1671 | * YY_NULL will get returned. |
||
1672 | */ |
||
1673 | yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; |
||
1674 | |||
1675 | |||
1676 | goto do_action; |
||
1677 | } |
||
1678 | |||
1679 | |||
1680 | { |
||
1681 | if ( ! yyg->yy_did_buffer_switch_on_eof ) |
||
1682 | YY_NEW_FILE; |
||
1683 | } |
||
1684 | break; |
||
1685 | } |
||
1686 | |||
1687 | |||
1688 | yyg->yy_c_buf_p = |
||
1689 | yyg->yytext_ptr + yy_amount_of_matched_text; |
||
1690 | |||
1691 | |||
1692 | |||
1693 | |||
1694 | yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; |
||
1695 | goto yy_match; |
||
1696 | |||
1697 | |||
1698 | yyg->yy_c_buf_p = |
||
1699 | &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; |
||
1700 | |||
1701 | |||
1702 | |||
1703 | |||
1704 | yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; |
||
1705 | goto yy_find_action; |
||
1706 | } |
||
1707 | break; |
||
1708 | } |
||
1709 | |||
1710 | |||
1711 | YY_FATAL_ERROR( |
||
1712 | "fatal flex scanner internal error--no action found" ); |
||
1713 | } /* end of action switch */ |
||
1714 | } /* end of scanning one token */ |
||
1715 | } /* end of user's declarations */ |
||
7195 | punk_joker | 1716 | } /* end of yylex */ |
1717 | |||
5563 | serge | 1718 | |
1719 | * |
||
1720 | * Returns a code representing an action: |
||
1721 | * EOB_ACT_LAST_MATCH - |
||
1722 | * EOB_ACT_CONTINUE_SCAN - continue scanning from current position |
||
1723 | * EOB_ACT_END_OF_FILE - end of file |
||
1724 | */ |
||
1725 | static int yy_get_next_buffer (yyscan_t yyscanner) |
||
1726 | { |
||
1727 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
1728 | char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; |
||
7195 | punk_joker | 1729 | char *source = yyg->yytext_ptr; |
1730 | int number_to_move, i; |
||
1731 | int ret_val; |
||
5563 | serge | 1732 | |
1733 | |||
1734 | YY_FATAL_ERROR( |
||
1735 | "fatal flex scanner internal error--end of buffer missed" ); |
||
1736 | |||
1737 | |||
1738 | { /* Don't try to fill the buffer, so this is an EOF. */ |
||
1739 | if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) |
||
1740 | { |
||
1741 | /* We matched a single character, the EOB, so |
||
1742 | * treat this as a final EOF. |
||
1743 | */ |
||
1744 | return EOB_ACT_END_OF_FILE; |
||
1745 | } |
||
1746 | |||
1747 | |||
1748 | { |
||
1749 | /* We matched some text prior to the EOB, first |
||
1750 | * process it. |
||
1751 | */ |
||
1752 | return EOB_ACT_LAST_MATCH; |
||
1753 | } |
||
1754 | } |
||
1755 | |||
1756 | |||
1757 | |||
1758 | |||
1759 | number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); |
||
7195 | punk_joker | 1760 | |
5563 | serge | 1761 | |
1762 | *(dest++) = *(source++); |
||
1763 | |||
1764 | |||
1765 | /* don't do the read, it's not guaranteed to return an EOF, |
||
1766 | * just force an EOF |
||
1767 | */ |
||
1768 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; |
||
1769 | |||
1770 | |||
1771 | { |
||
1772 | int num_to_read = |
||
1773 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; |
||
1774 | |||
1775 | |||
1776 | { /* Not enough room in the buffer - grow it. */ |
||
1777 | |||
1778 | |||
1779 | YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; |
||
7195 | punk_joker | 1780 | |
5563 | serge | 1781 | |
1782 | (int) (yyg->yy_c_buf_p - b->yy_ch_buf); |
||
1783 | |||
1784 | |||
1785 | { |
||
1786 | int new_size = b->yy_buf_size * 2; |
||
1787 | |||
1788 | |||
1789 | b->yy_buf_size += b->yy_buf_size / 8; |
||
1790 | else |
||
1791 | b->yy_buf_size *= 2; |
||
1792 | |||
1793 | |||
1794 | /* Include room in for 2 EOB chars. */ |
||
1795 | yyrealloc( (void *) b->yy_ch_buf, |
||
7195 | punk_joker | 1796 | (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); |
1797 | } |
||
5563 | serge | 1798 | else |
1799 | /* Can't grow it, we don't own it. */ |
||
1800 | b->yy_ch_buf = NULL; |
||
7195 | punk_joker | 1801 | |
5563 | serge | 1802 | |
1803 | YY_FATAL_ERROR( |
||
1804 | "fatal error - scanner input buffer overflow" ); |
||
1805 | |||
1806 | |||
1807 | |||
1808 | |||
1809 | number_to_move - 1; |
||
1810 | |||
1811 | |||
1812 | |||
1813 | |||
1814 | num_to_read = YY_READ_BUF_SIZE; |
||
1815 | |||
1816 | |||
1817 | YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), |
||
1818 | yyg->yy_n_chars, num_to_read ); |
||
7195 | punk_joker | 1819 | |
5563 | serge | 1820 | |
1821 | } |
||
1822 | |||
1823 | |||
1824 | { |
||
1825 | if ( number_to_move == YY_MORE_ADJ ) |
||
1826 | { |
||
1827 | ret_val = EOB_ACT_END_OF_FILE; |
||
1828 | yyrestart( yyin , yyscanner); |
||
7195 | punk_joker | 1829 | } |
5563 | serge | 1830 | |
1831 | |||
1832 | { |
||
1833 | ret_val = EOB_ACT_LAST_MATCH; |
||
1834 | YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = |
||
1835 | YY_BUFFER_EOF_PENDING; |
||
1836 | } |
||
1837 | } |
||
1838 | |||
1839 | |||
1840 | ret_val = EOB_ACT_CONTINUE_SCAN; |
||
1841 | |||
1842 | |||
7195 | punk_joker | 1843 | /* Extend the array by 50%, plus the number we really need. */ |
5563 | serge | 1844 | int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); |
7195 | punk_joker | 1845 | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( |
1846 | (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); |
||
1847 | if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) |
||
5563 | serge | 1848 | YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); |
1849 | /* "- 2" to take care of EOB's */ |
||
7195 | punk_joker | 1850 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); |
1851 | } |
||
5563 | serge | 1852 | |
1853 | |||
1854 | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; |
||
1855 | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; |
||
1856 | |||
1857 | |||
1858 | |||
1859 | |||
1860 | } |
||
1861 | |||
1862 | |||
1863 | |||
1864 | |||
1865 | { |
||
1866 | yy_state_type yy_current_state; |
||
7195 | punk_joker | 1867 | char *yy_cp; |
1868 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
5563 | serge | 1869 | |
1870 | |||
1871 | yy_current_state += YY_AT_BOL(); |
||
1872 | |||
1873 | |||
1874 | { |
||
1875 | YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); |
||
7195 | punk_joker | 1876 | if ( yy_accept[yy_current_state] ) |
5563 | serge | 1877 | { |
1878 | yyg->yy_last_accepting_state = yy_current_state; |
||
1879 | yyg->yy_last_accepting_cpos = yy_cp; |
||
1880 | } |
||
1881 | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) |
||
1882 | { |
||
1883 | yy_current_state = (int) yy_def[yy_current_state]; |
||
1884 | if ( yy_current_state >= 150 ) |
||
1885 | yy_c = yy_meta[yy_c]; |
||
7195 | punk_joker | 1886 | } |
5563 | serge | 1887 | yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; |
7195 | punk_joker | 1888 | } |
5563 | serge | 1889 | |
1890 | |||
1891 | } |
||
1892 | |||
1893 | |||
1894 | * |
||
1895 | * synopsis |
||
1896 | * next_state = yy_try_NUL_trans( current_state ); |
||
1897 | */ |
||
1898 | static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) |
||
1899 | { |
||
1900 | int yy_is_jam; |
||
7195 | punk_joker | 1901 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ |
5563 | serge | 1902 | char *yy_cp = yyg->yy_c_buf_p; |
7195 | punk_joker | 1903 | |
5563 | serge | 1904 | |
7195 | punk_joker | 1905 | if ( yy_accept[yy_current_state] ) |
5563 | serge | 1906 | { |
1907 | yyg->yy_last_accepting_state = yy_current_state; |
||
1908 | yyg->yy_last_accepting_cpos = yy_cp; |
||
1909 | } |
||
1910 | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) |
||
1911 | { |
||
1912 | yy_current_state = (int) yy_def[yy_current_state]; |
||
1913 | if ( yy_current_state >= 150 ) |
||
1914 | yy_c = yy_meta[yy_c]; |
||
7195 | punk_joker | 1915 | } |
5563 | serge | 1916 | yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; |
7195 | punk_joker | 1917 | yy_is_jam = (yy_current_state == 149); |
5563 | serge | 1918 | |
1919 | |||
7195 | punk_joker | 1920 | return yy_is_jam ? 0 : yy_current_state; |
5563 | serge | 1921 | } |
1922 | |||
1923 | |||
7195 | punk_joker | 1924 | |
1925 | |||
1926 | { |
||
5563 | serge | 1927 | char *yy_cp; |
7195 | punk_joker | 1928 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
5563 | serge | 1929 | |
1930 | |||
1931 | |||
1932 | |||
1933 | *yy_cp = yyg->yy_hold_char; |
||
1934 | |||
1935 | |||
1936 | { /* need to shift things up to make room */ |
||
1937 | /* +2 for EOB chars. */ |
||
1938 | int number_to_move = yyg->yy_n_chars + 2; |
||
7195 | punk_joker | 1939 | char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ |
1940 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; |
||
5563 | serge | 1941 | char *source = |
7195 | punk_joker | 1942 | &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; |
5563 | serge | 1943 | |
1944 | |||
1945 | *--dest = *--source; |
||
1946 | |||
1947 | |||
1948 | yy_bp += (int) (dest - source); |
||
1949 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = |
||
1950 | yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; |
||
7195 | punk_joker | 1951 | |
5563 | serge | 1952 | |
1953 | YY_FATAL_ERROR( "flex scanner push-back overflow" ); |
||
1954 | } |
||
1955 | |||
1956 | |||
1957 | |||
1958 | |||
1959 | yyg->yy_hold_char = *yy_cp; |
||
1960 | yyg->yy_c_buf_p = yy_cp; |
||
1961 | } |
||
1962 | |||
1963 | |||
7195 | punk_joker | 1964 | |
1965 | |||
5563 | serge | 1966 | #ifdef __cplusplus |
1967 | static int yyinput (yyscan_t yyscanner) |
||
1968 | #else |
||
1969 | static int input (yyscan_t yyscanner) |
||
1970 | #endif |
||
1971 | |||
1972 | |||
1973 | int c; |
||
1974 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
1975 | |||
1976 | |||
1977 | |||
1978 | |||
1979 | { |
||
1980 | /* yy_c_buf_p now points to the character we want to return. |
||
1981 | * If this occurs *before* the EOB characters, then it's a |
||
1982 | * valid NUL; if not, then we've hit the end of the buffer. |
||
1983 | */ |
||
1984 | if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) |
||
1985 | /* This was really a NUL. */ |
||
1986 | *yyg->yy_c_buf_p = '\0'; |
||
1987 | |||
1988 | |||
1989 | { /* need more input */ |
||
1990 | int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); |
||
7195 | punk_joker | 1991 | ++yyg->yy_c_buf_p; |
5563 | serge | 1992 | |
1993 | |||
1994 | { |
||
1995 | case EOB_ACT_LAST_MATCH: |
||
1996 | /* This happens because yy_g_n_b() |
||
1997 | * sees that we've accumulated a |
||
1998 | * token and flags that we need to |
||
1999 | * try matching the token before |
||
2000 | * proceeding. But for input(), |
||
2001 | * there's no matching to consider. |
||
2002 | * So convert the EOB_ACT_LAST_MATCH |
||
2003 | * to EOB_ACT_END_OF_FILE. |
||
2004 | */ |
||
2005 | |||
2006 | |||
2007 | yyrestart( yyin , yyscanner); |
||
7195 | punk_joker | 2008 | |
5563 | serge | 2009 | |
2010 | |||
2011 | |||
2012 | { |
||
2013 | if ( yywrap( yyscanner ) ) |
||
7195 | punk_joker | 2014 | return 0; |
2015 | |||
5563 | serge | 2016 | |
2017 | YY_NEW_FILE; |
||
2018 | #ifdef __cplusplus |
||
2019 | return yyinput(yyscanner); |
||
2020 | #else |
||
2021 | return input(yyscanner); |
||
2022 | #endif |
||
2023 | } |
||
2024 | |||
2025 | |||
2026 | yyg->yy_c_buf_p = yyg->yytext_ptr + offset; |
||
2027 | break; |
||
2028 | } |
||
2029 | } |
||
2030 | } |
||
2031 | |||
2032 | |||
2033 | *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ |
||
2034 | yyg->yy_hold_char = *++yyg->yy_c_buf_p; |
||
2035 | |||
2036 | |||
2037 | |||
2038 | |||
2039 | } |
||
2040 | #endif /* ifndef YY_NO_INPUT */ |
||
2041 | |||
2042 | |||
2043 | * @param input_file A readable stream. |
||
2044 | * @param yyscanner The scanner object. |
||
2045 | * @note This function does not reset the start condition to @c INITIAL . |
||
2046 | */ |
||
2047 | void yyrestart (FILE * input_file , yyscan_t yyscanner) |
||
7195 | punk_joker | 2048 | { |
5563 | serge | 2049 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2050 | |||
2051 | |||
2052 | yyensure_buffer_stack (yyscanner); |
||
7195 | punk_joker | 2053 | YY_CURRENT_BUFFER_LVALUE = |
5563 | serge | 2054 | yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); |
7195 | punk_joker | 2055 | } |
5563 | serge | 2056 | |
2057 | |||
7195 | punk_joker | 2058 | yy_load_buffer_state( yyscanner ); |
2059 | } |
||
5563 | serge | 2060 | |
2061 | |||
2062 | * @param new_buffer The new input buffer. |
||
2063 | * @param yyscanner The scanner object. |
||
2064 | */ |
||
2065 | void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) |
||
7195 | punk_joker | 2066 | { |
5563 | serge | 2067 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2068 | |||
2069 | |||
2070 | * with |
||
2071 | * yypop_buffer_state(); |
||
7195 | punk_joker | 2072 | * yypush_buffer_state(new_buffer); |
2073 | */ |
||
5563 | serge | 2074 | yyensure_buffer_stack (yyscanner); |
7195 | punk_joker | 2075 | if ( YY_CURRENT_BUFFER == new_buffer ) |
5563 | serge | 2076 | return; |
2077 | |||
2078 | |||
2079 | { |
||
2080 | /* Flush out information for old buffer. */ |
||
2081 | *yyg->yy_c_buf_p = yyg->yy_hold_char; |
||
2082 | YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; |
||
2083 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; |
||
2084 | } |
||
2085 | |||
2086 | |||
2087 | yy_load_buffer_state( yyscanner ); |
||
7195 | punk_joker | 2088 | |
5563 | serge | 2089 | |
2090 | * EOF (yywrap()) processing, but the only time this flag |
||
7195 | punk_joker | 2091 | * is looked at is after yywrap() is called, so it's safe |
2092 | * to go ahead and always set it. |
||
5563 | serge | 2093 | */ |
2094 | yyg->yy_did_buffer_switch_on_eof = 1; |
||
2095 | } |
||
2096 | |||
2097 | |||
7195 | punk_joker | 2098 | { |
5563 | serge | 2099 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2100 | yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
||
2101 | yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; |
||
2102 | yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; |
||
2103 | yyg->yy_hold_char = *yyg->yy_c_buf_p; |
||
2104 | } |
||
2105 | |||
2106 | |||
2107 | * @param file A readable stream. |
||
2108 | * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. |
||
2109 | * @param yyscanner The scanner object. |
||
2110 | * @return the allocated buffer state. |
||
2111 | */ |
||
2112 | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) |
||
7195 | punk_joker | 2113 | { |
5563 | serge | 2114 | YY_BUFFER_STATE b; |
2115 | |||
2116 | |||
7195 | punk_joker | 2117 | if ( ! b ) |
5563 | serge | 2118 | YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); |
7195 | punk_joker | 2119 | |
5563 | serge | 2120 | |
2121 | |||
2122 | |||
2123 | * we need to put in 2 end-of-buffer characters. |
||
2124 | */ |
||
2125 | b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); |
||
7195 | punk_joker | 2126 | if ( ! b->yy_ch_buf ) |
5563 | serge | 2127 | YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); |
7195 | punk_joker | 2128 | |
5563 | serge | 2129 | |
2130 | |||
2131 | |||
7195 | punk_joker | 2132 | |
5563 | serge | 2133 | |
2134 | } |
||
2135 | |||
2136 | |||
2137 | * @param b a buffer created with yy_create_buffer() |
||
7195 | punk_joker | 2138 | * @param yyscanner The scanner object. |
5563 | serge | 2139 | */ |
2140 | void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) |
||
7195 | punk_joker | 2141 | { |
5563 | serge | 2142 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2143 | |||
2144 | |||
2145 | return; |
||
2146 | |||
2147 | |||
2148 | YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; |
||
2149 | |||
2150 | |||
2151 | yyfree( (void *) b->yy_ch_buf , yyscanner ); |
||
7195 | punk_joker | 2152 | |
5563 | serge | 2153 | |
7195 | punk_joker | 2154 | } |
5563 | serge | 2155 | |
2156 | |||
2157 | * This function is sometimes called more than once on the same buffer, |
||
2158 | * such as during a yyrestart() or at EOF. |
||
7195 | punk_joker | 2159 | */ |
5563 | serge | 2160 | static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) |
7195 | punk_joker | 2161 | |
5563 | serge | 2162 | |
2163 | int oerrno = errno; |
||
2164 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
2165 | |||
2166 | |||
7195 | punk_joker | 2167 | |
5563 | serge | 2168 | |
2169 | b->yy_fill_buffer = 1; |
||
2170 | |||
2171 | |||
7195 | punk_joker | 2172 | * called from yyrestart() or through yy_get_next_buffer. |
2173 | * In that case, we don't want to reset the lineno or column. |
||
5563 | serge | 2174 | */ |
2175 | if (b != YY_CURRENT_BUFFER){ |
||
2176 | b->yy_bs_lineno = 1; |
||
2177 | b->yy_bs_column = 0; |
||
2178 | } |
||
2179 | |||
2180 | |||
2181 | |||
2182 | |||
2183 | } |
||
2184 | |||
2185 | |||
2186 | * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. |
||
2187 | * @param yyscanner The scanner object. |
||
2188 | */ |
||
2189 | void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) |
||
7195 | punk_joker | 2190 | { |
5563 | serge | 2191 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2192 | if ( ! b ) |
||
2193 | return; |
||
2194 | |||
2195 | |||
2196 | |||
2197 | |||
2198 | * a transition to the end-of-buffer state. The second causes |
||
2199 | * a jam in that state. |
||
2200 | */ |
||
2201 | b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; |
||
2202 | b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; |
||
2203 | |||
2204 | |||
2205 | |||
2206 | |||
2207 | b->yy_buffer_status = YY_BUFFER_NEW; |
||
2208 | |||
2209 | |||
2210 | yy_load_buffer_state( yyscanner ); |
||
7195 | punk_joker | 2211 | } |
5563 | serge | 2212 | |
2213 | |||
2214 | * the current state. This function will allocate the stack |
||
2215 | * if necessary. |
||
2216 | * @param new_buffer The new state. |
||
2217 | * @param yyscanner The scanner object. |
||
2218 | */ |
||
2219 | void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) |
||
7195 | punk_joker | 2220 | { |
5563 | serge | 2221 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2222 | if (new_buffer == NULL) |
||
2223 | return; |
||
2224 | |||
2225 | |||
7195 | punk_joker | 2226 | |
5563 | serge | 2227 | |
7195 | punk_joker | 2228 | if ( YY_CURRENT_BUFFER ) |
5563 | serge | 2229 | { |
2230 | /* Flush out information for old buffer. */ |
||
2231 | *yyg->yy_c_buf_p = yyg->yy_hold_char; |
||
2232 | YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; |
||
2233 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; |
||
2234 | } |
||
2235 | |||
2236 | |||
2237 | if (YY_CURRENT_BUFFER) |
||
2238 | yyg->yy_buffer_stack_top++; |
||
2239 | YY_CURRENT_BUFFER_LVALUE = new_buffer; |
||
2240 | |||
2241 | |||
7195 | punk_joker | 2242 | yy_load_buffer_state( yyscanner ); |
2243 | yyg->yy_did_buffer_switch_on_eof = 1; |
||
5563 | serge | 2244 | } |
2245 | |||
2246 | |||
2247 | * The next element becomes the new top. |
||
2248 | * @param yyscanner The scanner object. |
||
2249 | */ |
||
2250 | void yypop_buffer_state (yyscan_t yyscanner) |
||
7195 | punk_joker | 2251 | { |
5563 | serge | 2252 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2253 | if (!YY_CURRENT_BUFFER) |
||
2254 | return; |
||
2255 | |||
2256 | |||
7195 | punk_joker | 2257 | YY_CURRENT_BUFFER_LVALUE = NULL; |
5563 | serge | 2258 | if (yyg->yy_buffer_stack_top > 0) |
2259 | --yyg->yy_buffer_stack_top; |
||
2260 | |||
2261 | |||
2262 | yy_load_buffer_state( yyscanner ); |
||
7195 | punk_joker | 2263 | yyg->yy_did_buffer_switch_on_eof = 1; |
5563 | serge | 2264 | } |
2265 | } |
||
2266 | |||
2267 | |||
2268 | * Guarantees space for at least one push. |
||
2269 | */ |
||
2270 | static void yyensure_buffer_stack (yyscan_t yyscanner) |
||
7195 | punk_joker | 2271 | { |
5563 | serge | 2272 | yy_size_t num_to_alloc; |
7195 | punk_joker | 2273 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
5563 | serge | 2274 | |
2275 | |||
2276 | |||
2277 | |||
2278 | * scanner will even need a stack. We use 2 instead of 1 to avoid an |
||
2279 | * immediate realloc on the next call. |
||
2280 | */ |
||
2281 | num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ |
||
7195 | punk_joker | 2282 | yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc |
2283 | (num_to_alloc * sizeof(struct yy_buffer_state*) |
||
5563 | serge | 2284 | , yyscanner); |
2285 | if ( ! yyg->yy_buffer_stack ) |
||
2286 | YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); |
||
7195 | punk_joker | 2287 | |
2288 | |||
5563 | serge | 2289 | |
7195 | punk_joker | 2290 | |
5563 | serge | 2291 | yyg->yy_buffer_stack_top = 0; |
2292 | return; |
||
2293 | } |
||
2294 | |||
2295 | |||
2296 | |||
2297 | |||
2298 | yy_size_t grow_size = 8 /* arbitrary grow size */; |
||
7195 | punk_joker | 2299 | |
5563 | serge | 2300 | |
2301 | yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc |
||
7195 | punk_joker | 2302 | (yyg->yy_buffer_stack, |
5563 | serge | 2303 | num_to_alloc * sizeof(struct yy_buffer_state*) |
2304 | , yyscanner); |
||
2305 | if ( ! yyg->yy_buffer_stack ) |
||
2306 | YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); |
||
7195 | punk_joker | 2307 | |
5563 | serge | 2308 | |
2309 | memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); |
||
2310 | yyg->yy_buffer_stack_max = num_to_alloc; |
||
2311 | } |
||
2312 | } |
||
2313 | |||
2314 | |||
2315 | * @param base the character buffer |
||
2316 | * @param size the size in bytes of the character buffer |
||
2317 | * @param yyscanner The scanner object. |
||
2318 | * @return the newly allocated buffer state object. |
||
7195 | punk_joker | 2319 | */ |
5563 | serge | 2320 | YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) |
7195 | punk_joker | 2321 | { |
5563 | serge | 2322 | YY_BUFFER_STATE b; |
2323 | |||
2324 | |||
2325 | base[size-2] != YY_END_OF_BUFFER_CHAR || |
||
2326 | base[size-1] != YY_END_OF_BUFFER_CHAR ) |
||
2327 | /* They forgot to leave room for the EOB's. */ |
||
2328 | return NULL; |
||
7195 | punk_joker | 2329 | |
5563 | serge | 2330 | |
7195 | punk_joker | 2331 | if ( ! b ) |
5563 | serge | 2332 | YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); |
7195 | punk_joker | 2333 | |
5563 | serge | 2334 | |
7195 | punk_joker | 2335 | b->yy_buf_pos = b->yy_ch_buf = base; |
5563 | serge | 2336 | b->yy_is_our_buffer = 0; |
2337 | b->yy_input_file = NULL; |
||
7195 | punk_joker | 2338 | b->yy_n_chars = b->yy_buf_size; |
5563 | serge | 2339 | b->yy_is_interactive = 0; |
2340 | b->yy_at_bol = 1; |
||
2341 | b->yy_fill_buffer = 0; |
||
2342 | b->yy_buffer_status = YY_BUFFER_NEW; |
||
2343 | |||
2344 | |||
7195 | punk_joker | 2345 | |
5563 | serge | 2346 | |
2347 | } |
||
2348 | |||
2349 | |||
7195 | punk_joker | 2350 | * scan from a @e copy of @a str. |
5563 | serge | 2351 | * @param yystr a NUL-terminated string to scan |
2352 | * @param yyscanner The scanner object. |
||
2353 | * @return the newly allocated buffer state object. |
||
2354 | * @note If you want to scan bytes that may contain NUL values, then use |
||
2355 | * yy_scan_bytes() instead. |
||
7195 | punk_joker | 2356 | */ |
5563 | serge | 2357 | YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner) |
7195 | punk_joker | 2358 | { |
5563 | serge | 2359 | |
2360 | |||
7195 | punk_joker | 2361 | } |
5563 | serge | 2362 | |
2363 | |||
7195 | punk_joker | 2364 | * scan from a @e copy of @a bytes. |
5563 | serge | 2365 | * @param yybytes the byte buffer to scan |
2366 | * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. |
||
2367 | * @param yyscanner The scanner object. |
||
2368 | * @return the newly allocated buffer state object. |
||
2369 | */ |
||
2370 | YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner) |
||
7195 | punk_joker | 2371 | { |
5563 | serge | 2372 | YY_BUFFER_STATE b; |
2373 | char *buf; |
||
2374 | yy_size_t n; |
||
2375 | int i; |
||
2376 | |||
2377 | |||
2378 | n = (yy_size_t) (_yybytes_len + 2); |
||
7195 | punk_joker | 2379 | buf = (char *) yyalloc( n , yyscanner ); |
2380 | if ( ! buf ) |
||
5563 | serge | 2381 | YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); |
7195 | punk_joker | 2382 | |
5563 | serge | 2383 | |
2384 | buf[i] = yybytes[i]; |
||
2385 | |||
2386 | |||
2387 | |||
2388 | |||
7195 | punk_joker | 2389 | if ( ! b ) |
5563 | serge | 2390 | YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); |
7195 | punk_joker | 2391 | |
5563 | serge | 2392 | |
2393 | * away when we're done. |
||
2394 | */ |
||
2395 | b->yy_is_our_buffer = 1; |
||
2396 | |||
2397 | |||
2398 | } |
||
2399 | |||
2400 | |||
7195 | punk_joker | 2401 | { |
5563 | serge | 2402 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2403 | if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) |
||
2404 | { |
||
2405 | yy_size_t new_size; |
||
2406 | |||
2407 | |||
2408 | new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int ); |
||
7195 | punk_joker | 2409 | |
5563 | serge | 2410 | |
2411 | yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner ); |
||
7195 | punk_joker | 2412 | |
5563 | serge | 2413 | |
2414 | yyg->yy_start_stack = (int *) yyrealloc( |
||
7195 | punk_joker | 2415 | (void *) yyg->yy_start_stack, new_size , yyscanner ); |
2416 | |||
5563 | serge | 2417 | |
2418 | YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); |
||
2419 | } |
||
2420 | |||
2421 | |||
2422 | |||
2423 | |||
7195 | punk_joker | 2424 | } |
5563 | serge | 2425 | |
2426 | |||
2427 | { |
||
2428 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
2429 | if ( --yyg->yy_start_stack_ptr < 0 ) |
||
2430 | YY_FATAL_ERROR( "start-condition stack underflow" ); |
||
2431 | |||
2432 | |||
2433 | } |
||
2434 | |||
2435 | |||
2436 | { |
||
2437 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
2438 | return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1]; |
||
2439 | } |
||
2440 | |||
2441 | |||
2442 | #define YY_EXIT_FAILURE 2 |
||
2443 | #endif |
||
2444 | |||
2445 | |||
7195 | punk_joker | 2446 | { |
5563 | serge | 2447 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
7195 | punk_joker | 2448 | (void)yyg; |
2449 | fprintf( stderr, "%s\n", msg ); |
||
2450 | exit( YY_EXIT_FAILURE ); |
||
5563 | serge | 2451 | } |
2452 | |||
2453 | |||
2454 | |||
2455 | |||
2456 | #define yyless(n) \ |
||
2457 | do \ |
||
2458 | { \ |
||
2459 | /* Undo effects of setting up yytext. */ \ |
||
2460 | int yyless_macro_arg = (n); \ |
||
2461 | YY_LESS_LINENO(yyless_macro_arg);\ |
||
2462 | yytext[yyleng] = yyg->yy_hold_char; \ |
||
2463 | yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ |
||
2464 | yyg->yy_hold_char = *yyg->yy_c_buf_p; \ |
||
2465 | *yyg->yy_c_buf_p = '\0'; \ |
||
2466 | yyleng = yyless_macro_arg; \ |
||
2467 | } \ |
||
2468 | while ( 0 ) |
||
2469 | |||
2470 | |||
2471 | |||
2472 | |||
2473 | * @param yyscanner The scanner object. |
||
2474 | */ |
||
2475 | YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner) |
||
7195 | punk_joker | 2476 | { |
5563 | serge | 2477 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2478 | return yyextra; |
||
2479 | } |
||
2480 | |||
2481 | |||
2482 | * @param yyscanner The scanner object. |
||
2483 | */ |
||
2484 | int yyget_lineno (yyscan_t yyscanner) |
||
7195 | punk_joker | 2485 | { |
5563 | serge | 2486 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2487 | |||
7195 | punk_joker | 2488 | |
5563 | serge | 2489 | return 0; |
2490 | |||
2491 | |||
2492 | } |
||
2493 | |||
2494 | |||
2495 | * @param yyscanner The scanner object. |
||
2496 | */ |
||
2497 | int yyget_column (yyscan_t yyscanner) |
||
7195 | punk_joker | 2498 | { |
5563 | serge | 2499 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2500 | |||
7195 | punk_joker | 2501 | |
5563 | serge | 2502 | return 0; |
2503 | |||
2504 | |||
2505 | } |
||
2506 | |||
2507 | |||
2508 | * @param yyscanner The scanner object. |
||
2509 | */ |
||
2510 | FILE *yyget_in (yyscan_t yyscanner) |
||
7195 | punk_joker | 2511 | { |
5563 | serge | 2512 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2513 | return yyin; |
||
2514 | } |
||
2515 | |||
2516 | |||
2517 | * @param yyscanner The scanner object. |
||
2518 | */ |
||
2519 | FILE *yyget_out (yyscan_t yyscanner) |
||
7195 | punk_joker | 2520 | { |
5563 | serge | 2521 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2522 | return yyout; |
||
2523 | } |
||
2524 | |||
2525 | |||
2526 | * @param yyscanner The scanner object. |
||
2527 | */ |
||
2528 | int yyget_leng (yyscan_t yyscanner) |
||
7195 | punk_joker | 2529 | { |
5563 | serge | 2530 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2531 | return yyleng; |
||
2532 | } |
||
2533 | |||
2534 | |||
2535 | * @param yyscanner The scanner object. |
||
2536 | */ |
||
2537 | |||
2538 | |||
7195 | punk_joker | 2539 | { |
5563 | serge | 2540 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2541 | return yytext; |
||
2542 | } |
||
2543 | |||
2544 | |||
2545 | * @param user_defined The data to be associated with this scanner. |
||
2546 | * @param yyscanner The scanner object. |
||
2547 | */ |
||
2548 | void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) |
||
7195 | punk_joker | 2549 | { |
5563 | serge | 2550 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2551 | yyextra = user_defined ; |
||
2552 | } |
||
2553 | |||
2554 | |||
2555 | * @param _line_number line number |
||
7195 | punk_joker | 2556 | * @param yyscanner The scanner object. |
5563 | serge | 2557 | */ |
2558 | void yyset_lineno (int _line_number , yyscan_t yyscanner) |
||
7195 | punk_joker | 2559 | { |
5563 | serge | 2560 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2561 | |||
2562 | |||
2563 | if (! YY_CURRENT_BUFFER ) |
||
2564 | YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); |
||
7195 | punk_joker | 2565 | |
5563 | serge | 2566 | |
7195 | punk_joker | 2567 | } |
5563 | serge | 2568 | |
2569 | |||
2570 | * @param _column_no column number |
||
7195 | punk_joker | 2571 | * @param yyscanner The scanner object. |
5563 | serge | 2572 | */ |
2573 | void yyset_column (int _column_no , yyscan_t yyscanner) |
||
7195 | punk_joker | 2574 | { |
5563 | serge | 2575 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2576 | |||
2577 | |||
2578 | if (! YY_CURRENT_BUFFER ) |
||
2579 | YY_FATAL_ERROR( "yyset_column called with no buffer" ); |
||
7195 | punk_joker | 2580 | |
5563 | serge | 2581 | |
7195 | punk_joker | 2582 | } |
5563 | serge | 2583 | |
2584 | |||
2585 | * input buffer. |
||
2586 | * @param _in_str A readable stream. |
||
7195 | punk_joker | 2587 | * @param yyscanner The scanner object. |
5563 | serge | 2588 | * @see yy_switch_to_buffer |
7195 | punk_joker | 2589 | */ |
5563 | serge | 2590 | void yyset_in (FILE * _in_str , yyscan_t yyscanner) |
7195 | punk_joker | 2591 | { |
5563 | serge | 2592 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2593 | yyin = _in_str ; |
||
7195 | punk_joker | 2594 | } |
5563 | serge | 2595 | |
2596 | |||
7195 | punk_joker | 2597 | { |
5563 | serge | 2598 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2599 | yyout = _out_str ; |
||
7195 | punk_joker | 2600 | } |
5563 | serge | 2601 | |
2602 | |||
7195 | punk_joker | 2603 | { |
5563 | serge | 2604 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2605 | return yy_flex_debug; |
||
2606 | } |
||
2607 | |||
2608 | |||
7195 | punk_joker | 2609 | { |
5563 | serge | 2610 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2611 | yy_flex_debug = _bdebug ; |
||
7195 | punk_joker | 2612 | } |
5563 | serge | 2613 | |
2614 | |||
2615 | |||
2616 | |||
7195 | punk_joker | 2617 | { |
5563 | serge | 2618 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2619 | return yylval; |
||
2620 | } |
||
2621 | |||
2622 | |||
7195 | punk_joker | 2623 | { |
5563 | serge | 2624 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2625 | yylval = yylval_param; |
||
2626 | } |
||
2627 | |||
2628 | |||
7195 | punk_joker | 2629 | { |
5563 | serge | 2630 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2631 | return yylloc; |
||
2632 | } |
||
2633 | |||
2634 | |||
7195 | punk_joker | 2635 | { |
5563 | serge | 2636 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2637 | yylloc = yylloc_param; |
||
2638 | } |
||
2639 | |||
2640 | |||
2641 | |||
2642 | |||
7195 | punk_joker | 2643 | * the ONLY reentrant function that doesn't take the scanner as the last argument. |
5563 | serge | 2644 | * That's why we explicitly handle the declaration, instead of using our macros. |
2645 | */ |
||
2646 | int yylex_init(yyscan_t* ptr_yy_globals) |
||
7195 | punk_joker | 2647 | { |
5563 | serge | 2648 | if (ptr_yy_globals == NULL){ |
2649 | errno = EINVAL; |
||
2650 | return 1; |
||
2651 | } |
||
2652 | |||
2653 | |||
7195 | punk_joker | 2654 | |
5563 | serge | 2655 | |
2656 | errno = ENOMEM; |
||
2657 | return 1; |
||
2658 | } |
||
2659 | |||
2660 | |||
2661 | memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); |
||
2662 | |||
2663 | |||
2664 | } |
||
2665 | |||
2666 | |||
7195 | punk_joker | 2667 | * convention of taking the scanner as the last argument. Note however, that |
5563 | serge | 2668 | * this is a *pointer* to a scanner, as it will be allocated by this call (and |
2669 | * is the reason, too, why this function also must handle its own declaration). |
||
2670 | * The user defined value in the first argument will be available to yyalloc in |
||
7195 | punk_joker | 2671 | * the yyextra field. |
5563 | serge | 2672 | */ |
2673 | int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) |
||
7195 | punk_joker | 2674 | { |
5563 | serge | 2675 | struct yyguts_t dummy_yyguts; |
2676 | |||
2677 | |||
7195 | punk_joker | 2678 | |
5563 | serge | 2679 | |
2680 | errno = EINVAL; |
||
2681 | return 1; |
||
2682 | } |
||
2683 | |||
7195 | punk_joker | 2684 | |
2685 | |||
2686 | |||
5563 | serge | 2687 | errno = ENOMEM; |
2688 | return 1; |
||
2689 | } |
||
2690 | |||
7195 | punk_joker | 2691 | |
5563 | serge | 2692 | yy_init_globals. Leave at 0x00 for releases. */ |
2693 | memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); |
||
2694 | |||
7195 | punk_joker | 2695 | |
2696 | |||
2697 | |||
5563 | serge | 2698 | } |
2699 | |||
2700 | |||
2701 | { |
||
2702 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
||
2703 | /* Initialization is the same as for the non-reentrant scanner. |
||
2704 | * This function is called from yylex_destroy(), so don't allocate here. |
||
7195 | punk_joker | 2705 | */ |
5563 | serge | 2706 | |
2707 | |||
7195 | punk_joker | 2708 | yyg->yy_buffer_stack_top = 0; |
5563 | serge | 2709 | yyg->yy_buffer_stack_max = 0; |
2710 | yyg->yy_c_buf_p = NULL; |
||
7195 | punk_joker | 2711 | yyg->yy_init = 0; |
5563 | serge | 2712 | yyg->yy_start = 0; |
2713 | |||
2714 | |||
2715 | yyg->yy_start_stack_depth = 0; |
||
2716 | yyg->yy_start_stack = NULL; |
||
2717 | |||
2718 | |||
2719 | #ifdef YY_STDINIT |
||
2720 | yyin = stdin; |
||
2721 | yyout = stdout; |
||
2722 | #else |
||
2723 | yyin = NULL; |
||
7195 | punk_joker | 2724 | yyout = NULL; |
2725 | #endif |
||
5563 | serge | 2726 | |
2727 | |||
2728 | * yylex_init() |
||
7195 | punk_joker | 2729 | */ |
5563 | serge | 2730 | return 0; |
2731 | } |
||
2732 | |||
2733 | |||
7195 | punk_joker | 2734 | int yylex_destroy (yyscan_t yyscanner) |
2735 | { |
||
5563 | serge | 2736 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
2737 | |||
2738 | |||
2739 | while(YY_CURRENT_BUFFER){ |
||
2740 | yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); |
||
7195 | punk_joker | 2741 | YY_CURRENT_BUFFER_LVALUE = NULL; |
5563 | serge | 2742 | yypop_buffer_state(yyscanner); |
7195 | punk_joker | 2743 | } |
5563 | serge | 2744 | |
2745 | |||
2746 | yyfree(yyg->yy_buffer_stack , yyscanner); |
||
7195 | punk_joker | 2747 | yyg->yy_buffer_stack = NULL; |
5563 | serge | 2748 | |
2749 | |||
2750 | yyfree( yyg->yy_start_stack , yyscanner ); |
||
7195 | punk_joker | 2751 | yyg->yy_start_stack = NULL; |
5563 | serge | 2752 | |
2753 | |||
2754 | * yylex() is called, initialization will occur. */ |
||
7195 | punk_joker | 2755 | yy_init_globals( yyscanner); |
5563 | serge | 2756 | |
2757 | |||
2758 | yyfree ( yyscanner , yyscanner ); |
||
7195 | punk_joker | 2759 | yyscanner = NULL; |
5563 | serge | 2760 | return 0; |
2761 | } |
||
2762 | |||
2763 | |||
2764 | * Internal utility routines. |
||
2765 | */ |
||
2766 | |||
2767 | |||
2768 | static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner) |
||
7195 | punk_joker | 2769 | { |
5563 | serge | 2770 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
7195 | punk_joker | 2771 | (void)yyg; |
2772 | |||
2773 | |||
2774 | for ( i = 0; i < n; ++i ) |
||
5563 | serge | 2775 | s1[i] = s2[i]; |
2776 | } |
||
2777 | #endif |
||
2778 | |||
2779 | |||
2780 | static int yy_flex_strlen (const char * s , yyscan_t yyscanner) |
||
7195 | punk_joker | 2781 | { |
5563 | serge | 2782 | int n; |
7195 | punk_joker | 2783 | for ( n = 0; s[n]; ++n ) |
5563 | serge | 2784 | ; |
2785 | |||
2786 | |||
2787 | } |
||
2788 | #endif |
||
2789 | |||
2790 | |||
7195 | punk_joker | 2791 | { |
5563 | serge | 2792 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
7195 | punk_joker | 2793 | (void)yyg; |
2794 | return malloc(size); |
||
2795 | } |
||
5563 | serge | 2796 | |
2797 | |||
7195 | punk_joker | 2798 | { |
5563 | serge | 2799 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
7195 | punk_joker | 2800 | (void)yyg; |
2801 | |||
2802 | |||
5563 | serge | 2803 | * implementations that use char* generic pointers, and those |
2804 | * that use void* generic pointers. It works with the latter |
||
2805 | * because both ANSI C and C++ allow castless assignment from |
||
2806 | * any pointer type to void*, and deal with argument conversions |
||
2807 | * as though doing an assignment. |
||
2808 | */ |
||
2809 | return realloc(ptr, size); |
||
7195 | punk_joker | 2810 | } |
5563 | serge | 2811 | |
2812 | |||
7195 | punk_joker | 2813 | { |
5563 | serge | 2814 | struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; |
7195 | punk_joker | 2815 | (void)yyg; |
2816 | free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ |
||
2817 | } |
||
5563 | serge | 2818 | |
2819 | |||
2820 | |||
2821 | |||
7195 | punk_joker | 2822 | |
5563 | serge | 2823 | |
2824 | |||
2825 | glcpp_lex_set_source_string(glcpp_parser_t *parser, const char *shader) |
||
2826 | { |
||
2827 | yy_scan_string(shader, parser->scanner); |
||
7195 | punk_joker | 2828 | }>>>>>>>>=>=>>=>=">>>>>>> |
5563 | serge | 2829 |