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 CPP_OPTION (pfile, warn_import) = 1;
545 CPP_OPTION (pfile, warn_paste) = 1;
546 CPP_OPTION (pfile, discard_comments) = 1;
547 CPP_OPTION (pfile, show_column) = 1;
548 CPP_OPTION (pfile, tabstop) = 8;
550 CPP_OPTION (pfile, pending) =
551 (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
553 /* After creating pfile->pending. */
554 set_lang (pfile, lang);
556 /* Initialize lexer state. */
557 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
559 /* Indicate date and time not yet calculated. */
560 pfile->date.type = CPP_EOF;
562 /* Initialise the base context. */
563 pfile->context = &pfile->base_context;
564 pfile->base_context.macro = 0;
565 pfile->base_context.prev = pfile->base_context.next = 0;
567 /* Identifier pool initially 8K. Unaligned, permanent pool. */
568 _cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0);
570 /* String and number pool initially 4K. Unaligned, temporary pool. */
571 _cpp_init_pool (&pfile->temp_string_pool, 4 * 1024, 1, 1);
573 /* Argument pool initially 8K. Aligned, temporary pool. */
574 _cpp_init_pool (&pfile->argument_pool, 8 * 1024, 0, 1);
576 /* Macro pool initially 8K. Aligned, permanent pool. */
577 _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
579 /* Start with temporary pool. */
580 pfile->string_pool = &pfile->temp_string_pool;
582 _cpp_init_hashtable (pfile);
583 _cpp_init_stacks (pfile);
584 _cpp_init_includes (pfile);
585 _cpp_init_internal_pragmas (pfile);
587 /* Initialize the special nodes. */
588 s = &pfile->spec_nodes;
589 s->n_L = cpp_lookup (pfile, DSC("L"));
590 s->n_defined = cpp_lookup (pfile, DSC("defined"));
591 s->n__Pragma = cpp_lookup (pfile, DSC("_Pragma"));
592 s->n__STRICT_ANSI__ = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
593 s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
594 s->n__VA_ARGS__ = cpp_lookup (pfile, DSC("__VA_ARGS__"));
595 s->n__VA_ARGS__->flags |= NODE_DIAGNOSTIC;
598 /* Free resources used by PFILE.
599 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
604 struct file_name_list *dir, *dirn;
605 cpp_context *context, *contextn;
607 while (CPP_BUFFER (pfile) != NULL)
608 cpp_pop_buffer (pfile);
610 if (pfile->macro_buffer)
611 free ((PTR) pfile->macro_buffer);
614 deps_free (pfile->deps);
616 _cpp_cleanup_includes (pfile);
617 _cpp_cleanup_stacks (pfile);
618 _cpp_cleanup_hashtable (pfile);
620 _cpp_free_lookaheads (pfile);
622 _cpp_free_pool (&pfile->ident_pool);
623 _cpp_free_pool (&pfile->temp_string_pool);
624 _cpp_free_pool (&pfile->macro_pool);
625 _cpp_free_pool (&pfile->argument_pool);
627 for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
634 for (context = pfile->base_context.next; context; context = contextn)
636 contextn = context->next;
642 /* This structure defines one built-in identifier. A node will be
643 entered in the hash table under the name NAME, with value VALUE (if
644 any). If flags has OPERATOR, the node's operator field is used; if
645 flags has BUILTIN the node's builtin field is used.
647 Two values are not compile time constants, so we tag
648 them in the FLAGS field instead:
649 VERS value is the global version_string, quoted
650 ULP value is the global user_label_prefix
652 Also, macros with CPLUS set in the flags field are entered only for C++. */
658 unsigned char builtin;
659 unsigned char operator;
660 unsigned short flags;
667 #define OPERATOR 0x10
669 #define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
670 #define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 }
671 #define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 }
672 #define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
673 static const struct builtin builtin_array[] =
675 B("__TIME__", BT_TIME),
676 B("__DATE__", BT_DATE),
677 B("__FILE__", BT_FILE),
678 B("__BASE_FILE__", BT_BASE_FILE),
679 B("__LINE__", BT_SPECLINE),
680 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
681 B("__STDC__", BT_STDC),
683 X("__VERSION__", VERS),
684 X("__USER_LABEL_PREFIX__", ULP),
685 C("__REGISTER_PREFIX__", REGISTER_PREFIX),
686 C("__HAVE_BUILTIN_SETJMP__", "1"),
687 #ifndef NO_BUILTIN_SIZE_TYPE
688 C("__SIZE_TYPE__", SIZE_TYPE),
690 #ifndef NO_BUILTIN_PTRDIFF_TYPE
691 C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
693 #ifndef NO_BUILTIN_WCHAR_TYPE
694 C("__WCHAR_TYPE__", WCHAR_TYPE),
696 #ifndef NO_BUILTIN_WINT_TYPE
697 C("__WINT_TYPE__", WINT_TYPE),
700 /* Named operators known to the preprocessor. These cannot be #defined
701 and always have their stated meaning. They are treated like normal
702 identifiers except for the type code and the meaning. Most of them
703 are only for C++ (but see iso646.h). */
704 O("and", CPP_AND_AND, CPLUS),
705 O("and_eq", CPP_AND_EQ, CPLUS),
706 O("bitand", CPP_AND, CPLUS),
707 O("bitor", CPP_OR, CPLUS),
708 O("compl", CPP_COMPL, CPLUS),
709 O("not", CPP_NOT, CPLUS),
710 O("not_eq", CPP_NOT_EQ, CPLUS),
711 O("or", CPP_OR_OR, CPLUS),
712 O("or_eq", CPP_OR_EQ, CPLUS),
713 O("xor", CPP_XOR, CPLUS),
714 O("xor_eq", CPP_XOR_EQ, CPLUS)
719 #define builtin_array_end \
720 builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
722 /* Subroutine of cpp_start_read; reads the builtins table above and
723 enters the macros into the hash table. */
725 initialize_builtins (pfile)
728 const struct builtin *b;
730 for(b = builtin_array; b < builtin_array_end; b++)
732 if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus))
735 if (b->flags & (OPERATOR | BUILTIN))
737 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
738 if (b->flags & OPERATOR)
740 hp->flags |= NODE_OPERATOR;
741 hp->value.operator = b->operator;
746 hp->flags |= NODE_BUILTIN;
747 hp->value.builtin = b->builtin;
750 else /* A standard macro of some kind. */
757 /* Allocate enough space for 'name "value"\n\0'. */
758 str = alloca (b->len + strlen (version_string) + 5);
759 sprintf (str, "%s \"%s\"\n", b->name, version_string);
764 val = CPP_OPTION (pfile, user_label_prefix);
768 /* Allocate enough space for "name value\n\0". */
769 str = alloca (b->len + strlen (val) + 3);
770 sprintf(str, "%s %s\n", b->name, val);
773 _cpp_define_builtin (pfile, str);
782 #undef builtin_array_end
784 /* Another subroutine of cpp_start_read. This one sets up to do
785 dependency-file output. */
787 initialize_dependency_output (pfile)
790 char *spec, *s, *output_file;
792 /* Either of two environment variables can specify output of deps.
793 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
794 where OUTPUT_FILE is the file to write deps info to
795 and DEPS_TARGET is the target to mention in the deps. */
797 if (CPP_OPTION (pfile, print_deps) == 0)
799 spec = getenv ("DEPENDENCIES_OUTPUT");
801 CPP_OPTION (pfile, print_deps) = 1;
804 spec = getenv ("SUNPRO_DEPENDENCIES");
806 CPP_OPTION (pfile, print_deps) = 2;
811 /* Find the space before the DEPS_TARGET, if there is one. */
812 s = strchr (spec, ' ');
815 CPP_OPTION (pfile, deps_target) = s + 1;
816 output_file = (char *) xmalloc (s - spec + 1);
817 memcpy (output_file, spec, s - spec);
818 output_file[s - spec] = 0;
822 CPP_OPTION (pfile, deps_target) = 0;
826 CPP_OPTION (pfile, deps_file) = output_file;
827 CPP_OPTION (pfile, print_deps_append) = 1;
830 pfile->deps = deps_init ();
832 /* Print the expected object file name as the target of this Make-rule. */
833 if (CPP_OPTION (pfile, deps_target))
834 deps_add_target (pfile->deps, CPP_OPTION (pfile, deps_target));
835 else if (*CPP_OPTION (pfile, in_fname) == 0)
836 deps_add_target (pfile->deps, "-");
838 deps_calc_target (pfile->deps, CPP_OPTION (pfile, in_fname));
840 if (CPP_OPTION (pfile, in_fname))
841 deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
844 /* And another subroutine. This one sets up the standard include path. */
846 initialize_standard_includes (pfile)
850 const struct default_include *p;
851 const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
853 /* Several environment variables may add to the include search path.
854 CPATH specifies an additional list of directories to be searched
855 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
856 etc. specify an additional list of directories to be searched as
857 if specified with -isystem, for the language indicated. */
859 GET_ENV_PATH_LIST (path, "CPATH");
860 if (path != 0 && *path != 0)
861 path_include (pfile, path, BRACKET);
863 switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
866 GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
869 GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
872 GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
875 GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
878 if (path != 0 && *path != 0)
879 path_include (pfile, path, SYSTEM);
881 /* Search "translated" versions of GNU directories.
882 These have /usr/local/lib/gcc... replaced by specd_prefix. */
883 if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
885 /* Remove the `include' from /usr/local/lib/gcc.../include.
886 GCC_INCLUDE_DIR will always end in /include. */
887 int default_len = cpp_GCC_INCLUDE_DIR_len;
888 char *default_prefix = (char *) alloca (default_len + 1);
889 int specd_len = strlen (specd_prefix);
891 memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
892 default_prefix[default_len] = '\0';
894 for (p = cpp_include_defaults; p->fname; p++)
896 /* Some standard dirs are only for C++. */
898 || (CPP_OPTION (pfile, cplusplus)
899 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
901 /* Does this dir start with the prefix? */
902 if (!memcmp (p->fname, default_prefix, default_len))
904 /* Yes; change prefix and add to search list. */
905 int flen = strlen (p->fname);
906 int this_len = specd_len + flen - default_len;
907 char *str = (char *) xmalloc (this_len + 1);
908 memcpy (str, specd_prefix, specd_len);
909 memcpy (str + specd_len,
910 p->fname + default_len,
911 flen - default_len + 1);
913 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
919 /* Search ordinary names for GNU include directories. */
920 for (p = cpp_include_defaults; p->fname; p++)
922 /* Some standard dirs are only for C++. */
924 || (CPP_OPTION (pfile, cplusplus)
925 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
927 char *str = xstrdup (update_path (p->fname, p->component));
928 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
933 /* Handles -imacro and -include from the command line. */
935 do_includes (pfile, p, scan)
937 struct pending_option *p;
942 struct pending_option *q;
944 /* Later: maybe update this to use the #include "" search path
945 if cpp_read_file fails. */
946 if (cpp_read_file (pfile, p->arg) && scan)
947 cpp_scan_buffer_nooutput (pfile);
954 /* This is called after options have been processed. Check options
955 for consistency, and setup for processing input from the file named
956 FNAME. (Use standard input if FNAME == NULL.) Return 1 on success,
960 cpp_start_read (pfile, fname)
964 struct pending_option *p, *q;
966 /* -MG doesn't select the form of output and must be specified with one of
967 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
968 inhibit compilation. */
969 if (CPP_OPTION (pfile, print_deps_missing_files)
970 && (CPP_OPTION (pfile, print_deps) == 0
971 || !CPP_OPTION (pfile, no_output)))
973 cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
977 /* -Wtraditional is not useful in C++ mode. */
978 if (CPP_OPTION (pfile, cplusplus))
979 CPP_OPTION (pfile, warn_traditional) = 0;
981 /* Do not warn about invalid token pasting if -lang-asm. */
982 if (CPP_OPTION (pfile, lang_asm))
983 CPP_OPTION (pfile, warn_paste) = 0;
985 /* Set this if it hasn't been set already. */
986 if (CPP_OPTION (pfile, user_label_prefix) == NULL)
987 CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
989 /* Set up the include search path now. */
990 if (! CPP_OPTION (pfile, no_standard_includes))
991 initialize_standard_includes (pfile);
993 merge_include_chains (pfile);
995 /* With -v, print the list of dirs to search. */
996 if (CPP_OPTION (pfile, verbose))
998 struct file_name_list *l;
999 fprintf (stderr, _("#include \"...\" search starts here:\n"));
1000 for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
1002 if (l == CPP_OPTION (pfile, bracket_include))
1003 fprintf (stderr, _("#include <...> search starts here:\n"));
1004 fprintf (stderr, " %s\n", l->name);
1006 fprintf (stderr, _("End of search list.\n"));
1009 /* Open the main input file. This must be done early, so we have a
1010 buffer to stand on. */
1011 if (CPP_OPTION (pfile, in_fname) == NULL
1012 || *CPP_OPTION (pfile, in_fname) == 0)
1014 CPP_OPTION (pfile, in_fname) = fname;
1015 if (CPP_OPTION (pfile, in_fname) == NULL)
1016 CPP_OPTION (pfile, in_fname) = "";
1018 if (CPP_OPTION (pfile, out_fname) == NULL)
1019 CPP_OPTION (pfile, out_fname) = "";
1021 if (!cpp_read_file (pfile, fname))
1024 initialize_dependency_output (pfile);
1026 /* Install __LINE__, etc. */
1027 initialize_builtins (pfile);
1029 /* Do -U's, -D's and -A's in the order they were seen. */
1030 p = CPP_OPTION (pfile, pending)->directive_head;
1033 (*p->handler) (pfile, p->arg);
1038 pfile->done_initializing = 1;
1040 /* The -imacros files can be scanned now, but the -include files
1041 have to be pushed onto the buffer stack and processed later,
1042 otherwise cppmain.c won't see the tokens. include_head was built
1043 up as a stack, and popping this stack onto the buffer stack means
1044 we preserve the order of the command line. */
1045 do_includes (pfile, CPP_OPTION (pfile, pending)->imacros_head, 1);
1046 do_includes (pfile, CPP_OPTION (pfile, pending)->include_head, 0);
1048 free (CPP_OPTION (pfile, pending));
1049 CPP_OPTION (pfile, pending) = NULL;
1054 /* This is called at the end of preprocessing. It pops the
1055 last buffer and writes dependency output. It should also
1056 clear macro definitions, such that you could call cpp_start_read
1057 with a new filename to restart processing. */
1062 if (CPP_BUFFER (pfile))
1064 cpp_ice (pfile, "buffers still stacked in cpp_finish");
1065 while (CPP_BUFFER (pfile))
1066 cpp_pop_buffer (pfile);
1069 /* Don't write the deps file if preprocessing has failed. */
1070 if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
1072 /* Stream on which to print the dependency information. */
1073 FILE *deps_stream = 0;
1074 const char *deps_mode
1075 = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
1076 if (CPP_OPTION (pfile, deps_file) == 0)
1077 deps_stream = stdout;
1080 deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
1081 if (deps_stream == 0)
1082 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
1086 deps_write (pfile->deps, deps_stream, 72);
1087 if (CPP_OPTION (pfile, deps_file))
1089 if (ferror (deps_stream) || fclose (deps_stream) != 0)
1090 cpp_fatal (pfile, "I/O error on output");
1095 /* Report on headers that could use multiple include guards. */
1096 if (CPP_OPTION (pfile, print_include_names))
1097 _cpp_report_missing_guards (pfile);
1101 new_pending_directive (pend, text, handler)
1102 struct cpp_pending *pend;
1104 cl_directive_handler handler;
1106 struct pending_option *o = (struct pending_option *)
1107 xmalloc (sizeof (struct pending_option));
1111 o->handler = handler;
1112 APPEND (pend, directive, o);
1115 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1116 I.e. a const string initializer with parens around it. That is
1117 what N_("string") resolves to, so we make no_* be macros instead. */
1118 #define no_arg N_("Argument missing after %s")
1119 #define no_ass N_("Assertion missing after %s")
1120 #define no_dir N_("Directory name missing after %s")
1121 #define no_fil N_("File name missing after %s")
1122 #define no_mac N_("Macro name missing after %s")
1123 #define no_pth N_("Path name missing after %s")
1124 #define no_num N_("Number missing after %s")
1126 /* This is the list of all command line options, with the leading
1127 "-" removed. It must be sorted in ASCII collating order. */
1128 #define COMMAND_LINE_OPTIONS \
1129 DEF_OPT("", 0, OPT_stdin_stdout) \
1130 DEF_OPT("$", 0, OPT_dollar) \
1131 DEF_OPT("+", 0, OPT_plus) \
1132 DEF_OPT("-help", 0, OPT__help) \
1133 DEF_OPT("-target-help", 0, OPT_target__help) \
1134 DEF_OPT("-version", 0, OPT__version) \
1135 DEF_OPT("A", no_ass, OPT_A) \
1136 DEF_OPT("C", 0, OPT_C) \
1137 DEF_OPT("D", no_mac, OPT_D) \
1138 DEF_OPT("H", 0, OPT_H) \
1139 DEF_OPT("I", no_dir, OPT_I) \
1140 DEF_OPT("M", 0, OPT_M) \
1141 DEF_OPT("MD", no_fil, OPT_MD) \
1142 DEF_OPT("MG", 0, OPT_MG) \
1143 DEF_OPT("MM", 0, OPT_MM) \
1144 DEF_OPT("MMD", no_fil, OPT_MMD) \
1145 DEF_OPT("P", 0, OPT_P) \
1146 DEF_OPT("U", no_mac, OPT_U) \
1147 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1148 DEF_OPT("d", no_arg, OPT_d) \
1149 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1150 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1151 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1152 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1153 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1154 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1155 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1156 DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
1157 DEF_OPT("h", 0, OPT_h) \
1158 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1159 DEF_OPT("imacros", no_fil, OPT_imacros) \
1160 DEF_OPT("include", no_fil, OPT_include) \
1161 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1162 DEF_OPT("isystem", no_dir, OPT_isystem) \
1163 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1164 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1165 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1166 DEF_OPT("lang-c", 0, OPT_lang_c) \
1167 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1168 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1169 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1170 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1171 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1172 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1173 DEF_OPT("o", no_fil, OPT_o) \
1174 DEF_OPT("pedantic", 0, OPT_pedantic) \
1175 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1176 DEF_OPT("remap", 0, OPT_remap) \
1177 DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
1178 DEF_OPT("std=c89", 0, OPT_std_c89) \
1179 DEF_OPT("std=c99", 0, OPT_std_c99) \
1180 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1181 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1182 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1183 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1184 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1185 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1186 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1187 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1188 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1189 DEF_OPT("v", 0, OPT_v) \
1190 DEF_OPT("w", 0, OPT_w)
1192 #define DEF_OPT(text, msg, code) code,
1195 COMMAND_LINE_OPTIONS
1202 const char *opt_text;
1205 enum opt_code opt_code;
1208 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1210 static struct cl_option cl_options[] =
1212 static const struct cl_option cl_options[] =
1215 COMMAND_LINE_OPTIONS
1218 #undef COMMAND_LINE_OPTIONS
1220 /* Perform a binary search to find which, if any, option the given
1221 command-line matches. Returns its index in the option array,
1222 negative on failure. Complications arise since some options can be
1223 suffixed with an argument, and multiple complete matches can occur,
1224 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
1225 accept options beginning with -g and -W that we do not recognise,
1226 but not to swallow any subsequent command line argument; these are
1227 handled as special cases in cpp_handle_option. */
1229 parse_option (input)
1232 unsigned int md, mn, mx;
1243 opt_len = cl_options[md].opt_len;
1244 comp = memcmp (input, cl_options[md].opt_text, opt_len);
1252 if (input[opt_len] == '\0')
1254 /* We were passed more text. If the option takes an argument,
1255 we may match a later option or we may have been passed the
1256 argument. The longest possible option match succeeds.
1257 If the option takes no arguments we have not matched and
1258 continue the search (e.g. input="stdc++" match was "stdc"). */
1260 if (cl_options[md].msg)
1262 /* Scan forwards. If we get an exact match, return it.
1263 Otherwise, return the longest option-accepting match.
1264 This loops no more than twice with current options. */
1266 for (; mn < N_OPTS; mn++)
1268 opt_len = cl_options[mn].opt_len;
1269 if (memcmp (input, cl_options[mn].opt_text, opt_len))
1271 if (input[opt_len] == '\0')
1273 if (cl_options[mn].msg)
1284 /* Handle one command-line option in (argc, argv).
1285 Can be called multiple times, to handle multiple sets of options.
1286 Returns number of strings consumed. */
1289 cpp_handle_option (pfile, argc, argv)
1295 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1297 if (argv[i][0] != '-')
1299 if (CPP_OPTION (pfile, out_fname) != NULL)
1300 cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
1302 else if (CPP_OPTION (pfile, in_fname) != NULL)
1303 CPP_OPTION (pfile, out_fname) = argv[i];
1305 CPP_OPTION (pfile, in_fname) = argv[i];
1309 enum opt_code opt_code;
1311 const char *arg = 0;
1313 /* Skip over '-'. */
1314 opt_index = parse_option (&argv[i][1]);
1318 opt_code = cl_options[opt_index].opt_code;
1319 if (cl_options[opt_index].msg)
1321 arg = &argv[i][cl_options[opt_index].opt_len + 1];
1323 /* Yuk. Special case for -g and -W as they must not swallow
1324 up any following argument. If this becomes common, add
1325 another field to the cl_options table. */
1326 if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
1331 cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1339 case N_OPTS: /* Shut GCC up. */
1341 case OPT_fleading_underscore:
1342 CPP_OPTION (pfile, user_label_prefix) = "_";
1344 case OPT_fno_leading_underscore:
1345 CPP_OPTION (pfile, user_label_prefix) = "";
1347 case OPT_fpreprocessed:
1348 CPP_OPTION (pfile, preprocessed) = 1;
1350 case OPT_fno_preprocessed:
1351 CPP_OPTION (pfile, preprocessed) = 0;
1353 case OPT_fshow_column:
1354 CPP_OPTION (pfile, show_column) = 1;
1356 case OPT_fno_show_column:
1357 CPP_OPTION (pfile, show_column) = 0;
1360 /* Silently ignore empty string, non-longs and silly values. */
1364 long tabstop = strtol (arg, &endptr, 10);
1365 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1366 CPP_OPTION (pfile, tabstop) = tabstop;
1370 CPP_OPTION (pfile, inhibit_warnings) = 1;
1372 case OPT_g: /* Silently ignore anything but -g3. */
1373 if (!strcmp(&argv[i][2], "3"))
1374 CPP_OPTION (pfile, debug_output) = 1;
1381 case OPT_target__help:
1382 /* Print if any target specific options. */
1386 fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1390 CPP_OPTION (pfile, discard_comments) = 0;
1393 CPP_OPTION (pfile, no_line_commands) = 1;
1395 case OPT_dollar: /* Don't include $ in identifiers. */
1396 CPP_OPTION (pfile, dollars_in_ident) = 0;
1399 CPP_OPTION (pfile, print_include_names) = 1;
1402 new_pending_directive (pend, arg, cpp_define);
1404 case OPT_pedantic_errors:
1405 CPP_OPTION (pfile, pedantic_errors) = 1;
1408 CPP_OPTION (pfile, pedantic) = 1;
1411 CPP_OPTION (pfile, trigraphs) = 1;
1414 CPP_OPTION (pfile, cplusplus) = 1;
1415 CPP_OPTION (pfile, cplusplus_comments) = 1;
1418 CPP_OPTION (pfile, remap) = 1;
1421 CPP_OPTION (pfile, include_prefix) = arg;
1422 CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1425 set_lang (pfile, CLK_GNUC89);
1427 case OPT_lang_cplusplus:
1428 set_lang (pfile, CLK_GNUCXX);
1431 set_lang (pfile, CLK_OBJC);
1433 case OPT_lang_objcplusplus:
1434 set_lang (pfile, CLK_OBJCXX);
1437 set_lang (pfile, CLK_ASM);
1439 case OPT_std_cplusplus98:
1440 set_lang (pfile, CLK_CXX98);
1443 set_lang (pfile, CLK_GNUC89);
1447 set_lang (pfile, CLK_GNUC99);
1449 case OPT_std_iso9899_199409:
1450 set_lang (pfile, CLK_STDC94);
1452 case OPT_std_iso9899_1990:
1455 set_lang (pfile, CLK_STDC89);
1457 case OPT_std_iso9899_199x:
1458 case OPT_std_iso9899_1999:
1461 set_lang (pfile, CLK_STDC99);
1464 /* -nostdinc causes no default include directories.
1465 You must specify all include-file directories with -I. */
1466 CPP_OPTION (pfile, no_standard_includes) = 1;
1468 case OPT_nostdincplusplus:
1469 /* -nostdinc++ causes no default C++-specific include directories. */
1470 CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1473 if (CPP_OPTION (pfile, out_fname) != NULL)
1475 cpp_fatal (pfile, "Output filename specified twice");
1478 CPP_OPTION (pfile, out_fname) = arg;
1479 if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
1480 CPP_OPTION (pfile, out_fname) = "";
1483 fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1484 #ifdef TARGET_VERSION
1487 fputc ('\n', stderr);
1488 CPP_OPTION (pfile, verbose) = 1;
1490 case OPT_stdin_stdout:
1491 /* JF handle '-' as file name meaning stdin or stdout. */
1492 if (CPP_OPTION (pfile, in_fname) == NULL)
1493 CPP_OPTION (pfile, in_fname) = "";
1494 else if (CPP_OPTION (pfile, out_fname) == NULL)
1495 CPP_OPTION (pfile, out_fname) = "";
1498 /* Args to -d specify what parts of macros to dump.
1499 Silently ignore unrecognised options; they may
1500 be aimed at the compiler proper. */
1504 while ((c = *arg++) != '\0')
1508 CPP_OPTION (pfile, dump_macros) = dump_only;
1509 CPP_OPTION (pfile, no_output) = 1;
1512 CPP_OPTION (pfile, dump_macros) = dump_names;
1515 CPP_OPTION (pfile, dump_macros) = dump_definitions;
1518 CPP_OPTION (pfile, dump_includes) = 1;
1523 /* The style of the choices here is a bit mixed.
1524 The chosen scheme is a hybrid of keeping all options in one string
1525 and specifying each option in a separate argument:
1526 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1527 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1528 -M[M][G][D file]. This is awkward to handle in specs, and is not
1530 /* ??? -MG must be specified in addition to one of -M or -MM.
1531 This can be relaxed in the future without breaking anything.
1532 The converse isn't true. */
1534 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1536 CPP_OPTION (pfile, print_deps_missing_files) = 1;
1542 if (opt_code == OPT_M || opt_code == OPT_MD)
1543 CPP_OPTION (pfile, print_deps) = 2;
1545 CPP_OPTION (pfile, print_deps) = 1;
1547 /* For -MD and -MMD, write deps on file named by next arg. */
1548 /* For -M and -MM, write deps on standard output and
1549 suppress the usual output. */
1550 if (opt_code == OPT_MD || opt_code == OPT_MMD)
1551 CPP_OPTION (pfile, deps_file) = arg;
1553 CPP_OPTION (pfile, no_output) = 1;
1558 /* -A with an argument beginning with '-' acts as
1559 #unassert on whatever immediately follows the '-'.
1560 If "-" is the whole argument, we eliminate all
1561 predefined macros and assertions, including those
1562 that were specified earlier on the command line.
1563 That way we can get rid of any that were passed
1564 automatically in from GCC. */
1568 struct pending_option *o1, *o2;
1570 o1 = pend->directive_head;
1577 pend->directive_head = NULL;
1578 pend->directive_tail = NULL;
1581 new_pending_directive (pend, arg + 1, cpp_unassert);
1584 new_pending_directive (pend, arg, cpp_assert);
1587 new_pending_directive (pend, arg, cpp_undef);
1589 case OPT_I: /* Add directory to path for includes. */
1590 if (!strcmp (arg, "-"))
1593 Use the preceding -I directories for #include "..."
1594 but not #include <...>.
1595 Don't search the directory of the present file
1596 for #include "...". (Note that -I. -I- is not the same as
1597 the default setup; -I. uses the compiler's working dir.) */
1598 if (! CPP_OPTION (pfile, ignore_srcdir))
1600 pend->quote_head = pend->brack_head;
1601 pend->quote_tail = pend->brack_tail;
1602 pend->brack_head = 0;
1603 pend->brack_tail = 0;
1604 CPP_OPTION (pfile, ignore_srcdir) = 1;
1608 cpp_fatal (pfile, "-I- specified twice");
1613 append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1616 /* Add directory to beginning of system include path, as a system
1617 include directory. */
1618 append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1622 struct pending_option *o = (struct pending_option *)
1623 xmalloc (sizeof (struct pending_option));
1626 /* This list has to be built in reverse order so that
1627 when cpp_start_read pushes all the -include files onto
1628 the buffer stack, they will be scanned in forward order. */
1629 o->next = pend->include_head;
1630 pend->include_head = o;
1635 struct pending_option *o = (struct pending_option *)
1636 xmalloc (sizeof (struct pending_option));
1640 APPEND (pend, imacros, o);
1643 case OPT_iwithprefix:
1644 /* Add directory to end of path for includes,
1645 with the default prefix at the front of its name. */
1647 case OPT_iwithprefixbefore:
1648 /* Add directory to main path for includes,
1649 with the default prefix at the front of its name. */
1656 if (CPP_OPTION (pfile, include_prefix) != 0)
1658 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1659 fname = xmalloc (ipl + len + 1);
1660 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1661 memcpy (fname + ipl, arg, len + 1);
1663 else if (cpp_GCC_INCLUDE_DIR_len)
1665 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1666 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1667 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1670 fname = xstrdup (arg);
1672 append_include_chain (pfile, fname,
1673 opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1677 /* Add directory to end of path for includes. */
1678 append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1681 /* Silently ignore unrecognised options. */
1682 if (!strcmp (argv[i], "-Wall"))
1684 CPP_OPTION (pfile, warn_trigraphs) = 1;
1685 CPP_OPTION (pfile, warn_comments) = 1;
1687 else if (!strcmp (argv[i], "-Wtraditional"))
1688 CPP_OPTION (pfile, warn_traditional) = 1;
1689 else if (!strcmp (argv[i], "-Wtrigraphs"))
1690 CPP_OPTION (pfile, warn_trigraphs) = 1;
1691 else if (!strcmp (argv[i], "-Wcomment"))
1692 CPP_OPTION (pfile, warn_comments) = 1;
1693 else if (!strcmp (argv[i], "-Wcomments"))
1694 CPP_OPTION (pfile, warn_comments) = 1;
1695 else if (!strcmp (argv[i], "-Wundef"))
1696 CPP_OPTION (pfile, warn_undef) = 1;
1697 else if (!strcmp (argv[i], "-Wimport"))
1698 CPP_OPTION (pfile, warn_import) = 1;
1699 else if (!strcmp (argv[i], "-Wpaste"))
1700 CPP_OPTION (pfile, warn_paste) = 1;
1701 else if (!strcmp (argv[i], "-Werror"))
1702 CPP_OPTION (pfile, warnings_are_errors) = 1;
1703 else if (!strcmp (argv[i], "-Wsystem-headers"))
1704 CPP_OPTION (pfile, warn_system_headers) = 1;
1705 else if (!strcmp (argv[i], "-Wno-traditional"))
1706 CPP_OPTION (pfile, warn_traditional) = 0;
1707 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1708 CPP_OPTION (pfile, warn_trigraphs) = 0;
1709 else if (!strcmp (argv[i], "-Wno-comment"))
1710 CPP_OPTION (pfile, warn_comments) = 0;
1711 else if (!strcmp (argv[i], "-Wno-comments"))
1712 CPP_OPTION (pfile, warn_comments) = 0;
1713 else if (!strcmp (argv[i], "-Wno-undef"))
1714 CPP_OPTION (pfile, warn_undef) = 0;
1715 else if (!strcmp (argv[i], "-Wno-import"))
1716 CPP_OPTION (pfile, warn_import) = 0;
1717 else if (!strcmp (argv[i], "-Wno-paste"))
1718 CPP_OPTION (pfile, warn_paste) = 0;
1719 else if (!strcmp (argv[i], "-Wno-error"))
1720 CPP_OPTION (pfile, warnings_are_errors) = 0;
1721 else if (!strcmp (argv[i], "-Wno-system-headers"))
1722 CPP_OPTION (pfile, warn_system_headers) = 0;
1731 opt_comp (const void *p1, const void *p2)
1733 return strcmp (((struct cl_option *)p1)->opt_text,
1734 ((struct cl_option *)p2)->opt_text);
1738 /* Handle command-line options in (argc, argv).
1739 Can be called multiple times, to handle multiple sets of options.
1740 Returns if an unrecognized option is seen.
1741 Returns number of strings consumed. */
1743 cpp_handle_options (pfile, argc, argv)
1749 int strings_processed;
1751 for (i = 0; i < argc; i += strings_processed)
1753 strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1754 if (strings_processed == 0)
1763 fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1764 /* To keep the lines from getting too long for some compilers, limit
1765 to about 500 characters (6 lines) per chunk. */
1768 -include <file> Include the contents of <file> before other files\n\
1769 -imacros <file> Accept definition of macros in <file>\n\
1770 -iprefix <path> Specify <path> as a prefix for next two options\n\
1771 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1772 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1773 -isystem <dir> Add <dir> to the start of the system include path\n\
1776 -idirafter <dir> Add <dir> to the end of the system include path\n\
1777 -I <dir> Add <dir> to the end of the main include path\n\
1778 -I- Fine-grained include path control; see info docs\n\
1779 -nostdinc Do not search system include directories\n\
1780 (dirs specified with -isystem will still be used)\n\
1781 -nostdinc++ Do not search system include directories for C++\n\
1782 -o <file> Put output into <file>\n\
1785 -pedantic Issue all warnings demanded by strict ISO C\n\
1786 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1787 -trigraphs Support ISO C trigraphs\n\
1788 -lang-c Assume that the input sources are in C\n\
1789 -lang-c89 Assume that the input sources are in C89\n\
1792 -lang-c++ Assume that the input sources are in C++\n\
1793 -lang-objc Assume that the input sources are in ObjectiveC\n\
1794 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1795 -lang-asm Assume that the input sources are in assembler\n\
1798 -std=<std name> Specify the conformance standard; one of:\n\
1799 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1800 iso9899:199409, iso9899:1999\n\
1801 -+ Allow parsing of C++ style features\n\
1802 -w Inhibit warning messages\n\
1803 -Wtrigraphs Warn if trigraphs are encountered\n\
1804 -Wno-trigraphs Do not warn about trigraphs\n\
1805 -Wcomment{s} Warn if one comment starts inside another\n\
1808 -Wno-comment{s} Do not warn about comments\n\
1809 -Wtraditional Warn about features not present in traditional C\n\
1810 -Wno-traditional Do not warn about traditional C\n\
1811 -Wundef Warn if an undefined macro is used by #if\n\
1812 -Wno-undef Do not warn about testing undefined macros\n\
1813 -Wimport Warn about the use of the #import directive\n\
1816 -Wno-import Do not warn about the use of #import\n\
1817 -Werror Treat all warnings as errors\n\
1818 -Wno-error Do not treat warnings as errors\n\
1819 -Wsystem-headers Do not suppress warnings from system headers\n\
1820 -Wno-system-headers Suppress warnings from system headers\n\
1821 -Wall Enable all preprocessor warnings\n\
1824 -M Generate make dependencies\n\
1825 -MM As -M, but ignore system header files\n\
1826 -MD As -M, but put output in a .d file\n\
1827 -MMD As -MD, but ignore system header files\n\
1828 -MG Treat missing header file as generated files\n\
1829 -g3 Include #define and #undef directives in the output\n\
1832 -D<macro> Define a <macro> with string '1' as its value\n\
1833 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1834 -A<question> (<answer>) Assert the <answer> to <question>\n\
1835 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1836 -U<macro> Undefine <macro> \n\
1837 -v Display the version number\n\
1840 -H Print the name of header files as they are used\n\
1841 -C Do not discard comments\n\
1842 -dM Display a list of macro definitions active at end\n\
1843 -dD Preserve macro definitions in output\n\
1844 -dN As -dD except that only the names are preserved\n\
1845 -dI Include #include directives in the output\n\
1848 -ftabstop=<number> Distance between tab stops for column reporting\n\
1849 -P Do not generate #line directives\n\
1850 -$ Do not allow '$' in identifiers\n\
1851 -remap Remap file names when including files.\n\
1852 --version Display version information\n\
1853 -h or --help Display this information\n\