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. */
28 #include "localedir.h"
31 static void init_library (void);
32 static void mark_named_operators (cpp_reader *);
33 static void read_original_filename (cpp_reader *);
34 static void read_original_directory (cpp_reader *);
35 static void post_options (cpp_reader *);
37 /* If we have designated initializers (GCC >2.7) these tables can be
38 initialized, constant data. Otherwise, they have to be filled in at
40 #if HAVE_DESIGNATED_INITIALIZERS
42 #define init_trigraph_map() /* Nothing. */
43 #define TRIGRAPH_MAP \
44 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
47 #define s(p, v) [p] = v,
51 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
52 static void init_trigraph_map (void) { \
53 unsigned char *x = _cpp_trigraph_map;
56 #define s(p, v) x[p] = v;
61 s('=', '#') s(')', ']') s('!', '|')
62 s('(', '[') s('\'', '^') s('>', '}')
63 s('/', '\\') s('<', '{') s('-', '~')
70 /* A set of booleans indicating what CPP features each source language
76 char extended_numbers;
77 char extended_identifiers;
79 char cplusplus_comments;
83 static const struct lang_flags lang_defaults[] =
84 { /* c99 c++ xnum xid std // digr */
85 /* GNUC89 */ { 0, 0, 1, 0, 0, 1, 1 },
86 /* GNUC99 */ { 1, 0, 1, 0, 0, 1, 1 },
87 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0 },
88 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 1 },
89 /* STDC99 */ { 1, 0, 1, 0, 1, 1, 1 },
90 /* GNUCXX */ { 0, 1, 1, 0, 0, 1, 1 },
91 /* CXX98 */ { 0, 1, 1, 0, 1, 1, 1 },
92 /* ASM */ { 0, 0, 1, 0, 0, 1, 0 }
93 /* xid should be 1 for GNUC99, STDC99, GNUCXX and CXX98 when no
94 longer experimental (when all uses of identifiers in the compiler
95 have been audited for correct handling of extended
99 /* Sets internal flags correctly for a given language. */
101 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
103 const struct lang_flags *l = &lang_defaults[(int) lang];
105 CPP_OPTION (pfile, lang) = lang;
107 CPP_OPTION (pfile, c99) = l->c99;
108 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
109 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
110 CPP_OPTION (pfile, extended_identifiers) = l->extended_identifiers;
111 CPP_OPTION (pfile, std) = l->std;
112 CPP_OPTION (pfile, trigraphs) = l->std;
113 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
114 CPP_OPTION (pfile, digraphs) = l->digraphs;
117 /* Initialize library global state. */
121 static int initialized = 0;
127 /* Set up the trigraph map. This doesn't need to do anything if
128 we were compiled with a compiler that supports C99 designated
130 init_trigraph_map ();
133 (void) bindtextdomain (PACKAGE, LOCALEDIR);
138 /* Initialize a cpp_reader structure. */
140 cpp_create_reader (enum c_lang lang, hash_table *table,
141 struct line_maps *line_table)
145 /* Initialize this instance of the library if it hasn't been already. */
148 pfile = XCNEW (cpp_reader);
150 cpp_set_lang (pfile, lang);
151 CPP_OPTION (pfile, warn_multichar) = 1;
152 CPP_OPTION (pfile, discard_comments) = 1;
153 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
154 CPP_OPTION (pfile, show_column) = 1;
155 CPP_OPTION (pfile, tabstop) = 8;
156 CPP_OPTION (pfile, operator_names) = 1;
157 CPP_OPTION (pfile, warn_trigraphs) = 2;
158 CPP_OPTION (pfile, warn_endif_labels) = 1;
159 CPP_OPTION (pfile, warn_deprecated) = 1;
160 CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
161 CPP_OPTION (pfile, dollars_in_ident) = 1;
162 CPP_OPTION (pfile, warn_dollars) = 1;
163 CPP_OPTION (pfile, warn_variadic_macros) = 1;
164 CPP_OPTION (pfile, warn_normalize) = normalized_C;
166 /* Default CPP arithmetic to something sensible for the host for the
167 benefit of dumb users like fix-header. */
168 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
169 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
170 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
171 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
172 CPP_OPTION (pfile, unsigned_char) = 0;
173 CPP_OPTION (pfile, unsigned_wchar) = 1;
174 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
176 /* Default to no charset conversion. */
177 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
178 CPP_OPTION (pfile, wide_charset) = 0;
180 /* Default the input character set to UTF-8. */
181 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
184 CPP_OPTION (pfile, preproc_asm) = 1;
185 CPP_OPTION (pfile, pedantic_parse_number) = 0;
186 CPP_OPTION (pfile, obj_ext) = NULL;
188 /* A fake empty "directory" used as the starting point for files
189 looked up without a search path. Name cannot be '/' because we
190 don't want to prepend anything at all to filenames using it. All
191 other entries are correct zero-initialized. */
192 pfile->no_search_path.name = (char *) "";
194 /* Initialize the line map. */
195 pfile->line_table = line_table;
197 /* Initialize lexer state. */
198 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
200 /* Set up static tokens. */
201 pfile->avoid_paste.type = CPP_PADDING;
202 pfile->avoid_paste.val.source = NULL;
203 pfile->eof.type = CPP_EOF;
204 pfile->eof.flags = 0;
206 /* Create a token buffer for the lexer. */
207 _cpp_init_tokenrun (&pfile->base_run, 250);
208 pfile->cur_run = &pfile->base_run;
209 pfile->cur_token = pfile->base_run.base;
211 /* Initialize the base context. */
212 pfile->context = &pfile->base_context;
213 pfile->base_context.macro = 0;
214 pfile->base_context.prev = pfile->base_context.next = 0;
216 /* Aligned and unaligned storage. */
217 pfile->a_buff = _cpp_get_buff (pfile, 0);
218 pfile->u_buff = _cpp_get_buff (pfile, 0);
220 /* The expression parser stack. */
221 _cpp_expand_op_stack (pfile);
223 /* Initialize the buffer obstack. */
224 _obstack_begin (&pfile->buffer_ob, 0, 0,
225 (void *(*) (long)) xmalloc,
226 (void (*) (void *)) free);
228 _cpp_init_files (pfile);
230 _cpp_init_hashtable (pfile, table);
235 /* Free resources used by PFILE. Accessing PFILE after this function
236 returns leads to undefined behavior. Returns the error count. */
238 cpp_destroy (cpp_reader *pfile)
240 cpp_context *context, *contextn;
241 tokenrun *run, *runn;
243 free (pfile->op_stack);
245 while (CPP_BUFFER (pfile) != NULL)
246 _cpp_pop_buffer (pfile);
249 free (pfile->out.base);
251 if (pfile->macro_buffer)
253 free (pfile->macro_buffer);
254 pfile->macro_buffer = NULL;
255 pfile->macro_buffer_len = 0;
259 deps_free (pfile->deps);
260 obstack_free (&pfile->buffer_ob, 0);
262 _cpp_destroy_hashtable (pfile);
263 _cpp_cleanup_files (pfile);
264 _cpp_destroy_iconv (pfile);
266 _cpp_free_buff (pfile->a_buff);
267 _cpp_free_buff (pfile->u_buff);
268 _cpp_free_buff (pfile->free_buffs);
270 for (run = &pfile->base_run; run; run = runn)
274 if (run != &pfile->base_run)
278 for (context = pfile->base_context.next; context; context = contextn)
280 contextn = context->next;
287 /* This structure defines one built-in identifier. A node will be
288 entered in the hash table under the name NAME, with value VALUE.
290 There are two tables of these. builtin_array holds all the
291 "builtin" macros: these are handled by builtin_macro() in
292 macro.c. Builtin is somewhat of a misnomer -- the property of
293 interest is that these macros require special code to compute their
294 expansions. The value is a "builtin_type" enumerator.
296 operator_array holds the C++ named operators. These are keywords
297 which act as aliases for punctuators. In C++, they cannot be
298 altered through #define, and #if recognizes them as operators. In
299 C, these are not entered into the hash table at all (but see
300 <iso646.h>). The value is a token-type enumerator. */
305 unsigned short value;
308 #define B(n, t) { DSC(n), t }
309 static const struct builtin builtin_array[] =
311 B("__TIME__", BT_TIME),
312 B("__DATE__", BT_DATE),
313 B("__FILE__", BT_FILE),
314 B("__BASE_FILE__", BT_BASE_FILE),
315 B("__LINE__", BT_SPECLINE),
316 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
317 /* Keep builtins not used for -traditional-cpp at the end, and
318 update init_builtins() if any more are added. */
319 B("_Pragma", BT_PRAGMA),
320 B("__STDC__", BT_STDC),
323 static const struct builtin operator_array[] =
325 B("and", CPP_AND_AND),
326 B("and_eq", CPP_AND_EQ),
327 B("bitand", CPP_AND),
329 B("compl", CPP_COMPL),
331 B("not_eq", CPP_NOT_EQ),
333 B("or_eq", CPP_OR_EQ),
335 B("xor_eq", CPP_XOR_EQ)
339 /* Mark the C++ named operators in the hash table. */
341 mark_named_operators (cpp_reader *pfile)
343 const struct builtin *b;
345 for (b = operator_array;
346 b < (operator_array + ARRAY_SIZE (operator_array));
349 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
350 hp->flags |= NODE_OPERATOR;
351 hp->is_directive = 0;
352 hp->directive_index = b->value;
356 /* Read the builtins table above and enter them, and language-specific
357 macros, into the hash table. HOSTED is true if this is a hosted
360 cpp_init_builtins (cpp_reader *pfile, int hosted)
362 const struct builtin *b;
363 size_t n = ARRAY_SIZE (builtin_array);
365 if (CPP_OPTION (pfile, traditional))
367 else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
368 || CPP_OPTION (pfile, std))
371 _cpp_define_builtin (pfile, "__STDC__ 1");
374 for (b = builtin_array; b < builtin_array + n; b++)
376 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
378 hp->flags |= NODE_BUILTIN | NODE_WARN;
379 hp->value.builtin = (enum builtin_type) b->value;
382 if (CPP_OPTION (pfile, cplusplus))
383 _cpp_define_builtin (pfile, "__cplusplus 1");
384 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
385 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
386 else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
387 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
388 else if (CPP_OPTION (pfile, c99))
389 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
392 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
394 _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
396 if (CPP_OPTION (pfile, objc))
397 _cpp_define_builtin (pfile, "__OBJC__ 1");
400 /* Sanity-checks are dependent on command-line options, so it is
401 called as a subroutine of cpp_read_main_file (). */
403 static void sanity_checks (cpp_reader *);
404 static void sanity_checks (cpp_reader *pfile)
407 size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
409 /* Sanity checks for assumptions about CPP arithmetic and target
410 type precisions made by cpplib. */
413 cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
415 if (CPP_OPTION (pfile, precision) > max_precision)
416 cpp_error (pfile, CPP_DL_ICE,
417 "preprocessor arithmetic has maximum precision of %lu bits;"
418 " target requires %lu bits",
419 (unsigned long) max_precision,
420 (unsigned long) CPP_OPTION (pfile, precision));
422 if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
423 cpp_error (pfile, CPP_DL_ICE,
424 "CPP arithmetic must be at least as precise as a target int");
426 if (CPP_OPTION (pfile, char_precision) < 8)
427 cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
429 if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
430 cpp_error (pfile, CPP_DL_ICE,
431 "target wchar_t is narrower than target char");
433 if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
434 cpp_error (pfile, CPP_DL_ICE,
435 "target int is narrower than target char");
437 /* This is assumed in eval_token() and could be fixed if necessary. */
438 if (sizeof (cppchar_t) > sizeof (cpp_num_part))
439 cpp_error (pfile, CPP_DL_ICE,
440 "CPP half-integer narrower than CPP character");
442 if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
443 cpp_error (pfile, CPP_DL_ICE,
444 "CPP on this host cannot handle wide character constants over"
445 " %lu bits, but the target requires %lu bits",
446 (unsigned long) BITS_PER_CPPCHAR_T,
447 (unsigned long) CPP_OPTION (pfile, wchar_precision));
450 # define sanity_checks(PFILE)
453 /* This is called after options have been parsed, and partially
456 cpp_post_options (cpp_reader *pfile)
458 sanity_checks (pfile);
460 post_options (pfile);
462 /* Mark named operators before handling command line macros. */
463 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
464 mark_named_operators (pfile);
467 /* Setup for processing input from the file named FNAME, or stdin if
468 it is the empty string. Return the original filename
469 on success (e.g. foo.i->foo.c), or NULL on failure. */
471 cpp_read_main_file (cpp_reader *pfile, const char *fname)
473 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
476 pfile->deps = deps_init ();
478 /* Set the default target (if there is none already). */
479 deps_add_default_target (pfile, fname);
483 = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
484 if (_cpp_find_failed (pfile->main_file))
487 _cpp_stack_file (pfile, pfile->main_file, false);
489 /* For foo.i, read the original filename foo.c now, for the benefit
490 of the front ends. */
491 if (CPP_OPTION (pfile, preprocessed))
493 read_original_filename (pfile);
494 fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
499 /* For preprocessed files, if the first tokens are of the form # NUM.
500 handle the directive so we know the original file name. This will
501 generate file_change callbacks, which the front ends must handle
502 appropriately given their state of initialization. */
504 read_original_filename (cpp_reader *pfile)
506 const cpp_token *token, *token1;
508 /* Lex ahead; if the first tokens are of the form # NUM, then
509 process the directive, otherwise back up. */
510 token = _cpp_lex_direct (pfile);
511 if (token->type == CPP_HASH)
513 pfile->state.in_directive = 1;
514 token1 = _cpp_lex_direct (pfile);
515 _cpp_backup_tokens (pfile, 1);
516 pfile->state.in_directive = 0;
518 /* If it's a #line directive, handle it. */
519 if (token1->type == CPP_NUMBER)
521 _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
522 read_original_directory (pfile);
527 /* Backup as if nothing happened. */
528 _cpp_backup_tokens (pfile, 1);
531 /* For preprocessed files, if the tokens following the first filename
532 line is of the form # <line> "/path/name//", handle the
533 directive so we know the original current directory. */
535 read_original_directory (cpp_reader *pfile)
537 const cpp_token *hash, *token;
539 /* Lex ahead; if the first tokens are of the form # NUM, then
540 process the directive, otherwise back up. */
541 hash = _cpp_lex_direct (pfile);
542 if (hash->type != CPP_HASH)
544 _cpp_backup_tokens (pfile, 1);
548 token = _cpp_lex_direct (pfile);
550 if (token->type != CPP_NUMBER)
552 _cpp_backup_tokens (pfile, 2);
556 token = _cpp_lex_direct (pfile);
558 if (token->type != CPP_STRING
559 || ! (token->val.str.len >= 5
560 && token->val.str.text[token->val.str.len-2] == '/'
561 && token->val.str.text[token->val.str.len-3] == '/'))
563 _cpp_backup_tokens (pfile, 3);
567 if (pfile->cb.dir_change)
569 char *debugdir = (char *) alloca (token->val.str.len - 3);
571 memcpy (debugdir, (const char *) token->val.str.text + 1,
572 token->val.str.len - 4);
573 debugdir[token->val.str.len - 4] = '\0';
575 pfile->cb.dir_change (pfile, debugdir);
579 /* This is called at the end of preprocessing. It pops the last
580 buffer and writes dependency output, and returns the number of
583 Maybe it should also reset state, such that you could call
584 cpp_start_read with a new filename to restart processing. */
586 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
588 /* Warn about unused macros before popping the final buffer. */
589 if (CPP_OPTION (pfile, warn_unused_macros))
590 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
592 /* lex.c leaves the final buffer on the stack. This it so that
593 it returns an unending stream of CPP_EOFs to the client. If we
594 popped the buffer, we'd dereference a NULL buffer pointer and
595 segfault. It's nice to allow the client to do worry-free excess
596 cpp_get_token calls. */
597 while (pfile->buffer)
598 _cpp_pop_buffer (pfile);
600 /* Don't write the deps file if there are errors. */
601 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
602 && deps_stream && pfile->errors == 0)
604 deps_write (pfile->deps, deps_stream, 72);
606 if (CPP_OPTION (pfile, deps.phony_targets))
607 deps_phony_targets (pfile->deps, deps_stream);
610 /* Report on headers that could use multiple include guards. */
611 if (CPP_OPTION (pfile, print_include_names))
612 _cpp_report_missing_guards (pfile);
614 return pfile->errors;
618 post_options (cpp_reader *pfile)
620 /* -Wtraditional is not useful in C++ mode. */
621 if (CPP_OPTION (pfile, cplusplus))
622 CPP_OPTION (pfile, warn_traditional) = 0;
624 /* Permanently disable macro expansion if we are rescanning
625 preprocessed text. Read preprocesed source in ISO mode. */
626 if (CPP_OPTION (pfile, preprocessed))
628 pfile->state.prevent_expansion = 1;
629 CPP_OPTION (pfile, traditional) = 0;
632 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
633 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
635 if (CPP_OPTION (pfile, traditional))
637 CPP_OPTION (pfile, cplusplus_comments) = 0;
639 /* Traditional CPP does not accurately track column information. */
640 CPP_OPTION (pfile, show_column) = 0;
641 CPP_OPTION (pfile, trigraphs) = 0;
642 CPP_OPTION (pfile, warn_trigraphs) = 0;