| blob | 629e25f3470b828c0d62c3dd11a4f94134c573bc |
1 /*
2 * Wrc preprocessor lexical analysis
3 *
4 * Copyright 1999-2000 Bertho A. Stultiens (BS)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * History:
21 * 24-Apr-2000 BS - Started from scratch to restructure everything
22 * and reintegrate the source into the wine-tree.
23 * 04-Jan-2000 BS - Added comments about the lexicographical
24 * grammar to give some insight in the complexity.
25 * 28-Dec-1999 BS - Eliminated backing-up of the flexer by running
26 * `flex -b' on the source. This results in some
27 * weirdo extra rules, but a much faster scanner.
28 * 23-Dec-1999 BS - Started this file
29 *
30 *-------------------------------------------------------------------------
31 * The preprocessor's lexographical grammar (approximately):
32 *
33 * pp := {ws} # {ws} if {ws} {expr} {ws} \n
34 * | {ws} # {ws} ifdef {ws} {id} {ws} \n
35 * | {ws} # {ws} ifndef {ws} {id} {ws} \n
36 * | {ws} # {ws} elif {ws} {expr} {ws} \n
37 * | {ws} # {ws} else {ws} \n
38 * | {ws} # {ws} endif {ws} \n
39 * | {ws} # {ws} include {ws} < {anytext} > \n
40 * | {ws} # {ws} include {ws} " {anytext} " \n
41 * | {ws} # {ws} define {ws} {anytext} \n
42 * | {ws} # {ws} define( {arglist} ) {ws} {expansion} \n
43 * | {ws} # {ws} pragma {ws} {anytext} \n
44 * | {ws} # {ws} ident {ws} {anytext} \n
45 * | {ws} # {ws} error {ws} {anytext} \n
46 * | {ws} # {ws} warning {ws} {anytext} \n
47 * | {ws} # {ws} line {ws} " {anytext} " {number} \n
48 * | {ws} # {ws} {number} " {anytext} " {number} [ {number} [{number}] ] \n
49 * | {ws} # {ws} \n
50 *
51 * ws := [ \t\r\f\v]*
52 *
53 * expr := {expr} [+-*%^/|&] {expr}
54 * | {expr} {logor|logand} {expr}
55 * | [!~+-] {expr}
56 * | {expr} ? {expr} : {expr}
57 *
58 * logor := ||
59 *
60 * logand := &&
61 *
62 * id := [a-zA-Z_][a-zA-Z0-9_]*
63 *
64 * anytext := [^\n]* (see note)
65 *
66 * arglist :=
67 * | {id}
68 * | {arglist} , {id}
69 * | {arglist} , {id} ...
70 *
71 * expansion := {id}
72 * | # {id}
73 * | {anytext}
74 * | {anytext} ## {anytext}
75 *
76 * number := [0-9]+
77 *
78 * Note: "anytext" is not always "[^\n]*". This is because the
79 * trailing context must be considered as well.
80 *
81 * The only certain assumption for the preprocessor to make is that
82 * directives start at the beginning of the line, followed by a '#'
83 * and end with a newline.
84 * Any directive may be suffixed with a line-continuation. Also
85 * classical comment / *...* / (note: no comments within comments,
86 * therefore spaces) is considered to be a line-continuation
87 * (according to gcc and egcs AFAIK, ANSI is a bit vague).
88 * Comments have not been added to the above grammar for simplicity
89 * reasons. However, it is allowed to enter comment anywhere within
90 * the directives as long as they do not interfere with the context.
91 * All comments are considered to be deletable whitespace (both
92 * classical form "/ *...* /" and C++ form "//...\n").
93 *
94 * All recursive scans, except for macro-expansion, are done by the
95 * parser, whereas the simple state transitions of non-recursive
96 * directives are done in the scanner. This results in the many
97 * exclusive start-conditions of the scanner.
98 *
99 * Macro expansions are slightly more difficult because they have to
100 * prescan the arguments. Parameter substitution is literal if the
101 * substitution is # or ## (either side). This enables new identifiers
102 * to be created (see 'info cpp' node Macro|Pitfalls|Prescan for more
103 * information).
104 *
105 * FIXME: Variable macro parameters is recognized, but not yet
106 * expanded. I have to reread the ANSI standard on the subject (yes,
107 * ANSI defines it).
108 *
109 * The following special defines are supported:
110 * __FILE__ -> "thissource.c"
111 * __LINE__ -> 123
112 * __DATE__ -> "May 1 2000"
113 * __TIME__ -> "23:59:59"
114 * These macros expand, as expected, into their ANSI defined values.
115 *
116 * The same include prevention is implemented as gcc and egcs does.
117 * This results in faster processing because we do not read the text
118 * at all. Some wine-sources attempt to include the same file 4 or 5
119 * times. This strategy also saves a lot blank output-lines, which in
120 * its turn improves the real resource scanner/parser.
121 *
122 */
124 /*
125 * Special flex options and exclusive scanner start-conditions
126 */
127 %option stack
128 %option never-interactive
130 %x pp_pp
131 %x pp_eol
132 %x pp_inc
133 %x pp_dqs
134 %x pp_sqs
135 %x pp_iqs
136 %x pp_comment
137 %x pp_def
138 %x pp_define
139 %x pp_macro
140 %x pp_mbody
141 %x pp_macign
142 %x pp_macscan
143 %x pp_macexp
144 %x pp_if
145 %x pp_ifd
146 %x pp_endif
147 %x pp_line
148 %x pp_defined
149 %x pp_ignore
150 %x RCINCL
152 ws [ \v\f\t\r]
153 cident [a-zA-Z_][0-9a-zA-Z_]*
154 ul [uUlL]|[uUlL][lL]|[lL][uU]|[lL][lL][uU]|[uU][lL][lL]|[lL][uU][lL]
156 %{
157 #include <stdio.h>
158 #include <stdlib.h>
159 #include <string.h>
160 #include <ctype.h>
161 #include <assert.h>
163 #include "wpp_private.h"
164 #include "y.tab.h"
166 /*
167 * Make sure that we are running an appropriate version of flex.
168 */
169 #if !defined(YY_FLEX_MAJOR_VERSION) || (1000 * YY_FLEX_MAJOR_VERSION + YY_FLEX_MINOR_VERSION < 2005)
170 #error Must use flex version 2.5.1 or higher (yy_scan_* routines are required).
171 #endif
173 #define YY_USE_PROTOS
174 #define YY_NO_UNPUT
175 #define YY_READ_BUF_SIZE 65536 /* So we read most of a file at once */
177 #define yy_current_state() YY_START
178 #define yy_pp_state(x) yy_pop_state(); yy_push_state(x)
180 /*
181 * Always update the current character position within a line
182 */
183 #define YY_USER_ACTION pp_status.char_number+=ppleng;
185 /*
186 * Buffer management for includes and expansions
187 */
188 #define MAXBUFFERSTACK 128 /* Nesting more than 128 includes or macro expansion textss is insane */
190 typedef struct bufferstackentry {
191 YY_BUFFER_STATE bufferstate; /* Buffer to switch back to */
192 pp_entry_t *define; /* Points to expanding define or NULL if handling includes */
193 int line_number; /* Line that we were handling */
194 int char_number; /* The current position on that line */
195 const char *filename; /* Filename that we were handling */
196 int if_depth; /* How many #if:s deep to check matching #endif:s */
197 int ncontinuations; /* Remember the continuation state */
198 int should_pop; /* Set if we must pop the start-state on EOF */
199 /* Include management */
200 include_state_t incl;
201 char *include_filename;
202 int pass_data;
203 } bufferstackentry_t;
205 #define ALLOCBLOCKSIZE (1 << 10) /* Allocate these chunks at a time for string-buffers */
207 /*
208 * Macro expansion nesting
209 * We need the stack to handle expansions while scanning
210 * a macro's arguments. The TOS must always be the macro
211 * that receives the current expansion from the scanner.
212 */
213 #define MAXMACEXPSTACK 128 /* Nesting more than 128 macro expansions is insane */
215 typedef struct macexpstackentry {
216 pp_entry_t *ppp; /* This macro we are scanning */
217 char **args; /* With these arguments */
218 char **ppargs; /* Resulting in these preprocessed arguments */
219 int *nnls; /* Number of newlines per argument */
220 int nargs; /* And this many arguments scanned */
221 int parentheses; /* Nesting level of () */
222 int curargsize; /* Current scanning argument's size */
223 int curargalloc; /* Current scanning argument's block allocated */
224 char *curarg; /* Current scanning argument's content */
225 } macexpstackentry_t;
227 #define MACROPARENTHESES() (top_macro()->parentheses)
229 /*
230 * Prototypes
231 */
232 static void newline(int);
233 static int make_number(int radix, YYSTYPE *val, const char *str, int len);
234 static void put_buffer(const char *s, int len);
235 /* Buffer management */
236 static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop);
237 static bufferstackentry_t *pop_buffer(void);
238 /* String functions */
239 static void new_string(void);
240 static void add_string(const char *str, int len);
241 static char *get_string(void);
242 static void put_string(void);
243 static int string_start(void);
244 /* Macro functions */
245 static void push_macro(pp_entry_t *ppp);
246 static macexpstackentry_t *top_macro(void);
247 static macexpstackentry_t *pop_macro(void);
248 static void free_macro(macexpstackentry_t *mep);
249 static void add_text_to_macro(const char *text, int len);
250 static void macro_add_arg(int last);
251 static void macro_add_expansion(void);
252 /* Expansion */
253 static void expand_special(pp_entry_t *ppp);
254 static void expand_define(pp_entry_t *ppp);
255 static void expand_macro(macexpstackentry_t *mep);
257 /*
258 * Local variables
259 */
260 static int ncontinuations;
262 static int strbuf_idx = 0;
263 static int strbuf_alloc = 0;
264 static char *strbuffer = NULL;
265 static int str_startline;
267 static macexpstackentry_t *macexpstack[MAXMACEXPSTACK];
268 static int macexpstackidx = 0;
270 static bufferstackentry_t bufferstack[MAXBUFFERSTACK];
271 static int bufferstackidx = 0;
273 static int pass_data=1;
275 /*
276 * Global variables
277 */
278 include_state_t pp_incl_state =
279 {
280 -1, /* state */
281 NULL, /* ppp */
282 0, /* ifdepth */
283 0 /* seen_junk */
284 };
286 includelogicentry_t *pp_includelogiclist = NULL;
288 %}
290 /*
291 **************************************************************************
292 * The scanner starts here
293 **************************************************************************
294 */
296 %%
297 /*
298 * Catch line-continuations.
299 * Note: Gcc keeps the line-continuations in, for example, strings
300 * intact. However, I prefer to remove them all so that the next
301 * scanner will not need to reduce the continuation state.
302 *
303 * <*>\\\n newline(0);
304 */
306 /*
307 * Detect the leading # of a preprocessor directive.
308 */
309 <INITIAL,pp_ignore>^{ws}*# pp_incl_state.seen_junk++; yy_push_state(pp_pp);
311 /*
312 * Scan for the preprocessor directives
313 */
314 <pp_pp>{ws}*include{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_inc); return tINCLUDE;} else {yy_pp_state(pp_eol);}
315 <pp_pp>{ws}*define{ws}* yy_pp_state(yy_current_state() != pp_ignore ? pp_def : pp_eol);
316 <pp_pp>{ws}*error{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tERROR;
317 <pp_pp>{ws}*warning{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tWARNING;
318 <pp_pp>{ws}*pragma{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPRAGMA;
319 <pp_pp>{ws}*ident{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPPIDENT;
320 <pp_pp>{ws}*undef{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_ifd); return tUNDEF;} else {yy_pp_state(pp_eol);}
321 <pp_pp>{ws}*ifdef{ws}* yy_pp_state(pp_ifd); return tIFDEF;
322 <pp_pp>{ws}*ifndef{ws}* pp_incl_state.seen_junk--; yy_pp_state(pp_ifd); return tIFNDEF;
323 <pp_pp>{ws}*if{ws}* yy_pp_state(pp_if); return tIF;
324 <pp_pp>{ws}*elif{ws}* yy_pp_state(pp_if); return tELIF;
325 <pp_pp>{ws}*else{ws}* yy_pp_state(pp_endif); return tELSE;
326 <pp_pp>{ws}*endif{ws}* yy_pp_state(pp_endif); return tENDIF;
327 <pp_pp>{ws}*line{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);}
328 <pp_pp>{ws}+ if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);}
329 <pp_pp>{ws}*[a-z]+ pperror("Invalid preprocessor token '%s'", pptext);
330 <pp_pp>\r?\n newline(1); yy_pop_state(); return tNL; /* This could be the null-token */
331 <pp_pp>\\\r?\n newline(0);
332 <pp_pp>\\\r? pperror("Preprocessor junk '%s'", pptext);
333 <pp_pp>. return *pptext;
335 /*
336 * Handle #include and #line
337 */
338 <pp_line>[0-9]+ return make_number(10, &pplval, pptext, ppleng);
339 <pp_inc>\< new_string(); add_string(pptext, ppleng); yy_push_state(pp_iqs);
340 <pp_inc,pp_line>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
341 <pp_inc,pp_line>{ws}+ ;
342 <pp_inc,pp_line>\n newline(1); yy_pop_state(); return tNL;
343 <pp_inc,pp_line>\\\r?\n newline(0);
344 <pp_inc,pp_line>(\\\r?)|(.) pperror(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line");
346 /*
347 * Ignore all input when a false clause is parsed
348 */
349 <pp_ignore>[^#/\\\n]+ ;
350 <pp_ignore>\n newline(1);
351 <pp_ignore>\\\r?\n newline(0);
352 <pp_ignore>(\\\r?)|(.) ;
354 /*
355 * Handle #if and #elif.
356 * These require conditionals to be evaluated, but we do not
357 * want to jam the scanner normally when we see these tokens.
358 * Note: tIDENT is handled below.
359 */
361 <pp_if>0[0-7]*{ul}? return make_number(8, &pplval, pptext, ppleng);
362 <pp_if>0[0-7]*[8-9]+{ul}? pperror("Invalid octal digit");
363 <pp_if>[1-9][0-9]*{ul}? return make_number(10, &pplval, pptext, ppleng);
364 <pp_if>0[xX][0-9a-fA-F]+{ul}? return make_number(16, &pplval, pptext, ppleng);
365 <pp_if>0[xX] pperror("Invalid hex number");
366 <pp_if>defined yy_push_state(pp_defined); return tDEFINED;
367 <pp_if>"<<" return tLSHIFT;
368 <pp_if>">>" return tRSHIFT;
369 <pp_if>"&&" return tLOGAND;
370 <pp_if>"||" return tLOGOR;
371 <pp_if>"==" return tEQ;
372 <pp_if>"!=" return tNE;
373 <pp_if>"<=" return tLTE;
374 <pp_if>">=" return tGTE;
375 <pp_if>\n newline(1); yy_pop_state(); return tNL;
376 <pp_if>\\\r?\n newline(0);
377 <pp_if>\\\r? pperror("Junk in conditional expression");
378 <pp_if>{ws}+ ;
379 <pp_if>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
380 <pp_if>\" pperror("String constants not allowed in conditionals");
381 <pp_if>. return *pptext;
383 /*
384 * Handle #ifdef, #ifndef and #undef
385 * to get only an untranslated/unexpanded identifier
386 */
387 <pp_ifd>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT;
388 <pp_ifd>{ws}+ ;
389 <pp_ifd>\n newline(1); yy_pop_state(); return tNL;
390 <pp_ifd>\\\r?\n newline(0);
391 <pp_ifd>(\\\r?)|(.) pperror("Identifier expected");
393 /*
394 * Handle #else and #endif.
395 */
396 <pp_endif>{ws}+ ;
397 <pp_endif>\n newline(1); yy_pop_state(); return tNL;
398 <pp_endif>\\\r?\n newline(0);
399 <pp_endif>. pperror("Garbage after #else or #endif.");
401 /*
402 * Handle the special 'defined' keyword.
403 * This is necessary to get the identifier prior to any
404 * substitutions.
405 */
406 <pp_defined>{cident} yy_pop_state(); pplval.cptr = pp_xstrdup(pptext); return tIDENT;
407 <pp_defined>{ws}+ ;
408 <pp_defined>(\()|(\)) return *pptext;
409 <pp_defined>\\\r?\n newline(0);
410 <pp_defined>(\\.)|(\n)|(.) pperror("Identifier expected");
412 /*
413 * Handle #error, #warning, #pragma and #ident.
414 * Pass everything literally to the parser, which
415 * will act appropriately.
416 * Comments are stripped from the literal text.
417 */
418 <pp_eol>[^/\\\n]+ if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; }
419 <pp_eol>\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; }
420 <pp_eol>(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; }
421 <pp_eol>\n newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; }
422 <pp_eol>\\\r?\n newline(0);
424 /*
425 * Handle left side of #define
426 */
427 <pp_def>{cident}\( pplval.cptr = pp_xstrdup(pptext); pplval.cptr[ppleng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO;
428 <pp_def>{cident} pplval.cptr = pp_xstrdup(pptext); yy_pp_state(pp_define); return tDEFINE;
429 <pp_def>{ws}+ ;
430 <pp_def>\\\r?\n newline(0);
431 <pp_def>(\\\r?)|(\n)|(.) perror("Identifier expected");
433 /*
434 * Scan the substitution of a define
435 */
436 <pp_define>[^'"/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
437 <pp_define>(\\\r?)|(\/[^/*]) pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
438 <pp_define>\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL;
439 <pp_define>\\\r?\n newline(0);
440 <pp_define>\n newline(1); yy_pop_state(); return tNL;
441 <pp_define>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
442 <pp_define>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
444 /*
445 * Scan the definition macro arguments
446 */
447 <pp_macro>\){ws}* yy_pp_state(pp_mbody); return tMACROEND;
448 <pp_macro>{ws}+ ;
449 <pp_macro>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT;
450 <pp_macro>, return ',';
451 <pp_macro>"..." return tELIPSIS;
452 <pp_macro>(\\\r?)|(\n)|(.)|(\.\.?) pperror("Argument identifier expected");
453 <pp_macro>\\\r?\n newline(0);
455 /*
456 * Scan the substitution of a macro
457 */
458 <pp_mbody>[^a-zA-Z0-9'"#/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
459 <pp_mbody>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT;
460 <pp_mbody>\#\# return tCONCAT;
461 <pp_mbody>\# return tSTRINGIZE;
462 <pp_mbody>[0-9][^'"#/\\\n]* pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
463 <pp_mbody>(\\\r?)|(\/[^/*'"#\\\n]*) pplval.cptr = pp_xstrdup(pptext); return tLITERAL;
464 <pp_mbody>\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL;
465 <pp_mbody>\\\r?\n newline(0);
466 <pp_mbody>\n newline(1); yy_pop_state(); return tNL;
467 <pp_mbody>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
468 <pp_mbody>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
470 /*
471 * Macro expansion text scanning.
472 * This state is active just after the identifier is scanned
473 * that triggers an expansion. We *must* delete the leading
474 * whitespace before we can start scanning for arguments.
475 *
476 * If we do not see a '(' as next trailing token, then we have
477 * a false alarm. We just continue with a nose-bleed...
478 */
479 <pp_macign>{ws}*/\( yy_pp_state(pp_macscan);
480 <pp_macign>{ws}*\n {
481 if(yy_top_state() != pp_macscan)
482 newline(0);
483 }
484 <pp_macign>{ws}*\\\r?\n newline(0);
485 <pp_macign>{ws}+|{ws}*\\\r?|. {
486 macexpstackentry_t *mac = pop_macro();
487 yy_pop_state();
488 put_buffer(mac->ppp->ident, strlen(mac->ppp->ident));
489 put_buffer(pptext, ppleng);
490 free_macro(mac);
491 }
493 /*
494 * Macro expansion argument text scanning.
495 * This state is active when a macro's arguments are being read for expansion.
496 */
497 <pp_macscan>\( {
498 if(++MACROPARENTHESES() > 1)
499 add_text_to_macro(pptext, ppleng);
500 }
501 <pp_macscan>\) {
502 if(--MACROPARENTHESES() == 0)
503 {
504 yy_pop_state();
505 macro_add_arg(1);
506 }
507 else
508 add_text_to_macro(pptext, ppleng);
509 }
510 <pp_macscan>, {
511 if(MACROPARENTHESES() > 1)
512 add_text_to_macro(pptext, ppleng);
513 else
514 macro_add_arg(0);
515 }
516 <pp_macscan>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
517 <pp_macscan>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
518 <pp_macscan>"/*" yy_push_state(pp_comment); add_text_to_macro(" ", 1);
519 <pp_macscan>\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(pptext, ppleng);
520 <pp_macscan>([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(pptext, ppleng);
521 <pp_macscan>\\\r?\n newline(0);
523 /*
524 * Comment handling (almost all start-conditions)
525 */
526 <INITIAL,pp_pp,pp_ignore,pp_eol,pp_inc,pp_if,pp_ifd,pp_endif,pp_defined,pp_def,pp_define,pp_macro,pp_mbody,RCINCL>"/*" yy_push_state(pp_comment);
527 <pp_comment>[^*\n]*|"*"+[^*/\n]* ;
528 <pp_comment>\n newline(0);
529 <pp_comment>"*"+"/" yy_pop_state();
531 /*
532 * Remove C++ style comment (almost all start-conditions)
533 */
534 <INITIAL,pp_pp,pp_ignore,pp_eol,pp_inc,pp_if,pp_ifd,pp_endif,pp_defined,pp_def,pp_define,pp_macro,pp_mbody,pp_macscan,RCINCL>"//"[^\n]* {
535 if(pptext[ppleng-1] == '\\')
536 ppwarning("C++ style comment ends with an escaped newline (escape ignored)");
537 }
539 /*
540 * Single, double and <> quoted constants
541 */
542 <INITIAL,pp_macexp>\" pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs);
543 <INITIAL,pp_macexp>\' pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs);
544 <pp_dqs>[^"\\\n]+ add_string(pptext, ppleng);
545 <pp_dqs>\" {
546 add_string(pptext, ppleng);
547 yy_pop_state();
548 switch(yy_current_state())
549 {
550 case pp_pp:
551 case pp_define:
552 case pp_mbody:
553 case pp_inc:
554 case pp_line:
555 case RCINCL:
556 if (yy_current_state()==RCINCL) yy_pop_state();
557 pplval.cptr = get_string();
558 return tDQSTRING;
559 default:
560 put_string();
561 }
562 }
563 <pp_sqs>[^'\\\n]+ add_string(pptext, ppleng);
564 <pp_sqs>\' {
565 add_string(pptext, ppleng);
566 yy_pop_state();
567 switch(yy_current_state())
568 {
569 case pp_if:
570 case pp_define:
571 case pp_mbody:
572 pplval.cptr = get_string();
573 return tSQSTRING;
574 default:
575 put_string();
576 }
577 }
578 <pp_iqs>[^\>\\\n]+ add_string(pptext, ppleng);
579 <pp_iqs>\> {
580 add_string(pptext, ppleng);
581 yy_pop_state();
582 pplval.cptr = get_string();
583 return tIQSTRING;
584 }
585 <pp_dqs>\\\r?\n {
586 /*
587 * This is tricky; we need to remove the line-continuation
588 * from preprocessor strings, but OTOH retain them in all
589 * other strings. This is because the resource grammar is
590 * even more braindead than initially analysed and line-
591 * continuations in strings introduce, sigh, newlines in
592 * the output. There goes the concept of non-breaking, non-
593 * spacing whitespace.
594 */
595 switch(yy_top_state())
596 {
597 case pp_pp:
598 case pp_define:
599 case pp_mbody:
600 case pp_inc:
601 case pp_line:
602 newline(0);
603 break;
604 default:
605 add_string(pptext, ppleng);
606 newline(-1);
607 }
608 }
609 <pp_iqs,pp_dqs,pp_sqs>\\. add_string(pptext, ppleng);
610 <pp_iqs,pp_dqs,pp_sqs>\n {
611 newline(1);
612 add_string(pptext, ppleng);
613 ppwarning("Newline in string constant encounterd (started line %d)", string_start());
614 }
616 /*
617 * Identifier scanning
618 */
619 <INITIAL,pp_if,pp_inc,pp_macexp>{cident} {
620 pp_entry_t *ppp;
621 pp_incl_state.seen_junk++;
622 if(!(ppp = pplookup(pptext)))
623 {
624 if(yy_current_state() == pp_inc)
625 pperror("Expected include filename");
627 if(yy_current_state() == pp_if)
628 {
629 pplval.cptr = pp_xstrdup(pptext);
630 return tIDENT;
631 }
632 else {
633 if((yy_current_state()==INITIAL) && (strcasecmp(pptext,"RCINCLUDE")==0)){
634 yy_push_state(RCINCL);
635 return tRCINCLUDE;
636 }
637 else put_buffer(pptext, ppleng);
638 }
639 }
640 else if(!ppp->expanding)
641 {
642 switch(ppp->type)
643 {
644 case def_special:
645 expand_special(ppp);
646 break;
647 case def_define:
648 expand_define(ppp);
649 break;
650 case def_macro:
651 yy_push_state(pp_macign);
652 push_macro(ppp);
653 break;
654 default:
655 pp_internal_error(__FILE__, __LINE__, "Invalid define type %d\n", ppp->type);
656 }
657 }
658 }
660 /*
661 * Everything else that needs to be passed and
662 * newline and continuation handling
663 */
664 <INITIAL,pp_macexp>[^a-zA-Z_#'"/\\\n \r\t\f\v]+|(\/|\\)[^a-zA-Z_/*'"\\\n \r\t\v\f]* pp_incl_state.seen_junk++; put_buffer(pptext, ppleng);
665 <INITIAL,pp_macexp>{ws}+ put_buffer(pptext, ppleng);
666 <INITIAL>\n newline(1);
667 <INITIAL>\\\r?\n newline(0);
668 <INITIAL>\\\r? pp_incl_state.seen_junk++; put_buffer(pptext, ppleng);
670 /*
671 * Special catcher for macro argmument expansion to prevent
672 * newlines to propagate to the output or admin.
673 */
674 <pp_macexp>(\n)|(.)|(\\\r?(\n|.)) put_buffer(pptext, ppleng);
676 <RCINCL>[A-Za-z0-9_\.\\/]+ {
677 pplval.cptr=pp_xstrdup(pptext);
678 yy_pop_state();
679 return tRCINCLUDEPATH;
680 }
682 <RCINCL>{ws}+ ;
684 <RCINCL>\" {
685 new_string(); add_string(pptext,ppleng);yy_push_state(pp_dqs);
686 }
688 /*
689 * This is a 'catch-all' rule to discover errors in the scanner
690 * in an orderly manner.
691 */
692 <*>. pp_incl_state.seen_junk++; ppwarning("Unmatched text '%c' (0x%02x); please report\n", isprint(*pptext & 0xff) ? *pptext : ' ', *pptext);
694 <<EOF>> {
695 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
696 bufferstackentry_t *bep = pop_buffer();
698 if((!bep && pp_get_if_depth()) || (bep && pp_get_if_depth() != bep->if_depth))
699 ppwarning("Unmatched #if/#endif at end of file");
701 if(!bep)
702 {
703 if(YY_START != INITIAL)
704 pperror("Unexpected end of file during preprocessing");
705 yyterminate();
706 }
707 else if(bep->should_pop == 2)
708 {
709 macexpstackentry_t *mac;
710 mac = pop_macro();
711 expand_macro(mac);
712 }
713 pp_delete_buffer(b);
714 }
716 %%
717 /*
718 **************************************************************************
719 * Support functions
720 **************************************************************************
721 */
723 #ifndef ppwrap
724 int ppwrap(void)
725 {
726 return 1;
727 }
728 #endif
731 /*
732 *-------------------------------------------------------------------------
733 * Output newlines or set them as continuations
734 *
735 * Input: -1 - Don't count this one, but update local position (see pp_dqs)
736 * 0 - Line-continuation seen and cache output
737 * 1 - Newline seen and flush output
738 *-------------------------------------------------------------------------
739 */
740 static void newline(int dowrite)
741 {
742 pp_status.line_number++;
743 pp_status.char_number = 1;
745 if(dowrite == -1)
746 return;
748 ncontinuations++;
749 if(dowrite)
750 {
751 for(;ncontinuations; ncontinuations--)
752 put_buffer("\n", 1);
753 }
754 }
757 /*
758 *-------------------------------------------------------------------------
759 * Make a number out of an any-base and suffixed string
760 *
761 * Possible number extensions:
762 * - "" int
763 * - "L" long int
764 * - "LL" long long int
765 * - "U" unsigned int
766 * - "UL" unsigned long int
767 * - "ULL" unsigned long long int
768 * - "LU" unsigned long int
769 * - "LLU" unsigned long long int
770 * - "LUL" invalid
771 *
772 * FIXME:
773 * The sizes of resulting 'int' and 'long' are compiler specific.
774 * I depend on sizeof(int) > 2 here (although a relatively safe
775 * assumption).
776 * Long longs are not yet implemented because this is very compiler
777 * specific and I don't want to think too much about the problems.
778 *
779 *-------------------------------------------------------------------------
780 */
781 static int make_number(int radix, YYSTYPE *val, const char *str, int len)
782 {
783 int is_l = 0;
784 int is_ll = 0;
785 int is_u = 0;
786 char ext[4];
788 ext[3] = '\0';
789 ext[2] = toupper(str[len-1]);
790 ext[1] = len > 1 ? toupper(str[len-2]) : ' ';
791 ext[0] = len > 2 ? toupper(str[len-3]) : ' ';
793 if(!strcmp(ext, "LUL"))
794 pperror("Invalid constant suffix");
795 else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL"))
796 {
797 is_ll++;
798 is_u++;
799 }
800 else if(!strcmp(ext+1, "LU") || !strcmp(ext+1, "UL"))
801 {
802 is_l++;
803 is_u++;
804 }
805 else if(!strcmp(ext+1, "LL"))
806 {
807 is_ll++;
808 }
809 else if(!strcmp(ext+2, "L"))
810 {
811 is_l++;
812 }
813 else if(!strcmp(ext+2, "U"))
814 {
815 is_u++;
816 }
818 if(is_ll)
819 pp_internal_error(__FILE__, __LINE__, "long long constants not implemented yet");
821 if(is_u && is_l)
822 {
823 val->ulong = strtoul(str, NULL, radix);
824 return tULONG;
825 }
826 else if(!is_u && is_l)
827 {
828 val->slong = strtol(str, NULL, radix);
829 return tSLONG;
830 }
831 else if(is_u && !is_l)
832 {
833 val->uint = (unsigned int)strtoul(str, NULL, radix);
834 return tUINT;
835 }
837 /* Else it must be an int... */
838 val->sint = (int)strtol(str, NULL, radix);
839 return tSINT;
840 }
843 /*
844 *-------------------------------------------------------------------------
845 * Macro and define expansion support
846 *
847 * FIXME: Variable macro arguments.
848 *-------------------------------------------------------------------------
849 */
850 static void expand_special(pp_entry_t *ppp)
851 {
852 const char *dbgtext = "?";
853 static char *buf = NULL;
855 assert(ppp->type == def_special);
857 if(!strcmp(ppp->ident, "__LINE__"))
858 {
859 dbgtext = "def_special(__LINE__)";
860 buf = pp_xrealloc(buf, 32);
861 sprintf(buf, "%d", pp_status.line_number);
862 }
863 else if(!strcmp(ppp->ident, "__FILE__"))
864 {
865 dbgtext = "def_special(__FILE__)";
866 buf = pp_xrealloc(buf, strlen(pp_status.input) + 3);
867 sprintf(buf, "\"%s\"", pp_status.input);
868 }
869 else
870 pp_internal_error(__FILE__, __LINE__, "Special macro '%s' not found...\n", ppp->ident);
872 if(pp_flex_debug)
873 fprintf(stderr, "expand_special(%d): %s:%d: '%s' -> '%s'\n",
874 macexpstackidx,
875 pp_status.input,
876 pp_status.line_number,
877 ppp->ident,
878 buf ? buf : "");
880 if(buf && buf[0])
881 {
882 push_buffer(ppp, NULL, NULL, 0);
883 yy_scan_string(buf);
884 }
885 }
887 static void expand_define(pp_entry_t *ppp)
888 {
889 assert(ppp->type == def_define);
891 if(pp_flex_debug)
892 fprintf(stderr, "expand_define(%d): %s:%d: '%s' -> '%s'\n",
893 macexpstackidx,
894 pp_status.input,
895 pp_status.line_number,
896 ppp->ident,
897 ppp->subst.text);
898 if(ppp->subst.text && ppp->subst.text[0])
899 {
900 push_buffer(ppp, NULL, NULL, 0);
901 yy_scan_string(ppp->subst.text);
902 }
903 }
905 static int curdef_idx = 0;
906 static int curdef_alloc = 0;
907 static char *curdef_text = NULL;
909 static void add_text(const char *str, int len)
910 {
911 if(len == 0)
912 return;
913 if(curdef_idx >= curdef_alloc || curdef_alloc - curdef_idx < len)
914 {
915 curdef_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
916 curdef_text = pp_xrealloc(curdef_text, curdef_alloc * sizeof(curdef_text[0]));
917 if(curdef_alloc > 65536)
918 ppwarning("Reallocating macro-expansion buffer larger than 64kB");
919 }
920 memcpy(&curdef_text[curdef_idx], str, len);
921 curdef_idx += len;
922 }
924 static mtext_t *add_expand_text(mtext_t *mtp, macexpstackentry_t *mep, int *nnl)
925 {
926 char *cptr;
927 char *exp;
928 int tag;
929 int n;
931 if(mtp == NULL)
932 return NULL;
934 switch(mtp->type)
935 {
936 case exp_text:
937 if(pp_flex_debug)
938 fprintf(stderr, "add_expand_text: exp_text: '%s'\n", mtp->subst.text);
939 add_text(mtp->subst.text, strlen(mtp->subst.text));
940 break;
942 case exp_stringize:
943 if(pp_flex_debug)
944 fprintf(stderr, "add_expand_text: exp_stringize(%d): '%s'\n",
945 mtp->subst.argidx,
946 mep->args[mtp->subst.argidx]);
947 cptr = mep->args[mtp->subst.argidx];
948 add_text("\"", 1);
949 while(*cptr)
950 {
951 if(*cptr == '"' || *cptr == '\\')
952 add_text("\\", 1);
953 add_text(cptr, 1);
954 cptr++;
955 }
956 add_text("\"", 1);
957 break;
959 case exp_concat:
960 if(pp_flex_debug)
961 fprintf(stderr, "add_expand_text: exp_concat\n");
962 /* Remove trailing whitespace from current expansion text */
963 while(curdef_idx)
964 {
965 if(isspace(curdef_text[curdef_idx-1] & 0xff))
966 curdef_idx--;
967 else
968 break;
969 }
970 /* tag current position and recursively expand the next part */
971 tag = curdef_idx;
972 mtp = add_expand_text(mtp->next, mep, nnl);
974 /* Now get rid of the leading space of the expansion */
975 cptr = &curdef_text[tag];
976 n = curdef_idx - tag;
977 while(n)
978 {
979 if(isspace(*cptr & 0xff))
980 {
981 cptr++;
982 n--;
983 }
984 else
985 break;
986 }
987 if(cptr != &curdef_text[tag])
988 {
989 memmove(&curdef_text[tag], cptr, n);
990 curdef_idx -= (curdef_idx - tag) - n;
991 }
992 break;
994 case exp_subst:
995 if((mtp->next && mtp->next->type == exp_concat) || (mtp->prev && mtp->prev->type == exp_concat))
996 exp = mep->args[mtp->subst.argidx];
997 else
998 exp = mep->ppargs[mtp->subst.argidx];
999 if(exp)
1000 {
1001 add_text(exp, strlen(exp));
1002 *nnl -= mep->nnls[mtp->subst.argidx];
1003 cptr = strchr(exp, '\n');
1004 while(cptr)
1005 {
1006 *cptr = ' ';
1007 cptr = strchr(cptr+1, '\n');
1008 }
1009 mep->nnls[mtp->subst.argidx] = 0;
1010 }
1011 if(pp_flex_debug)
1012 fprintf(stderr, "add_expand_text: exp_subst(%d): '%s'\n", mtp->subst.argidx, exp);
1013 break;
1015 default:
1016 pp_internal_error(__FILE__, __LINE__, "Invalid expansion type (%d) in macro expansion\n", mtp->type);
1017 }
1018 return mtp;
1019 }
1021 static void expand_macro(macexpstackentry_t *mep)
1022 {
1023 mtext_t *mtp;
1024 int n, k;
1025 char *cptr;
1026 int nnl = 0;
1027 pp_entry_t *ppp = mep->ppp;
1028 int nargs = mep->nargs;
1030 assert(ppp->type == def_macro);
1031 assert(ppp->expanding == 0);
1033 if((ppp->nargs >= 0 && nargs != ppp->nargs) || (ppp->nargs < 0 && nargs < -ppp->nargs))
1034 pperror("Too %s macro arguments (%d)", nargs < abs(ppp->nargs) ? "few" : "many", nargs);
1036 for(n = 0; n < nargs; n++)
1037 nnl += mep->nnls[n];
1039 if(pp_flex_debug)
1040 fprintf(stderr, "expand_macro(%d): %s:%d: '%s'(%d,%d) -> ...\n",
1041 macexpstackidx,
1042 pp_status.input,
1043 pp_status.line_number,
1044 ppp->ident,
1045 mep->nargs,
1046 nnl);
1048 curdef_idx = 0;
1050 for(mtp = ppp->subst.mtext; mtp; mtp = mtp->next)
1051 {
1052 if(!(mtp = add_expand_text(mtp, mep, &nnl)))
1053 break;
1054 }
1056 for(n = 0; n < nnl; n++)
1057 add_text("\n", 1);
1059 /* To make sure there is room and termination (see below) */
1060 add_text(" \0", 2);
1062 /* Strip trailing whitespace from expansion */
1063 for(k = curdef_idx, cptr = &curdef_text[curdef_idx-1]; k > 0; k--, cptr--)
1064 {
1065 if(!isspace(*cptr & 0xff))
1066 break;
1067 }
1069 /*
1070 * We must add *one* whitespace to make sure that there
1071 * is a token-separation after the expansion.
1072 */
1073 *(++cptr) = ' ';
1074 *(++cptr) = '\0';
1075 k++;
1077 /* Strip leading whitespace from expansion */
1078 for(n = 0, cptr = curdef_text; n < k; n++, cptr++)
1079 {
1080 if(!isspace(*cptr & 0xff))
1081 break;
1082 }
1084 if(k - n > 0)
1085 {
1086 if(pp_flex_debug)
1087 fprintf(stderr, "expand_text: '%s'\n", curdef_text + n);
1088 push_buffer(ppp, NULL, NULL, 0);
1089 /*yy_scan_bytes(curdef_text + n, k - n);*/
1090 yy_scan_string(curdef_text + n);
1091 }
1092 }
1094 /*
1095 *-------------------------------------------------------------------------
1096 * String collection routines
1097 *-------------------------------------------------------------------------
1098 */
1099 static void new_string(void)
1100 {
1101 #ifdef DEBUG
1102 if(strbuf_idx)
1103 ppwarning("new_string: strbuf_idx != 0");
1104 #endif
1105 strbuf_idx = 0;
1106 str_startline = pp_status.line_number;
1107 }
1109 static void add_string(const char *str, int len)
1110 {
1111 if(len == 0)
1112 return;
1113 if(strbuf_idx >= strbuf_alloc || strbuf_alloc - strbuf_idx < len)
1114 {
1115 strbuf_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
1116 strbuffer = pp_xrealloc(strbuffer, strbuf_alloc * sizeof(strbuffer[0]));
1117 if(strbuf_alloc > 65536)
1118 ppwarning("Reallocating string buffer larger than 64kB");
1119 }
1120 memcpy(&strbuffer[strbuf_idx], str, len);
1121 strbuf_idx += len;
1122 }
1124 static char *get_string(void)
1125 {
1126 char *str = pp_xmalloc(strbuf_idx + 1);
1127 memcpy(str, strbuffer, strbuf_idx);
1128 str[strbuf_idx] = '\0';
1129 #ifdef DEBUG
1130 strbuf_idx = 0;
1131 #endif
1132 return str;
1133 }
1135 static void put_string(void)
1136 {
1137 put_buffer(strbuffer, strbuf_idx);
1138 #ifdef DEBUG
1139 strbuf_idx = 0;
1140 #endif
1141 }
1143 static int string_start(void)
1144 {
1145 return str_startline;
1146 }
1149 /*
1150 *-------------------------------------------------------------------------
1151 * Buffer management
1152 *-------------------------------------------------------------------------
1153 */
1154 static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop)
1155 {
1156 if(ppdebug)
1157 printf("push_buffer(%d): %p %p %p %d\n", bufferstackidx, ppp, filename, incname, pop);
1158 if(bufferstackidx >= MAXBUFFERSTACK)
1159 pp_internal_error(__FILE__, __LINE__, "Buffer stack overflow");
1161 memset(&bufferstack[bufferstackidx], 0, sizeof(bufferstack[0]));
1162 bufferstack[bufferstackidx].bufferstate = YY_CURRENT_BUFFER;
1163 bufferstack[bufferstackidx].define = ppp;
1164 bufferstack[bufferstackidx].line_number = pp_status.line_number;
1165 bufferstack[bufferstackidx].char_number = pp_status.char_number;
1166 bufferstack[bufferstackidx].if_depth = pp_get_if_depth();
1167 bufferstack[bufferstackidx].should_pop = pop;
1168 bufferstack[bufferstackidx].filename = pp_status.input;
1169 bufferstack[bufferstackidx].ncontinuations = ncontinuations;
1170 bufferstack[bufferstackidx].incl = pp_incl_state;
1171 bufferstack[bufferstackidx].include_filename = incname;
1172 bufferstack[bufferstackidx].pass_data = pass_data;
1174 if(ppp)
1175 ppp->expanding = 1;
1176 else if(filename)
1177 {
1178 /* These will track the pperror to the correct file and line */
1179 pp_status.line_number = 1;
1180 pp_status.char_number = 1;
1181 pp_status.input = filename;
1182 ncontinuations = 0;
1183 }
1184 else if(!pop)
1185 pp_internal_error(__FILE__, __LINE__, "Pushing buffer without knowing where to go to");
1186 bufferstackidx++;
1187 }
1189 static bufferstackentry_t *pop_buffer(void)
1190 {
1191 if(bufferstackidx < 0)
1192 pp_internal_error(__FILE__, __LINE__, "Bufferstack underflow?");
1194 if(bufferstackidx == 0)
1195 return NULL;
1197 bufferstackidx--;
1199 if(bufferstack[bufferstackidx].define)
1200 bufferstack[bufferstackidx].define->expanding = 0;
1201 else
1202 {
1203 pp_status.line_number = bufferstack[bufferstackidx].line_number;
1204 pp_status.char_number = bufferstack[bufferstackidx].char_number;
1205 pp_status.input = bufferstack[bufferstackidx].filename;
1206 ncontinuations = bufferstack[bufferstackidx].ncontinuations;
1207 if(!bufferstack[bufferstackidx].should_pop)
1208 {
1209 fclose(ppin);
1210 fprintf(ppout, "# %d \"%s\" 2\n", pp_status.line_number, pp_status.input);
1212 /* We have EOF, check the include logic */
1213 if(pp_incl_state.state == 2 && !pp_incl_state.seen_junk && pp_incl_state.ppp)
1214 {
1215 pp_entry_t *ppp = pplookup(pp_incl_state.ppp);
1216 if(ppp)
1217 {
1218 includelogicentry_t *iep = pp_xmalloc(sizeof(includelogicentry_t));
1219 iep->ppp = ppp;
1220 ppp->iep = iep;
1221 iep->filename = bufferstack[bufferstackidx].include_filename;
1222 iep->prev = NULL;
1223 iep->next = pp_includelogiclist;
1224 if(iep->next)
1225 iep->next->prev = iep;
1226 pp_includelogiclist = iep;
1227 if(pp_status.debug)
1228 fprintf(stderr, "pop_buffer: %s:%d: includelogic added, include_ppp='%s', file='%s'\n", pp_status.input, pp_status.line_number, pp_incl_state.ppp, iep->filename);
1229 }
1230 else if(bufferstack[bufferstackidx].include_filename)
1231 free(bufferstack[bufferstackidx].include_filename);
1232 }
1233 if(pp_incl_state.ppp)
1234 free(pp_incl_state.ppp);
1235 pp_incl_state = bufferstack[bufferstackidx].incl;
1236 pass_data = bufferstack[bufferstackidx].pass_data;
1238 }
1239 }
1241 if(ppdebug)
1242 printf("pop_buffer(%d): %p %p (%d, %d, %d) %p %d\n",
1243 bufferstackidx,
1244 bufferstack[bufferstackidx].bufferstate,
1245 bufferstack[bufferstackidx].define,
1246 bufferstack[bufferstackidx].line_number,
1247 bufferstack[bufferstackidx].char_number,
1248 bufferstack[bufferstackidx].if_depth,
1249 bufferstack[bufferstackidx].filename,
1250 bufferstack[bufferstackidx].should_pop);
1252 pp_switch_to_buffer(bufferstack[bufferstackidx].bufferstate);
1254 if(bufferstack[bufferstackidx].should_pop)
1255 {
1256 if(yy_current_state() == pp_macexp)
1257 macro_add_expansion();
1258 else
1259 pp_internal_error(__FILE__, __LINE__, "Pop buffer and state without macro expansion state");
1260 yy_pop_state();
1261 }
1263 return &bufferstack[bufferstackidx];
1264 }
1267 /*
1268 *-------------------------------------------------------------------------
1269 * Macro nestng support
1270 *-------------------------------------------------------------------------
1271 */
1272 static void push_macro(pp_entry_t *ppp)
1273 {
1274 if(macexpstackidx >= MAXMACEXPSTACK)
1275 pperror("Too many nested macros");
1277 macexpstack[macexpstackidx] = pp_xmalloc(sizeof(macexpstack[0][0]));
1278 memset( macexpstack[macexpstackidx], 0, sizeof(macexpstack[0][0]));
1279 macexpstack[macexpstackidx]->ppp = ppp;
1280 macexpstackidx++;
1281 }
1283 static macexpstackentry_t *top_macro(void)
1284 {
1285 return macexpstackidx > 0 ? macexpstack[macexpstackidx-1] : NULL;
1286 }
1288 static macexpstackentry_t *pop_macro(void)
1289 {
1290 if(macexpstackidx <= 0)
1291 pp_internal_error(__FILE__, __LINE__, "Macro expansion stack underflow\n");
1292 return macexpstack[--macexpstackidx];
1293 }
1295 static void free_macro(macexpstackentry_t *mep)
1296 {
1297 int i;
1299 for(i = 0; i < mep->nargs; i++)
1300 free(mep->args[i]);
1301 if(mep->args)
1302 free(mep->args);
1303 if(mep->nnls)
1304 free(mep->nnls);
1305 if(mep->curarg)
1306 free(mep->curarg);
1307 free(mep);
1308 }
1310 static void add_text_to_macro(const char *text, int len)
1311 {
1312 macexpstackentry_t *mep = top_macro();
1314 assert(mep->ppp->expanding == 0);
1316 if(mep->curargalloc - mep->curargsize <= len+1) /* +1 for '\0' */
1317 {
1318 mep->curargalloc += (ALLOCBLOCKSIZE > len+1) ? ALLOCBLOCKSIZE : len+1;
1319 mep->curarg = pp_xrealloc(mep->curarg, mep->curargalloc * sizeof(mep->curarg[0]));
1320 }
1321 memcpy(mep->curarg + mep->curargsize, text, len);
1322 mep->curargsize += len;
1323 mep->curarg[mep->curargsize] = '\0';
1324 }
1326 static void macro_add_arg(int last)
1327 {
1328 int nnl = 0;
1329 char *cptr;
1330 macexpstackentry_t *mep = top_macro();
1332 assert(mep->ppp->expanding == 0);
1334 mep->args = pp_xrealloc(mep->args, (mep->nargs+1) * sizeof(mep->args[0]));
1335 mep->ppargs = pp_xrealloc(mep->ppargs, (mep->nargs+1) * sizeof(mep->ppargs[0]));
1336 mep->nnls = pp_xrealloc(mep->nnls, (mep->nargs+1) * sizeof(mep->nnls[0]));
1337 mep->args[mep->nargs] = pp_xstrdup(mep->curarg ? mep->curarg : "");
1338 cptr = mep->args[mep->nargs]-1;
1339 while((cptr = strchr(cptr+1, '\n')))
1340 {
1341 nnl++;
1342 }
1343 mep->nnls[mep->nargs] = nnl;
1344 mep->nargs++;
1345 free(mep->curarg);
1346 mep->curargalloc = mep->curargsize = 0;
1347 mep->curarg = NULL;
1349 if(pp_flex_debug)
1350 fprintf(stderr, "macro_add_arg: %s:%d: %d -> '%s'\n",
1351 pp_status.input,
1352 pp_status.line_number,
1353 mep->nargs-1,
1354 mep->args[mep->nargs-1]);
1356 /* Each macro argument must be expanded to cope with stingize */
1357 if(last || mep->args[mep->nargs-1][0])
1358 {
1359 yy_push_state(pp_macexp);
1360 push_buffer(NULL, NULL, NULL, last ? 2 : 1);
1361 yy_scan_string(mep->args[mep->nargs-1]);
1362 /*mep->bufferstackidx = bufferstackidx; But not nested! */
1363 }
1364 }
1366 static void macro_add_expansion(void)
1367 {
1368 macexpstackentry_t *mep = top_macro();
1370 assert(mep->ppp->expanding == 0);
1372 mep->ppargs[mep->nargs-1] = pp_xstrdup(mep->curarg ? mep->curarg : "");
1373 free(mep->curarg);
1374 mep->curargalloc = mep->curargsize = 0;
1375 mep->curarg = NULL;
1377 if(pp_flex_debug)
1378 fprintf(stderr, "macro_add_expansion: %s:%d: %d -> '%s'\n",
1379 pp_status.input,
1380 pp_status.line_number,
1381 mep->nargs-1,
1382 mep->ppargs[mep->nargs-1]);
1383 }
1386 /*
1387 *-------------------------------------------------------------------------
1388 * Output management
1389 *-------------------------------------------------------------------------
1390 */
1391 static void put_buffer(const char *s, int len)
1392 {
1393 if(top_macro())
1394 add_text_to_macro(s, len);
1395 else {
1396 if(pass_data)
1397 fwrite(s, 1, len, ppout);
1398 }
1399 }
1402 /*
1403 *-------------------------------------------------------------------------
1404 * Include management
1405 *-------------------------------------------------------------------------
1406 */
1407 static int is_c_h_include(char *fname)
1408 {
1409 int sl=strlen(fname);
1410 if (sl < 2) return 0;
1411 if ((toupper(fname[sl-1])!='H') && (toupper(fname[sl-1])!='C')) return 0;
1412 if (fname[sl-2]!='.') return 0;
1413 return 1;
1414 }
1416 void pp_do_include(char *fname, int type)
1417 {
1418 char *newpath;
1419 int n;
1420 includelogicentry_t *iep;
1422 for(iep = pp_includelogiclist; iep; iep = iep->next)
1423 {
1424 if(!strcmp(iep->filename, fname))
1425 {
1426 /*
1427 * We are done. The file was included before.
1428 * If the define was deleted, then this entry would have
1429 * been deleted too.
1430 */
1431 return;
1432 }
1433 }
1435 n = strlen(fname);
1437 if(n <= 2)
1438 pperror("Empty include filename");
1440 /* Undo the effect of the quotation */
1441 fname[n-1] = '\0';
1443 if((ppin = pp_open_include(fname+1, type, &newpath)) == NULL)
1444 pperror("Unable to open include file %s", fname+1);
1446 fname[n-1] = *fname; /* Redo the quotes */
1447 push_buffer(NULL, newpath, fname, 0);
1448 pp_incl_state.seen_junk = 0;
1449 pp_incl_state.state = 0;
1450 pp_incl_state.ppp = NULL;
1451 if (is_c_h_include(newpath)) pass_data=0;
1452 else pass_data=1;
1454 if(pp_status.debug)
1455 fprintf(stderr, "pp_do_include: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d ,pass_data=%d\n",
1456 pp_status.input, pp_status.line_number, pp_incl_state.state, pp_incl_state.ppp, pp_incl_state.ifdepth, pass_data);
1457 pp_switch_to_buffer(pp_create_buffer(ppin, YY_BUF_SIZE));
1459 fprintf(ppout, "# 1 \"%s\" 1%s\n", newpath, type ? "" : " 3");
1460 }
1462 /*
1463 *-------------------------------------------------------------------------
1464 * Push/pop preprocessor ignore state when processing conditionals
1465 * which are false.
1466 *-------------------------------------------------------------------------
1467 */
1468 void pp_push_ignore_state(void)
1469 {
1470 yy_push_state(pp_ignore);
1471 }
1473 void pp_pop_ignore_state(void)
1474 {
1475 yy_pop_state();
1476 }