| blob | e71bf6ecf20911d48344d80ff46d4a073f8eae21 |
1 /* -*-C-*-
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 8bit never-interactive
129 %option noinput nounput
130 %option prefix="ppy_"
132 %x pp_pp
133 %x pp_eol
134 %x pp_inc
135 %x pp_dqs
136 %x pp_sqs
137 %x pp_iqs
138 %x pp_comment
139 %x pp_def
140 %x pp_define
141 %x pp_macro
142 %x pp_mbody
143 %x pp_macign
144 %x pp_macscan
145 %x pp_macexp
146 %x pp_if
147 %x pp_ifd
148 %x pp_endif
149 %x pp_line
150 %x pp_defined
151 %x pp_ignore
152 %x RCINCL
154 ws [ \v\f\t\r]
155 cident [a-zA-Z_][0-9a-zA-Z_]*
156 ul [uUlL]|[uUlL][lL]|[lL][uU]|[lL][lL][uU]|[uU][lL][lL]|[lL][uU][lL]
158 %{
159 #include "config.h"
160 #include "wine/port.h"
161 #include <stdio.h>
162 #include <stdlib.h>
163 #include <string.h>
164 #include <ctype.h>
165 #include <assert.h>
166 #include <errno.h>
167 #include <limits.h>
169 #ifndef LLONG_MAX
170 # define LLONG_MAX ((long long)0x7fffffff << 32 | 0xffffffff)
171 # define LLONG_MIN (-LLONG_MAX - 1)
172 #endif
173 #ifndef ULLONG_MAX
174 # define ULLONG_MAX ((long long)0xffffffff << 32 | 0xffffffff)
175 #endif
177 #ifndef HAVE_UNISTD_H
178 #define YY_NO_UNISTD_H
179 #endif
181 #include "wpp_private.h"
182 #include "ppy.tab.h"
184 /*
185 * Make sure that we are running an appropriate version of flex.
186 */
187 #if !defined(YY_FLEX_MAJOR_VERSION) || (1000 * YY_FLEX_MAJOR_VERSION + YY_FLEX_MINOR_VERSION < 2005)
188 #error Must use flex version 2.5.1 or higher (yy_scan_* routines are required).
189 #endif
191 #define YY_READ_BUF_SIZE 65536 /* So we read most of a file at once */
193 #define yy_current_state() YY_START
194 #define yy_pp_state(x) yy_pop_state(); yy_push_state(x)
196 /*
197 * Always update the current character position within a line
198 */
199 #define YY_USER_ACTION pp_status.char_number+=ppy_leng;
201 /*
202 * Buffer management for includes and expansions
203 */
204 #define MAXBUFFERSTACK 128 /* Nesting more than 128 includes or macro expansion textss is insane */
206 typedef struct bufferstackentry {
207 YY_BUFFER_STATE bufferstate; /* Buffer to switch back to */
208 pp_entry_t *define; /* Points to expanding define or NULL if handling includes */
209 int line_number; /* Line that we were handling */
210 int char_number; /* The current position on that line */
211 const char *filename; /* Filename that we were handling */
212 int if_depth; /* How many #if:s deep to check matching #endif:s */
213 int ncontinuations; /* Remember the continuation state */
214 int should_pop; /* Set if we must pop the start-state on EOF */
215 /* Include management */
216 include_state_t incl;
217 char *include_filename;
218 } bufferstackentry_t;
220 #define ALLOCBLOCKSIZE (1 << 10) /* Allocate these chunks at a time for string-buffers */
222 /*
223 * Macro expansion nesting
224 * We need the stack to handle expansions while scanning
225 * a macro's arguments. The TOS must always be the macro
226 * that receives the current expansion from the scanner.
227 */
228 #define MAXMACEXPSTACK 128 /* Nesting more than 128 macro expansions is insane */
230 typedef struct macexpstackentry {
231 pp_entry_t *ppp; /* This macro we are scanning */
232 char **args; /* With these arguments */
233 char **ppargs; /* Resulting in these preprocessed arguments */
234 int *nnls; /* Number of newlines per argument */
235 int nargs; /* And this many arguments scanned */
236 int parentheses; /* Nesting level of () */
237 int curargsize; /* Current scanning argument's size */
238 int curargalloc; /* Current scanning argument's block allocated */
239 char *curarg; /* Current scanning argument's content */
240 } macexpstackentry_t;
242 #define MACROPARENTHESES() (top_macro()->parentheses)
244 /*
245 * Prototypes
246 */
247 static void newline(int);
248 static int make_number(int radix, YYSTYPE *val, const char *str, int len);
249 static void put_buffer(const char *s, int len);
250 /* Buffer management */
251 static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop);
252 static bufferstackentry_t *pop_buffer(void);
253 /* String functions */
254 static void new_string(void);
255 static void add_string(const char *str, int len);
256 static char *get_string(void);
257 static void put_string(void);
258 static int string_start(void);
259 /* Macro functions */
260 static void push_macro(pp_entry_t *ppp);
261 static macexpstackentry_t *top_macro(void);
262 static macexpstackentry_t *pop_macro(void);
263 static void free_macro(macexpstackentry_t *mep);
264 static void add_text_to_macro(const char *text, int len);
265 static void macro_add_arg(int last);
266 static void macro_add_expansion(void);
267 /* Expansion */
268 static void expand_special(pp_entry_t *ppp);
269 static void expand_define(pp_entry_t *ppp);
270 static void expand_macro(macexpstackentry_t *mep);
272 /*
273 * Local variables
274 */
275 static int ncontinuations;
277 static int strbuf_idx = 0;
278 static int strbuf_alloc = 0;
279 static char *strbuffer = NULL;
280 static int str_startline;
282 static macexpstackentry_t *macexpstack[MAXMACEXPSTACK];
283 static int macexpstackidx = 0;
285 static bufferstackentry_t bufferstack[MAXBUFFERSTACK];
286 static int bufferstackidx = 0;
288 /*
289 * Global variables
290 */
291 include_state_t pp_incl_state =
292 {
293 -1, /* state */
294 NULL, /* ppp */
295 0, /* ifdepth */
296 0 /* seen_junk */
297 };
299 includelogicentry_t *pp_includelogiclist = NULL;
301 %}
303 /*
304 **************************************************************************
305 * The scanner starts here
306 **************************************************************************
307 */
309 %%
310 /*
311 * Catch line-continuations.
312 * Note: Gcc keeps the line-continuations in, for example, strings
313 * intact. However, I prefer to remove them all so that the next
314 * scanner will not need to reduce the continuation state.
315 *
316 * <*>\\\n newline(0);
317 */
319 /*
320 * Detect the leading # of a preprocessor directive.
321 */
322 <INITIAL,pp_ignore>^{ws}*# pp_incl_state.seen_junk++; yy_push_state(pp_pp);
324 /*
325 * Scan for the preprocessor directives
326 */
327 <pp_pp>{ws}*include{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_inc); return tINCLUDE;} else {yy_pp_state(pp_eol);}
328 <pp_pp>{ws}*define{ws}* yy_pp_state(yy_current_state() != pp_ignore ? pp_def : pp_eol);
329 <pp_pp>{ws}*error{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tERROR;
330 <pp_pp>{ws}*warning{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tWARNING;
331 <pp_pp>{ws}*pragma{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPRAGMA;
332 <pp_pp>{ws}*ident{ws}* yy_pp_state(pp_eol); if(yy_top_state() != pp_ignore) return tPPIDENT;
333 <pp_pp>{ws}*undef{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_ifd); return tUNDEF;} else {yy_pp_state(pp_eol);}
334 <pp_pp>{ws}*ifdef{ws}* yy_pp_state(pp_ifd); return tIFDEF;
335 <pp_pp>{ws}*ifndef{ws}* pp_incl_state.seen_junk--; yy_pp_state(pp_ifd); return tIFNDEF;
336 <pp_pp>{ws}*if{ws}* yy_pp_state(pp_if); return tIF;
337 <pp_pp>{ws}*elif{ws}* yy_pp_state(pp_if); return tELIF;
338 <pp_pp>{ws}*else{ws}* yy_pp_state(pp_endif); return tELSE;
339 <pp_pp>{ws}*endif{ws}* yy_pp_state(pp_endif); return tENDIF;
340 <pp_pp>{ws}*line{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);}
341 <pp_pp>{ws}+ if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);}
342 <pp_pp>{ws}*[a-z]+ ppy_error("Invalid preprocessor token '%s'", ppy_text);
343 <pp_pp>\r?\n newline(1); yy_pop_state(); return tNL; /* This could be the null-token */
344 <pp_pp>\\\r?\n newline(0);
345 <pp_pp>\\\r? ppy_error("Preprocessor junk '%s'", ppy_text);
346 <pp_pp>. return *ppy_text;
348 /*
349 * Handle #include and #line
350 */
351 <pp_line>[0-9]+ return make_number(10, &ppy_lval, ppy_text, ppy_leng);
352 <pp_inc>\< new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_iqs);
353 <pp_inc,pp_line>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
354 <pp_inc,pp_line>{ws}+ ;
355 <pp_inc,pp_line>\n newline(1); yy_pop_state(); return tNL;
356 <pp_inc,pp_line>\\\r?\n newline(0);
357 <pp_inc,pp_line>(\\\r?)|(.) ppy_error(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line");
359 /*
360 * Ignore all input when a false clause is parsed
361 */
362 <pp_ignore>[^#/\\\n]+ ;
363 <pp_ignore>\n newline(1);
364 <pp_ignore>\\\r?\n newline(0);
365 <pp_ignore>(\\\r?)|(.) ;
367 /*
368 * Handle #if and #elif.
369 * These require conditionals to be evaluated, but we do not
370 * want to jam the scanner normally when we see these tokens.
371 * Note: tIDENT is handled below.
372 */
374 <pp_if>0[0-7]*{ul}? return make_number(8, &ppy_lval, ppy_text, ppy_leng);
375 <pp_if>0[0-7]*[8-9]+{ul}? ppy_error("Invalid octal digit");
376 <pp_if>[1-9][0-9]*{ul}? return make_number(10, &ppy_lval, ppy_text, ppy_leng);
377 <pp_if>0[xX][0-9a-fA-F]+{ul}? return make_number(16, &ppy_lval, ppy_text, ppy_leng);
378 <pp_if>0[xX] ppy_error("Invalid hex number");
379 <pp_if>defined yy_push_state(pp_defined); return tDEFINED;
380 <pp_if>"<<" return tLSHIFT;
381 <pp_if>">>" return tRSHIFT;
382 <pp_if>"&&" return tLOGAND;
383 <pp_if>"||" return tLOGOR;
384 <pp_if>"==" return tEQ;
385 <pp_if>"!=" return tNE;
386 <pp_if>"<=" return tLTE;
387 <pp_if>">=" return tGTE;
388 <pp_if>\n newline(1); yy_pop_state(); return tNL;
389 <pp_if>\\\r?\n newline(0);
390 <pp_if>\\\r? ppy_error("Junk in conditional expression");
391 <pp_if>{ws}+ ;
392 <pp_if>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
393 <pp_if>\" ppy_error("String constants not allowed in conditionals");
394 <pp_if>. return *ppy_text;
396 /*
397 * Handle #ifdef, #ifndef and #undef
398 * to get only an untranslated/unexpanded identifier
399 */
400 <pp_ifd>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
401 <pp_ifd>{ws}+ ;
402 <pp_ifd>\n newline(1); yy_pop_state(); return tNL;
403 <pp_ifd>\\\r?\n newline(0);
404 <pp_ifd>(\\\r?)|(.) ppy_error("Identifier expected");
406 /*
407 * Handle #else and #endif.
408 */
409 <pp_endif>{ws}+ ;
410 <pp_endif>\n newline(1); yy_pop_state(); return tNL;
411 <pp_endif>\\\r?\n newline(0);
412 <pp_endif>. ppy_error("Garbage after #else or #endif.");
414 /*
415 * Handle the special 'defined' keyword.
416 * This is necessary to get the identifier prior to any
417 * substitutions.
418 */
419 <pp_defined>{cident} yy_pop_state(); ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
420 <pp_defined>{ws}+ ;
421 <pp_defined>(\()|(\)) return *ppy_text;
422 <pp_defined>\\\r?\n newline(0);
423 <pp_defined>(\\.)|(\n)|(.) ppy_error("Identifier expected");
425 /*
426 * Handle #error, #warning, #pragma and #ident.
427 * Pass everything literally to the parser, which
428 * will act appropriately.
429 * Comments are stripped from the literal text.
430 */
431 <pp_eol>[^/\\\n]+ if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; }
432 <pp_eol>\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; }
433 <pp_eol>(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; }
434 <pp_eol>\n newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; }
435 <pp_eol>\\\r?\n newline(0);
437 /*
438 * Handle left side of #define
439 */
440 <pp_def>{cident}\( ppy_lval.cptr = pp_xstrdup(ppy_text); ppy_lval.cptr[ppy_leng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO;
441 <pp_def>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); yy_pp_state(pp_define); return tDEFINE;
442 <pp_def>{ws}+ ;
443 <pp_def>\\\r?\n newline(0);
444 <pp_def>(\\\r?)|(\n)|(.) perror("Identifier expected");
446 /*
447 * Scan the substitution of a define
448 */
449 <pp_define>[^'"/\\\n]+ ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
450 <pp_define>(\\\r?)|(\/[^/*]) ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
451 <pp_define>\\\r?\n{ws}+ newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL;
452 <pp_define>\\\r?\n newline(0);
453 <pp_define>\n newline(1); yy_pop_state(); return tNL;
454 <pp_define>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
455 <pp_define>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
457 /*
458 * Scan the definition macro arguments
459 */
460 <pp_macro>\){ws}* yy_pp_state(pp_mbody); return tMACROEND;
461 <pp_macro>{ws}+ ;
462 <pp_macro>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
463 <pp_macro>, return ',';
464 <pp_macro>"..." return tELIPSIS;
465 <pp_macro>(\\\r?)|(\n)|(.)|(\.\.?) ppy_error("Argument identifier expected");
466 <pp_macro>\\\r?\n newline(0);
468 /*
469 * Scan the substitution of a macro
470 */
471 <pp_mbody>[^a-zA-Z0-9'"#/\\\n]+ ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
472 <pp_mbody>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
473 <pp_mbody>\#\# return tCONCAT;
474 <pp_mbody>\# return tSTRINGIZE;
475 <pp_mbody>[0-9][^'"#/\\\n]* ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
476 <pp_mbody>(\\\r?)|(\/[^/*'"#\\\n]*) ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
477 <pp_mbody>\\\r?\n{ws}+ newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL;
478 <pp_mbody>\\\r?\n newline(0);
479 <pp_mbody>\n newline(1); yy_pop_state(); return tNL;
480 <pp_mbody>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
481 <pp_mbody>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
483 /*
484 * Macro expansion text scanning.
485 * This state is active just after the identifier is scanned
486 * that triggers an expansion. We *must* delete the leading
487 * whitespace before we can start scanning for arguments.
488 *
489 * If we do not see a '(' as next trailing token, then we have
490 * a false alarm. We just continue with a nose-bleed...
491 */
492 <pp_macign>{ws}*/\( yy_pp_state(pp_macscan);
493 <pp_macign>{ws}*\n {
494 if(yy_top_state() != pp_macscan)
495 newline(0);
496 }
497 <pp_macign>{ws}*\\\r?\n newline(0);
498 <pp_macign>{ws}+|{ws}*\\\r?|. {
499 macexpstackentry_t *mac = pop_macro();
500 yy_pop_state();
501 put_buffer(mac->ppp->ident, strlen(mac->ppp->ident));
502 put_buffer(ppy_text, ppy_leng);
503 free_macro(mac);
504 }
506 /*
507 * Macro expansion argument text scanning.
508 * This state is active when a macro's arguments are being read for expansion.
509 */
510 <pp_macscan>\( {
511 if(++MACROPARENTHESES() > 1)
512 add_text_to_macro(ppy_text, ppy_leng);
513 }
514 <pp_macscan>\) {
515 if(--MACROPARENTHESES() == 0)
516 {
517 yy_pop_state();
518 macro_add_arg(1);
519 }
520 else
521 add_text_to_macro(ppy_text, ppy_leng);
522 }
523 <pp_macscan>, {
524 if(MACROPARENTHESES() > 1)
525 add_text_to_macro(ppy_text, ppy_leng);
526 else
527 macro_add_arg(0);
528 }
529 <pp_macscan>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
530 <pp_macscan>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
531 <pp_macscan>"/*" yy_push_state(pp_comment); add_text_to_macro(" ", 1);
532 <pp_macscan>\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(ppy_text, ppy_leng);
533 <pp_macscan>([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(ppy_text, ppy_leng);
534 <pp_macscan>\\\r?\n newline(0);
536 /*
537 * Comment handling (almost all start-conditions)
538 */
539 <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);
540 <pp_comment>[^*\n]*|"*"+[^*/\n]* ;
541 <pp_comment>\n newline(0);
542 <pp_comment>"*"+"/" yy_pop_state();
544 /*
545 * Remove C++ style comment (almost all start-conditions)
546 */
547 <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]* {
548 if(ppy_text[ppy_leng-1] == '\\')
549 ppy_warning("C++ style comment ends with an escaped newline (escape ignored)");
550 }
552 /*
553 * Single, double and <> quoted constants
554 */
555 <INITIAL,pp_macexp>\" pp_incl_state.seen_junk++; new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
556 <INITIAL,pp_macexp>\' pp_incl_state.seen_junk++; new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
557 <pp_dqs>[^"\\\n]+ add_string(ppy_text, ppy_leng);
558 <pp_dqs>\" {
559 add_string(ppy_text, ppy_leng);
560 yy_pop_state();
561 switch(yy_current_state())
562 {
563 case pp_pp:
564 case pp_define:
565 case pp_mbody:
566 case pp_inc:
567 case RCINCL:
568 if (yy_current_state()==RCINCL) yy_pop_state();
569 ppy_lval.cptr = get_string();
570 return tDQSTRING;
571 case pp_line:
572 ppy_lval.cptr = get_string();
573 return tDQSTRING;
574 default:
575 put_string();
576 }
577 }
578 <pp_sqs>[^'\\\n]+ add_string(ppy_text, ppy_leng);
579 <pp_sqs>\' {
580 add_string(ppy_text, ppy_leng);
581 yy_pop_state();
582 switch(yy_current_state())
583 {
584 case pp_if:
585 case pp_define:
586 case pp_mbody:
587 ppy_lval.cptr = get_string();
588 return tSQSTRING;
589 default:
590 put_string();
591 }
592 }
593 <pp_iqs>[^\>\\\n]+ add_string(ppy_text, ppy_leng);
594 <pp_iqs>\> {
595 add_string(ppy_text, ppy_leng);
596 yy_pop_state();
597 ppy_lval.cptr = get_string();
598 return tIQSTRING;
599 }
600 <pp_dqs>\\\r?\n {
601 /*
602 * This is tricky; we need to remove the line-continuation
603 * from preprocessor strings, but OTOH retain them in all
604 * other strings. This is because the resource grammar is
605 * even more braindead than initially analysed and line-
606 * continuations in strings introduce, sigh, newlines in
607 * the output. There goes the concept of non-breaking, non-
608 * spacing whitespace.
609 */
610 switch(yy_top_state())
611 {
612 case pp_pp:
613 case pp_define:
614 case pp_mbody:
615 case pp_inc:
616 case pp_line:
617 newline(0);
618 break;
619 default:
620 add_string(ppy_text, ppy_leng);
621 newline(-1);
622 }
623 }
624 <pp_iqs,pp_dqs,pp_sqs>\\. add_string(ppy_text, ppy_leng);
625 <pp_iqs,pp_dqs,pp_sqs>\n {
626 newline(1);
627 add_string(ppy_text, ppy_leng);
628 ppy_warning("Newline in string constant encounterd (started line %d)", string_start());
629 }
631 /*
632 * Identifier scanning
633 */
634 <INITIAL,pp_if,pp_inc,pp_macexp>{cident} {
635 pp_entry_t *ppp;
636 pp_incl_state.seen_junk++;
637 if(!(ppp = pplookup(ppy_text)))
638 {
639 if(yy_current_state() == pp_inc)
640 ppy_error("Expected include filename");
642 if(yy_current_state() == pp_if)
643 {
644 ppy_lval.cptr = pp_xstrdup(ppy_text);
645 return tIDENT;
646 }
647 else {
648 if((yy_current_state()==INITIAL) && (strcasecmp(ppy_text,"RCINCLUDE")==0)){
649 yy_push_state(RCINCL);
650 return tRCINCLUDE;
651 }
652 else put_buffer(ppy_text, ppy_leng);
653 }
654 }
655 else if(!ppp->expanding)
656 {
657 switch(ppp->type)
658 {
659 case def_special:
660 expand_special(ppp);
661 break;
662 case def_define:
663 expand_define(ppp);
664 break;
665 case def_macro:
666 yy_push_state(pp_macign);
667 push_macro(ppp);
668 break;
669 default:
670 pp_internal_error(__FILE__, __LINE__, "Invalid define type %d\n", ppp->type);
671 }
672 }
673 else put_buffer(ppy_text, ppy_leng);
674 }
676 /*
677 * Everything else that needs to be passed and
678 * newline and continuation handling
679 */
680 <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(ppy_text, ppy_leng);
681 <INITIAL,pp_macexp>{ws}+ put_buffer(ppy_text, ppy_leng);
682 <INITIAL>\n newline(1);
683 <INITIAL>\\\r?\n newline(0);
684 <INITIAL>\\\r? pp_incl_state.seen_junk++; put_buffer(ppy_text, ppy_leng);
686 /*
687 * Special catcher for macro argmument expansion to prevent
688 * newlines to propagate to the output or admin.
689 */
690 <pp_macexp>(\n)|(.)|(\\\r?(\n|.)) put_buffer(ppy_text, ppy_leng);
692 <RCINCL>[A-Za-z0-9_\.\\/]+ {
693 ppy_lval.cptr=pp_xstrdup(ppy_text);
694 yy_pop_state();
695 return tRCINCLUDEPATH;
696 }
698 <RCINCL>{ws}+ ;
700 <RCINCL>\" {
701 new_string(); add_string(ppy_text,ppy_leng);yy_push_state(pp_dqs);
702 }
704 /*
705 * This is a 'catch-all' rule to discover errors in the scanner
706 * in an orderly manner.
707 */
708 <*>. pp_incl_state.seen_junk++; ppy_warning("Unmatched text '%c' (0x%02x); please report\n", isprint(*ppy_text & 0xff) ? *ppy_text : ' ', *ppy_text);
710 <<EOF>> {
711 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
712 bufferstackentry_t *bep = pop_buffer();
714 if((!bep && pp_get_if_depth()) || (bep && pp_get_if_depth() != bep->if_depth))
715 ppy_warning("Unmatched #if/#endif at end of file");
717 if(!bep)
718 {
719 if(YY_START != INITIAL)
720 ppy_error("Unexpected end of file during preprocessing");
721 yyterminate();
722 }
723 else if(bep->should_pop == 2)
724 {
725 macexpstackentry_t *mac;
726 mac = pop_macro();
727 expand_macro(mac);
728 }
729 ppy__delete_buffer(b);
730 }
732 %%
733 /*
734 **************************************************************************
735 * Support functions
736 **************************************************************************
737 */
739 #ifndef ppy_wrap
740 int ppy_wrap(void)
741 {
742 return 1;
743 }
744 #endif
747 /*
748 *-------------------------------------------------------------------------
749 * Output newlines or set them as continuations
750 *
751 * Input: -1 - Don't count this one, but update local position (see pp_dqs)
752 * 0 - Line-continuation seen and cache output
753 * 1 - Newline seen and flush output
754 *-------------------------------------------------------------------------
755 */
756 static void newline(int dowrite)
757 {
758 pp_status.line_number++;
759 pp_status.char_number = 1;
761 if(dowrite == -1)
762 return;
764 ncontinuations++;
765 if(dowrite)
766 {
767 for(;ncontinuations; ncontinuations--)
768 put_buffer("\n", 1);
769 }
770 }
773 /*
774 *-------------------------------------------------------------------------
775 * Make a number out of an any-base and suffixed string
776 *
777 * Possible number extensions:
778 * - "" int
779 * - "L" long int
780 * - "LL" long long int
781 * - "U" unsigned int
782 * - "UL" unsigned long int
783 * - "ULL" unsigned long long int
784 * - "LU" unsigned long int
785 * - "LLU" unsigned long long int
786 * - "LUL" invalid
787 *
788 * FIXME:
789 * The sizes of resulting 'int' and 'long' are compiler specific.
790 * I depend on sizeof(int) > 2 here (although a relatively safe
791 * assumption).
792 * Long longs are not yet implemented because this is very compiler
793 * specific and I don't want to think too much about the problems.
794 *
795 *-------------------------------------------------------------------------
796 */
797 static int make_number(int radix, YYSTYPE *val, const char *str, int len)
798 {
799 int is_l = 0;
800 int is_ll = 0;
801 int is_u = 0;
802 char ext[4];
803 long l;
805 ext[3] = '\0';
806 ext[2] = toupper(str[len-1]);
807 ext[1] = len > 1 ? toupper(str[len-2]) : ' ';
808 ext[0] = len > 2 ? toupper(str[len-3]) : ' ';
810 if(!strcmp(ext, "LUL"))
811 ppy_error("Invalid constant suffix");
812 else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL"))
813 {
814 is_ll++;
815 is_u++;
816 }
817 else if(!strcmp(ext+1, "LU") || !strcmp(ext+1, "UL"))
818 {
819 is_l++;
820 is_u++;
821 }
822 else if(!strcmp(ext+1, "LL"))
823 {
824 is_ll++;
825 }
826 else if(!strcmp(ext+2, "L"))
827 {
828 is_l++;
829 }
830 else if(!strcmp(ext+2, "U"))
831 {
832 is_u++;
833 }
835 if(is_ll)
836 {
837 /* Assume as in the declaration of wrc_ull_t and wrc_sll_t */
838 #ifdef HAVE_LONG_LONG
839 if (is_u)
840 {
841 errno = 0;
842 val->ull = strtoull(str, NULL, radix);
843 if (val->ull == ULLONG_MAX && errno == ERANGE)
844 ppy_error("integer constant %s is too large\n", str);
845 return tULONGLONG;
846 }
847 else
848 {
849 errno = 0;
850 val->sll = strtoll(str, NULL, radix);
851 if ((val->sll == LLONG_MIN || val->sll == LLONG_MAX) && errno == ERANGE)
852 ppy_error("integer constant %s is too large\n", str);
853 return tSLONGLONG;
854 }
855 #else
856 pp_internal_error(__FILE__, __LINE__, "long long constants not supported on this platform");
857 #endif
858 }
859 else if(is_u && is_l)
860 {
861 errno = 0;
862 val->ulong = strtoul(str, NULL, radix);
863 if (val->ulong == ULONG_MAX && errno == ERANGE)
864 ppy_error("integer constant %s is too large\n", str);
865 return tULONG;
866 }
867 else if(!is_u && is_l)
868 {
869 errno = 0;
870 val->slong = strtol(str, NULL, radix);
871 if ((val->slong == LONG_MIN || val->slong == LONG_MAX) && errno == ERANGE)
872 ppy_error("integer constant %s is too large\n", str);
873 return tSLONG;
874 }
875 else if(is_u && !is_l)
876 {
877 unsigned long ul;
878 errno = 0;
879 ul = strtoul(str, NULL, radix);
880 if ((ul == ULONG_MAX && errno == ERANGE) || (ul > UINT_MAX))
881 ppy_error("integer constant %s is too large\n", str);
882 val->uint = (unsigned int)ul;
883 return tUINT;
884 }
886 /* Else it must be an int... */
887 errno = 0;
888 l = strtol(str, NULL, radix);
889 if (((l == LONG_MIN || l == LONG_MAX) && errno == ERANGE) ||
890 (l > INT_MAX) || (l < INT_MIN))
891 ppy_error("integer constant %s is too large\n", str);
892 val->sint = (int)l;
893 return tSINT;
894 }
897 /*
898 *-------------------------------------------------------------------------
899 * Macro and define expansion support
900 *
901 * FIXME: Variable macro arguments.
902 *-------------------------------------------------------------------------
903 */
904 static void expand_special(pp_entry_t *ppp)
905 {
906 const char *dbgtext = "?";
907 static char *buf = NULL;
909 assert(ppp->type == def_special);
911 if(!strcmp(ppp->ident, "__LINE__"))
912 {
913 dbgtext = "def_special(__LINE__)";
914 buf = pp_xrealloc(buf, 32);
915 sprintf(buf, "%d", pp_status.line_number);
916 }
917 else if(!strcmp(ppp->ident, "__FILE__"))
918 {
919 dbgtext = "def_special(__FILE__)";
920 buf = pp_xrealloc(buf, strlen(pp_status.input) + 3);
921 sprintf(buf, "\"%s\"", pp_status.input);
922 }
923 else
924 pp_internal_error(__FILE__, __LINE__, "Special macro '%s' not found...\n", ppp->ident);
926 if(pp_flex_debug)
927 fprintf(stderr, "expand_special(%d): %s:%d: '%s' -> '%s'\n",
928 macexpstackidx,
929 pp_status.input,
930 pp_status.line_number,
931 ppp->ident,
932 buf ? buf : "");
934 if(buf && buf[0])
935 {
936 push_buffer(ppp, NULL, NULL, 0);
937 yy_scan_string(buf);
938 }
939 }
941 static void expand_define(pp_entry_t *ppp)
942 {
943 assert(ppp->type == def_define);
945 if(pp_flex_debug)
946 fprintf(stderr, "expand_define(%d): %s:%d: '%s' -> '%s'\n",
947 macexpstackidx,
948 pp_status.input,
949 pp_status.line_number,
950 ppp->ident,
951 ppp->subst.text);
952 if(ppp->subst.text && ppp->subst.text[0])
953 {
954 push_buffer(ppp, NULL, NULL, 0);
955 yy_scan_string(ppp->subst.text);
956 }
957 }
959 static int curdef_idx = 0;
960 static int curdef_alloc = 0;
961 static char *curdef_text = NULL;
963 static void add_text(const char *str, int len)
964 {
965 if(len == 0)
966 return;
967 if(curdef_idx >= curdef_alloc || curdef_alloc - curdef_idx < len)
968 {
969 curdef_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
970 curdef_text = pp_xrealloc(curdef_text, curdef_alloc * sizeof(curdef_text[0]));
971 if(curdef_alloc > 65536)
972 ppy_warning("Reallocating macro-expansion buffer larger than 64kB");
973 }
974 memcpy(&curdef_text[curdef_idx], str, len);
975 curdef_idx += len;
976 }
978 static mtext_t *add_expand_text(mtext_t *mtp, macexpstackentry_t *mep, int *nnl)
979 {
980 char *cptr;
981 char *exp;
982 int tag;
983 int n;
985 if(mtp == NULL)
986 return NULL;
988 switch(mtp->type)
989 {
990 case exp_text:
991 if(pp_flex_debug)
992 fprintf(stderr, "add_expand_text: exp_text: '%s'\n", mtp->subst.text);
993 add_text(mtp->subst.text, strlen(mtp->subst.text));
994 break;
996 case exp_stringize:
997 if(pp_flex_debug)
998 fprintf(stderr, "add_expand_text: exp_stringize(%d): '%s'\n",
999 mtp->subst.argidx,
1000 mep->args[mtp->subst.argidx]);
1001 cptr = mep->args[mtp->subst.argidx];
1002 add_text("\"", 1);
1003 while(*cptr)
1004 {
1005 if(*cptr == '"' || *cptr == '\\')
1006 add_text("\\", 1);
1007 add_text(cptr, 1);
1008 cptr++;
1009 }
1010 add_text("\"", 1);
1011 break;
1013 case exp_concat:
1014 if(pp_flex_debug)
1015 fprintf(stderr, "add_expand_text: exp_concat\n");
1016 /* Remove trailing whitespace from current expansion text */
1017 while(curdef_idx)
1018 {
1019 if(isspace(curdef_text[curdef_idx-1] & 0xff))
1020 curdef_idx--;
1021 else
1022 break;
1023 }
1024 /* tag current position and recursively expand the next part */
1025 tag = curdef_idx;
1026 mtp = add_expand_text(mtp->next, mep, nnl);
1028 /* Now get rid of the leading space of the expansion */
1029 cptr = &curdef_text[tag];
1030 n = curdef_idx - tag;
1031 while(n)
1032 {
1033 if(isspace(*cptr & 0xff))
1034 {
1035 cptr++;
1036 n--;
1037 }
1038 else
1039 break;
1040 }
1041 if(cptr != &curdef_text[tag])
1042 {
1043 memmove(&curdef_text[tag], cptr, n);
1044 curdef_idx -= (curdef_idx - tag) - n;
1045 }
1046 break;
1048 case exp_subst:
1049 if((mtp->next && mtp->next->type == exp_concat) || (mtp->prev && mtp->prev->type == exp_concat))
1050 exp = mep->args[mtp->subst.argidx];
1051 else
1052 exp = mep->ppargs[mtp->subst.argidx];
1053 if(exp)
1054 {
1055 add_text(exp, strlen(exp));
1056 *nnl -= mep->nnls[mtp->subst.argidx];
1057 cptr = strchr(exp, '\n');
1058 while(cptr)
1059 {
1060 *cptr = ' ';
1061 cptr = strchr(cptr+1, '\n');
1062 }
1063 mep->nnls[mtp->subst.argidx] = 0;
1064 }
1065 if(pp_flex_debug)
1066 fprintf(stderr, "add_expand_text: exp_subst(%d): '%s'\n", mtp->subst.argidx, exp);
1067 break;
1069 default:
1070 pp_internal_error(__FILE__, __LINE__, "Invalid expansion type (%d) in macro expansion\n", mtp->type);
1071 }
1072 return mtp;
1073 }
1075 static void expand_macro(macexpstackentry_t *mep)
1076 {
1077 mtext_t *mtp;
1078 int n, k;
1079 char *cptr;
1080 int nnl = 0;
1081 pp_entry_t *ppp = mep->ppp;
1082 int nargs = mep->nargs;
1084 assert(ppp->type == def_macro);
1085 assert(ppp->expanding == 0);
1087 if((ppp->nargs >= 0 && nargs != ppp->nargs) || (ppp->nargs < 0 && nargs < -ppp->nargs))
1088 ppy_error("Too %s macro arguments (%d)", nargs < abs(ppp->nargs) ? "few" : "many", nargs);
1090 for(n = 0; n < nargs; n++)
1091 nnl += mep->nnls[n];
1093 if(pp_flex_debug)
1094 fprintf(stderr, "expand_macro(%d): %s:%d: '%s'(%d,%d) -> ...\n",
1095 macexpstackidx,
1096 pp_status.input,
1097 pp_status.line_number,
1098 ppp->ident,
1099 mep->nargs,
1100 nnl);
1102 curdef_idx = 0;
1104 for(mtp = ppp->subst.mtext; mtp; mtp = mtp->next)
1105 {
1106 if(!(mtp = add_expand_text(mtp, mep, &nnl)))
1107 break;
1108 }
1110 for(n = 0; n < nnl; n++)
1111 add_text("\n", 1);
1113 /* To make sure there is room and termination (see below) */
1114 add_text(" \0", 2);
1116 /* Strip trailing whitespace from expansion */
1117 for(k = curdef_idx, cptr = &curdef_text[curdef_idx-1]; k > 0; k--, cptr--)
1118 {
1119 if(!isspace(*cptr & 0xff))
1120 break;
1121 }
1123 /*
1124 * We must add *one* whitespace to make sure that there
1125 * is a token-separation after the expansion.
1126 */
1127 *(++cptr) = ' ';
1128 *(++cptr) = '\0';
1129 k++;
1131 /* Strip leading whitespace from expansion */
1132 for(n = 0, cptr = curdef_text; n < k; n++, cptr++)
1133 {
1134 if(!isspace(*cptr & 0xff))
1135 break;
1136 }
1138 if(k - n > 0)
1139 {
1140 if(pp_flex_debug)
1141 fprintf(stderr, "expand_text: '%s'\n", curdef_text + n);
1142 push_buffer(ppp, NULL, NULL, 0);
1143 /*yy_scan_bytes(curdef_text + n, k - n);*/
1144 yy_scan_string(curdef_text + n);
1145 }
1146 }
1148 /*
1149 *-------------------------------------------------------------------------
1150 * String collection routines
1151 *-------------------------------------------------------------------------
1152 */
1153 static void new_string(void)
1154 {
1155 #ifdef DEBUG
1156 if(strbuf_idx)
1157 ppy_warning("new_string: strbuf_idx != 0");
1158 #endif
1159 strbuf_idx = 0;
1160 str_startline = pp_status.line_number;
1161 }
1163 static void add_string(const char *str, int len)
1164 {
1165 if(len == 0)
1166 return;
1167 if(strbuf_idx >= strbuf_alloc || strbuf_alloc - strbuf_idx < len)
1168 {
1169 strbuf_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
1170 strbuffer = pp_xrealloc(strbuffer, strbuf_alloc * sizeof(strbuffer[0]));
1171 if(strbuf_alloc > 65536)
1172 ppy_warning("Reallocating string buffer larger than 64kB");
1173 }
1174 memcpy(&strbuffer[strbuf_idx], str, len);
1175 strbuf_idx += len;
1176 }
1178 static char *get_string(void)
1179 {
1180 char *str = pp_xmalloc(strbuf_idx + 1);
1181 memcpy(str, strbuffer, strbuf_idx);
1182 str[strbuf_idx] = '\0';
1183 #ifdef DEBUG
1184 strbuf_idx = 0;
1185 #endif
1186 return str;
1187 }
1189 static void put_string(void)
1190 {
1191 put_buffer(strbuffer, strbuf_idx);
1192 #ifdef DEBUG
1193 strbuf_idx = 0;
1194 #endif
1195 }
1197 static int string_start(void)
1198 {
1199 return str_startline;
1200 }
1203 /*
1204 *-------------------------------------------------------------------------
1205 * Buffer management
1206 *-------------------------------------------------------------------------
1207 */
1208 static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop)
1209 {
1210 if(ppy_debug)
1211 printf("push_buffer(%d): %p %p %p %d\n", bufferstackidx, ppp, filename, incname, pop);
1212 if(bufferstackidx >= MAXBUFFERSTACK)
1213 pp_internal_error(__FILE__, __LINE__, "Buffer stack overflow");
1215 memset(&bufferstack[bufferstackidx], 0, sizeof(bufferstack[0]));
1216 bufferstack[bufferstackidx].bufferstate = YY_CURRENT_BUFFER;
1217 bufferstack[bufferstackidx].define = ppp;
1218 bufferstack[bufferstackidx].line_number = pp_status.line_number;
1219 bufferstack[bufferstackidx].char_number = pp_status.char_number;
1220 bufferstack[bufferstackidx].if_depth = pp_get_if_depth();
1221 bufferstack[bufferstackidx].should_pop = pop;
1222 bufferstack[bufferstackidx].filename = pp_status.input;
1223 bufferstack[bufferstackidx].ncontinuations = ncontinuations;
1224 bufferstack[bufferstackidx].incl = pp_incl_state;
1225 bufferstack[bufferstackidx].include_filename = incname;
1227 if(ppp)
1228 ppp->expanding = 1;
1229 else if(filename)
1230 {
1231 /* These will track the ppy_error to the correct file and line */
1232 pp_status.line_number = 1;
1233 pp_status.char_number = 1;
1234 pp_status.input = filename;
1235 ncontinuations = 0;
1236 }
1237 else if(!pop)
1238 pp_internal_error(__FILE__, __LINE__, "Pushing buffer without knowing where to go to");
1239 bufferstackidx++;
1240 }
1242 static bufferstackentry_t *pop_buffer(void)
1243 {
1244 if(bufferstackidx < 0)
1245 pp_internal_error(__FILE__, __LINE__, "Bufferstack underflow?");
1247 if(bufferstackidx == 0)
1248 return NULL;
1250 bufferstackidx--;
1252 if(bufferstack[bufferstackidx].define)
1253 bufferstack[bufferstackidx].define->expanding = 0;
1254 else
1255 {
1256 pp_status.line_number = bufferstack[bufferstackidx].line_number;
1257 pp_status.char_number = bufferstack[bufferstackidx].char_number;
1258 pp_status.input = bufferstack[bufferstackidx].filename;
1259 ncontinuations = bufferstack[bufferstackidx].ncontinuations;
1260 if(!bufferstack[bufferstackidx].should_pop)
1261 {
1262 fclose(ppy_in);
1263 fprintf(ppy_out, "# %d \"%s\" 2\n", pp_status.line_number, pp_status.input);
1265 /* We have EOF, check the include logic */
1266 if(pp_incl_state.state == 2 && !pp_incl_state.seen_junk && pp_incl_state.ppp)
1267 {
1268 pp_entry_t *ppp = pplookup(pp_incl_state.ppp);
1269 if(ppp)
1270 {
1271 includelogicentry_t *iep = pp_xmalloc(sizeof(includelogicentry_t));
1272 iep->ppp = ppp;
1273 ppp->iep = iep;
1274 iep->filename = bufferstack[bufferstackidx].include_filename;
1275 iep->prev = NULL;
1276 iep->next = pp_includelogiclist;
1277 if(iep->next)
1278 iep->next->prev = iep;
1279 pp_includelogiclist = iep;
1280 if(pp_status.debug)
1281 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);
1282 }
1283 else
1284 free(bufferstack[bufferstackidx].include_filename);
1285 }
1286 free(pp_incl_state.ppp);
1287 pp_incl_state = bufferstack[bufferstackidx].incl;
1289 }
1290 }
1292 if(ppy_debug)
1293 printf("pop_buffer(%d): %p %p (%d, %d, %d) %p %d\n",
1294 bufferstackidx,
1295 bufferstack[bufferstackidx].bufferstate,
1296 bufferstack[bufferstackidx].define,
1297 bufferstack[bufferstackidx].line_number,
1298 bufferstack[bufferstackidx].char_number,
1299 bufferstack[bufferstackidx].if_depth,
1300 bufferstack[bufferstackidx].filename,
1301 bufferstack[bufferstackidx].should_pop);
1303 ppy__switch_to_buffer(bufferstack[bufferstackidx].bufferstate);
1305 if(bufferstack[bufferstackidx].should_pop)
1306 {
1307 if(yy_current_state() == pp_macexp)
1308 macro_add_expansion();
1309 else
1310 pp_internal_error(__FILE__, __LINE__, "Pop buffer and state without macro expansion state");
1311 yy_pop_state();
1312 }
1314 return &bufferstack[bufferstackidx];
1315 }
1318 /*
1319 *-------------------------------------------------------------------------
1320 * Macro nestng support
1321 *-------------------------------------------------------------------------
1322 */
1323 static void push_macro(pp_entry_t *ppp)
1324 {
1325 if(macexpstackidx >= MAXMACEXPSTACK)
1326 ppy_error("Too many nested macros");
1328 macexpstack[macexpstackidx] = pp_xmalloc(sizeof(macexpstack[0][0]));
1329 memset( macexpstack[macexpstackidx], 0, sizeof(macexpstack[0][0]));
1330 macexpstack[macexpstackidx]->ppp = ppp;
1331 macexpstackidx++;
1332 }
1334 static macexpstackentry_t *top_macro(void)
1335 {
1336 return macexpstackidx > 0 ? macexpstack[macexpstackidx-1] : NULL;
1337 }
1339 static macexpstackentry_t *pop_macro(void)
1340 {
1341 if(macexpstackidx <= 0)
1342 pp_internal_error(__FILE__, __LINE__, "Macro expansion stack underflow\n");
1343 return macexpstack[--macexpstackidx];
1344 }
1346 static void free_macro(macexpstackentry_t *mep)
1347 {
1348 int i;
1350 for(i = 0; i < mep->nargs; i++)
1351 free(mep->args[i]);
1352 free(mep->args);
1353 free(mep->nnls);
1354 free(mep->curarg);
1355 free(mep);
1356 }
1358 static void add_text_to_macro(const char *text, int len)
1359 {
1360 macexpstackentry_t *mep = top_macro();
1362 assert(mep->ppp->expanding == 0);
1364 if(mep->curargalloc - mep->curargsize <= len+1) /* +1 for '\0' */
1365 {
1366 mep->curargalloc += (ALLOCBLOCKSIZE > len+1) ? ALLOCBLOCKSIZE : len+1;
1367 mep->curarg = pp_xrealloc(mep->curarg, mep->curargalloc * sizeof(mep->curarg[0]));
1368 }
1369 memcpy(mep->curarg + mep->curargsize, text, len);
1370 mep->curargsize += len;
1371 mep->curarg[mep->curargsize] = '\0';
1372 }
1374 static void macro_add_arg(int last)
1375 {
1376 int nnl = 0;
1377 char *cptr;
1378 macexpstackentry_t *mep = top_macro();
1380 assert(mep->ppp->expanding == 0);
1382 mep->args = pp_xrealloc(mep->args, (mep->nargs+1) * sizeof(mep->args[0]));
1383 mep->ppargs = pp_xrealloc(mep->ppargs, (mep->nargs+1) * sizeof(mep->ppargs[0]));
1384 mep->nnls = pp_xrealloc(mep->nnls, (mep->nargs+1) * sizeof(mep->nnls[0]));
1385 mep->args[mep->nargs] = pp_xstrdup(mep->curarg ? mep->curarg : "");
1386 cptr = mep->args[mep->nargs]-1;
1387 while((cptr = strchr(cptr+1, '\n')))
1388 {
1389 nnl++;
1390 }
1391 mep->nnls[mep->nargs] = nnl;
1392 mep->nargs++;
1393 free(mep->curarg);
1394 mep->curargalloc = mep->curargsize = 0;
1395 mep->curarg = NULL;
1397 if(pp_flex_debug)
1398 fprintf(stderr, "macro_add_arg: %s:%d: %d -> '%s'\n",
1399 pp_status.input,
1400 pp_status.line_number,
1401 mep->nargs-1,
1402 mep->args[mep->nargs-1]);
1404 /* Each macro argument must be expanded to cope with stingize */
1405 if(last || mep->args[mep->nargs-1][0])
1406 {
1407 yy_push_state(pp_macexp);
1408 push_buffer(NULL, NULL, NULL, last ? 2 : 1);
1409 yy_scan_string(mep->args[mep->nargs-1]);
1410 /*mep->bufferstackidx = bufferstackidx; But not nested! */
1411 }
1412 }
1414 static void macro_add_expansion(void)
1415 {
1416 macexpstackentry_t *mep = top_macro();
1418 assert(mep->ppp->expanding == 0);
1420 mep->ppargs[mep->nargs-1] = pp_xstrdup(mep->curarg ? mep->curarg : "");
1421 free(mep->curarg);
1422 mep->curargalloc = mep->curargsize = 0;
1423 mep->curarg = NULL;
1425 if(pp_flex_debug)
1426 fprintf(stderr, "macro_add_expansion: %s:%d: %d -> '%s'\n",
1427 pp_status.input,
1428 pp_status.line_number,
1429 mep->nargs-1,
1430 mep->ppargs[mep->nargs-1]);
1431 }
1434 /*
1435 *-------------------------------------------------------------------------
1436 * Output management
1437 *-------------------------------------------------------------------------
1438 */
1439 static void put_buffer(const char *s, int len)
1440 {
1441 if(top_macro())
1442 add_text_to_macro(s, len);
1443 else
1444 fwrite(s, 1, len, ppy_out);
1445 }
1448 /*
1449 *-------------------------------------------------------------------------
1450 * Include management
1451 *-------------------------------------------------------------------------
1452 */
1453 void pp_do_include(char *fname, int type)
1454 {
1455 char *newpath;
1456 int n;
1457 includelogicentry_t *iep;
1459 for(iep = pp_includelogiclist; iep; iep = iep->next)
1460 {
1461 if(!strcmp(iep->filename, fname))
1462 {
1463 /*
1464 * We are done. The file was included before.
1465 * If the define was deleted, then this entry would have
1466 * been deleted too.
1467 */
1468 return;
1469 }
1470 }
1472 n = strlen(fname);
1474 if(n <= 2)
1475 ppy_error("Empty include filename");
1477 /* Undo the effect of the quotation */
1478 fname[n-1] = '\0';
1480 if((ppy_in = pp_open_include(fname+1, type ? pp_status.input : NULL, &newpath)) == NULL)
1481 ppy_error("Unable to open include file %s", fname+1);
1483 fname[n-1] = *fname; /* Redo the quotes */
1484 push_buffer(NULL, newpath, fname, 0);
1485 pp_incl_state.seen_junk = 0;
1486 pp_incl_state.state = 0;
1487 pp_incl_state.ppp = NULL;
1489 if(pp_status.debug)
1490 fprintf(stderr, "pp_do_include: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d\n",
1491 pp_status.input, pp_status.line_number, pp_incl_state.state, pp_incl_state.ppp, pp_incl_state.ifdepth);
1492 ppy__switch_to_buffer(ppy__create_buffer(ppy_in, YY_BUF_SIZE));
1494 fprintf(ppy_out, "# 1 \"%s\" 1%s\n", newpath, type ? "" : " 3");
1495 }
1497 /*
1498 *-------------------------------------------------------------------------
1499 * Push/pop preprocessor ignore state when processing conditionals
1500 * which are false.
1501 *-------------------------------------------------------------------------
1502 */
1503 void pp_push_ignore_state(void)
1504 {
1505 yy_push_state(pp_ignore);
1506 }
1508 void pp_pop_ignore_state(void)
1509 {
1510 yy_pop_state();
1511 }