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 /* Sets internal flags correctly for a given language, and defines
402 macros if necessary. */
404 set_lang (pfile
, lang
)
408 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
411 CPP_OPTION (pfile
, lang
) = lang
;
412 CPP_OPTION (pfile
, objc
) = 0;
413 CPP_OPTION (pfile
, cplusplus
) = 0;
414 CPP_OPTION (pfile
, extended_numbers
) = 1; /* Allowed in GNU C and C99. */
420 CPP_OPTION (pfile
, trigraphs
) = 0;
421 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
422 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
423 CPP_OPTION (pfile
, digraphs
) = 1;
424 CPP_OPTION (pfile
, c99
) = 1;
425 new_pending_directive (pend
, "__STDC_VERSION__=199901L", cpp_define
);
428 CPP_OPTION (pfile
, trigraphs
) = 0;
429 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
430 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
431 CPP_OPTION (pfile
, digraphs
) = 1;
432 CPP_OPTION (pfile
, c99
) = 0;
437 new_pending_directive (pend
, "__STDC_VERSION__=199409L", cpp_define
);
439 CPP_OPTION (pfile
, trigraphs
) = 1;
440 CPP_OPTION (pfile
, dollars_in_ident
) = 0;
441 CPP_OPTION (pfile
, cplusplus_comments
) = 0;
442 CPP_OPTION (pfile
, digraphs
) = lang
== CLK_STDC94
;
443 CPP_OPTION (pfile
, c99
) = 0;
444 CPP_OPTION (pfile
, extended_numbers
) = 0;
445 new_pending_directive (pend
, "__STRICT_ANSI__", cpp_define
);
448 CPP_OPTION (pfile
, trigraphs
) = 1;
449 CPP_OPTION (pfile
, dollars_in_ident
) = 0;
450 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
451 CPP_OPTION (pfile
, digraphs
) = 1;
452 CPP_OPTION (pfile
, c99
) = 1;
453 new_pending_directive (pend
, "__STRICT_ANSI__", cpp_define
);
454 new_pending_directive (pend
, "__STDC_VERSION__=199901L", cpp_define
);
459 new_pending_directive (pend
, "__cplusplus", cpp_define
);
460 CPP_OPTION (pfile
, cplusplus
) = 1;
462 CPP_OPTION (pfile
, trigraphs
) = 0;
463 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
464 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
465 CPP_OPTION (pfile
, digraphs
) = 1;
466 CPP_OPTION (pfile
, c99
) = 0;
467 CPP_OPTION (pfile
, objc
) = 1;
468 new_pending_directive (pend
, "__OBJC__", cpp_define
);
474 CPP_OPTION (pfile
, cplusplus
) = 1;
475 CPP_OPTION (pfile
, trigraphs
) = lang
== CLK_CXX98
;
476 CPP_OPTION (pfile
, dollars_in_ident
) = lang
== CLK_GNUCXX
;
477 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
478 CPP_OPTION (pfile
, digraphs
) = 1;
479 CPP_OPTION (pfile
, c99
) = 0;
480 new_pending_directive (pend
, "__cplusplus", cpp_define
);
485 CPP_OPTION (pfile
, trigraphs
) = 0;
486 CPP_OPTION (pfile
, dollars_in_ident
) = 0; /* Maybe not? */
487 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
488 CPP_OPTION (pfile
, digraphs
) = 0;
489 CPP_OPTION (pfile
, c99
) = 0;
490 new_pending_directive (pend
, "__ASSEMBLER__", cpp_define
);
495 /* initialize initializes library global state. It might not need to
496 do anything depending on the platform and compiler. */
498 static int initialized
= 0;
504 /* For non-ASCII hosts, the cl_options array needs to be sorted at
506 qsort (cl_options
, N_OPTS
, sizeof (struct cl_option
), opt_comp
);
509 /* Set up the trigraph map and the IStable. These don't need to do
510 anything if we were compiled with a compiler that supports C99
511 designated initializers. */
512 init_trigraph_map ();
518 /* Initialize a cpp_reader structure. */
520 cpp_create_reader (lang
)
523 struct spec_nodes
*s
;
524 cpp_reader
*pfile
= (cpp_reader
*) xcalloc (1, sizeof (cpp_reader
));
526 /* Initialise this instance of the library if it hasn't been already. */
530 CPP_OPTION (pfile
, warn_import
) = 1;
531 CPP_OPTION (pfile
, discard_comments
) = 1;
532 CPP_OPTION (pfile
, show_column
) = 1;
533 CPP_OPTION (pfile
, tabstop
) = 8;
535 CPP_OPTION (pfile
, pending
) =
536 (struct cpp_pending
*) xcalloc (1, sizeof (struct cpp_pending
));
538 /* After creating pfile->pending. */
539 set_lang (pfile
, lang
);
541 /* Initialize lexer state. */
542 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
544 /* Indicate date and time not yet calculated. */
545 pfile
->date
.type
= CPP_EOF
;
547 /* Initialise the base context. */
548 pfile
->context
= &pfile
->base_context
;
549 pfile
->base_context
.macro
= 0;
550 pfile
->base_context
.prev
= pfile
->base_context
.next
= 0;
552 /* Identifier pool initially 8K. Unaligned, permanent pool. */
553 _cpp_init_pool (&pfile
->ident_pool
, 8 * 1024, 1, 0);
555 /* String and number pool initially 4K. Unaligned, temporary pool. */
556 _cpp_init_pool (&pfile
->temp_string_pool
, 4 * 1024, 1, 1);
558 /* Argument pool initially 8K. Aligned, temporary pool. */
559 _cpp_init_pool (&pfile
->argument_pool
, 8 * 1024, 0, 1);
561 /* Macro pool initially 8K. Aligned, permanent pool. */
562 _cpp_init_pool (&pfile
->macro_pool
, 8 * 1024, 0, 0);
564 /* Start with temporary pool. */
565 pfile
->string_pool
= &pfile
->temp_string_pool
;
567 _cpp_init_hashtable (pfile
);
568 _cpp_init_stacks (pfile
);
569 _cpp_init_includes (pfile
);
570 _cpp_init_internal_pragmas (pfile
);
572 /* Initialize the special nodes. */
573 s
= &pfile
->spec_nodes
;
574 s
->n_L
= cpp_lookup (pfile
, DSC("L"));
575 s
->n_defined
= cpp_lookup (pfile
, DSC("defined"));
576 s
->n__Pragma
= cpp_lookup (pfile
, DSC("_Pragma"));
577 s
->n__STRICT_ANSI__
= cpp_lookup (pfile
, DSC("__STRICT_ANSI__"));
578 s
->n__CHAR_UNSIGNED__
= cpp_lookup (pfile
, DSC("__CHAR_UNSIGNED__"));
579 s
->n__VA_ARGS__
= cpp_lookup (pfile
, DSC("__VA_ARGS__"));
580 s
->n__VA_ARGS__
->flags
|= NODE_DIAGNOSTIC
;
585 /* Free resources used by PFILE.
586 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
591 struct file_name_list
*dir
, *dirn
;
592 cpp_context
*context
, *contextn
;
594 while (CPP_BUFFER (pfile
) != NULL
)
595 cpp_pop_buffer (pfile
);
597 if (pfile
->macro_buffer
)
598 free ((PTR
) pfile
->macro_buffer
);
601 deps_free (pfile
->deps
);
603 _cpp_cleanup_includes (pfile
);
604 _cpp_cleanup_stacks (pfile
);
605 _cpp_cleanup_hashtable (pfile
);
607 _cpp_free_lookaheads (pfile
);
609 _cpp_free_pool (&pfile
->ident_pool
);
610 _cpp_free_pool (&pfile
->temp_string_pool
);
611 _cpp_free_pool (&pfile
->macro_pool
);
612 _cpp_free_pool (&pfile
->argument_pool
);
614 for (dir
= CPP_OPTION (pfile
, quote_include
); dir
; dir
= dirn
)
621 for (context
= pfile
->base_context
.next
; context
; context
= contextn
)
623 contextn
= context
->next
;
629 /* This structure defines one built-in identifier. A node will be
630 entered in the hash table under the name NAME, with value VALUE (if
631 any). If flags has OPERATOR, the node's operator field is used; if
632 flags has BUILTIN the node's builtin field is used.
634 Two values are not compile time constants, so we tag
635 them in the FLAGS field instead:
636 VERS value is the global version_string, quoted
637 ULP value is the global user_label_prefix
639 Also, macros with CPLUS set in the flags field are entered only for C++. */
645 unsigned char builtin
;
646 unsigned char operator;
647 unsigned short flags
;
654 #define OPERATOR 0x10
656 #define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
657 #define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 }
658 #define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 }
659 #define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
660 static const struct builtin builtin_array
[] =
662 B("__TIME__", BT_TIME
),
663 B("__DATE__", BT_DATE
),
664 B("__FILE__", BT_FILE
),
665 B("__BASE_FILE__", BT_BASE_FILE
),
666 B("__LINE__", BT_SPECLINE
),
667 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL
),
668 B("__STDC__", BT_STDC
),
670 X("__VERSION__", VERS
),
671 X("__USER_LABEL_PREFIX__", ULP
),
672 C("__REGISTER_PREFIX__", REGISTER_PREFIX
),
673 C("__HAVE_BUILTIN_SETJMP__", "1"),
674 #ifndef NO_BUILTIN_SIZE_TYPE
675 C("__SIZE_TYPE__", SIZE_TYPE
),
677 #ifndef NO_BUILTIN_PTRDIFF_TYPE
678 C("__PTRDIFF_TYPE__", PTRDIFF_TYPE
),
680 #ifndef NO_BUILTIN_WCHAR_TYPE
681 C("__WCHAR_TYPE__", WCHAR_TYPE
),
683 #ifndef NO_BUILTIN_WINT_TYPE
684 C("__WINT_TYPE__", WINT_TYPE
),
687 /* Named operators known to the preprocessor. These cannot be #defined
688 and always have their stated meaning. They are treated like normal
689 identifiers except for the type code and the meaning. Most of them
690 are only for C++ (but see iso646.h). */
691 O("and", CPP_AND_AND
, CPLUS
),
692 O("and_eq", CPP_AND_EQ
, CPLUS
),
693 O("bitand", CPP_AND
, CPLUS
),
694 O("bitor", CPP_OR
, CPLUS
),
695 O("compl", CPP_COMPL
, CPLUS
),
696 O("not", CPP_NOT
, CPLUS
),
697 O("not_eq", CPP_NOT_EQ
, CPLUS
),
698 O("or", CPP_OR_OR
, CPLUS
),
699 O("or_eq", CPP_OR_EQ
, CPLUS
),
700 O("xor", CPP_XOR
, CPLUS
),
701 O("xor_eq", CPP_XOR_EQ
, CPLUS
)
706 #define builtin_array_end \
707 builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
709 /* Subroutine of cpp_start_read; reads the builtins table above and
710 enters the macros into the hash table. */
712 initialize_builtins (pfile
)
715 const struct builtin
*b
;
717 for(b
= builtin_array
; b
< builtin_array_end
; b
++)
719 if ((b
->flags
& CPLUS
) && ! CPP_OPTION (pfile
, cplusplus
))
722 if (b
->flags
& (OPERATOR
| BUILTIN
))
724 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
725 if (b
->flags
& OPERATOR
)
727 hp
->flags
|= NODE_OPERATOR
;
728 hp
->value
.operator = b
->operator;
733 hp
->flags
|= NODE_BUILTIN
;
734 hp
->value
.builtin
= b
->builtin
;
737 else /* A standard macro of some kind. */
744 /* Allocate enough space for 'name "value"\n\0'. */
745 str
= alloca (b
->len
+ strlen (version_string
) + 5);
746 sprintf (str
, "%s \"%s\"\n", b
->name
, version_string
);
751 val
= CPP_OPTION (pfile
, user_label_prefix
);
755 /* Allocate enough space for "name value\n\0". */
756 str
= alloca (b
->len
+ strlen (val
) + 3);
757 sprintf(str
, "%s %s\n", b
->name
, val
);
760 _cpp_define_builtin (pfile
, str
);
769 #undef builtin_array_end
771 /* Another subroutine of cpp_start_read. This one sets up to do
772 dependency-file output. */
774 initialize_dependency_output (pfile
)
777 char *spec
, *s
, *output_file
;
779 /* Either of two environment variables can specify output of deps.
780 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
781 where OUTPUT_FILE is the file to write deps info to
782 and DEPS_TARGET is the target to mention in the deps. */
784 if (CPP_OPTION (pfile
, print_deps
) == 0)
786 spec
= getenv ("DEPENDENCIES_OUTPUT");
788 CPP_OPTION (pfile
, print_deps
) = 1;
791 spec
= getenv ("SUNPRO_DEPENDENCIES");
793 CPP_OPTION (pfile
, print_deps
) = 2;
798 /* Find the space before the DEPS_TARGET, if there is one. */
799 s
= strchr (spec
, ' ');
802 CPP_OPTION (pfile
, deps_target
) = s
+ 1;
803 output_file
= (char *) xmalloc (s
- spec
+ 1);
804 memcpy (output_file
, spec
, s
- spec
);
805 output_file
[s
- spec
] = 0;
809 CPP_OPTION (pfile
, deps_target
) = 0;
813 CPP_OPTION (pfile
, deps_file
) = output_file
;
814 CPP_OPTION (pfile
, print_deps_append
) = 1;
817 pfile
->deps
= deps_init ();
819 /* Print the expected object file name as the target of this Make-rule. */
820 if (CPP_OPTION (pfile
, deps_target
))
821 deps_add_target (pfile
->deps
, CPP_OPTION (pfile
, deps_target
));
822 else if (*CPP_OPTION (pfile
, in_fname
) == 0)
823 deps_add_target (pfile
->deps
, "-");
825 deps_calc_target (pfile
->deps
, CPP_OPTION (pfile
, in_fname
));
827 if (CPP_OPTION (pfile
, in_fname
))
828 deps_add_dep (pfile
->deps
, CPP_OPTION (pfile
, in_fname
));
831 /* And another subroutine. This one sets up the standard include path. */
833 initialize_standard_includes (pfile
)
837 const struct default_include
*p
;
838 const char *specd_prefix
= CPP_OPTION (pfile
, include_prefix
);
840 /* Several environment variables may add to the include search path.
841 CPATH specifies an additional list of directories to be searched
842 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
843 etc. specify an additional list of directories to be searched as
844 if specified with -isystem, for the language indicated. */
846 GET_ENV_PATH_LIST (path
, "CPATH");
847 if (path
!= 0 && *path
!= 0)
848 path_include (pfile
, path
, BRACKET
);
850 switch ((CPP_OPTION (pfile
, objc
) << 1) + CPP_OPTION (pfile
, cplusplus
))
853 GET_ENV_PATH_LIST (path
, "C_INCLUDE_PATH");
856 GET_ENV_PATH_LIST (path
, "CPLUS_INCLUDE_PATH");
859 GET_ENV_PATH_LIST (path
, "OBJC_INCLUDE_PATH");
862 GET_ENV_PATH_LIST (path
, "OBJCPLUS_INCLUDE_PATH");
865 if (path
!= 0 && *path
!= 0)
866 path_include (pfile
, path
, SYSTEM
);
868 /* Search "translated" versions of GNU directories.
869 These have /usr/local/lib/gcc... replaced by specd_prefix. */
870 if (specd_prefix
!= 0 && cpp_GCC_INCLUDE_DIR_len
)
872 /* Remove the `include' from /usr/local/lib/gcc.../include.
873 GCC_INCLUDE_DIR will always end in /include. */
874 int default_len
= cpp_GCC_INCLUDE_DIR_len
;
875 char *default_prefix
= (char *) alloca (default_len
+ 1);
876 int specd_len
= strlen (specd_prefix
);
878 memcpy (default_prefix
, cpp_GCC_INCLUDE_DIR
, default_len
);
879 default_prefix
[default_len
] = '\0';
881 for (p
= cpp_include_defaults
; p
->fname
; p
++)
883 /* Some standard dirs are only for C++. */
885 || (CPP_OPTION (pfile
, cplusplus
)
886 && !CPP_OPTION (pfile
, no_standard_cplusplus_includes
)))
888 /* Does this dir start with the prefix? */
889 if (!memcmp (p
->fname
, default_prefix
, default_len
))
891 /* Yes; change prefix and add to search list. */
892 int flen
= strlen (p
->fname
);
893 int this_len
= specd_len
+ flen
- default_len
;
894 char *str
= (char *) xmalloc (this_len
+ 1);
895 memcpy (str
, specd_prefix
, specd_len
);
896 memcpy (str
+ specd_len
,
897 p
->fname
+ default_len
,
898 flen
- default_len
+ 1);
900 append_include_chain (pfile
, str
, SYSTEM
, p
->cxx_aware
);
906 /* Search ordinary names for GNU include directories. */
907 for (p
= cpp_include_defaults
; p
->fname
; p
++)
909 /* Some standard dirs are only for C++. */
911 || (CPP_OPTION (pfile
, cplusplus
)
912 && !CPP_OPTION (pfile
, no_standard_cplusplus_includes
)))
914 char *str
= xstrdup (update_path (p
->fname
, p
->component
));
915 append_include_chain (pfile
, str
, SYSTEM
, p
->cxx_aware
);
920 /* Handles -imacro and -include from the command line. */
922 do_includes (pfile
, p
, scan
)
924 struct pending_option
*p
;
929 struct pending_option
*q
;
931 /* Later: maybe update this to use the #include "" search path
932 if cpp_read_file fails. */
933 if (cpp_read_file (pfile
, p
->arg
) && scan
)
934 cpp_scan_buffer_nooutput (pfile
, 0);
941 /* This is called after options have been processed. Check options
942 for consistency, and setup for processing input from the file named
943 FNAME. (Use standard input if FNAME == NULL.) Return 1 on success,
947 cpp_start_read (pfile
, fname
)
951 struct pending_option
*p
, *q
;
953 /* -MG doesn't select the form of output and must be specified with one of
954 -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
955 inhibit compilation. */
956 if (CPP_OPTION (pfile
, print_deps_missing_files
)
957 && (CPP_OPTION (pfile
, print_deps
) == 0
958 || !CPP_OPTION (pfile
, no_output
)))
960 cpp_fatal (pfile
, "-MG must be specified with one of -M or -MM");
964 /* -Wtraditional is not useful in C++ mode. */
965 if (CPP_OPTION (pfile
, cplusplus
))
966 CPP_OPTION (pfile
, warn_traditional
) = 0;
968 /* Set this if it hasn't been set already. */
969 if (CPP_OPTION (pfile
, user_label_prefix
) == NULL
)
970 CPP_OPTION (pfile
, user_label_prefix
) = USER_LABEL_PREFIX
;
972 /* Set up the include search path now. */
973 if (! CPP_OPTION (pfile
, no_standard_includes
))
974 initialize_standard_includes (pfile
);
976 merge_include_chains (pfile
);
978 /* With -v, print the list of dirs to search. */
979 if (CPP_OPTION (pfile
, verbose
))
981 struct file_name_list
*l
;
982 fprintf (stderr
, _("#include \"...\" search starts here:\n"));
983 for (l
= CPP_OPTION (pfile
, quote_include
); l
; l
= l
->next
)
985 if (l
== CPP_OPTION (pfile
, bracket_include
))
986 fprintf (stderr
, _("#include <...> search starts here:\n"));
987 fprintf (stderr
, " %s\n", l
->name
);
989 fprintf (stderr
, _("End of search list.\n"));
992 /* Open the main input file. This must be done early, so we have a
993 buffer to stand on. */
994 if (CPP_OPTION (pfile
, in_fname
) == NULL
995 || *CPP_OPTION (pfile
, in_fname
) == 0)
997 CPP_OPTION (pfile
, in_fname
) = fname
;
998 if (CPP_OPTION (pfile
, in_fname
) == NULL
)
999 CPP_OPTION (pfile
, in_fname
) = "";
1001 if (CPP_OPTION (pfile
, out_fname
) == NULL
)
1002 CPP_OPTION (pfile
, out_fname
) = "";
1004 if (!cpp_read_file (pfile
, fname
))
1007 initialize_dependency_output (pfile
);
1009 /* Install __LINE__, etc. */
1010 initialize_builtins (pfile
);
1012 /* Do -U's, -D's and -A's in the order they were seen. */
1013 p
= CPP_OPTION (pfile
, pending
)->directive_head
;
1016 (*p
->handler
) (pfile
, p
->arg
);
1021 pfile
->done_initializing
= 1;
1023 /* The -imacros files can be scanned now, but the -include files
1024 have to be pushed onto the buffer stack and processed later,
1025 otherwise cppmain.c won't see the tokens. include_head was built
1026 up as a stack, and popping this stack onto the buffer stack means
1027 we preserve the order of the command line. */
1028 do_includes (pfile
, CPP_OPTION (pfile
, pending
)->imacros_head
, 1);
1029 do_includes (pfile
, CPP_OPTION (pfile
, pending
)->include_head
, 0);
1031 free (CPP_OPTION (pfile
, pending
));
1032 CPP_OPTION (pfile
, pending
) = NULL
;
1037 /* This is called at the end of preprocessing. It pops the
1038 last buffer and writes dependency output. It should also
1039 clear macro definitions, such that you could call cpp_start_read
1040 with a new filename to restart processing. */
1045 if (CPP_BUFFER (pfile
))
1047 cpp_ice (pfile
, "buffers still stacked in cpp_finish");
1048 while (CPP_BUFFER (pfile
))
1049 cpp_pop_buffer (pfile
);
1052 /* Don't write the deps file if preprocessing has failed. */
1053 if (CPP_OPTION (pfile
, print_deps
) && pfile
->errors
== 0)
1055 /* Stream on which to print the dependency information. */
1056 FILE *deps_stream
= 0;
1057 const char *deps_mode
1058 = CPP_OPTION (pfile
, print_deps_append
) ? "a" : "w";
1059 if (CPP_OPTION (pfile
, deps_file
) == 0)
1060 deps_stream
= stdout
;
1063 deps_stream
= fopen (CPP_OPTION (pfile
, deps_file
), deps_mode
);
1064 if (deps_stream
== 0)
1065 cpp_notice_from_errno (pfile
, CPP_OPTION (pfile
, deps_file
));
1069 deps_write (pfile
->deps
, deps_stream
, 72);
1070 if (CPP_OPTION (pfile
, deps_file
))
1072 if (ferror (deps_stream
) || fclose (deps_stream
) != 0)
1073 cpp_fatal (pfile
, "I/O error on output");
1078 /* Report on headers that could use multiple include guards. */
1079 if (CPP_OPTION (pfile
, print_include_names
))
1080 _cpp_report_missing_guards (pfile
);
1084 new_pending_directive (pend
, text
, handler
)
1085 struct cpp_pending
*pend
;
1087 cl_directive_handler handler
;
1089 struct pending_option
*o
= (struct pending_option
*)
1090 xmalloc (sizeof (struct pending_option
));
1094 o
->handler
= handler
;
1095 APPEND (pend
, directive
, o
);
1098 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1099 I.e. a const string initializer with parens around it. That is
1100 what N_("string") resolves to, so we make no_* be macros instead. */
1101 #define no_arg N_("Argument missing after %s")
1102 #define no_ass N_("Assertion missing after %s")
1103 #define no_dir N_("Directory name missing after %s")
1104 #define no_fil N_("File name missing after %s")
1105 #define no_mac N_("Macro name missing after %s")
1106 #define no_pth N_("Path name missing after %s")
1107 #define no_num N_("Number missing after %s")
1109 /* This is the list of all command line options, with the leading
1110 "-" removed. It must be sorted in ASCII collating order. */
1111 #define COMMAND_LINE_OPTIONS \
1112 DEF_OPT("", 0, OPT_stdin_stdout) \
1113 DEF_OPT("$", 0, OPT_dollar) \
1114 DEF_OPT("+", 0, OPT_plus) \
1115 DEF_OPT("-help", 0, OPT__help) \
1116 DEF_OPT("-target-help", 0, OPT_target__help) \
1117 DEF_OPT("-version", 0, OPT__version) \
1118 DEF_OPT("A", no_ass, OPT_A) \
1119 DEF_OPT("C", 0, OPT_C) \
1120 DEF_OPT("D", no_mac, OPT_D) \
1121 DEF_OPT("H", 0, OPT_H) \
1122 DEF_OPT("I", no_dir, OPT_I) \
1123 DEF_OPT("M", 0, OPT_M) \
1124 DEF_OPT("MD", no_fil, OPT_MD) \
1125 DEF_OPT("MG", 0, OPT_MG) \
1126 DEF_OPT("MM", 0, OPT_MM) \
1127 DEF_OPT("MMD", no_fil, OPT_MMD) \
1128 DEF_OPT("P", 0, OPT_P) \
1129 DEF_OPT("U", no_mac, OPT_U) \
1130 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1131 DEF_OPT("d", no_arg, OPT_d) \
1132 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1133 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1134 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1135 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1136 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1137 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1138 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1139 DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
1140 DEF_OPT("h", 0, OPT_h) \
1141 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1142 DEF_OPT("imacros", no_fil, OPT_imacros) \
1143 DEF_OPT("include", no_fil, OPT_include) \
1144 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1145 DEF_OPT("isystem", no_dir, OPT_isystem) \
1146 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1147 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1148 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1149 DEF_OPT("lang-c", 0, OPT_lang_c) \
1150 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1151 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1152 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1153 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1154 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1155 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1156 DEF_OPT("o", no_fil, OPT_o) \
1157 DEF_OPT("pedantic", 0, OPT_pedantic) \
1158 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1159 DEF_OPT("remap", 0, OPT_remap) \
1160 DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
1161 DEF_OPT("std=c89", 0, OPT_std_c89) \
1162 DEF_OPT("std=c99", 0, OPT_std_c99) \
1163 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1164 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1165 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1166 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1167 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1168 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1169 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1170 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1171 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1172 DEF_OPT("v", 0, OPT_v) \
1173 DEF_OPT("w", 0, OPT_w)
1175 #define DEF_OPT(text, msg, code) code,
1178 COMMAND_LINE_OPTIONS
1185 const char *opt_text
;
1188 enum opt_code opt_code
;
1191 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1193 static struct cl_option cl_options
[] =
1195 static const struct cl_option cl_options
[] =
1198 COMMAND_LINE_OPTIONS
1201 #undef COMMAND_LINE_OPTIONS
1203 /* Perform a binary search to find which, if any, option the given
1204 command-line matches. Returns its index in the option array,
1205 negative on failure. Complications arise since some options can be
1206 suffixed with an argument, and multiple complete matches can occur,
1207 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
1208 accept options beginning with -g and -W that we do not recognise,
1209 but not to swallow any subsequent command line argument; these are
1210 handled as special cases in cpp_handle_option. */
1212 parse_option (input
)
1215 unsigned int md
, mn
, mx
;
1226 opt_len
= cl_options
[md
].opt_len
;
1227 comp
= memcmp (input
, cl_options
[md
].opt_text
, opt_len
);
1235 if (input
[opt_len
] == '\0')
1237 /* We were passed more text. If the option takes an argument,
1238 we may match a later option or we may have been passed the
1239 argument. The longest possible option match succeeds.
1240 If the option takes no arguments we have not matched and
1241 continue the search (e.g. input="stdc++" match was "stdc"). */
1243 if (cl_options
[md
].msg
)
1245 /* Scan forwards. If we get an exact match, return it.
1246 Otherwise, return the longest option-accepting match.
1247 This loops no more than twice with current options. */
1249 for (; mn
< N_OPTS
; mn
++)
1251 opt_len
= cl_options
[mn
].opt_len
;
1252 if (memcmp (input
, cl_options
[mn
].opt_text
, opt_len
))
1254 if (input
[opt_len
] == '\0')
1256 if (cl_options
[mn
].msg
)
1267 /* Handle one command-line option in (argc, argv).
1268 Can be called multiple times, to handle multiple sets of options.
1269 Returns number of strings consumed. */
1272 cpp_handle_option (pfile
, argc
, argv
)
1278 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
1280 if (argv
[i
][0] != '-')
1282 if (CPP_OPTION (pfile
, out_fname
) != NULL
)
1283 cpp_fatal (pfile
, "Too many arguments. Type %s --help for usage info",
1285 else if (CPP_OPTION (pfile
, in_fname
) != NULL
)
1286 CPP_OPTION (pfile
, out_fname
) = argv
[i
];
1288 CPP_OPTION (pfile
, in_fname
) = argv
[i
];
1292 enum opt_code opt_code
;
1294 const char *arg
= 0;
1296 /* Skip over '-'. */
1297 opt_index
= parse_option (&argv
[i
][1]);
1301 opt_code
= cl_options
[opt_index
].opt_code
;
1302 if (cl_options
[opt_index
].msg
)
1304 arg
= &argv
[i
][cl_options
[opt_index
].opt_len
+ 1];
1306 /* Yuk. Special case for -g and -W as they must not swallow
1307 up any following argument. If this becomes common, add
1308 another field to the cl_options table. */
1309 if (arg
[0] == '\0' && !(opt_code
== OPT_g
|| opt_code
== OPT_W
))
1314 cpp_fatal (pfile
, cl_options
[opt_index
].msg
, argv
[i
- 1]);
1322 case N_OPTS
: /* Shut GCC up. */
1324 case OPT_fleading_underscore
:
1325 CPP_OPTION (pfile
, user_label_prefix
) = "_";
1327 case OPT_fno_leading_underscore
:
1328 CPP_OPTION (pfile
, user_label_prefix
) = "";
1330 case OPT_fpreprocessed
:
1331 CPP_OPTION (pfile
, preprocessed
) = 1;
1333 case OPT_fno_preprocessed
:
1334 CPP_OPTION (pfile
, preprocessed
) = 0;
1336 case OPT_fshow_column
:
1337 CPP_OPTION (pfile
, show_column
) = 1;
1339 case OPT_fno_show_column
:
1340 CPP_OPTION (pfile
, show_column
) = 0;
1343 /* Silently ignore empty string, non-longs and silly values. */
1347 long tabstop
= strtol (arg
, &endptr
, 10);
1348 if (*endptr
== '\0' && tabstop
>= 1 && tabstop
<= 100)
1349 CPP_OPTION (pfile
, tabstop
) = tabstop
;
1353 CPP_OPTION (pfile
, inhibit_warnings
) = 1;
1355 case OPT_g
: /* Silently ignore anything but -g3. */
1356 if (!strcmp(&argv
[i
][2], "3"))
1357 CPP_OPTION (pfile
, debug_output
) = 1;
1364 case OPT_target__help
:
1365 /* Print if any target specific options. */
1369 fprintf (stderr
, _("GNU CPP version %s (cpplib)\n"), version_string
);
1373 CPP_OPTION (pfile
, discard_comments
) = 0;
1376 CPP_OPTION (pfile
, no_line_commands
) = 1;
1378 case OPT_dollar
: /* Don't include $ in identifiers. */
1379 CPP_OPTION (pfile
, dollars_in_ident
) = 0;
1382 CPP_OPTION (pfile
, print_include_names
) = 1;
1385 new_pending_directive (pend
, arg
, cpp_define
);
1387 case OPT_pedantic_errors
:
1388 CPP_OPTION (pfile
, pedantic_errors
) = 1;
1391 CPP_OPTION (pfile
, pedantic
) = 1;
1394 CPP_OPTION (pfile
, trigraphs
) = 1;
1397 CPP_OPTION (pfile
, cplusplus
) = 1;
1398 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
1401 CPP_OPTION (pfile
, remap
) = 1;
1404 CPP_OPTION (pfile
, include_prefix
) = arg
;
1405 CPP_OPTION (pfile
, include_prefix_len
) = strlen (arg
);
1408 set_lang (pfile
, CLK_GNUC89
);
1410 case OPT_lang_cplusplus
:
1411 set_lang (pfile
, CLK_GNUCXX
);
1414 set_lang (pfile
, CLK_OBJC
);
1416 case OPT_lang_objcplusplus
:
1417 set_lang (pfile
, CLK_OBJCXX
);
1420 set_lang (pfile
, CLK_ASM
);
1422 case OPT_std_cplusplus98
:
1423 set_lang (pfile
, CLK_CXX98
);
1426 set_lang (pfile
, CLK_GNUC89
);
1430 set_lang (pfile
, CLK_GNUC99
);
1432 case OPT_std_iso9899_199409
:
1433 set_lang (pfile
, CLK_STDC94
);
1435 case OPT_std_iso9899_1990
:
1438 set_lang (pfile
, CLK_STDC89
);
1440 case OPT_std_iso9899_199x
:
1441 case OPT_std_iso9899_1999
:
1444 set_lang (pfile
, CLK_STDC99
);
1447 /* -nostdinc causes no default include directories.
1448 You must specify all include-file directories with -I. */
1449 CPP_OPTION (pfile
, no_standard_includes
) = 1;
1451 case OPT_nostdincplusplus
:
1452 /* -nostdinc++ causes no default C++-specific include directories. */
1453 CPP_OPTION (pfile
, no_standard_cplusplus_includes
) = 1;
1456 if (CPP_OPTION (pfile
, out_fname
) != NULL
)
1458 cpp_fatal (pfile
, "Output filename specified twice");
1461 CPP_OPTION (pfile
, out_fname
) = arg
;
1462 if (!strcmp (CPP_OPTION (pfile
, out_fname
), "-"))
1463 CPP_OPTION (pfile
, out_fname
) = "";
1466 fprintf (stderr
, _("GNU CPP version %s (cpplib)"), version_string
);
1467 #ifdef TARGET_VERSION
1470 fputc ('\n', stderr
);
1471 CPP_OPTION (pfile
, verbose
) = 1;
1473 case OPT_stdin_stdout
:
1474 /* JF handle '-' as file name meaning stdin or stdout. */
1475 if (CPP_OPTION (pfile
, in_fname
) == NULL
)
1476 CPP_OPTION (pfile
, in_fname
) = "";
1477 else if (CPP_OPTION (pfile
, out_fname
) == NULL
)
1478 CPP_OPTION (pfile
, out_fname
) = "";
1481 /* Args to -d specify what parts of macros to dump.
1482 Silently ignore unrecognised options; they may
1483 be aimed at the compiler proper. */
1487 while ((c
= *arg
++) != '\0')
1491 CPP_OPTION (pfile
, dump_macros
) = dump_only
;
1492 CPP_OPTION (pfile
, no_output
) = 1;
1495 CPP_OPTION (pfile
, dump_macros
) = dump_names
;
1498 CPP_OPTION (pfile
, dump_macros
) = dump_definitions
;
1501 CPP_OPTION (pfile
, dump_includes
) = 1;
1506 /* The style of the choices here is a bit mixed.
1507 The chosen scheme is a hybrid of keeping all options in one string
1508 and specifying each option in a separate argument:
1509 -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
1510 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1511 -M[M][G][D file]. This is awkward to handle in specs, and is not
1513 /* ??? -MG must be specified in addition to one of -M or -MM.
1514 This can be relaxed in the future without breaking anything.
1515 The converse isn't true. */
1517 /* -MG isn't valid with -MD or -MMD. This is checked for later. */
1519 CPP_OPTION (pfile
, print_deps_missing_files
) = 1;
1525 if (opt_code
== OPT_M
|| opt_code
== OPT_MD
)
1526 CPP_OPTION (pfile
, print_deps
) = 2;
1528 CPP_OPTION (pfile
, print_deps
) = 1;
1530 /* For -MD and -MMD, write deps on file named by next arg. */
1531 /* For -M and -MM, write deps on standard output and
1532 suppress the usual output. */
1533 if (opt_code
== OPT_MD
|| opt_code
== OPT_MMD
)
1534 CPP_OPTION (pfile
, deps_file
) = arg
;
1536 CPP_OPTION (pfile
, no_output
) = 1;
1541 /* -A with an argument beginning with '-' acts as
1542 #unassert on whatever immediately follows the '-'.
1543 If "-" is the whole argument, we eliminate all
1544 predefined macros and assertions, including those
1545 that were specified earlier on the command line.
1546 That way we can get rid of any that were passed
1547 automatically in from GCC. */
1551 struct pending_option
*o1
, *o2
;
1553 o1
= pend
->directive_head
;
1560 pend
->directive_head
= NULL
;
1561 pend
->directive_tail
= NULL
;
1564 new_pending_directive (pend
, arg
+ 1, cpp_unassert
);
1567 new_pending_directive (pend
, arg
, cpp_assert
);
1570 new_pending_directive (pend
, arg
, cpp_undef
);
1572 case OPT_I
: /* Add directory to path for includes. */
1573 if (!strcmp (arg
, "-"))
1576 Use the preceding -I directories for #include "..."
1577 but not #include <...>.
1578 Don't search the directory of the present file
1579 for #include "...". (Note that -I. -I- is not the same as
1580 the default setup; -I. uses the compiler's working dir.) */
1581 if (! CPP_OPTION (pfile
, ignore_srcdir
))
1583 pend
->quote_head
= pend
->brack_head
;
1584 pend
->quote_tail
= pend
->brack_tail
;
1585 pend
->brack_head
= 0;
1586 pend
->brack_tail
= 0;
1587 CPP_OPTION (pfile
, ignore_srcdir
) = 1;
1591 cpp_fatal (pfile
, "-I- specified twice");
1596 append_include_chain (pfile
, xstrdup (arg
), BRACKET
, 0);
1599 /* Add directory to beginning of system include path, as a system
1600 include directory. */
1601 append_include_chain (pfile
, xstrdup (arg
), SYSTEM
, 0);
1605 struct pending_option
*o
= (struct pending_option
*)
1606 xmalloc (sizeof (struct pending_option
));
1609 /* This list has to be built in reverse order so that
1610 when cpp_start_read pushes all the -include files onto
1611 the buffer stack, they will be scanned in forward order. */
1612 o
->next
= pend
->include_head
;
1613 pend
->include_head
= o
;
1618 struct pending_option
*o
= (struct pending_option
*)
1619 xmalloc (sizeof (struct pending_option
));
1623 APPEND (pend
, imacros
, o
);
1626 case OPT_iwithprefix
:
1627 /* Add directory to end of path for includes,
1628 with the default prefix at the front of its name. */
1630 case OPT_iwithprefixbefore
:
1631 /* Add directory to main path for includes,
1632 with the default prefix at the front of its name. */
1639 if (CPP_OPTION (pfile
, include_prefix
) != 0)
1641 size_t ipl
= CPP_OPTION (pfile
, include_prefix_len
);
1642 fname
= xmalloc (ipl
+ len
+ 1);
1643 memcpy (fname
, CPP_OPTION (pfile
, include_prefix
), ipl
);
1644 memcpy (fname
+ ipl
, arg
, len
+ 1);
1646 else if (cpp_GCC_INCLUDE_DIR_len
)
1648 fname
= xmalloc (cpp_GCC_INCLUDE_DIR_len
+ len
+ 1);
1649 memcpy (fname
, cpp_GCC_INCLUDE_DIR
, cpp_GCC_INCLUDE_DIR_len
);
1650 memcpy (fname
+ cpp_GCC_INCLUDE_DIR_len
, arg
, len
+ 1);
1653 fname
= xstrdup (arg
);
1655 append_include_chain (pfile
, fname
,
1656 opt_code
== OPT_iwithprefix
? SYSTEM
: BRACKET
, 0);
1660 /* Add directory to end of path for includes. */
1661 append_include_chain (pfile
, xstrdup (arg
), AFTER
, 0);
1664 /* Silently ignore unrecognised options. */
1665 if (!strcmp (argv
[i
], "-Wall"))
1667 CPP_OPTION (pfile
, warn_trigraphs
) = 1;
1668 CPP_OPTION (pfile
, warn_comments
) = 1;
1670 else if (!strcmp (argv
[i
], "-Wtraditional"))
1671 CPP_OPTION (pfile
, warn_traditional
) = 1;
1672 else if (!strcmp (argv
[i
], "-Wtrigraphs"))
1673 CPP_OPTION (pfile
, warn_trigraphs
) = 1;
1674 else if (!strcmp (argv
[i
], "-Wcomment"))
1675 CPP_OPTION (pfile
, warn_comments
) = 1;
1676 else if (!strcmp (argv
[i
], "-Wcomments"))
1677 CPP_OPTION (pfile
, warn_comments
) = 1;
1678 else if (!strcmp (argv
[i
], "-Wundef"))
1679 CPP_OPTION (pfile
, warn_undef
) = 1;
1680 else if (!strcmp (argv
[i
], "-Wimport"))
1681 CPP_OPTION (pfile
, warn_import
) = 1;
1682 else if (!strcmp (argv
[i
], "-Werror"))
1683 CPP_OPTION (pfile
, warnings_are_errors
) = 1;
1684 else if (!strcmp (argv
[i
], "-Wsystem-headers"))
1685 CPP_OPTION (pfile
, warn_system_headers
) = 1;
1686 else if (!strcmp (argv
[i
], "-Wno-traditional"))
1687 CPP_OPTION (pfile
, warn_traditional
) = 0;
1688 else if (!strcmp (argv
[i
], "-Wno-trigraphs"))
1689 CPP_OPTION (pfile
, warn_trigraphs
) = 0;
1690 else if (!strcmp (argv
[i
], "-Wno-comment"))
1691 CPP_OPTION (pfile
, warn_comments
) = 0;
1692 else if (!strcmp (argv
[i
], "-Wno-comments"))
1693 CPP_OPTION (pfile
, warn_comments
) = 0;
1694 else if (!strcmp (argv
[i
], "-Wno-undef"))
1695 CPP_OPTION (pfile
, warn_undef
) = 0;
1696 else if (!strcmp (argv
[i
], "-Wno-import"))
1697 CPP_OPTION (pfile
, warn_import
) = 0;
1698 else if (!strcmp (argv
[i
], "-Wno-error"))
1699 CPP_OPTION (pfile
, warnings_are_errors
) = 0;
1700 else if (!strcmp (argv
[i
], "-Wno-system-headers"))
1701 CPP_OPTION (pfile
, warn_system_headers
) = 0;
1710 opt_comp (const void *p1
, const void *p2
)
1712 return strcmp (((struct cl_option
*)p1
)->opt_text
,
1713 ((struct cl_option
*)p2
)->opt_text
);
1717 /* Handle command-line options in (argc, argv).
1718 Can be called multiple times, to handle multiple sets of options.
1719 Returns if an unrecognized option is seen.
1720 Returns number of strings consumed. */
1722 cpp_handle_options (pfile
, argc
, argv
)
1728 int strings_processed
;
1730 for (i
= 0; i
< argc
; i
+= strings_processed
)
1732 strings_processed
= cpp_handle_option (pfile
, argc
- i
, argv
+ i
);
1733 if (strings_processed
== 0)
1742 fprintf (stderr
, _("Usage: %s [switches] input output\n"), progname
);
1743 /* To keep the lines from getting too long for some compilers, limit
1744 to about 500 characters (6 lines) per chunk. */
1747 -include <file> Include the contents of <file> before other files\n\
1748 -imacros <file> Accept definition of macros in <file>\n\
1749 -iprefix <path> Specify <path> as a prefix for next two options\n\
1750 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1751 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1752 -isystem <dir> Add <dir> to the start of the system include path\n\
1755 -idirafter <dir> Add <dir> to the end of the system include path\n\
1756 -I <dir> Add <dir> to the end of the main include path\n\
1757 -I- Fine-grained include path control; see info docs\n\
1758 -nostdinc Do not search system include directories\n\
1759 (dirs specified with -isystem will still be used)\n\
1760 -nostdinc++ Do not search system include directories for C++\n\
1761 -o <file> Put output into <file>\n\
1764 -pedantic Issue all warnings demanded by strict ISO C\n\
1765 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1766 -trigraphs Support ISO C trigraphs\n\
1767 -lang-c Assume that the input sources are in C\n\
1768 -lang-c89 Assume that the input sources are in C89\n\
1771 -lang-c++ Assume that the input sources are in C++\n\
1772 -lang-objc Assume that the input sources are in ObjectiveC\n\
1773 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1774 -lang-asm Assume that the input sources are in assembler\n\
1777 -std=<std name> Specify the conformance standard; one of:\n\
1778 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1779 iso9899:199409, iso9899:1999\n\
1780 -+ Allow parsing of C++ style features\n\
1781 -w Inhibit warning messages\n\
1782 -Wtrigraphs Warn if trigraphs are encountered\n\
1783 -Wno-trigraphs Do not warn about trigraphs\n\
1784 -Wcomment{s} Warn if one comment starts inside another\n\
1787 -Wno-comment{s} Do not warn about comments\n\
1788 -Wtraditional Warn about features not present in traditional C\n\
1789 -Wno-traditional Do not warn about traditional C\n\
1790 -Wundef Warn if an undefined macro is used by #if\n\
1791 -Wno-undef Do not warn about testing undefined macros\n\
1792 -Wimport Warn about the use of the #import directive\n\
1795 -Wno-import Do not warn about the use of #import\n\
1796 -Werror Treat all warnings as errors\n\
1797 -Wno-error Do not treat warnings as errors\n\
1798 -Wsystem-headers Do not suppress warnings from system headers\n\
1799 -Wno-system-headers Suppress warnings from system headers\n\
1800 -Wall Enable all preprocessor warnings\n\
1803 -M Generate make dependencies\n\
1804 -MM As -M, but ignore system header files\n\
1805 -MD As -M, but put output in a .d file\n\
1806 -MMD As -MD, but ignore system header files\n\
1807 -MG Treat missing header file as generated files\n\
1808 -g3 Include #define and #undef directives in the output\n\
1811 -D<macro> Define a <macro> with string '1' as its value\n\
1812 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1813 -A<question> (<answer>) Assert the <answer> to <question>\n\
1814 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1815 -U<macro> Undefine <macro> \n\
1816 -v Display the version number\n\
1819 -H Print the name of header files as they are used\n\
1820 -C Do not discard comments\n\
1821 -dM Display a list of macro definitions active at end\n\
1822 -dD Preserve macro definitions in output\n\
1823 -dN As -dD except that only the names are preserved\n\
1824 -dI Include #include directives in the output\n\
1827 -ftabstop=<number> Distance between tab stops for column reporting\n\
1828 -P Do not generate #line directives\n\
1829 -$ Do not allow '$' in identifiers\n\
1830 -remap Remap file names when including files.\n\
1831 --version Display version information\n\
1832 -h or --help Display this information\n\