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. */
30 static void init_library (void);
31 static void mark_named_operators (cpp_reader *);
32 static void read_original_filename (cpp_reader *);
33 static void read_original_directory (cpp_reader *);
34 static void post_options (cpp_reader *);
36 /* If we have designated initializers (GCC >2.7) these tables can be
37 initialized, constant data. Otherwise, they have to be filled in at
39 #if HAVE_DESIGNATED_INITIALIZERS
41 #define init_trigraph_map() /* Nothing. */
42 #define TRIGRAPH_MAP \
43 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
46 #define s(p, v) [p] = v,
50 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
51 static void init_trigraph_map (void) { \
52 unsigned char *x = _cpp_trigraph_map;
55 #define s(p, v) x[p] = v;
60 s('=', '#') s(')', ']') s('!', '|')
61 s('(', '[') s('\'', '^') s('>', '}')
62 s('/', '\\') s('<', '{') s('-', '~')
69 /* A set of booleans indicating what CPP features each source language
75 char extended_numbers;
77 char cplusplus_comments;
81 static const struct lang_flags lang_defaults[] =
82 { /* c99 c++ xnum std // digr */
83 /* GNUC89 */ { 0, 0, 1, 0, 1, 1 },
84 /* GNUC99 */ { 1, 0, 1, 0, 1, 1 },
85 /* STDC89 */ { 0, 0, 0, 1, 0, 0 },
86 /* STDC94 */ { 0, 0, 0, 1, 0, 1 },
87 /* STDC99 */ { 1, 0, 1, 1, 1, 1 },
88 /* GNUCXX */ { 0, 1, 1, 0, 1, 1 },
89 /* CXX98 */ { 0, 1, 1, 1, 1, 1 },
90 /* ASM */ { 0, 0, 1, 0, 1, 0 }
93 /* Sets internal flags correctly for a given language. */
95 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
97 const struct lang_flags *l = &lang_defaults[(int) lang];
99 CPP_OPTION (pfile, lang) = lang;
101 CPP_OPTION (pfile, c99) = l->c99;
102 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
103 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
104 CPP_OPTION (pfile, std) = l->std;
105 CPP_OPTION (pfile, trigraphs) = l->std;
106 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
107 CPP_OPTION (pfile, digraphs) = l->digraphs;
110 /* Initialize library global state. */
114 static int initialized = 0;
120 /* Set up the trigraph map. This doesn't need to do anything if
121 we were compiled with a compiler that supports C99 designated
123 init_trigraph_map ();
127 /* Initialize a cpp_reader structure. */
129 cpp_create_reader (enum c_lang lang, hash_table *table)
133 /* Initialize this instance of the library if it hasn't been already. */
136 pfile = xcalloc (1, sizeof (cpp_reader));
138 cpp_set_lang (pfile, lang);
139 CPP_OPTION (pfile, warn_multichar) = 1;
140 CPP_OPTION (pfile, discard_comments) = 1;
141 CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
142 CPP_OPTION (pfile, show_column) = 1;
143 CPP_OPTION (pfile, tabstop) = 8;
144 CPP_OPTION (pfile, operator_names) = 1;
145 CPP_OPTION (pfile, warn_trigraphs) = 2;
146 CPP_OPTION (pfile, warn_endif_labels) = 1;
147 CPP_OPTION (pfile, warn_deprecated) = 1;
148 CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
149 CPP_OPTION (pfile, dollars_in_ident) = 1;
150 CPP_OPTION (pfile, warn_dollars) = 1;
152 /* Default CPP arithmetic to something sensible for the host for the
153 benefit of dumb users like fix-header. */
154 CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
155 CPP_OPTION (pfile, char_precision) = CHAR_BIT;
156 CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
157 CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
158 CPP_OPTION (pfile, unsigned_char) = 0;
159 CPP_OPTION (pfile, unsigned_wchar) = 1;
160 CPP_OPTION (pfile, bytes_big_endian) = 1; /* does not matter */
162 /* Default to locale/UTF-8. */
163 CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
164 CPP_OPTION (pfile, wide_charset) = 0;
165 CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
167 /* A fake empty "directory" used as the starting point for files
168 looked up without a search path. Name cannot be '/' because we
169 don't want to prepend anything at all to filenames using it. All
170 other entries are correct zero-initialized. */
171 pfile->no_search_path.name = (char *) "";
173 /* Initialize the line map. Start at logical line 1, so we can use
174 a line number of zero for special states. */
175 linemap_init (&pfile->line_maps);
178 /* Initialize lexer state. */
179 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
181 /* Set up static tokens. */
182 pfile->avoid_paste.type = CPP_PADDING;
183 pfile->avoid_paste.val.source = NULL;
184 pfile->eof.type = CPP_EOF;
185 pfile->eof.flags = 0;
187 /* Create a token buffer for the lexer. */
188 _cpp_init_tokenrun (&pfile->base_run, 250);
189 pfile->cur_run = &pfile->base_run;
190 pfile->cur_token = pfile->base_run.base;
192 /* Initialize the base context. */
193 pfile->context = &pfile->base_context;
194 pfile->base_context.macro = 0;
195 pfile->base_context.prev = pfile->base_context.next = 0;
197 /* Aligned and unaligned storage. */
198 pfile->a_buff = _cpp_get_buff (pfile, 0);
199 pfile->u_buff = _cpp_get_buff (pfile, 0);
201 /* The expression parser stack. */
202 _cpp_expand_op_stack (pfile);
204 /* Initialize the buffer obstack. */
205 _obstack_begin (&pfile->buffer_ob, 0, 0,
206 (void *(*) (long)) xmalloc,
207 (void (*) (void *)) free);
209 _cpp_init_files (pfile);
211 _cpp_init_hashtable (pfile, table);
216 /* Free resources used by PFILE. Accessing PFILE after this function
217 returns leads to undefined behavior. Returns the error count. */
219 cpp_destroy (cpp_reader *pfile)
221 cpp_context *context, *contextn;
222 tokenrun *run, *runn;
224 free (pfile->op_stack);
226 while (CPP_BUFFER (pfile) != NULL)
227 _cpp_pop_buffer (pfile);
230 free (pfile->out.base);
232 if (pfile->macro_buffer)
234 free (pfile->macro_buffer);
235 pfile->macro_buffer = NULL;
236 pfile->macro_buffer_len = 0;
240 deps_free (pfile->deps);
241 obstack_free (&pfile->buffer_ob, 0);
243 _cpp_destroy_hashtable (pfile);
244 _cpp_cleanup_files (pfile);
245 _cpp_destroy_iconv (pfile);
247 _cpp_free_buff (pfile->a_buff);
248 _cpp_free_buff (pfile->u_buff);
249 _cpp_free_buff (pfile->free_buffs);
251 for (run = &pfile->base_run; run; run = runn)
255 if (run != &pfile->base_run)
259 for (context = pfile->base_context.next; context; context = contextn)
261 contextn = context->next;
265 linemap_free (&pfile->line_maps);
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, 0);
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);
484 fname = pfile->map->to_file;
489 /* For preprocessed files, if the first tokens are of the form # NUM.
490 handle the directive so we know the original file name. This will
491 generate file_change callbacks, which the front ends must handle
492 appropriately given their state of initialization. */
494 read_original_filename (cpp_reader *pfile)
496 const cpp_token *token, *token1;
498 /* Lex ahead; if the first tokens are of the form # NUM, then
499 process the directive, otherwise back up. */
500 token = _cpp_lex_direct (pfile);
501 if (token->type == CPP_HASH)
503 pfile->state.in_directive = 1;
504 token1 = _cpp_lex_direct (pfile);
505 _cpp_backup_tokens (pfile, 1);
506 pfile->state.in_directive = 0;
508 /* If it's a #line directive, handle it. */
509 if (token1->type == CPP_NUMBER)
511 _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
512 read_original_directory (pfile);
517 /* Backup as if nothing happened. */
518 _cpp_backup_tokens (pfile, 1);
521 /* For preprocessed files, if the tokens following the first filename
522 line is of the form # <line> "/path/name//", handle the
523 directive so we know the original current directory. */
525 read_original_directory (cpp_reader *pfile)
527 const cpp_token *hash, *token;
529 /* Lex ahead; if the first tokens are of the form # NUM, then
530 process the directive, otherwise back up. */
531 hash = _cpp_lex_direct (pfile);
532 if (hash->type != CPP_HASH)
534 _cpp_backup_tokens (pfile, 1);
538 token = _cpp_lex_direct (pfile);
540 if (token->type != CPP_NUMBER)
542 _cpp_backup_tokens (pfile, 2);
546 token = _cpp_lex_direct (pfile);
548 if (token->type != CPP_STRING
549 || ! (token->val.str.len >= 5
550 && token->val.str.text[token->val.str.len-2] == '/'
551 && token->val.str.text[token->val.str.len-3] == '/'))
553 _cpp_backup_tokens (pfile, 3);
557 if (pfile->cb.dir_change)
559 char *debugdir = alloca (token->val.str.len - 3);
561 memcpy (debugdir, (const char *) token->val.str.text + 1,
562 token->val.str.len - 4);
563 debugdir[token->val.str.len - 4] = '\0';
565 pfile->cb.dir_change (pfile, debugdir);
569 /* This is called at the end of preprocessing. It pops the last
570 buffer and writes dependency output, and returns the number of
573 Maybe it should also reset state, such that you could call
574 cpp_start_read with a new filename to restart processing. */
576 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
578 /* Warn about unused macros before popping the final buffer. */
579 if (CPP_OPTION (pfile, warn_unused_macros))
580 cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
582 /* cpplex.c leaves the final buffer on the stack. This it so that
583 it returns an unending stream of CPP_EOFs to the client. If we
584 popped the buffer, we'd dereference a NULL buffer pointer and
585 segfault. It's nice to allow the client to do worry-free excess
586 cpp_get_token calls. */
587 while (pfile->buffer)
588 _cpp_pop_buffer (pfile);
590 /* Don't write the deps file if there are errors. */
591 if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
592 && deps_stream && pfile->errors == 0)
594 deps_write (pfile->deps, deps_stream, 72);
596 if (CPP_OPTION (pfile, deps.phony_targets))
597 deps_phony_targets (pfile->deps, deps_stream);
600 /* Report on headers that could use multiple include guards. */
601 if (CPP_OPTION (pfile, print_include_names))
602 _cpp_report_missing_guards (pfile);
604 return pfile->errors;
608 post_options (cpp_reader *pfile)
610 /* -Wtraditional is not useful in C++ mode. */
611 if (CPP_OPTION (pfile, cplusplus))
612 CPP_OPTION (pfile, warn_traditional) = 0;
614 /* Permanently disable macro expansion if we are rescanning
615 preprocessed text. Read preprocesed source in ISO mode. */
616 if (CPP_OPTION (pfile, preprocessed))
618 pfile->state.prevent_expansion = 1;
619 CPP_OPTION (pfile, traditional) = 0;
622 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
623 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
625 if (CPP_OPTION (pfile, traditional))
627 CPP_OPTION (pfile, cplusplus_comments) = 0;
629 /* Traditional CPP does not accurately track column information. */
630 CPP_OPTION (pfile, show_column) = 0;
631 CPP_OPTION (pfile, trigraphs) = 0;
632 CPP_OPTION (pfile, warn_trigraphs) = 0;