2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 static void init_library (void);
29 static void mark_named_operators (cpp_reader *);
30 static void read_original_filename (cpp_reader *);
31 static void read_original_directory (cpp_reader *);
32 static void post_options (cpp_reader *);
34 /* If we have designated initializers (GCC >2.7) these tables can be
35 initialized, constant data. Otherwise, they have to be filled in at
37 #if HAVE_DESIGNATED_INITIALIZERS
39 #define init_trigraph_map() /* Nothing. */
40 #define TRIGRAPH_MAP \
41 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
44 #define s(p, v) [p] = v,
48 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
49 static void init_trigraph_map (void) { \
50 unsigned char *x = _cpp_trigraph_map;
53 #define s(p, v) x[p] = v;
58 s('=', '#') s(')', ']') s('!', '|')
59 s('(', '[') s('\'', '^') s('>', '}')
60 s('/', '\\') s('<', '{') s('-', '~')
67 /* A set of booleans indicating what CPP features each source language
73 char extended_numbers;
75 char cplusplus_comments;
79 static const struct lang_flags lang_defaults[] =
80 { /* c99 c++ xnum std // digr */
81 /* GNUC89 */ { 0, 0, 1, 0, 1, 1 },
82 /* GNUC99 */ { 1, 0, 1, 0, 1, 1 },
83 /* STDC89 */ { 0, 0, 0, 1, 0, 0 },
84 /* STDC94 */ { 0, 0, 0, 1, 0, 1 },
85 /* STDC99 */ { 1, 0, 1, 1, 1, 1 },
86 /* GNUCXX */ { 0, 1, 1, 0, 1, 1 },
87 /* CXX98 */ { 0, 1, 1, 1, 1, 1 },
88 /* ASM */ { 0, 0, 1, 0, 1, 0 }
91 /* Sets internal flags correctly for a given language. */
93 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
95 const struct lang_flags *l = &lang_defaults[(int) lang];
97 CPP_OPTION (pfile, lang) = lang;
99 CPP_OPTION (pfile, c99) = l->c99;
100 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
101 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
102 CPP_OPTION (pfile, std) = l->std;
103 CPP_OPTION (pfile, trigraphs) = l->std;
104 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
105 CPP_OPTION (pfile, digraphs) = l->digraphs;
108 /* Initialize library global state. */
112 static int initialized = 0;
118 /* Set up the trigraph map. This doesn't need to do anything if
119 we were compiled with a compiler that supports C99 designated
121 init_trigraph_map ();
125 /* Initialize a cpp_reader structure. */
127 cpp_create_reader (enum c_lang lang, hash_table *table,
128 struct line_maps *line_table)
132 /* Initialize this instance of the library if it hasn't been already. */
135 pfile = xcalloc (1, sizeof (cpp_reader));
137 cpp_set_lang (pfile, lang);
138 CPP_OPTION (pfile, warn_multichar) = 1;
139 CPP_OPTION (pfile, discard_comments) = 1;
140 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
141 CPP_OPTION (pfile, show_column) = 1;
142 CPP_OPTION (pfile, tabstop) = 8;
143 CPP_OPTION (pfile, operator_names) = 1;
144 CPP_OPTION (pfile, warn_trigraphs) = 2;
145 CPP_OPTION (pfile, warn_endif_labels) = 1;
146 CPP_OPTION (pfile, warn_deprecated) = 1;
147 CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
148 CPP_OPTION (pfile, dollars_in_ident) = 1;
149 CPP_OPTION (pfile, warn_dollars) = 1;
151 /* Default CPP arithmetic to something sensible for the host for the
152 benefit of dumb users like fix-header. */
153 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
154 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
155 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
156 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
157 CPP_OPTION (pfile, unsigned_char) = 0;
158 CPP_OPTION (pfile, unsigned_wchar) = 1;
159 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
161 /* Default to no charset conversion. */
162 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
163 CPP_OPTION (pfile, wide_charset) = 0;
165 /* Default the input character set to UTF-8. */
166 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
168 /* A fake empty "directory" used as the starting point for files
169 looked up without a search path. Name cannot be '/' because we
170 don't want to prepend anything at all to filenames using it. All
171 other entries are correct zero-initialized. */
172 pfile->no_search_path.name = (char *) "";
174 /* Initialize the line map. Start at logical line 1, so we can use
175 a line number of zero for special states. */
176 pfile->line_table = line_table;
179 /* Initialize lexer state. */
180 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
182 /* Set up static tokens. */
183 pfile->avoid_paste.type = CPP_PADDING;
184 pfile->avoid_paste.val.source = NULL;
185 pfile->eof.type = CPP_EOF;
186 pfile->eof.flags = 0;
188 /* Create a token buffer for the lexer. */
189 _cpp_init_tokenrun (&pfile->base_run, 250);
190 pfile->cur_run = &pfile->base_run;
191 pfile->cur_token = pfile->base_run.base;
193 /* Initialize the base context. */
194 pfile->context = &pfile->base_context;
195 pfile->base_context.macro = 0;
196 pfile->base_context.prev = pfile->base_context.next = 0;
198 /* Aligned and unaligned storage. */
199 pfile->a_buff = _cpp_get_buff (pfile, 0);
200 pfile->u_buff = _cpp_get_buff (pfile, 0);
202 /* The expression parser stack. */
203 _cpp_expand_op_stack (pfile);
205 /* Initialize the buffer obstack. */
206 _obstack_begin (&pfile->buffer_ob, 0, 0,
207 (void *(*) (long)) xmalloc,
208 (void (*) (void *)) free);
210 _cpp_init_files (pfile);
212 _cpp_init_hashtable (pfile, table);
217 /* Free resources used by PFILE. Accessing PFILE after this function
218 returns leads to undefined behavior. Returns the error count. */
220 cpp_destroy (cpp_reader *pfile)
222 cpp_context *context, *contextn;
223 tokenrun *run, *runn;
225 free (pfile->op_stack);
227 while (CPP_BUFFER (pfile) != NULL)
228 _cpp_pop_buffer (pfile);
231 free (pfile->out.base);
233 if (pfile->macro_buffer)
235 free (pfile->macro_buffer);
236 pfile->macro_buffer = NULL;
237 pfile->macro_buffer_len = 0;
241 deps_free (pfile->deps);
242 obstack_free (&pfile->buffer_ob, 0);
244 _cpp_destroy_hashtable (pfile);
245 _cpp_cleanup_files (pfile);
246 _cpp_destroy_iconv (pfile);
248 _cpp_free_buff (pfile->a_buff);
249 _cpp_free_buff (pfile->u_buff);
250 _cpp_free_buff (pfile->free_buffs);
252 for (run = &pfile->base_run; run; run = runn)
256 if (run != &pfile->base_run)
260 for (context = pfile->base_context.next; context; context = contextn)
262 contextn = context->next;
269 /* This structure defines one built-in identifier. A node will be
270 entered in the hash table under the name NAME, with value VALUE.
272 There are two tables of these. builtin_array holds all the
273 "builtin" macros: these are handled by builtin_macro() in
274 cppmacro.c. Builtin is somewhat of a misnomer -- the property of
275 interest is that these macros require special code to compute their
276 expansions. The value is a "builtin_type" enumerator.
278 operator_array holds the C++ named operators. These are keywords
279 which act as aliases for punctuators. In C++, they cannot be
280 altered through #define, and #if recognizes them as operators. In
281 C, these are not entered into the hash table at all (but see
282 <iso646.h>). The value is a token-type enumerator. */
287 unsigned short value;
290 #define B(n, t) { DSC(n), t }
291 static const struct builtin builtin_array[] =
293 B("__TIME__", BT_TIME),
294 B("__DATE__", BT_DATE),
295 B("__FILE__", BT_FILE),
296 B("__BASE_FILE__", BT_BASE_FILE),
297 B("__LINE__", BT_SPECLINE),
298 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
299 /* Keep builtins not used for -traditional-cpp at the end, and
300 update init_builtins() if any more are added. */
301 B("_Pragma", BT_PRAGMA),
302 B("__STDC__", BT_STDC),
305 static const struct builtin operator_array[] =
307 B("and", CPP_AND_AND),
308 B("and_eq", CPP_AND_EQ),
309 B("bitand", CPP_AND),
311 B("compl", CPP_COMPL),
313 B("not_eq", CPP_NOT_EQ),
315 B("or_eq", CPP_OR_EQ),
317 B("xor_eq", CPP_XOR_EQ)
321 /* Mark the C++ named operators in the hash table. */
323 mark_named_operators (cpp_reader *pfile)
325 const struct builtin *b;
327 for (b = operator_array;
328 b < (operator_array + ARRAY_SIZE (operator_array));
331 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
332 hp->flags |= NODE_OPERATOR;
333 hp->is_directive = 0;
334 hp->directive_index = b->value;
338 /* Read the builtins table above and enter them, and language-specific
339 macros, into the hash table. HOSTED is true if this is a hosted
342 cpp_init_builtins (cpp_reader *pfile, int hosted)
344 const struct builtin *b;
345 size_t n = ARRAY_SIZE (builtin_array);
347 if (CPP_OPTION (pfile, traditional))
350 for(b = builtin_array; b < builtin_array + n; b++)
352 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
354 hp->flags |= NODE_BUILTIN | NODE_WARN;
355 hp->value.builtin = b->value;
358 if (CPP_OPTION (pfile, cplusplus))
359 _cpp_define_builtin (pfile, "__cplusplus 1");
360 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
361 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
362 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
363 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
364 else if (CPP_OPTION (pfile, c99))
365 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
368 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
370 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
372 if (CPP_OPTION (pfile, objc))
373 _cpp_define_builtin (pfile, "__OBJC__ 1");
376 /* Sanity-checks are dependent on command-line options, so it is
377 called as a subroutine of cpp_read_main_file (). */
379 static void sanity_checks (cpp_reader *);
380 static void sanity_checks (cpp_reader *pfile)
383 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
385 /* Sanity checks for assumptions about CPP arithmetic and target
386 type precisions made by cpplib. */
389 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
391 if (CPP_OPTION (pfile, precision) > max_precision)
392 cpp_error (pfile, CPP_DL_ICE,
393 "preprocessor arithmetic has maximum precision of %lu bits;"
394 " target requires %lu bits",
395 (unsigned long) max_precision,
396 (unsigned long) CPP_OPTION (pfile, precision));
398 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
399 cpp_error (pfile, CPP_DL_ICE,
400 "CPP arithmetic must be at least as precise as a target int");
402 if (CPP_OPTION (pfile, char_precision) < 8)
403 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
405 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
406 cpp_error (pfile, CPP_DL_ICE,
407 "target wchar_t is narrower than target char");
409 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
410 cpp_error (pfile, CPP_DL_ICE,
411 "target int is narrower than target char");
413 /* This is assumed in eval_token() and could be fixed if necessary. */
414 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
415 cpp_error (pfile, CPP_DL_ICE,
416 "CPP half-integer narrower than CPP character");
418 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
419 cpp_error (pfile, CPP_DL_ICE,
420 "CPP on this host cannot handle wide character constants over"
421 " %lu bits, but the target requires %lu bits",
422 (unsigned long) BITS_PER_CPPCHAR_T,
423 (unsigned long) CPP_OPTION (pfile, wchar_precision));
426 # define sanity_checks(PFILE)
429 /* Add a dependency target. Can be called any number of times before
430 cpp_read_main_file(). If no targets have been added before
431 cpp_read_main_file(), then the default target is used. */
433 cpp_add_dependency_target (cpp_reader *pfile, const char *target, int quote)
436 pfile->deps = deps_init ();
438 deps_add_target (pfile->deps, target, quote);
441 /* This is called after options have been parsed, and partially
444 cpp_post_options (cpp_reader *pfile)
446 sanity_checks (pfile);
448 post_options (pfile);
450 /* Mark named operators before handling command line macros. */
451 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
452 mark_named_operators (pfile);
455 /* Setup for processing input from the file named FNAME, or stdin if
456 it is the empty string. Return the original filename
457 on success (e.g. foo.i->foo.c), or NULL on failure. */
459 cpp_read_main_file (cpp_reader *pfile, const char *fname)
461 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
464 pfile->deps = deps_init ();
466 /* Set the default target (if there is none already). */
467 deps_add_default_target (pfile->deps, fname);
471 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false);
472 if (_cpp_find_failed (pfile->main_file))
475 _cpp_stack_file (pfile, pfile->main_file, false);
477 /* For foo.i, read the original filename foo.c now, for the benefit
478 of the front ends. */
479 if (CPP_OPTION (pfile, preprocessed))
481 read_original_filename (pfile);
482 fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
487 /* For preprocessed files, if the first tokens are of the form # NUM.
488 handle the directive so we know the original file name. This will
489 generate file_change callbacks, which the front ends must handle
490 appropriately given their state of initialization. */
492 read_original_filename (cpp_reader *pfile)
494 const cpp_token *token, *token1;
496 /* Lex ahead; if the first tokens are of the form # NUM, then
497 process the directive, otherwise back up. */
498 token = _cpp_lex_direct (pfile);
499 if (token->type == CPP_HASH)
501 token1 = _cpp_lex_direct (pfile);
502 _cpp_backup_tokens (pfile, 1);
504 /* If it's a #line directive, handle it. */
505 if (token1->type == CPP_NUMBER)
507 _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
508 read_original_directory (pfile);
513 /* Backup as if nothing happened. */
514 _cpp_backup_tokens (pfile, 1);
517 /* For preprocessed files, if the tokens following the first filename
518 line is of the form # <line> "/path/name//", handle the
519 directive so we know the original current directory. */
521 read_original_directory (cpp_reader *pfile)
523 const cpp_token *hash, *token;
525 /* Lex ahead; if the first tokens are of the form # NUM, then
526 process the directive, otherwise back up. */
527 hash = _cpp_lex_direct (pfile);
528 if (hash->type != CPP_HASH)
530 _cpp_backup_tokens (pfile, 1);
534 token = _cpp_lex_direct (pfile);
536 if (token->type != CPP_NUMBER)
538 _cpp_backup_tokens (pfile, 2);
542 token = _cpp_lex_direct (pfile);
544 if (token->type != CPP_STRING
545 || ! (token->val.str.len >= 5
546 && token->val.str.text[token->val.str.len-2] == '/'
547 && token->val.str.text[token->val.str.len-3] == '/'))
549 _cpp_backup_tokens (pfile, 3);
553 if (pfile->cb.dir_change)
555 char *debugdir = alloca (token->val.str.len - 3);
557 memcpy (debugdir, (const char *) token->val.str.text + 1,
558 token->val.str.len - 4);
559 debugdir[token->val.str.len - 4] = '\0';
561 pfile->cb.dir_change (pfile, debugdir);
565 /* This is called at the end of preprocessing. It pops the last
566 buffer and writes dependency output, and returns the number of
569 Maybe it should also reset state, such that you could call
570 cpp_start_read with a new filename to restart processing. */
572 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
574 /* Warn about unused macros before popping the final buffer. */
575 if (CPP_OPTION (pfile, warn_unused_macros))
576 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
578 /* cpplex.c leaves the final buffer on the stack. This it so that
579 it returns an unending stream of CPP_EOFs to the client. If we
580 popped the buffer, we'd dereference a NULL buffer pointer and
581 segfault. It's nice to allow the client to do worry-free excess
582 cpp_get_token calls. */
583 while (pfile->buffer)
584 _cpp_pop_buffer (pfile);
586 /* Don't write the deps file if there are errors. */
587 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
588 && deps_stream && pfile->errors == 0)
590 deps_write (pfile->deps, deps_stream, 72);
592 if (CPP_OPTION (pfile, deps.phony_targets))
593 deps_phony_targets (pfile->deps, deps_stream);
596 /* Report on headers that could use multiple include guards. */
597 if (CPP_OPTION (pfile, print_include_names))
598 _cpp_report_missing_guards (pfile);
600 return pfile->errors;
604 post_options (cpp_reader *pfile)
606 /* -Wtraditional is not useful in C++ mode. */
607 if (CPP_OPTION (pfile, cplusplus))
608 CPP_OPTION (pfile, warn_traditional) = 0;
610 /* Permanently disable macro expansion if we are rescanning
611 preprocessed text. Read preprocesed source in ISO mode. */
612 if (CPP_OPTION (pfile, preprocessed))
614 pfile->state.prevent_expansion = 1;
615 CPP_OPTION (pfile, traditional) = 0;
618 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
619 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
621 if (CPP_OPTION (pfile, traditional))
623 /* Traditional CPP does not accurately track column information. */
624 CPP_OPTION (pfile, show_column) = 0;
625 CPP_OPTION (pfile, trigraphs) = 0;
626 CPP_OPTION (pfile, warn_trigraphs) = 0;