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;
940 struct pending_option *q;
942 /* Later: maybe update this to use the #include "" search path
943 if cpp_read_file fails. */
944 if (cpp_read_file (pfile, p->arg) && scan)
945 cpp_scan_buffer_nooutput (pfile);
952 /* This is called after options have been processed. Check options
953 for consistency, and setup for processing input from the file named
954 FNAME. (Use standard input if FNAME == NULL.) Return 1 on success,
958 cpp_start_read (pfile, fname)
962 struct pending_option *p, *q;
964 /* -MG doesn't select the form of output and must be specified with one of
965 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
966 inhibit compilation. */
967 if (CPP_OPTION (pfile, print_deps_missing_files)
968 && (CPP_OPTION (pfile, print_deps) == 0
969 || !CPP_OPTION (pfile, no_output)))
971 cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
975 /* -Wtraditional is not useful in C++ mode. */
976 if (CPP_OPTION (pfile, cplusplus))
977 CPP_OPTION (pfile, warn_traditional) = 0;
979 /* Do not warn about invalid token pasting if -lang-asm. */
980 if (CPP_OPTION (pfile, lang_asm))
981 CPP_OPTION (pfile, warn_paste) = 0;
983 /* Set this if it hasn't been set already. */
984 if (CPP_OPTION (pfile, user_label_prefix) == NULL)
985 CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
987 /* Set up the include search path now. */
988 if (! CPP_OPTION (pfile, no_standard_includes))
989 initialize_standard_includes (pfile);
991 merge_include_chains (pfile);
993 /* With -v, print the list of dirs to search. */
994 if (CPP_OPTION (pfile, verbose))
996 struct file_name_list *l;
997 fprintf (stderr, _("#include \"...\" search starts here:\n"));
998 for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
1000 if (l == CPP_OPTION (pfile, bracket_include))
1001 fprintf (stderr, _("#include <...> search starts here:\n"));
1002 fprintf (stderr, " %s\n", l->name);
1004 fprintf (stderr, _("End of search list.\n"));
1007 /* Open the main input file. This must be done early, so we have a
1008 buffer to stand on. */
1009 if (CPP_OPTION (pfile, in_fname) == NULL
1010 || *CPP_OPTION (pfile, in_fname) == 0)
1012 CPP_OPTION (pfile, in_fname) = fname;
1013 if (CPP_OPTION (pfile, in_fname) == NULL)
1014 CPP_OPTION (pfile, in_fname) = "";
1016 if (CPP_OPTION (pfile, out_fname) == NULL)
1017 CPP_OPTION (pfile, out_fname) = "";
1019 if (!cpp_read_file (pfile, fname))
1022 initialize_dependency_output (pfile);
1024 /* Install __LINE__, etc. */
1025 initialize_builtins (pfile);
1027 /* Do -U's, -D's and -A's in the order they were seen. */
1028 p = CPP_OPTION (pfile, pending)->directive_head;
1031 (*p->handler) (pfile, p->arg);
1036 pfile->done_initializing = 1;
1038 /* The -imacros files can be scanned now, but the -include files
1039 have to be pushed onto the buffer stack and processed later,
1040 otherwise cppmain.c won't see the tokens. include_head was built
1041 up as a stack, and popping this stack onto the buffer stack means
1042 we preserve the order of the command line. */
1043 do_includes (pfile, CPP_OPTION (pfile, pending)->imacros_head, 1);
1044 do_includes (pfile, CPP_OPTION (pfile, pending)->include_head, 0);
1046 free (CPP_OPTION (pfile, pending));
1047 CPP_OPTION (pfile, pending) = NULL;
1052 /* This is called at the end of preprocessing. It pops the
1053 last buffer and writes dependency output. It should also
1054 clear macro definitions, such that you could call cpp_start_read
1055 with a new filename to restart processing. */
1060 if (CPP_BUFFER (pfile))
1062 cpp_ice (pfile, "buffers still stacked in cpp_finish");
1063 while (CPP_BUFFER (pfile))
1064 cpp_pop_buffer (pfile);
1067 /* Don't write the deps file if preprocessing has failed. */
1068 if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
1070 /* Stream on which to print the dependency information. */
1071 FILE *deps_stream = 0;
1072 const char *deps_mode
1073 = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
1074 if (CPP_OPTION (pfile, deps_file) == 0)
1075 deps_stream = stdout;
1078 deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
1079 if (deps_stream == 0)
1080 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
1084 deps_write (pfile->deps, deps_stream, 72);
1085 if (CPP_OPTION (pfile, deps_file))
1087 if (ferror (deps_stream) || fclose (deps_stream) != 0)
1088 cpp_fatal (pfile, "I/O error on output");
1093 /* Report on headers that could use multiple include guards. */
1094 if (CPP_OPTION (pfile, print_include_names))
1095 _cpp_report_missing_guards (pfile);
1099 new_pending_directive (pend, text, handler)
1100 struct cpp_pending *pend;
1102 cl_directive_handler handler;
1104 struct pending_option *o = (struct pending_option *)
1105 xmalloc (sizeof (struct pending_option));
1109 o->handler = handler;
1110 APPEND (pend, directive, o);
1113 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1114 I.e. a const string initializer with parens around it. That is
1115 what N_("string") resolves to, so we make no_* be macros instead. */
1116 #define no_arg N_("Argument missing after %s")
1117 #define no_ass N_("Assertion missing after %s")
1118 #define no_dir N_("Directory name missing after %s")
1119 #define no_fil N_("File name missing after %s")
1120 #define no_mac N_("Macro name missing after %s")
1121 #define no_pth N_("Path name missing after %s")
1122 #define no_num N_("Number missing after %s")
1124 /* This is the list of all command line options, with the leading
1125 "-" removed. It must be sorted in ASCII collating order. */
1126 #define COMMAND_LINE_OPTIONS \
1127 DEF_OPT("", 0, OPT_stdin_stdout) \
1128 DEF_OPT("$", 0, OPT_dollar) \
1129 DEF_OPT("+", 0, OPT_plus) \
1130 DEF_OPT("-help", 0, OPT__help) \
1131 DEF_OPT("-target-help", 0, OPT_target__help) \
1132 DEF_OPT("-version", 0, OPT__version) \
1133 DEF_OPT("A", no_ass, OPT_A) \
1134 DEF_OPT("C", 0, OPT_C) \
1135 DEF_OPT("D", no_mac, OPT_D) \
1136 DEF_OPT("H", 0, OPT_H) \
1137 DEF_OPT("I", no_dir, OPT_I) \
1138 DEF_OPT("M", 0, OPT_M) \
1139 DEF_OPT("MD", no_fil, OPT_MD) \
1140 DEF_OPT("MG", 0, OPT_MG) \
1141 DEF_OPT("MM", 0, OPT_MM) \
1142 DEF_OPT("MMD", no_fil, OPT_MMD) \
1143 DEF_OPT("P", 0, OPT_P) \
1144 DEF_OPT("U", no_mac, OPT_U) \
1145 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1146 DEF_OPT("d", no_arg, OPT_d) \
1147 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1148 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1149 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1150 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1151 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1152 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1153 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1154 DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
1155 DEF_OPT("h", 0, OPT_h) \
1156 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1157 DEF_OPT("imacros", no_fil, OPT_imacros) \
1158 DEF_OPT("include", no_fil, OPT_include) \
1159 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1160 DEF_OPT("isystem", no_dir, OPT_isystem) \
1161 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1162 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1163 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1164 DEF_OPT("lang-c", 0, OPT_lang_c) \
1165 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1166 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1167 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1168 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1169 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1170 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1171 DEF_OPT("o", no_fil, OPT_o) \
1172 DEF_OPT("pedantic", 0, OPT_pedantic) \
1173 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1174 DEF_OPT("remap", 0, OPT_remap) \
1175 DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
1176 DEF_OPT("std=c89", 0, OPT_std_c89) \
1177 DEF_OPT("std=c99", 0, OPT_std_c99) \
1178 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1179 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1180 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1181 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1182 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1183 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1184 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1185 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1186 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1187 DEF_OPT("v", 0, OPT_v) \
1188 DEF_OPT("w", 0, OPT_w)
1190 #define DEF_OPT(text, msg, code) code,
1193 COMMAND_LINE_OPTIONS
1200 const char *opt_text;
1203 enum opt_code opt_code;
1206 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1208 static struct cl_option cl_options[] =
1210 static const struct cl_option cl_options[] =
1213 COMMAND_LINE_OPTIONS
1216 #undef COMMAND_LINE_OPTIONS
1218 /* Perform a binary search to find which, if any, option the given
1219 command-line matches. Returns its index in the option array,
1220 negative on failure. Complications arise since some options can be
1221 suffixed with an argument, and multiple complete matches can occur,
1222 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
1223 accept options beginning with -g and -W that we do not recognise,
1224 but not to swallow any subsequent command line argument; these are
1225 handled as special cases in cpp_handle_option. */
1227 parse_option (input)
1230 unsigned int md, mn, mx;
1241 opt_len = cl_options[md].opt_len;
1242 comp = memcmp (input, cl_options[md].opt_text, opt_len);
1250 if (input[opt_len] == '\0')
1252 /* We were passed more text. If the option takes an argument,
1253 we may match a later option or we may have been passed the
1254 argument. The longest possible option match succeeds.
1255 If the option takes no arguments we have not matched and
1256 continue the search (e.g. input="stdc++" match was "stdc"). */
1258 if (cl_options[md].msg)
1260 /* Scan forwards. If we get an exact match, return it.
1261 Otherwise, return the longest option-accepting match.
1262 This loops no more than twice with current options. */
1264 for (; mn < N_OPTS; mn++)
1266 opt_len = cl_options[mn].opt_len;
1267 if (memcmp (input, cl_options[mn].opt_text, opt_len))
1269 if (input[opt_len] == '\0')
1271 if (cl_options[mn].msg)
1282 /* Handle one command-line option in (argc, argv).
1283 Can be called multiple times, to handle multiple sets of options.
1284 Returns number of strings consumed. */
1287 cpp_handle_option (pfile, argc, argv)
1293 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1295 if (argv[i][0] != '-')
1297 if (CPP_OPTION (pfile, out_fname) != NULL)
1298 cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
1300 else if (CPP_OPTION (pfile, in_fname) != NULL)
1301 CPP_OPTION (pfile, out_fname) = argv[i];
1303 CPP_OPTION (pfile, in_fname) = argv[i];
1307 enum opt_code opt_code;
1309 const char *arg = 0;
1311 /* Skip over '-'. */
1312 opt_index = parse_option (&argv[i][1]);
1316 opt_code = cl_options[opt_index].opt_code;
1317 if (cl_options[opt_index].msg)
1319 arg = &argv[i][cl_options[opt_index].opt_len + 1];
1321 /* Yuk. Special case for -g and -W as they must not swallow
1322 up any following argument. If this becomes common, add
1323 another field to the cl_options table. */
1324 if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
1329 cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1337 case N_OPTS: /* Shut GCC up. */
1339 case OPT_fleading_underscore:
1340 CPP_OPTION (pfile, user_label_prefix) = "_";
1342 case OPT_fno_leading_underscore:
1343 CPP_OPTION (pfile, user_label_prefix) = "";
1345 case OPT_fpreprocessed:
1346 CPP_OPTION (pfile, preprocessed) = 1;
1348 case OPT_fno_preprocessed:
1349 CPP_OPTION (pfile, preprocessed) = 0;
1351 case OPT_fshow_column:
1352 CPP_OPTION (pfile, show_column) = 1;
1354 case OPT_fno_show_column:
1355 CPP_OPTION (pfile, show_column) = 0;
1358 /* Silently ignore empty string, non-longs and silly values. */
1362 long tabstop = strtol (arg, &endptr, 10);
1363 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1364 CPP_OPTION (pfile, tabstop) = tabstop;
1368 CPP_OPTION (pfile, inhibit_warnings) = 1;
1370 case OPT_g: /* Silently ignore anything but -g3. */
1371 if (!strcmp(&argv[i][2], "3"))
1372 CPP_OPTION (pfile, debug_output) = 1;
1379 case OPT_target__help:
1380 /* Print if any target specific options. */
1384 fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1388 CPP_OPTION (pfile, discard_comments) = 0;
1391 CPP_OPTION (pfile, no_line_commands) = 1;
1393 case OPT_dollar: /* Don't include $ in identifiers. */
1394 CPP_OPTION (pfile, dollars_in_ident) = 0;
1397 CPP_OPTION (pfile, print_include_names) = 1;
1400 new_pending_directive (pend, arg, cpp_define);
1402 case OPT_pedantic_errors:
1403 CPP_OPTION (pfile, pedantic_errors) = 1;
1406 CPP_OPTION (pfile, pedantic) = 1;
1409 CPP_OPTION (pfile, trigraphs) = 1;
1412 CPP_OPTION (pfile, cplusplus) = 1;
1413 CPP_OPTION (pfile, cplusplus_comments) = 1;
1416 CPP_OPTION (pfile, remap) = 1;
1419 CPP_OPTION (pfile, include_prefix) = arg;
1420 CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1423 set_lang (pfile, CLK_GNUC89);
1425 case OPT_lang_cplusplus:
1426 set_lang (pfile, CLK_GNUCXX);
1429 set_lang (pfile, CLK_OBJC);
1431 case OPT_lang_objcplusplus:
1432 set_lang (pfile, CLK_OBJCXX);
1435 set_lang (pfile, CLK_ASM);
1437 case OPT_std_cplusplus98:
1438 set_lang (pfile, CLK_CXX98);
1441 set_lang (pfile, CLK_GNUC89);
1445 set_lang (pfile, CLK_GNUC99);
1447 case OPT_std_iso9899_199409:
1448 set_lang (pfile, CLK_STDC94);
1450 case OPT_std_iso9899_1990:
1453 set_lang (pfile, CLK_STDC89);
1455 case OPT_std_iso9899_199x:
1456 case OPT_std_iso9899_1999:
1459 set_lang (pfile, CLK_STDC99);
1462 /* -nostdinc causes no default include directories.
1463 You must specify all include-file directories with -I. */
1464 CPP_OPTION (pfile, no_standard_includes) = 1;
1466 case OPT_nostdincplusplus:
1467 /* -nostdinc++ causes no default C++-specific include directories. */
1468 CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1471 if (CPP_OPTION (pfile, out_fname) != NULL)
1473 cpp_fatal (pfile, "Output filename specified twice");
1476 CPP_OPTION (pfile, out_fname) = arg;
1477 if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
1478 CPP_OPTION (pfile, out_fname) = "";
1481 fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1482 #ifdef TARGET_VERSION
1485 fputc ('\n', stderr);
1486 CPP_OPTION (pfile, verbose) = 1;
1488 case OPT_stdin_stdout:
1489 /* JF handle '-' as file name meaning stdin or stdout. */
1490 if (CPP_OPTION (pfile, in_fname) == NULL)
1491 CPP_OPTION (pfile, in_fname) = "";
1492 else if (CPP_OPTION (pfile, out_fname) == NULL)
1493 CPP_OPTION (pfile, out_fname) = "";
1496 /* Args to -d specify what parts of macros to dump.
1497 Silently ignore unrecognised options; they may
1498 be aimed at the compiler proper. */
1502 while ((c = *arg++) != '\0')
1506 CPP_OPTION (pfile, dump_macros) = dump_only;
1507 CPP_OPTION (pfile, no_output) = 1;
1510 CPP_OPTION (pfile, dump_macros) = dump_names;
1513 CPP_OPTION (pfile, dump_macros) = dump_definitions;
1516 CPP_OPTION (pfile, dump_includes) = 1;
1521 /* The style of the choices here is a bit mixed.
1522 The chosen scheme is a hybrid of keeping all options in one string
1523 and specifying each option in a separate argument:
1524 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1525 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1526 -M[M][G][D file]. This is awkward to handle in specs, and is not
1528 /* ??? -MG must be specified in addition to one of -M or -MM.
1529 This can be relaxed in the future without breaking anything.
1530 The converse isn't true. */
1532 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1534 CPP_OPTION (pfile, print_deps_missing_files) = 1;
1540 if (opt_code == OPT_M || opt_code == OPT_MD)
1541 CPP_OPTION (pfile, print_deps) = 2;
1543 CPP_OPTION (pfile, print_deps) = 1;
1545 /* For -MD and -MMD, write deps on file named by next arg. */
1546 /* For -M and -MM, write deps on standard output and
1547 suppress the usual output. */
1548 if (opt_code == OPT_MD || opt_code == OPT_MMD)
1549 CPP_OPTION (pfile, deps_file) = arg;
1551 CPP_OPTION (pfile, no_output) = 1;
1556 /* -A with an argument beginning with '-' acts as
1557 #unassert on whatever immediately follows the '-'.
1558 If "-" is the whole argument, we eliminate all
1559 predefined macros and assertions, including those
1560 that were specified earlier on the command line.
1561 That way we can get rid of any that were passed
1562 automatically in from GCC. */
1566 struct pending_option *o1, *o2;
1568 o1 = pend->directive_head;
1575 pend->directive_head = NULL;
1576 pend->directive_tail = NULL;
1579 new_pending_directive (pend, arg + 1, cpp_unassert);
1582 new_pending_directive (pend, arg, cpp_assert);
1585 new_pending_directive (pend, arg, cpp_undef);
1587 case OPT_I: /* Add directory to path for includes. */
1588 if (!strcmp (arg, "-"))
1591 Use the preceding -I directories for #include "..."
1592 but not #include <...>.
1593 Don't search the directory of the present file
1594 for #include "...". (Note that -I. -I- is not the same as
1595 the default setup; -I. uses the compiler's working dir.) */
1596 if (! CPP_OPTION (pfile, ignore_srcdir))
1598 pend->quote_head = pend->brack_head;
1599 pend->quote_tail = pend->brack_tail;
1600 pend->brack_head = 0;
1601 pend->brack_tail = 0;
1602 CPP_OPTION (pfile, ignore_srcdir) = 1;
1606 cpp_fatal (pfile, "-I- specified twice");
1611 append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1614 /* Add directory to beginning of system include path, as a system
1615 include directory. */
1616 append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1620 struct pending_option *o = (struct pending_option *)
1621 xmalloc (sizeof (struct pending_option));
1624 /* This list has to be built in reverse order so that
1625 when cpp_start_read pushes all the -include files onto
1626 the buffer stack, they will be scanned in forward order. */
1627 o->next = pend->include_head;
1628 pend->include_head = o;
1633 struct pending_option *o = (struct pending_option *)
1634 xmalloc (sizeof (struct pending_option));
1638 APPEND (pend, imacros, o);
1641 case OPT_iwithprefix:
1642 /* Add directory to end of path for includes,
1643 with the default prefix at the front of its name. */
1645 case OPT_iwithprefixbefore:
1646 /* Add directory to main path for includes,
1647 with the default prefix at the front of its name. */
1654 if (CPP_OPTION (pfile, include_prefix) != 0)
1656 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1657 fname = xmalloc (ipl + len + 1);
1658 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1659 memcpy (fname + ipl, arg, len + 1);
1661 else if (cpp_GCC_INCLUDE_DIR_len)
1663 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1664 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1665 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1668 fname = xstrdup (arg);
1670 append_include_chain (pfile, fname,
1671 opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1675 /* Add directory to end of path for includes. */
1676 append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1679 /* Silently ignore unrecognised options. */
1680 if (!strcmp (argv[i], "-Wall"))
1682 CPP_OPTION (pfile, warn_trigraphs) = 1;
1683 CPP_OPTION (pfile, warn_comments) = 1;
1685 else if (!strcmp (argv[i], "-Wtraditional"))
1686 CPP_OPTION (pfile, warn_traditional) = 1;
1687 else if (!strcmp (argv[i], "-Wtrigraphs"))
1688 CPP_OPTION (pfile, warn_trigraphs) = 1;
1689 else if (!strcmp (argv[i], "-Wcomment"))
1690 CPP_OPTION (pfile, warn_comments) = 1;
1691 else if (!strcmp (argv[i], "-Wcomments"))
1692 CPP_OPTION (pfile, warn_comments) = 1;
1693 else if (!strcmp (argv[i], "-Wundef"))
1694 CPP_OPTION (pfile, warn_undef) = 1;
1695 else if (!strcmp (argv[i], "-Wimport"))
1696 CPP_OPTION (pfile, warn_import) = 1;
1697 else if (!strcmp (argv[i], "-Wpaste"))
1698 CPP_OPTION (pfile, warn_paste) = 1;
1699 else if (!strcmp (argv[i], "-Werror"))
1700 CPP_OPTION (pfile, warnings_are_errors) = 1;
1701 else if (!strcmp (argv[i], "-Wsystem-headers"))
1702 CPP_OPTION (pfile, warn_system_headers) = 1;
1703 else if (!strcmp (argv[i], "-Wno-traditional"))
1704 CPP_OPTION (pfile, warn_traditional) = 0;
1705 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1706 CPP_OPTION (pfile, warn_trigraphs) = 0;
1707 else if (!strcmp (argv[i], "-Wno-comment"))
1708 CPP_OPTION (pfile, warn_comments) = 0;
1709 else if (!strcmp (argv[i], "-Wno-comments"))
1710 CPP_OPTION (pfile, warn_comments) = 0;
1711 else if (!strcmp (argv[i], "-Wno-undef"))
1712 CPP_OPTION (pfile, warn_undef) = 0;
1713 else if (!strcmp (argv[i], "-Wno-import"))
1714 CPP_OPTION (pfile, warn_import) = 0;
1715 else if (!strcmp (argv[i], "-Wno-paste"))
1716 CPP_OPTION (pfile, warn_paste) = 0;
1717 else if (!strcmp (argv[i], "-Wno-error"))
1718 CPP_OPTION (pfile, warnings_are_errors) = 0;
1719 else if (!strcmp (argv[i], "-Wno-system-headers"))
1720 CPP_OPTION (pfile, warn_system_headers) = 0;
1729 opt_comp (const void *p1, const void *p2)
1731 return strcmp (((struct cl_option *)p1)->opt_text,
1732 ((struct cl_option *)p2)->opt_text);
1736 /* Handle command-line options in (argc, argv).
1737 Can be called multiple times, to handle multiple sets of options.
1738 Returns if an unrecognized option is seen.
1739 Returns number of strings consumed. */
1741 cpp_handle_options (pfile, argc, argv)
1747 int strings_processed;
1749 for (i = 0; i < argc; i += strings_processed)
1751 strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1752 if (strings_processed == 0)
1761 fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1762 /* To keep the lines from getting too long for some compilers, limit
1763 to about 500 characters (6 lines) per chunk. */
1766 -include <file> Include the contents of <file> before other files\n\
1767 -imacros <file> Accept definition of macros in <file>\n\
1768 -iprefix <path> Specify <path> as a prefix for next two options\n\
1769 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1770 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1771 -isystem <dir> Add <dir> to the start of the system include path\n\
1774 -idirafter <dir> Add <dir> to the end of the system include path\n\
1775 -I <dir> Add <dir> to the end of the main include path\n\
1776 -I- Fine-grained include path control; see info docs\n\
1777 -nostdinc Do not search system include directories\n\
1778 (dirs specified with -isystem will still be used)\n\
1779 -nostdinc++ Do not search system include directories for C++\n\
1780 -o <file> Put output into <file>\n\
1783 -pedantic Issue all warnings demanded by strict ISO C\n\
1784 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1785 -trigraphs Support ISO C trigraphs\n\
1786 -lang-c Assume that the input sources are in C\n\
1787 -lang-c89 Assume that the input sources are in C89\n\
1790 -lang-c++ Assume that the input sources are in C++\n\
1791 -lang-objc Assume that the input sources are in ObjectiveC\n\
1792 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1793 -lang-asm Assume that the input sources are in assembler\n\
1796 -std=<std name> Specify the conformance standard; one of:\n\
1797 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1798 iso9899:199409, iso9899:1999\n\
1799 -+ Allow parsing of C++ style features\n\
1800 -w Inhibit warning messages\n\
1801 -Wtrigraphs Warn if trigraphs are encountered\n\
1802 -Wno-trigraphs Do not warn about trigraphs\n\
1803 -Wcomment{s} Warn if one comment starts inside another\n\
1806 -Wno-comment{s} Do not warn about comments\n\
1807 -Wtraditional Warn about features not present in traditional C\n\
1808 -Wno-traditional Do not warn about traditional C\n\
1809 -Wundef Warn if an undefined macro is used by #if\n\
1810 -Wno-undef Do not warn about testing undefined macros\n\
1811 -Wimport Warn about the use of the #import directive\n\
1814 -Wno-import Do not warn about the use of #import\n\
1815 -Werror Treat all warnings as errors\n\
1816 -Wno-error Do not treat warnings as errors\n\
1817 -Wsystem-headers Do not suppress warnings from system headers\n\
1818 -Wno-system-headers Suppress warnings from system headers\n\
1819 -Wall Enable all preprocessor warnings\n\
1822 -M Generate make dependencies\n\
1823 -MM As -M, but ignore system header files\n\
1824 -MD As -M, but put output in a .d file\n\
1825 -MMD As -MD, but ignore system header files\n\
1826 -MG Treat missing header file as generated files\n\
1827 -g3 Include #define and #undef directives in the output\n\
1830 -D<macro> Define a <macro> with string '1' as its value\n\
1831 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1832 -A<question> (<answer>) Assert the <answer> to <question>\n\
1833 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1834 -U<macro> Undefine <macro> \n\
1835 -v Display the version number\n\
1838 -H Print the name of header files as they are used\n\
1839 -C Do not discard comments\n\
1840 -dM Display a list of macro definitions active at end\n\
1841 -dD Preserve macro definitions in output\n\
1842 -dN As -dD except that only the names are preserved\n\
1843 -dI Include #include directives in the output\n\
1846 -ftabstop=<number> Distance between tab stops for column reporting\n\
1847 -P Do not generate #line directives\n\
1848 -$ Do not allow '$' in identifiers\n\
1849 -remap Remap file names when including files.\n\
1850 --version Display version information\n\
1851 -h or --help Display this information\n\