2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
27 #include "localedir.h"
29 static void init_library (void);
30 static void mark_named_operators (cpp_reader *);
31 static void read_original_filename (cpp_reader *);
32 static void read_original_directory (cpp_reader *);
33 static void post_options (cpp_reader *);
35 /* If we have designated initializers (GCC >2.7) these tables can be
36 initialized, constant data. Otherwise, they have to be filled in at
38 #if HAVE_DESIGNATED_INITIALIZERS
40 #define init_trigraph_map() /* Nothing. */
41 #define TRIGRAPH_MAP \
42 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
45 #define s(p, v) [p] = v,
49 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
50 static void init_trigraph_map (void) { \
51 unsigned char *x = _cpp_trigraph_map;
54 #define s(p, v) x[p] = v;
59 s('=', '#') s(')', ']') s('!', '|')
60 s('(', '[') s('\'', '^') s('>', '}')
61 s('/', '\\') s('<', '{') s('-', '~')
68 /* A set of booleans indicating what CPP features each source language
74 char extended_numbers;
75 char extended_identifiers;
77 char cplusplus_comments;
81 static const struct lang_flags lang_defaults[] =
82 { /* c99 c++ xnum xid std // digr */
83 /* GNUC89 */ { 0, 0, 1, 0, 0, 1, 1 },
84 /* GNUC99 */ { 1, 0, 1, 0, 0, 1, 1 },
85 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0 },
86 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 1 },
87 /* STDC99 */ { 1, 0, 1, 0, 1, 1, 1 },
88 /* GNUCXX */ { 0, 1, 1, 0, 0, 1, 1 },
89 /* CXX98 */ { 0, 1, 1, 0, 1, 1, 1 },
90 /* ASM */ { 0, 0, 1, 0, 0, 1, 0 }
91 /* xid should be 1 for GNUC99, STDC99, GNUCXX and CXX98 when no
92 longer experimental (when all uses of identifiers in the compiler
93 have been audited for correct handling of extended
97 /* Sets internal flags correctly for a given language. */
99 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
101 const struct lang_flags *l = &lang_defaults[(int) lang];
103 CPP_OPTION (pfile, lang) = lang;
105 CPP_OPTION (pfile, c99) = l->c99;
106 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
107 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
108 CPP_OPTION (pfile, extended_identifiers) = l->extended_identifiers;
109 CPP_OPTION (pfile, std) = l->std;
110 CPP_OPTION (pfile, trigraphs) = l->std;
111 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
112 CPP_OPTION (pfile, digraphs) = l->digraphs;
115 /* Initialize library global state. */
119 static int initialized = 0;
125 /* Set up the trigraph map. This doesn't need to do anything if
126 we were compiled with a compiler that supports C99 designated
128 init_trigraph_map ();
131 (void) bindtextdomain (PACKAGE, LOCALEDIR);
136 /* Initialize a cpp_reader structure. */
138 cpp_create_reader (enum c_lang lang, hash_table *table,
139 struct line_maps *line_table)
143 /* Initialize this instance of the library if it hasn't been already. */
146 pfile = XCNEW (cpp_reader);
148 cpp_set_lang (pfile, lang);
149 CPP_OPTION (pfile, warn_multichar) = 1;
150 CPP_OPTION (pfile, discard_comments) = 1;
151 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
152 CPP_OPTION (pfile, show_column) = 1;
153 CPP_OPTION (pfile, tabstop) = 8;
154 CPP_OPTION (pfile, operator_names) = 1;
155 CPP_OPTION (pfile, warn_trigraphs) = 2;
156 CPP_OPTION (pfile, warn_endif_labels) = 1;
157 CPP_OPTION (pfile, warn_deprecated) = 1;
158 CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
159 CPP_OPTION (pfile, dollars_in_ident) = 1;
160 CPP_OPTION (pfile, warn_dollars) = 1;
161 CPP_OPTION (pfile, warn_variadic_macros) = 1;
162 CPP_OPTION (pfile, warn_normalize) = normalized_C;
164 /* Default CPP arithmetic to something sensible for the host for the
165 benefit of dumb users like fix-header. */
166 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
167 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
168 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
169 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
170 CPP_OPTION (pfile, unsigned_char) = 0;
171 CPP_OPTION (pfile, unsigned_wchar) = 1;
172 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
174 /* Default to no charset conversion. */
175 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
176 CPP_OPTION (pfile, wide_charset) = 0;
178 /* Default the input character set to UTF-8. */
179 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
181 /* A fake empty "directory" used as the starting point for files
182 looked up without a search path. Name cannot be '/' because we
183 don't want to prepend anything at all to filenames using it. All
184 other entries are correct zero-initialized. */
185 pfile->no_search_path.name = (char *) "";
187 /* Initialize the line map. */
188 pfile->line_table = line_table;
190 /* Initialize lexer state. */
191 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
193 /* Set up static tokens. */
194 pfile->avoid_paste.type = CPP_PADDING;
195 pfile->avoid_paste.val.source = NULL;
196 pfile->eof.type = CPP_EOF;
197 pfile->eof.flags = 0;
199 /* Create a token buffer for the lexer. */
200 _cpp_init_tokenrun (&pfile->base_run, 250);
201 pfile->cur_run = &pfile->base_run;
202 pfile->cur_token = pfile->base_run.base;
204 /* Initialize the base context. */
205 pfile->context = &pfile->base_context;
206 pfile->base_context.macro = 0;
207 pfile->base_context.prev = pfile->base_context.next = 0;
209 /* Aligned and unaligned storage. */
210 pfile->a_buff = _cpp_get_buff (pfile, 0);
211 pfile->u_buff = _cpp_get_buff (pfile, 0);
213 /* The expression parser stack. */
214 _cpp_expand_op_stack (pfile);
216 /* Initialize the buffer obstack. */
217 _obstack_begin (&pfile->buffer_ob, 0, 0,
218 (void *(*) (long)) xmalloc,
219 (void (*) (void *)) free);
221 _cpp_init_files (pfile);
223 _cpp_init_hashtable (pfile, table);
228 /* Free resources used by PFILE. Accessing PFILE after this function
229 returns leads to undefined behavior. Returns the error count. */
231 cpp_destroy (cpp_reader *pfile)
233 cpp_context *context, *contextn;
234 tokenrun *run, *runn;
236 free (pfile->op_stack);
238 while (CPP_BUFFER (pfile) != NULL)
239 _cpp_pop_buffer (pfile);
242 free (pfile->out.base);
244 if (pfile->macro_buffer)
246 free (pfile->macro_buffer);
247 pfile->macro_buffer = NULL;
248 pfile->macro_buffer_len = 0;
252 deps_free (pfile->deps);
253 obstack_free (&pfile->buffer_ob, 0);
255 _cpp_destroy_hashtable (pfile);
256 _cpp_cleanup_files (pfile);
257 _cpp_destroy_iconv (pfile);
259 _cpp_free_buff (pfile->a_buff);
260 _cpp_free_buff (pfile->u_buff);
261 _cpp_free_buff (pfile->free_buffs);
263 for (run = &pfile->base_run; run; run = runn)
267 if (run != &pfile->base_run)
271 for (context = pfile->base_context.next; context; context = contextn)
273 contextn = context->next;
280 /* This structure defines one built-in identifier. A node will be
281 entered in the hash table under the name NAME, with value VALUE.
283 There are two tables of these. builtin_array holds all the
284 "builtin" macros: these are handled by builtin_macro() in
285 macro.c. Builtin is somewhat of a misnomer -- the property of
286 interest is that these macros require special code to compute their
287 expansions. The value is a "builtin_type" enumerator.
289 operator_array holds the C++ named operators. These are keywords
290 which act as aliases for punctuators. In C++, they cannot be
291 altered through #define, and #if recognizes them as operators. In
292 C, these are not entered into the hash table at all (but see
293 <iso646.h>). The value is a token-type enumerator. */
298 unsigned short value;
301 #define B(n, t) { DSC(n), t }
302 static const struct builtin builtin_array[] =
304 B("__TIMESTAMP__", BT_TIMESTAMP),
305 B("__TIME__", BT_TIME),
306 B("__DATE__", BT_DATE),
307 B("__FILE__", BT_FILE),
308 B("__BASE_FILE__", BT_BASE_FILE),
309 B("__LINE__", BT_SPECLINE),
310 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
311 B("__COUNTER__", BT_COUNTER),
312 /* Keep builtins not used for -traditional-cpp at the end, and
313 update init_builtins() if any more are added. */
314 B("_Pragma", BT_PRAGMA),
315 B("__STDC__", BT_STDC),
318 static const struct builtin operator_array[] =
320 B("and", CPP_AND_AND),
321 B("and_eq", CPP_AND_EQ),
322 B("bitand", CPP_AND),
324 B("compl", CPP_COMPL),
326 B("not_eq", CPP_NOT_EQ),
328 B("or_eq", CPP_OR_EQ),
330 B("xor_eq", CPP_XOR_EQ)
334 /* Mark the C++ named operators in the hash table. */
336 mark_named_operators (cpp_reader *pfile)
338 const struct builtin *b;
340 for (b = operator_array;
341 b < (operator_array + ARRAY_SIZE (operator_array));
344 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
345 hp->flags |= NODE_OPERATOR;
346 hp->is_directive = 0;
347 hp->directive_index = b->value;
352 cpp_init_special_builtins (cpp_reader *pfile)
354 const struct builtin *b;
355 size_t n = ARRAY_SIZE (builtin_array);
357 if (CPP_OPTION (pfile, traditional))
359 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
360 || CPP_OPTION (pfile, std))
363 for (b = builtin_array; b < builtin_array + n; b++)
365 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
367 hp->flags |= NODE_BUILTIN | NODE_WARN;
368 hp->value.builtin = (enum builtin_type) b->value;
372 /* Read the builtins table above and enter them, and language-specific
373 macros, into the hash table. HOSTED is true if this is a hosted
376 cpp_init_builtins (cpp_reader *pfile, int hosted)
378 cpp_init_special_builtins (pfile);
380 if (!CPP_OPTION (pfile, traditional)
381 && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
382 || CPP_OPTION (pfile, std)))
383 _cpp_define_builtin (pfile, "__STDC__ 1");
385 if (CPP_OPTION (pfile, cplusplus))
386 _cpp_define_builtin (pfile, "__cplusplus 1");
387 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
388 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
389 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
390 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
391 else if (CPP_OPTION (pfile, c99))
392 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
395 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
397 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
399 if (CPP_OPTION (pfile, objc))
400 _cpp_define_builtin (pfile, "__OBJC__ 1");
403 /* Sanity-checks are dependent on command-line options, so it is
404 called as a subroutine of cpp_read_main_file (). */
406 static void sanity_checks (cpp_reader *);
407 static void sanity_checks (cpp_reader *pfile)
410 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
412 /* Sanity checks for assumptions about CPP arithmetic and target
413 type precisions made by cpplib. */
416 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
418 if (CPP_OPTION (pfile, precision) > max_precision)
419 cpp_error (pfile, CPP_DL_ICE,
420 "preprocessor arithmetic has maximum precision of %lu bits;"
421 " target requires %lu bits",
422 (unsigned long) max_precision,
423 (unsigned long) CPP_OPTION (pfile, precision));
425 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
426 cpp_error (pfile, CPP_DL_ICE,
427 "CPP arithmetic must be at least as precise as a target int");
429 if (CPP_OPTION (pfile, char_precision) < 8)
430 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
432 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
433 cpp_error (pfile, CPP_DL_ICE,
434 "target wchar_t is narrower than target char");
436 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
437 cpp_error (pfile, CPP_DL_ICE,
438 "target int is narrower than target char");
440 /* This is assumed in eval_token() and could be fixed if necessary. */
441 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
442 cpp_error (pfile, CPP_DL_ICE,
443 "CPP half-integer narrower than CPP character");
445 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
446 cpp_error (pfile, CPP_DL_ICE,
447 "CPP on this host cannot handle wide character constants over"
448 " %lu bits, but the target requires %lu bits",
449 (unsigned long) BITS_PER_CPPCHAR_T,
450 (unsigned long) CPP_OPTION (pfile, wchar_precision));
453 # define sanity_checks(PFILE)
456 /* This is called after options have been parsed, and partially
459 cpp_post_options (cpp_reader *pfile)
461 sanity_checks (pfile);
463 post_options (pfile);
465 /* Mark named operators before handling command line macros. */
466 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
467 mark_named_operators (pfile);
470 /* Setup for processing input from the file named FNAME, or stdin if
471 it is the empty string. Return the original filename
472 on success (e.g. foo.i->foo.c), or NULL on failure. */
474 cpp_read_main_file (cpp_reader *pfile, const char *fname)
476 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
479 pfile->deps = deps_init ();
481 /* Set the default target (if there is none already). */
482 deps_add_default_target (pfile->deps, fname);
486 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
487 if (_cpp_find_failed (pfile->main_file))
490 _cpp_stack_file (pfile, pfile->main_file, false);
492 /* For foo.i, read the original filename foo.c now, for the benefit
493 of the front ends. */
494 if (CPP_OPTION (pfile, preprocessed))
496 read_original_filename (pfile);
497 fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
502 /* For preprocessed files, if the first tokens are of the form # NUM.
503 handle the directive so we know the original file name. This will
504 generate file_change callbacks, which the front ends must handle
505 appropriately given their state of initialization. */
507 read_original_filename (cpp_reader *pfile)
509 const cpp_token *token, *token1;
511 /* Lex ahead; if the first tokens are of the form # NUM, then
512 process the directive, otherwise back up. */
513 token = _cpp_lex_direct (pfile);
514 if (token->type == CPP_HASH)
516 pfile->state.in_directive = 1;
517 token1 = _cpp_lex_direct (pfile);
518 _cpp_backup_tokens (pfile, 1);
519 pfile->state.in_directive = 0;
521 /* If it's a #line directive, handle it. */
522 if (token1->type == CPP_NUMBER)
524 _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
525 read_original_directory (pfile);
530 /* Backup as if nothing happened. */
531 _cpp_backup_tokens (pfile, 1);
534 /* For preprocessed files, if the tokens following the first filename
535 line is of the form # <line> "/path/name//", handle the
536 directive so we know the original current directory. */
538 read_original_directory (cpp_reader *pfile)
540 const cpp_token *hash, *token;
542 /* Lex ahead; if the first tokens are of the form # NUM, then
543 process the directive, otherwise back up. */
544 hash = _cpp_lex_direct (pfile);
545 if (hash->type != CPP_HASH)
547 _cpp_backup_tokens (pfile, 1);
551 token = _cpp_lex_direct (pfile);
553 if (token->type != CPP_NUMBER)
555 _cpp_backup_tokens (pfile, 2);
559 token = _cpp_lex_direct (pfile);
561 if (token->type != CPP_STRING
562 || ! (token->val.str.len >= 5
563 && token->val.str.text[token->val.str.len-2] == '/'
564 && token->val.str.text[token->val.str.len-3] == '/'))
566 _cpp_backup_tokens (pfile, 3);
570 if (pfile->cb.dir_change)
572 char *debugdir = (char *) alloca (token->val.str.len - 3);
574 memcpy (debugdir, (const char *) token->val.str.text + 1,
575 token->val.str.len - 4);
576 debugdir[token->val.str.len - 4] = '\0';
578 pfile->cb.dir_change (pfile, debugdir);
582 /* This is called at the end of preprocessing. It pops the last
583 buffer and writes dependency output, and returns the number of
586 Maybe it should also reset state, such that you could call
587 cpp_start_read with a new filename to restart processing. */
589 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
591 /* Warn about unused macros before popping the final buffer. */
592 if (CPP_OPTION (pfile, warn_unused_macros))
593 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
595 /* lex.c leaves the final buffer on the stack. This it so that
596 it returns an unending stream of CPP_EOFs to the client. If we
597 popped the buffer, we'd dereference a NULL buffer pointer and
598 segfault. It's nice to allow the client to do worry-free excess
599 cpp_get_token calls. */
600 while (pfile->buffer)
601 _cpp_pop_buffer (pfile);
603 /* Don't write the deps file if there are errors. */
604 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
605 && deps_stream && pfile->errors == 0)
607 deps_write (pfile->deps, deps_stream, 72);
609 if (CPP_OPTION (pfile, deps.phony_targets))
610 deps_phony_targets (pfile->deps, deps_stream);
613 /* Report on headers that could use multiple include guards. */
614 if (CPP_OPTION (pfile, print_include_names))
615 _cpp_report_missing_guards (pfile);
617 return pfile->errors;
621 post_options (cpp_reader *pfile)
623 /* -Wtraditional is not useful in C++ mode. */
624 if (CPP_OPTION (pfile, cplusplus))
625 CPP_OPTION (pfile, warn_traditional) = 0;
627 /* Permanently disable macro expansion if we are rescanning
628 preprocessed text. Read preprocesed source in ISO mode. */
629 if (CPP_OPTION (pfile, preprocessed))
631 if (!CPP_OPTION (pfile, directives_only))
632 pfile->state.prevent_expansion = 1;
633 CPP_OPTION (pfile, traditional) = 0;
636 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
637 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
639 if (CPP_OPTION (pfile, traditional))
641 CPP_OPTION (pfile, cplusplus_comments) = 0;
643 /* Traditional CPP does not accurately track column information. */
644 CPP_OPTION (pfile, show_column) = 0;
645 CPP_OPTION (pfile, trigraphs) = 0;
646 CPP_OPTION (pfile, warn_trigraphs) = 0;