ReactOS  0.4.13-dev-66-gc714b7f
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;
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 );
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 
303 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
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 
460 
461 extern int yy_flex_debug;
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 #include <assert.h>
499 #include <stdarg.h>
500 
501 #define YY_NO_UNISTD_H
502 #include "windef.h"
503 #include "winbase.h"
504 #include "wingdi.h"
505 #include "winuser.h"
506 #include "winhelp.h"
507 
508 #include "wine/debug.h"
509 
511 
512 struct lex_data {
515  int quote_stack[32];
516  unsigned quote_stk_idx;
520 };
521 static struct lex_data* lex_data = NULL;
522 
523 struct lexret yylval;
524 
525 #define YY_INPUT(buf,result,max_size)\
526  if ((result = *lex_data->macroptr ? 1 : 0)) buf[0] = *lex_data->macroptr++;
527 
528 #line 529 "macro.lex.yy.c"
529 
530 #define INITIAL 0
531 #define quote 1
532 
533 #ifndef YY_NO_UNISTD_H
534 /* Special case for "unistd.h", since it is non-ANSI. We include it way
535  * down here because we want the user's section 1 to have been scanned first.
536  * The user has a chance to override it with an option.
537  */
538 #include <unistd.h>
539 #endif
540 
541 #ifndef YY_EXTRA_TYPE
542 #define YY_EXTRA_TYPE void *
543 #endif
544 
545 static int yy_init_globals (void );
546 
547 /* Accessor methods to globals.
548  These are made visible to non-reentrant scanners for convenience. */
549 
550 int yylex_destroy (void );
551 
552 int yyget_debug (void );
553 
554 void yyset_debug (int debug_flag );
555 
556 YY_EXTRA_TYPE yyget_extra (void );
557 
558 void yyset_extra (YY_EXTRA_TYPE user_defined );
559 
560 FILE *yyget_in (void );
561 
562 void yyset_in (FILE * in_str );
563 
564 FILE *yyget_out (void );
565 
566 void yyset_out (FILE * out_str );
567 
568 yy_size_t yyget_leng (void );
569 
570 char *yyget_text (void );
571 
572 int yyget_lineno (void );
573 
574 void yyset_lineno (int line_number );
575 
576 /* Macros after this point can all be overridden by user definitions in
577  * section 1.
578  */
579 
580 #ifndef YY_SKIP_YYWRAP
581 #ifdef __cplusplus
582 extern "C" int yywrap (void );
583 #else
584 extern int yywrap (void );
585 #endif
586 #endif
587 
588 #ifndef yytext_ptr
589 static void yy_flex_strncpy (char *,yyconst char *,int );
590 #endif
591 
592 #ifdef YY_NEED_STRLEN
593 static int yy_flex_strlen (yyconst char * );
594 #endif
595 
596 #ifndef YY_NO_INPUT
597 
598 #ifdef __cplusplus
599 static int yyinput (void );
600 #else
601 static int input (void );
602 #endif
603 
604 #endif
605 
606 /* Amount of stuff to slurp up with each read. */
607 #ifndef YY_READ_BUF_SIZE
608 #define YY_READ_BUF_SIZE 8192
609 #endif
610 
611 /* Copy whatever the last rule matched to the standard output. */
612 #ifndef ECHO
613 /* This used to be an fputs(), but since the string might contain NUL's,
614  * we now use fwrite().
615  */
616 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
617 #endif
618 
619 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
620  * is returned in "result".
621  */
622 #ifndef YY_INPUT
623 #define YY_INPUT(buf,result,max_size) \
624  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
625  { \
626  int c = '*'; \
627  size_t n; \
628  for ( n = 0; n < max_size && \
629  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
630  buf[n] = (char) c; \
631  if ( c == '\n' ) \
632  buf[n++] = (char) c; \
633  if ( c == EOF && ferror( yyin ) ) \
634  YY_FATAL_ERROR( "input in flex scanner failed" ); \
635  result = n; \
636  } \
637  else \
638  { \
639  errno=0; \
640  while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
641  { \
642  if( errno != EINTR) \
643  { \
644  YY_FATAL_ERROR( "input in flex scanner failed" ); \
645  break; \
646  } \
647  errno=0; \
648  clearerr(yyin); \
649  } \
650  }\
651 \
652 
653 #endif
654 
655 /* No semi-colon after return; correct usage is to write "yyterminate();" -
656  * we don't want an extra ';' after the "return" because that will cause
657  * some compilers to complain about unreachable statements.
658  */
659 #ifndef yyterminate
660 #define yyterminate() return YY_NULL
661 #endif
662 
663 /* Number of entries by which start-condition stack grows. */
664 #ifndef YY_START_STACK_INCR
665 #define YY_START_STACK_INCR 25
666 #endif
667 
668 /* Report a fatal error. */
669 #ifndef YY_FATAL_ERROR
670 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
671 #endif
672 
673 /* end tables serialization structures and prototypes */
674 
675 /* Default declaration of generated scanner - a define so the user can
676  * easily add parameters.
677  */
678 #ifndef YY_DECL
679 #define YY_DECL_IS_OURS 1
680 
681 extern int yylex (void);
682 
683 #define YY_DECL int yylex (void)
684 #endif /* !YY_DECL */
685 
686 /* Code executed at the beginning of each rule, after yytext and yyleng
687  * have been set up.
688  */
689 #ifndef YY_USER_ACTION
690 #define YY_USER_ACTION
691 #endif
692 
693 /* Code executed at the end of each rule. */
694 #ifndef YY_BREAK
695 #define YY_BREAK break;
696 #endif
697 
698 #define YY_RULE_SETUP \
699  YY_USER_ACTION
700 
703 YY_DECL
704 {
706  register char *yy_cp, *yy_bp;
707  register int yy_act;
708 
709 #line 58 "macro.lex.l"
710 
711 
712 #line 713 "macro.lex.yy.c"
713 
714  if ( !(yy_init) )
715  {
716  (yy_init) = 1;
717 
718 #ifdef YY_USER_INIT
719  YY_USER_INIT;
720 #endif
721 
722  if ( ! (yy_start) )
723  (yy_start) = 1; /* first start state */
724 
725  if ( ! yyin )
726  yyin = stdin;
727 
728  if ( ! yyout )
729  yyout = stdout;
730 
731  if ( ! YY_CURRENT_BUFFER ) {
735  }
736 
738  }
739 
740  while ( 1 ) /* loops until end-of-file is reached */
741  {
742  yy_cp = (yy_c_buf_p);
743 
744  /* Support of yytext. */
745  *yy_cp = (yy_hold_char);
746 
747  /* yy_bp points to the position in yy_ch_buf of the start of
748  * the current run.
749  */
750  yy_bp = yy_cp;
751 
753 yy_match:
754  do
755  {
756  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
758  {
761  }
762  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
763  {
765  if ( yy_current_state >= 28 )
766  yy_c = yy_meta[(unsigned int) yy_c];
767  }
768  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
769  ++yy_cp;
770  }
771  while ( yy_current_state != 27 );
774 
775 yy_find_action:
777 
779 
780 do_action: /* This label is used only to access EOF actions. */
781 
782  switch ( yy_act )
783  { /* beginning of action switch */
784  case 0: /* must back up */
785  /* undo the effects of YY_DO_BEFORE_ACTION */
786  *yy_cp = (yy_hold_char);
789  goto yy_find_action;
790 
791 case 1:
793 #line 60 "macro.lex.l"
794 yylval.integer = strtol(yytext, NULL, 10); return INTEGER;
795  YY_BREAK
796 case 2:
798 #line 61 "macro.lex.l"
799 yylval.integer = strtol(yytext, NULL, 16); return INTEGER;
800  YY_BREAK
801 case 3:
803 #line 63 "macro.lex.l"
804 return MACRO_Lookup(yytext, &yylval);
805  YY_BREAK
806 case 4:
807 #line 66 "macro.lex.l"
808 case 5:
809 #line 67 "macro.lex.l"
810 case 6:
811 #line 68 "macro.lex.l"
812 case 7:
813 #line 69 "macro.lex.l"
814 case 8:
815 #line 70 "macro.lex.l"
816 case 9:
818 #line 70 "macro.lex.l"
819 {
820  if (lex_data->quote_stk_idx == 0 ||
821  (yytext[0] == '\"' && lex_data->quote_stack[lex_data->quote_stk_idx - 1] != '\"') ||
822  (yytext[0] == '`'))
823  {
824  /* opening a new one */
825  if (lex_data->quote_stk_idx == 0)
826  {
829  yylval.string = lex_data->strptr;
830  lex_data->cache_used++;
831  BEGIN(quote);
832  }
833  else *lex_data->strptr++ = yytext[0];
836  }
837  else
838  {
839  if (yytext[0] == '`') assert(0);
840  /* close the current quote */
841  if (--lex_data->quote_stk_idx == 0)
842  {
843  BEGIN INITIAL;
844  *lex_data->strptr++ = '\0';
845  return STRING;
846  }
847  else *lex_data->strptr++ = yytext[0];
848  }
849 }
850  YY_BREAK
851 case 10:
853 #line 102 "macro.lex.l"
854 *lex_data->strptr++ = yytext[0];
855  YY_BREAK
856 case 11:
858 #line 103 "macro.lex.l"
859 *lex_data->strptr++ = yytext[1];
860  YY_BREAK
861 case YY_STATE_EOF(quote):
862 #line 104 "macro.lex.l"
863 return 0;
864  YY_BREAK
865 case 12:
867 #line 106 "macro.lex.l"
868 
869  YY_BREAK
870 case 13:
872 #line 107 "macro.lex.l"
873 return yytext[0];
874  YY_BREAK
875 case 14:
877 #line 108 "macro.lex.l"
878 ECHO;
879  YY_BREAK
880 #line 881 "macro.lex.yy.c"
881 case YY_STATE_EOF(INITIAL):
882  yyterminate();
883 
884  case YY_END_OF_BUFFER:
885  {
886  /* Amount of text matched not including the EOB char. */
887  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
888 
889  /* Undo the effects of YY_DO_BEFORE_ACTION. */
890  *yy_cp = (yy_hold_char);
892 
893  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
894  {
895  /* We're scanning a new file or input source. It's
896  * possible that this happened because the user
897  * just pointed yyin at a new source and called
898  * yylex(). If so, then we have to assure
899  * consistency between YY_CURRENT_BUFFER and our
900  * globals. Here is the right place to do so, because
901  * this is the first action (other than possibly a
902  * back-up) that will match for the new input source.
903  */
904  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
905  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
906  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
907  }
908 
909  /* Note that here we test for yy_c_buf_p "<=" to the position
910  * of the first EOB in the buffer, since yy_c_buf_p will
911  * already have been incremented past the NUL character
912  * (since all states make transitions on EOB to the
913  * end-of-buffer state). Contrast this with the test
914  * in input().
915  */
916  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
917  { /* This was really a NUL. */
918  yy_state_type yy_next_state;
919 
920  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
921 
923 
924  /* Okay, we're now positioned to make the NUL
925  * transition. We couldn't have
926  * yy_get_previous_state() go ahead and do it
927  * for us because it doesn't know how to deal
928  * with the possibility of jamming (and we don't
929  * want to build jamming into it because then it
930  * will run more slowly).
931  */
932 
933  yy_next_state = yy_try_NUL_trans( yy_current_state );
934 
936 
937  if ( yy_next_state )
938  {
939  /* Consume the NUL. */
940  yy_cp = ++(yy_c_buf_p);
941  yy_current_state = yy_next_state;
942  goto yy_match;
943  }
944 
945  else
946  {
949  goto yy_find_action;
950  }
951  }
952 
953  else switch ( yy_get_next_buffer( ) )
954  {
955  case EOB_ACT_END_OF_FILE:
956  {
958 
959  if ( yywrap( ) )
960  {
961  /* Note: because we've taken care in
962  * yy_get_next_buffer() to have set up
963  * yytext, we can now set up
964  * yy_c_buf_p so that if some total
965  * hoser (like flex itself) wants to
966  * call the scanner after we return the
967  * YY_NULL, it'll still work - another
968  * YY_NULL will get returned.
969  */
971 
973  goto do_action;
974  }
975 
976  else
977  {
978  if ( ! (yy_did_buffer_switch_on_eof) )
979  YY_NEW_FILE;
980  }
981  break;
982  }
983 
985  (yy_c_buf_p) =
986  (yytext_ptr) + yy_amount_of_matched_text;
987 
989 
990  yy_cp = (yy_c_buf_p);
992  goto yy_match;
993 
994  case EOB_ACT_LAST_MATCH:
995  (yy_c_buf_p) =
996  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
997 
999 
1000  yy_cp = (yy_c_buf_p);
1002  goto yy_find_action;
1003  }
1004  break;
1005  }
1006 
1007  default:
1009  "fatal flex scanner internal error--no action found" );
1010  } /* end of action switch */
1011  } /* end of scanning one token */
1012 } /* end of yylex */
1013 
1014 /* yy_get_next_buffer - try to read in a new buffer
1015  *
1016  * Returns a code representing an action:
1017  * EOB_ACT_LAST_MATCH -
1018  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1019  * EOB_ACT_END_OF_FILE - end of file
1020  */
1021 static int yy_get_next_buffer (void)
1022 {
1023  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1024  register char *source = (yytext_ptr);
1025  register int number_to_move, i;
1026  int ret_val;
1027 
1028  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1030  "fatal flex scanner internal error--end of buffer missed" );
1031 
1032  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1033  { /* Don't try to fill the buffer, so this is an EOF. */
1034  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1035  {
1036  /* We matched a single character, the EOB, so
1037  * treat this as a final EOF.
1038  */
1039  return EOB_ACT_END_OF_FILE;
1040  }
1041 
1042  else
1043  {
1044  /* We matched some text prior to the EOB, first
1045  * process it.
1046  */
1047  return EOB_ACT_LAST_MATCH;
1048  }
1049  }
1050 
1051  /* Try to read more data. */
1052 
1053  /* First move last chars to start of buffer. */
1054  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1055 
1056  for ( i = 0; i < number_to_move; ++i )
1057  *(dest++) = *(source++);
1058 
1059  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1060  /* don't do the read, it's not guaranteed to return an EOF,
1061  * just force an EOF
1062  */
1063  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1064 
1065  else
1066  {
1067  yy_size_t num_to_read =
1068  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1069 
1070  while ( num_to_read <= 0 )
1071  { /* Not enough room in the buffer - grow it. */
1072 
1073  /* just a shorter name for the current buffer */
1075 
1076  int yy_c_buf_p_offset =
1077  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1078 
1079  if ( b->yy_is_our_buffer )
1080  {
1081  yy_size_t new_size = b->yy_buf_size * 2;
1082 
1083  if ( new_size <= 0 )
1084  b->yy_buf_size += b->yy_buf_size / 8;
1085  else
1086  b->yy_buf_size *= 2;
1087 
1088  b->yy_ch_buf = (char *)
1089  /* Include room in for 2 EOB chars. */
1090  yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1091  }
1092  else
1093  /* Can't grow it, we don't own it. */
1094  b->yy_ch_buf = 0;
1095 
1096  if ( ! b->yy_ch_buf )
1098  "fatal error - scanner input buffer overflow" );
1099 
1100  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1101 
1102  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1103  number_to_move - 1;
1104 
1105  }
1106 
1107  if ( num_to_read > YY_READ_BUF_SIZE )
1108  num_to_read = YY_READ_BUF_SIZE;
1109 
1110  /* Read in more data. */
1111  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1112  (yy_n_chars), num_to_read );
1113 
1114  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1115  }
1116 
1117  if ( (yy_n_chars) == 0 )
1118  {
1119  if ( number_to_move == YY_MORE_ADJ )
1120  {
1121  ret_val = EOB_ACT_END_OF_FILE;
1122  yyrestart(yyin );
1123  }
1124 
1125  else
1126  {
1127  ret_val = EOB_ACT_LAST_MATCH;
1128  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1130  }
1131  }
1132 
1133  else
1134  ret_val = EOB_ACT_CONTINUE_SCAN;
1135 
1136  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1137  /* Extend the array by 50%, plus the number we really need. */
1138  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1139  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1140  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1141  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1142  }
1143 
1144  (yy_n_chars) += number_to_move;
1147 
1148  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1149 
1150  return ret_val;
1151 }
1152 
1153 /* yy_get_previous_state - get the state just before the EOB char was reached */
1154 
1156 {
1158  register char *yy_cp;
1159 
1161 
1162  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1163  {
1164  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1165  if ( yy_accept[yy_current_state] )
1166  {
1169  }
1170  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1171  {
1173  if ( yy_current_state >= 28 )
1174  yy_c = yy_meta[(unsigned int) yy_c];
1175  }
1176  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1177  }
1178 
1179  return yy_current_state;
1180 }
1181 
1182 /* yy_try_NUL_trans - try to make a transition on the NUL character
1183  *
1184  * synopsis
1185  * next_state = yy_try_NUL_trans( current_state );
1186  */
1188 {
1189  register int yy_is_jam;
1190  register char *yy_cp = (yy_c_buf_p);
1191 
1192  register YY_CHAR yy_c = 1;
1193  if ( yy_accept[yy_current_state] )
1194  {
1197  }
1198  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1199  {
1201  if ( yy_current_state >= 28 )
1202  yy_c = yy_meta[(unsigned int) yy_c];
1203  }
1204  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1205  yy_is_jam = (yy_current_state == 27);
1206 
1207  return yy_is_jam ? 0 : yy_current_state;
1208 }
1209 
1210 #ifndef YY_NO_INPUT
1211 #ifdef __cplusplus
1212  static int yyinput (void)
1213 #else
1214  static int input (void)
1215 #endif
1216 
1217 {
1218  int c;
1219 
1220  *(yy_c_buf_p) = (yy_hold_char);
1221 
1222  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1223  {
1224  /* yy_c_buf_p now points to the character we want to return.
1225  * If this occurs *before* the EOB characters, then it's a
1226  * valid NUL; if not, then we've hit the end of the buffer.
1227  */
1228  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1229  /* This was really a NUL. */
1230  *(yy_c_buf_p) = '\0';
1231 
1232  else
1233  { /* need more input */
1235  ++(yy_c_buf_p);
1236 
1237  switch ( yy_get_next_buffer( ) )
1238  {
1239  case EOB_ACT_LAST_MATCH:
1240  /* This happens because yy_g_n_b()
1241  * sees that we've accumulated a
1242  * token and flags that we need to
1243  * try matching the token before
1244  * proceeding. But for input(),
1245  * there's no matching to consider.
1246  * So convert the EOB_ACT_LAST_MATCH
1247  * to EOB_ACT_END_OF_FILE.
1248  */
1249 
1250  /* Reset buffer status. */
1251  yyrestart(yyin );
1252 
1253  /*FALLTHROUGH*/
1254 
1255  case EOB_ACT_END_OF_FILE:
1256  {
1257  if ( yywrap( ) )
1258  return EOF;
1259 
1260  if ( ! (yy_did_buffer_switch_on_eof) )
1261  YY_NEW_FILE;
1262 #ifdef __cplusplus
1263  return yyinput();
1264 #else
1265  return input();
1266 #endif
1267  }
1268 
1269  case EOB_ACT_CONTINUE_SCAN:
1270  (yy_c_buf_p) = (yytext_ptr) + offset;
1271  break;
1272  }
1273  }
1274  }
1275 
1276  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1277  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1278  (yy_hold_char) = *++(yy_c_buf_p);
1279 
1280  return c;
1281 }
1282 #endif /* ifndef YY_NO_INPUT */
1283 
1289  void yyrestart (FILE * input_file )
1290 {
1291 
1292  if ( ! YY_CURRENT_BUFFER ){
1296  }
1297 
1298  yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1300 }
1301 
1307 {
1308 
1309  /* TODO. We should be able to replace this entire function body
1310  * with
1311  * yypop_buffer_state();
1312  * yypush_buffer_state(new_buffer);
1313  */
1315  if ( YY_CURRENT_BUFFER == new_buffer )
1316  return;
1317 
1318  if ( YY_CURRENT_BUFFER )
1319  {
1320  /* Flush out information for old buffer. */
1321  *(yy_c_buf_p) = (yy_hold_char);
1322  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1323  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1324  }
1325 
1326  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1328 
1329  /* We don't actually know whether we did this switch during
1330  * EOF (yywrap()) processing, but the only time this flag
1331  * is looked at is after yywrap() is called, so it's safe
1332  * to go ahead and always set it.
1333  */
1335 }
1336 
1337 static void yy_load_buffer_state (void)
1338 {
1339  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1340  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1341  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1342  (yy_hold_char) = *(yy_c_buf_p);
1343 }
1344 
1352 {
1354 
1355  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1356  if ( ! b )
1357  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1358 
1359  b->yy_buf_size = size;
1360 
1361  /* yy_ch_buf has to be 2 characters longer than the size given because
1362  * we need to put in 2 end-of-buffer characters.
1363  */
1364  b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1365  if ( ! b->yy_ch_buf )
1366  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1367 
1368  b->yy_is_our_buffer = 1;
1369 
1370  yy_init_buffer(b,file );
1371 
1372  return b;
1373 }
1374 
1380 {
1381 
1382  if ( ! b )
1383  return;
1384 
1385  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1387 
1388  if ( b->yy_is_our_buffer )
1389  yyfree((void *) b->yy_ch_buf );
1390 
1391  yyfree((void *) b );
1392 }
1393 
1394 /* Initializes or reinitializes a buffer.
1395  * This function is sometimes called more than once on the same buffer,
1396  * such as during a yyrestart() or at EOF.
1397  */
1399 
1400 {
1401  int oerrno = errno;
1402 
1403  yy_flush_buffer(b );
1404 
1405  b->yy_input_file = file;
1406  b->yy_fill_buffer = 1;
1407 
1408  /* If b is the current buffer, then yy_init_buffer was _probably_
1409  * called from yyrestart() or through yy_get_next_buffer.
1410  * In that case, we don't want to reset the lineno or column.
1411  */
1412  if (b != YY_CURRENT_BUFFER){
1413  b->yy_bs_lineno = 1;
1414  b->yy_bs_column = 0;
1415  }
1416 
1417  b->yy_is_interactive = 0;
1418 
1419  errno = oerrno;
1420 }
1421 
1427 {
1428  if ( ! b )
1429  return;
1430 
1431  b->yy_n_chars = 0;
1432 
1433  /* We always need two end-of-buffer characters. The first causes
1434  * a transition to the end-of-buffer state. The second causes
1435  * a jam in that state.
1436  */
1437  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1438  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1439 
1440  b->yy_buf_pos = &b->yy_ch_buf[0];
1441 
1442  b->yy_at_bol = 1;
1443  b->yy_buffer_status = YY_BUFFER_NEW;
1444 
1445  if ( b == YY_CURRENT_BUFFER )
1447 }
1448 
1456 {
1457  if (new_buffer == NULL)
1458  return;
1459 
1461 
1462  /* This block is copied from yy_switch_to_buffer. */
1463  if ( YY_CURRENT_BUFFER )
1464  {
1465  /* Flush out information for old buffer. */
1466  *(yy_c_buf_p) = (yy_hold_char);
1467  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1468  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1469  }
1470 
1471  /* Only push if top exists. Otherwise, replace top. */
1472  if (YY_CURRENT_BUFFER)
1473  (yy_buffer_stack_top)++;
1474  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1475 
1476  /* copied from yy_switch_to_buffer. */
1479 }
1480 
1486 {
1487  if (!YY_CURRENT_BUFFER)
1488  return;
1489 
1492  if ((yy_buffer_stack_top) > 0)
1493  --(yy_buffer_stack_top);
1494 
1495  if (YY_CURRENT_BUFFER) {
1498  }
1499 }
1500 
1501 /* Allocates the stack if it does not exist.
1502  * Guarantees space for at least one push.
1503  */
1504 static void yyensure_buffer_stack (void)
1505 {
1506  yy_size_t num_to_alloc;
1507 
1508  if (!(yy_buffer_stack)) {
1509 
1510  /* First allocation is just for 2 elements, since we don't know if this
1511  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1512  * immediate realloc on the next call.
1513  */
1514  num_to_alloc = 1;
1516  (num_to_alloc * sizeof(struct yy_buffer_state*)
1517  );
1518  if ( ! (yy_buffer_stack) )
1519  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1520 
1521  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1522 
1523  (yy_buffer_stack_max) = num_to_alloc;
1524  (yy_buffer_stack_top) = 0;
1525  return;
1526  }
1527 
1528  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1529 
1530  /* Increase the buffer to prepare for a possible push. */
1531  int grow_size = 8 /* arbitrary grow size */;
1532 
1533  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1535  ((yy_buffer_stack),
1536  num_to_alloc * sizeof(struct yy_buffer_state*)
1537  );
1538  if ( ! (yy_buffer_stack) )
1539  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1540 
1541  /* zero only the new slots.*/
1542  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1543  (yy_buffer_stack_max) = num_to_alloc;
1544  }
1545 }
1546 
1554 {
1556 
1557  if ( size < 2 ||
1560  /* They forgot to leave room for the EOB's. */
1561  return 0;
1562 
1563  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1564  if ( ! b )
1565  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1566 
1567  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1568  b->yy_buf_pos = b->yy_ch_buf = base;
1569  b->yy_is_our_buffer = 0;
1570  b->yy_input_file = 0;
1571  b->yy_n_chars = b->yy_buf_size;
1572  b->yy_is_interactive = 0;
1573  b->yy_at_bol = 1;
1574  b->yy_fill_buffer = 0;
1575  b->yy_buffer_status = YY_BUFFER_NEW;
1576 
1578 
1579  return b;
1580 }
1581 
1591 {
1592 
1593  return yy_scan_bytes(yystr,strlen(yystr) );
1594 }
1595 
1603 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
1604 {
1606  char *buf;
1607  yy_size_t n;
1608  yy_size_t i;
1609 
1610  /* Get memory for full buffer, including space for trailing EOB's. */
1611  n = _yybytes_len + 2;
1612  buf = (char *) yyalloc(n );
1613  if ( ! buf )
1614  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1615 
1616  for ( i = 0; i < _yybytes_len; ++i )
1617  buf[i] = yybytes[i];
1618 
1619  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1620 
1621  b = yy_scan_buffer(buf,n );
1622  if ( ! b )
1623  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1624 
1625  /* It's okay to grow etc. this buffer, and we should throw it
1626  * away when we're done.
1627  */
1628  b->yy_is_our_buffer = 1;
1629 
1630  return b;
1631 }
1632 
1633 #ifndef YY_EXIT_FAILURE
1634 #define YY_EXIT_FAILURE 2
1635 #endif
1636 
1637 static void yy_fatal_error (yyconst char* msg )
1638 {
1639  (void) fprintf( stderr, "%s\n", msg );
1640  exit( YY_EXIT_FAILURE );
1641 }
1642 
1643 /* Redefine yyless() so it works in section 3 code. */
1644 
1645 #undef yyless
1646 #define yyless(n) \
1647  do \
1648  { \
1649  /* Undo effects of setting up yytext. */ \
1650  int yyless_macro_arg = (n); \
1651  YY_LESS_LINENO(yyless_macro_arg);\
1652  yytext[yyleng] = (yy_hold_char); \
1653  (yy_c_buf_p) = yytext + yyless_macro_arg; \
1654  (yy_hold_char) = *(yy_c_buf_p); \
1655  *(yy_c_buf_p) = '\0'; \
1656  yyleng = yyless_macro_arg; \
1657  } \
1658  while ( 0 )
1659 
1660 /* Accessor methods (get/set functions) to struct members. */
1661 
1665 int yyget_lineno (void)
1666 {
1667 
1668  return yylineno;
1669 }
1670 
1675 {
1676  return yyin;
1677 }
1678 
1683 {
1684  return yyout;
1685 }
1686 
1691 {
1692  return yyleng;
1693 }
1694 
1699 char *yyget_text (void)
1700 {
1701  return yytext;
1702 }
1703 
1709 {
1710 
1712 }
1713 
1720 void yyset_in (FILE * in_str )
1721 {
1722  yyin = in_str ;
1723 }
1724 
1725 void yyset_out (FILE * out_str )
1726 {
1727  yyout = out_str ;
1728 }
1729 
1730 int yyget_debug (void)
1731 {
1732  return yy_flex_debug;
1733 }
1734 
1735 void yyset_debug (int bdebug )
1736 {
1737  yy_flex_debug = bdebug ;
1738 }
1739 
1740 static int yy_init_globals (void)
1741 {
1742  /* Initialization is the same as for the non-reentrant scanner.
1743  * This function is called from yylex_destroy(), so don't allocate here.
1744  */
1745 
1746  (yy_buffer_stack) = 0;
1747  (yy_buffer_stack_top) = 0;
1748  (yy_buffer_stack_max) = 0;
1749  (yy_c_buf_p) = (char *) 0;
1750  (yy_init) = 0;
1751  (yy_start) = 0;
1752 
1753 /* Defined in main.c */
1754 #ifdef YY_STDINIT
1755  yyin = stdin;
1756  yyout = stdout;
1757 #else
1758  yyin = (FILE *) 0;
1759  yyout = (FILE *) 0;
1760 #endif
1761 
1762  /* For future reference: Set errno on error, since we are called by
1763  * yylex_init()
1764  */
1765  return 0;
1766 }
1767 
1768 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1769 int yylex_destroy (void)
1770 {
1771 
1772  /* Pop the buffer stack, destroying each element. */
1773  while(YY_CURRENT_BUFFER){
1777  }
1778 
1779  /* Destroy the stack itself. */
1780  yyfree((yy_buffer_stack) );
1781  (yy_buffer_stack) = NULL;
1782 
1783  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1784  * yylex() is called, initialization will occur. */
1785  yy_init_globals( );
1786 
1787  return 0;
1788 }
1789 
1790 /*
1791  * Internal utility routines.
1792  */
1793 
1794 #ifndef yytext_ptr
1795 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1796 {
1797  register int i;
1798  for ( i = 0; i < n; ++i )
1799  s1[i] = s2[i];
1800 }
1801 #endif
1802 
1803 #ifdef YY_NEED_STRLEN
1804 static int yy_flex_strlen (yyconst char * s )
1805 {
1806  register int n;
1807  for ( n = 0; s[n]; ++n )
1808  ;
1809 
1810  return n;
1811 }
1812 #endif
1813 
1815 {
1816  return (void *) malloc( size );
1817 }
1818 
1819 void *yyrealloc (void * ptr, yy_size_t size )
1820 {
1821  /* The cast to (char *) in the following accommodates both
1822  * implementations that use char* generic pointers, and those
1823  * that use void* generic pointers. It works with the latter
1824  * because both ANSI C and C++ allow castless assignment from
1825  * any pointer type to void*, and deal with argument conversions
1826  * as though doing an assignment.
1827  */
1828  return (void *) realloc( (char *) ptr, size );
1829 }
1830 
1831 void yyfree (void * ptr )
1832 {
1833  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1834 }
1835 
1836 #define YYTABLES_NAME "yytables"
1837 
1838 #line 107 "macro.lex.l"
1839 
1840 
1841 
1842 #if 0
1843 /* all code for testing macros */
1844 #include "winhelp.h"
1845 static CHAR szTestMacro[256];
1846 
1847 static LRESULT CALLBACK MACRO_TestDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
1848 {
1849  if (msg == WM_COMMAND && wParam == IDOK)
1850  {
1851  GetDlgItemText(hDlg, 99, szTestMacro, sizeof(szTestMacro));
1852  EndDialog(hDlg, IDOK);
1853  return TRUE;
1854  }
1855  return FALSE;
1856 }
1857 
1858 void macro_test(void)
1859 {
1860  WNDPROC lpfnDlg = MakeProcInstance(MACRO_TestDialogProc, Globals.hInstance);
1862  FreeProcInstance(lpfnDlg);
1863  macro = szTestMacro;
1864 }
1865 #endif
1866 
1867 /* small helper function for debug messages */
1868 static const char* ts(int t)
1869 {
1870  static char c[2] = {0,0};
1871 
1872  switch (t)
1873  {
1874  case EMPTY: return "EMPTY";
1875  case VOID_FUNCTION: return "VOID_FUNCTION";
1876  case BOOL_FUNCTION: return "BOOL_FUNCTION";
1877  case INTEGER: return "INTEGER";
1878  case STRING: return "STRING";
1879  case IDENTIFIER: return "IDENTIFIER";
1880  default: c[0] = (char)t; return c;
1881  }
1882 }
1883 
1884 static int MACRO_CallBoolFunc(void *fn, const char* args, void** ret);
1885 
1886 /******************************************************************
1887  * MACRO_CheckArgs
1888  *
1889  * checks number of arguments against prototype, and stores arguments on
1890  * stack pa for later call
1891  * returns -1 on error, otherwise the number of pushed parameters
1892  */
1893 static int MACRO_CheckArgs(void* pa[], unsigned max, const char* args)
1894 {
1895  int t;
1896  unsigned int len = 0, idx = 0;
1897 
1898  WINE_TRACE("Checking %s\n", debugstr_a(args));
1899 
1900  if (yylex() != '(') {WINE_WARN("missing (\n");return -1;}
1901 
1902  if (*args)
1903  {
1904  len = strlen(args);
1905  for (;;)
1906  {
1907  t = yylex();
1908  WINE_TRACE("Got %s <=> %c\n", debugstr_a(ts(t)), *args);
1909 
1910  switch (*args)
1911  {
1912  case 'S':
1913  if (t != STRING)
1914  {WINE_WARN("missing S\n");return -1;}
1915  pa[idx] = (void*)yylval.string;
1916  break;
1917  case 'U':
1918  case 'I':
1919  if (t != INTEGER)
1920  {WINE_WARN("missing U\n");return -1;}
1921  pa[idx] = LongToPtr(yylval.integer);
1922  break;
1923  case 'B':
1924  if (t != BOOL_FUNCTION)
1925  {WINE_WARN("missing B\n");return -1;}
1926  if (MACRO_CallBoolFunc(yylval.function, yylval.proto, &pa[idx]) == 0)
1927  return -1;
1928  break;
1929  default:
1930  WINE_WARN("unexpected %s while args is %c\n", debugstr_a(ts(t)), *args);
1931  return -1;
1932  }
1933  idx++;
1934  if (*++args == '\0') break;
1935  t = yylex();
1936  if (t == ')') goto CheckArgs_end;
1937  if (t != ',') {WINE_WARN("missing ,\n");return -1;}
1938  if (idx >= max) {WINE_FIXME("stack overflow (%d)\n", max);return -1;}
1939  }
1940  }
1941  if (yylex() != ')') {WINE_WARN("missing )\n");return -1;}
1942 
1943 CheckArgs_end:
1944  while (len > idx) pa[--len] = NULL;
1945  return idx;
1946 }
1947 
1948 /******************************************************************
1949  * MACRO_CallBoolFunc
1950  *
1951  * Invokes boolean function fn, which arguments are defined by args
1952  * stores bool result into ret
1953  */
1954 static int MACRO_CallBoolFunc(void *fn, const char* args, void** ret)
1955 {
1956  void* pa[2];
1957  int idx = MACRO_CheckArgs(pa, ARRAY_SIZE(pa), args);
1958 
1959  if (idx < 0) return 0;
1960  if (!fn) return 1;
1961 
1962  WINE_TRACE("calling with %u pmts\n", idx);
1963 
1964  switch (strlen(args))
1965  {
1966  case 0:
1967  {
1968  BOOL (WINAPI *func)(void) = fn;
1969  *ret = (void *)(ULONG_PTR)func();
1970  break;
1971  }
1972  case 1:
1973  {
1974  BOOL (WINAPI *func)(void *) = fn;
1975  *ret = (void *)(ULONG_PTR)func( pa[0]);
1976  break;
1977  }
1978  default: WINE_FIXME("NIY\n");
1979  }
1980 
1981  return 1;
1982 }
1983 
1984 /******************************************************************
1985  * MACRO_CallVoidFunc
1986  *
1987  *
1988  */
1989 static int MACRO_CallVoidFunc(void *fn, const char* args)
1990 {
1991  void* pa[6];
1992  int idx = MACRO_CheckArgs(pa, ARRAY_SIZE(pa), args);
1993 
1994  if (idx < 0) return 0;
1995  if (!fn) return 1;
1996 
1997  WINE_TRACE("calling %p with %u pmts\n", fn, idx);
1998 
1999  switch (strlen(args))
2000  {
2001  case 0:
2002  {
2003  void (WINAPI *func)(void) = fn;
2004  func();
2005  break;
2006  }
2007  case 1:
2008  {
2009  void (WINAPI *func)(void*) = fn;
2010  func( pa[0] );
2011  break;
2012  }
2013  case 2:
2014  {
2015  void (WINAPI *func)(void*,void*) = fn;
2016  func( pa[0], pa[1] );
2017  break;
2018  }
2019  case 3:
2020  {
2021  void (WINAPI *func)(void*,void*,void*) = fn;
2022  func( pa[0], pa[1], pa[2] );
2023  break;
2024  }
2025  case 4:
2026  {
2027  void (WINAPI *func)(void*,void*,void*,void*) = fn;
2028  func( pa[0], pa[1], pa[2], pa[3] );
2029  break;
2030  }
2031  case 5:
2032  {
2033  void (WINAPI *func)(void*,void*,void*,void*,void*) = fn;
2034  func( pa[0], pa[1], pa[2], pa[3], pa[4] );
2035  break;
2036  }
2037  case 6:
2038  {
2039  void (WINAPI *func)(void*,void*,void*,void*,void*,void*) = fn;
2040  func( pa[0], pa[1], pa[2], pa[3], pa[4], pa[5] );
2041  break;
2042  }
2043  default: WINE_FIXME("NIY\n");
2044  }
2045 
2046  return 1;
2047 }
2048 
2050 {
2051  struct lex_data curr_lex_data, *prev_lex_data;
2052  BOOL ret = TRUE;
2053  int t;
2054 
2055  WINE_TRACE("%s\n", debugstr_a(macro));
2056 
2057  prev_lex_data = lex_data;
2058  lex_data = &curr_lex_data;
2059 
2060  memset(lex_data, 0, sizeof(*lex_data));
2061  lex_data->macroptr = macro;
2063 
2064  while ((t = yylex()) != EMPTY)
2065  {
2066  switch (t)
2067  {
2068  case VOID_FUNCTION:
2069  WINE_TRACE("got type void func(%s)\n", debugstr_a(yylval.proto));
2070  MACRO_CallVoidFunc(yylval.function, yylval.proto);
2071  break;
2072  case BOOL_FUNCTION:
2073  WINE_WARN("got type bool func(%s)\n", debugstr_a(yylval.proto));
2074  break;
2075  default:
2076  WINE_WARN("got unexpected type %s\n", debugstr_a(ts(t)));
2078  ret = FALSE;
2079  goto done;
2080  }
2081  switch (t = yylex())
2082  {
2083  case EMPTY: goto done;
2084  case ';': break;
2085  default: ret = FALSE; YY_FLUSH_BUFFER; goto done;
2086  }
2087  }
2088 
2089 done:
2090  for (t = 0; t < lex_data->cache_used; t++)
2092  lex_data = prev_lex_data;
2094 
2095  return ret;
2096 }
2097 
2099 {
2100  return lex_data ? lex_data->window : Globals.active_win;
2101 }
2102 
2103 #ifndef yywrap
2104 int yywrap(void) { return 1; }
2105 #endif
2106 
#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:523
#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)
#define max(a, b)
Definition: svc.c:63
yy_size_t yy_n_chars
Definition: macro.lex.yy.c:205
struct S2 s2
#define TRUE
Definition: types.h:120
#define LongToPtr(l)
Definition: basetsd.h:91
#define IDOK
Definition: winuser.h:824
#define YY_STATE_EOF(state)
Definition: macro.lex.yy.c:136
WINHELP_WINDOW * window
Definition: macro.lex.yy.c:519
void yy_delete_buffer(YY_BUFFER_STATE b)
void yyrestart(FILE *input_file)
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define FreeProcInstance(p)
Definition: winbase.h:1973
#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)
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
#define EMPTY(rect)
Definition: text.c:32
#define YY_BUFFER_NORMAL
Definition: macro.lex.yy.c:237
WINE_DEFAULT_DEBUG_CHANNEL(winhelp)
char CHAR
Definition: xmlstorage.h:175
#define free
Definition: debug_ros.c:5
GLintptr offset
Definition: glext.h:5920
#define CALLBACK
Definition: compat.h:27
static size_t yy_buffer_stack_max
Definition: macro.lex.yy.c:255
static size_t yy_buffer_stack_top
Definition: macro.lex.yy.c:254
GLdouble n
Definition: glext.h:7729
void yyset_extra(YY_EXTRA_TYPE user_defined)
GLdouble GLdouble t
Definition: gl.h:2047
size_t yy_size_t
Definition: macro.lex.yy.c:159
register char * yy_bp
Definition: macro.lex.yy.c:706
#define assert(x)
Definition: debug.h:53
#define WINE_TRACE
Definition: debug.h:353
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
#define INITIAL
Definition: macro.lex.yy.c:530
#define YY_RULE_SETUP
Definition: macro.lex.yy.c:698
UINT_PTR WPARAM
Definition: windef.h:207
int line_number
Definition: parser.yy.c:775
#define YY_FATAL_ERROR(msg)
Definition: macro.lex.yy.c:670
static yyconst flex_int16_t yy_accept[28]
Definition: macro.lex.yy.c:373
#define YY_EXTRA_TYPE
Definition: macro.lex.yy.c:542
int errno
unsigned short int uint16_t
Definition: acefiex.h:54
#define yy_current_state()
Definition: ppl.yy.c:1235
Definition: macro.h:44
#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 BOOL
Definition: nt_native.h:43
#define YY_START
Definition: macro.lex.yy.c:132
Definition: match.c:390
int yy_flex_debug
Definition: macro.lex.yy.c:462
BOOL WINAPI EndDialog(_In_ HWND, _In_ INT_PTR)
WPARAM wParam
Definition: combotst.c:138
int yylex(void)
FILE * stdout
static int yy_start
Definition: macro.lex.yy.c:281
static void yyensure_buffer_stack(void)
uint32_t ULONG_PTR
Definition: typedefs.h:63
Definition: macro.h:29
yy_size_t yy_buf_size
Definition: macro.lex.yy.c:200
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
#define DialogBox
Definition: winuser.h:5627
CLIPBOARD_GLOBALS Globals
Definition: clipbrd.c:13
int MACRO_Lookup(const char *name, struct lexret *lr)
Definition: macro.c:1024
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
FILE * yyin
Definition: macro.lex.yy.c:338
BOOL WINHELP_ReleaseWindow(WINHELP_WINDOW *win)
Definition: winhelp.c:523
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
int yyget_debug(void)
void yyset_out(FILE *out_str)
unsigned int BOOL
Definition: ntddk_ex.h:94
GLuint base
Definition: 3dtext.c:35
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
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:707
static PVOID ptr
Definition: dispmode.c:27
#define quote
Definition: macro.lex.yy.c:531
unsigned int idx
Definition: utils.c:41
static const char * ts(int t)
int yy_state_type
Definition: macro.lex.yy.c:340
smooth NULL
Definition: ftsmooth.c:416
void * yyalloc(yy_size_t)
unsigned char
Definition: typeof.h:29
void yyfree(void *)
WINHELP_WINDOW * WINHELP_GrabWindow(WINHELP_WINDOW *win)
Definition: winhelp.c:512
unsigned int flex_uint32_t
Definition: macro.lex.yy.c:56
LONG_PTR LPARAM
Definition: windef.h:208
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
#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)
signed char int8_t
Definition: acefiex.h:50
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define yyconst
Definition: macro.lex.yy.c:109
GLsizeiptr size
Definition: glext.h:5919
#define GetDlgItemText
Definition: winuser.h:5651
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
if(!(yy_init))
Definition: macro.lex.yy.c:714
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
#define YY_BUFFER_NEW
Definition: macro.lex.yy.c:236
int quote_stack[32]
Definition: macro.lex.yy.c:515
static yyconst flex_int16_t yy_def[33]
Definition: macro.lex.yy.c:426
#define WINAPI
Definition: msvc.h:8
const char file[]
Definition: icontest.c:11
#define EOB_ACT_END_OF_FILE
Definition: macro.lex.yy.c:167
const GLubyte * c
Definition: glext.h:8905
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:2799
#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:608
int flex_int32_t
Definition: macro.lex.yy.c:53
#define ECHO
Definition: macro.lex.yy.c:616
static int yy_init_globals(void)
int ret
#define yyterminate()
Definition: macro.lex.yy.c:660
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:695
static yyconst flex_int32_t yy_meta[15]
Definition: macro.lex.yy.c:412
GLenum GLsizei len
Definition: glext.h:6722
GLdouble s
Definition: gl.h:2039
#define WM_COMMAND
Definition: winuser.h:1716
static IHTMLWindow2 * window
Definition: events.c:77
char * yytext
Definition: macro.lex.yy.c:471
static struct lex_data * lex_data
Definition: macro.lex.yy.c:521
BYTE uint8_t
Definition: msvideo1.c:66
INT32 int32_t
Definition: types.h:71
INT_PTR(CALLBACK * DLGPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2849
static int MACRO_CallVoidFunc(void *fn, const char *args)
YY_EXTRA_TYPE yyget_extra(void)
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2859
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)
#define ARRAY_SIZE(a)
Definition: main.h:24
void yyset_in(FILE *in_str)
unsigned short int flex_uint16_t
Definition: macro.lex.yy.c:55
#define WINE_WARN
Definition: debug.h:359
#define YY_DECL
Definition: macro.lex.yy.c:683
int yylineno
Definition: macro.lex.yy.c:344
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:517
LPSTR strptr
Definition: macro.lex.yy.c:514
UINT32 uint32_t
Definition: types.h:75
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 msg(x)
Definition: auth_time.c:54
#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)
int cache_used
Definition: macro.lex.yy.c:518
register char * yy_cp
Definition: macro.lex.yy.c:706
static char * yy_last_accepting_cpos
Definition: macro.lex.yy.c:459
#define c
Definition: ke_i.h:80
FILE * stderr
#define malloc
Definition: debug_ros.c:4
INT16 int16_t
Definition: types.h:70
static char * dest
Definition: rtl.c:135
#define YY_BUFFER_EOF_PENDING
Definition: macro.lex.yy.c:248
#define YY_INPUT(buf, result, max_size)
Definition: macro.lex.yy.c:525
LPCSTR macroptr
Definition: macro.lex.yy.c:513
static yyconst flex_int16_t yy_chk[77]
Definition: macro.lex.yy.c:446
FILE * yyout
Definition: macro.lex.yy.c:338
void exit(int exitcode)
Definition: _exit.c:33
LONG_PTR LRESULT
Definition: windef.h:209
unsigned quote_stk_idx
Definition: macro.lex.yy.c:516
HINSTANCE hInstance
Definition: precomp.h:43
#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
LPARAM lParam
Definition: combotst.c:139
#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)
void * yyrealloc(void *, yy_size_t)
#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:31
Definition: fci.c:126
#define WINE_FIXME
Definition: debug.h:365