2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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. */
31 #include "cppdefault.h"
33 /* Predefined symbols, built-in macros, and the default include path. */
35 #ifndef GET_ENV_PATH_LIST
36 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
39 /* Windows does not natively support inodes, and neither does MSDOS.
40 Cygwin's emulation can generate non-unique inodes, so don't use it.
41 VMS has non-numeric inodes. */
43 #define INO_T_EQ(a, b) (!memcmp (&(a), &(b), sizeof (a)))
44 #elif (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
45 #define INO_T_EQ(a, b) 0
47 #define INO_T_EQ(a, b) ((a) == (b))
50 /* Internal structures and prototypes. */
52 /* A `struct pending_option' remembers one -D, -A, -U, -include, or
55 typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
58 struct pending_option *next;
60 cl_directive_handler handler;
63 /* The `pending' structure accumulates all the options that are not
64 actually processed until we hit cpp_start_read. It consists of
65 several lists, one for each type of option. We keep both head and
66 tail pointers for quick insertion. */
69 struct pending_option *directive_head, *directive_tail;
71 struct file_name_list *quote_head, *quote_tail;
72 struct file_name_list *brack_head, *brack_tail;
73 struct file_name_list *systm_head, *systm_tail;
74 struct file_name_list *after_head, *after_tail;
76 struct pending_option *imacros_head, *imacros_tail;
77 struct pending_option *include_head, *include_tail;
81 #define APPEND(pend, list, elt) \
82 do { if (!(pend)->list##_head) (pend)->list##_head = (elt); \
83 else (pend)->list##_tail->next = (elt); \
84 (pend)->list##_tail = (elt); \
87 #define APPEND(pend, list, elt) \
88 do { if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
89 else (pend)->list/**/_tail->next = (elt); \
90 (pend)->list/**/_tail = (elt); \
94 static void print_help PARAMS ((void));
95 static void path_include PARAMS ((cpp_reader *,
97 static void initialize_builtins PARAMS ((cpp_reader *));
98 static void append_include_chain PARAMS ((cpp_reader *,
100 struct file_name_list * remove_dup_dir PARAMS ((cpp_reader *,
101 struct file_name_list *));
102 struct file_name_list * remove_dup_dirs PARAMS ((cpp_reader *,
103 struct file_name_list *));
104 static void merge_include_chains PARAMS ((cpp_reader *));
105 static void do_includes PARAMS ((cpp_reader *,
106 struct pending_option *,
108 static void set_lang PARAMS ((cpp_reader *, enum c_lang));
109 static void initialize_dependency_output PARAMS ((cpp_reader *));
110 static void initialize_standard_includes PARAMS ((cpp_reader *));
111 static void new_pending_directive PARAMS ((struct cpp_pending *,
113 cl_directive_handler));
115 static int opt_comp PARAMS ((const void *, const void *));
117 static int parse_option PARAMS ((const char *));
119 /* Fourth argument to append_include_chain: chain to use. */
120 enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
122 /* If we have designated initializers (GCC >2.7) these tables can be
123 initialized, constant data. Otherwise, they have to be filled in at
125 #if HAVE_DESIGNATED_INITIALIZERS
127 #define init_IStable() /* Nothing. */
128 #define ISTABLE __extension__ const U_CHAR _cpp_IStable[UCHAR_MAX + 1] = {
130 #define init_trigraph_map() /* Nothing. */
131 #define TRIGRAPH_MAP \
132 __extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
135 #define s(p, v) [p] = v,
139 #define ISTABLE unsigned char _cpp_IStable[UCHAR_MAX + 1] = { 0 }; \
140 static void init_IStable PARAMS ((void)) { \
141 unsigned char *x = _cpp_IStable;
143 #define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
144 static void init_trigraph_map PARAMS ((void)) { \
145 unsigned char *x = _cpp_trigraph_map;
148 #define s(p, v) x[p] = v;
152 #define A(x) s(x, ISidnum|ISidstart)
153 #define N(x) s(x, ISidnum|ISnumstart)
154 #define H(x) s(x, IShspace|ISspace)
155 #define V(x) s(x, ISvspace|ISspace)
156 #define S(x) s(x, ISspace)
161 A('a') A('b') A('c') A('d') A('e') A('f') A('g') A('h') A('i')
162 A('j') A('k') A('l') A('m') A('n') A('o') A('p') A('q') A('r')
163 A('s') A('t') A('u') A('v') A('w') A('x') A('y') A('z')
165 A('A') A('B') A('C') A('D') A('E') A('F') A('G') A('H') A('I')
166 A('J') A('K') A('L') A('M') A('N') A('O') A('P') A('Q') A('R')
167 A('S') A('T') A('U') A('V') A('W') A('X') A('Y') A('Z')
169 N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0')
175 S('\0') S('\v') S('\f')
179 s('=', '#') s(')', ']') s('!', '|')
180 s('(', '[') s('\'', '^') s('>', '}')
181 s('/', '\\') s('<', '{') s('-', '~')
194 /* Given a colon-separated list of file names PATH,
195 add all the names to the search path for include files. */
198 path_include (pfile, list, path)
209 /* Find the end of this name. */
211 while (*q != 0 && *q != PATH_SEPARATOR) q++;
214 /* An empty name in the path stands for the current directory. */
215 name = (char *) xmalloc (2);
221 /* Otherwise use the directory that is named. */
222 name = (char *) xmalloc (q - p + 1);
223 memcpy (name, p, q - p);
227 append_include_chain (pfile, name, path, 0);
229 /* Advance past this name. */
237 /* Append DIR to include path PATH. DIR must be permanently allocated
240 append_include_chain (pfile, dir, path, cxx_aware)
246 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
247 struct file_name_list *new;
251 _cpp_simplify_pathname (dir);
254 /* Dirs that don't exist are silently ignored. */
256 cpp_notice_from_errno (pfile, dir);
257 else if (CPP_OPTION (pfile, verbose))
258 fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
262 if (!S_ISDIR (st.st_mode))
264 cpp_notice (pfile, "%s: Not a directory", dir);
269 if (len > pfile->max_include_len)
270 pfile->max_include_len = len;
272 new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
275 new->ino = st.st_ino;
276 new->dev = st.st_dev;
278 new->sysp = cxx_aware ? 1 : 2;
281 new->name_map = NULL;
287 case QUOTE: APPEND (pend, quote, new); break;
288 case BRACKET: APPEND (pend, brack, new); break;
289 case SYSTEM: APPEND (pend, systm, new); break;
290 case AFTER: APPEND (pend, after, new); break;
294 /* Handle a duplicated include path. PREV is the link in the chain
295 before the duplicate. The duplicate is removed from the chain and
296 freed. Returns PREV. */
297 struct file_name_list *
298 remove_dup_dir (pfile, prev)
300 struct file_name_list *prev;
302 struct file_name_list *cur = prev->next;
304 if (CPP_OPTION (pfile, verbose))
305 fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
307 prev->next = cur->next;
314 /* Remove duplicate directories from a chain. Returns the tail of the
315 chain, or NULL if the chain is empty. This algorithm is quadratic
316 in the number of -I switches, which is acceptable since there
317 aren't usually that many of them. */
318 struct file_name_list *
319 remove_dup_dirs (pfile, head)
321 struct file_name_list *head;
323 struct file_name_list *prev = NULL, *cur, *other;
325 for (cur = head; cur; cur = cur->next)
327 for (other = head; other != cur; other = other->next)
328 if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
330 cur = remove_dup_dir (pfile, prev);
339 /* Merge the four include chains together in the order quote, bracket,
340 system, after. Remove duplicate dirs (as determined by
341 INO_T_EQ()). The system_include and after_include chains are never
342 referred to again after this function; all access is through the
343 bracket_include path.
345 For the future: Check if the directory is empty (but
346 how?) and possibly preload the include hash. */
349 merge_include_chains (pfile)
352 struct file_name_list *quote, *brack, *systm, *qtail;
354 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
356 quote = pend->quote_head;
357 brack = pend->brack_head;
358 systm = pend->systm_head;
359 qtail = pend->quote_tail;
361 /* Paste together bracket, system, and after include chains. */
363 pend->systm_tail->next = pend->after_head;
365 systm = pend->after_head;
368 pend->brack_tail->next = systm;
372 /* This is a bit tricky. First we drop dupes from the quote-include
373 list. Then we drop dupes from the bracket-include list.
374 Finally, if qtail and brack are the same directory, we cut out
377 We can't just merge the lists and then uniquify them because
378 then we may lose directories from the <> search path that should
379 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
380 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
381 -Ibar -I- -Ifoo -Iquux. */
383 remove_dup_dirs (pfile, brack);
384 qtail = remove_dup_dirs (pfile, quote);
390 /* If brack == qtail, remove brack as it's simpler. */
391 if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
392 brack = remove_dup_dir (pfile, qtail);
397 CPP_OPTION (pfile, quote_include) = quote;
398 CPP_OPTION (pfile, bracket_include) = brack;
401 /* cpp_init initializes library global state. It might not need to do
402 anything depending on the platform and compiler, so we have a static
403 flag to make sure it gets called before cpp_reader_init. */
405 static int cpp_init_completed = 0;
411 /* For non-ASCII hosts, the cl_options array needs to be sorted at
413 qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
416 /* Set up the trigraph map and the IStable. These don't need to do
417 anything if we were compiled with a compiler that supports C99
418 designated initializers. */
419 init_trigraph_map ();
422 cpp_init_completed = 1;
425 /* Sets internal flags correctly for a given language, and defines
426 macros if necessary. */
428 set_lang (pfile, lang)
432 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
434 /* Default to zero. */
435 CPP_OPTION (pfile, lang_asm) = 0;
436 CPP_OPTION (pfile, objc) = 0;
437 CPP_OPTION (pfile, cplusplus) = 0;
443 CPP_OPTION (pfile, trigraphs) = 0;
444 CPP_OPTION (pfile, dollars_in_ident) = 1;
445 CPP_OPTION (pfile, cplusplus_comments) = 1;
446 CPP_OPTION (pfile, digraphs) = 1;
447 CPP_OPTION (pfile, c89) = 0;
448 CPP_OPTION (pfile, c99) = 1;
449 new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
452 CPP_OPTION (pfile, trigraphs) = 0;
453 CPP_OPTION (pfile, dollars_in_ident) = 1;
454 CPP_OPTION (pfile, cplusplus_comments) = 1;
455 CPP_OPTION (pfile, digraphs) = 1;
456 CPP_OPTION (pfile, c89) = 1;
457 CPP_OPTION (pfile, c99) = 0;
462 new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define);
464 CPP_OPTION (pfile, trigraphs) = 1;
465 CPP_OPTION (pfile, dollars_in_ident) = 0;
466 CPP_OPTION (pfile, cplusplus_comments) = 0;
467 CPP_OPTION (pfile, digraphs) = lang == CLK_STDC94;
468 CPP_OPTION (pfile, c89) = 1;
469 CPP_OPTION (pfile, c99) = 0;
470 new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
473 CPP_OPTION (pfile, trigraphs) = 1;
474 CPP_OPTION (pfile, dollars_in_ident) = 0;
475 CPP_OPTION (pfile, cplusplus_comments) = 1;
476 CPP_OPTION (pfile, digraphs) = 1;
477 CPP_OPTION (pfile, c89) = 0;
478 CPP_OPTION (pfile, c99) = 1;
479 new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
480 new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
485 new_pending_directive (pend, "__cplusplus", cpp_define);
486 CPP_OPTION (pfile, cplusplus) = 1;
488 CPP_OPTION (pfile, trigraphs) = 0;
489 CPP_OPTION (pfile, dollars_in_ident) = 1;
490 CPP_OPTION (pfile, cplusplus_comments) = 1;
491 CPP_OPTION (pfile, digraphs) = 1;
492 CPP_OPTION (pfile, c89) = 0;
493 CPP_OPTION (pfile, c99) = 0;
494 CPP_OPTION (pfile, objc) = 1;
495 new_pending_directive (pend, "__OBJC__", cpp_define);
501 CPP_OPTION (pfile, cplusplus) = 1;
502 CPP_OPTION (pfile, trigraphs) = lang == CLK_CXX98;
503 CPP_OPTION (pfile, dollars_in_ident) = lang == CLK_GNUCXX;
504 CPP_OPTION (pfile, cplusplus_comments) = 1;
505 CPP_OPTION (pfile, digraphs) = 1;
506 CPP_OPTION (pfile, c89) = 0;
507 CPP_OPTION (pfile, c99) = 0;
508 new_pending_directive (pend, "__cplusplus", cpp_define);
513 CPP_OPTION (pfile, trigraphs) = 0;
514 CPP_OPTION (pfile, dollars_in_ident) = 0; /* Maybe not? */
515 CPP_OPTION (pfile, cplusplus_comments) = 1;
516 CPP_OPTION (pfile, digraphs) = 0;
517 CPP_OPTION (pfile, c89) = 0;
518 CPP_OPTION (pfile, c99) = 0;
519 CPP_OPTION (pfile, lang_asm) = 1;
520 new_pending_directive (pend, "__ASSEMBLER__", cpp_define);
525 /* Initialize a cpp_reader structure. */
527 cpp_reader_init (pfile, lang)
531 struct spec_nodes *s;
533 memset ((char *) pfile, 0, sizeof (cpp_reader));
535 /* If cpp_init hasn't been called, generate a fatal error (by hand)
537 if (!cpp_init_completed)
539 fputs ("cpp_reader_init: internal error: cpp_init not called.\n", stderr);
540 pfile->errors = CPP_FATAL_LIMIT;
544 set_lang (pfile, lang);
545 CPP_OPTION (pfile, warn_import) = 1;
546 CPP_OPTION (pfile, warn_paste) = 1;
547 CPP_OPTION (pfile, discard_comments) = 1;
548 CPP_OPTION (pfile, show_column) = 1;
549 CPP_OPTION (pfile, tabstop) = 8;
551 CPP_OPTION (pfile, pending) =
552 (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
554 /* Initialize lexer state. */
555 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
557 /* Indicate date and time not yet calculated. */
558 pfile->date.type = CPP_EOF;
560 /* Initialise the base context. */
561 pfile->context = &pfile->base_context;
562 pfile->base_context.macro = 0;
563 pfile->base_context.prev = pfile->base_context.next = 0;
565 /* Identifier pool initially 8K. Unaligned, permanent pool. */
566 _cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0);
568 /* String and number pool initially 4K. Unaligned, temporary pool. */
569 _cpp_init_pool (&pfile->temp_string_pool, 4 * 1024, 1, 1);
571 /* Argument pool initially 8K. Aligned, temporary pool. */
572 _cpp_init_pool (&pfile->argument_pool, 8 * 1024, 0, 1);
574 /* Macro pool initially 8K. Aligned, permanent pool. */
575 _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
577 /* Start with temporary pool. */
578 pfile->string_pool = &pfile->temp_string_pool;
580 _cpp_init_hashtable (pfile);
581 _cpp_init_stacks (pfile);
582 _cpp_init_includes (pfile);
583 _cpp_init_internal_pragmas (pfile);
585 /* Initialize the special nodes. */
586 s = &pfile->spec_nodes;
587 s->n_L = cpp_lookup (pfile, DSC("L"));
588 s->n_defined = cpp_lookup (pfile, DSC("defined"));
589 s->n__Pragma = cpp_lookup (pfile, DSC("_Pragma"));
590 s->n__STRICT_ANSI__ = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
591 s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
592 s->n__VA_ARGS__ = cpp_lookup (pfile, DSC("__VA_ARGS__"));
593 s->n__VA_ARGS__->flags |= NODE_DIAGNOSTIC;
596 /* Free resources used by PFILE.
597 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
602 struct file_name_list *dir, *dirn;
603 cpp_context *context, *contextn;
605 while (CPP_BUFFER (pfile) != NULL)
606 cpp_pop_buffer (pfile);
608 if (pfile->macro_buffer)
609 free ((PTR) pfile->macro_buffer);
612 deps_free (pfile->deps);
614 _cpp_cleanup_includes (pfile);
615 _cpp_cleanup_stacks (pfile);
616 _cpp_cleanup_hashtable (pfile);
618 _cpp_free_lookaheads (pfile);
620 _cpp_free_pool (&pfile->ident_pool);
621 _cpp_free_pool (&pfile->temp_string_pool);
622 _cpp_free_pool (&pfile->macro_pool);
623 _cpp_free_pool (&pfile->argument_pool);
625 for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
632 for (context = pfile->base_context.next; context; context = contextn)
634 contextn = context->next;
640 /* This structure defines one built-in identifier. A node will be
641 entered in the hash table under the name NAME, with value VALUE (if
642 any). If flags has OPERATOR, the node's operator field is used; if
643 flags has BUILTIN the node's builtin field is used.
645 Two values are not compile time constants, so we tag
646 them in the FLAGS field instead:
647 VERS value is the global version_string, quoted
648 ULP value is the global user_label_prefix
650 Also, macros with CPLUS set in the flags field are entered only for C++. */
656 unsigned char builtin;
657 unsigned char operator;
658 unsigned short flags;
665 #define OPERATOR 0x10
667 #define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
668 #define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 }
669 #define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 }
670 #define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
671 static const struct builtin builtin_array[] =
673 B("__TIME__", BT_TIME),
674 B("__DATE__", BT_DATE),
675 B("__FILE__", BT_FILE),
676 B("__BASE_FILE__", BT_BASE_FILE),
677 B("__LINE__", BT_SPECLINE),
678 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
679 B("__STDC__", BT_STDC),
681 X("__VERSION__", VERS),
682 X("__USER_LABEL_PREFIX__", ULP),
683 C("__REGISTER_PREFIX__", REGISTER_PREFIX),
684 C("__HAVE_BUILTIN_SETJMP__", "1"),
685 #ifndef NO_BUILTIN_SIZE_TYPE
686 C("__SIZE_TYPE__", SIZE_TYPE),
688 #ifndef NO_BUILTIN_PTRDIFF_TYPE
689 C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
691 #ifndef NO_BUILTIN_WCHAR_TYPE
692 C("__WCHAR_TYPE__", WCHAR_TYPE),
694 #ifndef NO_BUILTIN_WINT_TYPE
695 C("__WINT_TYPE__", WINT_TYPE),
698 /* Named operators known to the preprocessor. These cannot be #defined
699 and always have their stated meaning. They are treated like normal
700 identifiers except for the type code and the meaning. Most of them
701 are only for C++ (but see iso646.h). */
702 O("and", CPP_AND_AND, CPLUS),
703 O("and_eq", CPP_AND_EQ, CPLUS),
704 O("bitand", CPP_AND, CPLUS),
705 O("bitor", CPP_OR, CPLUS),
706 O("compl", CPP_COMPL, CPLUS),
707 O("not", CPP_NOT, CPLUS),
708 O("not_eq", CPP_NOT_EQ, CPLUS),
709 O("or", CPP_OR_OR, CPLUS),
710 O("or_eq", CPP_OR_EQ, CPLUS),
711 O("xor", CPP_XOR, CPLUS),
712 O("xor_eq", CPP_XOR_EQ, CPLUS)
717 #define builtin_array_end \
718 builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
720 /* Subroutine of cpp_start_read; reads the builtins table above and
721 enters the macros into the hash table. */
723 initialize_builtins (pfile)
726 const struct builtin *b;
728 for(b = builtin_array; b < builtin_array_end; b++)
730 if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus))
733 if (b->flags & (OPERATOR | BUILTIN))
735 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
736 if (b->flags & OPERATOR)
738 hp->flags |= NODE_OPERATOR;
739 hp->value.operator = b->operator;
744 hp->flags |= NODE_BUILTIN;
745 hp->value.builtin = b->builtin;
748 else /* A standard macro of some kind. */
755 /* Allocate enough space for 'name "value"\n\0'. */
756 str = alloca (b->len + strlen (version_string) + 5);
757 sprintf (str, "%s \"%s\"\n", b->name, version_string);
762 val = CPP_OPTION (pfile, user_label_prefix);
766 /* Allocate enough space for "name value\n\0". */
767 str = alloca (b->len + strlen (val) + 3);
768 sprintf(str, "%s %s\n", b->name, val);
771 _cpp_define_builtin (pfile, str);
780 #undef builtin_array_end
782 /* Another subroutine of cpp_start_read. This one sets up to do
783 dependency-file output. */
785 initialize_dependency_output (pfile)
788 char *spec, *s, *output_file;
790 /* Either of two environment variables can specify output of deps.
791 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
792 where OUTPUT_FILE is the file to write deps info to
793 and DEPS_TARGET is the target to mention in the deps. */
795 if (CPP_OPTION (pfile, print_deps) == 0)
797 spec = getenv ("DEPENDENCIES_OUTPUT");
799 CPP_OPTION (pfile, print_deps) = 1;
802 spec = getenv ("SUNPRO_DEPENDENCIES");
804 CPP_OPTION (pfile, print_deps) = 2;
809 /* Find the space before the DEPS_TARGET, if there is one. */
810 s = strchr (spec, ' ');
813 CPP_OPTION (pfile, deps_target) = s + 1;
814 output_file = (char *) xmalloc (s - spec + 1);
815 memcpy (output_file, spec, s - spec);
816 output_file[s - spec] = 0;
820 CPP_OPTION (pfile, deps_target) = 0;
824 CPP_OPTION (pfile, deps_file) = output_file;
825 CPP_OPTION (pfile, print_deps_append) = 1;
828 pfile->deps = deps_init ();
830 /* Print the expected object file name as the target of this Make-rule. */
831 if (CPP_OPTION (pfile, deps_target))
832 deps_add_target (pfile->deps, CPP_OPTION (pfile, deps_target));
833 else if (*CPP_OPTION (pfile, in_fname) == 0)
834 deps_add_target (pfile->deps, "-");
836 deps_calc_target (pfile->deps, CPP_OPTION (pfile, in_fname));
838 if (CPP_OPTION (pfile, in_fname))
839 deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
842 /* And another subroutine. This one sets up the standard include path. */
844 initialize_standard_includes (pfile)
848 const struct default_include *p;
849 const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
851 /* Several environment variables may add to the include search path.
852 CPATH specifies an additional list of directories to be searched
853 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
854 etc. specify an additional list of directories to be searched as
855 if specified with -isystem, for the language indicated. */
857 GET_ENV_PATH_LIST (path, "CPATH");
858 if (path != 0 && *path != 0)
859 path_include (pfile, path, BRACKET);
861 switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
864 GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
867 GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
870 GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
873 GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
876 if (path != 0 && *path != 0)
877 path_include (pfile, path, SYSTEM);
879 /* Search "translated" versions of GNU directories.
880 These have /usr/local/lib/gcc... replaced by specd_prefix. */
881 if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
883 /* Remove the `include' from /usr/local/lib/gcc.../include.
884 GCC_INCLUDE_DIR will always end in /include. */
885 int default_len = cpp_GCC_INCLUDE_DIR_len;
886 char *default_prefix = (char *) alloca (default_len + 1);
887 int specd_len = strlen (specd_prefix);
889 memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
890 default_prefix[default_len] = '\0';
892 for (p = cpp_include_defaults; p->fname; p++)
894 /* Some standard dirs are only for C++. */
896 || (CPP_OPTION (pfile, cplusplus)
897 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
899 /* Does this dir start with the prefix? */
900 if (!memcmp (p->fname, default_prefix, default_len))
902 /* Yes; change prefix and add to search list. */
903 int flen = strlen (p->fname);
904 int this_len = specd_len + flen - default_len;
905 char *str = (char *) xmalloc (this_len + 1);
906 memcpy (str, specd_prefix, specd_len);
907 memcpy (str + specd_len,
908 p->fname + default_len,
909 flen - default_len + 1);
911 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
917 /* Search ordinary names for GNU include directories. */
918 for (p = cpp_include_defaults; p->fname; p++)
920 /* Some standard dirs are only for C++. */
922 || (CPP_OPTION (pfile, cplusplus)
923 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
925 char *str = xstrdup (update_path (p->fname, p->component));
926 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
931 /* Handles -imacro and -include from the command line. */
933 do_includes (pfile, p, scan)
935 struct pending_option *p;
941 struct pending_option *q;
943 header.type = CPP_STRING;
944 header.val.str.text = (unsigned char *) p->arg;
945 header.val.str.len = strlen (p->arg);
947 /* Use the #include "" search path. */
948 _cpp_execute_include (pfile, &header, 0, 0);
950 cpp_scan_buffer_nooutput (pfile);
957 /* This is called after options have been processed. Check options
958 for consistency, and setup for processing input from the file named
959 FNAME. (Use standard input if FNAME == NULL.) Return 1 on success,
963 cpp_start_read (pfile, fname)
967 struct pending_option *p, *q;
969 /* -MG doesn't select the form of output and must be specified with one of
970 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
971 inhibit compilation. */
972 if (CPP_OPTION (pfile, print_deps_missing_files)
973 && (CPP_OPTION (pfile, print_deps) == 0
974 || !CPP_OPTION (pfile, no_output)))
976 cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
980 /* -Wtraditional is not useful in C++ mode. */
981 if (CPP_OPTION (pfile, cplusplus))
982 CPP_OPTION (pfile, warn_traditional) = 0;
984 /* Do not warn about invalid token pasting if -lang-asm. */
985 if (CPP_OPTION (pfile, lang_asm))
986 CPP_OPTION (pfile, warn_paste) = 0;
988 /* Set this if it hasn't been set already. */
989 if (CPP_OPTION (pfile, user_label_prefix) == NULL)
990 CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
992 /* Set up the include search path now. */
993 if (! CPP_OPTION (pfile, no_standard_includes))
994 initialize_standard_includes (pfile);
996 merge_include_chains (pfile);
998 /* With -v, print the list of dirs to search. */
999 if (CPP_OPTION (pfile, verbose))
1001 struct file_name_list *l;
1002 fprintf (stderr, _("#include \"...\" search starts here:\n"));
1003 for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
1005 if (l == CPP_OPTION (pfile, bracket_include))
1006 fprintf (stderr, _("#include <...> search starts here:\n"));
1007 fprintf (stderr, " %s\n", l->name);
1009 fprintf (stderr, _("End of search list.\n"));
1012 /* Open the main input file. This must be done early, so we have a
1013 buffer to stand on. */
1014 if (CPP_OPTION (pfile, in_fname) == NULL
1015 || *CPP_OPTION (pfile, in_fname) == 0)
1017 CPP_OPTION (pfile, in_fname) = fname;
1018 if (CPP_OPTION (pfile, in_fname) == NULL)
1019 CPP_OPTION (pfile, in_fname) = "";
1021 if (CPP_OPTION (pfile, out_fname) == NULL)
1022 CPP_OPTION (pfile, out_fname) = "";
1024 if (!cpp_read_file (pfile, fname))
1027 initialize_dependency_output (pfile);
1029 /* Install __LINE__, etc. */
1030 initialize_builtins (pfile);
1032 /* Do -U's, -D's and -A's in the order they were seen. */
1033 p = CPP_OPTION (pfile, pending)->directive_head;
1036 (*p->handler) (pfile, p->arg);
1041 pfile->done_initializing = 1;
1043 /* The -imacros files can be scanned now, but the -include files
1044 have to be pushed onto the buffer stack and processed later,
1045 otherwise cppmain.c won't see the tokens. include_head was built
1046 up as a stack, and popping this stack onto the buffer stack means
1047 we preserve the order of the command line. */
1048 do_includes (pfile, CPP_OPTION (pfile, pending)->imacros_head, 1);
1049 do_includes (pfile, CPP_OPTION (pfile, pending)->include_head, 0);
1051 free (CPP_OPTION (pfile, pending));
1052 CPP_OPTION (pfile, pending) = NULL;
1057 /* This is called at the end of preprocessing. It pops the
1058 last buffer and writes dependency output. It should also
1059 clear macro definitions, such that you could call cpp_start_read
1060 with a new filename to restart processing. */
1065 if (CPP_BUFFER (pfile))
1067 cpp_ice (pfile, "buffers still stacked in cpp_finish");
1068 while (CPP_BUFFER (pfile))
1069 cpp_pop_buffer (pfile);
1072 /* Don't write the deps file if preprocessing has failed. */
1073 if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
1075 /* Stream on which to print the dependency information. */
1076 FILE *deps_stream = 0;
1077 const char *deps_mode
1078 = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
1079 if (CPP_OPTION (pfile, deps_file) == 0)
1080 deps_stream = stdout;
1083 deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
1084 if (deps_stream == 0)
1085 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
1089 deps_write (pfile->deps, deps_stream, 72);
1090 if (CPP_OPTION (pfile, deps_file))
1092 if (ferror (deps_stream) || fclose (deps_stream) != 0)
1093 cpp_fatal (pfile, "I/O error on output");
1098 /* Report on headers that could use multiple include guards. */
1099 if (CPP_OPTION (pfile, print_include_names))
1100 _cpp_report_missing_guards (pfile);
1104 new_pending_directive (pend, text, handler)
1105 struct cpp_pending *pend;
1107 cl_directive_handler handler;
1109 struct pending_option *o = (struct pending_option *)
1110 xmalloc (sizeof (struct pending_option));
1114 o->handler = handler;
1115 APPEND (pend, directive, o);
1118 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1119 I.e. a const string initializer with parens around it. That is
1120 what N_("string") resolves to, so we make no_* be macros instead. */
1121 #define no_arg N_("Argument missing after %s")
1122 #define no_ass N_("Assertion missing after %s")
1123 #define no_dir N_("Directory name missing after %s")
1124 #define no_fil N_("File name missing after %s")
1125 #define no_mac N_("Macro name missing after %s")
1126 #define no_pth N_("Path name missing after %s")
1127 #define no_num N_("Number missing after %s")
1129 /* This is the list of all command line options, with the leading
1130 "-" removed. It must be sorted in ASCII collating order. */
1131 #define COMMAND_LINE_OPTIONS \
1132 DEF_OPT("", 0, OPT_stdin_stdout) \
1133 DEF_OPT("$", 0, OPT_dollar) \
1134 DEF_OPT("+", 0, OPT_plus) \
1135 DEF_OPT("-help", 0, OPT__help) \
1136 DEF_OPT("-target-help", 0, OPT_target__help) \
1137 DEF_OPT("-version", 0, OPT__version) \
1138 DEF_OPT("A", no_ass, OPT_A) \
1139 DEF_OPT("C", 0, OPT_C) \
1140 DEF_OPT("D", no_mac, OPT_D) \
1141 DEF_OPT("H", 0, OPT_H) \
1142 DEF_OPT("I", no_dir, OPT_I) \
1143 DEF_OPT("M", 0, OPT_M) \
1144 DEF_OPT("MD", no_fil, OPT_MD) \
1145 DEF_OPT("MG", 0, OPT_MG) \
1146 DEF_OPT("MM", 0, OPT_MM) \
1147 DEF_OPT("MMD", no_fil, OPT_MMD) \
1148 DEF_OPT("P", 0, OPT_P) \
1149 DEF_OPT("U", no_mac, OPT_U) \
1150 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1151 DEF_OPT("d", no_arg, OPT_d) \
1152 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1153 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1154 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1155 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1156 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1157 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1158 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1159 DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
1160 DEF_OPT("h", 0, OPT_h) \
1161 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1162 DEF_OPT("imacros", no_fil, OPT_imacros) \
1163 DEF_OPT("include", no_fil, OPT_include) \
1164 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1165 DEF_OPT("isystem", no_dir, OPT_isystem) \
1166 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1167 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1168 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1169 DEF_OPT("lang-c", 0, OPT_lang_c) \
1170 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1171 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1172 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1173 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1174 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1175 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1176 DEF_OPT("o", no_fil, OPT_o) \
1177 DEF_OPT("pedantic", 0, OPT_pedantic) \
1178 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1179 DEF_OPT("remap", 0, OPT_remap) \
1180 DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
1181 DEF_OPT("std=c89", 0, OPT_std_c89) \
1182 DEF_OPT("std=c99", 0, OPT_std_c99) \
1183 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1184 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1185 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1186 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1187 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1188 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1189 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1190 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1191 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1192 DEF_OPT("v", 0, OPT_v) \
1193 DEF_OPT("w", 0, OPT_w)
1195 #define DEF_OPT(text, msg, code) code,
1198 COMMAND_LINE_OPTIONS
1205 const char *opt_text;
1208 enum opt_code opt_code;
1211 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1213 static struct cl_option cl_options[] =
1215 static const struct cl_option cl_options[] =
1218 COMMAND_LINE_OPTIONS
1221 #undef COMMAND_LINE_OPTIONS
1223 /* Perform a binary search to find which, if any, option the given
1224 command-line matches. Returns its index in the option array,
1225 negative on failure. Complications arise since some options can be
1226 suffixed with an argument, and multiple complete matches can occur,
1227 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
1228 accept options beginning with -g and -W that we do not recognise,
1229 but not to swallow any subsequent command line argument; these are
1230 handled as special cases in cpp_handle_option. */
1232 parse_option (input)
1235 unsigned int md, mn, mx;
1246 opt_len = cl_options[md].opt_len;
1247 comp = memcmp (input, cl_options[md].opt_text, opt_len);
1255 if (input[opt_len] == '\0')
1257 /* We were passed more text. If the option takes an argument,
1258 we may match a later option or we may have been passed the
1259 argument. The longest possible option match succeeds.
1260 If the option takes no arguments we have not matched and
1261 continue the search (e.g. input="stdc++" match was "stdc"). */
1263 if (cl_options[md].msg)
1265 /* Scan forwards. If we get an exact match, return it.
1266 Otherwise, return the longest option-accepting match.
1267 This loops no more than twice with current options. */
1269 for (; mn < N_OPTS; mn++)
1271 opt_len = cl_options[mn].opt_len;
1272 if (memcmp (input, cl_options[mn].opt_text, opt_len))
1274 if (input[opt_len] == '\0')
1276 if (cl_options[mn].msg)
1287 /* Handle one command-line option in (argc, argv).
1288 Can be called multiple times, to handle multiple sets of options.
1289 Returns number of strings consumed. */
1292 cpp_handle_option (pfile, argc, argv)
1298 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1300 if (argv[i][0] != '-')
1302 if (CPP_OPTION (pfile, out_fname) != NULL)
1303 cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
1305 else if (CPP_OPTION (pfile, in_fname) != NULL)
1306 CPP_OPTION (pfile, out_fname) = argv[i];
1308 CPP_OPTION (pfile, in_fname) = argv[i];
1312 enum opt_code opt_code;
1314 const char *arg = 0;
1316 /* Skip over '-'. */
1317 opt_index = parse_option (&argv[i][1]);
1321 opt_code = cl_options[opt_index].opt_code;
1322 if (cl_options[opt_index].msg)
1324 arg = &argv[i][cl_options[opt_index].opt_len + 1];
1326 /* Yuk. Special case for -g and -W as they must not swallow
1327 up any following argument. If this becomes common, add
1328 another field to the cl_options table. */
1329 if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
1334 cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1342 case N_OPTS: /* Shut GCC up. */
1344 case OPT_fleading_underscore:
1345 CPP_OPTION (pfile, user_label_prefix) = "_";
1347 case OPT_fno_leading_underscore:
1348 CPP_OPTION (pfile, user_label_prefix) = "";
1350 case OPT_fpreprocessed:
1351 CPP_OPTION (pfile, preprocessed) = 1;
1353 case OPT_fno_preprocessed:
1354 CPP_OPTION (pfile, preprocessed) = 0;
1356 case OPT_fshow_column:
1357 CPP_OPTION (pfile, show_column) = 1;
1359 case OPT_fno_show_column:
1360 CPP_OPTION (pfile, show_column) = 0;
1363 /* Silently ignore empty string, non-longs and silly values. */
1367 long tabstop = strtol (arg, &endptr, 10);
1368 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1369 CPP_OPTION (pfile, tabstop) = tabstop;
1373 CPP_OPTION (pfile, inhibit_warnings) = 1;
1375 case OPT_g: /* Silently ignore anything but -g3. */
1376 if (!strcmp(&argv[i][2], "3"))
1377 CPP_OPTION (pfile, debug_output) = 1;
1384 case OPT_target__help:
1385 /* Print if any target specific options. */
1389 fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1393 CPP_OPTION (pfile, discard_comments) = 0;
1396 CPP_OPTION (pfile, no_line_commands) = 1;
1398 case OPT_dollar: /* Don't include $ in identifiers. */
1399 CPP_OPTION (pfile, dollars_in_ident) = 0;
1402 CPP_OPTION (pfile, print_include_names) = 1;
1405 new_pending_directive (pend, arg, cpp_define);
1407 case OPT_pedantic_errors:
1408 CPP_OPTION (pfile, pedantic_errors) = 1;
1411 CPP_OPTION (pfile, pedantic) = 1;
1414 CPP_OPTION (pfile, trigraphs) = 1;
1417 CPP_OPTION (pfile, cplusplus) = 1;
1418 CPP_OPTION (pfile, cplusplus_comments) = 1;
1421 CPP_OPTION (pfile, remap) = 1;
1424 CPP_OPTION (pfile, include_prefix) = arg;
1425 CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1428 set_lang (pfile, CLK_GNUC89);
1430 case OPT_lang_cplusplus:
1431 set_lang (pfile, CLK_GNUCXX);
1434 set_lang (pfile, CLK_OBJC);
1436 case OPT_lang_objcplusplus:
1437 set_lang (pfile, CLK_OBJCXX);
1440 set_lang (pfile, CLK_ASM);
1442 case OPT_std_cplusplus98:
1443 set_lang (pfile, CLK_CXX98);
1446 set_lang (pfile, CLK_GNUC89);
1450 set_lang (pfile, CLK_GNUC99);
1452 case OPT_std_iso9899_199409:
1453 set_lang (pfile, CLK_STDC94);
1455 case OPT_std_iso9899_1990:
1458 set_lang (pfile, CLK_STDC89);
1460 case OPT_std_iso9899_199x:
1461 case OPT_std_iso9899_1999:
1464 set_lang (pfile, CLK_STDC99);
1467 /* -nostdinc causes no default include directories.
1468 You must specify all include-file directories with -I. */
1469 CPP_OPTION (pfile, no_standard_includes) = 1;
1471 case OPT_nostdincplusplus:
1472 /* -nostdinc++ causes no default C++-specific include directories. */
1473 CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1476 if (CPP_OPTION (pfile, out_fname) != NULL)
1478 cpp_fatal (pfile, "Output filename specified twice");
1481 CPP_OPTION (pfile, out_fname) = arg;
1482 if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
1483 CPP_OPTION (pfile, out_fname) = "";
1486 fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1487 #ifdef TARGET_VERSION
1490 fputc ('\n', stderr);
1491 CPP_OPTION (pfile, verbose) = 1;
1493 case OPT_stdin_stdout:
1494 /* JF handle '-' as file name meaning stdin or stdout. */
1495 if (CPP_OPTION (pfile, in_fname) == NULL)
1496 CPP_OPTION (pfile, in_fname) = "";
1497 else if (CPP_OPTION (pfile, out_fname) == NULL)
1498 CPP_OPTION (pfile, out_fname) = "";
1501 /* Args to -d specify what parts of macros to dump.
1502 Silently ignore unrecognised options; they may
1503 be aimed at the compiler proper. */
1507 while ((c = *arg++) != '\0')
1511 CPP_OPTION (pfile, dump_macros) = dump_only;
1512 CPP_OPTION (pfile, no_output) = 1;
1515 CPP_OPTION (pfile, dump_macros) = dump_names;
1518 CPP_OPTION (pfile, dump_macros) = dump_definitions;
1521 CPP_OPTION (pfile, dump_includes) = 1;
1526 /* The style of the choices here is a bit mixed.
1527 The chosen scheme is a hybrid of keeping all options in one string
1528 and specifying each option in a separate argument:
1529 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1530 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1531 -M[M][G][D file]. This is awkward to handle in specs, and is not
1533 /* ??? -MG must be specified in addition to one of -M or -MM.
1534 This can be relaxed in the future without breaking anything.
1535 The converse isn't true. */
1537 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1539 CPP_OPTION (pfile, print_deps_missing_files) = 1;
1545 if (opt_code == OPT_M || opt_code == OPT_MD)
1546 CPP_OPTION (pfile, print_deps) = 2;
1548 CPP_OPTION (pfile, print_deps) = 1;
1550 /* For -MD and -MMD, write deps on file named by next arg. */
1551 /* For -M and -MM, write deps on standard output and
1552 suppress the usual output. */
1553 if (opt_code == OPT_MD || opt_code == OPT_MMD)
1554 CPP_OPTION (pfile, deps_file) = arg;
1556 CPP_OPTION (pfile, no_output) = 1;
1561 /* -A with an argument beginning with '-' acts as
1562 #unassert on whatever immediately follows the '-'.
1563 If "-" is the whole argument, we eliminate all
1564 predefined macros and assertions, including those
1565 that were specified earlier on the command line.
1566 That way we can get rid of any that were passed
1567 automatically in from GCC. */
1571 struct pending_option *o1, *o2;
1573 o1 = pend->directive_head;
1580 pend->directive_head = NULL;
1581 pend->directive_tail = NULL;
1584 new_pending_directive (pend, arg + 1, cpp_unassert);
1587 new_pending_directive (pend, arg, cpp_assert);
1590 new_pending_directive (pend, arg, cpp_undef);
1592 case OPT_I: /* Add directory to path for includes. */
1593 if (!strcmp (arg, "-"))
1596 Use the preceding -I directories for #include "..."
1597 but not #include <...>.
1598 Don't search the directory of the present file
1599 for #include "...". (Note that -I. -I- is not the same as
1600 the default setup; -I. uses the compiler's working dir.) */
1601 if (! CPP_OPTION (pfile, ignore_srcdir))
1603 pend->quote_head = pend->brack_head;
1604 pend->quote_tail = pend->brack_tail;
1605 pend->brack_head = 0;
1606 pend->brack_tail = 0;
1607 CPP_OPTION (pfile, ignore_srcdir) = 1;
1611 cpp_fatal (pfile, "-I- specified twice");
1616 append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1619 /* Add directory to beginning of system include path, as a system
1620 include directory. */
1621 append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1625 struct pending_option *o = (struct pending_option *)
1626 xmalloc (sizeof (struct pending_option));
1629 /* This list has to be built in reverse order so that
1630 when cpp_start_read pushes all the -include files onto
1631 the buffer stack, they will be scanned in forward order. */
1632 o->next = pend->include_head;
1633 pend->include_head = o;
1638 struct pending_option *o = (struct pending_option *)
1639 xmalloc (sizeof (struct pending_option));
1643 APPEND (pend, imacros, o);
1646 case OPT_iwithprefix:
1647 /* Add directory to end of path for includes,
1648 with the default prefix at the front of its name. */
1650 case OPT_iwithprefixbefore:
1651 /* Add directory to main path for includes,
1652 with the default prefix at the front of its name. */
1659 if (CPP_OPTION (pfile, include_prefix) != 0)
1661 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1662 fname = xmalloc (ipl + len + 1);
1663 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1664 memcpy (fname + ipl, arg, len + 1);
1666 else if (cpp_GCC_INCLUDE_DIR_len)
1668 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1669 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1670 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1673 fname = xstrdup (arg);
1675 append_include_chain (pfile, fname,
1676 opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1680 /* Add directory to end of path for includes. */
1681 append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1684 /* Silently ignore unrecognised options. */
1685 if (!strcmp (argv[i], "-Wall"))
1687 CPP_OPTION (pfile, warn_trigraphs) = 1;
1688 CPP_OPTION (pfile, warn_comments) = 1;
1690 else if (!strcmp (argv[i], "-Wtraditional"))
1691 CPP_OPTION (pfile, warn_traditional) = 1;
1692 else if (!strcmp (argv[i], "-Wtrigraphs"))
1693 CPP_OPTION (pfile, warn_trigraphs) = 1;
1694 else if (!strcmp (argv[i], "-Wcomment"))
1695 CPP_OPTION (pfile, warn_comments) = 1;
1696 else if (!strcmp (argv[i], "-Wcomments"))
1697 CPP_OPTION (pfile, warn_comments) = 1;
1698 else if (!strcmp (argv[i], "-Wundef"))
1699 CPP_OPTION (pfile, warn_undef) = 1;
1700 else if (!strcmp (argv[i], "-Wimport"))
1701 CPP_OPTION (pfile, warn_import) = 1;
1702 else if (!strcmp (argv[i], "-Wpaste"))
1703 CPP_OPTION (pfile, warn_paste) = 1;
1704 else if (!strcmp (argv[i], "-Werror"))
1705 CPP_OPTION (pfile, warnings_are_errors) = 1;
1706 else if (!strcmp (argv[i], "-Wsystem-headers"))
1707 CPP_OPTION (pfile, warn_system_headers) = 1;
1708 else if (!strcmp (argv[i], "-Wno-traditional"))
1709 CPP_OPTION (pfile, warn_traditional) = 0;
1710 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1711 CPP_OPTION (pfile, warn_trigraphs) = 0;
1712 else if (!strcmp (argv[i], "-Wno-comment"))
1713 CPP_OPTION (pfile, warn_comments) = 0;
1714 else if (!strcmp (argv[i], "-Wno-comments"))
1715 CPP_OPTION (pfile, warn_comments) = 0;
1716 else if (!strcmp (argv[i], "-Wno-undef"))
1717 CPP_OPTION (pfile, warn_undef) = 0;
1718 else if (!strcmp (argv[i], "-Wno-import"))
1719 CPP_OPTION (pfile, warn_import) = 0;
1720 else if (!strcmp (argv[i], "-Wno-paste"))
1721 CPP_OPTION (pfile, warn_paste) = 0;
1722 else if (!strcmp (argv[i], "-Wno-error"))
1723 CPP_OPTION (pfile, warnings_are_errors) = 0;
1724 else if (!strcmp (argv[i], "-Wno-system-headers"))
1725 CPP_OPTION (pfile, warn_system_headers) = 0;
1734 opt_comp (const void *p1, const void *p2)
1736 return strcmp (((struct cl_option *)p1)->opt_text,
1737 ((struct cl_option *)p2)->opt_text);
1741 /* Handle command-line options in (argc, argv).
1742 Can be called multiple times, to handle multiple sets of options.
1743 Returns if an unrecognized option is seen.
1744 Returns number of strings consumed. */
1746 cpp_handle_options (pfile, argc, argv)
1752 int strings_processed;
1754 for (i = 0; i < argc; i += strings_processed)
1756 strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1757 if (strings_processed == 0)
1766 fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1767 /* To keep the lines from getting too long for some compilers, limit
1768 to about 500 characters (6 lines) per chunk. */
1771 -include <file> Include the contents of <file> before other files\n\
1772 -imacros <file> Accept definition of macros in <file>\n\
1773 -iprefix <path> Specify <path> as a prefix for next two options\n\
1774 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1775 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1776 -isystem <dir> Add <dir> to the start of the system include path\n\
1779 -idirafter <dir> Add <dir> to the end of the system include path\n\
1780 -I <dir> Add <dir> to the end of the main include path\n\
1781 -I- Fine-grained include path control; see info docs\n\
1782 -nostdinc Do not search system include directories\n\
1783 (dirs specified with -isystem will still be used)\n\
1784 -nostdinc++ Do not search system include directories for C++\n\
1785 -o <file> Put output into <file>\n\
1788 -pedantic Issue all warnings demanded by strict ISO C\n\
1789 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1790 -trigraphs Support ISO C trigraphs\n\
1791 -lang-c Assume that the input sources are in C\n\
1792 -lang-c89 Assume that the input sources are in C89\n\
1795 -lang-c++ Assume that the input sources are in C++\n\
1796 -lang-objc Assume that the input sources are in ObjectiveC\n\
1797 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1798 -lang-asm Assume that the input sources are in assembler\n\
1801 -std=<std name> Specify the conformance standard; one of:\n\
1802 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1803 iso9899:199409, iso9899:1999\n\
1804 -+ Allow parsing of C++ style features\n\
1805 -w Inhibit warning messages\n\
1806 -Wtrigraphs Warn if trigraphs are encountered\n\
1807 -Wno-trigraphs Do not warn about trigraphs\n\
1808 -Wcomment{s} Warn if one comment starts inside another\n\
1811 -Wno-comment{s} Do not warn about comments\n\
1812 -Wtraditional Warn about features not present in traditional C\n\
1813 -Wno-traditional Do not warn about traditional C\n\
1814 -Wundef Warn if an undefined macro is used by #if\n\
1815 -Wno-undef Do not warn about testing undefined macros\n\
1816 -Wimport Warn about the use of the #import directive\n\
1819 -Wno-import Do not warn about the use of #import\n\
1820 -Werror Treat all warnings as errors\n\
1821 -Wno-error Do not treat warnings as errors\n\
1822 -Wsystem-headers Do not suppress warnings from system headers\n\
1823 -Wno-system-headers Suppress warnings from system headers\n\
1824 -Wall Enable all preprocessor warnings\n\
1827 -M Generate make dependencies\n\
1828 -MM As -M, but ignore system header files\n\
1829 -MD As -M, but put output in a .d file\n\
1830 -MMD As -MD, but ignore system header files\n\
1831 -MG Treat missing header file as generated files\n\
1832 -g3 Include #define and #undef directives in the output\n\
1835 -D<macro> Define a <macro> with string '1' as its value\n\
1836 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1837 -A<question> (<answer>) Assert the <answer> to <question>\n\
1838 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1839 -U<macro> Undefine <macro> \n\
1840 -v Display the version number\n\
1843 -H Print the name of header files as they are used\n\
1844 -C Do not discard comments\n\
1845 -dM Display a list of macro definitions active at end\n\
1846 -dD Preserve macro definitions in output\n\
1847 -dN As -dD except that only the names are preserved\n\
1848 -dI Include #include directives in the output\n\
1851 -ftabstop=<number> Distance between tab stops for column reporting\n\
1852 -P Do not generate #line directives\n\
1853 -$ Do not allow '$' in identifiers\n\
1854 -remap Remap file names when including files.\n\
1855 --version Display version information\n\
1856 -h or --help Display this information\n\