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 -imacros
53 switch. There are four lists: one for -D and -U, one for -A, one
54 for -include, one for -imacros. `undef' is set for -U, clear for
55 -D, ignored for the others.
56 (Future: add an equivalent of -U for -A) */
58 typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
61 struct pending_option *next;
63 cl_directive_handler handler;
66 /* The `pending' structure accumulates all the options that are not
67 actually processed until we hit cpp_start_read. It consists of
68 several lists, one for each type of option. We keep both head and
69 tail pointers for quick insertion. */
72 struct pending_option *directive_head, *directive_tail;
74 struct file_name_list *quote_head, *quote_tail;
75 struct file_name_list *brack_head, *brack_tail;
76 struct file_name_list *systm_head, *systm_tail;
77 struct file_name_list *after_head, *after_tail;
79 struct pending_option *imacros_head, *imacros_tail;
80 struct pending_option *include_head, *include_tail;
84 #define APPEND(pend, list, elt) \
85 do { if (!(pend)->list##_head) (pend)->list##_head = (elt); \
86 else (pend)->list##_tail->next = (elt); \
87 (pend)->list##_tail = (elt); \
90 #define APPEND(pend, list, elt) \
91 do { if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
92 else (pend)->list/**/_tail->next = (elt); \
93 (pend)->list/**/_tail = (elt); \
97 static void print_help PARAMS ((void));
98 static void path_include PARAMS ((cpp_reader *,
100 static void initialize_builtins PARAMS ((cpp_reader *));
101 static void append_include_chain PARAMS ((cpp_reader *,
103 struct file_name_list * remove_dup_dir PARAMS ((cpp_reader *,
104 struct file_name_list *));
105 struct file_name_list * remove_dup_dirs PARAMS ((cpp_reader *,
106 struct file_name_list *));
107 static void merge_include_chains PARAMS ((cpp_reader *));
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 /* Initialize a cpp_reader structure. */
427 cpp_reader_init (pfile)
430 memset ((char *) pfile, 0, sizeof (cpp_reader));
432 CPP_OPTION (pfile, dollars_in_ident) = 1;
433 CPP_OPTION (pfile, cplusplus_comments) = 1;
434 CPP_OPTION (pfile, warn_import) = 1;
435 CPP_OPTION (pfile, warn_paste) = 1;
436 CPP_OPTION (pfile, digraphs) = 1;
437 CPP_OPTION (pfile, discard_comments) = 1;
438 CPP_OPTION (pfile, show_column) = 1;
439 CPP_OPTION (pfile, tabstop) = 8;
441 CPP_OPTION (pfile, pending) =
442 (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
444 /* If cpp_init hasn't been called, generate a fatal error (by hand)
446 if (!cpp_init_completed)
448 fputs ("cpp_reader_init: internal error: cpp_init not called.\n", stderr);
449 pfile->errors = CPP_FATAL_LIMIT;
453 _cpp_init_macros (pfile);
454 _cpp_init_stacks (pfile);
455 _cpp_init_includes (pfile);
456 _cpp_init_internal_pragmas (pfile);
459 /* Initialize a cpp_printer structure. As a side effect, open the
462 cpp_printer_init (pfile, print)
466 memset (print, '\0', sizeof (cpp_printer));
467 if (CPP_OPTION (pfile, out_fname) == NULL)
468 CPP_OPTION (pfile, out_fname) = "";
470 if (CPP_OPTION (pfile, out_fname)[0] == '\0')
471 print->outf = stdout;
474 print->outf = fopen (CPP_OPTION (pfile, out_fname), "w");
477 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
484 /* Free resources used by PFILE.
485 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
490 struct file_name_list *dir, *next;
492 while (CPP_BUFFER (pfile) != NULL)
493 cpp_pop_buffer (pfile);
496 deps_free (pfile->deps);
498 if (pfile->spec_nodes)
499 free (pfile->spec_nodes);
501 _cpp_free_temp_tokens (pfile);
502 _cpp_cleanup_includes (pfile);
503 _cpp_cleanup_stacks (pfile);
504 _cpp_cleanup_macros (pfile);
506 for (dir = CPP_OPTION (pfile, quote_include); dir; dir = next)
515 /* This structure defines one built-in macro. A node of type TYPE will
516 be entered in the macro hash table under the name NAME, with value
517 VALUE (if any). If TYPE is T_OPERATOR, the CODE field is used instead.
519 Two values are not compile time constants, so we tag
520 them in the FLAGS field instead:
521 VERS value is the global version_string, quoted
522 ULP value is the global user_label_prefix
524 Also, macros with CPLUS set in the flags field are entered only for C++.
533 unsigned short flags;
540 #define B(n, t) { U n, 0, 0, t, 0, sizeof n - 1 }
541 #define C(n, v) { U n, v, 0, T_MACRO, 0, sizeof n - 1 }
542 #define X(n, f) { U n, 0, 0, T_MACRO, f, sizeof n - 1 }
543 #define O(n, c, f) { U n, 0, c, T_OPERATOR, f, sizeof n - 1 }
544 static const struct builtin builtin_array[] =
546 B("__TIME__", T_TIME),
547 B("__DATE__", T_DATE),
548 B("__FILE__", T_FILE),
549 B("__BASE_FILE__", T_BASE_FILE),
550 B("__LINE__", T_SPECLINE),
551 B("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL),
552 B("__STDC__", T_STDC),
554 X("__VERSION__", VERS),
555 X("__USER_LABEL_PREFIX__", ULP),
556 C("__REGISTER_PREFIX__", REGISTER_PREFIX),
557 C("__HAVE_BUILTIN_SETJMP__", "1"),
558 #ifndef NO_BUILTIN_SIZE_TYPE
559 C("__SIZE_TYPE__", SIZE_TYPE),
561 #ifndef NO_BUILTIN_PTRDIFF_TYPE
562 C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
564 #ifndef NO_BUILTIN_WCHAR_TYPE
565 C("__WCHAR_TYPE__", WCHAR_TYPE),
567 #ifndef NO_BUILTIN_WINT_TYPE
568 C("__WINT_TYPE__", WINT_TYPE),
571 /* Named operators known to the preprocessor. These cannot be #defined
572 and always have their stated meaning. They are treated like normal
573 string tokens except for the type code and the meaning. Most of them
574 are only for C++ (but see iso646.h). */
575 O("defined", CPP_DEFINED, 0),
576 O("and", CPP_AND_AND, CPLUS),
577 O("and_eq", CPP_AND_EQ, CPLUS),
578 O("bitand", CPP_AND, CPLUS),
579 O("bitor", CPP_OR, CPLUS),
580 O("compl", CPP_COMPL, CPLUS),
581 O("not", CPP_NOT, CPLUS),
582 O("not_eq", CPP_NOT_EQ, CPLUS),
583 O("or", CPP_OR_OR, CPLUS),
584 O("or_eq", CPP_OR_EQ, CPLUS),
585 O("xor", CPP_XOR, CPLUS),
586 O("xor_eq", CPP_XOR_EQ, CPLUS),
591 #define builtin_array_end \
592 builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
594 /* Subroutine of cpp_start_read; reads the builtins table above and
595 enters the macros into the hash table. */
597 initialize_builtins (pfile)
600 const struct builtin *b;
602 for(b = builtin_array; b < builtin_array_end; b++)
604 if (b->flags & CPLUS && ! CPP_OPTION (pfile, cplusplus))
607 if (b->type == T_MACRO)
614 /* Allocate enough space for 'name "value"\n\0'. */
615 str = alloca (b->len + strlen (version_string) + 5);
616 sprintf (str, "%s \"%s\"\n", b->name, version_string);
621 val = CPP_OPTION (pfile, user_label_prefix);
625 /* Allocate enough space for "name value\n\0". */
626 str = alloca (b->len + strlen (val) + 3);
627 sprintf(str, "%s %s\n", b->name, val);
630 _cpp_define_builtin (pfile, str);
634 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
636 if (b->type == T_OPERATOR)
637 hp->value.code = b->code;
643 #undef builtin_array_end
645 /* Another subroutine of cpp_start_read. This one sets up to do
646 dependency-file output. */
648 initialize_dependency_output (pfile)
651 char *spec, *s, *output_file;
653 /* Either of two environment variables can specify output of deps.
654 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
655 where OUTPUT_FILE is the file to write deps info to
656 and DEPS_TARGET is the target to mention in the deps. */
658 if (CPP_OPTION (pfile, print_deps) == 0)
660 spec = getenv ("DEPENDENCIES_OUTPUT");
662 CPP_OPTION (pfile, print_deps) = 1;
665 spec = getenv ("SUNPRO_DEPENDENCIES");
667 CPP_OPTION (pfile, print_deps) = 2;
672 /* Find the space before the DEPS_TARGET, if there is one. */
673 s = strchr (spec, ' ');
676 CPP_OPTION (pfile, deps_target) = s + 1;
677 output_file = (char *) xmalloc (s - spec + 1);
678 memcpy (output_file, spec, s - spec);
679 output_file[s - spec] = 0;
683 CPP_OPTION (pfile, deps_target) = 0;
687 CPP_OPTION (pfile, deps_file) = output_file;
688 CPP_OPTION (pfile, print_deps_append) = 1;
691 pfile->deps = deps_init ();
693 /* Print the expected object file name as the target of this Make-rule. */
694 if (CPP_OPTION (pfile, deps_target))
695 deps_add_target (pfile->deps, CPP_OPTION (pfile, deps_target));
696 else if (*CPP_OPTION (pfile, in_fname) == 0)
697 deps_add_target (pfile->deps, "-");
699 deps_calc_target (pfile->deps, CPP_OPTION (pfile, in_fname));
701 if (CPP_OPTION (pfile, in_fname))
702 deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
705 /* And another subroutine. This one sets up the standard include path. */
707 initialize_standard_includes (pfile)
711 const struct default_include *p;
712 const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
714 /* Several environment variables may add to the include search path.
715 CPATH specifies an additional list of directories to be searched
716 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
717 etc. specify an additional list of directories to be searched as
718 if specified with -isystem, for the language indicated. */
720 GET_ENV_PATH_LIST (path, "CPATH");
721 if (path != 0 && *path != 0)
722 path_include (pfile, path, BRACKET);
724 switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
727 GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
730 GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
733 GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
736 GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
739 if (path != 0 && *path != 0)
740 path_include (pfile, path, SYSTEM);
742 /* Search "translated" versions of GNU directories.
743 These have /usr/local/lib/gcc... replaced by specd_prefix. */
744 if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
746 /* Remove the `include' from /usr/local/lib/gcc.../include.
747 GCC_INCLUDE_DIR will always end in /include. */
748 int default_len = cpp_GCC_INCLUDE_DIR_len;
749 char *default_prefix = (char *) alloca (default_len + 1);
750 int specd_len = strlen (specd_prefix);
752 memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
753 default_prefix[default_len] = '\0';
755 for (p = cpp_include_defaults; p->fname; p++)
757 /* Some standard dirs are only for C++. */
759 || (CPP_OPTION (pfile, cplusplus)
760 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
762 /* Does this dir start with the prefix? */
763 if (!memcmp (p->fname, default_prefix, default_len))
765 /* Yes; change prefix and add to search list. */
766 int flen = strlen (p->fname);
767 int this_len = specd_len + flen - default_len;
768 char *str = (char *) xmalloc (this_len + 1);
769 memcpy (str, specd_prefix, specd_len);
770 memcpy (str + specd_len,
771 p->fname + default_len,
772 flen - default_len + 1);
774 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
780 /* Search ordinary names for GNU include directories. */
781 for (p = cpp_include_defaults; p->fname; p++)
783 /* Some standard dirs are only for C++. */
785 || (CPP_OPTION (pfile, cplusplus)
786 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
788 /* XXX Potential memory leak! */
789 char *str = xstrdup (update_path (p->fname, p->component));
790 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
795 /* This is called after options have been processed.
796 * Check options for consistency, and setup for processing input
797 * from the file named FNAME. (Use standard input if FNAME==NULL.)
798 * Return 1 on success, 0 on failure.
802 cpp_start_read (pfile, print, fname)
807 struct pending_option *p, *q;
809 /* -MG doesn't select the form of output and must be specified with one of
810 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
811 inhibit compilation. */
812 if (CPP_OPTION (pfile, print_deps_missing_files)
813 && (CPP_OPTION (pfile, print_deps) == 0
814 || !CPP_OPTION (pfile, no_output)))
816 cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
820 /* -Wtraditional is not useful in C++ mode. */
821 if (CPP_OPTION (pfile, cplusplus))
822 CPP_OPTION (pfile, warn_traditional) = 0;
824 /* Do not warn about invalid token pasting if -lang-asm. */
825 if (CPP_OPTION (pfile, lang_asm))
826 CPP_OPTION (pfile, warn_paste) = 0;
828 /* Set this if it hasn't been set already. */
829 if (CPP_OPTION (pfile, user_label_prefix) == NULL)
830 CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
832 /* Figure out if we need to save function macro parameter spellings.
833 We don't use CPP_PEDANTIC() here because that depends on whether
834 or not the current file is a system header, and there is no
836 pfile->save_parameter_spellings =
837 CPP_OPTION (pfile, pedantic)
838 || CPP_OPTION (pfile, debug_output)
839 || CPP_OPTION (pfile, dump_macros) == dump_definitions
840 || CPP_OPTION (pfile, dump_macros) == dump_only;
842 /* Set up the tables used by read_and_prescan. */
843 _cpp_init_input_buffer (pfile);
845 /* Set up the include search path now. */
846 if (! CPP_OPTION (pfile, no_standard_includes))
847 initialize_standard_includes (pfile);
849 merge_include_chains (pfile);
851 /* With -v, print the list of dirs to search. */
852 if (CPP_OPTION (pfile, verbose))
854 struct file_name_list *l;
855 fprintf (stderr, _("#include \"...\" search starts here:\n"));
856 for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
858 if (l == CPP_OPTION (pfile, bracket_include))
859 fprintf (stderr, _("#include <...> search starts here:\n"));
860 fprintf (stderr, " %s\n", l->name);
862 fprintf (stderr, _("End of search list.\n"));
865 /* Open the main input file. This must be done early, so we have a
866 buffer to stand on. */
867 if (CPP_OPTION (pfile, in_fname) == NULL
868 || *CPP_OPTION (pfile, in_fname) == 0)
870 CPP_OPTION (pfile, in_fname) = fname;
871 if (CPP_OPTION (pfile, in_fname) == NULL)
872 CPP_OPTION (pfile, in_fname) = "";
874 if (CPP_OPTION (pfile, out_fname) == NULL)
875 CPP_OPTION (pfile, out_fname) = "";
877 if (!cpp_read_file (pfile, fname))
880 initialize_dependency_output (pfile);
882 /* Install __LINE__, etc. */
883 initialize_builtins (pfile);
885 /* Do -U's, -D's and -A's in the order they were seen. */
886 p = CPP_OPTION (pfile, pending)->directive_head;
889 (*p->handler) (pfile, p->arg);
894 pfile->done_initializing = 1;
896 /* We start at line 1 of the main input file. */
899 print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
903 /* The -imacros files can be scanned now, but the -include files
904 have to be pushed onto the include stack and processed later,
905 in the main loop calling cpp_get_token. */
907 p = CPP_OPTION (pfile, pending)->imacros_head;
910 if (cpp_read_file (pfile, p->arg))
911 cpp_scan_buffer_nooutput (pfile);
917 p = CPP_OPTION (pfile, pending)->include_head;
920 cpp_read_file (pfile, p->arg);
926 free (CPP_OPTION (pfile, pending));
927 CPP_OPTION (pfile, pending) = NULL;
932 /* This is called at the end of preprocessing. It pops the
933 last buffer and writes dependency output. It should also
934 clear macro definitions, such that you could call cpp_start_read
935 with a new filename to restart processing. */
937 cpp_finish (pfile, print)
941 if (CPP_BUFFER (pfile))
943 cpp_ice (pfile, "buffers still stacked in cpp_finish");
944 while (CPP_BUFFER (pfile))
945 cpp_pop_buffer (pfile);
948 /* Don't write the deps file if preprocessing has failed. */
949 if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
951 /* Stream on which to print the dependency information. */
952 FILE *deps_stream = 0;
953 const char *deps_mode
954 = CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
955 if (CPP_OPTION (pfile, deps_file) == 0)
956 deps_stream = stdout;
959 deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
960 if (deps_stream == 0)
961 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
965 deps_write (pfile->deps, deps_stream, 72);
966 if (CPP_OPTION (pfile, deps_file))
968 if (ferror (deps_stream) || fclose (deps_stream) != 0)
969 cpp_fatal (pfile, "I/O error on output");
974 /* Flush any pending output. */
977 if (pfile->need_newline)
978 putc ('\n', print->outf);
979 if (ferror (print->outf) || fclose (print->outf))
980 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
983 /* Report on headers that could use multiple include guards. */
984 if (CPP_OPTION (pfile, print_include_names))
985 _cpp_report_missing_guards (pfile);
989 new_pending_directive (pend, text, handler)
990 struct cpp_pending *pend;
992 cl_directive_handler handler;
994 struct pending_option *o = (struct pending_option *)
995 xmalloc (sizeof (struct pending_option));
999 o->handler = handler;
1000 APPEND (pend, directive, o);
1003 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1004 I.e. a const string initializer with parens around it. That is
1005 what N_("string") resolves to, so we make no_* be macros instead. */
1006 #define no_arg N_("Argument missing after %s")
1007 #define no_ass N_("Assertion missing after %s")
1008 #define no_dir N_("Directory name missing after %s")
1009 #define no_fil N_("File name missing after %s")
1010 #define no_mac N_("Macro name missing after %s")
1011 #define no_pth N_("Path name missing after %s")
1012 #define no_num N_("Number missing after %s")
1014 /* This is the list of all command line options, with the leading
1015 "-" removed. It must be sorted in ASCII collating order. */
1016 #define COMMAND_LINE_OPTIONS \
1017 DEF_OPT("", 0, OPT_stdin_stdout) \
1018 DEF_OPT("$", 0, OPT_dollar) \
1019 DEF_OPT("+", 0, OPT_plus) \
1020 DEF_OPT("-help", 0, OPT__help) \
1021 DEF_OPT("-version", 0, OPT__version) \
1022 DEF_OPT("A", no_ass, OPT_A) \
1023 DEF_OPT("C", 0, OPT_C) \
1024 DEF_OPT("D", no_mac, OPT_D) \
1025 DEF_OPT("H", 0, OPT_H) \
1026 DEF_OPT("I", no_dir, OPT_I) \
1027 DEF_OPT("M", 0, OPT_M) \
1028 DEF_OPT("MD", no_fil, OPT_MD) \
1029 DEF_OPT("MG", 0, OPT_MG) \
1030 DEF_OPT("MM", 0, OPT_MM) \
1031 DEF_OPT("MMD", no_fil, OPT_MMD) \
1032 DEF_OPT("P", 0, OPT_P) \
1033 DEF_OPT("U", no_mac, OPT_U) \
1034 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1035 DEF_OPT("d", no_arg, OPT_d) \
1036 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1037 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1038 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1039 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1040 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1041 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1042 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1043 DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
1044 DEF_OPT("h", 0, OPT_h) \
1045 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1046 DEF_OPT("imacros", no_fil, OPT_imacros) \
1047 DEF_OPT("include", no_fil, OPT_include) \
1048 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1049 DEF_OPT("isystem", no_dir, OPT_isystem) \
1050 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1051 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1052 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1053 DEF_OPT("lang-c", 0, OPT_lang_c) \
1054 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1055 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1056 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1057 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1058 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1059 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1060 DEF_OPT("o", no_fil, OPT_o) \
1061 DEF_OPT("pedantic", 0, OPT_pedantic) \
1062 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1063 DEF_OPT("remap", 0, OPT_remap) \
1064 DEF_OPT("std=c89", 0, OPT_std_c89) \
1065 DEF_OPT("std=c99", 0, OPT_std_c99) \
1066 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1067 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1068 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1069 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1070 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1071 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1072 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1073 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1074 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1075 DEF_OPT("v", 0, OPT_v) \
1076 DEF_OPT("w", 0, OPT_w)
1078 #define DEF_OPT(text, msg, code) code,
1081 COMMAND_LINE_OPTIONS
1088 const char *opt_text;
1091 enum opt_code opt_code;
1094 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1096 static struct cl_option cl_options[] =
1098 static const struct cl_option cl_options[] =
1101 COMMAND_LINE_OPTIONS
1104 #undef COMMAND_LINE_OPTIONS
1106 /* Perform a binary search to find which, if any, option the given
1107 command-line matches. Returns its index in the option array,
1108 negative on failure. Complications arise since some options can be
1109 suffixed with an argument, and multiple complete matches can occur,
1110 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
1111 accept options beginning with -g and -W that we do not recognise,
1112 but not to swallow any subsequent command line argument; these are
1113 handled as special cases in cpp_handle_option */
1115 parse_option (input)
1118 unsigned int md, mn, mx;
1129 opt_len = cl_options[md].opt_len;
1130 comp = memcmp (input, cl_options[md].opt_text, opt_len);
1138 if (input[opt_len] == '\0')
1140 /* We were passed more text. If the option takes an argument,
1141 we may match a later option or we may have been passed the
1142 argument. The longest possible option match succeeds.
1143 If the option takes no arguments we have not matched and
1144 continue the search (e.g. input="stdc++" match was "stdc") */
1146 if (cl_options[md].msg)
1148 /* Scan forwards. If we get an exact match, return it.
1149 Otherwise, return the longest option-accepting match.
1150 This loops no more than twice with current options */
1152 for (; mn < N_OPTS; mn++)
1154 opt_len = cl_options[mn].opt_len;
1155 if (memcmp (input, cl_options[mn].opt_text, opt_len))
1157 if (input[opt_len] == '\0')
1159 if (cl_options[mn].msg)
1170 /* Handle one command-line option in (argc, argv).
1171 Can be called multiple times, to handle multiple sets of options.
1172 Returns number of strings consumed. */
1175 cpp_handle_option (pfile, argc, argv)
1181 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1183 if (argv[i][0] != '-')
1185 if (CPP_OPTION (pfile, out_fname) != NULL)
1186 cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
1188 else if (CPP_OPTION (pfile, in_fname) != NULL)
1189 CPP_OPTION (pfile, out_fname) = argv[i];
1191 CPP_OPTION (pfile, in_fname) = argv[i];
1195 enum opt_code opt_code;
1197 const char *arg = 0;
1200 opt_index = parse_option (&argv[i][1]);
1204 opt_code = cl_options[opt_index].opt_code;
1205 if (cl_options[opt_index].msg)
1207 arg = &argv[i][cl_options[opt_index].opt_len + 1];
1209 /* Yuk. Special case for -g and -W as they must not swallow
1210 up any following argument. If this becomes common, add
1211 another field to the cl_options table */
1212 if (arg[0] == '\0' && !(opt_code == OPT_g || opt_code == OPT_W))
1217 cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1225 case N_OPTS: /* shut GCC up */
1227 case OPT_fleading_underscore:
1228 CPP_OPTION (pfile, user_label_prefix) = "_";
1230 case OPT_fno_leading_underscore:
1231 CPP_OPTION (pfile, user_label_prefix) = "";
1233 case OPT_fpreprocessed:
1234 CPP_OPTION (pfile, preprocessed) = 1;
1236 case OPT_fno_preprocessed:
1237 CPP_OPTION (pfile, preprocessed) = 0;
1239 case OPT_fshow_column:
1240 CPP_OPTION (pfile, show_column) = 1;
1242 case OPT_fno_show_column:
1243 CPP_OPTION (pfile, show_column) = 0;
1246 /* Silently ignore empty string, non-longs and silly values. */
1250 long tabstop = strtol (arg, &endptr, 10);
1251 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1252 CPP_OPTION (pfile, tabstop) = tabstop;
1256 CPP_OPTION (pfile, inhibit_warnings) = 1;
1258 case OPT_g: /* Silently ignore anything but -g3 */
1259 if (!strcmp(&argv[i][2], "3"))
1260 CPP_OPTION (pfile, debug_output) = 1;
1268 fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1272 CPP_OPTION (pfile, discard_comments) = 0;
1275 CPP_OPTION (pfile, no_line_commands) = 1;
1277 case OPT_dollar: /* Don't include $ in identifiers. */
1278 CPP_OPTION (pfile, dollars_in_ident) = 0;
1281 CPP_OPTION (pfile, print_include_names) = 1;
1284 new_pending_directive (pend, arg, cpp_define);
1286 case OPT_pedantic_errors:
1287 CPP_OPTION (pfile, pedantic_errors) = 1;
1290 CPP_OPTION (pfile, pedantic) = 1;
1293 CPP_OPTION (pfile, trigraphs) = 1;
1296 CPP_OPTION (pfile, cplusplus) = 1;
1297 CPP_OPTION (pfile, cplusplus_comments) = 1;
1300 CPP_OPTION (pfile, remap) = 1;
1303 CPP_OPTION (pfile, include_prefix) = arg;
1304 CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1307 CPP_OPTION (pfile, cplusplus) = 0;
1308 CPP_OPTION (pfile, cplusplus_comments) = 1;
1309 CPP_OPTION (pfile, c89) = 0;
1310 CPP_OPTION (pfile, c99) = 1;
1311 CPP_OPTION (pfile, digraphs) = 1;
1312 CPP_OPTION (pfile, objc) = 0;
1314 case OPT_lang_cplusplus:
1315 CPP_OPTION (pfile, cplusplus) = 1;
1316 CPP_OPTION (pfile, cplusplus_comments) = 1;
1317 CPP_OPTION (pfile, c89) = 0;
1318 CPP_OPTION (pfile, c99) = 0;
1319 CPP_OPTION (pfile, objc) = 0;
1320 CPP_OPTION (pfile, digraphs) = 1;
1321 new_pending_directive (pend, "__cplusplus", cpp_define);
1323 case OPT_lang_objcplusplus:
1324 CPP_OPTION (pfile, cplusplus) = 1;
1325 new_pending_directive (pend, "__cplusplus", cpp_define);
1328 CPP_OPTION (pfile, cplusplus_comments) = 1;
1329 CPP_OPTION (pfile, c89) = 0;
1330 CPP_OPTION (pfile, c99) = 0;
1331 CPP_OPTION (pfile, objc) = 1;
1332 new_pending_directive (pend, "__OBJC__", cpp_define);
1335 CPP_OPTION (pfile, lang_asm) = 1;
1336 CPP_OPTION (pfile, dollars_in_ident) = 0;
1337 new_pending_directive (pend, "__ASSEMBLER__", cpp_define);
1340 /* -nostdinc causes no default include directories.
1341 You must specify all include-file directories with -I. */
1342 CPP_OPTION (pfile, no_standard_includes) = 1;
1344 case OPT_nostdincplusplus:
1345 /* -nostdinc++ causes no default C++-specific include directories. */
1346 CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1349 CPP_OPTION (pfile, cplusplus) = 0;
1350 CPP_OPTION (pfile, cplusplus_comments) = 1;
1351 CPP_OPTION (pfile, c89) = 1;
1352 CPP_OPTION (pfile, c99) = 0;
1353 CPP_OPTION (pfile, objc) = 0;
1354 CPP_OPTION (pfile, digraphs) = 1;
1358 CPP_OPTION (pfile, cplusplus) = 0;
1359 CPP_OPTION (pfile, cplusplus_comments) = 1;
1360 CPP_OPTION (pfile, c89) = 0;
1361 CPP_OPTION (pfile, c99) = 1;
1362 CPP_OPTION (pfile, digraphs) = 1;
1363 CPP_OPTION (pfile, objc) = 0;
1364 new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
1366 case OPT_std_iso9899_199409:
1367 new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define);
1369 case OPT_std_iso9899_1990:
1372 CPP_OPTION (pfile, cplusplus) = 0;
1373 CPP_OPTION (pfile, cplusplus_comments) = 0;
1374 CPP_OPTION (pfile, c89) = 1;
1375 CPP_OPTION (pfile, c99) = 0;
1376 CPP_OPTION (pfile, objc) = 0;
1377 CPP_OPTION (pfile, digraphs) = opt_code == OPT_std_iso9899_199409;
1378 CPP_OPTION (pfile, trigraphs) = 1;
1379 new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
1381 case OPT_std_iso9899_199x:
1382 case OPT_std_iso9899_1999:
1385 CPP_OPTION (pfile, cplusplus) = 0;
1386 CPP_OPTION (pfile, cplusplus_comments) = 1;
1387 CPP_OPTION (pfile, c89) = 0;
1388 CPP_OPTION (pfile, c99) = 1;
1389 CPP_OPTION (pfile, objc) = 0;
1390 CPP_OPTION (pfile, digraphs) = 1;
1391 CPP_OPTION (pfile, trigraphs) = 1;
1392 new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
1393 new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
1396 if (CPP_OPTION (pfile, out_fname) != NULL)
1398 cpp_fatal (pfile, "Output filename specified twice");
1401 CPP_OPTION (pfile, out_fname) = arg;
1402 if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
1403 CPP_OPTION (pfile, out_fname) = "";
1406 fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
1407 #ifdef TARGET_VERSION
1410 fputc ('\n', stderr);
1411 CPP_OPTION (pfile, verbose) = 1;
1413 case OPT_stdin_stdout:
1414 /* JF handle '-' as file name meaning stdin or stdout */
1415 if (CPP_OPTION (pfile, in_fname) == NULL)
1416 CPP_OPTION (pfile, in_fname) = "";
1417 else if (CPP_OPTION (pfile, out_fname) == NULL)
1418 CPP_OPTION (pfile, out_fname) = "";
1421 /* Args to -d specify what parts of macros to dump.
1422 Silently ignore unrecognised options; they may
1423 be aimed at the compiler proper. */
1427 while ((c = *arg++) != '\0')
1431 CPP_OPTION (pfile, dump_macros) = dump_only;
1432 CPP_OPTION (pfile, no_output) = 1;
1435 CPP_OPTION (pfile, dump_macros) = dump_names;
1438 CPP_OPTION (pfile, dump_macros) = dump_definitions;
1441 CPP_OPTION (pfile, dump_includes) = 1;
1446 /* The style of the choices here is a bit mixed.
1447 The chosen scheme is a hybrid of keeping all options in one string
1448 and specifying each option in a separate argument:
1449 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1450 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1451 -M[M][G][D file]. This is awkward to handle in specs, and is not
1453 /* ??? -MG must be specified in addition to one of -M or -MM.
1454 This can be relaxed in the future without breaking anything.
1455 The converse isn't true. */
1457 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1459 CPP_OPTION (pfile, print_deps_missing_files) = 1;
1465 if (opt_code == OPT_M || opt_code == OPT_MD)
1466 CPP_OPTION (pfile, print_deps) = 2;
1468 CPP_OPTION (pfile, print_deps) = 1;
1470 /* For -MD and -MMD options, write deps on file named by next arg */
1471 /* For -M and -MM, write deps on standard output
1472 and suppress the usual output. */
1473 if (opt_code == OPT_MD || opt_code == OPT_MMD)
1474 CPP_OPTION (pfile, deps_file) = arg;
1476 CPP_OPTION (pfile, no_output) = 1;
1481 /* -A with an argument beginning with '-' acts as
1482 #unassert on whatever immediately follows the '-'.
1483 If "-" is the whole argument, we eliminate all
1484 predefined macros and assertions, including those
1485 that were specified earlier on the command line.
1486 That way we can get rid of any that were passed
1487 automatically in from GCC. */
1491 struct pending_option *o1, *o2;
1493 o1 = pend->directive_head;
1500 pend->directive_head = NULL;
1501 pend->directive_tail = NULL;
1504 new_pending_directive (pend, arg + 1, cpp_unassert);
1507 new_pending_directive (pend, arg, cpp_assert);
1510 new_pending_directive (pend, arg, cpp_undef);
1512 case OPT_I: /* Add directory to path for includes. */
1513 if (!strcmp (arg, "-"))
1516 Use the preceding -I directories for #include "..."
1517 but not #include <...>.
1518 Don't search the directory of the present file
1519 for #include "...". (Note that -I. -I- is not the same as
1520 the default setup; -I. uses the compiler's working dir.) */
1521 if (! CPP_OPTION (pfile, ignore_srcdir))
1523 pend->quote_head = pend->brack_head;
1524 pend->quote_tail = pend->brack_tail;
1525 pend->brack_head = 0;
1526 pend->brack_tail = 0;
1527 CPP_OPTION (pfile, ignore_srcdir) = 1;
1531 cpp_fatal (pfile, "-I- specified twice");
1536 append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1539 /* Add directory to beginning of system include path, as a system
1540 include directory. */
1541 append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1545 struct pending_option *o = (struct pending_option *)
1546 xmalloc (sizeof (struct pending_option));
1549 /* This list has to be built in reverse order so that
1550 when cpp_start_read pushes all the -include files onto
1551 the buffer stack, they will be scanned in forward order. */
1552 o->next = pend->include_head;
1553 pend->include_head = o;
1558 struct pending_option *o = (struct pending_option *)
1559 xmalloc (sizeof (struct pending_option));
1563 APPEND (pend, imacros, o);
1566 case OPT_iwithprefix:
1567 /* Add directory to end of path for includes,
1568 with the default prefix at the front of its name. */
1570 case OPT_iwithprefixbefore:
1571 /* Add directory to main path for includes,
1572 with the default prefix at the front of its name. */
1579 if (CPP_OPTION (pfile, include_prefix) != 0)
1581 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1582 fname = xmalloc (ipl + len + 1);
1583 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1584 memcpy (fname + ipl, arg, len + 1);
1586 else if (cpp_GCC_INCLUDE_DIR_len)
1588 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1589 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1590 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1593 fname = xstrdup (arg);
1595 append_include_chain (pfile, fname,
1596 opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1600 /* Add directory to end of path for includes. */
1601 append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1604 /* Silently ignore unrecognised options */
1605 if (!strcmp (argv[i], "-Wall"))
1607 CPP_OPTION (pfile, warn_trigraphs) = 1;
1608 CPP_OPTION (pfile, warn_comments) = 1;
1610 else if (!strcmp (argv[i], "-Wtraditional"))
1611 CPP_OPTION (pfile, warn_traditional) = 1;
1612 else if (!strcmp (argv[i], "-Wtrigraphs"))
1613 CPP_OPTION (pfile, warn_trigraphs) = 1;
1614 else if (!strcmp (argv[i], "-Wcomment"))
1615 CPP_OPTION (pfile, warn_comments) = 1;
1616 else if (!strcmp (argv[i], "-Wcomments"))
1617 CPP_OPTION (pfile, warn_comments) = 1;
1618 else if (!strcmp (argv[i], "-Wundef"))
1619 CPP_OPTION (pfile, warn_undef) = 1;
1620 else if (!strcmp (argv[i], "-Wimport"))
1621 CPP_OPTION (pfile, warn_import) = 1;
1622 else if (!strcmp (argv[i], "-Wpaste"))
1623 CPP_OPTION (pfile, warn_paste) = 1;
1624 else if (!strcmp (argv[i], "-Werror"))
1625 CPP_OPTION (pfile, warnings_are_errors) = 1;
1626 else if (!strcmp (argv[i], "-Wsystem-headers"))
1627 CPP_OPTION (pfile, warn_system_headers) = 1;
1628 else if (!strcmp (argv[i], "-Wno-traditional"))
1629 CPP_OPTION (pfile, warn_traditional) = 0;
1630 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1631 CPP_OPTION (pfile, warn_trigraphs) = 0;
1632 else if (!strcmp (argv[i], "-Wno-comment"))
1633 CPP_OPTION (pfile, warn_comments) = 0;
1634 else if (!strcmp (argv[i], "-Wno-comments"))
1635 CPP_OPTION (pfile, warn_comments) = 0;
1636 else if (!strcmp (argv[i], "-Wno-undef"))
1637 CPP_OPTION (pfile, warn_undef) = 0;
1638 else if (!strcmp (argv[i], "-Wno-import"))
1639 CPP_OPTION (pfile, warn_import) = 0;
1640 else if (!strcmp (argv[i], "-Wno-paste"))
1641 CPP_OPTION (pfile, warn_paste) = 0;
1642 else if (!strcmp (argv[i], "-Wno-error"))
1643 CPP_OPTION (pfile, warnings_are_errors) = 0;
1644 else if (!strcmp (argv[i], "-Wno-system-headers"))
1645 CPP_OPTION (pfile, warn_system_headers) = 0;
1654 opt_comp (const void *p1, const void *p2)
1656 return strcmp (((struct cl_option *)p1)->opt_text,
1657 ((struct cl_option *)p2)->opt_text);
1661 /* Handle command-line options in (argc, argv).
1662 Can be called multiple times, to handle multiple sets of options.
1663 Returns if an unrecognized option is seen.
1664 Returns number of strings consumed. */
1666 cpp_handle_options (pfile, argc, argv)
1672 int strings_processed;
1674 for (i = 0; i < argc; i += strings_processed)
1676 strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1677 if (strings_processed == 0)
1686 fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1687 /* To keep the lines from getting too long for some compilers, limit
1688 to about 500 characters (6 lines) per chunk. */
1691 -include <file> Include the contents of <file> before other files\n\
1692 -imacros <file> Accept definition of macros in <file>\n\
1693 -iprefix <path> Specify <path> as a prefix for next two options\n\
1694 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1695 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1696 -isystem <dir> Add <dir> to the start of the system include path\n\
1699 -idirafter <dir> Add <dir> to the end of the system include path\n\
1700 -I <dir> Add <dir> to the end of the main include path\n\
1701 -I- Fine-grained include path control; see info docs\n\
1702 -nostdinc Do not search system include directories\n\
1703 (dirs specified with -isystem will still be used)\n\
1704 -nostdinc++ Do not search system include directories for C++\n\
1705 -o <file> Put output into <file>\n\
1708 -pedantic Issue all warnings demanded by strict ISO C\n\
1709 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1710 -trigraphs Support ISO C trigraphs\n\
1711 -lang-c Assume that the input sources are in C\n\
1712 -lang-c89 Assume that the input sources are in C89\n\
1715 -lang-c++ Assume that the input sources are in C++\n\
1716 -lang-objc Assume that the input sources are in ObjectiveC\n\
1717 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1718 -lang-asm Assume that the input sources are in assembler\n\
1721 -std=<std name> Specify the conformance standard; one of:\n\
1722 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1723 iso9899:199409, iso9899:1999\n\
1724 -+ Allow parsing of C++ style features\n\
1725 -w Inhibit warning messages\n\
1726 -Wtrigraphs Warn if trigraphs are encountered\n\
1727 -Wno-trigraphs Do not warn about trigraphs\n\
1728 -Wcomment{s} Warn if one comment starts inside another\n\
1731 -Wno-comment{s} Do not warn about comments\n\
1732 -Wtraditional Warn about features not present in traditional C\n\
1733 -Wno-traditional Do not warn about traditional C\n\
1734 -Wundef Warn if an undefined macro is used by #if\n\
1735 -Wno-undef Do not warn about testing undefined macros\n\
1736 -Wimport Warn about the use of the #import directive\n\
1739 -Wno-import Do not warn about the use of #import\n\
1740 -Werror Treat all warnings as errors\n\
1741 -Wno-error Do not treat warnings as errors\n\
1742 -Wsystem-headers Do not suppress warnings from system headers\n\
1743 -Wno-system-headers Suppress warnings from system headers\n\
1744 -Wall Enable all preprocessor warnings\n\
1747 -M Generate make dependencies\n\
1748 -MM As -M, but ignore system header files\n\
1749 -MD As -M, but put output in a .d file\n\
1750 -MMD As -MD, but ignore system header files\n\
1751 -MG Treat missing header file as generated files\n\
1752 -g3 Include #define and #undef directives in the output\n\
1755 -D<macro> Define a <macro> with string '1' as its value\n\
1756 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1757 -A<question> (<answer>) Assert the <answer> to <question>\n\
1758 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1759 -U<macro> Undefine <macro> \n\
1760 -v Display the version number\n\
1763 -H Print the name of header files as they are used\n\
1764 -C Do not discard comments\n\
1765 -dM Display a list of macro definitions active at end\n\
1766 -dD Preserve macro definitions in output\n\
1767 -dN As -dD except that only the names are preserved\n\
1768 -dI Include #include directives in the output\n\
1771 -ftabstop=<number> Distance between tab stops for column reporting\n\
1772 -P Do not generate #line directives\n\
1773 -$ Do not allow '$' in identifiers\n\
1774 -remap Remap file names when including files.\n\
1775 --version Display version information\n\
1776 -h or --help Display this information\n\