ReactOS  0.4.14-dev-608-gd495a4f
parser.yy.c
Go to the documentation of this file.
1 #line 2 "parser.yy.c"
2 
3 #line 4 "parser.yy.c"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define yy_create_buffer parser__create_buffer
10 #define yy_delete_buffer parser__delete_buffer
11 #define yy_flex_debug parser__flex_debug
12 #define yy_init_buffer parser__init_buffer
13 #define yy_flush_buffer parser__flush_buffer
14 #define yy_load_buffer_state parser__load_buffer_state
15 #define yy_switch_to_buffer parser__switch_to_buffer
16 #define yyin parser_in
17 #define yyleng parser_leng
18 #define yylex parser_lex
19 #define yylineno parser_lineno
20 #define yyout parser_out
21 #define yyrestart parser_restart
22 #define yytext parser_text
23 #define yywrap parser_wrap
24 #define yyalloc parser_alloc
25 #define yyrealloc parser_realloc
26 #define yyfree parser_free
27 
28 #define FLEX_SCANNER
29 #define YY_FLEX_MAJOR_VERSION 2
30 #define YY_FLEX_MINOR_VERSION 5
31 #define YY_FLEX_SUBMINOR_VERSION 37
32 #if YY_FLEX_SUBMINOR_VERSION > 0
33 #define FLEX_BETA
34 #endif
35 
36 /* First, we deal with platform-specific or compiler-specific issues. */
37 
38 /* begin standard C headers. */
39 #include <stdio.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <stdlib.h>
43 
44 /* end standard C headers. */
45 
46 /* flex integer type definitions */
47 
48 #ifndef FLEXINT_H
49 #define FLEXINT_H
50 
51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52 
53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54 
55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56  * if you want the limit (max/min) macros for int types.
57  */
58 #ifndef __STDC_LIMIT_MACROS
59 #define __STDC_LIMIT_MACROS 1
60 #endif
61 
62 #include <inttypes.h>
63 typedef int8_t flex_int8_t;
64 typedef uint8_t flex_uint8_t;
65 typedef int16_t flex_int16_t;
66 typedef uint16_t flex_uint16_t;
67 typedef int32_t flex_int32_t;
68 typedef uint32_t flex_uint32_t;
69 #else
70 typedef signed char flex_int8_t;
71 typedef short int flex_int16_t;
72 typedef int flex_int32_t;
73 typedef unsigned char flex_uint8_t;
74 typedef unsigned short int flex_uint16_t;
75 typedef unsigned int flex_uint32_t;
76 
77 /* Limits of integral types. */
78 #ifndef INT8_MIN
79 #define INT8_MIN (-128)
80 #endif
81 #ifndef INT16_MIN
82 #define INT16_MIN (-32767-1)
83 #endif
84 #ifndef INT32_MIN
85 #define INT32_MIN (-2147483647-1)
86 #endif
87 #ifndef INT8_MAX
88 #define INT8_MAX (127)
89 #endif
90 #ifndef INT16_MAX
91 #define INT16_MAX (32767)
92 #endif
93 #ifndef INT32_MAX
94 #define INT32_MAX (2147483647)
95 #endif
96 #ifndef UINT8_MAX
97 #define UINT8_MAX (255U)
98 #endif
99 #ifndef UINT16_MAX
100 #define UINT16_MAX (65535U)
101 #endif
102 #ifndef UINT32_MAX
103 #define UINT32_MAX (4294967295U)
104 #endif
105 
106 #endif /* ! C99 */
107 
108 #endif /* ! FLEXINT_H */
109 
110 #ifdef __cplusplus
111 
112 /* The "const" storage-class-modifier is valid. */
113 #define YY_USE_CONST
114 
115 #else /* ! __cplusplus */
116 
117 /* C99 requires __STDC__ to be defined as 1. */
118 #if defined (__STDC__)
119 
120 #define YY_USE_CONST
121 
122 #endif /* defined (__STDC__) */
123 #endif /* ! __cplusplus */
124 
125 #ifdef YY_USE_CONST
126 #define yyconst const
127 #else
128 #define yyconst
129 #endif
130 
131 /* Returned upon end-of-file. */
132 #define YY_NULL 0
133 
134 /* Promotes a possibly negative, possibly signed char to an unsigned
135  * integer for use as an array index. If the signed char is negative,
136  * we want to instead treat it as an 8-bit unsigned char, hence the
137  * double cast.
138  */
139 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
140 
141 /* Enter a start condition. This macro really ought to take a parameter,
142  * but we do it the disgusting crufty way forced on us by the ()-less
143  * definition of BEGIN.
144  */
145 #define BEGIN (yy_start) = 1 + 2 *
146 
147 /* Translate the current start state into a value that can be later handed
148  * to BEGIN to return to the state. The YYSTATE alias is for lex
149  * compatibility.
150  */
151 #define YY_START (((yy_start) - 1) / 2)
152 #define YYSTATE YY_START
153 
154 /* Action number for EOF rule of a given start state. */
155 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
156 
157 /* Special action meaning "start processing a new file". */
158 #define YY_NEW_FILE parser_restart(parser_in )
159 
160 #define YY_END_OF_BUFFER_CHAR 0
161 
162 /* Size of default input buffer. */
163 #ifndef YY_BUF_SIZE
164 #define YY_BUF_SIZE 16384
165 #endif
166 
167 /* The state buf must be large enough to hold one state per character in the main buffer.
168  */
169 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
170 
171 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
172 #define YY_TYPEDEF_YY_BUFFER_STATE
173 typedef struct yy_buffer_state *YY_BUFFER_STATE;
174 #endif
175 
176 #ifndef YY_TYPEDEF_YY_SIZE_T
177 #define YY_TYPEDEF_YY_SIZE_T
178 typedef size_t yy_size_t;
179 #endif
180 
181 extern yy_size_t parser_leng;
182 
183 extern FILE *parser_in, *parser_out;
184 
185 #define EOB_ACT_CONTINUE_SCAN 0
186 #define EOB_ACT_END_OF_FILE 1
187 #define EOB_ACT_LAST_MATCH 2
188 
189  #define YY_LESS_LINENO(n)
190 
191 /* Return all but the first "n" matched characters back to the input stream. */
192 #define yyless(n) \
193  do \
194  { \
195  /* Undo effects of setting up parser_text. */ \
196  int yyless_macro_arg = (n); \
197  YY_LESS_LINENO(yyless_macro_arg);\
198  *yy_cp = (yy_hold_char); \
199  YY_RESTORE_YY_MORE_OFFSET \
200  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
201  YY_DO_BEFORE_ACTION; /* set up parser_text again */ \
202  } \
203  while ( 0 )
204 
205 #define unput(c) yyunput( c, (yytext_ptr) )
206 
207 #ifndef YY_STRUCT_YY_BUFFER_STATE
208 #define YY_STRUCT_YY_BUFFER_STATE
209 struct yy_buffer_state
210  {
211  FILE *yy_input_file;
212 
213  char *yy_ch_buf; /* input buffer */
214  char *yy_buf_pos; /* current position in input buffer */
215 
216  /* Size of input buffer in bytes, not including room for EOB
217  * characters.
218  */
219  yy_size_t yy_buf_size;
220 
221  /* Number of characters read into yy_ch_buf, not including EOB
222  * characters.
223  */
224  yy_size_t yy_n_chars;
225 
226  /* Whether we "own" the buffer - i.e., we know we created it,
227  * and can realloc() it to grow it, and should free() it to
228  * delete it.
229  */
230  int yy_is_our_buffer;
231 
232  /* Whether this is an "interactive" input source; if so, and
233  * if we're using stdio for input, then we want to use getc()
234  * instead of fread(), to make sure we stop fetching input after
235  * each newline.
236  */
237  int yy_is_interactive;
238 
239  /* Whether we're considered to be at the beginning of a line.
240  * If so, '^' rules will be active on the next match, otherwise
241  * not.
242  */
243  int yy_at_bol;
244 
245  int yy_bs_lineno;
246  int yy_bs_column;
248  /* Whether to try to fill the input buffer when we reach the
249  * end of it.
250  */
251  int yy_fill_buffer;
252 
253  int yy_buffer_status;
254 
255 #define YY_BUFFER_NEW 0
256 #define YY_BUFFER_NORMAL 1
257  /* When an EOF's been seen but there's still some text to process
258  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
259  * shouldn't try reading from the input source any more. We might
260  * still have a bunch of tokens to match, though, because of
261  * possible backing-up.
262  *
263  * When we actually see the EOF, we change the status to "new"
264  * (via parser_restart()), so that the user can continue scanning by
265  * just pointing parser_in at a new input file.
266  */
267 #define YY_BUFFER_EOF_PENDING 2
268 
269  };
270 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
271 
272 /* Stack of input buffers. */
273 static size_t yy_buffer_stack_top = 0;
274 static size_t yy_buffer_stack_max = 0;
275 static YY_BUFFER_STATE * yy_buffer_stack = 0;
277 /* We provide macros for accessing buffer states in case in the
278  * future we want to put the buffer states in a more general
279  * "scanner state".
280  *
281  * Returns the top of the stack, or NULL.
282  */
283 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
284  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
285  : NULL)
286 
287 /* Same as previous macro, but useful when we know that the buffer stack is not
288  * NULL or when we need an lvalue. For internal use only.
289  */
290 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291 
292 /* yy_hold_char holds the character lost when parser_text is formed. */
293 static char yy_hold_char;
294 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
295 yy_size_t parser_leng;
296 
297 /* Points to current character in buffer. */
298 static char *yy_c_buf_p = (char *) 0;
299 static int yy_init = 0; /* whether we need to initialize */
300 static int yy_start = 0; /* start state number */
301 
302 /* Flag which is used to allow parser_wrap()'s to do buffer switches
303  * instead of setting up a fresh parser_in. A bit of a hack ...
304  */
305 static int yy_did_buffer_switch_on_eof;
306 
307 void parser_restart (FILE *input_file );
308 void parser__switch_to_buffer (YY_BUFFER_STATE new_buffer );
309 YY_BUFFER_STATE parser__create_buffer (FILE *file,int size );
310 void parser__delete_buffer (YY_BUFFER_STATE b );
311 void parser__flush_buffer (YY_BUFFER_STATE b );
312 void parser_push_buffer_state (YY_BUFFER_STATE new_buffer );
313 void parser_pop_buffer_state (void );
314 
315 static void parser_ensure_buffer_stack (void );
316 static void parser__load_buffer_state (void );
317 static void parser__init_buffer (YY_BUFFER_STATE b,FILE *file );
318 
319 #define YY_FLUSH_BUFFER parser__flush_buffer(YY_CURRENT_BUFFER )
320 
321 YY_BUFFER_STATE parser__scan_buffer (char *base,yy_size_t size );
322 YY_BUFFER_STATE parser__scan_string (yyconst char *yy_str );
323 YY_BUFFER_STATE parser__scan_bytes (yyconst char *bytes,yy_size_t len );
324 
325 void *parser_alloc (yy_size_t );
326 void *parser_realloc (void *,yy_size_t );
327 void parser_free (void * );
328 
329 #define yy_new_buffer parser__create_buffer
330 
331 #define yy_set_interactive(is_interactive) \
332  { \
333  if ( ! YY_CURRENT_BUFFER ){ \
334  parser_ensure_buffer_stack (); \
335  YY_CURRENT_BUFFER_LVALUE = \
336  parser__create_buffer(parser_in,YY_BUF_SIZE ); \
337  } \
338  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
339  }
340 
341 #define yy_set_bol(at_bol) \
342  { \
343  if ( ! YY_CURRENT_BUFFER ){\
344  parser_ensure_buffer_stack (); \
345  YY_CURRENT_BUFFER_LVALUE = \
346  parser__create_buffer(parser_in,YY_BUF_SIZE ); \
347  } \
348  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
349  }
350 
351 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352 
353 /* Begin user sect3 */
354 
355 typedef unsigned char YY_CHAR;
356 
357 FILE *parser_in = (FILE *) 0, *parser_out = (FILE *) 0;
358 
359 typedef int yy_state_type;
360 
361 extern int parser_lineno;
362 
363 int parser_lineno = 1;
364 
365 extern char *parser_text;
366 #define yytext_ptr parser_text
367 
368 static yy_state_type yy_get_previous_state (void );
369 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
370 static int yy_get_next_buffer (void );
371 static void yy_fatal_error (yyconst char msg[] );
372 
373 /* Done after the current pattern has been matched and before the
374  * corresponding action - sets up parser_text.
375  */
376 #define YY_DO_BEFORE_ACTION \
377  (yytext_ptr) = yy_bp; \
378  parser_leng = (size_t) (yy_cp - yy_bp); \
379  (yy_hold_char) = *yy_cp; \
380  *yy_cp = '\0'; \
381  (yy_c_buf_p) = yy_cp;
382 
383 #define YY_NUM_RULES 41
384 #define YY_END_OF_BUFFER 42
385 /* This struct is not used in this scanner,
386  but its presence is necessary. */
387 struct yy_trans_info
388  {
389  flex_int32_t yy_verify;
390  flex_int32_t yy_nxt;
391  };
392 static yyconst flex_int16_t yy_accept[210] =
393  { 0,
394  0, 0, 0, 0, 0, 0, 0, 0, 3, 3,
395  6, 6, 0, 0, 42, 40, 29, 28, 40, 8,
396  40, 12, 40, 40, 24, 24, 40, 40, 40, 27,
397  27, 27, 19, 40, 29, 2, 27, 18, 41, 9,
398  18, 11, 24, 24, 21, 21, 21, 20, 29, 2,
399  3, 6, 6, 6, 13, 18, 34, 38, 32, 0,
400  0, 24, 24, 24, 0, 30, 36, 33, 35, 31,
401  27, 10, 27, 37, 0, 2, 0, 2, 0, 27,
402  17, 15, 14, 24, 0, 21, 21, 0, 2, 2,
403  3, 6, 6, 6, 16, 39, 25, 24, 24, 23,
404 
405  27, 0, 0, 27, 24, 0, 21, 6, 6, 0,
406  23, 23, 27, 0, 0, 27, 24, 0, 21, 6,
407  6, 0, 25, 23, 23, 27, 0, 0, 27, 24,
408  0, 21, 6, 5, 27, 0, 0, 27, 24, 0,
409  21, 6, 5, 27, 0, 0, 27, 24, 0, 21,
410  6, 27, 0, 1, 27, 24, 0, 21, 6, 27,
411  0, 27, 0, 24, 4, 0, 26, 0, 27, 0,
412  4, 0, 27, 0, 0, 0, 0, 0, 0, 0,
413  0, 0, 0, 0, 0, 0, 0, 0, 0, 7,
414  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
415 
416  0, 0, 0, 0, 0, 0, 0, 22, 0
417  } ;
418 
419 static yyconst flex_int32_t yy_ec[256] =
420  { 0,
421  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
422  1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
423  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424  1, 2, 4, 5, 6, 1, 1, 7, 8, 9,
425  1, 1, 10, 1, 11, 12, 1, 13, 14, 14,
426  14, 14, 14, 14, 14, 14, 14, 1, 1, 15,
427  16, 17, 1, 1, 18, 19, 19, 19, 20, 21,
428  22, 22, 22, 22, 22, 23, 22, 22, 22, 22,
429  22, 24, 25, 22, 26, 22, 22, 27, 28, 22,
430  29, 30, 31, 1, 32, 1, 33, 19, 34, 35,
431 
432  36, 19, 37, 38, 39, 22, 22, 40, 41, 42,
433  43, 44, 22, 45, 22, 46, 47, 22, 48, 49,
434  22, 22, 1, 50, 1, 1, 1, 1, 1, 1,
435  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
436  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
437  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
438  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
439  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
440  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
441  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442 
443  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
444  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448  1, 1, 1, 1, 1
449  } ;
450 
451 static yyconst flex_int32_t yy_meta[51] =
452  { 0,
453  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
454  1, 1, 3, 3, 1, 1, 1, 3, 3, 3,
455  3, 4, 4, 4, 4, 4, 4, 4, 1, 1,
456  1, 4, 3, 3, 3, 3, 4, 4, 4, 4,
457  4, 4, 4, 4, 4, 4, 4, 4, 4, 1
458  } ;
459 
460 static yyconst flex_int16_t yy_base[251] =
461  { 0,
462  0, 49, 49, 53, 54, 57, 90, 59, 404, 397,
463  138, 139, 140, 141, 399, 677, 677, 677, 381, 677,
464  389, 677, 378, 382, 176, 138, 48, 377, 50, 0,
465  387, 372, 677, 335, 151, 152, 345, 677, 677, 677,
466  48, 677, 213, 118, 250, 0, 378, 677, 66, 377,
467  0, 0, 339, 337, 677, 138, 677, 677, 677, 363,
468  56, 181, 129, 48, 0, 677, 677, 677, 677, 677,
469  0, 677, 351, 677, 156, 154, 332, 157, 325, 328,
470  677, 677, 677, 274, 0, 309, 0, 71, 360, 359,
471  0, 0, 325, 316, 677, 677, 199, 677, 677, 137,
472 
473  337, 320, 317, 309, 333, 0, 368, 308, 296, 195,
474  191, 142, 322, 298, 300, 304, 392, 0, 427, 303,
475  288, 61, 230, 677, 677, 309, 299, 285, 281, 451,
476  0, 486, 288, 0, 296, 275, 284, 271, 510, 0,
477  545, 279, 0, 294, 266, 302, 269, 569, 0, 604,
478  263, 271, 265, 294, 254, 292, 279, 278, 239, 80,
479  244, 239, 0, 351, 0, 164, 677, 238, 245, 0,
480  0, 244, 274, 0, 273, 167, 0, 241, 262, 227,
481  0, 225, 0, 226, 0, 219, 0, 222, 247, 677,
482  0, 0, 0, 0, 246, 0, 0, 0, 0, 0,
483 
484  0, 0, 0, 0, 0, 0, 0, 677, 677, 640,
485  644, 648, 650, 654, 656, 660, 664, 253, 252, 251,
486  249, 248, 668, 242, 239, 238, 672, 234, 227, 226,
487  221, 219, 217, 215, 211, 208, 207, 197, 188, 180,
488  178, 172, 171, 169, 144, 83, 82, 78, 77, 73
489  } ;
490 
491 static yyconst flex_int16_t yy_def[251] =
492  { 0,
493  209, 1, 210, 210, 210, 210, 209, 7, 211, 211,
494  212, 212, 210, 210, 209, 209, 209, 209, 209, 209,
495  209, 209, 209, 209, 209, 209, 209, 209, 209, 213,
496  213, 213, 209, 209, 209, 209, 213, 209, 209, 209,
497  214, 209, 209, 43, 215, 215, 215, 209, 209, 209,
498  216, 217, 217, 217, 209, 214, 209, 209, 209, 209,
499  209, 209, 209, 209, 218, 209, 209, 209, 209, 209,
500  213, 209, 213, 209, 209, 209, 209, 209, 209, 213,
501  209, 209, 209, 209, 219, 215, 215, 209, 209, 209,
502  216, 217, 217, 217, 209, 209, 209, 209, 209, 218,
503 
504  213, 209, 209, 213, 209, 220, 215, 217, 217, 209,
505  209, 209, 213, 209, 209, 213, 209, 221, 215, 217,
506  217, 209, 209, 209, 209, 213, 209, 209, 213, 209,
507  222, 215, 217, 223, 213, 209, 209, 213, 209, 224,
508  215, 217, 223, 213, 209, 209, 213, 209, 225, 215,
509  217, 213, 209, 209, 213, 209, 209, 215, 217, 213,
510  209, 213, 226, 209, 227, 209, 209, 209, 213, 228,
511  227, 209, 213, 229, 209, 209, 230, 209, 209, 209,
512  231, 209, 232, 209, 233, 209, 234, 209, 209, 209,
513  235, 236, 237, 238, 209, 239, 240, 241, 242, 243,
514 
515  244, 245, 246, 247, 248, 249, 250, 209, 0, 209,
516  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
517  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
518  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
519  209, 209, 209, 209, 209, 209, 209, 209, 209, 209
520  } ;
521 
522 static yyconst flex_int16_t yy_nxt[728] =
523  { 0,
524  16, 17, 18, 19, 20, 16, 21, 22, 16, 16,
525  23, 24, 25, 26, 27, 28, 29, 30, 30, 30,
526  30, 30, 31, 30, 32, 30, 30, 30, 33, 16,
527  16, 30, 30, 30, 30, 30, 30, 30, 30, 30,
528  30, 30, 30, 30, 30, 30, 30, 30, 30, 34,
529  35, 39, 82, 40, 36, 39, 39, 40, 42, 39,
530  49, 42, 66, 67, 50, 69, 70, 88, 97, 97,
531  99, 89, 88, 123, 123, 208, 89, 83, 41, 207,
532  206, 166, 41, 41, 205, 204, 41, 99, 167, 37,
533  16, 17, 18, 19, 20, 16, 21, 22, 16, 16,
534 
535  23, 24, 43, 44, 27, 28, 29, 45, 45, 45,
536  45, 46, 47, 46, 46, 46, 46, 46, 33, 16,
537  48, 46, 45, 45, 45, 45, 46, 46, 46, 46,
538  46, 46, 46, 46, 46, 46, 46, 46, 46, 34,
539  39, 39, 39, 39, 209, 95, 203, 55, 55, 61,
540  62, 62, 75, 78, 98, 78, 76, 75, 78, 111,
541  63, 76, 112, 64, 125, 166, 209, 83, 176, 56,
542  56, 202, 167, 201, 200, 98, 111, 63, 53, 53,
543  199, 125, 198, 112, 64, 54, 54, 61, 62, 62,
544  197, 77, 61, 62, 62, 79, 77, 79, 63, 195,
545 
546  79, 64, 65, 63, 122, 122, 64, 123, 123, 194,
547  193, 97, 97, 192, 178, 63, 124, 189, 110, 187,
548  63, 185, 64, 183, 65, 84, 84, 64, 179, 177,
549  85, 85, 85, 85, 110, 63, 174, 124, 64, 65,
550  170, 157, 123, 123, 149, 85, 85, 85, 85, 110,
551  140, 131, 63, 118, 106, 100, 196, 191, 190, 64,
552  188, 65, 86, 86, 186, 110, 184, 86, 86, 86,
553  86, 182, 181, 180, 176, 176, 175, 173, 172, 169,
554  168, 165, 86, 86, 86, 86, 105, 105, 163, 163,
555  162, 106, 106, 106, 106, 154, 63, 161, 160, 64,
556 
557  159, 155, 163, 154, 164, 164, 106, 106, 106, 106,
558  153, 152, 151, 63, 63, 147, 146, 64, 145, 144,
559  64, 107, 107, 142, 138, 137, 107, 107, 107, 107,
560  136, 63, 135, 134, 133, 129, 128, 127, 64, 126,
561  121, 107, 107, 107, 107, 117, 117, 120, 116, 115,
562  118, 118, 118, 118, 114, 63, 113, 109, 64, 108,
563  90, 90, 104, 164, 164, 118, 118, 118, 118, 103,
564  102, 101, 63, 63, 96, 94, 64, 93, 90, 64,
565  119, 119, 72, 80, 74, 119, 119, 119, 119, 73,
566  63, 72, 68, 60, 59, 58, 57, 64, 209, 39,
567 
568  119, 119, 119, 119, 130, 130, 39, 209, 209, 131,
569  131, 131, 131, 209, 63, 209, 209, 64, 209, 209,
570  209, 209, 209, 209, 131, 131, 131, 131, 209, 209,
571  209, 63, 209, 209, 209, 209, 209, 209, 64, 132,
572  132, 209, 209, 209, 132, 132, 132, 132, 209, 209,
573  209, 209, 209, 209, 209, 209, 209, 209, 209, 132,
574  132, 132, 132, 139, 139, 209, 209, 209, 140, 140,
575  140, 140, 209, 63, 209, 209, 64, 209, 209, 209,
576  209, 209, 209, 140, 140, 140, 140, 209, 209, 209,
577  63, 209, 209, 209, 209, 209, 209, 64, 141, 141,
578 
579  209, 209, 209, 141, 141, 141, 141, 209, 209, 209,
580  209, 209, 209, 209, 209, 209, 209, 209, 141, 141,
581  141, 141, 148, 148, 209, 209, 209, 149, 149, 149,
582  149, 209, 63, 209, 209, 64, 209, 209, 209, 209,
583  209, 209, 149, 149, 149, 149, 209, 209, 209, 63,
584  209, 209, 209, 209, 209, 209, 64, 150, 150, 209,
585  209, 209, 150, 150, 150, 150, 209, 209, 209, 209,
586  209, 209, 209, 209, 209, 209, 209, 150, 150, 150,
587  150, 156, 156, 209, 209, 209, 157, 157, 157, 157,
588  209, 63, 209, 209, 64, 209, 209, 209, 209, 209,
589 
590  209, 157, 157, 157, 157, 209, 209, 209, 63, 209,
591  209, 209, 209, 209, 209, 64, 158, 158, 209, 209,
592  209, 158, 158, 158, 158, 209, 209, 209, 209, 209,
593  209, 209, 209, 209, 209, 209, 158, 158, 158, 158,
594  38, 38, 38, 38, 51, 51, 51, 51, 52, 52,
595  52, 52, 71, 71, 81, 209, 81, 81, 87, 87,
596  91, 209, 91, 91, 92, 209, 92, 92, 143, 209,
597  143, 143, 171, 209, 171, 171, 15, 209, 209, 209,
598  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
599  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
600 
601  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
602  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
603  209, 209, 209, 209, 209, 209, 209
604  } ;
605 
606 static yyconst flex_int16_t yy_chk[728] =
607  { 0,
608  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
609  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
610  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
611  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
612  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
613  2, 3, 41, 3, 2, 4, 5, 4, 5, 6,
614  8, 6, 27, 27, 8, 29, 29, 49, 61, 61,
615  64, 49, 88, 122, 122, 250, 88, 41, 3, 249,
616  248, 160, 4, 5, 247, 246, 6, 64, 160, 2,
617  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
618 
619  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
620  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
621  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
622  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
623  11, 12, 13, 14, 44, 56, 245, 13, 14, 26,
624  26, 26, 35, 36, 63, 76, 35, 75, 78, 100,
625  26, 75, 100, 26, 112, 166, 44, 56, 176, 13,
626  14, 244, 166, 243, 242, 63, 100, 26, 11, 12,
627  241, 112, 240, 100, 26, 11, 12, 25, 25, 25,
628  239, 35, 62, 62, 62, 36, 75, 76, 25, 238,
629 
630  78, 25, 25, 62, 110, 110, 62, 110, 110, 237,
631  236, 97, 97, 235, 176, 25, 111, 234, 97, 233,
632  62, 232, 25, 231, 25, 43, 43, 62, 230, 229,
633  43, 43, 43, 43, 97, 43, 228, 111, 43, 43,
634  226, 225, 123, 123, 224, 43, 43, 43, 43, 123,
635  222, 221, 43, 220, 219, 218, 195, 189, 188, 43,
636  186, 43, 45, 45, 184, 123, 182, 45, 45, 45,
637  45, 180, 179, 178, 175, 173, 172, 169, 168, 162,
638  161, 159, 45, 45, 45, 45, 84, 84, 158, 157,
639  155, 84, 84, 84, 84, 154, 84, 153, 152, 84,
640 
641  151, 147, 156, 146, 156, 156, 84, 84, 84, 84,
642  145, 144, 142, 84, 156, 138, 137, 156, 136, 135,
643  84, 86, 86, 133, 129, 128, 86, 86, 86, 86,
644  127, 156, 126, 121, 120, 116, 115, 114, 156, 113,
645  109, 86, 86, 86, 86, 105, 105, 108, 104, 103,
646  105, 105, 105, 105, 102, 105, 101, 94, 105, 93,
647  90, 89, 80, 164, 164, 105, 105, 105, 105, 79,
648  77, 73, 105, 164, 60, 54, 164, 53, 50, 105,
649  107, 107, 47, 37, 34, 107, 107, 107, 107, 32,
650  164, 31, 28, 24, 23, 21, 19, 164, 15, 10,
651 
652  107, 107, 107, 107, 117, 117, 9, 0, 0, 117,
653  117, 117, 117, 0, 117, 0, 0, 117, 0, 0,
654  0, 0, 0, 0, 117, 117, 117, 117, 0, 0,
655  0, 117, 0, 0, 0, 0, 0, 0, 117, 119,
656  119, 0, 0, 0, 119, 119, 119, 119, 0, 0,
657  0, 0, 0, 0, 0, 0, 0, 0, 0, 119,
658  119, 119, 119, 130, 130, 0, 0, 0, 130, 130,
659  130, 130, 0, 130, 0, 0, 130, 0, 0, 0,
660  0, 0, 0, 130, 130, 130, 130, 0, 0, 0,
661  130, 0, 0, 0, 0, 0, 0, 130, 132, 132,
662 
663  0, 0, 0, 132, 132, 132, 132, 0, 0, 0,
664  0, 0, 0, 0, 0, 0, 0, 0, 132, 132,
665  132, 132, 139, 139, 0, 0, 0, 139, 139, 139,
666  139, 0, 139, 0, 0, 139, 0, 0, 0, 0,
667  0, 0, 139, 139, 139, 139, 0, 0, 0, 139,
668  0, 0, 0, 0, 0, 0, 139, 141, 141, 0,
669  0, 0, 141, 141, 141, 141, 0, 0, 0, 0,
670  0, 0, 0, 0, 0, 0, 0, 141, 141, 141,
671  141, 148, 148, 0, 0, 0, 148, 148, 148, 148,
672  0, 148, 0, 0, 148, 0, 0, 0, 0, 0,
673 
674  0, 148, 148, 148, 148, 0, 0, 0, 148, 0,
675  0, 0, 0, 0, 0, 148, 150, 150, 0, 0,
676  0, 150, 150, 150, 150, 0, 0, 0, 0, 0,
677  0, 0, 0, 0, 0, 0, 150, 150, 150, 150,
678  210, 210, 210, 210, 211, 211, 211, 211, 212, 212,
679  212, 212, 213, 213, 214, 0, 214, 214, 215, 215,
680  216, 0, 216, 216, 217, 0, 217, 217, 223, 0,
681  223, 223, 227, 0, 227, 227, 209, 209, 209, 209,
682  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
683  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
684 
685  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
686  209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
687  209, 209, 209, 209, 209, 209, 209
688  } ;
689 
690 static yy_state_type yy_last_accepting_state;
691 static char *yy_last_accepting_cpos;
692 
693 extern int parser__flex_debug;
694 int parser__flex_debug = 0;
695 
696 /* The intent behind this definition is that it'll catch
697  * any uses of REJECT which flex missed.
698  */
699 #define REJECT reject_used_but_not_detected
700 #define yymore() yymore_used_but_not_detected
701 #define YY_MORE_ADJ 0
702 #define YY_RESTORE_YY_MORE_OFFSET
703 char *parser_text;
704 #line 1 "parser.l"
705 /* -*-C-*-
706  * IDL Compiler
707  *
708  * Copyright 2002 Ove Kaaven
709  *
710  * This library is free software; you can redistribute it and/or
711  * modify it under the terms of the GNU Lesser General Public
712  * License as published by the Free Software Foundation; either
713  * version 2.1 of the License, or (at your option) any later version.
714  *
715  * This library is distributed in the hope that it will be useful,
716  * but WITHOUT ANY WARRANTY; without even the implied warranty of
717  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718  * Lesser General Public License for more details.
719  *
720  * You should have received a copy of the GNU Lesser General Public
721  * License along with this library; if not, write to the Free Software
722  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
723  */
724 #define YY_NO_INPUT 1
725 
726 
727 
728 
729 
730 
731 #line 44 "parser.l"
732 
733 #include "config.h"
734 #include "wine/port.h"
735 
736 #include <stdio.h>
737 #include <stdlib.h>
738 #include <string.h>
739 #include <ctype.h>
740 #include <assert.h>
741 #include <errno.h>
742 #include <limits.h>
743 
744 #ifdef HAVE_UNISTD_H
745 #include <unistd.h>
746 #else
747 #define YY_NO_UNISTD_H
748 #endif
749 
750 #include "widl.h"
751 #include "utils.h"
752 #include "parser.h"
753 #include "wine/wpp.h"
754 
755 #include "parser.tab.h"
756 
757 static void addcchar(char c);
758 static char *get_buffered_cstring(void);
759 
760 static char *cbuffer;
761 static int cbufidx;
762 static int cbufalloc = 0;
763 
764 static int kw_token(const char *kw);
765 static int attr_token(const char *kw);
766 
767 static void switch_to_acf(void);
768 
769 static warning_list_t *disabled_warnings = NULL;
770 
771 #define MAX_IMPORT_DEPTH 20
772 struct {
773  YY_BUFFER_STATE state;
774  char *input_name;
775  int line_number;
776  char *temp_name;
777 } import_stack[MAX_IMPORT_DEPTH];
778 int import_stack_ptr = 0;
779 
780 /* converts an integer in string form to an unsigned long and prints an error
781  * on overflow */
782 static unsigned int xstrtoul(const char *nptr, char **endptr, int base)
783 {
784  unsigned long val;
785 
786  errno = 0;
787  val = strtoul(nptr, endptr, base);
788  if ((val == ULONG_MAX && errno == ERANGE) || ((unsigned int)val != val))
789  error_loc("integer constant %s is too large\n", nptr);
790  return val;
791 }
792 
793 UUID *parse_uuid(const char *u)
794 {
795  UUID* uuid = xmalloc(sizeof(UUID));
796  char b[3];
797  /* it would be nice to use UuidFromStringA */
798  uuid->Data1 = strtoul(u, NULL, 16);
799  uuid->Data2 = strtoul(u+9, NULL, 16);
800  uuid->Data3 = strtoul(u+14, NULL, 16);
801  b[2] = 0;
802  memcpy(b, u+19, 2); uuid->Data4[0] = strtoul(b, NULL, 16);
803  memcpy(b, u+21, 2); uuid->Data4[1] = strtoul(b, NULL, 16);
804  memcpy(b, u+24, 2); uuid->Data4[2] = strtoul(b, NULL, 16);
805  memcpy(b, u+26, 2); uuid->Data4[3] = strtoul(b, NULL, 16);
806  memcpy(b, u+28, 2); uuid->Data4[4] = strtoul(b, NULL, 16);
807  memcpy(b, u+30, 2); uuid->Data4[5] = strtoul(b, NULL, 16);
808  memcpy(b, u+32, 2); uuid->Data4[6] = strtoul(b, NULL, 16);
809  memcpy(b, u+34, 2); uuid->Data4[7] = strtoul(b, NULL, 16);
810  return uuid;
811 }
812 
813 /*
814  **************************************************************************
815  * The flexer starts here
816  **************************************************************************
817  */
818 #line 819 "parser.yy.c"
819 
820 #define INITIAL 0
821 #define QUOTE 1
822 #define WSTRQUOTE 2
823 #define ATTR 3
824 #define PP_LINE 4
825 #define PP_PRAGMA 5
826 #define SQUOTE 6
827 
828 #ifndef YY_NO_UNISTD_H
829 /* Special case for "unistd.h", since it is non-ANSI. We include it way
830  * down here because we want the user's section 1 to have been scanned first.
831  * The user has a chance to override it with an option.
832  */
833 #include <unistd.h>
834 #endif
835 
836 #ifndef YY_EXTRA_TYPE
837 #define YY_EXTRA_TYPE void *
838 #endif
839 
840 static int yy_init_globals (void );
841 
842 /* Accessor methods to globals.
843  These are made visible to non-reentrant scanners for convenience. */
844 
845 int parser_lex_destroy (void );
846 
847 int parser_get_debug (void );
848 
849 void parser_set_debug (int debug_flag );
850 
851 YY_EXTRA_TYPE parser_get_extra (void );
852 
853 void parser_set_extra (YY_EXTRA_TYPE user_defined );
854 
855 FILE *parser_get_in (void );
856 
857 void parser_set_in (FILE * in_str );
858 
859 FILE *parser_get_out (void );
860 
861 void parser_set_out (FILE * out_str );
862 
863 yy_size_t parser_get_leng (void );
864 
865 char *parser_get_text (void );
866 
867 int parser_get_lineno (void );
868 
869 void parser_set_lineno (int line_number );
870 
871 /* Macros after this point can all be overridden by user definitions in
872  * section 1.
873  */
874 
875 #ifndef YY_SKIP_YYWRAP
876 #ifdef __cplusplus
877 extern "C" int parser_wrap (void );
878 #else
879 extern int parser_wrap (void );
880 #endif
881 #endif
882 
883 #ifndef yytext_ptr
884 static void yy_flex_strncpy (char *,yyconst char *,int );
885 #endif
886 
887 #ifdef YY_NEED_STRLEN
888 static int yy_flex_strlen (yyconst char * );
889 #endif
890 
891 #ifndef YY_NO_INPUT
892 
893 #ifdef __cplusplus
894 static int yyinput (void );
895 #else
896 static int input (void );
897 #endif
898 
899 #endif
900 
901  static int yy_start_stack_ptr = 0;
902  static int yy_start_stack_depth = 0;
903  static int *yy_start_stack = NULL;
904 
905  static void yy_push_state (int new_state );
906 
907  static void yy_pop_state (void );
908 
909 /* Amount of stuff to slurp up with each read. */
910 #ifndef YY_READ_BUF_SIZE
911 #define YY_READ_BUF_SIZE 8192
912 #endif
913 
914 /* Copy whatever the last rule matched to the standard output. */
915 #ifndef ECHO
916 /* This used to be an fputs(), but since the string might contain NUL's,
917  * we now use fwrite().
918  */
919 #define ECHO do { if (fwrite( parser_text, parser_leng, 1, parser_out )) {} } while (0)
920 #endif
921 
922 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
923  * is returned in "result".
924  */
925 #ifndef YY_INPUT
926 #define YY_INPUT(buf,result,max_size) \
927  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
928  { \
929  int c = '*'; \
930  size_t n; \
931  for ( n = 0; n < max_size && \
932  (c = getc( parser_in )) != EOF && c != '\n'; ++n ) \
933  buf[n] = (char) c; \
934  if ( c == '\n' ) \
935  buf[n++] = (char) c; \
936  if ( c == EOF && ferror( parser_in ) ) \
937  YY_FATAL_ERROR( "input in flex scanner failed" ); \
938  result = n; \
939  } \
940  else \
941  { \
942  errno=0; \
943  while ( (result = fread(buf, 1, max_size, parser_in))==0 && ferror(parser_in)) \
944  { \
945  if( errno != EINTR) \
946  { \
947  YY_FATAL_ERROR( "input in flex scanner failed" ); \
948  break; \
949  } \
950  errno=0; \
951  clearerr(parser_in); \
952  } \
953  }\
954 \
955 
956 #endif
957 
958 /* No semi-colon after return; correct usage is to write "yyterminate();" -
959  * we don't want an extra ';' after the "return" because that will cause
960  * some compilers to complain about unreachable statements.
961  */
962 #ifndef yyterminate
963 #define yyterminate() return YY_NULL
964 #endif
965 
966 /* Number of entries by which start-condition stack grows. */
967 #ifndef YY_START_STACK_INCR
968 #define YY_START_STACK_INCR 25
969 #endif
970 
971 /* Report a fatal error. */
972 #ifndef YY_FATAL_ERROR
973 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
974 #endif
975 
976 /* end tables serialization structures and prototypes */
977 
978 /* Default declaration of generated scanner - a define so the user can
979  * easily add parameters.
980  */
981 #ifndef YY_DECL
982 #define YY_DECL_IS_OURS 1
983 
984 extern int parser_lex (void);
985 
986 #define YY_DECL int parser_lex (void)
987 #endif /* !YY_DECL */
988 
989 /* Code executed at the beginning of each rule, after parser_text and parser_leng
990  * have been set up.
991  */
992 #ifndef YY_USER_ACTION
993 #define YY_USER_ACTION
994 #endif
995 
996 /* Code executed at the end of each rule. */
997 #ifndef YY_BREAK
998 #define YY_BREAK break;
999 #endif
1000 
1001 #define YY_RULE_SETUP \
1002  if ( parser_leng > 0 ) \
1003  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1004  (parser_text[parser_leng - 1] == '\n'); \
1005  YY_USER_ACTION
1006 
1009 YY_DECL
1010 {
1011  register yy_state_type yy_current_state;
1012  register char *yy_cp, *yy_bp;
1013  register int yy_act;
1014 
1015 #line 132 "parser.l"
1016 
1017 #line 1018 "parser.yy.c"
1018 
1019  if ( !(yy_init) )
1020  {
1021  (yy_init) = 1;
1022 
1023 #ifdef YY_USER_INIT
1024  YY_USER_INIT;
1025 #endif
1026 
1027  if ( ! (yy_start) )
1028  (yy_start) = 1; /* first start state */
1029 
1030  if ( ! parser_in )
1031  parser_in = stdin;
1032 
1033  if ( ! parser_out )
1034  parser_out = stdout;
1035 
1036  if ( ! YY_CURRENT_BUFFER ) {
1037  parser_ensure_buffer_stack ();
1038  YY_CURRENT_BUFFER_LVALUE =
1039  parser__create_buffer(parser_in,YY_BUF_SIZE );
1040  }
1041 
1042  parser__load_buffer_state( );
1043  }
1044 
1045  while ( 1 ) /* loops until end-of-file is reached */
1046  {
1047  yy_cp = (yy_c_buf_p);
1048 
1049  /* Support of parser_text. */
1050  *yy_cp = (yy_hold_char);
1051 
1052  /* yy_bp points to the position in yy_ch_buf of the start of
1053  * the current run.
1054  */
1055  yy_bp = yy_cp;
1056 
1057  yy_current_state = (yy_start);
1058  yy_current_state += YY_AT_BOL();
1059 yy_match:
1060  do
1061  {
1062  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1063  if ( yy_accept[yy_current_state] )
1064  {
1065  (yy_last_accepting_state) = yy_current_state;
1066  (yy_last_accepting_cpos) = yy_cp;
1067  }
1068  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1069  {
1070  yy_current_state = (int) yy_def[yy_current_state];
1071  if ( yy_current_state >= 210 )
1072  yy_c = yy_meta[(unsigned int) yy_c];
1073  }
1074  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1075  ++yy_cp;
1076  }
1077  while ( yy_current_state != 209 );
1078  yy_cp = (yy_last_accepting_cpos);
1079  yy_current_state = (yy_last_accepting_state);
1080 
1081 yy_find_action:
1082  yy_act = yy_accept[yy_current_state];
1083 
1084  YY_DO_BEFORE_ACTION;
1085 
1086 do_action: /* This label is used only to access EOF actions. */
1087 
1088  switch ( yy_act )
1089  { /* beginning of action switch */
1090  case 0: /* must back up */
1091  /* undo the effects of YY_DO_BEFORE_ACTION */
1092  *yy_cp = (yy_hold_char);
1093  yy_cp = (yy_last_accepting_cpos);
1094  yy_current_state = (yy_last_accepting_state);
1095  goto yy_find_action;
1096 
1097 case 1:
1098 YY_RULE_SETUP
1099 #line 133 "parser.l"
1100 yy_push_state(PP_PRAGMA);
1101  YY_BREAK
1102 case 2:
1103 YY_RULE_SETUP
1104 #line 134 "parser.l"
1105 yy_push_state(PP_LINE);
1106  YY_BREAK
1107 case 3:
1108 YY_RULE_SETUP
1109 #line 135 "parser.l"
1110 {
1111  int lineno;
1112  char *cptr, *fname;
1113  yy_pop_state();
1114  lineno = (int)strtol(parser_text, &cptr, 10);
1115  if(!lineno)
1116  error_loc("Malformed '#...' line-directive; invalid linenumber\n");
1117  fname = strchr(cptr, '"');
1118  if(!fname)
1119  error_loc("Malformed '#...' line-directive; missing filename\n");
1120  fname++;
1121  cptr = strchr(fname, '"');
1122  if(!cptr)
1123  error_loc("Malformed '#...' line-directive; missing terminating \"\n");
1124  *cptr = '\0';
1125  line_number = lineno - 1; /* We didn't read the newline */
1126  input_name = xstrdup(fname);
1127  }
1128  YY_BREAK
1129 case 4:
1130 YY_RULE_SETUP
1131 #line 153 "parser.l"
1132 yyless(9); yy_pop_state(); return tCPPQUOTE;
1133  YY_BREAK
1134 case 5:
1135 YY_RULE_SETUP
1136 #line 154 "parser.l"
1137 {
1138  if(import_stack_ptr) {
1139  if(!winrt_mode)
1140  error_loc("winrt IDL file imported in non-winrt mode\n");
1141  }else {
1142  const char *ptr = parser_text+5;
1143 
1144  winrt_mode = TRUE;
1145 
1146  while(isspace(*ptr))
1147  ptr++;
1148  if(!strncmp(ptr, "ns_prefix", 9) && (!*(ptr += 9) || isspace(*ptr)))
1149  use_abi_namespace = TRUE;
1150  }
1151  yy_pop_state();
1152  }
1153  YY_BREAK
1154 case 6:
1155 YY_RULE_SETUP
1156 #line 170 "parser.l"
1157 parser_lval.str = xstrdup(parser_text); yy_pop_state(); return aPRAGMA;
1158  YY_BREAK
1159 case 7:
1160 YY_RULE_SETUP
1161 #line 171 "parser.l"
1162 return tPRAGMA_WARNING;
1163  YY_BREAK
1164 case 8:
1165 YY_RULE_SETUP
1166 #line 172 "parser.l"
1167 yy_push_state(QUOTE); cbufidx = 0;
1168  YY_BREAK
1169 case 9:
1170 YY_RULE_SETUP
1171 #line 173 "parser.l"
1172 {
1173  yy_pop_state();
1174  parser_lval.str = get_buffered_cstring();
1175  return aSTRING;
1176  }
1177  YY_BREAK
1178 case 10:
1179 YY_RULE_SETUP
1180 #line 178 "parser.l"
1181 yy_push_state(WSTRQUOTE); cbufidx = 0;
1182  YY_BREAK
1183 case 11:
1184 YY_RULE_SETUP
1185 #line 179 "parser.l"
1186 {
1187  yy_pop_state();
1188  parser_lval.str = get_buffered_cstring();
1189  return aWSTRING;
1190  }
1191  YY_BREAK
1192 case 12:
1193 YY_RULE_SETUP
1194 #line 184 "parser.l"
1195 yy_push_state(SQUOTE); cbufidx = 0;
1196  YY_BREAK
1197 case 13:
1198 YY_RULE_SETUP
1199 #line 185 "parser.l"
1200 {
1201  yy_pop_state();
1202  parser_lval.str = get_buffered_cstring();
1203  return aSQSTRING;
1204  }
1205  YY_BREAK
1206 case 14:
1207 #line 191 "parser.l"
1208 case 15:
1209 YY_RULE_SETUP
1210 #line 191 "parser.l"
1211 addcchar(parser_text[1]);
1212  YY_BREAK
1213 case 16:
1214 YY_RULE_SETUP
1215 #line 192 "parser.l"
1216 addcchar(parser_text[1]);
1217  YY_BREAK
1218 case 17:
1219 YY_RULE_SETUP
1220 #line 193 "parser.l"
1221 addcchar('\\'); addcchar(parser_text[1]);
1222  YY_BREAK
1223 case 18:
1224 YY_RULE_SETUP
1225 #line 194 "parser.l"
1226 addcchar(parser_text[0]);
1227  YY_BREAK
1228 case 19:
1229 YY_RULE_SETUP
1230 #line 195 "parser.l"
1231 yy_push_state(ATTR); return '[';
1232  YY_BREAK
1233 case 20:
1234 YY_RULE_SETUP
1235 #line 196 "parser.l"
1236 yy_pop_state(); return ']';
1237  YY_BREAK
1238 case 21:
1239 YY_RULE_SETUP
1240 #line 197 "parser.l"
1241 return attr_token(parser_text);
1242  YY_BREAK
1243 case 22:
1244 YY_RULE_SETUP
1245 #line 198 "parser.l"
1246 {
1247  parser_lval.uuid = parse_uuid(parser_text);
1248  return aUUID;
1249  }
1250  YY_BREAK
1251 case 23:
1252 YY_RULE_SETUP
1253 #line 202 "parser.l"
1254 {
1255  parser_lval.num = xstrtoul(parser_text, NULL, 0);
1256  return aHEXNUM;
1257  }
1258  YY_BREAK
1259 case 24:
1260 YY_RULE_SETUP
1261 #line 206 "parser.l"
1262 {
1263  parser_lval.num = xstrtoul(parser_text, NULL, 0);
1264  return aNUM;
1265  }
1266  YY_BREAK
1267 case 25:
1268 YY_RULE_SETUP
1269 #line 210 "parser.l"
1270 {
1271  parser_lval.dbl = strtod(parser_text, NULL);
1272  return aDOUBLE;
1273  }
1274  YY_BREAK
1275 case 26:
1276 *yy_cp = (yy_hold_char); /* undo effects of setting up parser_text */
1277 (yy_c_buf_p) = yy_cp -= 1;
1278 YY_DO_BEFORE_ACTION; /* set up parser_text again */
1279 YY_RULE_SETUP
1280 #line 214 "parser.l"
1281 return tSAFEARRAY;
1282  YY_BREAK
1283 case 27:
1284 YY_RULE_SETUP
1285 #line 215 "parser.l"
1286 return kw_token(parser_text);
1287  YY_BREAK
1288 case 28:
1289 /* rule 28 can match eol */
1290 YY_RULE_SETUP
1291 #line 216 "parser.l"
1292 line_number++;
1293  YY_BREAK
1294 case 29:
1295 YY_RULE_SETUP
1296 #line 217 "parser.l"
1297 
1298  YY_BREAK
1299 case 30:
1300 YY_RULE_SETUP
1301 #line 218 "parser.l"
1302 return SHL;
1303  YY_BREAK
1304 case 31:
1305 YY_RULE_SETUP
1306 #line 219 "parser.l"
1307 return SHR;
1308  YY_BREAK
1309 case 32:
1310 YY_RULE_SETUP
1311 #line 220 "parser.l"
1312 return MEMBERPTR;
1313  YY_BREAK
1314 case 33:
1315 YY_RULE_SETUP
1316 #line 221 "parser.l"
1317 return EQUALITY;
1318  YY_BREAK
1319 case 34:
1320 YY_RULE_SETUP
1321 #line 222 "parser.l"
1322 return INEQUALITY;
1323  YY_BREAK
1324 case 35:
1325 YY_RULE_SETUP
1326 #line 223 "parser.l"
1327 return GREATEREQUAL;
1328  YY_BREAK
1329 case 36:
1330 YY_RULE_SETUP
1331 #line 224 "parser.l"
1332 return LESSEQUAL;
1333  YY_BREAK
1334 case 37:
1335 YY_RULE_SETUP
1336 #line 225 "parser.l"
1337 return LOGICALOR;
1338  YY_BREAK
1339 case 38:
1340 YY_RULE_SETUP
1341 #line 226 "parser.l"
1342 return LOGICALAND;
1343  YY_BREAK
1344 case 39:
1345 YY_RULE_SETUP
1346 #line 227 "parser.l"
1347 return ELLIPSIS;
1348  YY_BREAK
1349 case 40:
1350 YY_RULE_SETUP
1351 #line 228 "parser.l"
1352 return parser_text[0];
1353  YY_BREAK
1354 case YY_STATE_EOF(INITIAL):
1355 case YY_STATE_EOF(QUOTE):
1356 case YY_STATE_EOF(WSTRQUOTE):
1357 case YY_STATE_EOF(ATTR):
1358 case YY_STATE_EOF(PP_LINE):
1359 case YY_STATE_EOF(PP_PRAGMA):
1360 case YY_STATE_EOF(SQUOTE):
1361 #line 229 "parser.l"
1362 {
1363  if (import_stack_ptr)
1364  return aEOF;
1365  if (acf_name)
1366  {
1367  switch_to_acf();
1368  return aACF;
1369  }
1370  yyterminate();
1371  }
1372  YY_BREAK
1373 case 41:
1374 YY_RULE_SETUP
1375 #line 239 "parser.l"
1376 ECHO;
1377  YY_BREAK
1378 #line 1379 "parser.yy.c"
1379 
1380  case YY_END_OF_BUFFER:
1381  {
1382  /* Amount of text matched not including the EOB char. */
1383  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1384 
1385  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1386  *yy_cp = (yy_hold_char);
1387  YY_RESTORE_YY_MORE_OFFSET
1388 
1389  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1390  {
1391  /* We're scanning a new file or input source. It's
1392  * possible that this happened because the user
1393  * just pointed parser_in at a new source and called
1394  * parser_lex(). If so, then we have to assure
1395  * consistency between YY_CURRENT_BUFFER and our
1396  * globals. Here is the right place to do so, because
1397  * this is the first action (other than possibly a
1398  * back-up) that will match for the new input source.
1399  */
1400  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1401  YY_CURRENT_BUFFER_LVALUE->yy_input_file = parser_in;
1402  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1403  }
1404 
1405  /* Note that here we test for yy_c_buf_p "<=" to the position
1406  * of the first EOB in the buffer, since yy_c_buf_p will
1407  * already have been incremented past the NUL character
1408  * (since all states make transitions on EOB to the
1409  * end-of-buffer state). Contrast this with the test
1410  * in input().
1411  */
1412  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1413  { /* This was really a NUL. */
1414  yy_state_type yy_next_state;
1415 
1416  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1417 
1418  yy_current_state = yy_get_previous_state( );
1419 
1420  /* Okay, we're now positioned to make the NUL
1421  * transition. We couldn't have
1422  * yy_get_previous_state() go ahead and do it
1423  * for us because it doesn't know how to deal
1424  * with the possibility of jamming (and we don't
1425  * want to build jamming into it because then it
1426  * will run more slowly).
1427  */
1428 
1429  yy_next_state = yy_try_NUL_trans( yy_current_state );
1430 
1431  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1432 
1433  if ( yy_next_state )
1434  {
1435  /* Consume the NUL. */
1436  yy_cp = ++(yy_c_buf_p);
1437  yy_current_state = yy_next_state;
1438  goto yy_match;
1439  }
1440 
1441  else
1442  {
1443  yy_cp = (yy_last_accepting_cpos);
1444  yy_current_state = (yy_last_accepting_state);
1445  goto yy_find_action;
1446  }
1447  }
1448 
1449  else switch ( yy_get_next_buffer( ) )
1450  {
1451  case EOB_ACT_END_OF_FILE:
1452  {
1453  (yy_did_buffer_switch_on_eof) = 0;
1454 
1455  if ( parser_wrap( ) )
1456  {
1457  /* Note: because we've taken care in
1458  * yy_get_next_buffer() to have set up
1459  * parser_text, we can now set up
1460  * yy_c_buf_p so that if some total
1461  * hoser (like flex itself) wants to
1462  * call the scanner after we return the
1463  * YY_NULL, it'll still work - another
1464  * YY_NULL will get returned.
1465  */
1466  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1467 
1468  yy_act = YY_STATE_EOF(YY_START);
1469  goto do_action;
1470  }
1471 
1472  else
1473  {
1474  if ( ! (yy_did_buffer_switch_on_eof) )
1475  YY_NEW_FILE;
1476  }
1477  break;
1478  }
1479 
1480  case EOB_ACT_CONTINUE_SCAN:
1481  (yy_c_buf_p) =
1482  (yytext_ptr) + yy_amount_of_matched_text;
1483 
1484  yy_current_state = yy_get_previous_state( );
1485 
1486  yy_cp = (yy_c_buf_p);
1487  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1488  goto yy_match;
1489 
1490  case EOB_ACT_LAST_MATCH:
1491  (yy_c_buf_p) =
1492  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1493 
1494  yy_current_state = yy_get_previous_state( );
1495 
1496  yy_cp = (yy_c_buf_p);
1497  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1498  goto yy_find_action;
1499  }
1500  break;
1501  }
1502 
1503  default:
1504  YY_FATAL_ERROR(
1505  "fatal flex scanner internal error--no action found" );
1506  } /* end of action switch */
1507  } /* end of scanning one token */
1508 } /* end of parser_lex */
1509 
1510 /* yy_get_next_buffer - try to read in a new buffer
1511  *
1512  * Returns a code representing an action:
1513  * EOB_ACT_LAST_MATCH -
1514  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1515  * EOB_ACT_END_OF_FILE - end of file
1516  */
1517 static int yy_get_next_buffer (void)
1518 {
1519  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1520  register char *source = (yytext_ptr);
1521  register int number_to_move, i;
1522  int ret_val;
1523 
1524  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1525  YY_FATAL_ERROR(
1526  "fatal flex scanner internal error--end of buffer missed" );
1527 
1528  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1529  { /* Don't try to fill the buffer, so this is an EOF. */
1530  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1531  {
1532  /* We matched a single character, the EOB, so
1533  * treat this as a final EOF.
1534  */
1535  return EOB_ACT_END_OF_FILE;
1536  }
1537 
1538  else
1539  {
1540  /* We matched some text prior to the EOB, first
1541  * process it.
1542  */
1543  return EOB_ACT_LAST_MATCH;
1544  }
1545  }
1546 
1547  /* Try to read more data. */
1548 
1549  /* First move last chars to start of buffer. */
1550  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1551 
1552  for ( i = 0; i < number_to_move; ++i )
1553  *(dest++) = *(source++);
1554 
1555  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1556  /* don't do the read, it's not guaranteed to return an EOF,
1557  * just force an EOF
1558  */
1559  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1560 
1561  else
1562  {
1563  yy_size_t num_to_read =
1564  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1565 
1566  while ( num_to_read <= 0 )
1567  { /* Not enough room in the buffer - grow it. */
1568 
1569  /* just a shorter name for the current buffer */
1570  YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1571 
1572  int yy_c_buf_p_offset =
1573  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1574 
1575  if ( b->yy_is_our_buffer )
1576  {
1577  yy_size_t new_size = b->yy_buf_size * 2;
1578 
1579  if ( new_size <= 0 )
1580  b->yy_buf_size += b->yy_buf_size / 8;
1581  else
1582  b->yy_buf_size *= 2;
1583 
1584  b->yy_ch_buf = (char *)
1585  /* Include room in for 2 EOB chars. */
1586  parser_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1587  }
1588  else
1589  /* Can't grow it, we don't own it. */
1590  b->yy_ch_buf = 0;
1591 
1592  if ( ! b->yy_ch_buf )
1593  YY_FATAL_ERROR(
1594  "fatal error - scanner input buffer overflow" );
1595 
1596  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1597 
1598  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1599  number_to_move - 1;
1600 
1601  }
1602 
1603  if ( num_to_read > YY_READ_BUF_SIZE )
1604  num_to_read = YY_READ_BUF_SIZE;
1605 
1606  /* Read in more data. */
1607  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1608  (yy_n_chars), num_to_read );
1609 
1610  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1611  }
1612 
1613  if ( (yy_n_chars) == 0 )
1614  {
1615  if ( number_to_move == YY_MORE_ADJ )
1616  {
1617  ret_val = EOB_ACT_END_OF_FILE;
1618  parser_restart(parser_in );
1619  }
1620 
1621  else
1622  {
1623  ret_val = EOB_ACT_LAST_MATCH;
1624  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1625  YY_BUFFER_EOF_PENDING;
1626  }
1627  }
1628 
1629  else
1630  ret_val = EOB_ACT_CONTINUE_SCAN;
1631 
1632  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1633  /* Extend the array by 50%, plus the number we really need. */
1634  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1635  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) parser_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1636  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1637  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1638  }
1639 
1640  (yy_n_chars) += number_to_move;
1641  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1642  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1643 
1644  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1645 
1646  return ret_val;
1647 }
1648 
1649 /* yy_get_previous_state - get the state just before the EOB char was reached */
1650 
1651  static yy_state_type yy_get_previous_state (void)
1652 {
1653  register yy_state_type yy_current_state;
1654  register char *yy_cp;
1655 
1656  yy_current_state = (yy_start);
1657  yy_current_state += YY_AT_BOL();
1658 
1659  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1660  {
1661  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1662  if ( yy_accept[yy_current_state] )
1663  {
1664  (yy_last_accepting_state) = yy_current_state;
1665  (yy_last_accepting_cpos) = yy_cp;
1666  }
1667  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1668  {
1669  yy_current_state = (int) yy_def[yy_current_state];
1670  if ( yy_current_state >= 210 )
1671  yy_c = yy_meta[(unsigned int) yy_c];
1672  }
1673  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1674  }
1675 
1676  return yy_current_state;
1677 }
1678 
1679 /* yy_try_NUL_trans - try to make a transition on the NUL character
1680  *
1681  * synopsis
1682  * next_state = yy_try_NUL_trans( current_state );
1683  */
1684  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1685 {
1686  register int yy_is_jam;
1687  register char *yy_cp = (yy_c_buf_p);
1688 
1689  register YY_CHAR yy_c = 1;
1690  if ( yy_accept[yy_current_state] )
1691  {
1692  (yy_last_accepting_state) = yy_current_state;
1693  (yy_last_accepting_cpos) = yy_cp;
1694  }
1695  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1696  {
1697  yy_current_state = (int) yy_def[yy_current_state];
1698  if ( yy_current_state >= 210 )
1699  yy_c = yy_meta[(unsigned int) yy_c];
1700  }
1701  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1702  yy_is_jam = (yy_current_state == 209);
1703 
1704  return yy_is_jam ? 0 : yy_current_state;
1705 }
1706 
1707 #ifndef YY_NO_INPUT
1708 #ifdef __cplusplus
1709  static int yyinput (void)
1710 #else
1711  static int input (void)
1712 #endif
1713 
1714 {
1715  int c;
1716 
1717  *(yy_c_buf_p) = (yy_hold_char);
1718 
1719  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1720  {
1721  /* yy_c_buf_p now points to the character we want to return.
1722  * If this occurs *before* the EOB characters, then it's a
1723  * valid NUL; if not, then we've hit the end of the buffer.
1724  */
1725  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1726  /* This was really a NUL. */
1727  *(yy_c_buf_p) = '\0';
1728 
1729  else
1730  { /* need more input */
1731  yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1732  ++(yy_c_buf_p);
1733 
1734  switch ( yy_get_next_buffer( ) )
1735  {
1736  case EOB_ACT_LAST_MATCH:
1737  /* This happens because yy_g_n_b()
1738  * sees that we've accumulated a
1739  * token and flags that we need to
1740  * try matching the token before
1741  * proceeding. But for input(),
1742  * there's no matching to consider.
1743  * So convert the EOB_ACT_LAST_MATCH
1744  * to EOB_ACT_END_OF_FILE.
1745  */
1746 
1747  /* Reset buffer status. */
1748  parser_restart(parser_in );
1749 
1750  /*FALLTHROUGH*/
1751 
1752  case EOB_ACT_END_OF_FILE:
1753  {
1754  if ( parser_wrap( ) )
1755  return EOF;
1756 
1757  if ( ! (yy_did_buffer_switch_on_eof) )
1758  YY_NEW_FILE;
1759 #ifdef __cplusplus
1760  return yyinput();
1761 #else
1762  return input();
1763 #endif
1764  }
1765 
1766  case EOB_ACT_CONTINUE_SCAN:
1767  (yy_c_buf_p) = (yytext_ptr) + offset;
1768  break;
1769  }
1770  }
1771  }
1772 
1773  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1774  *(yy_c_buf_p) = '\0'; /* preserve parser_text */
1775  (yy_hold_char) = *++(yy_c_buf_p);
1776 
1777  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1778 
1779  return c;
1780 }
1781 #endif /* ifndef YY_NO_INPUT */
1782 
1788  void parser_restart (FILE * input_file )
1789 {
1790 
1791  if ( ! YY_CURRENT_BUFFER ){
1792  parser_ensure_buffer_stack ();
1793  YY_CURRENT_BUFFER_LVALUE =
1794  parser__create_buffer(parser_in,YY_BUF_SIZE );
1795  }
1796 
1797  parser__init_buffer(YY_CURRENT_BUFFER,input_file );
1798  parser__load_buffer_state( );
1799 }
1800 
1805  void parser__switch_to_buffer (YY_BUFFER_STATE new_buffer )
1806 {
1807 
1808  /* TODO. We should be able to replace this entire function body
1809  * with
1810  * parser_pop_buffer_state();
1811  * parser_push_buffer_state(new_buffer);
1812  */
1813  parser_ensure_buffer_stack ();
1814  if ( YY_CURRENT_BUFFER == new_buffer )
1815  return;
1816 
1817  if ( YY_CURRENT_BUFFER )
1818  {
1819  /* Flush out information for old buffer. */
1820  *(yy_c_buf_p) = (yy_hold_char);
1821  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1822  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1823  }
1824 
1825  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1826  parser__load_buffer_state( );
1827 
1828  /* We don't actually know whether we did this switch during
1829  * EOF (parser_wrap()) processing, but the only time this flag
1830  * is looked at is after parser_wrap() is called, so it's safe
1831  * to go ahead and always set it.
1832  */
1833  (yy_did_buffer_switch_on_eof) = 1;
1834 }
1835 
1836 static void parser__load_buffer_state (void)
1837 {
1838  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1839  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1840  parser_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1841  (yy_hold_char) = *(yy_c_buf_p);
1842 }
1843 
1850  YY_BUFFER_STATE parser__create_buffer (FILE * file, int size )
1851 {
1852  YY_BUFFER_STATE b;
1853 
1854  b = (YY_BUFFER_STATE) parser_alloc(sizeof( struct yy_buffer_state ) );
1855  if ( ! b )
1856  YY_FATAL_ERROR( "out of dynamic memory in parser__create_buffer()" );
1857 
1858  b->yy_buf_size = size;
1859 
1860  /* yy_ch_buf has to be 2 characters longer than the size given because
1861  * we need to put in 2 end-of-buffer characters.
1862  */
1863  b->yy_ch_buf = (char *) parser_alloc(b->yy_buf_size + 2 );
1864  if ( ! b->yy_ch_buf )
1865  YY_FATAL_ERROR( "out of dynamic memory in parser__create_buffer()" );
1866 
1867  b->yy_is_our_buffer = 1;
1868 
1869  parser__init_buffer(b,file );
1870 
1871  return b;
1872 }
1873 
1878  void parser__delete_buffer (YY_BUFFER_STATE b )
1879 {
1880 
1881  if ( ! b )
1882  return;
1883 
1884  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1885  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1886 
1887  if ( b->yy_is_our_buffer )
1888  parser_free((void *) b->yy_ch_buf );
1889 
1890  parser_free((void *) b );
1891 }
1892 
1893 /* Initializes or reinitializes a buffer.
1894  * This function is sometimes called more than once on the same buffer,
1895  * such as during a parser_restart() or at EOF.
1896  */
1897  static void parser__init_buffer (YY_BUFFER_STATE b, FILE * file )
1898 
1899 {
1900  int oerrno = errno;
1901 
1902  parser__flush_buffer(b );
1903 
1904  b->yy_input_file = file;
1905  b->yy_fill_buffer = 1;
1906 
1907  /* If b is the current buffer, then parser__init_buffer was _probably_
1908  * called from parser_restart() or through yy_get_next_buffer.
1909  * In that case, we don't want to reset the lineno or column.
1910  */
1911  if (b != YY_CURRENT_BUFFER){
1912  b->yy_bs_lineno = 1;
1913  b->yy_bs_column = 0;
1914  }
1915 
1916  b->yy_is_interactive = 0;
1917 
1918  errno = oerrno;
1919 }
1920 
1925  void parser__flush_buffer (YY_BUFFER_STATE b )
1926 {
1927  if ( ! b )
1928  return;
1929 
1930  b->yy_n_chars = 0;
1931 
1932  /* We always need two end-of-buffer characters. The first causes
1933  * a transition to the end-of-buffer state. The second causes
1934  * a jam in that state.
1935  */
1936  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1937  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1938 
1939  b->yy_buf_pos = &b->yy_ch_buf[0];
1940 
1941  b->yy_at_bol = 1;
1942  b->yy_buffer_status = YY_BUFFER_NEW;
1943 
1944  if ( b == YY_CURRENT_BUFFER )
1945  parser__load_buffer_state( );
1946 }
1947 
1954 void parser_push_buffer_state (YY_BUFFER_STATE new_buffer )
1955 {
1956  if (new_buffer == NULL)
1957  return;
1958 
1959  parser_ensure_buffer_stack();
1960 
1961  /* This block is copied from parser__switch_to_buffer. */
1962  if ( YY_CURRENT_BUFFER )
1963  {
1964  /* Flush out information for old buffer. */
1965  *(yy_c_buf_p) = (yy_hold_char);
1966  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1967  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1968  }
1969 
1970  /* Only push if top exists. Otherwise, replace top. */
1971  if (YY_CURRENT_BUFFER)
1972  (yy_buffer_stack_top)++;
1973  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1974 
1975  /* copied from parser__switch_to_buffer. */
1976  parser__load_buffer_state( );
1977  (yy_did_buffer_switch_on_eof) = 1;
1978 }
1979 
1984 void parser_pop_buffer_state (void)
1985 {
1986  if (!YY_CURRENT_BUFFER)
1987  return;
1988 
1989  parser__delete_buffer(YY_CURRENT_BUFFER );
1990  YY_CURRENT_BUFFER_LVALUE = NULL;
1991  if ((yy_buffer_stack_top) > 0)
1992  --(yy_buffer_stack_top);
1993 
1994  if (YY_CURRENT_BUFFER) {
1995  parser__load_buffer_state( );
1996  (yy_did_buffer_switch_on_eof) = 1;
1997  }
1998 }
1999 
2000 /* Allocates the stack if it does not exist.
2001  * Guarantees space for at least one push.
2002  */
2003 static void parser_ensure_buffer_stack (void)
2004 {
2005  yy_size_t num_to_alloc;
2006 
2007  if (!(yy_buffer_stack)) {
2008 
2009  /* First allocation is just for 2 elements, since we don't know if this
2010  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2011  * immediate realloc on the next call.
2012  */
2013  num_to_alloc = 1;
2014  (yy_buffer_stack) = (struct yy_buffer_state**)parser_alloc
2015  (num_to_alloc * sizeof(struct yy_buffer_state*)
2016  );
2017  if ( ! (yy_buffer_stack) )
2018  YY_FATAL_ERROR( "out of dynamic memory in parser_ensure_buffer_stack()" );
2019 
2020  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2021 
2022  (yy_buffer_stack_max) = num_to_alloc;
2023  (yy_buffer_stack_top) = 0;
2024  return;
2025  }
2026 
2027  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2028 
2029  /* Increase the buffer to prepare for a possible push. */
2030  int grow_size = 8 /* arbitrary grow size */;
2031 
2032  num_to_alloc = (yy_buffer_stack_max) + grow_size;
2033  (yy_buffer_stack) = (struct yy_buffer_state**)parser_realloc
2034  ((yy_buffer_stack),
2035  num_to_alloc * sizeof(struct yy_buffer_state*)
2036  );
2037  if ( ! (yy_buffer_stack) )
2038  YY_FATAL_ERROR( "out of dynamic memory in parser_ensure_buffer_stack()" );
2039 
2040  /* zero only the new slots.*/
2041  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2042  (yy_buffer_stack_max) = num_to_alloc;
2043  }
2044 }
2045 
2052 YY_BUFFER_STATE parser__scan_buffer (char * base, yy_size_t size )
2053 {
2054  YY_BUFFER_STATE b;
2055 
2056  if ( size < 2 ||
2057  base[size-2] != YY_END_OF_BUFFER_CHAR ||
2058  base[size-1] != YY_END_OF_BUFFER_CHAR )
2059  /* They forgot to leave room for the EOB's. */
2060  return 0;
2061 
2062  b = (YY_BUFFER_STATE) parser_alloc(sizeof( struct yy_buffer_state ) );
2063  if ( ! b )
2064  YY_FATAL_ERROR( "out of dynamic memory in parser__scan_buffer()" );
2065 
2066  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2067  b->yy_buf_pos = b->yy_ch_buf = base;
2068  b->yy_is_our_buffer = 0;
2069  b->yy_input_file = 0;
2070  b->yy_n_chars = b->yy_buf_size;
2071  b->yy_is_interactive = 0;
2072  b->yy_at_bol = 1;
2073  b->yy_fill_buffer = 0;
2074  b->yy_buffer_status = YY_BUFFER_NEW;
2075 
2076  parser__switch_to_buffer(b );
2077 
2078  return b;
2079 }
2080 
2089 YY_BUFFER_STATE parser__scan_string (yyconst char * yystr )
2090 {
2091 
2092  return parser__scan_bytes(yystr,strlen(yystr) );
2093 }
2094 
2102 YY_BUFFER_STATE parser__scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
2103 {
2104  YY_BUFFER_STATE b;
2105  char *buf;
2106  yy_size_t n;
2107  yy_size_t i;
2108 
2109  /* Get memory for full buffer, including space for trailing EOB's. */
2110  n = _yybytes_len + 2;
2111  buf = (char *) parser_alloc(n );
2112  if ( ! buf )
2113  YY_FATAL_ERROR( "out of dynamic memory in parser__scan_bytes()" );
2114 
2115  for ( i = 0; i < _yybytes_len; ++i )
2116  buf[i] = yybytes[i];
2117 
2118  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2119 
2120  b = parser__scan_buffer(buf,n );
2121  if ( ! b )
2122  YY_FATAL_ERROR( "bad buffer in parser__scan_bytes()" );
2123 
2124  /* It's okay to grow etc. this buffer, and we should throw it
2125  * away when we're done.
2126  */
2127  b->yy_is_our_buffer = 1;
2128 
2129  return b;
2130 }
2131 
2132  static void yy_push_state (int new_state )
2133 {
2134  if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
2135  {
2136  yy_size_t new_size;
2137 
2138  (yy_start_stack_depth) += YY_START_STACK_INCR;
2139  new_size = (yy_start_stack_depth) * sizeof( int );
2140 
2141  if ( ! (yy_start_stack) )
2142  (yy_start_stack) = (int *) parser_alloc(new_size );
2143 
2144  else
2145  (yy_start_stack) = (int *) parser_realloc((void *) (yy_start_stack),new_size );
2146 
2147  if ( ! (yy_start_stack) )
2148  YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
2149  }
2150 
2151  (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
2152 
2153  BEGIN(new_state);
2154 }
2155 
2156  static void yy_pop_state (void)
2157 {
2158  if ( --(yy_start_stack_ptr) < 0 )
2159  YY_FATAL_ERROR( "start-condition stack underflow" );
2160 
2161  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
2162 }
2163 
2164 #ifndef YY_EXIT_FAILURE
2165 #define YY_EXIT_FAILURE 2
2166 #endif
2167 
2168 static void yy_fatal_error (yyconst char* msg )
2169 {
2170  (void) fprintf( stderr, "%s\n", msg );
2171  exit( YY_EXIT_FAILURE );
2172 }
2173 
2174 /* Redefine yyless() so it works in section 3 code. */
2175 
2176 #undef yyless
2177 #define yyless(n) \
2178  do \
2179  { \
2180  /* Undo effects of setting up parser_text. */ \
2181  int yyless_macro_arg = (n); \
2182  YY_LESS_LINENO(yyless_macro_arg);\
2183  parser_text[parser_leng] = (yy_hold_char); \
2184  (yy_c_buf_p) = parser_text + yyless_macro_arg; \
2185  (yy_hold_char) = *(yy_c_buf_p); \
2186  *(yy_c_buf_p) = '\0'; \
2187  parser_leng = yyless_macro_arg; \
2188  } \
2189  while ( 0 )
2190 
2191 /* Accessor methods (get/set functions) to struct members. */
2192 
2196 int parser_get_lineno (void)
2197 {
2198 
2199  return parser_lineno;
2200 }
2201 
2205 FILE *parser_get_in (void)
2206 {
2207  return parser_in;
2208 }
2209 
2213 FILE *parser_get_out (void)
2214 {
2215  return parser_out;
2216 }
2217 
2221 yy_size_t parser_get_leng (void)
2222 {
2223  return parser_leng;
2224 }
2225 
2230 char *parser_get_text (void)
2231 {
2232  return parser_text;
2233 }
2234 
2239 void parser_set_lineno (int line_number )
2240 {
2241 
2242  parser_lineno = line_number;
2243 }
2244 
2251 void parser_set_in (FILE * in_str )
2252 {
2253  parser_in = in_str ;
2254 }
2255 
2256 void parser_set_out (FILE * out_str )
2257 {
2258  parser_out = out_str ;
2259 }
2260 
2261 int parser_get_debug (void)
2262 {
2263  return parser__flex_debug;
2264 }
2265 
2266 void parser_set_debug (int bdebug )
2267 {
2268  parser__flex_debug = bdebug ;
2269 }
2270 
2271 static int yy_init_globals (void)
2272 {
2273  /* Initialization is the same as for the non-reentrant scanner.
2274  * This function is called from parser_lex_destroy(), so don't allocate here.
2275  */
2276 
2277  (yy_buffer_stack) = 0;
2278  (yy_buffer_stack_top) = 0;
2279  (yy_buffer_stack_max) = 0;
2280  (yy_c_buf_p) = (char *) 0;
2281  (yy_init) = 0;
2282  (yy_start) = 0;
2283 
2284  (yy_start_stack_ptr) = 0;
2285  (yy_start_stack_depth) = 0;
2286  (yy_start_stack) = NULL;
2287 
2288 /* Defined in main.c */
2289 #ifdef YY_STDINIT
2290  parser_in = stdin;
2291  parser_out = stdout;
2292 #else
2293  parser_in = (FILE *) 0;
2294  parser_out = (FILE *) 0;
2295 #endif
2296 
2297  /* For future reference: Set errno on error, since we are called by
2298  * parser_lex_init()
2299  */
2300  return 0;
2301 }
2302 
2303 /* parser_lex_destroy is for both reentrant and non-reentrant scanners. */
2304 int parser_lex_destroy (void)
2305 {
2306 
2307  /* Pop the buffer stack, destroying each element. */
2308  while(YY_CURRENT_BUFFER){
2309  parser__delete_buffer(YY_CURRENT_BUFFER );
2310  YY_CURRENT_BUFFER_LVALUE = NULL;
2311  parser_pop_buffer_state();
2312  }
2313 
2314  /* Destroy the stack itself. */
2315  parser_free((yy_buffer_stack) );
2316  (yy_buffer_stack) = NULL;
2317 
2318  /* Destroy the start condition stack. */
2319  parser_free((yy_start_stack) );
2320  (yy_start_stack) = NULL;
2321 
2322  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2323  * parser_lex() is called, initialization will occur. */
2324  yy_init_globals( );
2325 
2326  return 0;
2327 }
2328 
2329 /*
2330  * Internal utility routines.
2331  */
2332 
2333 #ifndef yytext_ptr
2334 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2335 {
2336  register int i;
2337  for ( i = 0; i < n; ++i )
2338  s1[i] = s2[i];
2339 }
2340 #endif
2341 
2342 #ifdef YY_NEED_STRLEN
2343 static int yy_flex_strlen (yyconst char * s )
2344 {
2345  register int n;
2346  for ( n = 0; s[n]; ++n )
2347  ;
2348 
2349  return n;
2350 }
2351 #endif
2352 
2353 void *parser_alloc (yy_size_t size )
2354 {
2355  return (void *) malloc( size );
2356 }
2357 
2358 void *parser_realloc (void * ptr, yy_size_t size )
2359 {
2360  /* The cast to (char *) in the following accommodates both
2361  * implementations that use char* generic pointers, and those
2362  * that use void* generic pointers. It works with the latter
2363  * because both ANSI C and C++ allow castless assignment from
2364  * any pointer type to void*, and deal with argument conversions
2365  * as though doing an assignment.
2366  */
2367  return (void *) realloc( (char *) ptr, size );
2368 }
2369 
2370 void parser_free (void * ptr )
2371 {
2372  free( (char *) ptr ); /* see parser_realloc() for (char *) cast */
2373 }
2374 
2375 #define YYTABLES_NAME "yytables"
2376 
2377 #line 238 "parser.l"
2378 
2379 
2380 
2381 #ifndef parser_wrap
2382 int parser_wrap(void)
2383 {
2384  return 1;
2385 }
2386 #endif
2387 
2388 struct keyword {
2389  const char *kw;
2390  int token;
2391 };
2392 
2393 /* This table MUST be alphabetically sorted on the kw field */
2394 static const struct keyword keywords[] = {
2395  {"FALSE", tFALSE},
2396  {"NULL", tNULL},
2397  {"TRUE", tTRUE},
2398  {"__cdecl", tCDECL},
2399  {"__fastcall", tFASTCALL},
2400  {"__int32", tINT32},
2401  {"__int3264", tINT3264},
2402  {"__int64", tINT64},
2403  {"__pascal", tPASCAL},
2404  {"__stdcall", tSTDCALL},
2405  {"_cdecl", tCDECL},
2406  {"_fastcall", tFASTCALL},
2407  {"_pascal", tPASCAL},
2408  {"_stdcall", tSTDCALL},
2409  {"boolean", tBOOLEAN},
2410  {"byte", tBYTE},
2411  {"case", tCASE},
2412  {"cdecl", tCDECL},
2413  {"char", tCHAR},
2414  {"coclass", tCOCLASS},
2415  {"const", tCONST},
2416  {"cpp_quote", tCPPQUOTE},
2417  {"default", tDEFAULT},
2418  {"dispinterface", tDISPINTERFACE},
2419  {"double", tDOUBLE},
2420  {"enum", tENUM},
2421  {"error_status_t", tERRORSTATUST},
2422  {"extern", tEXTERN},
2423  {"float", tFLOAT},
2424  {"handle_t", tHANDLET},
2425  {"hyper", tHYPER},
2426  {"import", tIMPORT},
2427  {"importlib", tIMPORTLIB},
2428  {"inline", tINLINE},
2429  {"int", tINT},
2430  {"interface", tINTERFACE},
2431  {"library", tLIBRARY},
2432  {"long", tLONG},
2433  {"methods", tMETHODS},
2434  {"module", tMODULE},
2435  {"namespace", tNAMESPACE},
2436  {"pascal", tPASCAL},
2437  {"properties", tPROPERTIES},
2438  {"register", tREGISTER},
2439  {"short", tSHORT},
2440  {"signed", tSIGNED},
2441  {"sizeof", tSIZEOF},
2442  {"small", tSMALL},
2443  {"static", tSTATIC},
2444  {"stdcall", tSTDCALL},
2445  {"struct", tSTRUCT},
2446  {"switch", tSWITCH},
2447  {"typedef", tTYPEDEF},
2448  {"union", tUNION},
2449  {"unsigned", tUNSIGNED},
2450  {"void", tVOID},
2451  {"wchar_t", tWCHAR},
2452 };
2453 #define NKEYWORDS (sizeof(keywords)/sizeof(keywords[0]))
2454 
2455 /* keywords only recognized in attribute lists
2456  * This table MUST be alphabetically sorted on the kw field
2457  */
2458 static const struct keyword attr_keywords[] =
2459 {
2460  {"aggregatable", tAGGREGATABLE},
2461  {"allocate", tALLOCATE},
2462  {"annotation", tANNOTATION},
2463  {"apartment", tAPARTMENT},
2464  {"appobject", tAPPOBJECT},
2465  {"async", tASYNC},
2466  {"async_uuid", tASYNCUUID},
2467  {"auto_handle", tAUTOHANDLE},
2468  {"bindable", tBINDABLE},
2469  {"both", tBOTH},
2470  {"broadcast", tBROADCAST},
2471  {"byte_count", tBYTECOUNT},
2472  {"call_as", tCALLAS},
2473  {"callback", tCALLBACK},
2474  {"code", tCODE},
2475  {"comm_status", tCOMMSTATUS},
2476  {"context_handle", tCONTEXTHANDLE},
2477  {"context_handle_noserialize", tCONTEXTHANDLENOSERIALIZE},
2478  {"context_handle_serialize", tCONTEXTHANDLENOSERIALIZE},
2479  {"control", tCONTROL},
2480  {"decode", tDECODE},
2481  {"defaultbind", tDEFAULTBIND},
2482  {"defaultcollelem", tDEFAULTCOLLELEM},
2483  {"defaultvalue", tDEFAULTVALUE},
2484  {"defaultvtable", tDEFAULTVTABLE},
2485  {"disable_consistency_check", tDISABLECONSISTENCYCHECK},
2486  {"displaybind", tDISPLAYBIND},
2487  {"dllname", tDLLNAME},
2488  {"dual", tDUAL},
2489  {"enable_allocate", tENABLEALLOCATE},
2490  {"encode", tENCODE},
2491  {"endpoint", tENDPOINT},
2492  {"entry", tENTRY},
2493  {"explicit_handle", tEXPLICITHANDLE},
2494  {"fault_status", tFAULTSTATUS},
2495  {"force_allocate", tFORCEALLOCATE},
2496  {"free", tFREE},
2497  {"handle", tHANDLE},
2498  {"helpcontext", tHELPCONTEXT},
2499  {"helpfile", tHELPFILE},
2500  {"helpstring", tHELPSTRING},
2501  {"helpstringcontext", tHELPSTRINGCONTEXT},
2502  {"helpstringdll", tHELPSTRINGDLL},
2503  {"hidden", tHIDDEN},
2504  {"id", tID},
2505  {"idempotent", tIDEMPOTENT},
2506  {"ignore", tIGNORE},
2507  {"iid_is", tIIDIS},
2508  {"immediatebind", tIMMEDIATEBIND},
2509  {"implicit_handle", tIMPLICITHANDLE},
2510  {"in", tIN},
2511  {"in_line", tIN_LINE},
2512  {"input_sync", tINPUTSYNC},
2513  {"lcid", tLCID},
2514  {"length_is", tLENGTHIS},
2515  {"licensed", tLICENSED},
2516  {"local", tLOCAL},
2517  {"maybe", tMAYBE},
2518  {"message", tMESSAGE},
2519  {"neutral", tNEUTRAL},
2520  {"nocode", tNOCODE},
2521  {"nonbrowsable", tNONBROWSABLE},
2522  {"noncreatable", tNONCREATABLE},
2523  {"nonextensible", tNONEXTENSIBLE},
2524  {"notify", tNOTIFY},
2525  {"notify_flag", tNOTIFYFLAG},
2526  {"object", tOBJECT},
2527  {"odl", tODL},
2528  {"oleautomation", tOLEAUTOMATION},
2529  {"optimize", tOPTIMIZE},
2530  {"optional", tOPTIONAL},
2531  {"out", tOUT},
2532  {"partial_ignore", tPARTIALIGNORE},
2533  {"pointer_default", tPOINTERDEFAULT},
2534  {"progid", tPROGID},
2535  {"propget", tPROPGET},
2536  {"propput", tPROPPUT},
2537  {"propputref", tPROPPUTREF},
2538  {"proxy", tPROXY},
2539  {"ptr", tPTR},
2540  {"public", tPUBLIC},
2541  {"range", tRANGE},
2542  {"readonly", tREADONLY},
2543  {"ref", tREF},
2544  {"represent_as", tREPRESENTAS},
2545  {"requestedit", tREQUESTEDIT},
2546  {"restricted", tRESTRICTED},
2547  {"retval", tRETVAL},
2548  {"single", tSINGLE},
2549  {"size_is", tSIZEIS},
2550  {"source", tSOURCE},
2551  {"strict_context_handle", tSTRICTCONTEXTHANDLE},
2552  {"string", tSTRING},
2553  {"switch_is", tSWITCHIS},
2554  {"switch_type", tSWITCHTYPE},
2555  {"threading", tTHREADING},
2556  {"transmit_as", tTRANSMITAS},
2557  {"uidefault", tUIDEFAULT},
2558  {"unique", tUNIQUE},
2559  {"user_marshal", tUSERMARSHAL},
2560  {"usesgetlasterror", tUSESGETLASTERROR},
2561  {"uuid", tUUID},
2562  {"v1_enum", tV1ENUM},
2563  {"vararg", tVARARG},
2564  {"version", tVERSION},
2565  {"vi_progid", tVIPROGID},
2566  {"wire_marshal", tWIREMARSHAL},
2567 };
2568 
2569 /* attributes TODO:
2570  custom
2571  first_is
2572  last_is
2573  max_is
2574  min_is
2575 */
2576 
2577 #define KWP(p) ((const struct keyword *)(p))
2578 
2579 static int kw_cmp_func(const void *s1, const void *s2)
2580 {
2581  return strcmp(KWP(s1)->kw, KWP(s2)->kw);
2582 }
2583 
2584 static int kw_token(const char *kw)
2585 {
2586  struct keyword key, *kwp;
2587  key.kw = kw;
2588  kwp = bsearch(&key, keywords, NKEYWORDS, sizeof(keywords[0]), kw_cmp_func);
2589  if (kwp && (winrt_mode || kwp->token != tNAMESPACE)) {
2590  parser_lval.str = xstrdup(kwp->kw);
2591  return kwp->token;
2592  }
2593  parser_lval.str = xstrdup(kw);
2594  return is_type(kw) ? aKNOWNTYPE : aIDENTIFIER;
2595 }
2596 
2597 static int attr_token(const char *kw)
2598 {
2599  struct keyword key, *kwp;
2600  key.kw = kw;
2601  kwp = bsearch(&key, attr_keywords, sizeof(attr_keywords)/sizeof(attr_keywords[0]),
2602  sizeof(attr_keywords[0]), kw_cmp_func);
2603  if (kwp) {
2604  parser_lval.str = xstrdup(kwp->kw);
2605  return kwp->token;
2606  }
2607  return kw_token(kw);
2608 }
2609 
2610 static void addcchar(char c)
2611 {
2612  if(cbufidx >= cbufalloc)
2613  {
2614  cbufalloc += 1024;
2615  cbuffer = xrealloc(cbuffer, cbufalloc * sizeof(cbuffer[0]));
2616  if(cbufalloc > 65536)
2617  parser_warning("Reallocating string buffer larger than 64kB\n");
2618  }
2619  cbuffer[cbufidx++] = c;
2620 }
2621 
2622 static char *get_buffered_cstring(void)
2623 {
2624  addcchar(0);
2625  return xstrdup(cbuffer);
2626 }
2627 
2628 void pop_import(void)
2629 {
2630  int ptr = import_stack_ptr-1;
2631 
2632  fclose(parser_in);
2633  parser__delete_buffer(YY_CURRENT_BUFFER );
2634  parser__switch_to_buffer(import_stack[ptr].state );
2635  if (temp_name) {
2636  unlink(temp_name);
2637  free(temp_name);
2638  }
2639  temp_name = import_stack[ptr].temp_name;
2640  input_name = import_stack[ptr].input_name;
2641  line_number = import_stack[ptr].line_number;
2642  import_stack_ptr--;
2643 }
2644 
2645 struct imports {
2646  char *name;
2647  struct imports *next;
2648 } *first_import;
2649 
2650 int do_import(char *fname)
2651 {
2652  FILE *f;
2653  char *path, *name;
2654  struct imports *import;
2655  int ptr = import_stack_ptr;
2656  int ret, fd;
2657 
2658  import = first_import;
2659  while (import && strcmp(import->name, fname))
2660  import = import->next;
2661  if (import) return 0; /* already imported */
2662 
2663  import = xmalloc(sizeof(struct imports));
2664  import->name = xstrdup(fname);
2665  import->next = first_import;
2666  first_import = import;
2667 
2668  /* don't search for a file name with a path in the include directories,
2669  * for compatibility with MIDL */
2670  if (strchr( fname, '/' ) || strchr( fname, '\\' ))
2671  path = xstrdup( fname );
2672  else if (!(path = wpp_find_include( fname, input_name )))
2673  error_loc("Unable to open include file %s\n", fname);
2674 
2675  if (import_stack_ptr == MAX_IMPORT_DEPTH)
2676  error_loc("Exceeded max import depth\n");
2677 
2678  import_stack[ptr].temp_name = temp_name;
2679  import_stack[ptr].input_name = input_name;
2680  import_stack[ptr].line_number = line_number;
2681  import_stack_ptr++;
2682  input_name = path;
2683  line_number = 1;
2684 
2685  name = xstrdup( "widl.XXXXXX" );
2686  if((fd = mkstemps( name, 0 )) == -1)
2687  error("Could not generate a temp name from %s\n", name);
2688 
2689  temp_name = name;
2690  if (!(f = fdopen(fd, "wt")))
2691  error("Could not open fd %s for writing\n", name);
2692 
2693  ret = wpp_parse( path, f );
2694  fclose( f );
2695  if (ret) exit(1);
2696 
2697  if((f = fopen(temp_name, "r")) == NULL)
2698  error_loc("Unable to open %s\n", temp_name);
2699 
2700  import_stack[ptr].state = YY_CURRENT_BUFFER;
2701  parser__switch_to_buffer(parser__create_buffer(f,YY_BUF_SIZE));
2702  return 1;
2703 }
2704 
2705 void abort_import(void)
2706 {
2707  int ptr;
2708 
2709  for (ptr=0; ptr<import_stack_ptr; ptr++)
2710  unlink(import_stack[ptr].temp_name);
2711 }
2712 
2713 static void switch_to_acf(void)
2714 {
2715  int ptr = import_stack_ptr;
2716  int ret, fd;
2717  char *name;
2718  FILE *f;
2719 
2720  assert(import_stack_ptr == 0);
2721 
2722  input_name = acf_name;
2723  acf_name = NULL;
2724  line_number = 1;
2725 
2726  name = xstrdup( "widl.XXXXXX" );
2727  if((fd = mkstemps( name, 0 )) == -1)
2728  error("Could not generate a temp name from %s\n", name);
2729 
2730  temp_name = name;
2731  if (!(f = fdopen(fd, "wt")))
2732  error("Could not open fd %s for writing\n", name);
2733 
2734  ret = wpp_parse(input_name, f);
2735  fclose(f);
2736  if (ret) exit(1);
2737 
2738  if((f = fopen(temp_name, "r")) == NULL)
2739  error_loc("Unable to open %s\n", temp_name);
2740 
2741  import_stack[ptr].state = YY_CURRENT_BUFFER;
2742  parser__switch_to_buffer(parser__create_buffer(f,YY_BUF_SIZE));
2743 }
2744 
2745 static void warning_disable(int warning)
2746 {
2747  warning_t *warning_entry;
2748  LIST_FOR_EACH_ENTRY(warning_entry, disabled_warnings, warning_t, entry)
2749  if(warning_entry->num == warning)
2750  return;
2751  warning_entry = xmalloc( sizeof(*warning_entry) );
2752  warning_entry->num = warning;
2753  list_add_tail(disabled_warnings, &warning_entry->entry);
2754 }
2755 
2756 static void warning_enable(int warning)
2757 {
2758  warning_t *warning_entry;
2759  LIST_FOR_EACH_ENTRY(warning_entry, disabled_warnings, warning_t, entry)
2760  if(warning_entry->num == warning)
2761  {
2762  list_remove(&warning_entry->entry);
2763  free(warning_entry);
2764  break;
2765  }
2766 }
2767 
2768 int do_warning(char *toggle, warning_list_t *wnum)
2769 {
2770  warning_t *warning, *next;
2771  int ret = 1;
2772  if(!disabled_warnings)
2773  {
2774  disabled_warnings = xmalloc( sizeof(*disabled_warnings) );
2775  list_init( disabled_warnings );
2776  }
2777 
2778  if(!strcmp(toggle, "disable"))
2779  LIST_FOR_EACH_ENTRY(warning, wnum, warning_t, entry)
2780  warning_disable(warning->num);
2781  else if(!strcmp(toggle, "enable"))
2782  LIST_FOR_EACH_ENTRY(warning, wnum, warning_t, entry)
2783  warning_enable(warning->num);
2784  else
2785  ret = 0;
2786 
2787  LIST_FOR_EACH_ENTRY_SAFE(warning, next, wnum, warning_t, entry)
2788  free(warning);
2789  return ret;
2790 }
2791 
2792 int is_warning_enabled(int warning)
2793 {
2794  warning_t *warning_entry;
2795  if(!disabled_warnings)
2796  return 1;
2797  LIST_FOR_EACH_ENTRY(warning_entry, disabled_warnings, warning_t, entry)
2798  if(warning_entry->num == warning)
2799  return 0;
2800  return 1;
2801 }
2802 
realloc
#define realloc
Definition: debug_ros.c:6
u
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 * u
Definition: glfuncs.h:240
parser_out
FILE * parser_out
Definition: parser.yy.c:357
flex_int32_t
int flex_int32_t
Definition: parser.yy.c:72
YYSTYPE::uuid
UUID * uuid
Definition: parser.tab.c:465
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: parser.yy.c:376
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: parser.yy.c:384
WSTRQUOTE
#define WSTRQUOTE
Definition: parser.yy.c:822
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: macro.lex.yy.c:195
yy_buffer_state::yy_input_file
FILE * yy_input_file
Definition: macro.lex.yy.c:192
isspace
#define isspace(c)
Definition: acclib.h:69
cbufidx
static int cbufidx
Definition: parser.yy.c:761
strtoul
UINT32 strtoul(const char *String, char **Terminator, UINT32 Base)
Definition: utclib.c:696
parser_free
void parser_free(void *)
Definition: parser.yy.c:2370
parser__delete_buffer
void parser__delete_buffer(YY_BUFFER_STATE b)
Definition: parser.yy.c:1878
yy_buffer_state::yy_n_chars
yy_size_t yy_n_chars
Definition: macro.lex.yy.c:205
s2
struct S2 s2
TRUE
#define TRUE
Definition: types.h:120
parser__flex_debug
int parser__flex_debug
Definition: parser.yy.c:694
attr_keywords
static const struct keyword attr_keywords[]
Definition: parser.yy.c:2458
parser_push_buffer_state
void parser_push_buffer_state(YY_BUFFER_STATE new_buffer)
Definition: parser.yy.c:1954
yy_init
static int yy_init
Definition: parser.yy.c:299
yy_cp
register char * yy_cp
Definition: parser.yy.c:1012
void
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
do_warning
int do_warning(char *toggle, warning_list_t *wnum)
Definition: parser.yy.c:2768
parser__init_buffer
static void parser__init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: parser.yy.c:1897
error
#define error(str)
Definition: mkdosfs.c:1605
yy_push_state
static void yy_push_state(int new_state)
Definition: parser.yy.c:2132
parser_in
FILE * parser_in
Definition: parser.yy.c:357
keywords
static const struct keyword keywords[]
Definition: parser.yy.c:2394
attr_token
static int attr_token(const char *kw)
Definition: parser.yy.c:2597
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: parser.yy.c:186
YY_NEW_FILE
#define YY_NEW_FILE
Definition: parser.yy.c:158
YY_CHAR
unsigned char YY_CHAR
Definition: macro.lex.yy.c:336
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: parser.yy.c:283
strtod
_Check_return_ double __cdecl strtod(_In_z_ const char *_Str, _Out_opt_ _Deref_post_z_ char **_EndPtr)
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: macro.lex.yy.c:232
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: parser.yy.c:155
parser_realloc
void * parser_realloc(void *, yy_size_t)
Definition: parser.yy.c:2358
yy_init_globals
static int yy_init_globals(void)
Definition: parser.yy.c:2271
path
GLsizei const GLchar ** path
Definition: glext.h:7234
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: parser.yy.c:1001
MAX_IMPORT_DEPTH
#define MAX_IMPORT_DEPTH
Definition: parser.yy.c:771
cbufalloc
static int cbufalloc
Definition: parser.yy.c:762
free
#define free
Definition: debug_ros.c:5
wpp_find_include
char * wpp_find_include(const char *name, const char *parent_name)
Definition: preproc.c:509
offset
GLintptr offset
Definition: glext.h:5920
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: parser.yy.c:290
parser_text
char * parser_text
Definition: parser.yy.c:703
n
GLdouble n
Definition: glext.h:7729
unlink
#define unlink
Definition: syshdrs.h:54
yy_size_t
size_t yy_size_t
Definition: macro.lex.yy.c:159
flex_uint8_t
unsigned char flex_uint8_t
Definition: parser.yy.c:73
yy_state_type
int yy_state_type
Definition: parser.yy.c:359
yy_chk
static yyconst flex_int16_t yy_chk[728]
Definition: parser.yy.c:606
assert
#define assert(x)
Definition: debug.h:53
ECHO
#define ECHO
Definition: parser.yy.c:919
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: parser.yy.c:160
parser_set_out
void parser_set_out(FILE *out_str)
Definition: parser.yy.c:2256
fd
static int fd
Definition: io.c:51
stdin
FILE * stdin
parser_get_out
FILE * parser_get_out(void)
Definition: parser.yy.c:2213
line_number
int line_number
Definition: parser.yy.c:775
errno
int errno
uint16_t
unsigned short int uint16_t
Definition: acefiex.h:54
yy_buffer_state::yy_bs_lineno
int yy_bs_lineno
Definition: macro.lex.yy.c:226
parser__scan_buffer
YY_BUFFER_STATE parser__scan_buffer(char *base, yy_size_t size)
Definition: parser.yy.c:2052
parser_set_in
void parser_set_in(FILE *in_str)
Definition: parser.yy.c:2251
is_warning_enabled
int is_warning_enabled(int warning)
Definition: parser.yy.c:2792
yy_get_previous_state
static yy_state_type yy_get_previous_state(void)
Definition: parser.yy.c:1651
YY_AT_BOL
#define YY_AT_BOL()
Definition: parser.yy.c:351
YY_START
#define YY_START
Definition: parser.yy.c:151
is_type
int is_type(const char *name)
Definition: parser.tab.c:6173
KWP
#define KWP(p)
Definition: parser.yy.c:2577
stdout
FILE * stdout
YY_DECL
#define YY_DECL
Definition: parser.yy.c:986
parser__load_buffer_state
static void parser__load_buffer_state(void)
Definition: parser.yy.c:1836
yy_buffer_state::yy_buf_size
yy_size_t yy_buf_size
Definition: macro.lex.yy.c:200
list_add_tail
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
keyword::token
int token
Definition: parser.yy.c:2390
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: parser.yy.c:926
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: parser.yy.c:837
LIST_FOR_EACH_ENTRY
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
i
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
parser_get_text
char * parser_get_text(void)
Definition: parser.yy.c:2230
parser__switch_to_buffer
void parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: parser.yy.c:1805
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: parser.yy.c:305
xrealloc
void * xrealloc(void *oldmem, size_t size)
Definition: uimain.c:736
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: parser.yy.c:701
kw_token
static int kw_token(const char *kw)
Definition: parser.yy.c:2584
YYSTYPE::str
jsstr_t * str
Definition: parser.tab.c:295
wpp_parse
int wpp_parse(const char *input, FILE *output)
Definition: compiler.c:437
xmalloc
void * xmalloc(int size)
Definition: uimain.c:747
base
GLuint base
Definition: 3dtext.c:35
fprintf
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
kw_cmp_func
static int kw_cmp_func(const void *s1, const void *s2)
Definition: parser.yy.c:2579
BEGIN
#define BEGIN
Definition: parser.yy.c:145
addcchar
static void addcchar(char c)
Definition: parser.yy.c:2610
yy_accept
static yyconst flex_int16_t yy_accept[210]
Definition: parser.yy.c:392
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: parser.yy.c:173
parser_get_extra
YY_EXTRA_TYPE parser_get_extra(void)
ptr
static PVOID ptr
Definition: dispmode.c:27
yy_n_chars
static yy_size_t yy_n_chars
Definition: parser.yy.c:294
SQUOTE
#define SQUOTE
Definition: parser.yy.c:826
error_loc
void error_loc(const char *s,...)
Definition: utils.c:69
PP_PRAGMA
#define PP_PRAGMA
Definition: parser.yy.c:825
yy_state_type
int yy_state_type
Definition: macro.lex.yy.c:340
NULL
smooth NULL
Definition: ftsmooth.c:416
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: macro.lex.yy.c:224
yy_buffer_stack
static YY_BUFFER_STATE * yy_buffer_stack
Definition: parser.yy.c:275
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: parser.yy.c:267
yy_buffer_state::yy_bs_column
int yy_bs_column
Definition: macro.lex.yy.c:227
parser_lex_destroy
int parser_lex_destroy(void)
Definition: parser.yy.c:2304
abort_import
void abort_import(void)
Definition: parser.yy.c:2705
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: parser.yy.c:256
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: parser.yy.c:911
yy_size_t
size_t yy_size_t
Definition: parser.yy.c:178
parser_lval
YYSTYPE parser_lval
b
#define b
Definition: ke_i.h:79
val
GLuint GLfloat * val
Definition: glext.h:7180
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: parser.yy.c:164
do_import
int do_import(char *fname)
Definition: parser.yy.c:2650
list_remove
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
yy_nxt
static yyconst flex_int16_t yy_nxt[728]
Definition: parser.yy.c:522
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: parser.yy.c:187
f
GLfloat f
Definition: glext.h:7540
int8_t
signed char int8_t
Definition: acefiex.h:50
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
size
GLsizeiptr size
Definition: glext.h:5919
import_stack
struct @4049 import_stack[MAX_IMPORT_DEPTH]
YYSTYPE::num
unsigned int num
Definition: parser.tab.c:466
yy_start_stack_ptr
static int yy_start_stack_ptr
Definition: parser.yy.c:901
keyword::kw
const char * kw
Definition: parser.yy.c:2389
s1
struct S1 s1
disabled_warnings
static warning_list_t * disabled_warnings
Definition: parser.yy.c:769
flex_int16_t
short int flex_int16_t
Definition: parser.yy.c:71
parser_ensure_buffer_stack
static void parser_ensure_buffer_stack(void)
Definition: parser.yy.c:2003
file
const char file[]
Definition: icontest.c:11
_iobuf
Definition: mbstring.h:19
yy_fatal_error
static void yy_fatal_error(yyconst char msg[])
warning_disable
static void warning_disable(int warning)
Definition: parser.yy.c:2745
c
const GLubyte * c
Definition: glext.h:8905
strncmp
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
yy_act
register int yy_act
Definition: parser.yy.c:1013
parser_pop_buffer_state
void parser_pop_buffer_state(void)
Definition: parser.yy.c:1984
cbuffer
static char * cbuffer
Definition: parser.yy.c:760
yy_buffer_state::yy_ch_buf
char * yy_ch_buf
Definition: macro.lex.yy.c:194
parser_lineno
int parser_lineno
Definition: parser.yy.c:363
flex_int16_t
short int flex_int16_t
Definition: macro.lex.yy.c:52
yy_current_state
#define yy_current_state()
Definition: ppl.yy.c:1440
flex_int8_t
signed char flex_int8_t
Definition: parser.yy.c:70
yy_start_stack_depth
static int yy_start_stack_depth
Definition: parser.yy.c:902
yy_last_accepting_cpos
static char * yy_last_accepting_cpos
Definition: parser.yy.c:691
flex_int32_t
int flex_int32_t
Definition: macro.lex.yy.c:53
warning_enable
static void warning_enable(int warning)
Definition: parser.yy.c:2756
ERANGE
#define ERANGE
Definition: acclib.h:92
parser__create_buffer
YY_BUFFER_STATE parser__create_buffer(FILE *file, int size)
Definition: parser.yy.c:1850
parser_get_in
FILE * parser_get_in(void)
Definition: parser.yy.c:2205
import_stack_ptr
int import_stack_ptr
Definition: parser.yy.c:778
ret
int ret
Definition: wcstombs-tests.c:31
yy_buffer_state
Definition: macro.lex.yy.c:190
YY_START_STACK_INCR
#define YY_START_STACK_INCR
Definition: parser.yy.c:968
parser_get_debug
int parser_get_debug(void)
Definition: parser.yy.c:2261
ATTR
#define ATTR
Definition: parser.yy.c:823
yyconst
#define yyconst
Definition: parser.yy.c:128
parser_set_extra
void parser_set_extra(YY_EXTRA_TYPE user_defined)
YY_CHAR
unsigned char YY_CHAR
Definition: parser.yy.c:355
NKEYWORDS
#define NKEYWORDS
Definition: parser.yy.c:2453
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: macro.lex.yy.c:211
entry
uint32_t entry
Definition: isohybrid.c:63
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
len
GLenum GLsizei len
Definition: glext.h:6722
s
GLdouble s
Definition: gl.h:2039
parser_leng
yy_size_t parser_leng
Definition: parser.yy.c:295
list
Definition: _list.h:228
parse_uuid
UUID * parse_uuid(const char *u)
Definition: parser.yy.c:793
fclose
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
fopen
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
_warning_t::entry
struct list entry
Definition: widltypes.h:546
yy_buffer_stack_top
static size_t yy_buffer_stack_top
Definition: parser.yy.c:273
flex_uint32_t
unsigned int flex_uint32_t
Definition: parser.yy.c:75
_warning_t::num
int num
Definition: widltypes.h:545
parser_set_lineno
void parser_set_lineno(int line_number)
Definition: parser.yy.c:2239
uint8_t
BYTE uint8_t
Definition: msvideo1.c:66
xstrtoul
static unsigned int xstrtoul(const char *nptr, char **endptr, int base)
Definition: parser.yy.c:782
use_abi_namespace
int use_abi_namespace
Definition: widl.c:130
int32_t
INT32 int32_t
Definition: types.h:71
parser_alloc
void * parser_alloc(yy_size_t)
Definition: parser.yy.c:2353
switch_to_acf
static void switch_to_acf(void)
Definition: parser.yy.c:2713
PP_LINE
#define PP_LINE
Definition: parser.yy.c:824
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: parser.yy.c:185
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: parser.yy.c:1684
yy_base
static yyconst flex_int16_t yy_base[251]
Definition: parser.yy.c:460
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: parser.yy.c:139
yy_pop_state
static void yy_pop_state(void)
Definition: parser.yy.c:2156
next
static unsigned __int64 next
Definition: rand_nt.c:6
imports::next
struct imports * next
Definition: parser.yy.c:2647
LIST_FOR_EACH_ENTRY_SAFE
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
parser__flush_buffer
void parser__flush_buffer(YY_BUFFER_STATE b)
Definition: parser.yy.c:1925
yy_trans_info::yy_verify
flex_int32_t yy_verify
Definition: macro.lex.yy.c:370
input
GLenum GLenum GLenum input
Definition: glext.h:9031
yy_start
static int yy_start
Definition: parser.yy.c:300
yy_bp
register char * yy_bp
Definition: parser.yy.c:1012
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: parser.yy.c:255
f
#define f
Definition: ke_i.h:83
parser_restart
void parser_restart(FILE *input_file)
Definition: parser.yy.c:1788
yyless
#define yyless(n)
Definition: parser.yy.c:2177
pop_import
void pop_import(void)
Definition: parser.yy.c:2628
fdopen
_Check_return_ _CRTIMP FILE *__cdecl fdopen(_In_ int _FileHandle, _In_z_ const char *_Format)
mkstemps
int mkstemps(char *template, int suffix_len)
Definition: mkstemps.c:73
yy_buffer_stack_max
static size_t yy_buffer_stack_max
Definition: parser.yy.c:274
temp_name
char * temp_name
Definition: parser.yy.c:776
yy_hold_char
static char yy_hold_char
Definition: parser.yy.c:293
parser_wrap
int parser_wrap(void)
Definition: parser.yy.c:2382
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: parser.yy.c:2165
first_import
struct imports * first_import
uint32_t
UINT32 uint32_t
Definition: types.h:75
get_buffered_cstring
static char * get_buffered_cstring(void)
Definition: parser.yy.c:2622
yy_start_stack
static int * yy_start_stack
Definition: parser.yy.c:903
yy_trans_info::yy_nxt
flex_int32_t yy_nxt
Definition: macro.lex.yy.c:371
strchr
char * strchr(const char *String, int ch)
Definition: utclib.c:501
flex_uint16_t
unsigned short int flex_uint16_t
Definition: parser.yy.c:74
msg
#define msg(x)
Definition: auth_time.c:54
EOF
#define EOF
Definition: stdio.h:24
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: macro.lex.yy.c:218
yytext_ptr
#define yytext_ptr
Definition: parser.yy.c:366
name
Definition: name.c:38
yy_get_next_buffer
static int yy_get_next_buffer(void)
Definition: parser.yy.c:1517
strtol
_Check_return_ long __cdecl strtol(_In_z_ const char *_Str, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
yy_last_accepting_state
static yy_state_type yy_last_accepting_state
Definition: parser.yy.c:690
list_init
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
c
#define c
Definition: ke_i.h:80
yy_ec
static yyconst flex_int32_t yy_ec[256]
Definition: parser.yy.c:419
uuid
Definition: msctf.idl:510
stderr
FILE * stderr
parser_set_debug
void parser_set_debug(int debug_flag)
Definition: parser.yy.c:2266
_warning_t
Definition: widltypes.h:544
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
parser__scan_bytes
YY_BUFFER_STATE parser__scan_bytes(yyconst char *bytes, yy_size_t len)
Definition: parser.yy.c:2102
malloc
#define malloc
Definition: debug_ros.c:4
QUOTE
#define QUOTE
Definition: parser.yy.c:821
yy_c_buf_p
static char * yy_c_buf_p
Definition: parser.yy.c:298
int16_t
INT16 int16_t
Definition: types.h:70
dest
static char * dest
Definition: rtl.c:135
imports::name
char * name
Definition: parser.yy.c:2646
exit
void exit(int exitcode)
Definition: _exit.c:33
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: parser.yy.c:702
YY_BREAK
#define YY_BREAK
Definition: parser.yy.c:998
parser_get_lineno
int parser_get_lineno(void)
Definition: parser.yy.c:2196
xstrdup
char * xstrdup(const char *s)
Definition: uimain.c:768
state
YY_BUFFER_STATE state
Definition: parser.yy.c:773
parser__scan_string
YY_BUFFER_STATE parser__scan_string(yyconst char *yy_str)
Definition: parser.yy.c:2089
acf_name
char * acf_name
Definition: widl.c:135
YYSTYPE::dbl
double dbl
Definition: parser.tab.c:269
memset
#define memset(x, y, z)
Definition: compat.h:39
INITIAL
#define INITIAL
Definition: parser.yy.c:820
yy_trans_info
Definition: macro.lex.yy.c:368
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: macro.lex.yy.c:234
parser_lex
int parser_lex(void)
yy_def
static yyconst flex_int16_t yy_def[251]
Definition: parser.yy.c:491
parser_get_leng
yy_size_t parser_get_leng(void)
Definition: parser.yy.c:2221
parser_warning
int parser_warning(const char *s,...)
Definition: utils.c:94
ULONG_MAX
#define ULONG_MAX
Definition: limits.h:44
yyterminate
#define yyterminate()
Definition: parser.yy.c:963
warning
#define warning(s)
Definition: debug.h:71
winrt_mode
int winrt_mode
Definition: widl.c:129
yy_meta
static yyconst flex_int32_t yy_meta[51]
Definition: parser.yy.c:451
key
Definition: path.c:41
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: parser.yy.c:973
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
input_name
char * input_name
Definition: parser.yy.c:774
file
Definition: fci.c:126
bsearch
#define bsearch
Definition: tif_config.wince.h:38
name
GLuint const GLchar * name
Definition: glext.h:6031