]>
Commit | Line | Data |
---|---|---|
7f2935c7 PB |
1 | /* Definitions for CPP library. |
2 | Copyright (C) 1995 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 | |
940d9d63 | 17 | Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
7f2935c7 PB |
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 | ||
7f2935c7 PB |
30 | typedef unsigned char U_CHAR; |
31 | ||
7f2935c7 PB |
32 | typedef struct cpp_reader cpp_reader; |
33 | typedef struct cpp_buffer cpp_buffer; | |
34 | typedef struct cpp_options cpp_options; | |
35 | typedef struct hashnode cpp_hashnode; | |
36 | ||
37 | enum cpp_token { | |
38 | CPP_EOF = -1, | |
39 | CPP_OTHER = 0, | |
40 | CPP_COMMENT = 1, | |
41 | CPP_HSPACE, | |
42 | CPP_VSPACE, /* newlines and #line directives */ | |
43 | CPP_NAME, | |
44 | CPP_NUMBER, | |
45 | CPP_CHAR, | |
46 | CPP_STRING, | |
47 | CPP_DIRECTIVE, | |
48 | CPP_LPAREN, /* "(" */ | |
49 | CPP_RPAREN, /* ")" */ | |
50 | CPP_LBRACE, /* "{" */ | |
51 | CPP_RBRACE, /* "}" */ | |
52 | CPP_COMMA, /* "," */ | |
53 | CPP_SEMICOLON,/* ";" */ | |
54 | CPP_3DOTS, /* "..." */ | |
55 | #if 0 | |
56 | CPP_ANDAND, /* "&&" */ | |
57 | CPP_OROR, /* "||" */ | |
58 | CPP_LSH, /* "<<" */ | |
59 | CPP_RSH, /* ">>" */ | |
60 | CPP_EQL, /* "==" */ | |
61 | CPP_NEQ, /* "!=" */ | |
62 | CPP_LEQ, /* "<=" */ | |
63 | CPP_GEQ, /* ">=" */ | |
64 | CPP_PLPL, /* "++" */ | |
65 | CPP_MINMIN, /* "--" */ | |
66 | #endif | |
67 | /* POP_TOKEN is returned when we've popped a cpp_buffer. */ | |
68 | CPP_POP | |
69 | }; | |
70 | ||
71 | #ifndef PARAMS | |
72 | #ifdef __STDC | |
73 | #define PARAMS(P) P | |
74 | #else | |
75 | #define PARAMS(P) () | |
76 | #endif | |
77 | #endif /* !PARAMS */ | |
78 | ||
0f41302f MS |
79 | typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader *)); |
80 | typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader *)); | |
7f2935c7 PB |
81 | |
82 | /* A parse_marker indicates a previous position, | |
83 | which we can backtrack to. */ | |
84 | ||
85 | struct parse_marker { | |
86 | cpp_buffer *buf; | |
87 | struct parse_marker *next; | |
88 | int position; | |
89 | }; | |
90 | ||
0f41302f MS |
91 | extern void parse_set_mark PARAMS ((struct parse_marker *, cpp_reader *)); |
92 | extern void parse_clear_mark PARAMS ((struct parse_marker *)); | |
93 | extern void parse_goto_mark PARAMS((struct parse_marker *, cpp_reader *)); | |
94 | extern void parse_move_mark PARAMS((struct parse_marker *, cpp_reader *)); | |
7f2935c7 | 95 | |
0f41302f MS |
96 | extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **)); |
97 | extern enum cpp_token cpp_get_token PARAMS ((struct parse_marker *)); | |
98 | extern void cpp_skip_hspace PARAMS((cpp_reader *)); | |
7f2935c7 PB |
99 | extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *)); |
100 | ||
af453bb0 | 101 | /* This frees resources used by PFILE. */ |
0f41302f | 102 | extern void cpp_cleanup PARAMS ((cpp_reader *PFILE)); |
7f2935c7 PB |
103 | |
104 | /* Maintain and search list of included files, for #import. */ | |
105 | ||
106 | #define IMPORT_HASH_SIZE 31 | |
107 | ||
108 | struct import_file { | |
109 | char *name; | |
110 | ino_t inode; | |
111 | dev_t dev; | |
112 | struct import_file *next; | |
113 | }; | |
114 | ||
115 | /* If we have a huge buffer, may need to cache more recent counts */ | |
116 | #define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base) | |
117 | ||
118 | struct cpp_buffer { | |
119 | unsigned char *buf; | |
120 | unsigned char *cur; | |
121 | unsigned char *rlimit; /* end of valid data */ | |
122 | unsigned char *alimit; /* end of allocated buffer */ | |
123 | unsigned char *prev; /* start of current token */ | |
124 | ||
125 | char *fname; | |
126 | /* Filename specified with #line command. */ | |
127 | char *nominal_fname; | |
128 | ||
129 | /* Record where in the search path this file was found. | |
130 | For #include_next. */ | |
131 | struct file_name_list *dir; | |
132 | ||
133 | long line_base; | |
134 | long lineno; /* Line number at CPP_LINE_BASE. */ | |
135 | long colno; /* Column number at CPP_LINE_BASE. */ | |
7f2935c7 PB |
136 | parse_underflow_t underflow; |
137 | parse_cleanup_t cleanup; | |
138 | void *data; | |
139 | struct parse_marker *marks; | |
140 | /* Value of if_stack at start of this file. | |
141 | Used to prohibit unmatched #endif (etc) in an include file. */ | |
142 | struct if_stack *if_stack; | |
143 | ||
144 | /* True if this is a header file included using <FILENAME>. */ | |
145 | char system_header_p; | |
146 | char seen_eof; | |
147 | ||
148 | /* True if buffer contains escape sequences. | |
af453bb0 | 149 | Currently there are three kinds: |
7f2935c7 | 150 | "@-" means following identifier should not be macro-expanded. |
7e2eb697 PB |
151 | "@ " means a token-separator. This turns into " " in final output |
152 | if not stringizing and needed to separate tokens; otherwise nothing. | |
6536dfcb PB |
153 | "@@" means a normal '@'. |
154 | (An '@' inside a string stands for itself and is never an escape.) */ | |
7f2935c7 PB |
155 | char has_escapes; |
156 | }; | |
157 | ||
158 | struct cpp_pending; /* Forward declaration - for C++. */ | |
7e2eb697 | 159 | struct file_name_map_list; |
7f2935c7 PB |
160 | |
161 | typedef struct assertion_hashnode ASSERTION_HASHNODE; | |
162 | #define ASSERTION_HASHSIZE 37 | |
163 | ||
7f2935c7 PB |
164 | /* Maximum nesting of cpp_buffers. We use a static limit, partly for |
165 | efficiency, and partly to limit runaway recursion. */ | |
166 | #define CPP_STACK_MAX 200 | |
af453bb0 PB |
167 | |
168 | /* A cpp_reader encapsulates the "state" of a pre-processor run. | |
169 | Applying cpp_get_token repeatedly yields a stream of pre-processor | |
170 | tokens. Usually, there is only one cpp_reader object active. */ | |
7f2935c7 PB |
171 | |
172 | struct cpp_reader { | |
7f2935c7 PB |
173 | parse_underflow_t get_token; |
174 | cpp_buffer *buffer; | |
7f2935c7 | 175 | cpp_buffer buffer_stack[CPP_STACK_MAX]; |
7f2935c7 PB |
176 | |
177 | int errors; /* Error counter for exit code */ | |
7f2935c7 PB |
178 | void *data; |
179 | ||
af453bb0 PB |
180 | /* A buffer used for both for cpp_get_token's output, and also internally. */ |
181 | unsigned char *token_buffer; | |
182 | /* Alocated size of token_buffer. CPP_RESERVE allocates space. */ | |
7f2935c7 | 183 | int token_buffer_size; |
af453bb0 PB |
184 | /* End of the written part of token_buffer. */ |
185 | unsigned char *limit; | |
7f2935c7 | 186 | |
3232050c PB |
187 | /* Line where a newline was first seen in a string constant. */ |
188 | int multiline_string_line; | |
189 | ||
7f2935c7 PB |
190 | /* Current depth in #include directives that use <...>. */ |
191 | int system_include_depth; | |
192 | ||
193 | /* List of included files that contained #pragma once. */ | |
194 | struct file_name_list *dont_repeat_files; | |
195 | ||
196 | /* List of other included files. | |
197 | If ->control_macro if nonzero, the file had a #ifndef | |
198 | around the entire contents, and ->control_macro gives the macro name. */ | |
199 | struct file_name_list *all_include_files; | |
200 | ||
201 | /* Current maximum length of directory names in the search path | |
202 | for include files. (Altered as we get more of them.) */ | |
203 | int max_include_len; | |
204 | ||
205 | /* Hash table of files already included with #include or #import. */ | |
206 | struct import_file *import_hash_table[IMPORT_HASH_SIZE]; | |
207 | ||
208 | struct if_stack *if_stack; | |
209 | ||
210 | /* Nonzero means we are inside an IF during a -pcp run. In this mode | |
211 | macro expansion is done, and preconditions are output for all macro | |
212 | uses requiring them. */ | |
213 | char pcp_inside_if; | |
214 | ||
215 | /* Nonzero means we have printed (while error reporting) a list of | |
216 | containing files that matches the current status. */ | |
217 | char input_stack_listing_current; | |
218 | ||
219 | /* If non-zero, macros are not expanded. */ | |
220 | char no_macro_expand; | |
221 | ||
222 | /* Print column number in error messages. */ | |
223 | char show_column; | |
224 | ||
225 | /* We're printed a warning recommending against using #import. */ | |
226 | char import_warning; | |
227 | ||
228 | /* If true, character between '<' and '>' are a single (string) token. */ | |
229 | char parsing_include_directive; | |
230 | ||
231 | /* True if escape sequences (as described for has_escapes in | |
232 | parse_buffer) should be emitted. */ | |
233 | char output_escapes; | |
234 | ||
235 | /* 0: Have seen non-white-space on this line. | |
236 | 1: Only seen white space so far on this line. | |
237 | 2: Only seen white space so far in this file. */ | |
238 | char only_seen_white; | |
239 | ||
240 | /* Nonzero means this file was included with a -imacros or -include | |
241 | command line and should not be recorded as an include file. */ | |
242 | ||
243 | int no_record_file; | |
244 | ||
245 | long lineno; | |
246 | ||
247 | struct tm *timebuf; | |
248 | ||
249 | ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE]; | |
250 | ||
251 | /* Buffer of -M output. */ | |
252 | char *deps_buffer; | |
253 | ||
254 | /* Number of bytes allocated in above. */ | |
255 | int deps_allocated_size; | |
256 | ||
257 | /* Number of bytes used. */ | |
258 | int deps_size; | |
259 | ||
260 | /* Number of bytes since the last newline. */ | |
261 | int deps_column; | |
af453bb0 PB |
262 | |
263 | #ifdef __cplusplus | |
264 | ~cpp_reader () { cpp_cleanup (this); } | |
265 | #endif | |
7f2935c7 PB |
266 | }; |
267 | ||
194d7493 PB |
268 | #define CPP_FATAL_LIMIT 1000 |
269 | /* True if we have seen a "fatal" error. */ | |
270 | #define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT) | |
271 | ||
7f2935c7 PB |
272 | #define CPP_BUF_PEEK(BUFFER) \ |
273 | ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF) | |
274 | #define CPP_BUF_GET(BUFFER) \ | |
275 | ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF) | |
276 | #define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N)) | |
277 | ||
194d7493 PB |
278 | /* Macros for manipulating the token_buffer. */ |
279 | ||
280 | #define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer) | |
281 | ||
7f2935c7 PB |
282 | /* Number of characters currently in PFILE's output buffer. */ |
283 | #define CPP_WRITTEN(PFILE) ((PFILE)->limit - (PFILE)->token_buffer) | |
284 | #define CPP_PWRITTEN(PFILE) ((PFILE)->limit) | |
285 | ||
286 | /* Make sure PFILE->token_buffer has space for at least N more characters. */ | |
287 | #define CPP_RESERVE(PFILE, N) \ | |
288 | (CPP_WRITTEN (PFILE) + N > (PFILE)->token_buffer_size \ | |
289 | && (cpp_grow_buffer (PFILE, N), 0)) | |
290 | ||
291 | /* Append string STR (of length N) to PFILE's output buffer. | |
292 | Assume there is enough space. */ | |
293 | #define CPP_PUTS_Q(PFILE, STR, N) \ | |
294 | (bcopy (STR, (PFILE)->limit, (N)), (PFILE)->limit += (N)) | |
295 | /* Append string STR (of length N) to PFILE's output buffer. Make space. */ | |
296 | #define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N) | |
297 | /* Append character CH to PFILE's output buffer. Assume sufficient space. */ | |
298 | #define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH)) | |
299 | /* Append character CH to PFILE's output buffer. Make space if need be. */ | |
300 | #define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH)) | |
301 | /* Make sure PFILE->limit is followed by '\0'. */ | |
302 | #define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0) | |
303 | #define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0) | |
304 | #define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA)) | |
305 | #define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N)) | |
306 | ||
0f41302f | 307 | #define CPP_OPTIONS(PFILE) ((cpp_options *) (PFILE)->data) |
194d7493 | 308 | |
7f2935c7 | 309 | #define CPP_BUFFER(PFILE) ((PFILE)->buffer) |
7f2935c7 | 310 | #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1) |
194d7493 | 311 | /* The bottom of the buffer stack. */ |
7f2935c7 | 312 | #define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX]) |
7f2935c7 | 313 | |
af453bb0 | 314 | /* Pointed to by cpp_reader::data. */ |
7f2935c7 PB |
315 | struct cpp_options { |
316 | char *in_fname; | |
317 | ||
318 | /* Name of output file, for error messages. */ | |
319 | char *out_fname; | |
320 | ||
7e2eb697 PB |
321 | struct file_name_map_list *map_list; |
322 | ||
7f2935c7 PB |
323 | /* Non-0 means -v, so print the full set of include dirs. */ |
324 | char verbose; | |
325 | ||
326 | /* Nonzero means use extra default include directories for C++. */ | |
327 | ||
328 | char cplusplus; | |
329 | ||
330 | /* Nonzero means handle cplusplus style comments */ | |
331 | ||
332 | char cplusplus_comments; | |
333 | ||
334 | /* Nonzero means handle #import, for objective C. */ | |
335 | ||
336 | char objc; | |
337 | ||
338 | /* Nonzero means this is an assembly file, and allow | |
339 | unknown directives, which could be comments. */ | |
340 | ||
341 | int lang_asm; | |
342 | ||
343 | /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */ | |
344 | ||
345 | char for_lint; | |
346 | ||
347 | /* Nonzero means handle CHILL comment syntax | |
ddd5a7c1 | 348 | and output CHILL string delimiter for __DATE___ etc. */ |
7f2935c7 PB |
349 | |
350 | char chill; | |
351 | ||
352 | /* Nonzero means copy comments into the output file. */ | |
353 | ||
354 | char put_out_comments; | |
355 | ||
356 | /* Nonzero means don't process the ANSI trigraph sequences. */ | |
357 | ||
358 | char no_trigraphs; | |
359 | ||
360 | /* Nonzero means print the names of included files rather than | |
361 | the preprocessed output. 1 means just the #include "...", | |
362 | 2 means #include <...> as well. */ | |
363 | ||
364 | char print_deps; | |
365 | ||
366 | /* Nonzero if missing .h files in -M output are assumed to be generated | |
367 | files and not errors. */ | |
368 | ||
369 | char print_deps_missing_files; | |
370 | ||
371 | /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */ | |
372 | char print_deps_append; | |
373 | ||
374 | /* Nonzero means print names of header files (-H). */ | |
375 | ||
376 | char print_include_names; | |
377 | ||
378 | /* Nonzero means try to make failure to fit ANSI C an error. */ | |
379 | ||
380 | char pedantic_errors; | |
381 | ||
382 | /* Nonzero means don't print warning messages. -w. */ | |
383 | ||
384 | char inhibit_warnings; | |
385 | ||
386 | /* Nonzero means warn if slash-star appears in a comment. */ | |
387 | ||
388 | char warn_comments; | |
389 | ||
390 | /* Nonzero means warn if there are any trigraphs. */ | |
391 | ||
392 | char warn_trigraphs; | |
393 | ||
394 | /* Nonzero means warn if #import is used. */ | |
395 | ||
396 | char warn_import; | |
397 | ||
398 | /* Nonzero means warn if a macro argument is (or would be) | |
399 | stringified with -traditional. */ | |
400 | ||
401 | char warn_stringify; | |
402 | ||
403 | /* Nonzero means turn warnings into errors. */ | |
404 | ||
405 | char warnings_are_errors; | |
406 | ||
407 | /* Nonzero causes output not to be done, | |
408 | but directives such as #define that have side effects | |
409 | are still obeyed. */ | |
410 | ||
411 | char no_output; | |
412 | ||
413 | /* Nonzero means don't output line number information. */ | |
414 | ||
415 | char no_line_commands; | |
416 | ||
417 | /* Nonzero means output the text in failing conditionals, | |
418 | inside #failed ... #endfailed. */ | |
419 | ||
420 | char output_conditionals; | |
421 | ||
422 | /* Nonzero means -I- has been seen, | |
423 | so don't look for #include "foo" the source-file directory. */ | |
424 | char ignore_srcdir; | |
425 | ||
426 | /* Zero means dollar signs are punctuation. | |
427 | -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise. | |
428 | This must be 0 for correct processing of this ANSI C program: | |
429 | #define foo(a) #a | |
430 | #define lose(b) foo (b) | |
431 | #define test$ | |
432 | lose (test) */ | |
433 | char dollars_in_ident; | |
434 | #ifndef DOLLARS_IN_IDENTIFIERS | |
435 | #define DOLLARS_IN_IDENTIFIERS 1 | |
436 | #endif | |
437 | ||
438 | /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */ | |
439 | char traditional; | |
440 | ||
441 | /* Nonzero means give all the error messages the ANSI standard requires. */ | |
442 | char pedantic; | |
443 | ||
444 | char done_initializing; | |
445 | ||
446 | struct file_name_list *include; /* First dir to search */ | |
447 | /* First dir to search for <file> */ | |
448 | /* This is the first element to use for #include <...>. | |
449 | If it is 0, use the entire chain for such includes. */ | |
450 | struct file_name_list *first_bracket_include; | |
451 | /* This is the first element in the chain that corresponds to | |
452 | a directory of system header files. */ | |
453 | struct file_name_list *first_system_include; | |
454 | struct file_name_list *last_include; /* Last in chain */ | |
455 | ||
456 | /* Chain of include directories to put at the end of the other chain. */ | |
457 | struct file_name_list *after_include; | |
458 | struct file_name_list *last_after_include; /* Last in chain */ | |
459 | ||
460 | /* Chain to put at the start of the system include files. */ | |
461 | struct file_name_list *before_system; | |
462 | struct file_name_list *last_before_system; /* Last in chain */ | |
463 | ||
464 | /* Directory prefix that should replace `/usr' in the standard | |
465 | include file directories. */ | |
466 | char *include_prefix; | |
467 | ||
468 | char inhibit_predefs; | |
469 | char no_standard_includes; | |
470 | char no_standard_cplusplus_includes; | |
471 | ||
472 | /* dump_only means inhibit output of the preprocessed text | |
473 | and instead output the definitions of all user-defined | |
474 | macros in a form suitable for use as input to cccp. | |
475 | dump_names means pass #define and the macro name through to output. | |
476 | dump_definitions means pass the whole definition (plus #define) through | |
477 | */ | |
478 | ||
479 | enum {dump_none = 0, dump_only, dump_names, dump_definitions} | |
480 | dump_macros; | |
481 | ||
482 | /* Nonzero means pass all #define and #undef directives which we actually | |
483 | process through to the output stream. This feature is used primarily | |
484 | to allow cc1 to record the #defines and #undefs for the sake of | |
485 | debuggers which understand about preprocessor macros, but it may | |
486 | also be useful with -E to figure out how symbols are defined, and | |
487 | where they are defined. */ | |
488 | int debug_output; | |
489 | ||
490 | /* Pending -D, -U and -A options, in reverse order. */ | |
491 | struct cpp_pending *pending; | |
492 | ||
493 | /* File name which deps are being written to. | |
494 | This is 0 if deps are being written to stdout. */ | |
495 | char *deps_file; | |
496 | ||
497 | /* Target-name to write with the dependency information. */ | |
498 | char *deps_target; | |
499 | }; | |
500 | ||
501 | #define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional) | |
502 | #define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic) | |
503 | #define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps) | |
504 | ||
7f2935c7 PB |
505 | /* Name under which this program was invoked. */ |
506 | ||
507 | extern char *progname; | |
508 | ||
509 | /* The structure of a node in the hash table. The hash table | |
510 | has entries for all tokens defined by #define commands (type T_MACRO), | |
511 | plus some special tokens like __LINE__ (these each have their own | |
512 | type, and the appropriate code is run when that type of node is seen. | |
513 | It does not contain control words like "#define", which are recognized | |
514 | by a separate piece of code. */ | |
515 | ||
516 | /* different flavors of hash nodes --- also used in keyword table */ | |
517 | enum node_type { | |
518 | T_DEFINE = 1, /* the `#define' keyword */ | |
519 | T_INCLUDE, /* the `#include' keyword */ | |
520 | T_INCLUDE_NEXT, /* the `#include_next' keyword */ | |
521 | T_IMPORT, /* the `#import' keyword */ | |
522 | T_IFDEF, /* the `#ifdef' keyword */ | |
523 | T_IFNDEF, /* the `#ifndef' keyword */ | |
524 | T_IF, /* the `#if' keyword */ | |
525 | T_ELSE, /* `#else' */ | |
526 | T_PRAGMA, /* `#pragma' */ | |
527 | T_ELIF, /* `#elif' */ | |
528 | T_UNDEF, /* `#undef' */ | |
529 | T_LINE, /* `#line' */ | |
530 | T_ERROR, /* `#error' */ | |
531 | T_WARNING, /* `#warning' */ | |
532 | T_ENDIF, /* `#endif' */ | |
533 | T_SCCS, /* `#sccs', used on system V. */ | |
534 | T_IDENT, /* `#ident', used on system V. */ | |
535 | T_ASSERT, /* `#assert', taken from system V. */ | |
536 | T_UNASSERT, /* `#unassert', taken from system V. */ | |
537 | T_SPECLINE, /* special symbol `__LINE__' */ | |
538 | T_DATE, /* `__DATE__' */ | |
539 | T_FILE, /* `__FILE__' */ | |
540 | T_BASE_FILE, /* `__BASE_FILE__' */ | |
541 | T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */ | |
542 | T_VERSION, /* `__VERSION__' */ | |
543 | T_SIZE_TYPE, /* `__SIZE_TYPE__' */ | |
544 | T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */ | |
545 | T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */ | |
546 | T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */ | |
547 | T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */ | |
548 | T_TIME, /* `__TIME__' */ | |
549 | T_CONST, /* Constant value, used by `__STDC__' */ | |
550 | T_MACRO, /* macro defined by `#define' */ | |
551 | T_DISABLED, /* macro temporarily turned off for rescan */ | |
552 | T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */ | |
553 | T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */ | |
554 | T_UNUSED /* Used for something not defined. */ | |
555 | }; | |
556 | ||
557 | /* Structure returned by create_definition */ | |
558 | typedef struct macrodef MACRODEF; | |
559 | struct macrodef | |
560 | { | |
561 | struct definition *defn; | |
af453bb0 | 562 | unsigned char *symnam; |
7f2935c7 PB |
563 | int symlen; |
564 | }; | |
565 | ||
566 | /* Structure allocated for every #define. For a simple replacement | |
567 | such as | |
568 | #define foo bar , | |
569 | nargs = -1, the `pattern' list is null, and the expansion is just | |
570 | the replacement text. Nargs = 0 means a functionlike macro with no args, | |
571 | e.g., | |
572 | #define getchar() getc (stdin) . | |
573 | When there are args, the expansion is the replacement text with the | |
574 | args squashed out, and the reflist is a list describing how to | |
575 | build the output from the input: e.g., "3 chars, then the 1st arg, | |
576 | then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg". | |
577 | The chars here come from the expansion. Whatever is left of the | |
578 | expansion after the last arg-occurrence is copied after that arg. | |
579 | Note that the reflist can be arbitrarily long--- | |
580 | its length depends on the number of times the arguments appear in | |
581 | the replacement text, not how many args there are. Example: | |
582 | #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and | |
583 | pattern list | |
584 | { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL } | |
585 | where (x, y) means (nchars, argno). */ | |
586 | ||
587 | typedef struct definition DEFINITION; | |
588 | struct definition { | |
589 | int nargs; | |
590 | int length; /* length of expansion string */ | |
591 | int predefined; /* True if the macro was builtin or */ | |
592 | /* came from the command line */ | |
af453bb0 | 593 | unsigned char *expansion; |
7f2935c7 PB |
594 | int line; /* Line number of definition */ |
595 | char *file; /* File of definition */ | |
596 | char rest_args; /* Nonzero if last arg. absorbs the rest */ | |
597 | struct reflist { | |
598 | struct reflist *next; | |
599 | char stringify; /* nonzero if this arg was preceded by a | |
600 | # operator. */ | |
601 | char raw_before; /* Nonzero if a ## operator before arg. */ | |
602 | char raw_after; /* Nonzero if a ## operator after arg. */ | |
603 | char rest_args; /* Nonzero if this arg. absorbs the rest */ | |
604 | int nchars; /* Number of literal chars to copy before | |
605 | this arg occurrence. */ | |
606 | int argno; /* Number of arg to substitute (origin-0) */ | |
607 | } *pattern; | |
608 | union { | |
609 | /* Names of macro args, concatenated in reverse order | |
610 | with comma-space between them. | |
611 | The only use of this is that we warn on redefinition | |
612 | if this differs between the old and new definitions. */ | |
af453bb0 | 613 | unsigned char *argnames; |
7f2935c7 PB |
614 | } args; |
615 | }; | |
616 | ||
af453bb0 | 617 | extern unsigned char is_idchar[256]; |
7f2935c7 PB |
618 | |
619 | /* Stack of conditionals currently in progress | |
620 | (including both successful and failing conditionals). */ | |
621 | ||
622 | struct if_stack { | |
623 | struct if_stack *next; /* for chaining to the next stack frame */ | |
624 | char *fname; /* copied from input when frame is made */ | |
625 | int lineno; /* similarly */ | |
626 | int if_succeeded; /* true if a leg of this if-group | |
627 | has been passed through rescan */ | |
af453bb0 | 628 | unsigned char *control_macro; /* For #ifndef at start of file, |
7f2935c7 PB |
629 | this is the macro name tested. */ |
630 | enum node_type type; /* type of last directive seen in this group */ | |
631 | }; | |
632 | typedef struct if_stack IF_STACK_FRAME; | |
633 | ||
0f41302f MS |
634 | extern void cpp_buf_line_and_col PARAMS((cpp_buffer *, long *, long *)); |
635 | extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader *)); | |
636 | extern void cpp_define PARAMS ((cpp_reader*, unsigned char *)); | |
7f2935c7 PB |
637 | |
638 | extern void cpp_error (); | |
639 | extern void cpp_warning (); | |
640 | extern void cpp_pedwarn (); | |
641 | extern void cpp_error_with_line (); | |
7f2935c7 PB |
642 | extern void cpp_pedwarn_with_line (); |
643 | extern void cpp_pedwarn_with_file_and_line (); | |
644 | extern void fatal (); | |
645 | extern void cpp_error_from_errno (); | |
646 | extern void cpp_perror_with_name (); | |
647 | extern void cpp_pfatal_with_name (); | |
648 | ||
0f41302f MS |
649 | extern void cpp_grow_buffer PARAMS ((cpp_reader *, long)); |
650 | extern int cpp_parse_escape PARAMS ((cpp_reader *, char **)); | |
651 | extern cpp_buffer *cpp_push_buffer PARAMS ((cpp_reader *, | |
652 | unsigned char *, long)); | |
653 | extern cpp_buffer *cpp_pop_buffer PARAMS ((cpp_reader *)); | |
7f2935c7 | 654 | |
0f41302f | 655 | extern cpp_hashnode *cpp_lookup PARAMS ((cpp_reader *, const unsigned char *, |
7f2935c7 PB |
656 | int, int)); |
657 | ||
7f2935c7 PB |
658 | #ifdef __cplusplus |
659 | } | |
660 | #endif |