]>
Commit | Line | Data |
---|---|---|
885824d3 | 1 | /* Definitions for CPP library. |
2 | Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc. | |
3 | Written by Per Bothner, 1994-95. | |
4 | ||
5 | This program is free software; you can redistribute it and/or modify it | |
6 | under the terms of the GNU General Public License as published by the | |
7 | Free Software Foundation; either version 2, or (at your option) any | |
8 | later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 | ||
19 | In other words, you are welcome to use, share and improve this program. | |
20 | You are forbidden to forbid anyone else to use, share and improve | |
21 | what you give them. Help stamp out software-hoarding! */ | |
22 | ||
23 | #include <sys/types.h> | |
24 | #include <sys/stat.h> | |
25 | ||
26 | #ifdef __cplusplus | |
27 | extern "C" { | |
28 | #endif | |
29 | ||
885824d3 | 30 | typedef enum cpp_token (*parseUnderflow) (cppReader *); |
31 | typedef void (*parseCleanup) (cppBuffer *, cppReader *); | |
32 | ||
3e3ec469 | 33 | /* Structure returned by create_definition */ |
34 | typedef struct s_macrodef macroDef; | |
35 | ||
885824d3 | 36 | /* A parse_marker indicates a previous position, |
37 | which we can backtrack to. */ | |
38 | ||
39 | struct parse_marker { | |
40 | /*@dependent@*/ cppBuffer *buf; | |
41 | /*@dependent@*/ /*@null@*/ struct parse_marker *next; | |
42 | int position; | |
43 | }; | |
44 | ||
45 | /* The arglist structure is built by do_define to tell | |
46 | collect_definition where the argument names begin. That | |
47 | is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist | |
48 | would contain pointers to the strings x, y, and z. | |
49 | Collect_definition would then build a DEFINITION node, | |
50 | with reflist nodes pointing to the places x, y, and z had | |
51 | appeared. So the arglist is just convenience data passed | |
52 | between these two routines. It is not kept around after | |
53 | the current #define has been processed and entered into the | |
54 | hash table. */ | |
55 | ||
56 | struct arglist { | |
57 | /*@null@*/ struct arglist *next; | |
58 | /*@dependent@*/ char *name; | |
abd7f895 | 59 | size_t length; |
885824d3 | 60 | int argno; |
61 | int rest_args; | |
62 | }; | |
63 | ||
3e3ec469 | 64 | extern enum cpp_token cpplib_getToken (cppReader *); |
65 | extern enum cpp_token cpplib_getTokenForceExpand (cppReader *); | |
66 | extern enum cpp_token cpplib_getTokenAux (cppReader *, bool p_forceExpand); | |
885824d3 | 67 | extern int /*@alt void@*/ cppSkipHspace (cppReader *); |
68 | ||
69 | /* This frees resources used by PFILE. */ | |
70 | extern /*@unused@*/ void cppCleanup (cppReader *p_pfile); | |
71 | ||
72 | struct cppBuffer { | |
73 | /*@null@*/ /*@only@*/ char *buf; | |
74 | /*@null@*/ /*@exposed@*/ char *cur; | |
75 | /*@null@*/ /*@exposed@*/ char *rlimit; /* end of valid data */ | |
76 | /*@null@*/ /*@exposed@*/ char *alimit; /* end of allocated buffer */ | |
77 | /*@null@*/ /*@exposed@*/ char *prev; | |
78 | ||
79 | /*@dependent@*/ cstring fname; | |
80 | ||
81 | /* Filename specified with #line command. */ | |
82 | /*@exposed@*/ cstring nominal_fname; | |
83 | ||
84 | /* Record where in the search path this file was found. | |
85 | For #include_next. */ | |
86 | ||
87 | /*@dependent@*/ /*@null@*/ struct file_name_list *dir; | |
88 | ||
89 | long line_base; | |
90 | int lineno; /* Line number at CPP_LINE_BASE. */ | |
91 | int colno; /* Column number at CPP_LINE_BASE. */ | |
92 | parseUnderflow underflow; | |
93 | parseCleanup cleanup; | |
94 | ||
cd7d9b17 | 95 | /*@dependent@*/ hashNode hnode; |
885824d3 | 96 | /*@dependent@*/ /*@null@*/ struct parse_marker *marks; |
97 | /* Value of if_stack at start of this file. | |
98 | Used to prohibit unmatched #endif (etc) in an include file. */ | |
99 | /*@null@*/ /*@exposed@*/ struct if_stack *if_stack; | |
100 | ||
101 | /* True if this is a header file included using <FILENAME>. */ | |
102 | char system_header_p; | |
103 | char seen_eof; | |
104 | ||
105 | /* True if buffer contains escape sequences. | |
106 | Currently there are three kinds: | |
107 | "@-" means following identifier should not be macro-expanded. | |
108 | "@ " means a token-separator. This turns into " " in final output | |
109 | if not stringizing and needed to separate tokens; otherwise nothing. | |
110 | "@@" means a normal '@'. | |
111 | (An '@' inside a string stands for itself and is never an escape.) */ | |
112 | bool has_escapes; | |
113 | }; | |
114 | ||
115 | struct cpp_pending; /* Forward declaration - for C++. */ | |
116 | struct file_name_map_list; | |
117 | ||
118 | /* Maximum nesting of cppBuffers. We use a static limit, partly for | |
119 | efficiency, and partly to limit runaway recursion. */ | |
120 | ||
121 | /*@constant int CPP_STACK_MAX; @*/ | |
122 | # define CPP_STACK_MAX 200 | |
123 | ||
124 | /* A cppReader encapsulates the "state" of a pre-processor run. | |
125 | Applying cppGetToken repeatedly yields a stream of pre-processor | |
126 | tokens. Usually, there is only one cppReader object active. */ | |
127 | ||
128 | struct cppReader { | |
129 | parseUnderflow get_token; | |
130 | /*@dependent@*/ /*@null@*/ cppBuffer *buffer; | |
131 | cppBuffer buffer_stack[CPP_STACK_MAX]; | |
132 | ||
133 | int errors; /* Error counter for exit code */ | |
134 | cppOptions *opts; | |
135 | /* void *data; */ | |
136 | ||
137 | /* A buffer used for both for cppGetToken's output, and also internally. */ | |
138 | /*@relnull@*/ char *token_buffer; | |
139 | ||
140 | /* Alocated size of token_buffer. cppReader_reserve allocates space. */ | |
141 | size_t token_buffer_size; | |
142 | /* End of the written part of token_buffer. */ | |
143 | /*@exposed@*/ char *limit; | |
144 | ||
145 | /* Line where a newline was first seen in a string constant. */ | |
146 | int multiline_string_line; | |
147 | ||
148 | /* Current depth in #include directives that use <...>. */ | |
149 | int system_include_depth; | |
150 | ||
151 | /* List of other included files. | |
152 | If ->control_macro if nonzero, the file had a #ifndef | |
153 | around the entire contents, and ->control_macro gives the macro name. */ | |
154 | /*@owned@*/ /*@null@*/ struct file_name_list *all_include_files; | |
155 | ||
156 | /* Current maximum length of directory names in the search path | |
157 | for include files. (Altered as we get more of them.) */ | |
e5081f8c | 158 | size_t max_include_len; |
885824d3 | 159 | |
160 | /*@null@*/ struct if_stack *if_stack; | |
161 | ||
162 | /* Nonzero means we are inside an IF during a -pcp run. In this mode | |
163 | macro expansion is done, and preconditions are output for all macro | |
164 | uses requiring them. */ | |
165 | char pcp_inside_if; | |
166 | ||
167 | /* Nonzero means we have printed (while error reporting) a list of | |
168 | containing files that matches the current status. */ | |
169 | char input_stack_listing_current; | |
170 | ||
171 | /* If non-zero, macros are not expanded. */ | |
172 | bool no_macro_expand; | |
173 | ||
174 | /* Print column number in error messages. */ | |
175 | bool show_column; | |
176 | ||
177 | /* If true, character between '<' and '>' are a single (string) token. */ | |
178 | char parsing_include_directive; | |
179 | ||
180 | /* True if escape sequences (as described for has_escapes in | |
181 | parse_buffer) should be emitted. */ | |
182 | char output_escapes; | |
183 | ||
184 | /* 0: Have seen non-white-space on this line. | |
185 | 1: Only seen white space so far on this line. | |
186 | 2: Only seen white space so far in this file. */ | |
187 | char only_seen_white; | |
188 | ||
189 | int lineno; | |
190 | ||
191 | /*@null@*/ /*@observer@*/ struct tm *timebuf; | |
885824d3 | 192 | }; |
193 | ||
194 | /*@constant int cppReader_fatalErrorLimit; @*/ | |
195 | #define cppReader_fatalErrorLimit 1000 | |
196 | ||
197 | /* True if we have seen a "fatal" error. */ | |
3e3ec469 | 198 | extern bool cpplib_fatalErrors (cppReader *) /*@*/ ; |
199 | #define cpplib_fatalErrors(READER) ((READER)->errors >= cppReader_fatalErrorLimit) | |
885824d3 | 200 | |
3e3ec469 | 201 | extern int cpplib_bufPeek (cppBuffer *) /*@*/ ; |
885824d3 | 202 | |
203 | /* Macros for manipulating the token_buffer. */ | |
204 | ||
205 | /*@notfunction@*/ | |
206 | #define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer) | |
207 | ||
208 | /* Number of characters currently in PFILE's output buffer. */ | |
209 | ||
3e3ec469 | 210 | extern size_t cpplib_getWritten (/*@sef@*/ cppReader *) /*@*/ ; |
211 | # define cpplib_getWritten(PFILE) \ | |
885824d3 | 212 | (size_fromInt ((PFILE)->limit - (PFILE)->token_buffer)) |
213 | ||
3e3ec469 | 214 | extern /*@exposed@*/ char *cpplib_getPWritten (cppReader *) /*@*/ ; |
215 | # define cpplib_getPWritten(PFILE) ((PFILE)->limit) | |
885824d3 | 216 | |
217 | /* Make sure PFILE->token_buffer has space for at least N more characters. */ | |
218 | ||
3e3ec469 | 219 | extern void cpplib_reserve (/*@sef@*/ cppReader *, /*@sef@*/ size_t); |
220 | #define cpplib_reserve(PFILE, N) \ | |
53306cab | 221 | (((cpplib_getWritten (PFILE) + (N) > (PFILE)->token_buffer_size)) ? cppReader_growBuffer (PFILE, (N)) : (void) 0) |
885824d3 | 222 | |
223 | /* Append string STR (of length N) to PFILE's output buffer. | |
224 | Assume there is enough space. */ | |
225 | ||
226 | extern void cppReader_putStrN (/*@sef@*/ cppReader *p_file, | |
227 | /*@unique@*/ char *p_str, /*@sef@*/ size_t p_n) | |
228 | /*@modifies *p_file; @*/; | |
229 | ||
230 | #define cppReader_putStrN(PFILE, STR, N) \ | |
231 | (memcpy ((PFILE)->limit, STR, (N)), (PFILE)->limit += (N)) | |
232 | ||
233 | extern void cppReader_setWritten (/*@sef@*/ /*@special@*/ cppReader *p_file, size_t) | |
234 | /*@uses p_file, *p_file, p_file->token_buffer;@*/ | |
235 | /*@sets p_file->limit;@*/ | |
236 | /*@modifies *p_file@*/ ; | |
237 | ||
238 | # define cppReader_setWritten(PFILE,N) \ | |
239 | ((PFILE)->limit = (PFILE)->token_buffer + (N)) | |
240 | ||
241 | extern /*@dependent@*/ /*@exposed@*/ cppOptions *CPPOPTIONS (/*@special@*/ cppReader *p_pfile) | |
242 | /*@uses p_pfile->opts@*/ ; | |
243 | #define CPPOPTIONS(PFILE) ((PFILE)->opts) | |
244 | ||
245 | /*@notfunction@*/ | |
246 | #define CPPBUFFER(PFILE) ((PFILE)->buffer) | |
247 | ||
248 | /* Checks for null */ | |
249 | extern /*@exposed@*/ cppBuffer * | |
250 | cppReader_getBufferSafe (/*@special@*/ cppReader *p_pfile) | |
251 | /*@uses p_pfile->buffer@*/ | |
252 | /*@modifies nothing@*/ ; | |
253 | ||
254 | extern /*@exposed@*/ cppBuffer *cppBuffer_prevBuffer (cppBuffer *) /*@*/ ; | |
255 | ||
256 | /* The bottom of the buffer stack. */ | |
257 | extern /*@exposed@*/ cppBuffer *cppReader_nullBuffer (/*@special@*/ cppReader *p_pfile) /*@uses p_pfile->buffer_stack@*/ /*@*/ ; | |
258 | # define cppReader_nullBuffer(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX]) | |
259 | ||
260 | /* Pointed to by cppReader::data. */ | |
261 | struct cppOptions { | |
262 | /*@dependent@*/ cstring in_fname; | |
263 | ||
264 | /* Name of output file, for error messages. */ | |
265 | /*@dependent@*/ cstring out_fname; | |
266 | ||
6fcd0b1e | 267 | /*@only@*/ struct file_name_map_list *map_list; |
885824d3 | 268 | |
269 | /* Non-0 means -v, so print the full set of include dirs. */ | |
270 | bool verbose; | |
271 | ||
272 | /* Nonzero means use extra default include directories for C++. */ | |
273 | ||
274 | bool cplusplus; | |
275 | ||
276 | /* Nonzero means handle cplusplus style comments */ | |
277 | ||
278 | bool cplusplus_comments; | |
279 | ||
280 | /* Nonzero means this is an assembly file, and allow | |
281 | unknown directives, which could be comments. */ | |
282 | ||
283 | int lang_asm; | |
284 | ||
285 | /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */ | |
286 | ||
287 | bool for_lint; | |
288 | ||
289 | /* Nonzero means handle CHILL comment syntax | |
290 | and output CHILL string delimiter for __DATE___ etc. */ | |
291 | ||
292 | bool chill; | |
293 | ||
294 | /* Nonzero means copy comments into the output file. */ | |
295 | ||
296 | bool put_out_comments; | |
297 | ||
298 | /* Nonzero means don't process the ANSI trigraph sequences. */ | |
299 | ||
300 | bool no_trigraphs; | |
301 | ||
302 | /* Nonzero means print names of header files (-H). */ | |
303 | ||
304 | bool print_include_names; | |
305 | ||
306 | /* Nonzero means try to make failure to fit ANSI C an error. */ | |
307 | ||
308 | bool pedantic_errors; | |
309 | ||
310 | /* Nonzero means don't print warning messages. -w. */ | |
b072092f | 311 | /* bool inhibit_warnings; -- removed evans 2001-07-19 */ |
885824d3 | 312 | |
313 | /* Nonzero means warn if slash-star appears in a comment. */ | |
885824d3 | 314 | bool warn_comments; |
315 | ||
316 | /* Nonzero means warn if a macro argument is (or would be) | |
317 | stringified with -traditional. */ | |
318 | ||
319 | bool warn_stringify; | |
320 | bool warnings_are_errors; | |
321 | bool no_output; | |
322 | ||
323 | /* Nonzero means don't output line number information. */ | |
324 | ||
325 | bool no_line_commands; | |
326 | ||
327 | /* Nonzero means output the text in failing conditionals, | |
328 | inside #failed ... #endfailed. */ | |
329 | ||
330 | char output_conditionals; | |
331 | ||
1d239d69 | 332 | bool ignore_srcdir; |
885824d3 | 333 | |
334 | /* Zero means dollar signs are punctuation. | |
335 | This used to be needed for conformance to the C Standard, | |
336 | before the C Standard was corrected. */ | |
337 | bool dollars_in_ident; | |
338 | ||
339 | /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */ | |
340 | bool traditional; | |
341 | ||
342 | /* Nonzero for the 1989 C Standard, including corrigenda and amendments. */ | |
343 | bool c89; | |
344 | ||
345 | /* Nonzero means give all the error messages the ANSI standard requires. */ | |
346 | bool pedantic; | |
347 | ||
348 | bool done_initializing; | |
349 | ||
350 | /* First dir to search */ | |
351 | /*@owned@*/ struct file_name_list *include; | |
6fcd0b1e | 352 | |
885824d3 | 353 | /* First dir to search for <file> */ |
354 | /* This is the first element to use for #include <...>. | |
355 | If it is 0, use the entire chain for such includes. */ | |
356 | /*@dependent@*/ struct file_name_list *first_bracket_include; | |
357 | /* This is the first element in the chain that corresponds to | |
358 | a directory of system header files. */ | |
359 | /*@dependent@*/ struct file_name_list *first_system_include; | |
360 | /*@exposed@*/ struct file_name_list *last_include; /* Last in chain */ | |
361 | ||
362 | /* Chain of include directories to put at the end of the other chain. */ | |
363 | struct file_name_list *after_include; | |
364 | /*@exposed@*/ struct file_name_list *last_after_include; /* Last in chain */ | |
365 | ||
366 | /* Chain to put at the start of the system include files. */ | |
367 | struct file_name_list *before_system; | |
368 | /*@exposed@*/ struct file_name_list *last_before_system; /* Last in chain */ | |
369 | ||
370 | /* Directory prefix that should replace `/usr' in the standard | |
371 | include file directories. */ | |
372 | char *include_prefix; | |
373 | ||
374 | char inhibit_predefs; | |
375 | char no_standard_includes; | |
376 | char no_standard_cplusplus_includes; | |
377 | ||
378 | /* | |
379 | ** DUMP_NAMES means pass #define and the macro name through to output. | |
380 | ** DUMP_DEFINITIONS means pass the whole definition (plus #define) through | |
381 | */ | |
382 | ||
383 | /*@-enummemuse@*/ | |
384 | enum { DUMP_NONE = 0, DUMP_NAMES, DUMP_DEFINITIONS } | |
385 | dump_macros; | |
386 | /*@=enummemuse@*/ | |
387 | ||
388 | /* Nonzero means pass all #define and #undef directives which we actually | |
389 | process through to the output stream. This feature is used primarily | |
390 | to allow cc1 to record the #defines and #undefs for the sake of | |
391 | debuggers which understand about preprocessor macros, but it may | |
392 | also be useful with -E to figure out how symbols are defined, and | |
393 | where they are defined. */ | |
394 | int debug_output; | |
395 | }; | |
396 | ||
397 | extern bool cppReader_isTraditional (/*@special@*/ cppReader *p_pfile) | |
398 | /*@uses p_pfile->opts@*/ | |
399 | /*@modifies nothing@*/ ; | |
400 | ||
c09ebffe | 401 | #define cppReader_isTraditional(PFILE) (CPPOPTIONS(PFILE)->traditional) |
885824d3 | 402 | |
403 | extern bool cppReader_isPedantic (cppReader *) /*@*/; | |
404 | #define cppReader_isPedantic(PFILE) (CPPOPTIONS (PFILE)->pedantic) | |
405 | ||
406 | /* The structure of a node in the hash table. The hash table | |
407 | has entries for all tokens defined by #define commands (type T_MACRO), | |
408 | plus some special tokens like __LINE__ (these each have their own | |
409 | type, and the appropriate code is run when that type of node is seen. | |
410 | It does not contain control words like "#define", which are recognized | |
411 | by a separate piece of code. */ | |
412 | ||
413 | /* different flavors of hash nodes --- also used in keyword table */ | |
414 | enum node_type { | |
415 | T_NONE = 0, | |
4caf866b | 416 | T_DEFINE = 1, /* the #define keyword */ |
417 | T_INCLUDE, /* the #include keyword */ | |
418 | T_INCLUDE_NEXT, /* the #include_next keyword */ | |
419 | T_IFDEF, /* the #ifdef keyword */ | |
420 | T_IFNDEF, /* the #ifndef keyword */ | |
421 | T_IF, /* the #if keyword */ | |
422 | T_ELSE, /* #else */ | |
423 | T_PRAGMA, /* #pragma */ | |
424 | T_ELIF, /* #elif */ | |
425 | T_UNDEF, /* #undef */ | |
426 | T_LINE, /* #line */ | |
427 | T_ERROR, /* #error */ | |
428 | T_WARNING, /* #warning */ | |
429 | T_ENDIF, /* #endif */ | |
430 | T_IDENT, /* #ident, used on system V. */ | |
431 | T_SPECLINE, /* special symbol __LINE__ */ | |
432 | T_DATE, /* __DATE__ */ | |
433 | T_FILE, /* __FILE__ */ | |
434 | T_BASE_FILE, /* __BASE_FILE__ */ | |
435 | T_INCLUDE_LEVEL, /* __INCLUDE_LEVEL__ */ | |
436 | T_FUNC, /* __func__ */ | |
437 | T_VERSION, /* __VERSION__ */ | |
438 | T_SIZE_TYPE, /* __SIZE_TYPE__ */ | |
439 | T_PTRDIFF_TYPE, /* __PTRDIFF_TYPE__ */ | |
440 | T_WCHAR_TYPE, /* __WCHAR_TYPE__ */ | |
441 | T_USER_LABEL_PREFIX_TYPE, /* __USER_LABEL_PREFIX__ */ | |
442 | T_REGISTER_PREFIX_TYPE, /* __REGISTER_PREFIX__ */ | |
443 | T_TIME, /* __TIME__ */ | |
444 | T_CONST, /* Constant value, used by __STDC__ */ | |
445 | T_MACRO, /* macro defined by #define */ | |
885824d3 | 446 | T_DISABLED, /* macro temporarily turned off for rescan */ |
4caf866b | 447 | T_SPEC_DEFINED, /* special defined macro for use in #if statements */ |
885824d3 | 448 | T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */ |
449 | T_UNUSED /* Used for something not defined. */ | |
450 | } ; | |
451 | ||
3e3ec469 | 452 | struct s_macrodef |
885824d3 | 453 | { |
454 | /*@null@*/ struct definition *defn; | |
2209bcb7 | 455 | /*@exposed@*/ /*@relnull@*/ char *symnam; /* null if defn is null */ |
abd7f895 | 456 | size_t symlen; |
885824d3 | 457 | }; |
458 | ||
459 | /* Structure allocated for every #define. For a simple replacement | |
460 | such as | |
461 | #define foo bar , | |
462 | nargs = -1, the `pattern' list is null, and the expansion is just | |
463 | the replacement text. Nargs = 0 means a functionlike macro with no args, | |
464 | e.g., | |
465 | #define getchar() getc (stdin) . | |
466 | When there are args, the expansion is the replacement text with the | |
467 | args squashed out, and the reflist is a list describing how to | |
468 | build the output from the input: e.g., "3 chars, then the 1st arg, | |
469 | then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg". | |
470 | The chars here come from the expansion. Whatever is left of the | |
471 | expansion after the last arg-occurrence is copied after that arg. | |
472 | Note that the reflist can be arbitrarily long--- | |
473 | its length depends on the number of times the arguments appear in | |
474 | the replacement text, not how many args there are. Example: | |
475 | #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and | |
476 | pattern list | |
477 | { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL } | |
478 | where (x, y) means (nchars, argno). */ | |
479 | ||
480 | typedef struct definition DEFINITION; | |
481 | ||
482 | struct definition { | |
483 | int nargs; | |
484 | size_t length; /* length of expansion string */ | |
485 | bool predefined; /* True if the macro was builtin or */ | |
486 | /* came from the command line */ | |
487 | /*@dependent@*/ char *expansion; | |
488 | long line; /* Line number of definition */ | |
489 | /*@exposed@*/ cstring file; /* File of definition */ | |
490 | ||
491 | bool noExpand; /* True if macro should not be expanded in code. */ | |
492 | bool rest_args; /* Nonzero if last arg. absorbs the rest */ | |
493 | ||
494 | /*@null@*/ struct reflist { | |
495 | /*@null@*/ /*@dependent@*/ struct reflist *next; | |
496 | bool stringify; /* nonzero if this arg was preceded by a | |
497 | # operator. */ | |
498 | bool raw_before; /* Nonzero if a ## operator before arg. */ | |
499 | bool raw_after; /* Nonzero if a ## operator after arg. */ | |
500 | bool rest_args; /* Nonzero if this arg. absorbs the rest */ | |
501 | int nchars; /* Number of literal chars to copy before | |
502 | this arg occurrence. */ | |
503 | int argno; /* Number of arg to substitute (origin-0) */ | |
504 | } *pattern; | |
505 | ||
506 | union { | |
507 | /* Names of macro args, concatenated in reverse order | |
508 | with comma-space between them. | |
509 | The only use of this is that we warn on redefinition | |
510 | if this differs between the old and new definitions. */ | |
511 | /*@null@*/ char *argnames; | |
512 | } args; | |
513 | }; | |
514 | ||
515 | /* Stack of conditionals currently in progress | |
516 | (including both successful and failing conditionals). */ | |
517 | ||
518 | struct if_stack { | |
519 | /*@null@*/ struct if_stack *next; /* for chaining to the next stack frame */ | |
520 | /*@observer@*/ cstring fname; /* copied from input when frame is made */ | |
521 | int lineno; /* similarly */ | |
522 | int if_succeeded; /* true if a leg of this if-group | |
523 | has been passed through rescan */ | |
524 | ||
525 | /* For #ifndef at start of file, this is the macro name tested. */ | |
526 | /*@null@*/ /*@dependent@*/ char *control_macro; | |
527 | ||
528 | ||
529 | enum node_type type; /* type of last directive seen in this group */ | |
530 | }; | |
531 | typedef struct if_stack cppIfStackFrame; | |
532 | ||
80489f0a | 533 | extern void cppBuffer_getLineAndColumn (/*@null@*/ cppBuffer *, /*@out@*/ int *, |
534 | /*@out@*/ /*@null@*/ int *); | |
885824d3 | 535 | extern /*@exposed@*/ /*@null@*/ cppBuffer *cppReader_fileBuffer (cppReader *); |
536 | ||
537 | extern void cppReader_growBuffer (cppReader *, size_t); | |
538 | extern int cppReader_parseEscape (cppReader *, char **); | |
539 | ||
540 | extern /*@exposed@*/ cppBuffer *cppReader_popBuffer (cppReader *p_pfile) | |
541 | /*@modifies p_pfile@*/ ; | |
542 | ||
543 | #ifdef __cplusplus | |
544 | } | |
545 | #endif | |
546 | ||
547 | extern void cppReader_skipRestOfLine (cppReader *p_pfile); | |
548 | ||
549 | # include <stdlib.h> | |
550 | ||
885824d3 | 551 | /*@constant observer char *GCC_INCLUDE_DIR;@*/ |
8fe44445 | 552 | /* This is defined by config.h now. */ |
885824d3 | 553 | |
885824d3 | 554 | /*@constant observer char *GCC_INCLUDE_DIR2@*/ |
8fe44445 | 555 | /* This is defined by config.h now. */ |
885824d3 | 556 | |
557 | struct file_name_list | |
558 | { | |
559 | /*@owned@*/ /*@null@*/ struct file_name_list *next; | |
560 | /*@dependent@*/ cstring fname; | |
561 | ||
562 | /* If the following is nonzero, it is a macro name. | |
563 | Don't include the file again if that macro is defined. */ | |
564 | ||
565 | /*@dependent@*/ /*@null@*/ char *control_macro; | |
566 | /* If the following is nonzero, it is a C-language system include | |
567 | directory. */ | |
568 | ||
569 | bool c_system_include_path; | |
570 | ||
571 | /* Mapping of file names for this directory. */ | |
572 | /*@exposed@*/ /*@relnull@*/ /*@reldef@*/ struct file_name_map *name_map; | |
573 | ||
574 | /* Non-zero if name_map is valid. */ | |
575 | bool got_name_map; | |
576 | }; | |
577 | ||
578 | extern void cppReader_addIncludeChain (/*@special@*/ cppReader *p_pfile, | |
6fcd0b1e | 579 | /*@only@*/ struct file_name_list *p_dir) |
885824d3 | 580 | /*@uses p_pfile->opts, p_pfile->max_include_len@*/ |
581 | /*@modifies p_pfile, p_dir@*/ ; | |
582 | ||
583 | extern void cppReader_define (cppReader *p_pfile, char *p_str); | |
584 | extern void cppReader_finish (cppReader *p_pfile); | |
3e3ec469 | 585 | extern void cpplib_init (/*@out@*/ cppReader *p_pfile) ; |
885824d3 | 586 | extern void cppOptions_init (/*@out@*/ cppOptions *p_opts); |
3e3ec469 | 587 | extern void cpplib_initializeReader (cppReader *p_pfile) /*@modifies p_pfile@*/ ; |
885824d3 | 588 | |
589 | extern int cppReader_startProcess (cppReader *p_pfile, cstring p_fname); | |
590 | ||
591 | extern bool isIdentifierChar (char) /*@*/ ; | |
592 | ||
593 | /* Find the largest host integer type and set its size and type. */ | |
594 | ||
595 | #ifndef HOST_BITS_PER_WIDE_INT | |
596 | ||
597 | #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT | |
598 | /*@notfunction@*/ | |
599 | #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG | |
600 | /*@notfunction@*/ | |
601 | #define HOST_WIDE_INT long | |
602 | #else | |
603 | /*@notfunction@*/ | |
604 | #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT | |
605 | /*@notfunction@*/ | |
606 | #define HOST_WIDE_INT long | |
607 | /* was int */ | |
608 | #endif | |
609 | ||
610 | #endif | |
611 | ||
612 | #ifndef S_ISREG | |
613 | /*@-macrounrecog@*/ | |
614 | #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) | |
615 | /*@=macrounrecog@*/ | |
616 | #endif | |
617 | ||
618 | #ifndef S_ISDIR | |
619 | /*@-macrounrecog@*/ | |
620 | #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) | |
621 | /*@=macrounrecog@*/ | |
622 | #endif | |
623 | ||
624 | #ifndef INCLUDE_LEN_FUDGE | |
625 | /*@constant int INCLUDE_LEN_FUDGE@*/ | |
626 | #define INCLUDE_LEN_FUDGE 0 | |
627 | #endif | |
628 | ||
abd7f895 | 629 | extern size_t cppReader_checkMacroName (cppReader *p_pfile, char *p_symname, |
630 | cstring p_usage); | |
885824d3 | 631 | |
86d93ed3 | 632 | extern struct operation cppReader_parseNumber (cppReader * p_pfile, char * p_start, int p_olen) /*@requires maxRead(p_start) >= (p_olen - 1) @*/; |
885824d3 | 633 |