ReactOS  r74662
macro.lex.yy.c
Go to the documentation of this file.
1 #line 2 "macro.lex.yy.c"
2 
3 #line 4 "macro.lex.yy.c"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define FLEX_SCANNER
10 #define YY_FLEX_MAJOR_VERSION 2
11 #define YY_FLEX_MINOR_VERSION 5
12 #define YY_FLEX_SUBMINOR_VERSION 37
13 #if YY_FLEX_SUBMINOR_VERSION > 0
14 #define FLEX_BETA
15 #endif
16 
17 /* First, we deal with platform-specific or compiler-specific issues. */
18 
19 /* begin standard C headers. */
20 #include <stdio.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <stdlib.h>
24 
25 /* end standard C headers. */
26 
27 /* flex integer type definitions */
28 
29 #ifndef FLEXINT_H
30 #define FLEXINT_H
31 
32 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
33 
34 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
35 
36 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37  * if you want the limit (max/min) macros for int types.
38  */
39 #ifndef __STDC_LIMIT_MACROS
40 #define __STDC_LIMIT_MACROS 1
41 #endif
42 
43 #include <inttypes.h>
44 typedef int8_t flex_int8_t;
45 typedef uint8_t flex_uint8_t;
46 typedef int16_t flex_int16_t;
47 typedef uint16_t flex_uint16_t;
48 typedef int32_t flex_int32_t;
49 typedef uint32_t flex_uint32_t;
50 #else
51 typedef signed char flex_int8_t;
52 typedef short int flex_int16_t;
53 typedef int flex_int32_t;
54 typedef unsigned char flex_uint8_t;
55 typedef unsigned short int flex_uint16_t;
56 typedef unsigned int flex_uint32_t;
57 
58 /* Limits of integral types. */
59 #ifndef INT8_MIN
60 #define INT8_MIN (-128)
61 #endif
62 #ifndef INT16_MIN
63 #define INT16_MIN (-32767-1)
64 #endif
65 #ifndef INT32_MIN
66 #define INT32_MIN (-2147483647-1)
67 #endif
68 #ifndef INT8_MAX
69 #define INT8_MAX (127)
70 #endif
71 #ifndef INT16_MAX
72 #define INT16_MAX (32767)
73 #endif
74 #ifndef INT32_MAX
75 #define INT32_MAX (2147483647)
76 #endif
77 #ifndef UINT8_MAX
78 #define UINT8_MAX (255U)
79 #endif
80 #ifndef UINT16_MAX
81 #define UINT16_MAX (65535U)
82 #endif
83 #ifndef UINT32_MAX
84 #define UINT32_MAX (4294967295U)
85 #endif
86 
87 #endif /* ! C99 */
88 
89 #endif /* ! FLEXINT_H */
90 
91 #ifdef __cplusplus
92 
93 /* The "const" storage-class-modifier is valid. */
94 #define YY_USE_CONST
95 
96 #else /* ! __cplusplus */
97 
98 /* C99 requires __STDC__ to be defined as 1. */
99 #if defined (__STDC__)
100 
101 #define YY_USE_CONST
102 
103 #endif /* defined (__STDC__) */
104 #endif /* ! __cplusplus */
105 
106 #ifdef YY_USE_CONST
107 #define yyconst const
108 #else
109 #define yyconst
110 #endif
111 
112 /* Returned upon end-of-file. */
113 #define YY_NULL 0
114 
115 /* Promotes a possibly negative, possibly signed char to an unsigned
116  * integer for use as an array index. If the signed char is negative,
117  * we want to instead treat it as an 8-bit unsigned char, hence the
118  * double cast.
119  */
120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
121 
122 /* Enter a start condition. This macro really ought to take a parameter,
123  * but we do it the disgusting crufty way forced on us by the ()-less
124  * definition of BEGIN.
125  */
126 #define BEGIN (yy_start) = 1 + 2 *
127 
128 /* Translate the current start state into a value that can be later handed
129  * to BEGIN to return to the state. The YYSTATE alias is for lex
130  * compatibility.
131  */
132 #define YY_START (((yy_start) - 1) / 2)
133 #define YYSTATE YY_START
134 
135 /* Action number for EOF rule of a given start state. */
136 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
137 
138 /* Special action meaning "start processing a new file". */
139 #define YY_NEW_FILE yyrestart(yyin )
140 
141 #define YY_END_OF_BUFFER_CHAR 0
142 
143 /* Size of default input buffer. */
144 #ifndef YY_BUF_SIZE
145 #define YY_BUF_SIZE 16384
146 #endif
147 
148 /* The state buf must be large enough to hold one state per character in the main buffer.
149  */
150 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
151 
152 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
153 #define YY_TYPEDEF_YY_BUFFER_STATE
155 #endif
156 
157 #ifndef YY_TYPEDEF_YY_SIZE_T
158 #define YY_TYPEDEF_YY_SIZE_T
159 typedef size_t yy_size_t;
160 #endif
161 
162 extern yy_size_t yyleng;
163 
164 extern FILE *yyin, *yyout;
165 
166 #define EOB_ACT_CONTINUE_SCAN 0
167 #define EOB_ACT_END_OF_FILE 1
168 #define EOB_ACT_LAST_MATCH 2
169 
170  #define YY_LESS_LINENO(n)
171 
172 /* Return all but the first "n" matched characters back to the input stream. */
173 #define yyless(n) \
174  do \
175  { \
176  /* Undo effects of setting up yytext. */ \
177  int yyless_macro_arg = (n); \
178  YY_LESS_LINENO(yyless_macro_arg);\
179  *yy_cp = (yy_hold_char); \
180  YY_RESTORE_YY_MORE_OFFSET \
181  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
182  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
183  } \
184  while ( 0 )
185 
186 #define unput(c) yyunput( c, (yytext_ptr) )
187 
188 #ifndef YY_STRUCT_YY_BUFFER_STATE
189 #define YY_STRUCT_YY_BUFFER_STATE
191  {
193 
194  char *yy_ch_buf; /* input buffer */
195  char *yy_buf_pos; /* current position in input buffer */
196 
197  /* Size of input buffer in bytes, not including room for EOB
198  * characters.
199  */
201 
202  /* Number of characters read into yy_ch_buf, not including EOB
203  * characters.
204  */
206 
207  /* Whether we "own" the buffer - i.e., we know we created it,
208  * and can realloc() it to grow it, and should free() it to
209  * delete it.
210  */
212 
213  /* Whether this is an "interactive" input source; if so, and
214  * if we're using stdio for input, then we want to use getc()
215  * instead of fread(), to make sure we stop fetching input after
216  * each newline.
217  */
219 
220  /* Whether we're considered to be at the beginning of a line.
221  * If so, '^' rules will be active on the next match, otherwise
222  * not.
223  */
225 
229  /* Whether to try to fill the input buffer when we reach the
230  * end of it.
231  */
233 
235 
236 #define YY_BUFFER_NEW 0
237 #define YY_BUFFER_NORMAL 1
238  /* When an EOF's been seen but there's still some text to process
239  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
240  * shouldn't try reading from the input source any more. We might
241  * still have a bunch of tokens to match, though, because of
242  * possible backing-up.
243  *
244  * When we actually see the EOF, we change the status to "new"
245  * (via yyrestart()), so that the user can continue scanning by
246  * just pointing yyin at a new input file.
247  */
248 #define YY_BUFFER_EOF_PENDING 2
249 
250  };
251 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
252 
253 /* Stack of input buffers. */
254 static size_t yy_buffer_stack_top = 0;
255 static size_t yy_buffer_stack_max = 0;
256 static YY_BUFFER_STATE * yy_buffer_stack = 0;
258 /* We provide macros for accessing buffer states in case in the
259  * future we want to put the buffer states in a more general
260  * "scanner state".
261  *
262  * Returns the top of the stack, or NULL.
263  */
264 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
265  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
266  : NULL)
267 
268 /* Same as previous macro, but useful when we know that the buffer stack is not
269  * NULL or when we need an lvalue. For internal use only.
270  */
271 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
272 
273 /* yy_hold_char holds the character lost when yytext is formed. */
274 static char yy_hold_char;
275 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
277 
278 /* Points to current character in buffer. */
279 static char *yy_c_buf_p = (char *) 0;
280 static int yy_init = 0; /* whether we need to initialize */
281 static int yy_start = 0; /* start state number */
282 
283 /* Flag which is used to allow yywrap()'s to do buffer switches
284  * instead of setting up a fresh yyin. A bit of a hack ...
285  */
287 
288 void yyrestart (FILE *input_file );
289 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
290 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
291 void yy_delete_buffer (YY_BUFFER_STATE b );
292 void yy_flush_buffer (YY_BUFFER_STATE b );
293 void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
294 void yypop_buffer_state (void );
295 
296 static void yyensure_buffer_stack (void );
297 static void yy_load_buffer_state (void );
298 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
299 
300 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
301 
302 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
303 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
304 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len );
305 
306 void *yyalloc (yy_size_t );
307 void *yyrealloc (void *,yy_size_t );
308 void yyfree (void * );
309 
310 #define yy_new_buffer yy_create_buffer
311 
312 #define yy_set_interactive(is_interactive) \
313  { \
314  if ( ! YY_CURRENT_BUFFER ){ \
315  yyensure_buffer_stack (); \
316  YY_CURRENT_BUFFER_LVALUE = \
317  yy_create_buffer(yyin,YY_BUF_SIZE ); \
318  } \
319  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
320  }
321 
322 #define yy_set_bol(at_bol) \
323  { \
324  if ( ! YY_CURRENT_BUFFER ){\
325  yyensure_buffer_stack (); \
326  YY_CURRENT_BUFFER_LVALUE = \
327  yy_create_buffer(yyin,YY_BUF_SIZE ); \
328  } \
329  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
330  }
331 
332 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
333 
334 /* Begin user sect3 */
335 
336 typedef unsigned char YY_CHAR;
337 
338 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
339 
340 typedef int yy_state_type;
341 
342 extern int yylineno;
343 
344 int yylineno = 1;
345 
346 extern char *yytext;
347 #define yytext_ptr yytext
348 
349 static yy_state_type yy_get_previous_state (void );
350 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
351 static int yy_get_next_buffer (void );
352 static void yy_fatal_error (yyconst char msg[] );
353 
354 /* Done after the current pattern has been matched and before the
355  * corresponding action - sets up yytext.
356  */
357 #define YY_DO_BEFORE_ACTION \
358  (yytext_ptr) = yy_bp; \
359  yyleng = (size_t) (yy_cp - yy_bp); \
360  (yy_hold_char) = *yy_cp; \
361  *yy_cp = '\0'; \
362  (yy_c_buf_p) = yy_cp;
363 
364 #define YY_NUM_RULES 14
365 #define YY_END_OF_BUFFER 15
366 /* This struct is not used in this scanner,
367  but its presence is necessary. */
369  {
372  };
374  { 0,
375  0, 0, 0, 0, 15, 13, 14, 12, 5, 6,
376  13, 1, 1, 3, 4, 10, 8, 9, 10, 7,
377  1, 1, 0, 3, 11, 2, 0
378  } ;
379 
381  { 0,
382  1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
383  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
385  1, 3, 1, 4, 1, 1, 1, 1, 5, 1,
386  1, 1, 6, 1, 6, 1, 1, 7, 8, 8,
387  8, 8, 8, 8, 8, 8, 8, 1, 1, 1,
388  1, 1, 1, 1, 9, 9, 9, 9, 9, 9,
389  9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
390  9, 9, 9, 9, 9, 9, 9, 10, 9, 9,
391  1, 11, 1, 1, 12, 13, 14, 14, 14, 14,
392 
393  14, 14, 9, 9, 9, 9, 9, 9, 9, 9,
394  9, 9, 9, 9, 9, 9, 9, 9, 9, 10,
395  9, 9, 1, 1, 1, 1, 1, 1, 1, 1,
396  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
397  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403 
404  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409  1, 1, 1, 1, 1
410  } ;
411 
413  { 0,
414  1, 2, 1, 1, 1, 1, 3, 3, 4, 5,
415  1, 4, 1, 6
416  } ;
417 
419  { 0,
420  0, 0, 13, 25, 25, 62, 62, 62, 62, 62,
421  12, 13, 14, 0, 62, 62, 62, 62, 0, 62,
422  6, 24, 0, 0, 62, 0, 62, 38, 42, 45,
423  51, 55
424  } ;
425 
427  { 0,
428  27, 1, 28, 28, 27, 27, 27, 27, 27, 27,
429  27, 29, 27, 30, 27, 27, 27, 27, 31, 27,
430  29, 27, 32, 30, 27, 32, 0, 27, 27, 27,
431  27, 27
432  } ;
433 
435  { 0,
436  6, 7, 8, 9, 10, 11, 12, 13, 14, 14,
437  6, 6, 15, 14, 7, 23, 17, 18, 21, 22,
438  22, 22, 23, 19, 27, 20, 7, 27, 17, 18,
439  22, 22, 27, 27, 27, 19, 27, 20, 16, 16,
440  16, 16, 16, 16, 22, 27, 22, 24, 24, 24,
441  24, 25, 27, 25, 25, 25, 25, 26, 27, 27,
442  26, 5, 27, 27, 27, 27, 27, 27, 27, 27,
443  27, 27, 27, 27, 27, 27
444  } ;
445 
447  { 0,
448  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449  1, 1, 1, 1, 3, 21, 3, 3, 11, 11,
450  13, 13, 12, 3, 5, 3, 4, 0, 4, 4,
451  22, 22, 0, 0, 0, 4, 0, 4, 28, 28,
452  28, 28, 28, 28, 29, 0, 29, 30, 30, 30,
453  30, 31, 0, 31, 31, 31, 31, 32, 0, 0,
454  32, 27, 27, 27, 27, 27, 27, 27, 27, 27,
455  27, 27, 27, 27, 27, 27
456  } ;
457 
458 static yy_state_type yy_last_accepting_state;
460 
461 extern int yy_flex_debug;
462 int yy_flex_debug = 0;
463 
464 /* The intent behind this definition is that it'll catch
465  * any uses of REJECT which flex missed.
466  */
467 #define REJECT reject_used_but_not_detected
468 #define yymore() yymore_used_but_not_detected
469 #define YY_MORE_ADJ 0
470 #define YY_RESTORE_YY_MORE_OFFSET
471 char *yytext;
472 #line 1 "macro.lex.l"
473 #line 2 "macro.lex.l"
474 /*
475  * Help Viewer
476  *
477  * Copyright 1996 Ulrich Schmid
478  * Copyright 2002,2008 Eric Pouech
479  *
480  * This library is free software; you can redistribute it and/or
481  * modify it under the terms of the GNU Lesser General Public
482  * License as published by the Free Software Foundation; either
483  * version 2.1 of the License, or (at your option) any later version.
484  *
485  * This library is distributed in the hope that it will be useful,
486  * but WITHOUT ANY WARRANTY; without even the implied warranty of
487  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
488  * Lesser General Public License for more details.
489  *
490  * You should have received a copy of the GNU Lesser General Public
491  * License along with this library; if not, write to the Free Software
492  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
493  */
494 #define YY_NO_INPUT 1
495 
496 #line 26 "macro.lex.l"
497 #include <config.h>
498 
499 #define YY_NO_UNISTD_H
500 #include "winhelp.h"
501 
502 struct lex_data {
505  int quote_stack[32];
506  unsigned quote_stk_idx;
510 };
511 static struct lex_data* lex_data = NULL;
512 
513 struct lexret yylval;
514 
515 #define YY_INPUT(buf,result,max_size)\
516  if ((result = *lex_data->macroptr ? 1 : 0)) buf[0] = *lex_data->macroptr++;
517 
518 #line 537 "macro.lex.yy.c"
519 
520 #define INITIAL 0
521 #define quote 1
522 
523 #ifndef YY_NO_UNISTD_H
524 /* Special case for "unistd.h", since it is non-ANSI. We include it way
525  * down here because we want the user's section 1 to have been scanned first.
526  * The user has a chance to override it with an option.
527  */
528 #include <unistd.h>
529 #endif
530 
531 #ifndef YY_EXTRA_TYPE
532 #define YY_EXTRA_TYPE void *
533 #endif
534 
535 static int yy_init_globals (void );
536 
537 /* Accessor methods to globals.
538  These are made visible to non-reentrant scanners for convenience. */
539 
540 int yylex_destroy (void );
541 
542 int yyget_debug (void );
543 
544 void yyset_debug (int debug_flag );
545 
546 YY_EXTRA_TYPE yyget_extra (void );
547 
548 void yyset_extra (YY_EXTRA_TYPE user_defined );
549 
550 FILE *yyget_in (void );
551 
552 void yyset_in (FILE * in_str );
553 
554 FILE *yyget_out (void );
555 
556 void yyset_out (FILE * out_str );
557 
558 yy_size_t yyget_leng (void );
559 
560 char *yyget_text (void );
561 
562 int yyget_lineno (void );
563 
564 void yyset_lineno (int line_number );
565 
566 /* Macros after this point can all be overridden by user definitions in
567  * section 1.
568  */
569 
570 #ifndef YY_SKIP_YYWRAP
571 #ifdef __cplusplus
572 extern "C" int yywrap (void );
573 #else
574 extern int yywrap (void );
575 #endif
576 #endif
577 
578 #ifndef yytext_ptr
579 static void yy_flex_strncpy (char *,yyconst char *,int );
580 #endif
581 
582 #ifdef YY_NEED_STRLEN
583 static int yy_flex_strlen (yyconst char * );
584 #endif
585 
586 #ifndef YY_NO_INPUT
587 
588 #ifdef __cplusplus
589 static int yyinput (void );
590 #else
591 static int input (void );
592 #endif
593 
594 #endif
595 
596 /* Amount of stuff to slurp up with each read. */
597 #ifndef YY_READ_BUF_SIZE
598 #define YY_READ_BUF_SIZE 8192
599 #endif
600 
601 /* Copy whatever the last rule matched to the standard output. */
602 #ifndef ECHO
603 /* This used to be an fputs(), but since the string might contain NUL's,
604  * we now use fwrite().
605  */
606 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
607 #endif
608 
609 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
610  * is returned in "result".
611  */
612 #ifndef YY_INPUT
613 #define YY_INPUT(buf,result,max_size) \
614  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
615  { \
616  int c = '*'; \
617  size_t n; \
618  for ( n = 0; n < max_size && \
619  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
620  buf[n] = (char) c; \
621  if ( c == '\n' ) \
622  buf[n++] = (char) c; \
623  if ( c == EOF && ferror( yyin ) ) \
624  YY_FATAL_ERROR( "input in flex scanner failed" ); \
625  result = n; \
626  } \
627  else \
628  { \
629  errno=0; \
630  while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
631  { \
632  if( errno != EINTR) \
633  { \
634  YY_FATAL_ERROR( "input in flex scanner failed" ); \
635  break; \
636  } \
637  errno=0; \
638  clearerr(yyin); \
639  } \
640  }\
641 \
642 
643 #endif
644 
645 /* No semi-colon after return; correct usage is to write "yyterminate();" -
646  * we don't want an extra ';' after the "return" because that will cause
647  * some compilers to complain about unreachable statements.
648  */
649 #ifndef yyterminate
650 #define yyterminate() return YY_NULL
651 #endif
652 
653 /* Number of entries by which start-condition stack grows. */
654 #ifndef YY_START_STACK_INCR
655 #define YY_START_STACK_INCR 25
656 #endif
657 
658 /* Report a fatal error. */
659 #ifndef YY_FATAL_ERROR
660 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
661 #endif
662 
663 /* end tables serialization structures and prototypes */
664 
665 /* Default declaration of generated scanner - a define so the user can
666  * easily add parameters.
667  */
668 #ifndef YY_DECL
669 #define YY_DECL_IS_OURS 1
670 
671 extern int yylex (void);
672 
673 #define YY_DECL int yylex (void)
674 #endif /* !YY_DECL */
675 
676 /* Code executed at the beginning of each rule, after yytext and yyleng
677  * have been set up.
678  */
679 #ifndef YY_USER_ACTION
680 #define YY_USER_ACTION
681 #endif
682 
683 /* Code executed at the end of each rule. */
684 #ifndef YY_BREAK
685 #define YY_BREAK break;
686 #endif
687 
688 #define YY_RULE_SETUP \
689  YY_USER_ACTION
690 
693 YY_DECL
694 {
695  register yy_state_type yy_current_state;
696  register char *yy_cp, *yy_bp;
697  register int yy_act;
698 
699 #line 58 "macro.lex.l"
700 
701 
702 #line 726 "macro.lex.yy.c"
703 
704  if ( !(yy_init) )
705  {
706  (yy_init) = 1;
707 
708 #ifdef YY_USER_INIT
709  YY_USER_INIT;
710 #endif
711 
712  if ( ! (yy_start) )
713  (yy_start) = 1; /* first start state */
714 
715  if ( ! yyin )
716  yyin = stdin;
717 
718  if ( ! yyout )
719  yyout = stdout;
720 
721  if ( ! YY_CURRENT_BUFFER ) {
725  }
726 
728  }
729 
730  while ( 1 ) /* loops until end-of-file is reached */
731  {
732  yy_cp = (yy_c_buf_p);
733 
734  /* Support of yytext. */
735  *yy_cp = (yy_hold_char);
736 
737  /* yy_bp points to the position in yy_ch_buf of the start of
738  * the current run.
739  */
740  yy_bp = yy_cp;
741 
742  yy_current_state = (yy_start);
743 yy_match:
744  do
745  {
746  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
747  if ( yy_accept[yy_current_state] )
748  {
749  (yy_last_accepting_state) = yy_current_state;
750  (yy_last_accepting_cpos) = yy_cp;
751  }
752  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
753  {
754  yy_current_state = (int) yy_def[yy_current_state];
755  if ( yy_current_state >= 28 )
756  yy_c = yy_meta[(unsigned int) yy_c];
757  }
758  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
759  ++yy_cp;
760  }
761  while ( yy_current_state != 27 );
762  yy_cp = (yy_last_accepting_cpos);
763  yy_current_state = (yy_last_accepting_state);
764 
765 yy_find_action:
766  yy_act = yy_accept[yy_current_state];
767 
769 
770 do_action: /* This label is used only to access EOF actions. */
771 
772  switch ( yy_act )
773  { /* beginning of action switch */
774  case 0: /* must back up */
775  /* undo the effects of YY_DO_BEFORE_ACTION */
776  *yy_cp = (yy_hold_char);
777  yy_cp = (yy_last_accepting_cpos);
778  yy_current_state = (yy_last_accepting_state);
779  goto yy_find_action;
780 
781 case 1:
783 #line 60 "macro.lex.l"
784 yylval.integer = strtol(yytext, NULL, 10); return INTEGER;
785  YY_BREAK
786 case 2:
788 #line 61 "macro.lex.l"
789 yylval.integer = strtol(yytext, NULL, 16); return INTEGER;
790  YY_BREAK
791 case 3:
793 #line 63 "macro.lex.l"
794 return MACRO_Lookup(yytext, &yylval);
795  YY_BREAK
796 case 4:
797 #line 66 "macro.lex.l"
798 case 5:
799 #line 67 "macro.lex.l"
800 case 6:
801 #line 68 "macro.lex.l"
802 case 7:
803 #line 69 "macro.lex.l"
804 case 8:
805 #line 70 "macro.lex.l"
806 case 9:
808 #line 70 "macro.lex.l"
809 {
810  if (lex_data->quote_stk_idx == 0 ||
811  (yytext[0] == '\"' && lex_data->quote_stack[lex_data->quote_stk_idx - 1] != '\"') ||
812  (yytext[0] == '`'))
813  {
814  /* opening a new one */
815  if (lex_data->quote_stk_idx == 0)
816  {
817  assert(lex_data->cache_used < sizeof(lex_data->cache_string) / sizeof(lex_data->cache_string[0]));
818  lex_data->strptr = lex_data->cache_string[lex_data->cache_used] = HeapAlloc(GetProcessHeap(), 0, strlen(lex_data->macroptr) + 1);
819  yylval.string = lex_data->strptr;
820  lex_data->cache_used++;
821  BEGIN(quote);
822  }
823  else *lex_data->strptr++ = yytext[0];
824  lex_data->quote_stack[lex_data->quote_stk_idx++] = yytext[0];
825  assert(lex_data->quote_stk_idx < sizeof(lex_data->quote_stack) / sizeof(lex_data->quote_stack[0]));
826  }
827  else
828  {
829  if (yytext[0] == '`') assert(0);
830  /* close the current quote */
831  if (--lex_data->quote_stk_idx == 0)
832  {
833  BEGIN INITIAL;
834  *lex_data->strptr++ = '\0';
835  return STRING;
836  }
837  else *lex_data->strptr++ = yytext[0];
838  }
839 }
840  YY_BREAK
841 case 10:
843 #line 102 "macro.lex.l"
844 *lex_data->strptr++ = yytext[0];
845  YY_BREAK
846 case 11:
848 #line 103 "macro.lex.l"
849 *lex_data->strptr++ = yytext[1];
850  YY_BREAK
851 case YY_STATE_EOF(quote):
852 #line 104 "macro.lex.l"
853 return 0;
854  YY_BREAK
855 case 12:
857 #line 106 "macro.lex.l"
858 
859  YY_BREAK
860 case 13:
862 #line 107 "macro.lex.l"
863 return yytext[0];
864  YY_BREAK
865 case 14:
867 #line 108 "macro.lex.l"
868 ECHO;
869  YY_BREAK
870 #line 894 "macro.lex.yy.c"
871 case YY_STATE_EOF(INITIAL):
872  yyterminate();
873 
874  case YY_END_OF_BUFFER:
875  {
876  /* Amount of text matched not including the EOB char. */
877  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
878 
879  /* Undo the effects of YY_DO_BEFORE_ACTION. */
880  *yy_cp = (yy_hold_char);
882 
883  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
884  {
885  /* We're scanning a new file or input source. It's
886  * possible that this happened because the user
887  * just pointed yyin at a new source and called
888  * yylex(). If so, then we have to assure
889  * consistency between YY_CURRENT_BUFFER and our
890  * globals. Here is the right place to do so, because
891  * this is the first action (other than possibly a
892  * back-up) that will match for the new input source.
893  */
894  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
895  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
896  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
897  }
898 
899  /* Note that here we test for yy_c_buf_p "<=" to the position
900  * of the first EOB in the buffer, since yy_c_buf_p will
901  * already have been incremented past the NUL character
902  * (since all states make transitions on EOB to the
903  * end-of-buffer state). Contrast this with the test
904  * in input().
905  */
906  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
907  { /* This was really a NUL. */
908  yy_state_type yy_next_state;
909 
910  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
911 
912  yy_current_state = yy_get_previous_state( );
913 
914  /* Okay, we're now positioned to make the NUL
915  * transition. We couldn't have
916  * yy_get_previous_state() go ahead and do it
917  * for us because it doesn't know how to deal
918  * with the possibility of jamming (and we don't
919  * want to build jamming into it because then it
920  * will run more slowly).
921  */
922 
923  yy_next_state = yy_try_NUL_trans( yy_current_state );
924 
925  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
926 
927  if ( yy_next_state )
928  {
929  /* Consume the NUL. */
930  yy_cp = ++(yy_c_buf_p);
931  yy_current_state = yy_next_state;
932  goto yy_match;
933  }
934 
935  else
936  {
937  yy_cp = (yy_last_accepting_cpos);
938  yy_current_state = (yy_last_accepting_state);
939  goto yy_find_action;
940  }
941  }
942 
943  else switch ( yy_get_next_buffer( ) )
944  {
945  case EOB_ACT_END_OF_FILE:
946  {
948 
949  if ( yywrap( ) )
950  {
951  /* Note: because we've taken care in
952  * yy_get_next_buffer() to have set up
953  * yytext, we can now set up
954  * yy_c_buf_p so that if some total
955  * hoser (like flex itself) wants to
956  * call the scanner after we return the
957  * YY_NULL, it'll still work - another
958  * YY_NULL will get returned.
959  */
961 
962  yy_act = YY_STATE_EOF(YY_START);
963  goto do_action;
964  }
965 
966  else
967  {
968  if ( ! (yy_did_buffer_switch_on_eof) )
969  YY_NEW_FILE;
970  }
971  break;
972  }
973 
975  (yy_c_buf_p) =
976  (yytext_ptr) + yy_amount_of_matched_text;
977 
978  yy_current_state = yy_get_previous_state( );
979 
980  yy_cp = (yy_c_buf_p);
981  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
982  goto yy_match;
983 
984  case EOB_ACT_LAST_MATCH:
985  (yy_c_buf_p) =
986  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
987 
988  yy_current_state = yy_get_previous_state( );
989 
990  yy_cp = (yy_c_buf_p);
991  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
992  goto yy_find_action;
993  }
994  break;
995  }
996 
997  default:
999  "fatal flex scanner internal error--no action found" );
1000  } /* end of action switch */
1001  } /* end of scanning one token */
1002 } /* end of yylex */
1003 
1004 /* yy_get_next_buffer - try to read in a new buffer
1005  *
1006  * Returns a code representing an action:
1007  * EOB_ACT_LAST_MATCH -
1008  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1009  * EOB_ACT_END_OF_FILE - end of file
1010  */
1011 static int yy_get_next_buffer (void)
1012 {
1013  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1014  register char *source = (yytext_ptr);
1015  register int number_to_move, i;
1016  int ret_val;
1017 
1018  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1020  "fatal flex scanner internal error--end of buffer missed" );
1021 
1022  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1023  { /* Don't try to fill the buffer, so this is an EOF. */
1024  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1025  {
1026  /* We matched a single character, the EOB, so
1027  * treat this as a final EOF.
1028  */
1029  return EOB_ACT_END_OF_FILE;
1030  }
1031 
1032  else
1033  {
1034  /* We matched some text prior to the EOB, first
1035  * process it.
1036  */
1037  return EOB_ACT_LAST_MATCH;
1038  }
1039  }
1040 
1041  /* Try to read more data. */
1042 
1043  /* First move last chars to start of buffer. */
1044  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1045 
1046  for ( i = 0; i < number_to_move; ++i )
1047  *(dest++) = *(source++);
1048 
1049  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1050  /* don't do the read, it's not guaranteed to return an EOF,
1051  * just force an EOF
1052  */
1053  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1054 
1055  else
1056  {
1057  yy_size_t num_to_read =
1058  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1059 
1060  while ( num_to_read <= 0 )
1061  { /* Not enough room in the buffer - grow it. */
1062 
1063  /* just a shorter name for the current buffer */
1064  YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1065 
1066  int yy_c_buf_p_offset =
1067  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1068 
1069  if ( b->yy_is_our_buffer )
1070  {
1071  yy_size_t new_size = b->yy_buf_size * 2;
1072 
1073  if ( new_size <= 0 )
1074  b->yy_buf_size += b->yy_buf_size / 8;
1075  else
1076  b->yy_buf_size *= 2;
1077 
1078  b->yy_ch_buf = (char *)
1079  /* Include room in for 2 EOB chars. */
1080  yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1081  }
1082  else
1083  /* Can't grow it, we don't own it. */
1084  b->yy_ch_buf = 0;
1085 
1086  if ( ! b->yy_ch_buf )
1088  "fatal error - scanner input buffer overflow" );
1089 
1090  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1091 
1092  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1093  number_to_move - 1;
1094 
1095  }
1096 
1097  if ( num_to_read > YY_READ_BUF_SIZE )
1098  num_to_read = YY_READ_BUF_SIZE;
1099 
1100  /* Read in more data. */
1101  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1102  (yy_n_chars), num_to_read );
1103 
1104  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1105  }
1106 
1107  if ( (yy_n_chars) == 0 )
1108  {
1109  if ( number_to_move == YY_MORE_ADJ )
1110  {
1111  ret_val = EOB_ACT_END_OF_FILE;
1112  yyrestart(yyin );
1113  }
1114 
1115  else
1116  {
1117  ret_val = EOB_ACT_LAST_MATCH;
1118  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1120  }
1121  }
1122 
1123  else
1124  ret_val = EOB_ACT_CONTINUE_SCAN;
1125 
1126  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1127  /* Extend the array by 50%, plus the number we really need. */
1128  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1129  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1130  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1131  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1132  }
1133 
1134  (yy_n_chars) += number_to_move;
1137 
1138  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1139 
1140  return ret_val;
1141 }
1142 
1143 /* yy_get_previous_state - get the state just before the EOB char was reached */
1144 
1145  static yy_state_type yy_get_previous_state (void)
1146 {
1147  register yy_state_type yy_current_state;
1148  register char *yy_cp;
1149 
1150  yy_current_state = (yy_start);
1151 
1152  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1153  {
1154  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1155  if ( yy_accept[yy_current_state] )
1156  {
1157  (yy_last_accepting_state) = yy_current_state;
1158  (yy_last_accepting_cpos) = yy_cp;
1159  }
1160  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1161  {
1162  yy_current_state = (int) yy_def[yy_current_state];
1163  if ( yy_current_state >= 28 )
1164  yy_c = yy_meta[(unsigned int) yy_c];
1165  }
1166  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1167  }
1168 
1169  return yy_current_state;
1170 }
1171 
1172 /* yy_try_NUL_trans - try to make a transition on the NUL character
1173  *
1174  * synopsis
1175  * next_state = yy_try_NUL_trans( current_state );
1176  */
1177  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1178 {
1179  register int yy_is_jam;
1180  register char *yy_cp = (yy_c_buf_p);
1181 
1182  register YY_CHAR yy_c = 1;
1183  if ( yy_accept[yy_current_state] )
1184  {
1185  (yy_last_accepting_state) = yy_current_state;
1186  (yy_last_accepting_cpos) = yy_cp;
1187  }
1188  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1189  {
1190  yy_current_state = (int) yy_def[yy_current_state];
1191  if ( yy_current_state >= 28 )
1192  yy_c = yy_meta[(unsigned int) yy_c];
1193  }
1194  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1195  yy_is_jam = (yy_current_state == 27);
1196 
1197  return yy_is_jam ? 0 : yy_current_state;
1198 }
1199 
1200 #ifndef YY_NO_INPUT
1201 #ifdef __cplusplus
1202  static int yyinput (void)
1203 #else
1204  static int input (void)
1205 #endif
1206 
1207 {
1208  int c;
1209 
1210  *(yy_c_buf_p) = (yy_hold_char);
1211 
1212  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1213  {
1214  /* yy_c_buf_p now points to the character we want to return.
1215  * If this occurs *before* the EOB characters, then it's a
1216  * valid NUL; if not, then we've hit the end of the buffer.
1217  */
1218  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1219  /* This was really a NUL. */
1220  *(yy_c_buf_p) = '\0';
1221 
1222  else
1223  { /* need more input */
1225  ++(yy_c_buf_p);
1226 
1227  switch ( yy_get_next_buffer( ) )
1228  {
1229  case EOB_ACT_LAST_MATCH:
1230  /* This happens because yy_g_n_b()
1231  * sees that we've accumulated a
1232  * token and flags that we need to
1233  * try matching the token before
1234  * proceeding. But for input(),
1235  * there's no matching to consider.
1236  * So convert the EOB_ACT_LAST_MATCH
1237  * to EOB_ACT_END_OF_FILE.
1238  */
1239 
1240  /* Reset buffer status. */
1241  yyrestart(yyin );
1242 
1243  /*FALLTHROUGH*/
1244 
1245  case EOB_ACT_END_OF_FILE:
1246  {
1247  if ( yywrap( ) )
1248  return EOF;
1249 
1250  if ( ! (yy_did_buffer_switch_on_eof) )
1251  YY_NEW_FILE;
1252 #ifdef __cplusplus
1253  return yyinput();
1254 #else
1255  return input();
1256 #endif
1257  }
1258 
1259  case EOB_ACT_CONTINUE_SCAN:
1260  (yy_c_buf_p) = (yytext_ptr) + offset;
1261  break;
1262  }
1263  }
1264  }
1265 
1266  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1267  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1268  (yy_hold_char) = *++(yy_c_buf_p);
1269 
1270  return c;
1271 }
1272 #endif /* ifndef YY_NO_INPUT */
1273 
1279  void yyrestart (FILE * input_file )
1280 {
1281 
1282  if ( ! YY_CURRENT_BUFFER ){
1286  }
1287 
1288  yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1290 }
1291 
1296  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1297 {
1298 
1299  /* TODO. We should be able to replace this entire function body
1300  * with
1301  * yypop_buffer_state();
1302  * yypush_buffer_state(new_buffer);
1303  */
1305  if ( YY_CURRENT_BUFFER == new_buffer )
1306  return;
1307 
1308  if ( YY_CURRENT_BUFFER )
1309  {
1310  /* Flush out information for old buffer. */
1311  *(yy_c_buf_p) = (yy_hold_char);
1312  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1313  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1314  }
1315 
1316  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1318 
1319  /* We don't actually know whether we did this switch during
1320  * EOF (yywrap()) processing, but the only time this flag
1321  * is looked at is after yywrap() is called, so it's safe
1322  * to go ahead and always set it.
1323  */
1325 }
1326 
1327 static void yy_load_buffer_state (void)
1328 {
1329  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1330  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1331  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1332  (yy_hold_char) = *(yy_c_buf_p);
1333 }
1334 
1341  YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1342 {
1343  YY_BUFFER_STATE b;
1344 
1345  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1346  if ( ! b )
1347  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1348 
1349  b->yy_buf_size = size;
1350 
1351  /* yy_ch_buf has to be 2 characters longer than the size given because
1352  * we need to put in 2 end-of-buffer characters.
1353  */
1354  b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1355  if ( ! b->yy_ch_buf )
1356  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1357 
1358  b->yy_is_our_buffer = 1;
1359 
1360  yy_init_buffer(b,file );
1361 
1362  return b;
1363 }
1364 
1369  void yy_delete_buffer (YY_BUFFER_STATE b )
1370 {
1371 
1372  if ( ! b )
1373  return;
1374 
1375  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1377 
1378  if ( b->yy_is_our_buffer )
1379  yyfree((void *) b->yy_ch_buf );
1380 
1381  yyfree((void *) b );
1382 }
1383 
1384 /* Initializes or reinitializes a buffer.
1385  * This function is sometimes called more than once on the same buffer,
1386  * such as during a yyrestart() or at EOF.
1387  */
1388  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1389 
1390 {
1391  int oerrno = errno;
1392 
1393  yy_flush_buffer(b );
1394 
1395  b->yy_input_file = file;
1396  b->yy_fill_buffer = 1;
1397 
1398  /* If b is the current buffer, then yy_init_buffer was _probably_
1399  * called from yyrestart() or through yy_get_next_buffer.
1400  * In that case, we don't want to reset the lineno or column.
1401  */
1402  if (b != YY_CURRENT_BUFFER){
1403  b->yy_bs_lineno = 1;
1404  b->yy_bs_column = 0;
1405  }
1406 
1407  b->yy_is_interactive = 0;
1408 
1409  errno = oerrno;
1410 }
1411 
1416  void yy_flush_buffer (YY_BUFFER_STATE b )
1417 {
1418  if ( ! b )
1419  return;
1420 
1421  b->yy_n_chars = 0;
1422 
1423  /* We always need two end-of-buffer characters. The first causes
1424  * a transition to the end-of-buffer state. The second causes
1425  * a jam in that state.
1426  */
1429 
1430  b->yy_buf_pos = &b->yy_ch_buf[0];
1431 
1432  b->yy_at_bol = 1;
1434 
1435  if ( b == YY_CURRENT_BUFFER )
1437 }
1438 
1445 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1446 {
1447  if (new_buffer == NULL)
1448  return;
1449 
1451 
1452  /* This block is copied from yy_switch_to_buffer. */
1453  if ( YY_CURRENT_BUFFER )
1454  {
1455  /* Flush out information for old buffer. */
1456  *(yy_c_buf_p) = (yy_hold_char);
1457  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1458  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1459  }
1460 
1461  /* Only push if top exists. Otherwise, replace top. */
1462  if (YY_CURRENT_BUFFER)
1463  (yy_buffer_stack_top)++;
1464  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1465 
1466  /* copied from yy_switch_to_buffer. */
1469 }
1470 
1476 {
1477  if (!YY_CURRENT_BUFFER)
1478  return;
1479 
1482  if ((yy_buffer_stack_top) > 0)
1483  --(yy_buffer_stack_top);
1484 
1485  if (YY_CURRENT_BUFFER) {
1488  }
1489 }
1490 
1491 /* Allocates the stack if it does not exist.
1492  * Guarantees space for at least one push.
1493  */
1494 static void yyensure_buffer_stack (void)
1495 {
1496  yy_size_t num_to_alloc;
1497 
1498  if (!(yy_buffer_stack)) {
1499 
1500  /* First allocation is just for 2 elements, since we don't know if this
1501  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1502  * immediate realloc on the next call.
1503  */
1504  num_to_alloc = 1;
1506  (num_to_alloc * sizeof(struct yy_buffer_state*)
1507  );
1508  if ( ! (yy_buffer_stack) )
1509  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1510 
1511  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1512 
1513  (yy_buffer_stack_max) = num_to_alloc;
1514  (yy_buffer_stack_top) = 0;
1515  return;
1516  }
1517 
1518  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1519 
1520  /* Increase the buffer to prepare for a possible push. */
1521  int grow_size = 8 /* arbitrary grow size */;
1522 
1523  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1525  ((yy_buffer_stack),
1526  num_to_alloc * sizeof(struct yy_buffer_state*)
1527  );
1528  if ( ! (yy_buffer_stack) )
1529  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1530 
1531  /* zero only the new slots.*/
1532  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1533  (yy_buffer_stack_max) = num_to_alloc;
1534  }
1535 }
1536 
1543 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1544 {
1545  YY_BUFFER_STATE b;
1546 
1547  if ( size < 2 ||
1548  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1549  base[size-1] != YY_END_OF_BUFFER_CHAR )
1550  /* They forgot to leave room for the EOB's. */
1551  return 0;
1552 
1553  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1554  if ( ! b )
1555  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1556 
1557  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1558  b->yy_buf_pos = b->yy_ch_buf = base;
1559  b->yy_is_our_buffer = 0;
1560  b->yy_input_file = 0;
1561  b->yy_n_chars = b->yy_buf_size;
1562  b->yy_is_interactive = 0;
1563  b->yy_at_bol = 1;
1564  b->yy_fill_buffer = 0;
1566 
1567  yy_switch_to_buffer(b );
1568 
1569  return b;
1570 }
1571 
1580 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1581 {
1582 
1583  return yy_scan_bytes(yystr,strlen(yystr) );
1584 }
1585 
1593 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
1594 {
1595  YY_BUFFER_STATE b;
1596  char *buf;
1597  yy_size_t n;
1598  yy_size_t i;
1599 
1600  /* Get memory for full buffer, including space for trailing EOB's. */
1601  n = _yybytes_len + 2;
1602  buf = (char *) yyalloc(n );
1603  if ( ! buf )
1604  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1605 
1606  for ( i = 0; i < _yybytes_len; ++i )
1607  buf[i] = yybytes[i];
1608 
1609  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1610 
1611  b = yy_scan_buffer(buf,n );
1612  if ( ! b )
1613  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1614 
1615  /* It's okay to grow etc. this buffer, and we should throw it
1616  * away when we're done.
1617  */
1618  b->yy_is_our_buffer = 1;
1619 
1620  return b;
1621 }
1622 
1623 #ifndef YY_EXIT_FAILURE
1624 #define YY_EXIT_FAILURE 2
1625 #endif
1626 
1627 static void yy_fatal_error (yyconst char* msg )
1628 {
1629  (void) fprintf( stderr, "%s\n", msg );
1630  exit( YY_EXIT_FAILURE );
1631 }
1632 
1633 /* Redefine yyless() so it works in section 3 code. */
1634 
1635 #undef yyless
1636 #define yyless(n) \
1637  do \
1638  { \
1639  /* Undo effects of setting up yytext. */ \
1640  int yyless_macro_arg = (n); \
1641  YY_LESS_LINENO(yyless_macro_arg);\
1642  yytext[yyleng] = (yy_hold_char); \
1643  (yy_c_buf_p) = yytext + yyless_macro_arg; \
1644  (yy_hold_char) = *(yy_c_buf_p); \
1645  *(yy_c_buf_p) = '\0'; \
1646  yyleng = yyless_macro_arg; \
1647  } \
1648  while ( 0 )
1649 
1650 /* Accessor methods (get/set functions) to struct members. */
1651 
1655 int yyget_lineno (void)
1656 {
1657 
1658  return yylineno;
1659 }
1660 
1665 {
1666  return yyin;
1667 }
1668 
1673 {
1674  return yyout;
1675 }
1676 
1681 {
1682  return yyleng;
1683 }
1684 
1689 char *yyget_text (void)
1690 {
1691  return yytext;
1692 }
1693 
1699 {
1700 
1701  yylineno = line_number;
1702 }
1703 
1710 void yyset_in (FILE * in_str )
1711 {
1712  yyin = in_str ;
1713 }
1714 
1715 void yyset_out (FILE * out_str )
1716 {
1717  yyout = out_str ;
1718 }
1719 
1720 int yyget_debug (void)
1721 {
1722  return yy_flex_debug;
1723 }
1724 
1725 void yyset_debug (int bdebug )
1726 {
1727  yy_flex_debug = bdebug ;
1728 }
1729 
1730 static int yy_init_globals (void)
1731 {
1732  /* Initialization is the same as for the non-reentrant scanner.
1733  * This function is called from yylex_destroy(), so don't allocate here.
1734  */
1735 
1736  (yy_buffer_stack) = 0;
1737  (yy_buffer_stack_top) = 0;
1738  (yy_buffer_stack_max) = 0;
1739  (yy_c_buf_p) = (char *) 0;
1740  (yy_init) = 0;
1741  (yy_start) = 0;
1742 
1743 /* Defined in main.c */
1744 #ifdef YY_STDINIT
1745  yyin = stdin;
1746  yyout = stdout;
1747 #else
1748  yyin = (FILE *) 0;
1749  yyout = (FILE *) 0;
1750 #endif
1751 
1752  /* For future reference: Set errno on error, since we are called by
1753  * yylex_init()
1754  */
1755  return 0;
1756 }
1757 
1758 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1759 int yylex_destroy (void)
1760 {
1761 
1762  /* Pop the buffer stack, destroying each element. */
1763  while(YY_CURRENT_BUFFER){
1767  }
1768 
1769  /* Destroy the stack itself. */
1770  yyfree((yy_buffer_stack) );
1771  (yy_buffer_stack) = NULL;
1772 
1773  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1774  * yylex() is called, initialization will occur. */
1775  yy_init_globals( );
1776 
1777  return 0;
1778 }
1779 
1780 /*
1781  * Internal utility routines.
1782  */
1783 
1784 #ifndef yytext_ptr
1785 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1786 {
1787  register int i;
1788  for ( i = 0; i < n; ++i )
1789  s1[i] = s2[i];
1790 }
1791 #endif
1792 
1793 #ifdef YY_NEED_STRLEN
1794 static int yy_flex_strlen (yyconst char * s )
1795 {
1796  register int n;
1797  for ( n = 0; s[n]; ++n )
1798  ;
1799 
1800  return n;
1801 }
1802 #endif
1803 
1805 {
1806  return (void *) malloc( size );
1807 }
1808 
1809 void *yyrealloc (void * ptr, yy_size_t size )
1810 {
1811  /* The cast to (char *) in the following accommodates both
1812  * implementations that use char* generic pointers, and those
1813  * that use void* generic pointers. It works with the latter
1814  * because both ANSI C and C++ allow castless assignment from
1815  * any pointer type to void*, and deal with argument conversions
1816  * as though doing an assignment.
1817  */
1818  return (void *) realloc( (char *) ptr, size );
1819 }
1820 
1821 void yyfree (void * ptr )
1822 {
1823  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1824 }
1825 
1826 #define YYTABLES_NAME "yytables"
1827 
1828 #line 108 "macro.lex.l"
1829 
1830 
1831 
1832 #if 0
1833 /* all code for testing macros */
1834 #include "winhelp.h"
1835 static CHAR szTestMacro[256];
1836 
1837 static LRESULT CALLBACK MACRO_TestDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
1838 {
1839  if (msg == WM_COMMAND && wParam == IDOK)
1840  {
1841  GetDlgItemText(hDlg, 99, szTestMacro, sizeof(szTestMacro));
1842  EndDialog(hDlg, IDOK);
1843  return TRUE;
1844  }
1845  return FALSE;
1846 }
1847 
1848 void macro_test(void)
1849 {
1850  WNDPROC lpfnDlg = MakeProcInstance(MACRO_TestDialogProc, Globals.hInstance);
1852  FreeProcInstance(lpfnDlg);
1853  macro = szTestMacro;
1854 }
1855 #endif
1856 
1857 /* small helper function for debug messages */
1858 static const char* ts(int t)
1859 {
1860  static char c[2] = {0,0};
1861 
1862  switch (t)
1863  {
1864  case EMPTY: return "EMPTY";
1865  case VOID_FUNCTION: return "VOID_FUNCTION";
1866  case BOOL_FUNCTION: return "BOOL_FUNCTION";
1867  case INTEGER: return "INTEGER";
1868  case STRING: return "STRING";
1869  case IDENTIFIER: return "IDENTIFIER";
1870  default: c[0] = (char)t; return c;
1871  }
1872 }
1873 
1874 static int MACRO_CallBoolFunc(void *fn, const char* args, void** ret);
1875 
1876 /******************************************************************
1877  * MACRO_CheckArgs
1878  *
1879  * checks number of arguments against prototype, and stores arguments on
1880  * stack pa for later call
1881  * returns -1 on error, otherwise the number of pushed parameters
1882  */
1883 static int MACRO_CheckArgs(void* pa[], unsigned max, const char* args)
1884 {
1885  int t;
1886  unsigned int len = 0, idx = 0;
1887 
1888  WINE_TRACE("Checking %s\n", debugstr_a(args));
1889 
1890  if (yylex() != '(') {WINE_WARN("missing (\n");return -1;}
1891 
1892  if (*args)
1893  {
1894  len = strlen(args);
1895  for (;;)
1896  {
1897  t = yylex();
1898  WINE_TRACE("Got %s <=> %c\n", debugstr_a(ts(t)), *args);
1899 
1900  switch (*args)
1901  {
1902  case 'S':
1903  if (t != STRING)
1904  {WINE_WARN("missing S\n");return -1;}
1905  pa[idx] = (void*)yylval.string;
1906  break;
1907  case 'U':
1908  case 'I':
1909  if (t != INTEGER)
1910  {WINE_WARN("missing U\n");return -1;}
1911  pa[idx] = LongToPtr(yylval.integer);
1912  break;
1913  case 'B':
1914  if (t != BOOL_FUNCTION)
1915  {WINE_WARN("missing B\n");return -1;}
1916  if (MACRO_CallBoolFunc(yylval.function, yylval.proto, &pa[idx]) == 0)
1917  return -1;
1918  break;
1919  default:
1920  WINE_WARN("unexpected %s while args is %c\n", debugstr_a(ts(t)), *args);
1921  return -1;
1922  }
1923  idx++;
1924  if (*++args == '\0') break;
1925  t = yylex();
1926  if (t == ')') goto CheckArgs_end;
1927  if (t != ',') {WINE_WARN("missing ,\n");return -1;}
1928  if (idx >= max) {WINE_FIXME("stack overflow (%d)\n", max);return -1;}
1929  }
1930  }
1931  if (yylex() != ')') {WINE_WARN("missing )\n");return -1;}
1932 
1933 CheckArgs_end:
1934  while (len > idx) pa[--len] = NULL;
1935  return idx;
1936 }
1937 
1938 /******************************************************************
1939  * MACRO_CallBoolFunc
1940  *
1941  * Invokes boolean function fn, which arguments are defined by args
1942  * stores bool result into ret
1943  */
1944 static int MACRO_CallBoolFunc(void *fn, const char* args, void** ret)
1945 {
1946  void* pa[2];
1947  int idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
1948 
1949  if (idx < 0) return 0;
1950  if (!fn) return 1;
1951 
1952  WINE_TRACE("calling with %u pmts\n", idx);
1953 
1954  switch (strlen(args))
1955  {
1956  case 0:
1957  {
1958  BOOL (WINAPI *func)(void) = fn;
1959  *ret = (void *)(ULONG_PTR)func();
1960  break;
1961  }
1962  case 1:
1963  {
1964  BOOL (WINAPI *func)(void *) = fn;
1965  *ret = (void *)(ULONG_PTR)func( pa[0]);
1966  break;
1967  }
1968  default: WINE_FIXME("NIY\n");
1969  }
1970 
1971  return 1;
1972 }
1973 
1974 /******************************************************************
1975  * MACRO_CallVoidFunc
1976  *
1977  *
1978  */
1979 static int MACRO_CallVoidFunc(void *fn, const char* args)
1980 {
1981  void* pa[6];
1982  int idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
1983 
1984  if (idx < 0) return 0;
1985  if (!fn) return 1;
1986 
1987  WINE_TRACE("calling %p with %u pmts\n", fn, idx);
1988 
1989  switch (strlen(args))
1990  {
1991  case 0:
1992  {
1993  void (WINAPI *func)(void) = fn;
1994  func();
1995  break;
1996  }
1997  case 1:
1998  {
1999  void (WINAPI *func)(void*) = fn;
2000  func( pa[0] );
2001  break;
2002  }
2003  case 2:
2004  {
2005  void (WINAPI *func)(void*,void*) = fn;
2006  func( pa[0], pa[1] );
2007  break;
2008  }
2009  case 3:
2010  {
2011  void (WINAPI *func)(void*,void*,void*) = fn;
2012  func( pa[0], pa[1], pa[2] );
2013  break;
2014  }
2015  case 4:
2016  {
2017  void (WINAPI *func)(void*,void*,void*,void*) = fn;
2018  func( pa[0], pa[1], pa[2], pa[3] );
2019  break;
2020  }
2021  case 5:
2022  {
2023  void (WINAPI *func)(void*,void*,void*,void*,void*) = fn;
2024  func( pa[0], pa[1], pa[2], pa[3], pa[4] );
2025  break;
2026  }
2027  case 6:
2028  {
2029  void (WINAPI *func)(void*,void*,void*,void*,void*,void*) = fn;
2030  func( pa[0], pa[1], pa[2], pa[3], pa[4], pa[5] );
2031  break;
2032  }
2033  default: WINE_FIXME("NIY\n");
2034  }
2035 
2036  return 1;
2037 }
2038 
2040 {
2041  struct lex_data curr_lex_data, *prev_lex_data;
2042  BOOL ret = TRUE;
2043  int t;
2044 
2045  WINE_TRACE("%s\n", debugstr_a(macro));
2046 
2047  prev_lex_data = lex_data;
2048  lex_data = &curr_lex_data;
2049 
2050  memset(lex_data, 0, sizeof(*lex_data));
2051  lex_data->macroptr = macro;
2052  lex_data->window = WINHELP_GrabWindow(window);
2053 
2054  while ((t = yylex()) != EMPTY)
2055  {
2056  switch (t)
2057  {
2058  case VOID_FUNCTION:
2059  WINE_TRACE("got type void func(%s)\n", debugstr_a(yylval.proto));
2060  MACRO_CallVoidFunc(yylval.function, yylval.proto);
2061  break;
2062  case BOOL_FUNCTION:
2063  WINE_WARN("got type bool func(%s)\n", debugstr_a(yylval.proto));
2064  break;
2065  default:
2066  WINE_WARN("got unexpected type %s\n", debugstr_a(ts(t)));
2068  ret = FALSE;
2069  goto done;
2070  }
2071  switch (t = yylex())
2072  {
2073  case EMPTY: goto done;
2074  case ';': break;
2075  default: ret = FALSE; YY_FLUSH_BUFFER; goto done;
2076  }
2077  }
2078 
2079 done:
2080  for (t = 0; t < lex_data->cache_used; t++)
2081  HeapFree(GetProcessHeap(), 0, lex_data->cache_string[t]);
2082  lex_data = prev_lex_data;
2083  WINHELP_ReleaseWindow(window);
2084 
2085  return ret;
2086 }
2087 
2089 {
2090  return lex_data ? lex_data->window : Globals.active_win;
2091 }
2092 
2093 #ifndef yywrap
2094 int yywrap(void) { return 1; }
2095 #endif
2096 
#define realloc
Definition: debug_ros.c:6
static yyconst flex_int32_t yy_ec[256]
Definition: macro.lex.yy.c:380
unsigned char flex_uint8_t
Definition: macro.lex.yy.c:54
GLenum func
Definition: glext.h:6028
YY_BUFFER_STATE yy_scan_string(yyconst char *yy_str)
struct lexret yylval
Definition: macro.lex.yy.c:513
#define YY_END_OF_BUFFER
Definition: macro.lex.yy.c:365
static void yy_fatal_error(yyconst char msg[])
FILE * yy_input_file
Definition: macro.lex.yy.c:192
yy_size_t yyget_leng(void)
yy_size_t yy_n_chars
Definition: macro.lex.yy.c:205
struct S2 s2
#define LongToPtr(l)
Definition: basetsd.h:90
#define IDOK
Definition: winuser.h:824
unsigned int uint32_t
Definition: acefiex.h:55
#define YY_STATE_EOF(state)
Definition: macro.lex.yy.c:136
WINHELP_WINDOW * window
Definition: macro.lex.yy.c:509
void yy_delete_buffer(YY_BUFFER_STATE b)
void yyrestart(FILE *input_file)
#define FreeProcInstance(p)
Definition: winbase.h:1895
#define YY_DO_BEFORE_ACTION
Definition: macro.lex.yy.c:357
#define YY_MORE_ADJ
Definition: macro.lex.yy.c:469
unsigned char YY_CHAR
Definition: macro.lex.yy.c:336
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
int yywrap(void)
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
#define EMPTY(rect)
Definition: text.c:31
#define YY_BUFFER_NORMAL
Definition: macro.lex.yy.c:237
char CHAR
Definition: xmlstorage.h:175
#define free
Definition: debug_ros.c:5
#define CALLBACK
Definition: compat.h:27
static size_t yy_buffer_stack_max
Definition: macro.lex.yy.c:255
#define TRUE
Definition: numbers.c:17
static size_t yy_buffer_stack_top
Definition: macro.lex.yy.c:254
void yyset_extra(YY_EXTRA_TYPE user_defined)
GLdouble GLdouble t
Definition: gl.h:2047
HANDLE HWND
Definition: compat.h:13
size_t yy_size_t
Definition: macro.lex.yy.c:159
register char * yy_bp
Definition: macro.lex.yy.c:696
#define assert(x)
Definition: debug.h:53
#define WINE_TRACE
Definition: debug.h:351
static char * yy_c_buf_p
Definition: macro.lex.yy.c:279
#define EOB_ACT_LAST_MATCH
Definition: macro.lex.yy.c:168
FILE * stdin
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define INITIAL
Definition: macro.lex.yy.c:520
#define YY_RULE_SETUP
Definition: macro.lex.yy.c:688
int line_number
Definition: parser.yy.c:773
#define YY_FATAL_ERROR(msg)
Definition: macro.lex.yy.c:660
static yyconst flex_int16_t yy_accept[28]
Definition: macro.lex.yy.c:373
#define YY_EXTRA_TYPE
Definition: macro.lex.yy.c:532
int errno
unsigned short int uint16_t
Definition: acefiex.h:54
Definition: macro.h:37
#define YY_EXIT_FAILURE
char * LPSTR
Definition: xmlstorage.h:182
#define YY_CURRENT_BUFFER_LVALUE
Definition: macro.lex.yy.c:271
void yyset_debug(int debug_flag)
#define YY_START
Definition: macro.lex.yy.c:132
Definition: match.c:295
int yy_flex_debug
Definition: macro.lex.yy.c:462
BOOL WINAPI EndDialog(_In_ HWND, _In_ INT_PTR)
int yylex(void)
FILE * stdout
static int yy_start
Definition: macro.lex.yy.c:281
static void yyensure_buffer_stack(void)
UINT_PTR WPARAM
Definition: windef.h:230
uint32_t ULONG_PTR
Definition: typedefs.h:64
Definition: macro.h:22
yy_size_t yy_buf_size
Definition: macro.lex.yy.c:200
const XML_Char int const XML_Char int const XML_Char * base
Definition: expat.h:331
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
GLuint n
Definition: s_context.h:57
#define DialogBox
Definition: winuser.h:5592
CLIPBOARD_GLOBALS Globals
Definition: clipbrd.c:13
int MACRO_Lookup(const char *name, struct lexret *lr)
Definition: macro.c:1015
GLenum GLclampf GLint i
Definition: glfuncs.h:14
FILE * yyin
Definition: macro.lex.yy.c:338
BOOL WINHELP_ReleaseWindow(WINHELP_WINDOW *win)
Definition: winhelp.c:506
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
int yyget_debug(void)
void yyset_out(FILE *out_str)
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
LONG_PTR LPARAM
Definition: windef.h:231
FILE * yyget_in(void)
WINHELP_WINDOW * MACRO_CurrentWindow(void)
#define YY_BUF_SIZE
Definition: macro.lex.yy.c:145
register int yy_act
Definition: macro.lex.yy.c:697
static PVOID ptr
Definition: dispmode.c:40
#define quote
Definition: macro.lex.yy.c:521
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:47
unsigned int idx
Definition: utils.c:36
static const char * ts(int t)
int yy_state_type
Definition: macro.lex.yy.c:340
smooth NULL
Definition: ftsmooth.c:464
void * yyalloc(yy_size_t)
unsigned char
Definition: typeof.h:27
void yyfree(void *)
WINHELP_WINDOW * WINHELP_GrabWindow(WINHELP_WINDOW *win)
Definition: winhelp.c:495
unsigned int flex_uint32_t
Definition: macro.lex.yy.c:56
static yyconst flex_int16_t yy_base[33]
Definition: macro.lex.yy.c:418
const char * LPCSTR
Definition: xmlstorage.h:183
signed char flex_int8_t
Definition: macro.lex.yy.c:51
static int yy_did_buffer_switch_on_eof
Definition: macro.lex.yy.c:286
#define b
Definition: ke_i.h:79
INT_PTR(CALLBACK * DLGPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2837
YY_DECL register yy_state_type yy_current_state
Definition: macro.lex.yy.c:695
#define YY_FLUSH_BUFFER
Definition: macro.lex.yy.c:300
static yy_size_t yy_n_chars
Definition: macro.lex.yy.c:275
#define YY_RESTORE_YY_MORE_OFFSET
Definition: macro.lex.yy.c:470
YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, yy_size_t len)
short int int16_t
Definition: acefiex.h:51
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2847
signed char int8_t
Definition: acefiex.h:50
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define yyconst
Definition: macro.lex.yy.c:109
unsigned int BOOL
Definition: ntddk_ex.h:94
#define GetDlgItemText
Definition: winuser.h:5616
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
if(!(yy_init))
Definition: macro.lex.yy.c:704
static yyconst flex_int16_t yy_nxt[77]
Definition: macro.lex.yy.c:434
#define debugstr_a
Definition: kernel32.h:31
#define YY_END_OF_BUFFER_CHAR
Definition: macro.lex.yy.c:141
struct S1 s1
#define BEGIN
Definition: macro.lex.yy.c:126
UINT WPARAM wParam
Definition: precomp.h:49
#define YY_BUFFER_NEW
Definition: macro.lex.yy.c:236
int quote_stack[32]
Definition: macro.lex.yy.c:505
static yyconst flex_int16_t yy_def[33]
Definition: macro.lex.yy.c:426
const char file[]
Definition: icontest.c:11
#define EOB_ACT_END_OF_FILE
Definition: macro.lex.yy.c:167
GLfloat CONST GLvector4f CONST GLfloat GLvector4f * dest
Definition: m_xform.h:122
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
static int yy_init
Definition: macro.lex.yy.c:280
int yyget_lineno(void)
#define MakeProcInstance(p, i)
Definition: winbase.h:2720
#define STRING(String)
short int flex_int16_t
Definition: macro.lex.yy.c:52
std::wstring STRING
Definition: fontsub.cpp:33
#define YY_READ_BUF_SIZE
Definition: macro.lex.yy.c:598
int flex_int32_t
Definition: macro.lex.yy.c:53
#define ECHO
Definition: macro.lex.yy.c:606
static int yy_init_globals(void)
int ret
#define yyterminate()
Definition: macro.lex.yy.c:650
#define exit(n)
Definition: config.h:212
static yy_state_type yy_last_accepting_state
Definition: macro.lex.yy.c:458
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
#define YY_BREAK
Definition: macro.lex.yy.c:685
static yyconst flex_int32_t yy_meta[15]
Definition: macro.lex.yy.c:412
GLdouble s
Definition: gl.h:2039
GLenum GLsizei len
Definition: glext.h:6722
#define WM_COMMAND
Definition: winuser.h:1706
static IHTMLWindow2 * window
Definition: events.c:89
char * yytext
Definition: macro.lex.yy.c:471
static struct lex_data * lex_data
Definition: macro.lex.yy.c:511
BYTE uint8_t
Definition: msvideo1.c:70
#define WINAPI
Definition: msvc.h:20
static int MACRO_CallVoidFunc(void *fn, const char *args)
YY_EXTRA_TYPE yyget_extra(void)
static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
int yylex_destroy(void)
void yy_flush_buffer(YY_BUFFER_STATE b)
FILE * yyget_out(void)
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
static YY_BUFFER_STATE * yy_buffer_stack
Definition: macro.lex.yy.c:256
static int yy_get_next_buffer(void)
flex_int32_t yy_verify
Definition: macro.lex.yy.c:370
GLenum GLenum GLenum input
Definition: glext.h:9031
static void yy_load_buffer_state(void)
BOOL MACRO_ExecuteMacro(WINHELP_WINDOW *window, LPCSTR macro)
void yyset_in(FILE *in_str)
GLsizeiptr size
Definition: glext.h:5919
unsigned short int flex_uint16_t
Definition: macro.lex.yy.c:55
#define WINE_WARN
Definition: debug.h:357
#define YY_DECL
Definition: macro.lex.yy.c:673
int yylineno
Definition: macro.lex.yy.c:344
UINT WPARAM LPARAM lParam
Definition: precomp.h:49
static char yy_hold_char
Definition: macro.lex.yy.c:274
unsigned int UINT
Definition: ndis.h:50
const char STRING_DIALOG_TEST[]
Definition: string.c:29
struct yy_buffer_state * YY_BUFFER_STATE
Definition: macro.lex.yy.c:154
char * yyget_text(void)
LPSTR cache_string[32]
Definition: macro.lex.yy.c:507
LPSTR strptr
Definition: macro.lex.yy.c:504
flex_int32_t yy_nxt
Definition: macro.lex.yy.c:371
#define YY_NEW_FILE
Definition: macro.lex.yy.c:139
void yypush_buffer_state(YY_BUFFER_STATE new_buffer)
void yyset_lineno(int line_number)
#define EOB_ACT_CONTINUE_SCAN
Definition: macro.lex.yy.c:166
static int MACRO_CheckArgs(void *pa[], unsigned max, const char *args)
#define EOF
Definition: stdio.h:24
static yy_state_type yy_get_previous_state(void)
_Check_return_ long __cdecl strtol(_In_z_ const char *_Str, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
void yypop_buffer_state(void)
#define FALSE
Definition: numbers.c:16
int cache_used
Definition: macro.lex.yy.c:508
register char * yy_cp
Definition: macro.lex.yy.c:696
static char * yy_last_accepting_cpos
Definition: macro.lex.yy.c:459
UINT msg
Definition: msvc.h:92
#define c
Definition: ke_i.h:80
FILE * stderr
#define malloc
Definition: debug_ros.c:4
#define YY_BUFFER_EOF_PENDING
Definition: macro.lex.yy.c:248
#define YY_INPUT(buf, result, max_size)
Definition: macro.lex.yy.c:515
LPCSTR macroptr
Definition: macro.lex.yy.c:503
#define max(a, b)
Definition: slicer.cc:81
static yyconst flex_int16_t yy_chk[77]
Definition: macro.lex.yy.c:446
FILE * yyout
Definition: macro.lex.yy.c:338
LONG_PTR LRESULT
Definition: windef.h:232
unsigned quote_stk_idx
Definition: macro.lex.yy.c:506
HINSTANCE hInstance
Definition: precomp.h:30
#define memset(x, y, z)
Definition: compat.h:39
#define YY_CURRENT_BUFFER
Definition: macro.lex.yy.c:264
#define yytext_ptr
Definition: macro.lex.yy.c:347
#define BOOL
Definition: msvc.h:23
#define HeapFree(x, y, z)
Definition: compat.h:394
yy_size_t yyleng
Definition: macro.lex.yy.c:276
static int MACRO_CallBoolFunc(void *fn, const char *args, void **ret)
int int32_t
Definition: acefiex.h:52
void * yyrealloc(void *, yy_size_t)
GLintptr offset
Definition: glext.h:5920
#define YY_SC_TO_UI(c)
Definition: macro.lex.yy.c:120
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:29
Definition: fci.c:114
#define WINE_FIXME
Definition: debug.h:363