ReactOS  0.4.14-dev-552-g2fad488
ppl.yy.c
Go to the documentation of this file.
1 #line 1 "ppl.yy.c"
2 
3 #line 3 "ppl.yy.c"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define yy_create_buffer ppy__create_buffer
10 #define yy_delete_buffer ppy__delete_buffer
11 #define yy_scan_buffer ppy__scan_buffer
12 #define yy_scan_string ppy__scan_string
13 #define yy_scan_bytes ppy__scan_bytes
14 #define yy_init_buffer ppy__init_buffer
15 #define yy_flush_buffer ppy__flush_buffer
16 #define yy_load_buffer_state ppy__load_buffer_state
17 #define yy_switch_to_buffer ppy__switch_to_buffer
18 #define yypush_buffer_state ppy_push_buffer_state
19 #define yypop_buffer_state ppy_pop_buffer_state
20 #define yyensure_buffer_stack ppy_ensure_buffer_stack
21 #define yy_flex_debug ppy__flex_debug
22 #define yyin ppy_in
23 #define yyleng ppy_leng
24 #define yylex ppy_lex
25 #define yylineno ppy_lineno
26 #define yyout ppy_out
27 #define yyrestart ppy_restart
28 #define yytext ppy_text
29 #define yywrap ppy_wrap
30 #define yyalloc ppy_alloc
31 #define yyrealloc ppy_realloc
32 #define yyfree ppy_free
33 
34 #define FLEX_SCANNER
35 #define YY_FLEX_MAJOR_VERSION 2
36 #define YY_FLEX_MINOR_VERSION 6
37 #define YY_FLEX_SUBMINOR_VERSION 4
38 #if YY_FLEX_SUBMINOR_VERSION > 0
39 #define FLEX_BETA
40 #endif
41 
42 #ifdef yy_create_buffer
43 #define ppy__create_buffer_ALREADY_DEFINED
44 #else
45 #define yy_create_buffer ppy__create_buffer
46 #endif
47 
48 #ifdef yy_delete_buffer
49 #define ppy__delete_buffer_ALREADY_DEFINED
50 #else
51 #define yy_delete_buffer ppy__delete_buffer
52 #endif
53 
54 #ifdef yy_scan_buffer
55 #define ppy__scan_buffer_ALREADY_DEFINED
56 #else
57 #define yy_scan_buffer ppy__scan_buffer
58 #endif
59 
60 #ifdef yy_scan_string
61 #define ppy__scan_string_ALREADY_DEFINED
62 #else
63 #define yy_scan_string ppy__scan_string
64 #endif
65 
66 #ifdef yy_scan_bytes
67 #define ppy__scan_bytes_ALREADY_DEFINED
68 #else
69 #define yy_scan_bytes ppy__scan_bytes
70 #endif
71 
72 #ifdef yy_init_buffer
73 #define ppy__init_buffer_ALREADY_DEFINED
74 #else
75 #define yy_init_buffer ppy__init_buffer
76 #endif
77 
78 #ifdef yy_flush_buffer
79 #define ppy__flush_buffer_ALREADY_DEFINED
80 #else
81 #define yy_flush_buffer ppy__flush_buffer
82 #endif
83 
84 #ifdef yy_load_buffer_state
85 #define ppy__load_buffer_state_ALREADY_DEFINED
86 #else
87 #define yy_load_buffer_state ppy__load_buffer_state
88 #endif
89 
90 #ifdef yy_switch_to_buffer
91 #define ppy__switch_to_buffer_ALREADY_DEFINED
92 #else
93 #define yy_switch_to_buffer ppy__switch_to_buffer
94 #endif
95 
96 #ifdef yypush_buffer_state
97 #define ppy_push_buffer_state_ALREADY_DEFINED
98 #else
99 #define yypush_buffer_state ppy_push_buffer_state
100 #endif
101 
102 #ifdef yypop_buffer_state
103 #define ppy_pop_buffer_state_ALREADY_DEFINED
104 #else
105 #define yypop_buffer_state ppy_pop_buffer_state
106 #endif
107 
108 #ifdef yyensure_buffer_stack
109 #define ppy_ensure_buffer_stack_ALREADY_DEFINED
110 #else
111 #define yyensure_buffer_stack ppy_ensure_buffer_stack
112 #endif
113 
114 #ifdef yylex
115 #define ppy_lex_ALREADY_DEFINED
116 #else
117 #define yylex ppy_lex
118 #endif
119 
120 #ifdef yyrestart
121 #define ppy_restart_ALREADY_DEFINED
122 #else
123 #define yyrestart ppy_restart
124 #endif
125 
126 #ifdef yylex_init
127 #define ppy_lex_init_ALREADY_DEFINED
128 #else
129 #define yylex_init ppy_lex_init
130 #endif
131 
132 #ifdef yylex_init_extra
133 #define ppy_lex_init_extra_ALREADY_DEFINED
134 #else
135 #define yylex_init_extra ppy_lex_init_extra
136 #endif
137 
138 #ifdef yylex_destroy
139 #define ppy_lex_destroy_ALREADY_DEFINED
140 #else
141 #define yylex_destroy ppy_lex_destroy
142 #endif
143 
144 #ifdef yyget_debug
145 #define ppy_get_debug_ALREADY_DEFINED
146 #else
147 #define yyget_debug ppy_get_debug
148 #endif
149 
150 #ifdef yyset_debug
151 #define ppy_set_debug_ALREADY_DEFINED
152 #else
153 #define yyset_debug ppy_set_debug
154 #endif
155 
156 #ifdef yyget_extra
157 #define ppy_get_extra_ALREADY_DEFINED
158 #else
159 #define yyget_extra ppy_get_extra
160 #endif
161 
162 #ifdef yyset_extra
163 #define ppy_set_extra_ALREADY_DEFINED
164 #else
165 #define yyset_extra ppy_set_extra
166 #endif
167 
168 #ifdef yyget_in
169 #define ppy_get_in_ALREADY_DEFINED
170 #else
171 #define yyget_in ppy_get_in
172 #endif
173 
174 #ifdef yyset_in
175 #define ppy_set_in_ALREADY_DEFINED
176 #else
177 #define yyset_in ppy_set_in
178 #endif
179 
180 #ifdef yyget_out
181 #define ppy_get_out_ALREADY_DEFINED
182 #else
183 #define yyget_out ppy_get_out
184 #endif
185 
186 #ifdef yyset_out
187 #define ppy_set_out_ALREADY_DEFINED
188 #else
189 #define yyset_out ppy_set_out
190 #endif
191 
192 #ifdef yyget_leng
193 #define ppy_get_leng_ALREADY_DEFINED
194 #else
195 #define yyget_leng ppy_get_leng
196 #endif
197 
198 #ifdef yyget_text
199 #define ppy_get_text_ALREADY_DEFINED
200 #else
201 #define yyget_text ppy_get_text
202 #endif
203 
204 #ifdef yyget_lineno
205 #define ppy_get_lineno_ALREADY_DEFINED
206 #else
207 #define yyget_lineno ppy_get_lineno
208 #endif
209 
210 #ifdef yyset_lineno
211 #define ppy_set_lineno_ALREADY_DEFINED
212 #else
213 #define yyset_lineno ppy_set_lineno
214 #endif
215 
216 #ifdef yywrap
217 #define ppy_wrap_ALREADY_DEFINED
218 #else
219 #define yywrap ppy_wrap
220 #endif
221 
222 #ifdef yyalloc
223 #define ppy_alloc_ALREADY_DEFINED
224 #else
225 #define yyalloc ppy_alloc
226 #endif
227 
228 #ifdef yyrealloc
229 #define ppy_realloc_ALREADY_DEFINED
230 #else
231 #define yyrealloc ppy_realloc
232 #endif
233 
234 #ifdef yyfree
235 #define ppy_free_ALREADY_DEFINED
236 #else
237 #define yyfree ppy_free
238 #endif
239 
240 #ifdef yytext
241 #define ppy_text_ALREADY_DEFINED
242 #else
243 #define yytext ppy_text
244 #endif
245 
246 #ifdef yyleng
247 #define ppy_leng_ALREADY_DEFINED
248 #else
249 #define yyleng ppy_leng
250 #endif
251 
252 #ifdef yyin
253 #define ppy_in_ALREADY_DEFINED
254 #else
255 #define yyin ppy_in
256 #endif
257 
258 #ifdef yyout
259 #define ppy_out_ALREADY_DEFINED
260 #else
261 #define yyout ppy_out
262 #endif
263 
264 #ifdef yy_flex_debug
265 #define ppy__flex_debug_ALREADY_DEFINED
266 #else
267 #define yy_flex_debug ppy__flex_debug
268 #endif
269 
270 #ifdef yylineno
271 #define ppy_lineno_ALREADY_DEFINED
272 #else
273 #define yylineno ppy_lineno
274 #endif
275 
276 /* First, we deal with platform-specific or compiler-specific issues. */
277 
278 /* begin standard C headers. */
279 #include <stdio.h>
280 #include <string.h>
281 #include <errno.h>
282 #include <stdlib.h>
283 
284 /* end standard C headers. */
285 
286 /* flex integer type definitions */
287 
288 #ifndef FLEXINT_H
289 #define FLEXINT_H
290 
291 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
292 
293 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
294 
295 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
296  * if you want the limit (max/min) macros for int types.
297  */
298 #ifndef __STDC_LIMIT_MACROS
299 #define __STDC_LIMIT_MACROS 1
300 #endif
301 
302 #include <inttypes.h>
303 typedef int8_t flex_int8_t;
304 typedef uint8_t flex_uint8_t;
305 typedef int16_t flex_int16_t;
306 typedef uint16_t flex_uint16_t;
307 typedef int32_t flex_int32_t;
308 typedef uint32_t flex_uint32_t;
309 #else
310 typedef signed char flex_int8_t;
311 typedef short int flex_int16_t;
312 typedef int flex_int32_t;
313 typedef unsigned char flex_uint8_t;
314 typedef unsigned short int flex_uint16_t;
315 typedef unsigned int flex_uint32_t;
316 
317 /* Limits of integral types. */
318 #ifndef INT8_MIN
319 #define INT8_MIN (-128)
320 #endif
321 #ifndef INT16_MIN
322 #define INT16_MIN (-32767-1)
323 #endif
324 #ifndef INT32_MIN
325 #define INT32_MIN (-2147483647-1)
326 #endif
327 #ifndef INT8_MAX
328 #define INT8_MAX (127)
329 #endif
330 #ifndef INT16_MAX
331 #define INT16_MAX (32767)
332 #endif
333 #ifndef INT32_MAX
334 #define INT32_MAX (2147483647)
335 #endif
336 #ifndef UINT8_MAX
337 #define UINT8_MAX (255U)
338 #endif
339 #ifndef UINT16_MAX
340 #define UINT16_MAX (65535U)
341 #endif
342 #ifndef UINT32_MAX
343 #define UINT32_MAX (4294967295U)
344 #endif
345 
346 #ifndef SIZE_MAX
347 #define SIZE_MAX (~(size_t)0)
348 #endif
349 
350 #endif /* ! C99 */
351 
352 #endif /* ! FLEXINT_H */
353 
354 /* begin standard C++ headers. */
355 
356 /* TODO: this is always defined, so inline it */
357 #define yyconst const
358 
359 #if defined(__GNUC__) && __GNUC__ >= 3
360 #define yynoreturn __attribute__((__noreturn__))
361 #else
362 #define yynoreturn
363 #endif
364 
365 /* Returned upon end-of-file. */
366 #define YY_NULL 0
367 
368 /* Promotes a possibly negative, possibly signed char to an
369  * integer in range [0..255] for use as an array index.
370  */
371 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
372 
373 /* Enter a start condition. This macro really ought to take a parameter,
374  * but we do it the disgusting crufty way forced on us by the ()-less
375  * definition of BEGIN.
376  */
377 #define BEGIN (yy_start) = 1 + 2 *
378 /* Translate the current start state into a value that can be later handed
379  * to BEGIN to return to the state. The YYSTATE alias is for lex
380  * compatibility.
381  */
382 #define YY_START (((yy_start) - 1) / 2)
383 #define YYSTATE YY_START
384 /* Action number for EOF rule of a given start state. */
385 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
386 /* Special action meaning "start processing a new file". */
387 #define YY_NEW_FILE yyrestart( yyin )
388 #define YY_END_OF_BUFFER_CHAR 0
389 
390 /* Size of default input buffer. */
391 #ifndef YY_BUF_SIZE
392 #ifdef __ia64__
393 /* On IA-64, the buffer size is 16k, not 8k.
394  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
395  * Ditto for the __ia64__ case accordingly.
396  */
397 #define YY_BUF_SIZE 32768
398 #else
399 #define YY_BUF_SIZE 16384
400 #endif /* __ia64__ */
401 #endif
402 
403 /* The state buf must be large enough to hold one state per character in the main buffer.
404  */
405 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
406 
407 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
408 #define YY_TYPEDEF_YY_BUFFER_STATE
410 #endif
411 
412 #ifndef YY_TYPEDEF_YY_SIZE_T
413 #define YY_TYPEDEF_YY_SIZE_T
414 typedef size_t yy_size_t;
415 #endif
416 
417 extern int yyleng;
418 
419 extern FILE *yyin, *yyout;
420 
421 #define EOB_ACT_CONTINUE_SCAN 0
422 #define EOB_ACT_END_OF_FILE 1
423 #define EOB_ACT_LAST_MATCH 2
424 
425  #define YY_LESS_LINENO(n)
426  #define YY_LINENO_REWIND_TO(ptr)
427 
428 /* Return all but the first "n" matched characters back to the input stream. */
429 #define yyless(n) \
430  do \
431  { \
432  /* Undo effects of setting up yytext. */ \
433  int yyless_macro_arg = (n); \
434  YY_LESS_LINENO(yyless_macro_arg);\
435  *yy_cp = (yy_hold_char); \
436  YY_RESTORE_YY_MORE_OFFSET \
437  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
438  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
439  } \
440  while ( 0 )
441 #define unput(c) yyunput( c, (yytext_ptr) )
442 
443 #ifndef YY_STRUCT_YY_BUFFER_STATE
444 #define YY_STRUCT_YY_BUFFER_STATE
445 struct yy_buffer_state
446  {
448 
449  char *yy_ch_buf; /* input buffer */
450  char *yy_buf_pos; /* current position in input buffer */
451 
452  /* Size of input buffer in bytes, not including room for EOB
453  * characters.
454  */
455  int yy_buf_size;
456 
457  /* Number of characters read into yy_ch_buf, not including EOB
458  * characters.
459  */
460  int yy_n_chars;
461 
462  /* Whether we "own" the buffer - i.e., we know we created it,
463  * and can realloc() it to grow it, and should free() it to
464  * delete it.
465  */
466  int yy_is_our_buffer;
467 
468  /* Whether this is an "interactive" input source; if so, and
469  * if we're using stdio for input, then we want to use getc()
470  * instead of fread(), to make sure we stop fetching input after
471  * each newline.
472  */
473  int yy_is_interactive;
474 
475  /* Whether we're considered to be at the beginning of a line.
476  * If so, '^' rules will be active on the next match, otherwise
477  * not.
478  */
479  int yy_at_bol;
480 
481  int yy_bs_lineno;
482  int yy_bs_column;
484  /* Whether to try to fill the input buffer when we reach the
485  * end of it.
486  */
487  int yy_fill_buffer;
488 
489  int yy_buffer_status;
490 
491 #define YY_BUFFER_NEW 0
492 #define YY_BUFFER_NORMAL 1
493  /* When an EOF's been seen but there's still some text to process
494  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
495  * shouldn't try reading from the input source any more. We might
496  * still have a bunch of tokens to match, though, because of
497  * possible backing-up.
498  *
499  * When we actually see the EOF, we change the status to "new"
500  * (via yyrestart()), so that the user can continue scanning by
501  * just pointing yyin at a new input file.
502  */
503 #define YY_BUFFER_EOF_PENDING 2
504 
505  };
506 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
507 
508 /* Stack of input buffers. */
509 static size_t yy_buffer_stack_top = 0;
510 static size_t yy_buffer_stack_max = 0;
513 /* We provide macros for accessing buffer states in case in the
514  * future we want to put the buffer states in a more general
515  * "scanner state".
516  *
517  * Returns the top of the stack, or NULL.
518  */
519 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
520  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
521  : NULL)
522 /* Same as previous macro, but useful when we know that the buffer stack is not
523  * NULL or when we need an lvalue. For internal use only.
524  */
525 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
526 
527 /* yy_hold_char holds the character lost when yytext is formed. */
528 static char yy_hold_char;
529 static int yy_n_chars; /* number of characters read into yy_ch_buf */
530 int yyleng;
531 
532 /* Points to current character in buffer. */
533 static char *yy_c_buf_p = NULL;
534 static int yy_init = 0; /* whether we need to initialize */
535 static int yy_start = 0; /* start state number */
536 
537 /* Flag which is used to allow yywrap()'s to do buffer switches
538  * instead of setting up a fresh yyin. A bit of a hack ...
539  */
541 
542 void yyrestart ( FILE *input_file );
543 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
547 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
548 void yypop_buffer_state ( void );
549 
550 static void yyensure_buffer_stack ( void );
551 static void yy_load_buffer_state ( void );
552 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
553 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
554 
556 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
557 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
558 
559 void *yyalloc ( yy_size_t );
560 void *yyrealloc ( void *, yy_size_t );
561 void yyfree ( void * );
562 
563 #define yy_new_buffer yy_create_buffer
564 #define yy_set_interactive(is_interactive) \
565  { \
566  if ( ! YY_CURRENT_BUFFER ){ \
567  yyensure_buffer_stack (); \
568  YY_CURRENT_BUFFER_LVALUE = \
569  yy_create_buffer( yyin, YY_BUF_SIZE ); \
570  } \
571  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
572  }
573 #define yy_set_bol(at_bol) \
574  { \
575  if ( ! YY_CURRENT_BUFFER ){\
576  yyensure_buffer_stack (); \
577  YY_CURRENT_BUFFER_LVALUE = \
578  yy_create_buffer( yyin, YY_BUF_SIZE ); \
579  } \
580  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
581  }
582 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
583 
584 /* Begin user sect3 */
586 
588 
589 typedef int yy_state_type;
590 
591 extern int yylineno;
592 int yylineno = 1;
593 
594 extern char *yytext;
595 #ifdef yytext_ptr
596 #undef yytext_ptr
597 #endif
598 #define yytext_ptr yytext
599 
600 static yy_state_type yy_get_previous_state ( void );
601 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
602 static int yy_get_next_buffer ( void );
603 static void yynoreturn yy_fatal_error ( const char* msg );
604 
605 /* Done after the current pattern has been matched and before the
606  * corresponding action - sets up yytext.
607  */
608 #define YY_DO_BEFORE_ACTION \
609  (yytext_ptr) = yy_bp; \
610  yyleng = (int) (yy_cp - yy_bp); \
611  (yy_hold_char) = *yy_cp; \
612  *yy_cp = '\0'; \
613  (yy_c_buf_p) = yy_cp;
614 #define YY_NUM_RULES 145
615 #define YY_END_OF_BUFFER 146
616 /* This struct is not used in this scanner,
617  but its presence is necessary. */
618 struct yy_trans_info
619  {
622  };
623 static const flex_int16_t yy_accept[421] =
624  { 0,
625  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
626  0, 0, 0, 0, 119, 119, 0, 0, 0, 0,
627  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
628  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
629  0, 0, 0, 0, 0, 0, 146, 135, 136, 137,
630  123, 144, 124, 135, 134, 135, 136, 1, 21, 16,
631  18, 16, 21, 20, 17, 17, 17, 17, 17, 17,
632  17, 17, 70, 73, 71, 72, 28, 25, 26, 24,
633  28, 23, 28, 28, 125, 133, 126, 144, 127, 128,
634  144, 129, 130, 119, 120, 119, 79, 77, 79, 79,
635 
636  76, 79, 80, 84, 86, 85, 144, 81, 92, 88,
637  92, 87, 90, 92, 92, 89, 92, 94, 102, 104,
638  97, 103, 99, 98, 95, 99, 94, 108, 108, 106,
639  105, 108, 116, 115, 112, 113, 109, 110, 111, 116,
640  116, 135, 136, 140, 123, 140, 124, 135, 134, 135,
641  53, 50, 47, 53, 52, 53, 51, 53, 33, 35,
642  53, 53, 53, 53, 49, 53, 53, 60, 57, 58,
643  60, 56, 60, 54, 55, 64, 61, 62, 64, 64,
644  22, 69, 66, 69, 67, 69, 65, 69, 29, 30,
645  32, 32, 32, 29, 1, 142, 145, 143, 141, 141,
646 
647  135, 136, 135, 118, 122, 134, 138, 139, 136, 1,
648  16, 17, 17, 17, 17, 17, 17, 17, 17, 18,
649  19, 20, 17, 17, 17, 17, 17, 11, 17, 17,
650  17, 17, 17, 70, 71, 72, 74, 72, 25, 27,
651  28, 125, 132, 131, 132, 127, 129, 119, 119, 119,
652  121, 77, 75, 76, 78, 79, 80, 81, 83, 81,
653  88, 87, 92, 89, 93, 92, 94, 96, 99, 98,
654  98, 95, 101, 99, 94, 108, 106, 105, 108, 107,
655  108, 116, 116, 114, 117, 116, 135, 140, 140, 50,
656  44, 41, 33, 34, 33, 33, 37, 35, 35, 35,
657 
658  39, 45, 43, 46, 40, 48, 49, 134, 42, 57,
659  56, 59, 60, 54, 61, 63, 0, 22, 66, 65,
660  69, 68, 69, 29, 31, 32, 29, 142, 141, 122,
661  122, 17, 17, 17, 17, 17, 17, 11, 17, 17,
662  17, 17, 17, 17, 17, 71, 82, 91, 100, 34,
663  34, 33, 33, 33, 36, 35, 35, 35, 134, 122,
664  17, 12, 13, 17, 17, 17, 17, 17, 17, 15,
665  17, 17, 17, 34, 34, 34, 33, 36, 36, 35,
666  134, 17, 12, 13, 14, 4, 7, 9, 17, 17,
667  15, 17, 8, 17, 34, 36, 36, 36, 134, 3,
668 
669  14, 4, 7, 9, 10, 17, 6, 8, 17, 36,
670  134, 3, 10, 2, 6, 5, 38, 2, 5, 0
671  } ;
672 
673 static const YY_CHAR yy_ec[256] =
674  { 0,
675  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
676  2, 2, 4, 1, 1, 1, 1, 1, 1, 1,
677  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
678  1, 2, 5, 6, 7, 1, 1, 8, 9, 10,
679  11, 12, 1, 13, 1, 14, 15, 16, 17, 17,
680  17, 17, 17, 17, 17, 18, 18, 1, 1, 19,
681  20, 21, 1, 1, 22, 22, 22, 22, 22, 22,
682  23, 23, 23, 23, 23, 24, 23, 23, 23, 23,
683  23, 23, 23, 23, 25, 23, 23, 26, 23, 23,
684  1, 27, 1, 1, 28, 1, 29, 30, 31, 32,
685 
686  33, 34, 35, 36, 37, 36, 36, 38, 39, 40,
687  41, 42, 36, 43, 44, 45, 46, 36, 47, 48,
688  36, 36, 1, 49, 1, 1, 1, 1, 1, 1,
689  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
690  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
691  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
692  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
693  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
694  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
695  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
696 
697  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
698  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
699  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
700  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
701  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
702  1, 1, 1, 1, 1
703  } ;
704 
705 static const YY_CHAR yy_meta[50] =
706  { 0,
707  1, 2, 3, 2, 1, 4, 5, 1, 6, 7,
708  8, 9, 8, 10, 11, 12, 12, 12, 1, 1,
709  13, 14, 15, 15, 15, 15, 16, 17, 14, 14,
710  14, 14, 14, 14, 15, 15, 15, 15, 15, 15,
711  15, 15, 15, 15, 15, 15, 15, 15, 1
712  } ;
713 
714 static const flex_int16_t yy_base[467] =
715  { 0,
716  0, 48, 55, 0, 102, 103, 130, 0, 177, 178,
717  179, 182, 186, 187, 104, 107, 214, 0, 261, 262,
718  289, 0, 338, 0, 386, 389, 414, 439, 466, 0,
719  515, 0, 564, 0, 1129, 1128, 399, 403, 612, 638,
720  665, 0, 428, 618, 714, 763, 1130, 0, 49, 1920,
721  1920, 1920, 1920, 96, 0, 109, 118, 1920, 1920, 811,
722  1920, 1126, 111, 111, 858, 1095, 154, 161, 1090, 1083,
723  1085, 1095, 0, 1920, 184, 124, 1920, 196, 1920, 1920,
724  254, 1920, 0, 199, 0, 1920, 1920, 269, 0, 1920,
725  1120, 0, 1920, 0, 1920, 263, 1920, 208, 1920, 267,
726 
727  1112, 277, 0, 1920, 1920, 1920, 271, 281, 1920, 393,
728  1920, 396, 1920, 1107, 396, 0, 406, 0, 1920, 1920,
729  1113, 1920, 400, 905, 0, 418, 954, 1920, 430, 1920,
730  1920, 433, 0, 1920, 1920, 1920, 1920, 1920, 1920, 432,
731  435, 0, 449, 1920, 1920, 1920, 1920, 444, 0, 1003,
732  1920, 456, 1920, 1099, 1920, 1110, 1920, 449, 1037, 714,
733  443, 1097, 603, 0, 623, 1083, 1066, 1920, 615, 1920,
734  619, 0, 632, 0, 1920, 1920, 644, 1920, 635, 634,
735  635, 1920, 655, 1920, 1920, 646, 0, 659, 0, 1920,
736  1920, 725, 738, 741, 1920, 742, 1920, 1920, 0, 735,
737 
738  0, 747, 741, 1920, 0, 0, 1920, 1111, 755, 1920,
739  0, 0, 1079, 747, 754, 1074, 1067, 1069, 1079, 1920,
740  1920, 1104, 1069, 717, 1070, 1058, 1067, 777, 1063, 1052,
741  1062, 1056, 1041, 0, 0, 1920, 1920, 1079, 787, 1920,
742  1078, 0, 1920, 1920, 1077, 0, 0, 0, 743, 765,
743  1920, 791, 1920, 1069, 1920, 1075, 0, 1920, 794, 1074,
744  795, 798, 1062, 0, 1920, 1071, 0, 1920, 789, 0,
745  1085, 0, 801, 1070, 0, 804, 1920, 1920, 807, 1920,
746  1069, 0, 804, 1920, 1920, 1068, 806, 1920, 0, 818,
747  1920, 1920, 847, 843, 874, 799, 0, 905, 903, 800,
748 
749  1920, 1920, 1920, 1920, 1920, 1920, 1066, 1026, 1920, 823,
750  0, 1920, 1048, 0, 824, 1920, 1047, 816, 871, 0,
751  1920, 1920, 1027, 0, 1920, 1006, 872, 876, 0, 1134,
752  0, 969, 971, 948, 943, 906, 897, 880, 875, 871,
753  864, 844, 835, 833, 799, 0, 884, 1920, 890, 907,
754  845, 618, 863, 873, 914, 889, 910, 912, 799, 1183,
755  795, 938, 942, 796, 786, 747, 702, 695, 614, 959,
756  610, 598, 428, 932, 945, 946, 1920, 947, 952, 1920,
757  406, 395, 975, 984, 985, 990, 993, 994, 385, 372,
758  997, 365, 998, 247, 1920, 966, 991, 994, 241, 1023,
759 
760  1024, 1029, 1032, 1033, 1036, 153, 1037, 1040, 74, 1920,
761  22, 1041, 1044, 1045, 1054, 1055, 0, 1062, 1063, 1920,
762  1232, 1249, 1266, 1283, 1300, 1317, 1334, 1351, 1368, 1385,
763  1402, 1419, 1436, 1453, 1466, 1468, 1485, 1502, 1519, 1536,
764  1553, 1570, 1587, 1604, 1615, 1632, 1649, 1655, 1672, 1689,
765  1706, 1712, 1729, 1746, 1763, 1769, 1786, 1792, 1809, 1826,
766  1834, 1851, 1868, 1885, 1056, 1902
767  } ;
768 
769 static const flex_int16_t yy_def[467] =
770  { 0,
771  420, 1, 420, 3, 421, 421, 420, 7, 422, 422,
772  423, 423, 424, 424, 425, 425, 420, 17, 426, 426,
773  420, 21, 420, 23, 427, 427, 428, 428, 420, 29,
774  420, 31, 420, 33, 429, 429, 430, 430, 431, 431,
775  420, 41, 432, 432, 433, 433, 420, 434, 420, 420,
776  420, 420, 420, 435, 436, 435, 420, 420, 420, 420,
777  420, 60, 420, 420, 60, 65, 65, 65, 65, 65,
778  65, 65, 437, 420, 438, 420, 420, 420, 420, 420,
779  420, 420, 436, 420, 439, 420, 420, 440, 441, 420,
780  440, 442, 420, 443, 420, 444, 420, 420, 420, 420,
781 
782  445, 420, 446, 420, 420, 420, 447, 420, 420, 420,
783  420, 420, 420, 420, 420, 448, 420, 449, 420, 420,
784  420, 420, 450, 451, 452, 420, 452, 420, 420, 420,
785  420, 420, 453, 420, 420, 420, 420, 420, 420, 454,
786  420, 434, 420, 420, 420, 420, 420, 435, 436, 455,
787  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
788  420, 420, 420, 436, 420, 436, 420, 420, 420, 420,
789  420, 456, 420, 457, 420, 420, 420, 420, 420, 420,
790  420, 420, 420, 420, 420, 420, 458, 459, 460, 420,
791  420, 420, 420, 460, 420, 420, 420, 420, 461, 461,
792 
793  434, 420, 435, 420, 462, 436, 420, 420, 420, 420,
794  60, 65, 65, 65, 65, 65, 65, 65, 65, 420,
795  420, 420, 65, 65, 65, 65, 65, 65, 65, 65,
796  65, 65, 65, 437, 463, 420, 420, 420, 420, 420,
797  420, 439, 420, 420, 420, 441, 442, 443, 444, 444,
798  420, 420, 420, 445, 420, 420, 446, 420, 420, 420,
799  420, 420, 420, 448, 420, 420, 449, 420, 450, 464,
800  451, 452, 420, 420, 127, 420, 420, 420, 420, 420,
801  420, 453, 454, 420, 420, 420, 435, 420, 455, 420,
802  420, 420, 420, 420, 420, 420, 465, 420, 420, 420,
803 
804  420, 420, 420, 420, 420, 420, 420, 436, 420, 420,
805  456, 420, 420, 457, 420, 420, 420, 420, 420, 458,
806  420, 420, 420, 460, 420, 420, 460, 420, 461, 466,
807  462, 65, 65, 65, 65, 65, 65, 420, 65, 65,
808  65, 65, 65, 65, 65, 463, 420, 420, 420, 420,
809  420, 420, 420, 420, 465, 420, 420, 420, 436, 466,
810  65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
811  65, 65, 65, 420, 420, 420, 420, 420, 420, 420,
812  436, 65, 420, 420, 65, 65, 65, 65, 65, 65,
813  420, 65, 65, 65, 420, 420, 420, 420, 436, 65,
814 
815  420, 420, 420, 420, 65, 65, 65, 420, 65, 420,
816  436, 420, 420, 65, 420, 65, 436, 420, 420, 0,
817  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
818  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
819  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
820  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
821  420, 420, 420, 420, 420, 420
822  } ;
823 
824 static const flex_int16_t yy_nxt[1970] =
825  { 0,
826  48, 49, 50, 49, 48, 51, 52, 48, 53, 48,
827  48, 48, 48, 48, 54, 48, 48, 48, 48, 48,
828  48, 55, 55, 55, 55, 55, 56, 55, 55, 55,
829  55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
830  55, 55, 55, 55, 55, 55, 55, 55, 48, 57,
831  202, 57, 202, 417, 58, 59, 60, 61, 62, 59,
832  59, 59, 59, 59, 59, 59, 59, 59, 59, 63,
833  59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
834  59, 64, 59, 65, 65, 65, 66, 67, 65, 65,
835  65, 68, 69, 65, 65, 65, 70, 65, 65, 65,
836 
837  71, 72, 65, 59, 74, 74, 95, 204, 416, 95,
838  205, 207, 208, 221, 222, 96, 75, 75, 96, 209,
839  420, 209, 204, 420, 210, 205, 237, 238, 76, 76,
840  77, 78, 79, 78, 77, 80, 77, 77, 77, 77,
841  77, 77, 77, 77, 81, 77, 77, 77, 82, 77,
842  77, 83, 83, 83, 83, 83, 84, 83, 83, 83,
843  83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
844  83, 83, 83, 83, 83, 83, 83, 83, 77, 86,
845  86, 86, 87, 87, 86, 414, 236, 90, 86, 86,
846  90, 224, 227, 225, 228, 204, 226, 239, 205, 239,
847 
848  229, 240, 241, 88, 88, 91, 93, 93, 91, 252,
849  236, 252, 91, 91, 97, 98, 99, 98, 97, 97,
850  97, 97, 97, 97, 97, 97, 97, 97, 100, 97,
851  97, 97, 97, 97, 97, 101, 101, 101, 101, 101,
852  102, 101, 101, 101, 101, 101, 101, 101, 101, 101,
853  101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
854  101, 101, 97, 104, 104, 204, 105, 105, 205, 106,
855  106, 244, 245, 411, 250, 107, 107, 251, 204, 255,
856  256, 205, 204, 259, 260, 205, 409, 108, 108, 109,
857  110, 111, 110, 109, 109, 109, 109, 109, 109, 112,
858 
859  109, 113, 114, 115, 109, 109, 109, 109, 109, 109,
860  116, 116, 116, 116, 116, 117, 116, 116, 116, 116,
861  116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
862  116, 116, 116, 116, 116, 116, 116, 109, 118, 118,
863  119, 118, 118, 120, 121, 118, 122, 118, 118, 118,
864  118, 118, 123, 124, 124, 124, 118, 118, 118, 125,
865  125, 125, 125, 125, 126, 127, 125, 125, 125, 125,
866  125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
867  125, 125, 125, 125, 125, 125, 118, 129, 130, 129,
868  129, 130, 129, 407, 261, 131, 261, 262, 131, 262,
869 
870  177, 178, 177, 406, 177, 178, 177, 204, 265, 266,
871  205, 204, 132, 179, 205, 132, 134, 179, 405, 135,
872  273, 274, 136, 137, 138, 180, 139, 400, 140, 180,
873  190, 276, 277, 276, 191, 280, 281, 285, 286, 278,
874  141, 134, 192, 284, 135, 399, 205, 136, 137, 138,
875  202, 139, 202, 140, 193, 420, 279, 290, 420, 290,
876  204, 301, 302, 205, 394, 141, 142, 143, 144, 143,
877  142, 145, 146, 142, 147, 142, 142, 142, 142, 142,
878  148, 142, 142, 142, 142, 142, 142, 149, 149, 149,
879  149, 149, 150, 149, 149, 149, 149, 149, 149, 149,
880 
881  149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
882  149, 149, 149, 149, 142, 151, 152, 153, 152, 154,
883  155, 151, 156, 157, 151, 151, 151, 151, 151, 158,
884  159, 160, 160, 161, 162, 163, 164, 164, 164, 164,
885  164, 165, 164, 164, 164, 164, 166, 164, 164, 164,
886  164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
887  164, 164, 164, 167, 168, 169, 170, 169, 168, 168,
888  168, 168, 168, 168, 168, 168, 168, 168, 171, 168,
889  168, 168, 168, 168, 168, 172, 172, 172, 172, 172,
890  173, 172, 172, 172, 172, 172, 172, 172, 172, 172,
891 
892  172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
893  172, 172, 168, 78, 79, 78, 310, 80, 310, 194,
894  190, 194, 304, 305, 195, 306, 307, 181, 181, 181,
895  204, 393, 192, 205, 312, 313, 316, 317, 84, 78,
896  79, 78, 377, 80, 193, 315, 204, 315, 392, 205,
897  318, 318, 318, 181, 181, 181, 319, 204, 319, 390,
898  205, 322, 323, 377, 84, 182, 183, 184, 183, 182,
899  182, 182, 182, 182, 185, 185, 182, 182, 182, 186,
900  182, 182, 182, 182, 182, 182, 187, 187, 187, 187,
901  187, 188, 187, 187, 187, 187, 187, 187, 187, 187,
902 
903  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
904  187, 187, 187, 182, 52, 196, 197, 196, 52, 198,
905  52, 52, 52, 52, 52, 52, 52, 389, 200, 298,
906  298, 298, 52, 52, 52, 388, 204, 299, 300, 205,
907  325, 326, 327, 328, 327, 328, 204, 210, 202, 330,
908  202, 299, 420, 333, 420, 420, 209, 420, 209, 300,
909  334, 210, 52, 52, 196, 197, 196, 52, 198, 52,
910  52, 52, 52, 52, 52, 52, 250, 200, 338, 251,
911  338, 52, 52, 52, 224, 227, 225, 228, 239, 226,
912  239, 387, 252, 229, 252, 347, 261, 347, 261, 262,
913 
914  420, 262, 349, 420, 349, 276, 277, 276, 339, 280,
915  281, 52, 211, 278, 211, 420, 340, 420, 420, 290,
916  420, 290, 354, 358, 310, 315, 310, 315, 386, 385,
917  279, 318, 318, 318, 382, 381, 354, 358, 373, 212,
918  212, 212, 213, 214, 212, 212, 212, 215, 216, 212,
919  212, 212, 217, 212, 212, 212, 218, 219, 212, 420,
920  294, 420, 293, 293, 294, 372, 350, 351, 376, 371,
921  295, 296, 319, 327, 319, 327, 370, 328, 210, 328,
922  350, 338, 376, 338, 295, 347, 377, 347, 351, 212,
923  212, 349, 296, 349, 212, 212, 377, 352, 353, 212,
924 
925  377, 369, 368, 212, 212, 270, 270, 367, 270, 270,
926  377, 352, 270, 380, 270, 270, 270, 270, 270, 353,
927  298, 298, 298, 270, 270, 270, 356, 357, 299, 300,
928  374, 375, 270, 380, 380, 380, 366, 378, 379, 383,
929  356, 383, 299, 384, 374, 384, 365, 380, 357, 380,
930  300, 378, 375, 270, 267, 267, 395, 267, 267, 379,
931  391, 267, 391, 267, 267, 267, 267, 267, 395, 395,
932  396, 397, 267, 267, 267, 398, 383, 395, 383, 364,
933  363, 275, 395, 395, 396, 384, 401, 384, 401, 398,
934  410, 402, 397, 402, 403, 404, 403, 404, 391, 408,
935 
936  391, 408, 267, 287, 362, 361, 289, 287, 325, 287,
937  287, 410, 287, 287, 410, 287, 287, 410, 287, 287,
938  287, 287, 287, 287, 412, 401, 412, 401, 410, 322,
939  402, 410, 402, 403, 404, 403, 404, 413, 415, 413,
940  415, 408, 412, 408, 412, 413, 418, 413, 418, 316,
941  312, 287, 293, 293, 294, 415, 419, 415, 419, 359,
942  295, 296, 297, 418, 419, 418, 419, 355, 306, 355,
943  285, 280, 273, 265, 295, 348, 259, 255, 253, 244,
944  240, 237, 296, 345, 297, 270, 270, 344, 270, 270,
945  343, 342, 270, 341, 270, 270, 270, 270, 270, 337,
946 
947  336, 335, 332, 270, 270, 270, 221, 233, 232, 231,
948  230, 223, 270, 207, 309, 308, 303, 292, 291, 268,
949  263, 253, 420, 233, 232, 231, 230, 223, 220, 420,
950  175, 175, 420, 270, 331, 331, 420, 331, 331, 331,
951  331, 331, 331, 331, 331, 331, 331, 420, 420, 420,
952  420, 420, 331, 331, 331, 420, 420, 420, 420, 420,
953  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
954  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
955  420, 420, 331, 331, 331, 420, 331, 331, 331, 331,
956  331, 331, 331, 331, 331, 331, 420, 420, 420, 420,
957 
958  420, 331, 331, 331, 420, 420, 420, 420, 420, 420,
959  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
960  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
961  420, 331, 73, 73, 73, 73, 73, 73, 73, 73,
962  73, 73, 73, 73, 73, 73, 73, 73, 73, 85,
963  85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
964  85, 85, 85, 85, 85, 85, 89, 89, 89, 89,
965  89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
966  89, 89, 89, 92, 92, 92, 92, 92, 92, 92,
967  92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
968 
969  94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
970  94, 94, 94, 94, 94, 94, 94, 103, 103, 103,
971  103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
972  103, 103, 103, 103, 128, 128, 128, 128, 128, 128,
973  128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
974  128, 133, 133, 133, 133, 133, 133, 133, 133, 133,
975  133, 133, 133, 133, 133, 133, 133, 133, 174, 174,
976  174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
977  174, 174, 174, 174, 174, 176, 176, 176, 176, 176,
978  176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
979 
980  176, 176, 77, 77, 77, 77, 77, 77, 77, 77,
981  77, 77, 77, 77, 77, 77, 77, 77, 77, 189,
982  189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
983  189, 189, 189, 189, 189, 189, 199, 199, 199, 199,
984  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
985  199, 199, 199, 201, 420, 420, 420, 420, 420, 201,
986  201, 201, 201, 420, 201, 201, 203, 420, 420, 420,
987  203, 420, 203, 203, 203, 203, 203, 203, 203, 206,
988  420, 206, 206, 420, 206, 234, 234, 420, 234, 234,
989  234, 234, 234, 234, 234, 420, 234, 234, 234, 234,
990 
991  420, 234, 235, 235, 235, 235, 235, 235, 235, 235,
992  235, 235, 235, 235, 235, 235, 235, 235, 235, 242,
993  242, 420, 420, 242, 242, 242, 242, 242, 242, 242,
994  242, 242, 242, 242, 420, 242, 243, 243, 243, 243,
995  243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
996  243, 243, 243, 246, 246, 420, 246, 246, 420, 246,
997  246, 246, 246, 246, 246, 246, 246, 246, 420, 246,
998  247, 247, 420, 247, 247, 247, 247, 247, 247, 247,
999  247, 247, 420, 247, 247, 420, 247, 248, 248, 420,
1000  248, 248, 248, 248, 248, 420, 248, 248, 248, 248,
1001 
1002  248, 248, 248, 248, 249, 249, 420, 249, 249, 249,
1003  249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
1004  249, 254, 420, 420, 420, 420, 254, 420, 254, 254,
1005  420, 254, 257, 257, 420, 420, 257, 420, 257, 257,
1006  257, 257, 420, 257, 257, 257, 257, 420, 257, 258,
1007  258, 258, 258, 258, 258, 258, 258, 258, 258, 258,
1008  258, 258, 258, 258, 258, 258, 264, 420, 264, 264,
1009  420, 264, 267, 267, 420, 420, 420, 420, 267, 267,
1010  267, 267, 420, 420, 267, 420, 420, 420, 267, 269,
1011  269, 420, 420, 420, 420, 269, 269, 269, 269, 269,
1012 
1013  269, 269, 269, 269, 420, 269, 271, 271, 420, 420,
1014  420, 420, 271, 271, 271, 271, 420, 271, 271, 271,
1015  271, 420, 271, 272, 420, 272, 272, 420, 272, 282,
1016  282, 420, 420, 282, 420, 420, 420, 282, 282, 420,
1017  282, 282, 282, 282, 420, 282, 283, 283, 420, 420,
1018  283, 420, 420, 420, 283, 283, 283, 283, 283, 283,
1019  283, 420, 283, 288, 288, 288, 288, 288, 288, 288,
1020  288, 288, 288, 288, 288, 288, 288, 288, 288, 288,
1021  311, 420, 311, 311, 420, 311, 314, 314, 420, 314,
1022  314, 314, 314, 314, 314, 314, 314, 314, 314, 314,
1023 
1024  314, 314, 314, 320, 420, 320, 320, 420, 320, 321,
1025  321, 321, 321, 321, 321, 321, 321, 321, 321, 321,
1026  321, 321, 321, 321, 321, 321, 324, 324, 420, 324,
1027  420, 324, 324, 324, 324, 324, 420, 324, 324, 324,
1028  324, 420, 324, 329, 329, 329, 420, 329, 329, 329,
1029  329, 331, 331, 420, 331, 331, 331, 331, 331, 331,
1030  331, 331, 331, 331, 331, 331, 331, 331, 346, 346,
1031  420, 346, 346, 346, 346, 346, 420, 346, 420, 346,
1032  346, 346, 346, 420, 346, 270, 270, 420, 420, 420,
1033  420, 270, 270, 270, 270, 420, 420, 270, 420, 420,
1034 
1035  420, 270, 360, 360, 420, 360, 360, 360, 360, 360,
1036  360, 360, 360, 360, 360, 360, 360, 360, 360, 47,
1037  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1038  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1039  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1040  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1041  420, 420, 420, 420, 420, 420, 420, 420, 420
1042  } ;
1043 
1044 static const flex_int16_t yy_chk[1970] =
1045  { 0,
1046  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1047  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1048  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1049  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1050  1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
1051  49, 2, 49, 411, 2, 3, 3, 3, 3, 3,
1052  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1053  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1054  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1055  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1056 
1057  3, 3, 3, 3, 5, 6, 15, 54, 409, 16,
1058  54, 56, 56, 64, 64, 15, 5, 6, 16, 57,
1059  56, 57, 63, 56, 57, 63, 76, 76, 5, 6,
1060  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1061  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1062  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1063  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1064  7, 7, 7, 7, 7, 7, 7, 7, 7, 9,
1065  10, 11, 9, 10, 12, 406, 75, 11, 13, 14,
1066  12, 67, 68, 67, 68, 75, 67, 78, 75, 78,
1067 
1068  68, 84, 84, 9, 10, 11, 13, 14, 12, 98,
1069  75, 98, 13, 14, 17, 17, 17, 17, 17, 17,
1070  17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
1071  17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
1072  17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
1073  17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
1074  17, 17, 17, 19, 20, 81, 19, 20, 81, 19,
1075  20, 88, 88, 399, 96, 19, 20, 96, 100, 102,
1076  102, 100, 107, 108, 108, 107, 394, 19, 20, 21,
1077  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1078 
1079  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1080  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1081  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1082  21, 21, 21, 21, 21, 21, 21, 21, 23, 23,
1083  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1084  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1085  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1086  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1087  23, 23, 23, 23, 23, 23, 23, 25, 25, 25,
1088  26, 26, 26, 392, 110, 25, 110, 112, 26, 112,
1089 
1090  37, 37, 37, 390, 38, 38, 38, 115, 117, 117,
1091  115, 123, 25, 37, 123, 26, 27, 38, 389, 27,
1092  126, 126, 27, 27, 27, 37, 27, 382, 27, 38,
1093  43, 129, 129, 129, 43, 132, 132, 141, 141, 129,
1094  27, 28, 43, 140, 28, 381, 140, 28, 28, 28,
1095  143, 28, 143, 28, 43, 148, 129, 152, 148, 152,
1096  158, 161, 161, 158, 373, 28, 29, 29, 29, 29,
1097  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1098  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1099  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1100 
1101  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1102  29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
1103  31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
1104  31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
1105  31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
1106  31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
1107  31, 31, 31, 31, 33, 33, 33, 33, 33, 33,
1108  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1109  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1110  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1111 
1112  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1113  33, 33, 33, 39, 39, 39, 169, 39, 169, 44,
1114  44, 44, 163, 163, 44, 165, 165, 39, 39, 39,
1115  171, 372, 44, 171, 173, 173, 180, 180, 39, 40,
1116  40, 40, 352, 40, 44, 177, 179, 177, 371, 179,
1117  181, 181, 181, 40, 40, 40, 183, 186, 183, 369,
1118  186, 188, 188, 352, 40, 41, 41, 41, 41, 41,
1119  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1120  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1121  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1122 
1123  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1124  41, 41, 41, 41, 45, 45, 45, 45, 45, 45,
1125  45, 45, 45, 45, 45, 45, 45, 368, 45, 160,
1126  160, 160, 45, 45, 45, 367, 192, 160, 160, 192,
1127  193, 193, 194, 196, 194, 196, 200, 194, 202, 200,
1128  202, 160, 203, 224, 249, 203, 209, 249, 209, 160,
1129  224, 209, 45, 46, 46, 46, 46, 46, 46, 46,
1130  46, 46, 46, 46, 46, 46, 250, 46, 228, 250,
1131  228, 46, 46, 46, 214, 215, 214, 215, 239, 214,
1132  239, 366, 252, 215, 252, 259, 261, 259, 261, 262,
1133 
1134  269, 262, 273, 269, 273, 276, 276, 276, 228, 279,
1135  279, 46, 60, 276, 60, 283, 228, 287, 283, 290,
1136  287, 290, 296, 300, 310, 315, 310, 315, 365, 364,
1137  276, 318, 318, 318, 361, 359, 296, 300, 345, 60,
1138  60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
1139  60, 60, 60, 60, 60, 60, 60, 60, 60, 65,
1140  294, 65, 293, 293, 293, 344, 294, 294, 351, 343,
1141  293, 293, 319, 327, 319, 327, 342, 328, 327, 328,
1142  294, 338, 351, 338, 293, 347, 353, 347, 294, 65,
1143  65, 349, 293, 349, 65, 65, 354, 295, 295, 65,
1144 
1145  353, 341, 340, 65, 65, 124, 124, 339, 124, 124,
1146  354, 295, 124, 356, 124, 124, 124, 124, 124, 295,
1147  298, 298, 298, 124, 124, 124, 299, 299, 298, 298,
1148  350, 350, 124, 357, 356, 358, 337, 355, 355, 362,
1149  299, 362, 298, 363, 350, 363, 336, 357, 299, 358,
1150  298, 355, 350, 124, 127, 127, 374, 127, 127, 355,
1151  370, 127, 370, 127, 127, 127, 127, 127, 375, 376,
1152  378, 378, 127, 127, 127, 379, 383, 374, 383, 335,
1153  334, 127, 375, 376, 378, 384, 385, 384, 385, 379,
1154  396, 386, 378, 386, 387, 388, 387, 388, 391, 393,
1155 
1156  391, 393, 127, 150, 333, 332, 150, 150, 326, 150,
1157  150, 396, 150, 150, 397, 150, 150, 398, 150, 150,
1158  150, 150, 150, 150, 400, 401, 400, 401, 397, 323,
1159  402, 398, 402, 403, 404, 403, 404, 405, 407, 405,
1160  407, 408, 412, 408, 412, 413, 414, 413, 414, 317,
1161  313, 150, 159, 159, 159, 415, 416, 415, 416, 308,
1162  159, 159, 159, 418, 419, 418, 419, 465, 307, 465,
1163  286, 281, 274, 266, 159, 263, 260, 256, 254, 245,
1164  241, 238, 159, 233, 159, 271, 271, 232, 271, 271,
1165  231, 230, 271, 229, 271, 271, 271, 271, 271, 227,
1166 
1167  226, 225, 223, 271, 271, 271, 222, 219, 218, 217,
1168  216, 213, 271, 208, 167, 166, 162, 156, 154, 121,
1169  114, 101, 91, 72, 71, 70, 69, 66, 62, 47,
1170  36, 35, 0, 271, 330, 330, 0, 330, 330, 330,
1171  330, 330, 330, 330, 330, 330, 330, 0, 0, 0,
1172  0, 0, 330, 330, 330, 0, 0, 0, 0, 0,
1173  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1174  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1175  0, 0, 330, 360, 360, 0, 360, 360, 360, 360,
1176  360, 360, 360, 360, 360, 360, 0, 0, 0, 0,
1177 
1178  0, 360, 360, 360, 0, 0, 0, 0, 0, 0,
1179  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1180  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1181  0, 360, 421, 421, 421, 421, 421, 421, 421, 421,
1182  421, 421, 421, 421, 421, 421, 421, 421, 421, 422,
1183  422, 422, 422, 422, 422, 422, 422, 422, 422, 422,
1184  422, 422, 422, 422, 422, 422, 423, 423, 423, 423,
1185  423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
1186  423, 423, 423, 424, 424, 424, 424, 424, 424, 424,
1187  424, 424, 424, 424, 424, 424, 424, 424, 424, 424,
1188 
1189  425, 425, 425, 425, 425, 425, 425, 425, 425, 425,
1190  425, 425, 425, 425, 425, 425, 425, 426, 426, 426,
1191  426, 426, 426, 426, 426, 426, 426, 426, 426, 426,
1192  426, 426, 426, 426, 427, 427, 427, 427, 427, 427,
1193  427, 427, 427, 427, 427, 427, 427, 427, 427, 427,
1194  427, 428, 428, 428, 428, 428, 428, 428, 428, 428,
1195  428, 428, 428, 428, 428, 428, 428, 428, 429, 429,
1196  429, 429, 429, 429, 429, 429, 429, 429, 429, 429,
1197  429, 429, 429, 429, 429, 430, 430, 430, 430, 430,
1198  430, 430, 430, 430, 430, 430, 430, 430, 430, 430,
1199 
1200  430, 430, 431, 431, 431, 431, 431, 431, 431, 431,
1201  431, 431, 431, 431, 431, 431, 431, 431, 431, 432,
1202  432, 432, 432, 432, 432, 432, 432, 432, 432, 432,
1203  432, 432, 432, 432, 432, 432, 433, 433, 433, 433,
1204  433, 433, 433, 433, 433, 433, 433, 433, 433, 433,
1205  433, 433, 433, 434, 0, 0, 0, 0, 0, 434,
1206  434, 434, 434, 0, 434, 434, 435, 0, 0, 0,
1207  435, 0, 435, 435, 435, 435, 435, 435, 435, 436,
1208  0, 436, 436, 0, 436, 437, 437, 0, 437, 437,
1209  437, 437, 437, 437, 437, 0, 437, 437, 437, 437,
1210 
1211  0, 437, 438, 438, 438, 438, 438, 438, 438, 438,
1212  438, 438, 438, 438, 438, 438, 438, 438, 438, 439,
1213  439, 0, 0, 439, 439, 439, 439, 439, 439, 439,
1214  439, 439, 439, 439, 0, 439, 440, 440, 440, 440,
1215  440, 440, 440, 440, 440, 440, 440, 440, 440, 440,
1216  440, 440, 440, 441, 441, 0, 441, 441, 0, 441,
1217  441, 441, 441, 441, 441, 441, 441, 441, 0, 441,
1218  442, 442, 0, 442, 442, 442, 442, 442, 442, 442,
1219  442, 442, 0, 442, 442, 0, 442, 443, 443, 0,
1220  443, 443, 443, 443, 443, 0, 443, 443, 443, 443,
1221 
1222  443, 443, 443, 443, 444, 444, 0, 444, 444, 444,
1223  444, 444, 444, 444, 444, 444, 444, 444, 444, 444,
1224  444, 445, 0, 0, 0, 0, 445, 0, 445, 445,
1225  0, 445, 446, 446, 0, 0, 446, 0, 446, 446,
1226  446, 446, 0, 446, 446, 446, 446, 0, 446, 447,
1227  447, 447, 447, 447, 447, 447, 447, 447, 447, 447,
1228  447, 447, 447, 447, 447, 447, 448, 0, 448, 448,
1229  0, 448, 449, 449, 0, 0, 0, 0, 449, 449,
1230  449, 449, 0, 0, 449, 0, 0, 0, 449, 450,
1231  450, 0, 0, 0, 0, 450, 450, 450, 450, 450,
1232 
1233  450, 450, 450, 450, 0, 450, 451, 451, 0, 0,
1234  0, 0, 451, 451, 451, 451, 0, 451, 451, 451,
1235  451, 0, 451, 452, 0, 452, 452, 0, 452, 453,
1236  453, 0, 0, 453, 0, 0, 0, 453, 453, 0,
1237  453, 453, 453, 453, 0, 453, 454, 454, 0, 0,
1238  454, 0, 0, 0, 454, 454, 454, 454, 454, 454,
1239  454, 0, 454, 455, 455, 455, 455, 455, 455, 455,
1240  455, 455, 455, 455, 455, 455, 455, 455, 455, 455,
1241  456, 0, 456, 456, 0, 456, 457, 457, 0, 457,
1242  457, 457, 457, 457, 457, 457, 457, 457, 457, 457,
1243 
1244  457, 457, 457, 458, 0, 458, 458, 0, 458, 459,
1245  459, 459, 459, 459, 459, 459, 459, 459, 459, 459,
1246  459, 459, 459, 459, 459, 459, 460, 460, 0, 460,
1247  0, 460, 460, 460, 460, 460, 0, 460, 460, 460,
1248  460, 0, 460, 461, 461, 461, 0, 461, 461, 461,
1249  461, 462, 462, 0, 462, 462, 462, 462, 462, 462,
1250  462, 462, 462, 462, 462, 462, 462, 462, 463, 463,
1251  0, 463, 463, 463, 463, 463, 0, 463, 0, 463,
1252  463, 463, 463, 0, 463, 464, 464, 0, 0, 0,
1253  0, 464, 464, 464, 464, 0, 0, 464, 0, 0,
1254 
1255  0, 464, 466, 466, 0, 466, 466, 466, 466, 466,
1256  466, 466, 466, 466, 466, 466, 466, 466, 466, 420,
1257  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1258  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1259  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1260  420, 420, 420, 420, 420, 420, 420, 420, 420, 420,
1261  420, 420, 420, 420, 420, 420, 420, 420, 420
1262  } ;
1263 
1266 
1267 extern int yy_flex_debug;
1269 
1270 /* The intent behind this definition is that it'll catch
1271  * any uses of REJECT which flex missed.
1272  */
1273 #define REJECT reject_used_but_not_detected
1274 #define yymore() yymore_used_but_not_detected
1275 #define YY_MORE_ADJ 0
1276 #define YY_RESTORE_YY_MORE_OFFSET
1277 char *yytext;
1278 #line 1 "ppl.l"
1279 /* -*-C-*-
1280  * Wrc preprocessor lexical analysis
1281  *
1282  * Copyright 1999-2000 Bertho A. Stultiens (BS)
1283  *
1284  * This library is free software; you can redistribute it and/or
1285  * modify it under the terms of the GNU Lesser General Public
1286  * License as published by the Free Software Foundation; either
1287  * version 2.1 of the License, or (at your option) any later version.
1288  *
1289  * This library is distributed in the hope that it will be useful,
1290  * but WITHOUT ANY WARRANTY; without even the implied warranty of
1291  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1292  * Lesser General Public License for more details.
1293  *
1294  * You should have received a copy of the GNU Lesser General Public
1295  * License along with this library; if not, write to the Free Software
1296  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
1297  *
1298  *-------------------------------------------------------------------------
1299  * The preprocessor's lexographical grammar (approximately):
1300  *
1301  * pp := {ws} # {ws} if {ws} {expr} {ws} \n
1302  * | {ws} # {ws} ifdef {ws} {id} {ws} \n
1303  * | {ws} # {ws} ifndef {ws} {id} {ws} \n
1304  * | {ws} # {ws} elif {ws} {expr} {ws} \n
1305  * | {ws} # {ws} else {ws} \n
1306  * | {ws} # {ws} endif {ws} \n
1307  * | {ws} # {ws} include {ws} < {anytext} > \n
1308  * | {ws} # {ws} include {ws} " {anytext} " \n
1309  * | {ws} # {ws} define {ws} {anytext} \n
1310  * | {ws} # {ws} define( {arglist} ) {ws} {expansion} \n
1311  * | {ws} # {ws} pragma {ws} {anytext} \n
1312  * | {ws} # {ws} ident {ws} {anytext} \n
1313  * | {ws} # {ws} error {ws} {anytext} \n
1314  * | {ws} # {ws} warning {ws} {anytext} \n
1315  * | {ws} # {ws} line {ws} " {anytext} " {number} \n
1316  * | {ws} # {ws} {number} " {anytext} " {number} [ {number} [{number}] ] \n
1317  * | {ws} # {ws} \n
1318  *
1319  * ws := [ \t\r\f\v]*
1320  *
1321  * expr := {expr} [+-*%^/|&] {expr}
1322  * | {expr} {logor|logand} {expr}
1323  * | [!~+-] {expr}
1324  * | {expr} ? {expr} : {expr}
1325  *
1326  * logor := ||
1327  *
1328  * logand := &&
1329  *
1330  * id := [a-zA-Z_][a-zA-Z0-9_]*
1331  *
1332  * anytext := [^\n]* (see note)
1333  *
1334  * arglist :=
1335  * | {id}
1336  * | {arglist} , {id}
1337  * | {arglist} , {id} ...
1338  *
1339  * expansion := {id}
1340  * | # {id}
1341  * | {anytext}
1342  * | {anytext} ## {anytext}
1343  *
1344  * number := [0-9]+
1345  *
1346  * Note: "anytext" is not always "[^\n]*". This is because the
1347  * trailing context must be considered as well.
1348  *
1349  * The only certain assumption for the preprocessor to make is that
1350  * directives start at the beginning of the line, followed by a '#'
1351  * and end with a newline.
1352  * Any directive may be suffixed with a line-continuation. Also
1353  * classical comment / *...* / (note: no comments within comments,
1354  * therefore spaces) is considered to be a line-continuation
1355  * (according to gcc and egcs AFAIK, ANSI is a bit vague).
1356  * Comments have not been added to the above grammar for simplicity
1357  * reasons. However, it is allowed to enter comment anywhere within
1358  * the directives as long as they do not interfere with the context.
1359  * All comments are considered to be deletable whitespace (both
1360  * classical form "/ *...* /" and C++ form "//...\n").
1361  *
1362  * All recursive scans, except for macro-expansion, are done by the
1363  * parser, whereas the simple state transitions of non-recursive
1364  * directives are done in the scanner. This results in the many
1365  * exclusive start-conditions of the scanner.
1366  *
1367  * Macro expansions are slightly more difficult because they have to
1368  * prescan the arguments. Parameter substitution is literal if the
1369  * substitution is # or ## (either side). This enables new identifiers
1370  * to be created (see 'info cpp' node Macro|Pitfalls|Prescan for more
1371  * information).
1372  *
1373  * FIXME: Variable macro parameters is recognized, but not yet
1374  * expanded. I have to reread the ANSI standard on the subject (yes,
1375  * ANSI defines it).
1376  *
1377  * The following special defines are supported:
1378  * __FILE__ -> "thissource.c"
1379  * __LINE__ -> 123
1380  * __DATE__ -> "May 1 2000"
1381  * __TIME__ -> "23:59:59"
1382  * These macros expand, as expected, into their ANSI defined values.
1383  *
1384  * The same include prevention is implemented as gcc and egcs does.
1385  * This results in faster processing because we do not read the text
1386  * at all. Some wine-sources attempt to include the same file 4 or 5
1387  * times. This strategy also saves a lot blank output-lines, which in
1388  * its turn improves the real resource scanner/parser.
1389  *
1390  */
1391 /*
1392  * Special flex options and exclusive scanner start-conditions
1393  */
1394 #define YY_NO_INPUT 1
1395 
1396 
1397 
1398 
1399 
1400 
1401 
1402 
1403 
1404 
1405 
1406 
1407 
1408 
1409 
1410 
1411 
1412 
1413 
1414 
1415 
1416 
1417 #line 150 "ppl.l"
1418 #include <stdio.h>
1419 #include <stdlib.h>
1420 #include <string.h>
1421 #include <ctype.h>
1422 #include <assert.h>
1423 #include <errno.h>
1424 #include <limits.h>
1425 
1426 #define YY_NO_UNISTD_H
1427 
1428 #include "wpp_private.h"
1429 #include "ppy.tab.h"
1430 
1431 /*
1432  * Make sure that we are running an appropriate version of flex.
1433  */
1434 #if !defined(YY_FLEX_MAJOR_VERSION) || (1000 * YY_FLEX_MAJOR_VERSION + YY_FLEX_MINOR_VERSION < 2005)
1435 #error Must use flex version 2.5.1 or higher (yy_scan_* routines are required).
1436 #endif
1437 
1438 #define YY_READ_BUF_SIZE 65536 /* So we read most of a file at once */
1439 
1440 #define yy_current_state() YY_START
1441 #define yy_pp_state(x) yy_pop_state(); yy_push_state(x)
1442 
1443 /*
1444  * Always update the current character position within a line
1445  */
1446 #define YY_USER_ACTION pp_status.char_number+=ppy_leng;
1447 
1448 /*
1449  * Buffer management for includes and expansions
1450  */
1451 #define MAXBUFFERSTACK 128 /* Nesting more than 128 includes or macro expansion textss is insane */
1452 
1453 typedef struct bufferstackentry {
1454  YY_BUFFER_STATE bufferstate; /* Buffer to switch back to */
1455  void *filehandle; /* Handle to be used with wpp_callbacks->read */
1456  pp_entry_t *define; /* Points to expanding define or NULL if handling includes */
1457  int line_number; /* Line that we were handling */
1458  int char_number; /* The current position on that line */
1459  char *filename; /* Filename that we were handling */
1460  int if_depth; /* How many #if:s deep to check matching #endif:s */
1461  int ncontinuations; /* Remember the continuation state */
1462  int should_pop; /* Set if we must pop the start-state on EOF */
1463  /* Include management */
1467 
1468 #define ALLOCBLOCKSIZE (1 << 10) /* Allocate these chunks at a time for string-buffers */
1469 
1470 /*
1471  * Macro expansion nesting
1472  * We need the stack to handle expansions while scanning
1473  * a macro's arguments. The TOS must always be the macro
1474  * that receives the current expansion from the scanner.
1475  */
1476 #define MAXMACEXPSTACK 128 /* Nesting more than 128 macro expansions is insane */
1477 
1478 typedef struct macexpstackentry {
1479  pp_entry_t *ppp; /* This macro we are scanning */
1480  char **args; /* With these arguments */
1481  char **ppargs; /* Resulting in these preprocessed arguments */
1482  int *nnls; /* Number of newlines per argument */
1483  int nargs; /* And this many arguments scanned */
1484  int parentheses; /* Nesting level of () */
1485  int curargsize; /* Current scanning argument's size */
1486  int curargalloc; /* Current scanning argument's block allocated */
1487  char *curarg; /* Current scanning argument's content */
1489 
1490 #define MACROPARENTHESES() (top_macro()->parentheses)
1491 
1492 /*
1493  * Prototypes
1494  */
1495 static void newline(int);
1496 static int make_number(int radix, YYSTYPE *val, const char *str, int len);
1497 static void put_buffer(const char *s, int len);
1498 /* Buffer management */
1499 static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop);
1500 static bufferstackentry_t *pop_buffer(void);
1501 /* String functions */
1502 static void new_string(void);
1503 static void add_string(const char *str, int len);
1504 static char *get_string(void);
1505 static void put_string(void);
1506 static int string_start(void);
1507 /* Macro functions */
1508 static void push_macro(pp_entry_t *ppp);
1509 static macexpstackentry_t *top_macro(void);
1510 static macexpstackentry_t *pop_macro(void);
1511 static void free_macro(macexpstackentry_t *mep);
1512 static void add_text_to_macro(const char *text, int len);
1513 static void macro_add_arg(int last);
1514 static void macro_add_expansion(void);
1515 /* Expansion */
1516 static void expand_special(pp_entry_t *ppp);
1517 static void expand_define(pp_entry_t *ppp);
1518 static void expand_macro(macexpstackentry_t *mep);
1519 
1520 /*
1521  * Local variables
1522  */
1523 static int ncontinuations;
1524 
1525 static int strbuf_idx = 0;
1526 static int strbuf_alloc = 0;
1527 static char *strbuffer = NULL;
1528 static int str_startline;
1529 
1531 static int macexpstackidx = 0;
1532 
1534 static int bufferstackidx = 0;
1535 
1536 /*
1537  * Global variables
1538  */
1540 {
1541  -1, /* state */
1542  NULL, /* ppp */
1543  0, /* ifdepth */
1544  0 /* seen_junk */
1545 };
1546 
1548 
1549 #define YY_INPUT(buf,result,max_size) \
1550  { \
1551  result = wpp_read(pp_status.file, buf, max_size); \
1552  }
1553 
1554 #define BUFFERINITIALCAPACITY 256
1555 
1556 void WINAPIV pp_writestring(const char *format, ...)
1557 {
1559  int len;
1560  static char *buffer;
1561  static int buffercapacity;
1562  char *new_buffer;
1563 
1564  if(buffercapacity == 0)
1565  {
1567  if(buffer == NULL)
1568  return;
1569  buffercapacity = BUFFERINITIALCAPACITY;
1570  }
1571 
1573  len = vsnprintf(buffer, buffercapacity,
1574  format, valist);
1576  /* If the string is longer than buffersize, vsnprintf returns
1577  * the string length with glibc >= 2.1, -1 with glibc < 2.1 */
1578  while(len > buffercapacity || len < 0)
1579  {
1580  do
1581  {
1582  buffercapacity *= 2;
1583  } while(len > buffercapacity);
1584 
1585  new_buffer = pp_xrealloc(buffer, buffercapacity);
1586  if(new_buffer == NULL)
1587  return;
1588  buffer = new_buffer;
1590  len = vsnprintf(buffer, buffercapacity,
1591  format, valist);
1593  }
1594 
1595  wpp_write(buffer, len);
1596 }
1597 
1598 #line 1598 "ppl.yy.c"
1599 /*
1600  **************************************************************************
1601  * The scanner starts here
1602  **************************************************************************
1603  */
1604 #line 1604 "ppl.yy.c"
1605 
1606 #define INITIAL 0
1607 #define pp_pp 1
1608 #define pp_eol 2
1609 #define pp_inc 3
1610 #define pp_dqs 4
1611 #define pp_sqs 5
1612 #define pp_iqs 6
1613 #define pp_comment 7
1614 #define pp_def 8
1615 #define pp_define 9
1616 #define pp_macro 10
1617 #define pp_mbody 11
1618 #define pp_macign 12
1619 #define pp_macscan 13
1620 #define pp_macexp 14
1621 #define pp_if 15
1622 #define pp_ifd 16
1623 #define pp_ifignored 17
1624 #define pp_endif 18
1625 #define pp_line 19
1626 #define pp_defined 20
1627 #define pp_ignore 21
1628 #define RCINCL 22
1629 
1630 #ifndef YY_NO_UNISTD_H
1631 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1632  * down here because we want the user's section 1 to have been scanned first.
1633  * The user has a chance to override it with an option.
1634  */
1635 #include <unistd.h>
1636 #endif
1637 
1638 #ifndef YY_EXTRA_TYPE
1639 #define YY_EXTRA_TYPE void *
1640 #endif
1641 
1642 static int yy_init_globals ( void );
1643 
1644 /* Accessor methods to globals.
1645  These are made visible to non-reentrant scanners for convenience. */
1646 
1647 int yylex_destroy ( void );
1648 
1649 int yyget_debug ( void );
1650 
1651 void yyset_debug ( int debug_flag );
1652 
1653 YY_EXTRA_TYPE yyget_extra ( void );
1654 
1655 void yyset_extra ( YY_EXTRA_TYPE user_defined );
1656 
1657 FILE *yyget_in ( void );
1658 
1659 void yyset_in ( FILE * _in_str );
1660 
1661 FILE *yyget_out ( void );
1662 
1663 void yyset_out ( FILE * _out_str );
1664 
1665  int yyget_leng ( void );
1666 
1667 char *yyget_text ( void );
1668 
1669 int yyget_lineno ( void );
1670 
1671 void yyset_lineno ( int _line_number );
1672 
1673 /* Macros after this point can all be overridden by user definitions in
1674  * section 1.
1675  */
1676 
1677 #ifndef YY_SKIP_YYWRAP
1678 #ifdef __cplusplus
1679 extern "C" int yywrap ( void );
1680 #else
1681 extern int yywrap ( void );
1682 #endif
1683 #endif
1684 
1685 #ifndef YY_NO_UNPUT
1686 
1687 #endif
1688 
1689 #ifndef yytext_ptr
1690 static void yy_flex_strncpy ( char *, const char *, int );
1691 #endif
1692 
1693 #ifdef YY_NEED_STRLEN
1694 static int yy_flex_strlen ( const char * );
1695 #endif
1696 
1697 #ifndef YY_NO_INPUT
1698 #ifdef __cplusplus
1699 static int yyinput ( void );
1700 #else
1701 static int input ( void );
1702 #endif
1703 
1704 #endif
1705 
1706  static int yy_start_stack_ptr = 0;
1707  static int yy_start_stack_depth = 0;
1708  static int *yy_start_stack = NULL;
1709 
1710  static void yy_push_state ( int _new_state );
1711 
1712  static void yy_pop_state ( void );
1713 
1714  static int yy_top_state ( void );
1715 
1716 /* Amount of stuff to slurp up with each read. */
1717 #ifndef YY_READ_BUF_SIZE
1718 #ifdef __ia64__
1719 /* On IA-64, the buffer size is 16k, not 8k */
1720 #define YY_READ_BUF_SIZE 16384
1721 #else
1722 #define YY_READ_BUF_SIZE 8192
1723 #endif /* __ia64__ */
1724 #endif
1725 
1726 /* Copy whatever the last rule matched to the standard output. */
1727 #ifndef ECHO
1728 /* This used to be an fputs(), but since the string might contain NUL's,
1729  * we now use fwrite().
1730  */
1731 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
1732 #endif
1733 
1734 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1735  * is returned in "result".
1736  */
1737 #ifndef YY_INPUT
1738 #define YY_INPUT(buf,result,max_size) \
1739  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1740  { \
1741  int c = '*'; \
1742  int n; \
1743  for ( n = 0; n < max_size && \
1744  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1745  buf[n] = (char) c; \
1746  if ( c == '\n' ) \
1747  buf[n++] = (char) c; \
1748  if ( c == EOF && ferror( yyin ) ) \
1749  YY_FATAL_ERROR( "input in flex scanner failed" ); \
1750  result = n; \
1751  } \
1752  else \
1753  { \
1754  errno=0; \
1755  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
1756  { \
1757  if( errno != EINTR) \
1758  { \
1759  YY_FATAL_ERROR( "input in flex scanner failed" ); \
1760  break; \
1761  } \
1762  errno=0; \
1763  clearerr(yyin); \
1764  } \
1765  }\
1766 \
1767 
1768 #endif
1769 
1770 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1771  * we don't want an extra ';' after the "return" because that will cause
1772  * some compilers to complain about unreachable statements.
1773  */
1774 #ifndef yyterminate
1775 #define yyterminate() return YY_NULL
1776 #endif
1777 
1778 /* Number of entries by which start-condition stack grows. */
1779 #ifndef YY_START_STACK_INCR
1780 #define YY_START_STACK_INCR 25
1781 #endif
1782 
1783 /* Report a fatal error. */
1784 #ifndef YY_FATAL_ERROR
1785 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1786 #endif
1787 
1788 /* end tables serialization structures and prototypes */
1789 
1790 /* Default declaration of generated scanner - a define so the user can
1791  * easily add parameters.
1792  */
1793 #ifndef YY_DECL
1794 #define YY_DECL_IS_OURS 1
1795 
1796 extern int yylex (void);
1797 
1798 #define YY_DECL int yylex (void)
1799 #endif /* !YY_DECL */
1800 
1801 /* Code executed at the beginning of each rule, after yytext and yyleng
1802  * have been set up.
1803  */
1804 #ifndef YY_USER_ACTION
1805 #define YY_USER_ACTION
1806 #endif
1807 
1808 /* Code executed at the end of each rule. */
1809 #ifndef YY_BREAK
1810 #define YY_BREAK /*LINTED*/break;
1811 #endif
1812 
1813 #define YY_RULE_SETUP \
1814  if ( yyleng > 0 ) \
1815  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1816  (yytext[yyleng - 1] == '\n'); \
1817  YY_USER_ACTION
1818 
1821 YY_DECL
1824  char *yy_cp, *yy_bp;
1825  int yy_act;
1826 
1827  if ( !(yy_init) )
1828  {
1829  (yy_init) = 1;
1830 
1831 #ifdef YY_USER_INIT
1832  YY_USER_INIT;
1833 #endif
1834 
1835  if ( ! (yy_start) )
1836  (yy_start) = 1; /* first start state */
1837 
1838  if ( ! yyin )
1839  yyin = stdin;
1840 
1841  if ( ! yyout )
1842  yyout = stdout;
1843 
1844  if ( ! YY_CURRENT_BUFFER ) {
1848  }
1849 
1851  }
1852 
1853  {
1854 #line 338 "ppl.l"
1855 
1856 #line 340 "ppl.l"
1857  /*
1858  * Catch line-continuations.
1859  * Note: Gcc keeps the line-continuations in, for example, strings
1860  * intact. However, I prefer to remove them all so that the next
1861  * scanner will not need to reduce the continuation state.
1862  *
1863  * <*>\\\n newline(0);
1864  */
1865 
1866  /*
1867  * Detect the leading # of a preprocessor directive.
1868  */
1869 #line 1869 "ppl.yy.c"
1870 
1871  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1872  {
1873  yy_cp = (yy_c_buf_p);
1874 
1875  /* Support of yytext. */
1876  *yy_cp = (yy_hold_char);
1877 
1878  /* yy_bp points to the position in yy_ch_buf of the start of
1879  * the current run.
1880  */
1881  yy_bp = yy_cp;
1882 
1885 yy_match:
1886  do
1887  {
1888  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1889  if ( yy_accept[yy_current_state] )
1890  {
1893  }
1894  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1895  {
1897  if ( yy_current_state >= 421 )
1898  yy_c = yy_meta[yy_c];
1899  }
1901  ++yy_cp;
1902  }
1903  while ( yy_current_state != 420 );
1906 
1907 yy_find_action:
1909 
1911 
1912 do_action: /* This label is used only to access EOF actions. */
1913 
1914  switch ( yy_act )
1915  { /* beginning of action switch */
1916  case 0: /* must back up */
1917  /* undo the effects of YY_DO_BEFORE_ACTION */
1918  *yy_cp = (yy_hold_char);
1921  goto yy_find_action;
1922 
1923 case 1:
1925 #line 352 "ppl.l"
1927  YY_BREAK
1928 /*
1929  * Scan for the preprocessor directives
1930  */
1931 case 2:
1933 #line 357 "ppl.l"
1934 if(yy_top_state() != pp_ignore) {yy_pp_state(pp_inc); return tINCLUDE;} else {yy_pp_state(pp_eol);}
1935  YY_BREAK
1936 case 3:
1938 #line 358 "ppl.l"
1940  YY_BREAK
1941 case 4:
1943 #line 359 "ppl.l"
1944 yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tERROR;
1945  YY_BREAK
1946 case 5:
1948 #line 360 "ppl.l"
1950  YY_BREAK
1951 case 6:
1953 #line 361 "ppl.l"
1954 yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPRAGMA;
1955  YY_BREAK
1956 case 7:
1958 #line 362 "ppl.l"
1960  YY_BREAK
1961 case 8:
1963 #line 363 "ppl.l"
1964 if(yy_top_state() != pp_ignore) {yy_pp_state(pp_ifd); return tUNDEF;} else {yy_pp_state(pp_eol);}
1965  YY_BREAK
1966 case 9:
1968 #line 364 "ppl.l"
1969 yy_pp_state(pp_ifd); return tIFDEF;
1970  YY_BREAK
1971 case 10:
1973 #line 365 "ppl.l"
1975  YY_BREAK
1976 case 11:
1978 #line 366 "ppl.l"
1979 if(yy_top_state() != pp_ignore) {yy_pp_state(pp_if);} else {yy_pp_state(pp_ifignored);} return tIF;
1980  YY_BREAK
1981 case 12:
1983 #line 367 "ppl.l"
1984 yy_pp_state(pp_if); return tELIF;
1985  YY_BREAK
1986 case 13:
1988 #line 368 "ppl.l"
1989 yy_pp_state(pp_endif); return tELSE;
1990  YY_BREAK
1991 case 14:
1993 #line 369 "ppl.l"
1994 yy_pp_state(pp_endif); return tENDIF;
1995  YY_BREAK
1996 case 15:
1998 #line 370 "ppl.l"
1999 if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);}
2000  YY_BREAK
2001 case 16:
2003 #line 371 "ppl.l"
2004 if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);}
2005  YY_BREAK
2006 case 17:
2008 #line 372 "ppl.l"
2009 ppy_error("Invalid preprocessor token '%s'", ppy_text);
2010  YY_BREAK
2011 case 18:
2012 /* rule 18 can match eol */
2014 #line 373 "ppl.l"
2015 newline(1); yy_pop_state(); return tNL; /* This could be the null-token */
2016  YY_BREAK
2017 case 19:
2018 /* rule 19 can match eol */
2020 #line 374 "ppl.l"
2021 newline(0);
2022  YY_BREAK
2023 case 20:
2025 #line 375 "ppl.l"
2026 ppy_error("Preprocessor junk '%s'", ppy_text);
2027  YY_BREAK
2028 case 21:
2030 #line 376 "ppl.l"
2031 return *ppy_text;
2032  YY_BREAK
2033 /*
2034  * Handle #include and #line
2035  */
2036 case 22:
2038 #line 381 "ppl.l"
2039 return make_number(10, &ppy_lval, ppy_text, ppy_leng);
2040  YY_BREAK
2041 case 23:
2043 #line 382 "ppl.l"
2045  YY_BREAK
2046 case 24:
2048 #line 383 "ppl.l"
2050  YY_BREAK
2051 case 25:
2053 #line 384 "ppl.l"
2054 ;
2055  YY_BREAK
2056 case 26:
2057 /* rule 26 can match eol */
2059 #line 385 "ppl.l"
2060 newline(1); yy_pop_state(); return tNL;
2061  YY_BREAK
2062 case 27:
2063 /* rule 27 can match eol */
2065 #line 386 "ppl.l"
2066 newline(0);
2067  YY_BREAK
2068 case 28:
2070 #line 387 "ppl.l"
2071 ppy_error(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line");
2072  YY_BREAK
2073 /*
2074  * Ignore all input when a false clause is parsed
2075  */
2076 case 29:
2078 #line 392 "ppl.l"
2079 ;
2080  YY_BREAK
2081 case 30:
2082 /* rule 30 can match eol */
2084 #line 393 "ppl.l"
2085 newline(1);
2086  YY_BREAK
2087 case 31:
2088 /* rule 31 can match eol */
2090 #line 394 "ppl.l"
2091 newline(0);
2092  YY_BREAK
2093 case 32:
2095 #line 395 "ppl.l"
2096 ;
2097  YY_BREAK
2098 /*
2099  * Handle #if and #elif.
2100  * These require conditionals to be evaluated, but we do not
2101  * want to jam the scanner normally when we see these tokens.
2102  * Note: tIDENT is handled below.
2103  */
2104 case 33:
2106 #line 404 "ppl.l"
2107 return make_number(8, &ppy_lval, ppy_text, ppy_leng);
2108  YY_BREAK
2109 case 34:
2111 #line 405 "ppl.l"
2112 ppy_error("Invalid octal digit");
2113  YY_BREAK
2114 case 35:
2116 #line 406 "ppl.l"
2117 return make_number(10, &ppy_lval, ppy_text, ppy_leng);
2118  YY_BREAK
2119 case 36:
2121 #line 407 "ppl.l"
2122 return make_number(16, &ppy_lval, ppy_text, ppy_leng);
2123  YY_BREAK
2124 case 37:
2126 #line 408 "ppl.l"
2127 ppy_error("Invalid hex number");
2128  YY_BREAK
2129 case 38:
2131 #line 409 "ppl.l"
2133  YY_BREAK
2134 case 39:
2136 #line 410 "ppl.l"
2137 return tLSHIFT;
2138  YY_BREAK
2139 case 40:
2141 #line 411 "ppl.l"
2142 return tRSHIFT;
2143  YY_BREAK
2144 case 41:
2146 #line 412 "ppl.l"
2147 return tLOGAND;
2148  YY_BREAK
2149 case 42:
2151 #line 413 "ppl.l"
2152 return tLOGOR;
2153  YY_BREAK
2154 case 43:
2156 #line 414 "ppl.l"
2157 return tEQ;
2158  YY_BREAK
2159 case 44:
2161 #line 415 "ppl.l"
2162 return tNE;
2163  YY_BREAK
2164 case 45:
2166 #line 416 "ppl.l"
2167 return tLTE;
2168  YY_BREAK
2169 case 46:
2171 #line 417 "ppl.l"
2172 return tGTE;
2173  YY_BREAK
2174 case 47:
2175 /* rule 47 can match eol */
2177 #line 418 "ppl.l"
2178 newline(1); yy_pop_state(); return tNL;
2179  YY_BREAK
2180 case 48:
2181 /* rule 48 can match eol */
2183 #line 419 "ppl.l"
2184 newline(0);
2185  YY_BREAK
2186 case 49:
2188 #line 420 "ppl.l"
2189 ppy_error("Junk in conditional expression");
2190  YY_BREAK
2191 case 50:
2193 #line 421 "ppl.l"
2194 ;
2195  YY_BREAK
2196 case 51:
2198 #line 422 "ppl.l"
2200  YY_BREAK
2201 case 52:
2203 #line 423 "ppl.l"
2204 ppy_error("String constants not allowed in conditionals");
2205  YY_BREAK
2206 case 53:
2208 #line 424 "ppl.l"
2209 return *ppy_text;
2210  YY_BREAK
2211 case 54:
2213 #line 426 "ppl.l"
2214 ppy_lval.sint = 0; return tSINT;
2215  YY_BREAK
2216 case 55:
2217 /* rule 55 can match eol */
2219 #line 427 "ppl.l"
2220 newline(1); yy_pop_state(); return tNL;
2221  YY_BREAK
2222 /*
2223  * Handle #ifdef, #ifndef and #undef
2224  * to get only an untranslated/unexpanded identifier
2225  */
2226 case 56:
2228 #line 433 "ppl.l"
2230  YY_BREAK
2231 case 57:
2233 #line 434 "ppl.l"
2234 ;
2235  YY_BREAK
2236 case 58:
2237 /* rule 58 can match eol */
2239 #line 435 "ppl.l"
2240 newline(1); yy_pop_state(); return tNL;
2241  YY_BREAK
2242 case 59:
2243 /* rule 59 can match eol */
2245 #line 436 "ppl.l"
2246 newline(0);
2247  YY_BREAK
2248 case 60:
2250 #line 437 "ppl.l"
2251 ppy_error("Identifier expected");
2252  YY_BREAK
2253 /*
2254  * Handle #else and #endif.
2255  */
2256 case 61:
2258 #line 442 "ppl.l"
2259 ;
2260  YY_BREAK
2261 case 62:
2262 /* rule 62 can match eol */
2264 #line 443 "ppl.l"
2265 newline(1); yy_pop_state(); return tNL;
2266  YY_BREAK
2267 case 63:
2268 /* rule 63 can match eol */
2270 #line 444 "ppl.l"
2271 newline(0);
2272  YY_BREAK
2273 case 64:
2275 #line 445 "ppl.l"
2276 ppy_error("Garbage after #else or #endif.");
2277  YY_BREAK
2278 /*
2279  * Handle the special 'defined' keyword.
2280  * This is necessary to get the identifier prior to any
2281  * substitutions.
2282  */
2283 case 65:
2285 #line 452 "ppl.l"
2287  YY_BREAK
2288 case 66:
2290 #line 453 "ppl.l"
2291 ;
2292  YY_BREAK
2293 case 67:
2295 #line 454 "ppl.l"
2296 return *ppy_text;
2297  YY_BREAK
2298 case 68:
2299 /* rule 68 can match eol */
2301 #line 455 "ppl.l"
2302 newline(0);
2303  YY_BREAK
2304 case 69:
2305 /* rule 69 can match eol */
2307 #line 456 "ppl.l"
2308 ppy_error("Identifier expected");
2309  YY_BREAK
2310 /*
2311  * Handle #error, #warning, #pragma and #ident.
2312  * Pass everything literally to the parser, which
2313  * will act appropriately.
2314  * Comments are stripped from the literal text.
2315  */
2316 case 70:
2318 #line 464 "ppl.l"
2320  YY_BREAK
2321 case 71:
2323 #line 465 "ppl.l"
2325  YY_BREAK
2326 case 72:
2327 /* rule 72 can match eol */
2329 #line 466 "ppl.l"
2331  YY_BREAK
2332 case 73:
2333 /* rule 73 can match eol */
2335 #line 467 "ppl.l"
2336 newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; }
2337  YY_BREAK
2338 case 74:
2339 /* rule 74 can match eol */
2341 #line 468 "ppl.l"
2342 newline(0);
2343  YY_BREAK
2344 /*
2345  * Handle left side of #define
2346  */
2347 case 75:
2349 #line 473 "ppl.l"
2351  YY_BREAK
2352 case 76:
2354 #line 474 "ppl.l"
2356  YY_BREAK
2357 case 77:
2359 #line 475 "ppl.l"
2360 ;
2361  YY_BREAK
2362 case 78:
2363 /* rule 78 can match eol */
2365 #line 476 "ppl.l"
2366 newline(0);
2367  YY_BREAK
2368 case 79:
2369 /* rule 79 can match eol */
2371 #line 477 "ppl.l"
2372 perror("Identifier expected");
2373  YY_BREAK
2374 /*
2375  * Scan the substitution of a define
2376  */
2377 case 80:
2379 #line 482 "ppl.l"
2381  YY_BREAK
2382 case 81:
2383 /* rule 81 can match eol */
2385 #line 483 "ppl.l"
2387  YY_BREAK
2388 case 82:
2389 /* rule 82 can match eol */
2391 #line 484 "ppl.l"
2392 newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL;
2393  YY_BREAK
2394 case 83:
2395 /* rule 83 can match eol */
2397 #line 485 "ppl.l"
2398 newline(0);
2399  YY_BREAK
2400 case 84:
2401 /* rule 84 can match eol */
2403 #line 486 "ppl.l"
2404 newline(1); yy_pop_state(); return tNL;
2405  YY_BREAK
2406 case 85:
2408 #line 487 "ppl.l"
2410  YY_BREAK
2411 case 86:
2413 #line 488 "ppl.l"
2415  YY_BREAK
2416 /*
2417  * Scan the definition macro arguments
2418  */
2419 case 87:
2421 #line 493 "ppl.l"
2422 yy_pp_state(pp_mbody); return tMACROEND;
2423  YY_BREAK
2424 case 88:
2426 #line 494 "ppl.l"
2427 ;
2428  YY_BREAK
2429 case 89:
2431 #line 495 "ppl.l"
2433  YY_BREAK
2434 case 90:
2436 #line 496 "ppl.l"
2437 return ',';
2438  YY_BREAK
2439 case 91:
2441 #line 497 "ppl.l"
2442 return tELIPSIS;
2443  YY_BREAK
2444 case 92:
2445 /* rule 92 can match eol */
2447 #line 498 "ppl.l"
2448 ppy_error("Argument identifier expected");
2449  YY_BREAK
2450 case 93:
2451 /* rule 93 can match eol */
2453 #line 499 "ppl.l"
2454 newline(0);
2455  YY_BREAK
2456 /*
2457  * Scan the substitution of a macro
2458  */
2459 case 94:
2461 #line 504 "ppl.l"
2463  YY_BREAK
2464 case 95:
2466 #line 505 "ppl.l"
2468  YY_BREAK
2469 case 96:
2471 #line 506 "ppl.l"
2472 return tCONCAT;
2473  YY_BREAK
2474 case 97:
2476 #line 507 "ppl.l"
2477 return tSTRINGIZE;
2478  YY_BREAK
2479 case 98:
2481 #line 508 "ppl.l"
2483  YY_BREAK
2484 case 99:
2486 #line 509 "ppl.l"
2488  YY_BREAK
2489 case 100:
2490 /* rule 100 can match eol */
2492 #line 510 "ppl.l"
2493 newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL;
2494  YY_BREAK
2495 case 101:
2496 /* rule 101 can match eol */
2498 #line 511 "ppl.l"
2499 newline(0);
2500  YY_BREAK
2501 case 102:
2502 /* rule 102 can match eol */
2504 #line 512 "ppl.l"
2505 newline(1); yy_pop_state(); return tNL;
2506  YY_BREAK
2507 case 103:
2509 #line 513 "ppl.l"
2511  YY_BREAK
2512 case 104:
2514 #line 514 "ppl.l"
2516  YY_BREAK
2517 /*
2518  * Macro expansion text scanning.
2519  * This state is active just after the identifier is scanned
2520  * that triggers an expansion. We *must* delete the leading
2521  * whitespace before we can start scanning for arguments.
2522  *
2523  * If we do not see a '(' as next trailing token, then we have
2524  * a false alarm. We just continue with a nose-bleed...
2525  */
2526 case 105:
2527 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2528 (yy_c_buf_p) = yy_cp -= 1;
2529 YY_DO_BEFORE_ACTION; /* set up yytext again */
2531 #line 525 "ppl.l"
2533  YY_BREAK
2534 case 106:
2535 /* rule 106 can match eol */
2537 #line 526 "ppl.l"
2538 {
2539  if(yy_top_state() != pp_macscan)
2540  newline(0);
2541  }
2542  YY_BREAK
2543 case 107:
2544 /* rule 107 can match eol */
2546 #line 530 "ppl.l"
2547 newline(0);
2548  YY_BREAK
2549 case 108:
2551 #line 531 "ppl.l"
2552 {
2553  macexpstackentry_t *mac = pop_macro();
2554  yy_pop_state();
2555  put_buffer(mac->ppp->ident, strlen(mac->ppp->ident));
2557  free_macro(mac);
2558  }
2559  YY_BREAK
2560 /*
2561  * Macro expansion argument text scanning.
2562  * This state is active when a macro's arguments are being read for expansion.
2563  */
2564 case 109:
2566 #line 543 "ppl.l"
2567 {
2568  if(++MACROPARENTHESES() > 1)
2570  }
2571  YY_BREAK
2572 case 110:
2574 #line 547 "ppl.l"
2575 {
2576  if(--MACROPARENTHESES() == 0)
2577  {
2578  yy_pop_state();
2579  macro_add_arg(1);
2580  }
2581  else
2583  }
2584  YY_BREAK
2585 case 111:
2587 #line 556 "ppl.l"
2588 {
2589  if(MACROPARENTHESES() > 1)
2591  else
2592  macro_add_arg(0);
2593  }
2594  YY_BREAK
2595 case 112:
2597 #line 562 "ppl.l"
2599  YY_BREAK
2600 case 113:
2602 #line 563 "ppl.l"
2604  YY_BREAK
2605 case 114:
2607 #line 564 "ppl.l"
2609  YY_BREAK
2610 case 115:
2611 /* rule 115 can match eol */
2613 #line 565 "ppl.l"
2615  YY_BREAK
2616 case 116:
2618 #line 566 "ppl.l"
2620  YY_BREAK
2621 case 117:
2622 /* rule 117 can match eol */
2624 #line 567 "ppl.l"
2625 newline(0);
2626  YY_BREAK
2627 /*
2628  * Comment handling (almost all start-conditions)
2629  */
2630 case 118:
2632 #line 572 "ppl.l"
2634  YY_BREAK
2635 case 119:
2637 #line 573 "ppl.l"
2638 ;
2639  YY_BREAK
2640 case 120:
2641 /* rule 120 can match eol */
2643 #line 574 "ppl.l"
2644 newline(0);
2645  YY_BREAK
2646 case 121:
2648 #line 575 "ppl.l"
2649 yy_pop_state();
2650  YY_BREAK
2651 /*
2652  * Remove C++ style comment (almost all start-conditions)
2653  */
2654 case 122:
2656 #line 580 "ppl.l"
2657 {
2658  if(ppy_text[ppy_leng-1] == '\\')
2659  ppy_warning("C++ style comment ends with an escaped newline (escape ignored)");
2660  }
2661  YY_BREAK
2662 /*
2663  * Single, double and <> quoted constants
2664  */
2665 case 123:
2667 #line 588 "ppl.l"
2669  YY_BREAK
2670 case 124:
2672 #line 589 "ppl.l"
2674  YY_BREAK
2675 case 125:
2677 #line 590 "ppl.l"
2679  YY_BREAK
2680 case 126:
2682 #line 591 "ppl.l"
2683 {
2685  yy_pop_state();
2686  switch(yy_current_state())
2687  {
2688  case pp_pp:
2689  case pp_define:
2690  case pp_mbody:
2691  case pp_inc:
2692  case RCINCL:
2694  ppy_lval.cptr = get_string();
2695  return tDQSTRING;
2696  case pp_line:
2697  ppy_lval.cptr = get_string();
2698  return tDQSTRING;
2699  default:
2700  put_string();
2701  }
2702  }
2703  YY_BREAK
2704 case 127:
2706 #line 611 "ppl.l"
2708  YY_BREAK
2709 case 128:
2711 #line 612 "ppl.l"
2712 {
2714  yy_pop_state();
2715  switch(yy_current_state())
2716  {
2717  case pp_if:
2718  case pp_define:
2719  case pp_mbody:
2720  ppy_lval.cptr = get_string();
2721  return tSQSTRING;
2722  default:
2723  put_string();
2724  }
2725  }
2726  YY_BREAK
2727 case 129:
2729 #line 626 "ppl.l"
2731  YY_BREAK
2732 case 130:
2734 #line 627 "ppl.l"
2735 {
2737  yy_pop_state();
2738  ppy_lval.cptr = get_string();
2739  return tIQSTRING;
2740  }
2741  YY_BREAK
2742 case 131:
2743 /* rule 131 can match eol */
2745 #line 633 "ppl.l"
2746 {
2747  /*
2748  * This is tricky; we need to remove the line-continuation
2749  * from preprocessor strings, but OTOH retain them in all
2750  * other strings. This is because the resource grammar is
2751  * even more braindead than initially analysed and line-
2752  * continuations in strings introduce, sigh, newlines in
2753  * the output. There goes the concept of non-breaking, non-
2754  * spacing whitespace.
2755  */
2756  switch(yy_top_state())
2757  {
2758  case pp_pp:
2759  case pp_define:
2760  case pp_mbody:
2761  case pp_inc:
2762  case pp_line:
2763  newline(0);
2764  break;
2765  default:
2767  newline(-1);
2768  }
2769  }
2770  YY_BREAK
2771 case 132:
2773 #line 657 "ppl.l"
2775  YY_BREAK
2776 case 133:
2777 /* rule 133 can match eol */
2779 #line 658 "ppl.l"
2780 {
2781  newline(1);
2783  ppy_warning("Newline in string constant encountered (started line %d)", string_start());
2784  }
2785  YY_BREAK
2786 /*
2787  * Identifier scanning
2788  */
2789 case 134:
2791 #line 667 "ppl.l"
2792 {
2793  pp_entry_t *ppp;
2795  if(!(ppp = pplookup(ppy_text)))
2796  {
2797  if(yy_current_state() == pp_inc)
2798  ppy_error("Expected include filename");
2799 
2800  else if(yy_current_state() == pp_if)
2801  {
2803  return tIDENT;
2804  }
2805  else {
2806  if((yy_current_state()==INITIAL) && (strcasecmp(ppy_text,"RCINCLUDE")==0)){
2808  return tRCINCLUDE;
2809  }
2810  else put_buffer(ppy_text, ppy_leng);
2811  }
2812  }
2813  else if(!ppp->expanding)
2814  {
2815  switch(ppp->type)
2816  {
2817  case def_special:
2818  expand_special(ppp);
2819  break;
2820  case def_define:
2821  expand_define(ppp);
2822  break;
2823  case def_macro:
2825  push_macro(ppp);
2826  break;
2827  default:
2828  pp_internal_error(__FILE__, __LINE__, "Invalid define type %d\n", ppp->type);
2829  }
2830  }
2831  else put_buffer(ppy_text, ppy_leng);
2832  }
2833  YY_BREAK
2834 /*
2835  * Everything else that needs to be passed and
2836  * newline and continuation handling
2837  */
2838 case 135:
2840 #line 713 "ppl.l"
2842  YY_BREAK
2843 case 136:
2845 #line 714 "ppl.l"
2847  YY_BREAK
2848 case 137:
2849 /* rule 137 can match eol */
2851 #line 715 "ppl.l"
2852 newline(1);
2853  YY_BREAK
2854 case 138:
2855 /* rule 138 can match eol */
2857 #line 716 "ppl.l"
2858 newline(0);
2859  YY_BREAK
2860 case 139:
2862 #line 717 "ppl.l"
2864  YY_BREAK
2865 /*
2866  * Special catcher for macro argmument expansion to prevent
2867  * newlines to propagate to the output or admin.
2868  */
2869 case 140:
2870 /* rule 140 can match eol */
2872 #line 723 "ppl.l"
2874  YY_BREAK
2875 case 141:
2877 #line 725 "ppl.l"
2878 {
2880  yy_pop_state();
2881  return tRCINCLUDEPATH;
2882  }
2883  YY_BREAK
2884 case 142:
2886 #line 731 "ppl.l"
2887 ;
2888  YY_BREAK
2889 case 143:
2891 #line 733 "ppl.l"
2892 {
2894  }
2895  YY_BREAK
2896 /*
2897  * This is a 'catch-all' rule to discover errors in the scanner
2898  * in an orderly manner.
2899  */
2900 case 144:
2902 #line 741 "ppl.l"
2903 pp_incl_state.seen_junk++; ppy_warning("Unmatched text '%c' (0x%02x); please report\n", isprint(*ppy_text & 0xff) ? *ppy_text : ' ', *ppy_text);
2904  YY_BREAK
2905 case YY_STATE_EOF(INITIAL):
2906 case YY_STATE_EOF(pp_pp):
2907 case YY_STATE_EOF(pp_eol):
2908 case YY_STATE_EOF(pp_inc):
2909 case YY_STATE_EOF(pp_dqs):
2910 case YY_STATE_EOF(pp_sqs):
2911 case YY_STATE_EOF(pp_iqs):
2912 case YY_STATE_EOF(pp_comment):
2913 case YY_STATE_EOF(pp_def):
2914 case YY_STATE_EOF(pp_define):
2915 case YY_STATE_EOF(pp_macro):
2916 case YY_STATE_EOF(pp_mbody):
2917 case YY_STATE_EOF(pp_macign):
2918 case YY_STATE_EOF(pp_macscan):
2919 case YY_STATE_EOF(pp_macexp):
2920 case YY_STATE_EOF(pp_if):
2921 case YY_STATE_EOF(pp_ifd):
2923 case YY_STATE_EOF(pp_endif):
2924 case YY_STATE_EOF(pp_line):
2925 case YY_STATE_EOF(pp_defined):
2926 case YY_STATE_EOF(pp_ignore):
2927 case YY_STATE_EOF(RCINCL):
2928 #line 743 "ppl.l"
2929 {
2931  bufferstackentry_t *bep = pop_buffer();
2932 
2933  if((!bep && pp_get_if_depth()) || (bep && pp_get_if_depth() != bep->if_depth))
2934  ppy_warning("Unmatched #if/#endif at end of file");
2935 
2936  if(!bep)
2937  {
2938  if(YY_START != INITIAL)
2939  {
2940  ppy_error("Unexpected end of file during preprocessing");
2941  BEGIN(INITIAL);
2942  }
2943  yyterminate();
2944  }
2945  else if(bep->should_pop == 2)
2946  {
2947  macexpstackentry_t *mac;
2948  mac = pop_macro();
2949  expand_macro(mac);
2950  }
2952  }
2953  YY_BREAK
2954 case 145:
2956 #line 768 "ppl.l"
2957 ECHO;
2958  YY_BREAK
2959 #line 2959 "ppl.yy.c"
2960 
2961  case YY_END_OF_BUFFER:
2962  {
2963  /* Amount of text matched not including the EOB char. */
2964  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2965 
2966  /* Undo the effects of YY_DO_BEFORE_ACTION. */
2967  *yy_cp = (yy_hold_char);
2969 
2970  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2971  {
2972  /* We're scanning a new file or input source. It's
2973  * possible that this happened because the user
2974  * just pointed yyin at a new source and called
2975  * yylex(). If so, then we have to assure
2976  * consistency between YY_CURRENT_BUFFER and our
2977  * globals. Here is the right place to do so, because
2978  * this is the first action (other than possibly a
2979  * back-up) that will match for the new input source.
2980  */
2981  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2982  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2983  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2984  }
2985 
2986  /* Note that here we test for yy_c_buf_p "<=" to the position
2987  * of the first EOB in the buffer, since yy_c_buf_p will
2988  * already have been incremented past the NUL character
2989  * (since all states make transitions on EOB to the
2990  * end-of-buffer state). Contrast this with the test
2991  * in input().
2992  */
2993  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2994  { /* This was really a NUL. */
2995  yy_state_type yy_next_state;
2996 
2997  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2998 
3000 
3001  /* Okay, we're now positioned to make the NUL
3002  * transition. We couldn't have
3003  * yy_get_previous_state() go ahead and do it
3004  * for us because it doesn't know how to deal
3005  * with the possibility of jamming (and we don't
3006  * want to build jamming into it because then it
3007  * will run more slowly).
3008  */
3009 
3010  yy_next_state = yy_try_NUL_trans( yy_current_state );
3011 
3013 
3014  if ( yy_next_state )
3015  {
3016  /* Consume the NUL. */
3017  yy_cp = ++(yy_c_buf_p);
3018  yy_current_state = yy_next_state;
3019  goto yy_match;
3020  }
3021 
3022  else
3023  {
3026  goto yy_find_action;
3027  }
3028  }
3029 
3030  else switch ( yy_get_next_buffer( ) )
3031  {
3032  case EOB_ACT_END_OF_FILE:
3033  {
3035 
3036  if ( yywrap( ) )
3037  {
3038  /* Note: because we've taken care in
3039  * yy_get_next_buffer() to have set up
3040  * yytext, we can now set up
3041  * yy_c_buf_p so that if some total
3042  * hoser (like flex itself) wants to
3043  * call the scanner after we return the
3044  * YY_NULL, it'll still work - another
3045  * YY_NULL will get returned.
3046  */
3048 
3050  goto do_action;
3051  }
3052 
3053  else
3054  {
3055  if ( ! (yy_did_buffer_switch_on_eof) )
3056  YY_NEW_FILE;
3057  }
3058  break;
3059  }
3060 
3061  case EOB_ACT_CONTINUE_SCAN:
3062  (yy_c_buf_p) =
3063  (yytext_ptr) + yy_amount_of_matched_text;
3064 
3066 
3067  yy_cp = (yy_c_buf_p);
3069  goto yy_match;
3070 
3071  case EOB_ACT_LAST_MATCH:
3072  (yy_c_buf_p) =
3073  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
3074 
3076 
3077  yy_cp = (yy_c_buf_p);
3079  goto yy_find_action;
3080  }
3081  break;
3082  }
3083 
3084  default:
3086  "fatal flex scanner internal error--no action found" );
3087  } /* end of action switch */
3088  } /* end of scanning one token */
3089  } /* end of user's declarations */
3090 } /* end of yylex */
3091 
3092 /* yy_get_next_buffer - try to read in a new buffer
3093  *
3094  * Returns a code representing an action:
3095  * EOB_ACT_LAST_MATCH -
3096  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3097  * EOB_ACT_END_OF_FILE - end of file
3098  */
3099 static int yy_get_next_buffer (void)
3100 {
3101  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
3102  char *source = (yytext_ptr);
3103  int number_to_move, i;
3104  int ret_val;
3105 
3106  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
3108  "fatal flex scanner internal error--end of buffer missed" );
3109 
3110  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
3111  { /* Don't try to fill the buffer, so this is an EOF. */
3112  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
3113  {
3114  /* We matched a single character, the EOB, so
3115  * treat this as a final EOF.
3116  */
3117  return EOB_ACT_END_OF_FILE;
3118  }
3119 
3120  else
3121  {
3122  /* We matched some text prior to the EOB, first
3123  * process it.
3124  */
3125  return EOB_ACT_LAST_MATCH;
3126  }
3127  }
3128 
3129  /* Try to read more data. */
3130 
3131  /* First move last chars to start of buffer. */
3132  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
3133 
3134  for ( i = 0; i < number_to_move; ++i )
3135  *(dest++) = *(source++);
3136 
3137  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3138  /* don't do the read, it's not guaranteed to return an EOF,
3139  * just force an EOF
3140  */
3141  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
3142 
3143  else
3144  {
3145  int num_to_read =
3146  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3147 
3148  while ( num_to_read <= 0 )
3149  { /* Not enough room in the buffer - grow it. */
3150 
3151  /* just a shorter name for the current buffer */
3153 
3154  int yy_c_buf_p_offset =
3155  (int) ((yy_c_buf_p) - b->yy_ch_buf);
3156 
3157  if ( b->yy_is_our_buffer )
3158  {
3159  int new_size = b->yy_buf_size * 2;
3160 
3161  if ( new_size <= 0 )
3162  b->yy_buf_size += b->yy_buf_size / 8;
3163  else
3164  b->yy_buf_size *= 2;
3165 
3166  b->yy_ch_buf = (char *)
3167  /* Include room in for 2 EOB chars. */
3168  yyrealloc( (void *) b->yy_ch_buf,
3169  (yy_size_t) (b->yy_buf_size + 2) );
3170  }
3171  else
3172  /* Can't grow it, we don't own it. */
3173  b->yy_ch_buf = NULL;
3174 
3175  if ( ! b->yy_ch_buf )
3177  "fatal error - scanner input buffer overflow" );
3178 
3179  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
3180 
3181  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
3182  number_to_move - 1;
3183 
3184  }
3185 
3186  if ( num_to_read > YY_READ_BUF_SIZE )
3187  num_to_read = YY_READ_BUF_SIZE;
3188 
3189  /* Read in more data. */
3190  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3191  (yy_n_chars), num_to_read );
3192 
3193  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3194  }
3195 
3196  if ( (yy_n_chars) == 0 )
3197  {
3198  if ( number_to_move == YY_MORE_ADJ )
3199  {
3200  ret_val = EOB_ACT_END_OF_FILE;
3201  yyrestart( yyin );
3202  }
3203 
3204  else
3205  {
3206  ret_val = EOB_ACT_LAST_MATCH;
3207  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3209  }
3210  }
3211 
3212  else
3213  ret_val = EOB_ACT_CONTINUE_SCAN;
3214 
3215  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
3216  /* Extend the array by 50%, plus the number we really need. */
3217  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3218  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
3219  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
3220  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3221  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3222  /* "- 2" to take care of EOB's */
3223  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
3224  }
3225 
3226  (yy_n_chars) += number_to_move;
3229 
3230  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3231 
3232  return ret_val;
3233 }
3234 
3235 /* yy_get_previous_state - get the state just before the EOB char was reached */
3236 
3237  static yy_state_type yy_get_previous_state (void)
3238 {
3240  char *yy_cp;
3241 
3244 
3245  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3246  {
3247  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3248  if ( yy_accept[yy_current_state] )
3249  {
3252  }
3253  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3254  {
3256  if ( yy_current_state >= 421 )
3257  yy_c = yy_meta[yy_c];
3258  }
3260  }
3261 
3262  return yy_current_state;
3263 }
3264 
3265 /* yy_try_NUL_trans - try to make a transition on the NUL character
3266  *
3267  * synopsis
3268  * next_state = yy_try_NUL_trans( current_state );
3269  */
3271 {
3272  int yy_is_jam;
3273  char *yy_cp = (yy_c_buf_p);
3274 
3275  YY_CHAR yy_c = 1;
3276  if ( yy_accept[yy_current_state] )
3277  {
3280  }
3281  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3282  {
3284  if ( yy_current_state >= 421 )
3285  yy_c = yy_meta[yy_c];
3286  }
3288  yy_is_jam = (yy_current_state == 420);
3289 
3290  return yy_is_jam ? 0 : yy_current_state;
3291 }
3292 
3293 #ifndef YY_NO_UNPUT
3294 
3295 #endif
3296 
3297 #ifndef YY_NO_INPUT
3298 #ifdef __cplusplus
3299  static int yyinput (void)
3300 #else
3301  static int input (void)
3302 #endif
3303 
3304 {
3305  int c;
3306 
3307  *(yy_c_buf_p) = (yy_hold_char);
3308 
3309  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3310  {
3311  /* yy_c_buf_p now points to the character we want to return.
3312  * If this occurs *before* the EOB characters, then it's a
3313  * valid NUL; if not, then we've hit the end of the buffer.
3314  */
3315  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3316  /* This was really a NUL. */
3317  *(yy_c_buf_p) = '\0';
3318 
3319  else
3320  { /* need more input */
3321  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
3322  ++(yy_c_buf_p);
3323 
3324  switch ( yy_get_next_buffer( ) )
3325  {
3326  case EOB_ACT_LAST_MATCH:
3327  /* This happens because yy_g_n_b()
3328  * sees that we've accumulated a
3329  * token and flags that we need to
3330  * try matching the token before
3331  * proceeding. But for input(),
3332  * there's no matching to consider.
3333  * So convert the EOB_ACT_LAST_MATCH
3334  * to EOB_ACT_END_OF_FILE.
3335  */
3336 
3337  /* Reset buffer status. */
3338  yyrestart( yyin );
3339 
3340  /*FALLTHROUGH*/
3341 
3342  case EOB_ACT_END_OF_FILE:
3343  {
3344  if ( yywrap( ) )
3345  return 0;
3346 
3347  if ( ! (yy_did_buffer_switch_on_eof) )
3348  YY_NEW_FILE;
3349 #ifdef __cplusplus
3350  return yyinput();
3351 #else
3352  return input();
3353 #endif
3354  }
3355 
3356  case EOB_ACT_CONTINUE_SCAN:
3357  (yy_c_buf_p) = (yytext_ptr) + offset;
3358  break;
3359  }
3360  }
3361  }
3362 
3363  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
3364  *(yy_c_buf_p) = '\0'; /* preserve yytext */
3365  (yy_hold_char) = *++(yy_c_buf_p);
3366 
3367  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
3368 
3369  return c;
3370 }
3371 #endif /* ifndef YY_NO_INPUT */
3372 
3378  void yyrestart (FILE * input_file )
3379 {
3380 
3381  if ( ! YY_CURRENT_BUFFER ){
3385  }
3386 
3387  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
3389 }
3390 
3395  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
3396 {
3397 
3398  /* TODO. We should be able to replace this entire function body
3399  * with
3400  * yypop_buffer_state();
3401  * yypush_buffer_state(new_buffer);
3402  */
3404  if ( YY_CURRENT_BUFFER == new_buffer )
3405  return;
3406 
3407  if ( YY_CURRENT_BUFFER )
3408  {
3409  /* Flush out information for old buffer. */
3410  *(yy_c_buf_p) = (yy_hold_char);
3411  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3412  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3413  }
3414 
3415  YY_CURRENT_BUFFER_LVALUE = new_buffer;
3417 
3418  /* We don't actually know whether we did this switch during
3419  * EOF (yywrap()) processing, but the only time this flag
3420  * is looked at is after yywrap() is called, so it's safe
3421  * to go ahead and always set it.
3422  */
3424 }
3425 
3426 static void yy_load_buffer_state (void)
3427 {
3428  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3429  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
3430  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
3431  (yy_hold_char) = *(yy_c_buf_p);
3432 }
3433 
3441 {
3443 
3444  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
3445  if ( ! b )
3446  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3447 
3448  b->yy_buf_size = size;
3449 
3450  /* yy_ch_buf has to be 2 characters longer than the size given because
3451  * we need to put in 2 end-of-buffer characters.
3452  */
3453  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
3454  if ( ! b->yy_ch_buf )
3455  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3456 
3457  b->yy_is_our_buffer = 1;
3458 
3459  yy_init_buffer( b, file );
3460 
3461  return b;
3462 }
3463 
3469 {
3470 
3471  if ( ! b )
3472  return;
3473 
3474  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3476 
3477  if ( b->yy_is_our_buffer )
3478  yyfree( (void *) b->yy_ch_buf );
3479 
3480  yyfree( (void *) b );
3481 }
3482 
3483 /* Initializes or reinitializes a buffer.
3484  * This function is sometimes called more than once on the same buffer,
3485  * such as during a yyrestart() or at EOF.
3486  */
3487  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
3488 
3489 {
3490  int oerrno = errno;
3491 
3492  yy_flush_buffer( b );
3493 
3494  b->yy_input_file = file;
3495  b->yy_fill_buffer = 1;
3496 
3497  /* If b is the current buffer, then yy_init_buffer was _probably_
3498  * called from yyrestart() or through yy_get_next_buffer.
3499  * In that case, we don't want to reset the lineno or column.
3500  */
3501  if (b != YY_CURRENT_BUFFER){
3502  b->yy_bs_lineno = 1;
3503  b->yy_bs_column = 0;
3504  }
3505 
3506  b->yy_is_interactive = 0;
3507 
3508  errno = oerrno;
3509 }
3510 
3516 {
3517  if ( ! b )
3518  return;
3519 
3520  b->yy_n_chars = 0;
3521 
3522  /* We always need two end-of-buffer characters. The first causes
3523  * a transition to the end-of-buffer state. The second causes
3524  * a jam in that state.
3525  */
3526  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3527  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3528 
3529  b->yy_buf_pos = &b->yy_ch_buf[0];
3530 
3531  b->yy_at_bol = 1;
3532  b->yy_buffer_status = YY_BUFFER_NEW;
3533 
3534  if ( b == YY_CURRENT_BUFFER )
3536 }
3537 
3544 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
3545 {
3546  if (new_buffer == NULL)
3547  return;
3548 
3550 
3551  /* This block is copied from yy_switch_to_buffer. */
3552  if ( YY_CURRENT_BUFFER )
3553  {
3554  /* Flush out information for old buffer. */
3555  *(yy_c_buf_p) = (yy_hold_char);
3556  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3557  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3558  }
3559 
3560  /* Only push if top exists. Otherwise, replace top. */
3561  if (YY_CURRENT_BUFFER)
3562  (yy_buffer_stack_top)++;
3563  YY_CURRENT_BUFFER_LVALUE = new_buffer;
3564 
3565  /* copied from yy_switch_to_buffer. */
3568 }
3569 
3574 void yypop_buffer_state (void)
3575 {
3576  if (!YY_CURRENT_BUFFER)
3577  return;
3578 
3581  if ((yy_buffer_stack_top) > 0)
3582  --(yy_buffer_stack_top);
3583 
3584  if (YY_CURRENT_BUFFER) {
3587  }
3588 }
3589 
3590 /* Allocates the stack if it does not exist.
3591  * Guarantees space for at least one push.
3592  */
3593 static void yyensure_buffer_stack (void)
3594 {
3595  yy_size_t num_to_alloc;
3596 
3597  if (!(yy_buffer_stack)) {
3598 
3599  /* First allocation is just for 2 elements, since we don't know if this
3600  * scanner will even need a stack. We use 2 instead of 1 to avoid an
3601  * immediate realloc on the next call.
3602  */
3603  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
3605  (num_to_alloc * sizeof(struct yy_buffer_state*)
3606  );
3607  if ( ! (yy_buffer_stack) )
3608  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3609 
3610  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3611 
3612  (yy_buffer_stack_max) = num_to_alloc;
3613  (yy_buffer_stack_top) = 0;
3614  return;
3615  }
3616 
3617  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3618 
3619  /* Increase the buffer to prepare for a possible push. */
3620  yy_size_t grow_size = 8 /* arbitrary grow size */;
3621 
3622  num_to_alloc = (yy_buffer_stack_max) + grow_size;
3624  ((yy_buffer_stack),
3625  num_to_alloc * sizeof(struct yy_buffer_state*)
3626  );
3627  if ( ! (yy_buffer_stack) )
3628  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
3629 
3630  /* zero only the new slots.*/
3631  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3632  (yy_buffer_stack_max) = num_to_alloc;
3633  }
3634 }
3635 
3643 {
3645 
3646  if ( size < 2 ||
3649  /* They forgot to leave room for the EOB's. */
3650  return NULL;
3651 
3652  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
3653  if ( ! b )
3654  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3655 
3656  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
3657  b->yy_buf_pos = b->yy_ch_buf = base;
3658  b->yy_is_our_buffer = 0;
3659  b->yy_input_file = NULL;
3660  b->yy_n_chars = b->yy_buf_size;
3661  b->yy_is_interactive = 0;
3662  b->yy_at_bol = 1;
3663  b->yy_fill_buffer = 0;
3664  b->yy_buffer_status = YY_BUFFER_NEW;
3665 
3667 
3668  return b;
3669 }
3670 
3679 YY_BUFFER_STATE yy_scan_string (const char * yystr )
3680 {
3681 
3682  return yy_scan_bytes( yystr, (int) strlen(yystr) );
3683 }
3684 
3692 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
3693 {
3695  char *buf;
3696  yy_size_t n;
3697  int i;
3698 
3699  /* Get memory for full buffer, including space for trailing EOB's. */
3700  n = (yy_size_t) (_yybytes_len + 2);
3701  buf = (char *) yyalloc( n );
3702  if ( ! buf )
3703  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3704 
3705  for ( i = 0; i < _yybytes_len; ++i )
3706  buf[i] = yybytes[i];
3707 
3708  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3709 
3710  b = yy_scan_buffer( buf, n );
3711  if ( ! b )
3712  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3713 
3714  /* It's okay to grow etc. this buffer, and we should throw it
3715  * away when we're done.
3716  */
3717  b->yy_is_our_buffer = 1;
3718 
3719  return b;
3720 }
3721 
3722  static void yy_push_state (int _new_state )
3723 {
3725  {
3726  yy_size_t new_size;
3727 
3729  new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int );
3730 
3731  if ( ! (yy_start_stack) )
3732  (yy_start_stack) = (int *) yyalloc( new_size );
3733 
3734  else
3735  (yy_start_stack) = (int *) yyrealloc(
3736  (void *) (yy_start_stack), new_size );
3737 
3738  if ( ! (yy_start_stack) )
3739  YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
3740  }
3741 
3743 
3744  BEGIN(_new_state);
3745 }
3746 
3747  static void yy_pop_state (void)
3748 {
3749  if ( --(yy_start_stack_ptr) < 0 )
3750  YY_FATAL_ERROR( "start-condition stack underflow" );
3751 
3753 }
3754 
3755  static int yy_top_state (void)
3756 {
3757  return (yy_start_stack)[(yy_start_stack_ptr) - 1];
3758 }
3759 
3760 #ifndef YY_EXIT_FAILURE
3761 #define YY_EXIT_FAILURE 2
3762 #endif
3763 
3764 static void yynoreturn yy_fatal_error (const char* msg )
3765 {
3766  fprintf( stderr, "%s\n", msg );
3767  exit( YY_EXIT_FAILURE );
3768 }
3769 
3770 /* Redefine yyless() so it works in section 3 code. */
3771 
3772 #undef yyless
3773 #define yyless(n) \
3774  do \
3775  { \
3776  /* Undo effects of setting up yytext. */ \
3777  int yyless_macro_arg = (n); \
3778  YY_LESS_LINENO(yyless_macro_arg);\
3779  yytext[yyleng] = (yy_hold_char); \
3780  (yy_c_buf_p) = yytext + yyless_macro_arg; \
3781  (yy_hold_char) = *(yy_c_buf_p); \
3782  *(yy_c_buf_p) = '\0'; \
3783  yyleng = yyless_macro_arg; \
3784  } \
3785  while ( 0 )
3786 
3787 /* Accessor methods (get/set functions) to struct members. */
3788 
3792 int yyget_lineno (void)
3793 {
3794 
3795  return yylineno;
3796 }
3797 
3801 FILE *yyget_in (void)
3802 {
3803  return yyin;
3804 }
3805 
3809 FILE *yyget_out (void)
3810 {
3811  return yyout;
3812 }
3813 
3817 int yyget_leng (void)
3818 {
3819  return yyleng;
3820 }
3821 
3826 char *yyget_text (void)
3827 {
3828  return yytext;
3829 }
3830 
3835 void yyset_lineno (int _line_number )
3836 {
3837 
3838  yylineno = _line_number;
3839 }
3840 
3847 void yyset_in (FILE * _in_str )
3848 {
3849  yyin = _in_str ;
3850 }
3851 
3852 void yyset_out (FILE * _out_str )
3853 {
3854  yyout = _out_str ;
3855 }
3856 
3857 int yyget_debug (void)
3858 {
3859  return yy_flex_debug;
3860 }
3861 
3862 void yyset_debug (int _bdebug )
3863 {
3864  yy_flex_debug = _bdebug ;
3865 }
3866 
3867 static int yy_init_globals (void)
3868 {
3869  /* Initialization is the same as for the non-reentrant scanner.
3870  * This function is called from yylex_destroy(), so don't allocate here.
3871  */
3872 
3873  (yy_buffer_stack) = NULL;
3874  (yy_buffer_stack_top) = 0;
3875  (yy_buffer_stack_max) = 0;
3876  (yy_c_buf_p) = NULL;
3877  (yy_init) = 0;
3878  (yy_start) = 0;
3879 
3880  (yy_start_stack_ptr) = 0;
3881  (yy_start_stack_depth) = 0;
3882  (yy_start_stack) = NULL;
3883 
3884 /* Defined in main.c */
3885 #ifdef YY_STDINIT
3886  yyin = stdin;
3887  yyout = stdout;
3888 #else
3889  yyin = NULL;
3890  yyout = NULL;
3891 #endif
3892 
3893  /* For future reference: Set errno on error, since we are called by
3894  * yylex_init()
3895  */
3896  return 0;
3897 }
3898 
3899 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
3900 int yylex_destroy (void)
3901 {
3902 
3903  /* Pop the buffer stack, destroying each element. */
3904  while(YY_CURRENT_BUFFER){
3908  }
3909 
3910  /* Destroy the stack itself. */
3911  yyfree((yy_buffer_stack) );
3912  (yy_buffer_stack) = NULL;
3913 
3914  /* Destroy the start condition stack. */
3915  yyfree( (yy_start_stack) );
3916  (yy_start_stack) = NULL;
3917 
3918  /* Reset the globals. This is important in a non-reentrant scanner so the next time
3919  * yylex() is called, initialization will occur. */
3920  yy_init_globals( );
3921 
3922  return 0;
3923 }
3924 
3925 /*
3926  * Internal utility routines.
3927  */
3928 
3929 #ifndef yytext_ptr
3930 static void yy_flex_strncpy (char* s1, const char * s2, int n )
3931 {
3932 
3933  int i;
3934  for ( i = 0; i < n; ++i )
3935  s1[i] = s2[i];
3936 }
3937 #endif
3938 
3939 #ifdef YY_NEED_STRLEN
3940 static int yy_flex_strlen (const char * s )
3941 {
3942  int n;
3943  for ( n = 0; s[n]; ++n )
3944  ;
3945 
3946  return n;
3947 }
3948 #endif
3949 
3950 void *yyalloc (yy_size_t size )
3951 {
3952  return malloc(size);
3953 }
3954 
3955 void *yyrealloc (void * ptr, yy_size_t size )
3956 {
3957 
3958  /* The cast to (char *) in the following accommodates both
3959  * implementations that use char* generic pointers, and those
3960  * that use void* generic pointers. It works with the latter
3961  * because both ANSI C and C++ allow castless assignment from
3962  * any pointer type to void*, and deal with argument conversions
3963  * as though doing an assignment.
3964  */
3965  return realloc(ptr, size);
3966 }
3967 
3968 void yyfree (void * ptr )
3969 {
3970  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
3971 }
3972 
3973 #define YYTABLES_NAME "yytables"
3974 
3975 #line 768 "ppl.l"
3976 
3977 /*
3978  **************************************************************************
3979  * Support functions
3980  **************************************************************************
3981  */
3982 
3983 #ifndef ppy_wrap
3984 int ppy_wrap(void)
3985 {
3986  return 1;
3987 }
3988 #endif
3989 
3990 
3991 /*
3992  *-------------------------------------------------------------------------
3993  * Output newlines or set them as continuations
3994  *
3995  * Input: -1 - Don't count this one, but update local position (see pp_dqs)
3996  * 0 - Line-continuation seen and cache output
3997  * 1 - Newline seen and flush output
3998  *-------------------------------------------------------------------------
3999  */
4000 static void newline(int dowrite)
4001 {
4003  pp_status.char_number = 1;
4004 
4005  if(dowrite == -1)
4006  return;
4007 
4008  ncontinuations++;
4009  if(dowrite)
4010  {
4012  put_buffer("\n", 1);
4013  }
4014 }
4015 
4016 
4017 /*
4018  *-------------------------------------------------------------------------
4019  * Make a number out of an any-base and suffixed string
4020  *
4021  * Possible number extensions:
4022  * - "" int
4023  * - "L" long int
4024  * - "LL" long long int
4025  * - "U" unsigned int
4026  * - "UL" unsigned long int
4027  * - "ULL" unsigned long long int
4028  * - "LU" unsigned long int
4029  * - "LLU" unsigned long long int
4030  * - "LUL" invalid
4031  *
4032  * FIXME:
4033  * The sizes of resulting 'int' and 'long' are compiler specific.
4034  * I depend on sizeof(int) > 2 here (although a relatively safe
4035  * assumption).
4036  * Long longs are not yet implemented because this is very compiler
4037  * specific and I don't want to think too much about the problems.
4038  *
4039  *-------------------------------------------------------------------------
4040  */
4041 static int make_number(int radix, YYSTYPE *val, const char *str, int len)
4042 {
4043  int is_l = 0;
4044  int is_ll = 0;
4045  int is_u = 0;
4046  char ext[4];
4047  long l;
4048 
4049  ext[3] = '\0';
4050  ext[2] = toupper(str[len-1]);
4051  ext[1] = len > 1 ? toupper(str[len-2]) : ' ';
4052  ext[0] = len > 2 ? toupper(str[len-3]) : ' ';
4053 
4054  if(!strcmp(ext, "LUL"))
4055  {
4056  ppy_error("Invalid constant suffix");
4057  return 0;
4058  }
4059  else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL"))
4060  {
4061  is_ll++;
4062  is_u++;
4063  }
4064  else if(!strcmp(ext+1, "LU") || !strcmp(ext+1, "UL"))
4065  {
4066  is_l++;
4067  is_u++;
4068  }
4069  else if(!strcmp(ext+1, "LL"))
4070  {
4071  is_ll++;
4072  }
4073  else if(!strcmp(ext+2, "L"))
4074  {
4075  is_l++;
4076  }
4077  else if(!strcmp(ext+2, "U"))
4078  {
4079  is_u++;
4080  }
4081 
4082  if(is_u && is_ll)
4083  {
4084  errno = 0;
4085  val->ull = _strtoui64(str, NULL, radix);
4086  if (val->ull == ULLONG_MAX && errno == ERANGE)
4087  ppy_error("integer constant %s is too large\n", str);
4088  return tULONGLONG;
4089  }
4090  else if(!is_u && is_ll)
4091  {
4092  errno = 0;
4093  val->sll = _strtoi64(str, NULL, radix);
4094  if ((val->sll == LLONG_MIN || val->sll == LLONG_MAX) && errno == ERANGE)
4095  ppy_error("integer constant %s is too large\n", str);
4096  return tSLONGLONG;
4097  }
4098  else if(is_u && is_l)
4099  {
4100  errno = 0;
4101  val->ulong = strtoul(str, NULL, radix);
4102  if (val->ulong == ULONG_MAX && errno == ERANGE)
4103  ppy_error("integer constant %s is too large\n", str);
4104  return tULONG;
4105  }
4106  else if(!is_u && is_l)
4107  {
4108  errno = 0;
4109  val->slong = strtol(str, NULL, radix);
4110  if ((val->slong == LONG_MIN || val->slong == LONG_MAX) && errno == ERANGE)
4111  ppy_error("integer constant %s is too large\n", str);
4112  return tSLONG;
4113  }
4114  else if(is_u && !is_l)
4115  {
4116  unsigned long ul;
4117  errno = 0;
4118  ul = strtoul(str, NULL, radix);
4119  if ((ul == ULONG_MAX && errno == ERANGE) || (ul > UINT_MAX))
4120  ppy_error("integer constant %s is too large\n", str);
4121  val->uint = (unsigned int)ul;
4122  return tUINT;
4123  }
4124 
4125  /* Else it must be an int... */
4126  errno = 0;
4127  l = strtol(str, NULL, radix);
4128  if (((l == LONG_MIN || l == LONG_MAX) && errno == ERANGE) ||
4129  (l > INT_MAX) || (l < INT_MIN))
4130  ppy_error("integer constant %s is too large\n", str);
4131  val->sint = (int)l;
4132  return tSINT;
4133 }
4134 
4135 
4136 /*
4137  *-------------------------------------------------------------------------
4138  * Macro and define expansion support
4139  *
4140  * FIXME: Variable macro arguments.
4141  *-------------------------------------------------------------------------
4142  */
4143 static void expand_special(pp_entry_t *ppp)
4144 {
4145  static char *buf = NULL;
4146  char *new_buf;
4147 
4148  assert(ppp->type == def_special);
4149 
4150  if(!strcmp(ppp->ident, "__LINE__"))
4151  {
4152  new_buf = pp_xrealloc(buf, 32);
4153  if(!new_buf)
4154  return;
4155  buf = new_buf;
4156  sprintf(buf, "%d", pp_status.line_number);
4157  }
4158  else if(!strcmp(ppp->ident, "__FILE__"))
4159  {
4160  new_buf = pp_xrealloc(buf, strlen(pp_status.input) + 3);
4161  if(!new_buf)
4162  return;
4163  buf = new_buf;
4164  sprintf(buf, "\"%s\"", pp_status.input);
4165  }
4166  else
4167  pp_internal_error(__FILE__, __LINE__, "Special macro '%s' not found...\n", ppp->ident);
4168 
4169  if(buf && buf[0])
4170  {
4171  push_buffer(ppp, NULL, NULL, 0);
4173  }
4174 }
4175 
4176 static void expand_define(pp_entry_t *ppp)
4177 {
4178  assert(ppp->type == def_define);
4179 
4180  if(ppp->subst.text && ppp->subst.text[0])
4181  {
4182  push_buffer(ppp, NULL, NULL, 0);
4183  yy_scan_string(ppp->subst.text);
4184  }
4185 }
4186 
4187 static int curdef_idx = 0;
4188 static int curdef_alloc = 0;
4189 static char *curdef_text = NULL;
4190 
4191 static void add_text(const char *str, int len)
4192 {
4193  int new_alloc;
4194  char *new_text;
4195 
4196  if(len == 0)
4197  return;
4199  {
4200  new_alloc = curdef_alloc + ((len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1));
4201  new_text = pp_xrealloc(curdef_text, new_alloc * sizeof(curdef_text[0]));
4202  if(!new_text)
4203  return;
4204  curdef_text = new_text;
4205  curdef_alloc = new_alloc;
4206  if(curdef_alloc > 65536)
4207  ppy_warning("Reallocating macro-expansion buffer larger than 64kB");
4208  }
4210  curdef_idx += len;
4211 }
4212 
4213 static mtext_t *add_expand_text(mtext_t *mtp, macexpstackentry_t *mep, int *nnl)
4214 {
4215  char *cptr;
4216  char *exp;
4217  int tag;
4218  int n;
4219 
4220  if(mtp == NULL)
4221  return NULL;
4222 
4223  switch(mtp->type)
4224  {
4225  case exp_text:
4226  add_text(mtp->subst.text, strlen(mtp->subst.text));
4227  break;
4228 
4229  case exp_stringize:
4230  cptr = mep->args[mtp->subst.argidx];
4231  add_text("\"", 1);
4232  while(*cptr)
4233  {
4234  if(*cptr == '"' || *cptr == '\\')
4235  add_text("\\", 1);
4236  add_text(cptr, 1);
4237  cptr++;
4238  }
4239  add_text("\"", 1);
4240  break;
4241 
4242  case exp_concat:
4243  /* Remove trailing whitespace from current expansion text */
4244  while(curdef_idx)
4245  {
4246  if(isspace(curdef_text[curdef_idx-1] & 0xff))
4247  curdef_idx--;
4248  else
4249  break;
4250  }
4251  /* tag current position and recursively expand the next part */
4252  tag = curdef_idx;
4253  mtp = add_expand_text(mtp->next, mep, nnl);
4254 
4255  /* Now get rid of the leading space of the expansion */
4256  cptr = &curdef_text[tag];
4257  n = curdef_idx - tag;
4258  while(n)
4259  {
4260  if(isspace(*cptr & 0xff))
4261  {
4262  cptr++;
4263  n--;
4264  }
4265  else
4266  break;
4267  }
4268  if(cptr != &curdef_text[tag])
4269  {
4270  memmove(&curdef_text[tag], cptr, n);
4271  curdef_idx -= (curdef_idx - tag) - n;
4272  }
4273  break;
4274 
4275  case exp_subst:
4276  if((mtp->next && mtp->next->type == exp_concat) || (mtp->prev && mtp->prev->type == exp_concat))
4277  exp = mep->args[mtp->subst.argidx];
4278  else
4279  exp = mep->ppargs[mtp->subst.argidx];
4280  if(exp)
4281  {
4282  add_text(exp, strlen(exp));
4283  *nnl -= mep->nnls[mtp->subst.argidx];
4284  cptr = strchr(exp, '\n');
4285  while(cptr)
4286  {
4287  *cptr = ' ';
4288  cptr = strchr(cptr+1, '\n');
4289  }
4290  mep->nnls[mtp->subst.argidx] = 0;
4291  }
4292  break;
4293 
4294  default:
4295  pp_internal_error(__FILE__, __LINE__, "Invalid expansion type (%d) in macro expansion\n", mtp->type);
4296  }
4297  return mtp;
4298 }
4299 
4301 {
4302  mtext_t *mtp;
4303  int n, k;
4304  char *cptr;
4305  int nnl = 0;
4306  pp_entry_t *ppp = mep->ppp;
4307  int nargs = mep->nargs;
4308 
4309  assert(ppp->type == def_macro);
4310  assert(ppp->expanding == 0);
4311 
4312  if((ppp->nargs >= 0 && nargs != ppp->nargs) || (ppp->nargs < 0 && nargs < -ppp->nargs))
4313  {
4314  ppy_error("Too %s macro arguments (%d)", nargs < abs(ppp->nargs) ? "few" : "many", nargs);
4315  return;
4316  }
4317 
4318  for(n = 0; n < nargs; n++)
4319  nnl += mep->nnls[n];
4320 
4321  curdef_idx = 0;
4322 
4323  for(mtp = ppp->subst.mtext; mtp; mtp = mtp->next)
4324  {
4325  if(!(mtp = add_expand_text(mtp, mep, &nnl)))
4326  break;
4327  }
4328 
4329  for(n = 0; n < nnl; n++)
4330  add_text("\n", 1);
4331 
4332  /* To make sure there is room and termination (see below) */
4333  add_text(" \0", 2);
4334 
4335  /* Strip trailing whitespace from expansion */
4336  for(k = curdef_idx, cptr = &curdef_text[curdef_idx-1]; k > 0; k--, cptr--)
4337  {
4338  if(!isspace(*cptr & 0xff))
4339  break;
4340  }
4341 
4342  /*
4343  * We must add *one* whitespace to make sure that there
4344  * is a token-separation after the expansion.
4345  */
4346  *(++cptr) = ' ';
4347  *(++cptr) = '\0';
4348  k++;
4349 
4350  /* Strip leading whitespace from expansion */
4351  for(n = 0, cptr = curdef_text; n < k; n++, cptr++)
4352  {
4353  if(!isspace(*cptr & 0xff))
4354  break;
4355  }
4356 
4357  if(k - n > 0)
4358  {
4359  push_buffer(ppp, NULL, NULL, 0);
4360  /*yy_scan_bytes(curdef_text + n, k - n);*/
4362  }
4363 }
4364 
4365 /*
4366  *-------------------------------------------------------------------------
4367  * String collection routines
4368  *-------------------------------------------------------------------------
4369  */
4370 static void new_string(void)
4371 {
4372 #ifdef DEBUG
4373  if(strbuf_idx)
4374  ppy_warning("new_string: strbuf_idx != 0");
4375 #endif
4376  strbuf_idx = 0;
4378 }
4379 
4380 static void add_string(const char *str, int len)
4381 {
4382  int new_alloc;
4383  char *new_buffer;
4384 
4385  if(len == 0)
4386  return;
4388  {
4389  new_alloc = strbuf_alloc + ((len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1));
4390  new_buffer = pp_xrealloc(strbuffer, new_alloc * sizeof(strbuffer[0]));
4391  if(!new_buffer)
4392  return;
4393  strbuffer = new_buffer;
4394  strbuf_alloc = new_alloc;
4395  if(strbuf_alloc > 65536)
4396  ppy_warning("Reallocating string buffer larger than 64kB");
4397  }
4399  strbuf_idx += len;
4400 }
4401 
4402 static char *get_string(void)
4403 {
4404  char *str = pp_xmalloc(strbuf_idx + 1);
4405  if(!str)
4406  return NULL;
4408  str[strbuf_idx] = '\0';
4409 #ifdef DEBUG
4410  strbuf_idx = 0;
4411 #endif
4412  return str;
4413 }
4414 
4415 static void put_string(void)
4416 {
4418 #ifdef DEBUG
4419  strbuf_idx = 0;
4420 #endif
4421 }
4422 
4423 static int string_start(void)
4424 {
4425  return str_startline;
4426 }
4427 
4428 
4429 /*
4430  *-------------------------------------------------------------------------
4431  * Buffer management
4432  *-------------------------------------------------------------------------
4433  */
4434 static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop)
4435 {
4437  pp_internal_error(__FILE__, __LINE__, "Buffer stack overflow");
4438 
4439  memset(&bufferstack[bufferstackidx], 0, sizeof(bufferstack[0]));
4451 
4452  if(ppp)
4453  ppp->expanding = 1;
4454  else if(filename)
4455  {
4456  /* These will track the ppy_error to the correct file and line */
4457  pp_status.line_number = 1;
4458  pp_status.char_number = 1;
4460  ncontinuations = 0;
4461  }
4462  else if(!pop)
4463  pp_internal_error(__FILE__, __LINE__, "Pushing buffer without knowing where to go to");
4464  bufferstackidx++;
4465 }
4466 
4468 {
4469  if(bufferstackidx < 0)
4470  pp_internal_error(__FILE__, __LINE__, "Bufferstack underflow?");
4471 
4472  if(bufferstackidx == 0)
4473  return NULL;
4474 
4475  bufferstackidx--;
4476 
4479  else
4480  {
4481  includelogicentry_t *iep = NULL;
4482 
4483  if(!bufferstack[bufferstackidx].should_pop)
4484  {
4487 
4488  /* We have EOF, check the include logic */
4490  {
4492  if(ppp)
4493  {
4494  iep = pp_xmalloc(sizeof(includelogicentry_t));
4495  if (iep)
4496  {
4497  iep->ppp = ppp;
4498  ppp->iep = iep;
4500  iep->prev = NULL;
4501  iep->next = pp_includelogiclist;
4502  if(iep->next)
4503  iep->next->prev = iep;
4504  pp_includelogiclist = iep;
4505  }
4506  }
4507  }
4510 
4511  }
4512  if (bufferstack[bufferstackidx].include_filename)
4513  {
4514  free(pp_status.input);
4516  }
4520  if (!iep)
4521  free(bufferstack[bufferstackidx].include_filename);
4522  }
4523 
4526 
4527  if(bufferstack[bufferstackidx].should_pop)
4528  {
4529  if(yy_current_state() == pp_macexp)
4531  else
4532  pp_internal_error(__FILE__, __LINE__, "Pop buffer and state without macro expansion state");
4533  yy_pop_state();
4534  }
4535 
4536  return &bufferstack[bufferstackidx];
4537 }
4538 
4539 
4540 /*
4541  *-------------------------------------------------------------------------
4542  * Macro nestng support
4543  *-------------------------------------------------------------------------
4544  */
4545 static void push_macro(pp_entry_t *ppp)
4546 {
4548  {
4549  ppy_error("Too many nested macros");
4550  return;
4551  }
4552 
4555  return;
4556  memset( macexpstack[macexpstackidx], 0, sizeof(macexpstack[0][0]));
4557  macexpstack[macexpstackidx]->ppp = ppp;
4558  macexpstackidx++;
4559 }
4560 
4562 {
4563  return macexpstackidx > 0 ? macexpstack[macexpstackidx-1] : NULL;
4564 }
4565 
4567 {
4568  if(macexpstackidx <= 0)
4569  pp_internal_error(__FILE__, __LINE__, "Macro expansion stack underflow\n");
4570  return macexpstack[--macexpstackidx];
4571 }
4572 
4574 {
4575  int i;
4576 
4577  for(i = 0; i < mep->nargs; i++)
4578  free(mep->args[i]);
4579  free(mep->args);
4580  free(mep->nnls);
4581  free(mep->curarg);
4582  free(mep);
4583 }
4584 
4585 static void add_text_to_macro(const char *text, int len)
4586 {
4587  macexpstackentry_t *mep = top_macro();
4588 
4589  assert(mep->ppp->expanding == 0);
4590 
4591  if(mep->curargalloc - mep->curargsize <= len+1) /* +1 for '\0' */
4592  {
4593  char *new_curarg;
4594  int new_alloc = mep->curargalloc + ((ALLOCBLOCKSIZE > len+1) ? ALLOCBLOCKSIZE : len+1);
4595  new_curarg = pp_xrealloc(mep->curarg, new_alloc * sizeof(mep->curarg[0]));
4596  if(!new_curarg)
4597  return;
4598  mep->curarg = new_curarg;
4599  mep->curargalloc = new_alloc;
4600  }
4601  memcpy(mep->curarg + mep->curargsize, text, len);
4602  mep->curargsize += len;
4603  mep->curarg[mep->curargsize] = '\0';
4604 }
4605 
4606 static void macro_add_arg(int last)
4607 {
4608  int nnl = 0;
4609  char *cptr;
4610  char **new_args, **new_ppargs;
4611  int *new_nnls;
4612  macexpstackentry_t *mep = top_macro();
4613 
4614  assert(mep->ppp->expanding == 0);
4615 
4616  new_args = pp_xrealloc(mep->args, (mep->nargs+1) * sizeof(mep->args[0]));
4617  if(!new_args)
4618  return;
4619  mep->args = new_args;
4620 
4621  new_ppargs = pp_xrealloc(mep->ppargs, (mep->nargs+1) * sizeof(mep->ppargs[0]));
4622  if(!new_ppargs)
4623  return;
4624  mep->ppargs = new_ppargs;
4625 
4626  new_nnls = pp_xrealloc(mep->nnls, (mep->nargs+1) * sizeof(mep->nnls[0]));
4627  if(!new_nnls)
4628  return;
4629  mep->nnls = new_nnls;
4630 
4631  mep->args[mep->nargs] = pp_xstrdup(mep->curarg ? mep->curarg : "");
4632  if(!mep->args[mep->nargs])
4633  return;
4634  cptr = mep->args[mep->nargs]-1;
4635  while((cptr = strchr(cptr+1, '\n')))
4636  {
4637  nnl++;
4638  }
4639  mep->nnls[mep->nargs] = nnl;
4640  mep->nargs++;
4641  free(mep->curarg);
4642  mep->curargalloc = mep->curargsize = 0;
4643  mep->curarg = NULL;
4644 
4645  /* Each macro argument must be expanded to cope with stingize */
4646  if(last || mep->args[mep->nargs-1][0])
4647  {
4649  push_buffer(NULL, NULL, NULL, last ? 2 : 1);
4650  yy_scan_string(mep->args[mep->nargs-1]);
4651  /*mep->bufferstackidx = bufferstackidx; But not nested! */
4652  }
4653 }
4654 
4655 static void macro_add_expansion(void)
4656 {
4657  macexpstackentry_t *mep = top_macro();
4658 
4659  assert(mep->ppp->expanding == 0);
4660 
4661  mep->ppargs[mep->nargs-1] = pp_xstrdup(mep->curarg ? mep->curarg : "");
4662  free(mep->curarg);
4663  mep->curargalloc = mep->curargsize = 0;
4664  mep->curarg = NULL;
4665 }
4666 
4667 
4668 /*
4669  *-------------------------------------------------------------------------
4670  * Output management
4671  *-------------------------------------------------------------------------
4672  */
4673 static void put_buffer(const char *s, int len)
4674 {
4675  if(top_macro())
4677  else
4678  wpp_write(s, len);
4679 }
4680 
4681 
4682 /*
4683  *-------------------------------------------------------------------------
4684  * Include management
4685  *-------------------------------------------------------------------------
4686  */
4687 void pp_do_include(char *fname, int type)
4688 {
4689  char *newpath;
4690  int n;
4691  includelogicentry_t *iep;
4692  void *fp;
4693 
4694  if(!fname)
4695  return;
4696 
4697  for(iep = pp_includelogiclist; iep; iep = iep->next)
4698  {
4699  if(!strcmp(iep->filename, fname))
4700  {
4701  /*
4702  * We are done. The file was included before.
4703  * If the define was deleted, then this entry would have
4704  * been deleted too.
4705  */
4706  free(fname);
4707  return;
4708  }
4709  }
4710 
4711  n = strlen(fname);
4712 
4713  if(n <= 2)
4714  {
4715  ppy_error("Empty include filename");
4716  free(fname);
4717  return;
4718  }
4719 
4720  /* Undo the effect of the quotation */
4721  fname[n-1] = '\0';
4722 
4723  if((fp = pp_open_include(fname+1, type, pp_status.input, &newpath)) == NULL)
4724  {
4725  ppy_error("Unable to open include file %s", fname+1);
4726  free(fname);
4727  return;
4728  }
4729 
4730  fname[n-1] = *fname; /* Redo the quotes */
4731  push_buffer(NULL, newpath, fname, 0);
4733  pp_incl_state.state = 0;
4735 
4736  pp_status.file = fp;
4738 
4739  pp_writestring("# 1 \"%s\" 1%s\n", newpath, type ? "" : " 3");
4740 }
4741 
4742 /*
4743  *-------------------------------------------------------------------------
4744  * Push/pop preprocessor ignore state when processing conditionals
4745  * which are false.
4746  *-------------------------------------------------------------------------
4747  */
4749 {
4751 }
4752 
4754 {
4755  yy_pop_state();
4756 }
4757 
#define realloc
Definition: debug_ros.c:6
#define YY_BREAK
Definition: ppl.yy.c:1810
unsigned char flex_uint8_t
Definition: macro.lex.yy.c:54
unsigned short int flex_uint16_t
Definition: ppl.yy.c:314
#define yy_flush_buffer
Definition: ppl.yy.c:15
#define RCINCL
Definition: ppl.yy.c:1628
int nargs
Definition: wpp_private.h:101
#define abs(i)
Definition: fconv.c:206
#define vsnprintf
Definition: tif_win32.c:406
char * curarg
Definition: ppl.yy.c:1487
#define BUFFERINITIALCAPACITY
Definition: ppl.yy.c:1554
#define YY_START
Definition: ppl.yy.c:382
int WINAPIV ppy_error(const char *msg,...)
Definition: compiler.c:135
#define YY_DECL
Definition: ppl.yy.c:1798
FILE * yy_input_file
Definition: macro.lex.yy.c:192
#define isspace(c)
Definition: acclib.h:69
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define pp_line
Definition: ppl.yy.c:1625
static const YY_CHAR yy_ec[256]
Definition: ppl.yy.c:673
static const flex_int16_t yy_nxt[1970]
Definition: ppl.yy.c:824
UINT32 strtoul(const char *String, char **Terminator, UINT32 Base)
Definition: utclib.c:696
yy_size_t yy_n_chars
Definition: macro.lex.yy.c:205
union pp_entry::@239 subst
struct S2 s2
pp_entry_t * define
Definition: ppl.yy.c:1456
static int * yy_start_stack
Definition: ppl.yy.c:1708
static const flex_int16_t yy_base[467]
Definition: ppl.yy.c:714
struct yy_buffer_state * YY_BUFFER_STATE
Definition: ppl.yy.c:409
void WINAPIV pp_internal_error(const char *file, int line, const char *s,...)
Definition: preproc.c:438
int pp_get_if_depth(void)
Definition: preproc.c:433
int yy_state_type
Definition: ppl.yy.c:589
char * text
Definition: wpp_private.h:104
static char yy_hold_char
Definition: ppl.yy.c:528
static bufferstackentry_t * pop_buffer(void)
Definition: ppl.yy.c:4467
static static const char __ms_va_list
Definition: printf.c:76
#define INT_MAX
Definition: limits.h:40
#define strcasecmp
Definition: fake.h:9
static int str_startline
Definition: ppl.yy.c:1528
static int strbuf_alloc
Definition: ppl.yy.c:1526
#define YY_EXTRA_TYPE
Definition: ppl.yy.c:1639
unsigned char YY_CHAR
Definition: macro.lex.yy.c:336
static int string_start(void)
Definition: ppl.yy.c:4423
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static void yynoreturn yy_fatal_error(const char *msg)
#define pp_macscan
Definition: ppl.yy.c:1619
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
POINT last
Definition: font.c:46
static int strbuf_idx
Definition: ppl.yy.c:1525
#define pp_def
Definition: ppl.yy.c:1614
void * pp_xrealloc(void *p, size_t size)
Definition: preproc.c:59
#define yypop_buffer_state
Definition: ppl.yy.c:19
Definition: ppy.tab.c:209
const WCHAR * text
Definition: package.c:1827
static int bufferstackidx
Definition: ppl.yy.c:1534
static int yy_start
Definition: ppl.yy.c:535
Definition: ppy.tab.c:245
static void expand_macro(macexpstackentry_t *mep)
Definition: ppl.yy.c:4300
#define pp_iqs
Definition: ppl.yy.c:1612
#define LLONG_MAX
Definition: ppl.yy.c:1211
#define free
Definition: debug_ros.c:5
char * ident
Definition: wpp_private.h:99
_Check_return_ __MINGW_EXTENSION _CRTIMP __int64 __cdecl _strtoi64(_In_z_ const char *_String, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
GLintptr offset
Definition: glext.h:5920
#define yyget_leng
Definition: ppl.yy.c:195
int line_number
Definition: wpp_private.h:222
#define MACROPARENTHESES()
Definition: ppl.yy.c:1490
#define YY_AT_BOL()
Definition: ppl.yy.c:582
#define yyleng
Definition: ppl.yy.c:23
#define yynoreturn
Definition: ppl.yy.c:362
GLdouble n
Definition: glext.h:7729
#define yy_scan_bytes
Definition: ppl.yy.c:13
static YY_BUFFER_STATE * yy_buffer_stack
Definition: ppl.yy.c:511
size_t yy_size_t
Definition: macro.lex.yy.c:159
#define pp_ifignored
Definition: ppl.yy.c:1623
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
Definition: ecma_167.h:138
int argidx
Definition: wpp_private.h:81
GLuint buffer
Definition: glext.h:5915
#define yyget_in
Definition: ppl.yy.c:171
static char * yy_c_buf_p
Definition: ppl.yy.c:533
#define pp_define
Definition: ppl.yy.c:1615
#define yyrestart
Definition: ppl.yy.c:27
FILE * stdin
#define pp_endif
Definition: ppl.yy.c:1624
int line_number
Definition: parser.yy.c:775
#define yyrealloc
Definition: ppl.yy.c:31
#define yyget_text
Definition: ppl.yy.c:201
#define yyget_extra
Definition: ppl.yy.c:159
int errno
static const flex_int16_t yy_chk[1970]
Definition: ppl.yy.c:1044
unsigned short int uint16_t
Definition: acefiex.h:54
#define yy_flex_debug
Definition: ppl.yy.c:21
#define pp_eol
Definition: ppl.yy.c:1608
char * cptr
Definition: ppy.tab.c:267
static int make_number(int radix, YYSTYPE *val, const char *str, int len)
const char * filename
Definition: ioapi.h:135
static calc_node_t * pop(void)
Definition: rpn_ieee.c:90
#define YY_INPUT(buf, result, max_size)
Definition: ppl.yy.c:1549
#define yyget_lineno
Definition: ppl.yy.c:207
unsigned int flex_uint32_t
Definition: ppl.yy.c:315
static int macexpstackidx
Definition: ppl.yy.c:1531
static yy_state_type yy_last_accepting_state
Definition: ppl.yy.c:1264
static char * get_string(void)
Definition: ppl.yy.c:4402
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
char * filename
Definition: ppl.yy.c:1459
int expanding
Definition: wpp_private.h:106
FILE * stdout
#define pp_ignore
Definition: ppl.yy.c:1627
#define YY_STATE_EOF(state)
Definition: ppl.yy.c:385
#define pp_inc
Definition: ppl.yy.c:1609
static size_t yy_buffer_stack_max
Definition: ppl.yy.c:510
#define YY_DO_BEFORE_ACTION
Definition: ppl.yy.c:608
include_state_t incl
Definition: ppl.yy.c:1464
#define yytext_ptr
Definition: ppl.yy.c:598
yy_size_t yy_buf_size
Definition: macro.lex.yy.c:200
#define yyset_debug
Definition: ppl.yy.c:153
#define sprintf(buf, format,...)
Definition: sprintf.c:55
void ppy__switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: ppl.yy.c:3165
#define YY_CURRENT_BUFFER
Definition: ppl.yy.c:519
static int yy_get_next_buffer(void)
char * yy_bp
Definition: ppl.yy.c:1824
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void * pp_open_include(const char *name, int type, const char *parent_name, char **newpath)
Definition: preproc.c:290
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
#define yy_scan_string
Definition: ppl.yy.c:12
Definition: ppy.tab.c:247
_CRTIMP void __cdecl perror(_In_opt_z_ const char *_ErrMsg)
GLuint base
Definition: 3dtext.c:35
static int ncontinuations
Definition: ppl.yy.c:1523
int yy_act
Definition: ppl.yy.c:1825
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define YY_RULE_SETUP
Definition: ppl.yy.c:1813
#define pp_sqs
Definition: ppl.yy.c:1611
static char * strbuffer
Definition: ppl.yy.c:1527
static PVOID ptr
Definition: dispmode.c:27
const WCHAR * str
int char_number
Definition: wpp_private.h:223
int yy_state_type
Definition: macro.lex.yy.c:340
smooth NULL
Definition: ftsmooth.c:416
#define YY_CURRENT_BUFFER_LVALUE
Definition: ppl.yy.c:525
char ext[3]
Definition: mkdosfs.c:358
#define yylineno
Definition: ppl.yy.c:25
static char * yy_last_accepting_cpos
Definition: ppl.yy.c:1265
#define yyfree
Definition: ppl.yy.c:32
static const flex_int16_t yy_def[467]
Definition: ppl.yy.c:769
Definition: parser.c:48
#define BEGIN
Definition: ppl.yy.c:377
Definition: ppy.tab.c:248
static int yy_init
Definition: ppl.yy.c:534
static yy_state_type yy_get_previous_state(void)
#define yyset_out
Definition: ppl.yy.c:189