2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 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 init
PARAMS ((void));
98 static void init_builtins
PARAMS ((cpp_reader
*));
99 static void append_include_chain
PARAMS ((cpp_reader
*,
101 struct file_name_list
* remove_dup_dir
PARAMS ((cpp_reader
*,
102 struct file_name_list
*));
103 struct file_name_list
* remove_dup_dirs
PARAMS ((cpp_reader
*,
104 struct file_name_list
*));
105 static void merge_include_chains
PARAMS ((cpp_reader
*));
106 static void do_includes
PARAMS ((cpp_reader
*,
107 struct pending_option
*,
109 static void set_lang
PARAMS ((cpp_reader
*, enum c_lang
));
110 static void init_dependency_output
PARAMS ((cpp_reader
*));
111 static void init_standard_includes
PARAMS ((cpp_reader
*));
112 static void new_pending_directive
PARAMS ((struct cpp_pending
*,
114 cl_directive_handler
));
115 static void output_deps
PARAMS ((cpp_reader
*));
116 static int parse_option
PARAMS ((const char *));
118 /* Fourth argument to append_include_chain: chain to use. */
119 enum { QUOTE
= 0, BRACKET
, SYSTEM
, AFTER
};
121 /* If we have designated initializers (GCC >2.7) these tables can be
122 initialized, constant data. Otherwise, they have to be filled in at
124 #if HAVE_DESIGNATED_INITIALIZERS
126 #define init_trigraph_map() /* Nothing. */
127 #define TRIGRAPH_MAP \
128 __extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
131 #define s(p, v) [p] = v,
135 #define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
136 static void init_trigraph_map PARAMS ((void)) { \
137 unsigned char *x = _cpp_trigraph_map;
140 #define s(p, v) x[p] = v;
145 s('=', '#') s(')', ']') s('!', '|')
146 s('(', '[') s('\'', '^') s('>', '}')
147 s('/', '\\') s('<', '{') s('-', '~')
154 /* Given a colon-separated list of file names PATH,
155 add all the names to the search path for include files. */
158 path_include (pfile
, list
, path
)
169 /* Find the end of this name. */
171 while (*q
!= 0 && *q
!= PATH_SEPARATOR
) q
++;
174 /* An empty name in the path stands for the current directory. */
175 name
= (char *) xmalloc (2);
181 /* Otherwise use the directory that is named. */
182 name
= (char *) xmalloc (q
- p
+ 1);
183 memcpy (name
, p
, q
- p
);
187 append_include_chain (pfile
, name
, path
, 0);
189 /* Advance past this name. */
197 /* Append DIR to include path PATH. DIR must be permanently allocated
200 append_include_chain (pfile
, dir
, path
, cxx_aware
)
206 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
207 struct file_name_list
*new;
211 _cpp_simplify_pathname (dir
);
214 /* Dirs that don't exist are silently ignored. */
216 cpp_notice_from_errno (pfile
, dir
);
217 else if (CPP_OPTION (pfile
, verbose
))
218 fprintf (stderr
, _("ignoring nonexistent directory \"%s\"\n"), dir
);
222 if (!S_ISDIR (st
.st_mode
))
224 cpp_notice (pfile
, "%s: Not a directory", dir
);
229 if (len
> pfile
->max_include_len
)
230 pfile
->max_include_len
= len
;
232 new = (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
235 new->ino
= st
.st_ino
;
236 new->dev
= st
.st_dev
;
238 new->sysp
= cxx_aware
? 1 : 2;
241 new->name_map
= NULL
;
247 case QUOTE
: APPEND (pend
, quote
, new); break;
248 case BRACKET
: APPEND (pend
, brack
, new); break;
249 case SYSTEM
: APPEND (pend
, systm
, new); break;
250 case AFTER
: APPEND (pend
, after
, new); break;
254 /* Handle a duplicated include path. PREV is the link in the chain
255 before the duplicate. The duplicate is removed from the chain and
256 freed. Returns PREV. */
257 struct file_name_list
*
258 remove_dup_dir (pfile
, prev
)
260 struct file_name_list
*prev
;
262 struct file_name_list
*cur
= prev
->next
;
264 if (CPP_OPTION (pfile
, verbose
))
265 fprintf (stderr
, _("ignoring duplicate directory \"%s\"\n"), cur
->name
);
267 prev
->next
= cur
->next
;
274 /* Remove duplicate directories from a chain. Returns the tail of the
275 chain, or NULL if the chain is empty. This algorithm is quadratic
276 in the number of -I switches, which is acceptable since there
277 aren't usually that many of them. */
278 struct file_name_list
*
279 remove_dup_dirs (pfile
, head
)
281 struct file_name_list
*head
;
283 struct file_name_list
*prev
= NULL
, *cur
, *other
;
285 for (cur
= head
; cur
; cur
= cur
->next
)
287 for (other
= head
; other
!= cur
; other
= other
->next
)
288 if (INO_T_EQ (cur
->ino
, other
->ino
) && cur
->dev
== other
->dev
)
290 cur
= remove_dup_dir (pfile
, prev
);
299 /* Merge the four include chains together in the order quote, bracket,
300 system, after. Remove duplicate dirs (as determined by
301 INO_T_EQ()). The system_include and after_include chains are never
302 referred to again after this function; all access is through the
303 bracket_include path.
305 For the future: Check if the directory is empty (but
306 how?) and possibly preload the include hash. */
309 merge_include_chains (pfile
)
312 struct file_name_list
*quote
, *brack
, *systm
, *qtail
;
314 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
316 quote
= pend
->quote_head
;
317 brack
= pend
->brack_head
;
318 systm
= pend
->systm_head
;
319 qtail
= pend
->quote_tail
;
321 /* Paste together bracket, system, and after include chains. */
323 pend
->systm_tail
->next
= pend
->after_head
;
325 systm
= pend
->after_head
;
328 pend
->brack_tail
->next
= systm
;
332 /* This is a bit tricky. First we drop dupes from the quote-include
333 list. Then we drop dupes from the bracket-include list.
334 Finally, if qtail and brack are the same directory, we cut out
337 We can't just merge the lists and then uniquify them because
338 then we may lose directories from the <> search path that should
339 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
340 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
341 -Ibar -I- -Ifoo -Iquux. */
343 remove_dup_dirs (pfile
, brack
);
344 qtail
= remove_dup_dirs (pfile
, quote
);
350 /* If brack == qtail, remove brack as it's simpler. */
351 if (INO_T_EQ (qtail
->ino
, brack
->ino
) && qtail
->dev
== brack
->dev
)
352 brack
= remove_dup_dir (pfile
, qtail
);
357 CPP_OPTION (pfile
, quote_include
) = quote
;
358 CPP_OPTION (pfile
, bracket_include
) = brack
;
361 /* Sets internal flags correctly for a given language, and defines
362 macros if necessary. */
364 set_lang (pfile
, lang
)
368 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
371 CPP_OPTION (pfile
, lang
) = lang
;
372 CPP_OPTION (pfile
, objc
) = 0;
373 CPP_OPTION (pfile
, cplusplus
) = 0;
374 CPP_OPTION (pfile
, extended_numbers
) = 1; /* Allowed in GNU C and C99. */
380 CPP_OPTION (pfile
, trigraphs
) = 0;
381 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
382 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
383 CPP_OPTION (pfile
, digraphs
) = 1;
384 CPP_OPTION (pfile
, c99
) = 1;
385 new_pending_directive (pend
, "__STDC_VERSION__=199901L", cpp_define
);
388 CPP_OPTION (pfile
, trigraphs
) = 0;
389 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
390 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
391 CPP_OPTION (pfile
, digraphs
) = 1;
392 CPP_OPTION (pfile
, c99
) = 0;
397 new_pending_directive (pend
, "__STDC_VERSION__=199409L", cpp_define
);
399 CPP_OPTION (pfile
, trigraphs
) = 1;
400 CPP_OPTION (pfile
, dollars_in_ident
) = 0;
401 CPP_OPTION (pfile
, cplusplus_comments
) = 0;
402 CPP_OPTION (pfile
, digraphs
) = lang
== CLK_STDC94
;
403 CPP_OPTION (pfile
, c99
) = 0;
404 CPP_OPTION (pfile
, extended_numbers
) = 0;
405 new_pending_directive (pend
, "__STRICT_ANSI__", cpp_define
);
408 CPP_OPTION (pfile
, trigraphs
) = 1;
409 CPP_OPTION (pfile
, dollars_in_ident
) = 0;
410 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
411 CPP_OPTION (pfile
, digraphs
) = 1;
412 CPP_OPTION (pfile
, c99
) = 1;
413 new_pending_directive (pend
, "__STRICT_ANSI__", cpp_define
);
414 new_pending_directive (pend
, "__STDC_VERSION__=199901L", cpp_define
);
419 new_pending_directive (pend
, "__cplusplus", cpp_define
);
420 CPP_OPTION (pfile
, cplusplus
) = 1;
422 CPP_OPTION (pfile
, trigraphs
) = 0;
423 CPP_OPTION (pfile
, dollars_in_ident
) = 1;
424 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
425 CPP_OPTION (pfile
, digraphs
) = 1;
426 CPP_OPTION (pfile
, c99
) = 0;
427 CPP_OPTION (pfile
, objc
) = 1;
428 new_pending_directive (pend
, "__OBJC__", cpp_define
);
434 CPP_OPTION (pfile
, cplusplus
) = 1;
435 CPP_OPTION (pfile
, trigraphs
) = lang
== CLK_CXX98
;
436 CPP_OPTION (pfile
, dollars_in_ident
) = lang
== CLK_GNUCXX
;
437 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
438 CPP_OPTION (pfile
, digraphs
) = 1;
439 CPP_OPTION (pfile
, c99
) = 0;
440 new_pending_directive (pend
, "__cplusplus", cpp_define
);
445 CPP_OPTION (pfile
, trigraphs
) = 0;
446 CPP_OPTION (pfile
, dollars_in_ident
) = 0; /* Maybe not? */
447 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
448 CPP_OPTION (pfile
, digraphs
) = 0;
449 CPP_OPTION (pfile
, c99
) = 0;
450 new_pending_directive (pend
, "__ASSEMBLER__", cpp_define
);
456 static int opt_comp
PARAMS ((const void *, const void *));
458 /* Run-time sorting of options array. */
463 return strcmp (((struct cl_option
*) p1
)->opt_text
,
464 ((struct cl_option
*) p2
)->opt_text
);
468 /* init initializes library global state. It might not need to
469 do anything depending on the platform and compiler. */
474 static int initialized
= 0;
481 /* For non-ASCII hosts, the cl_options array needs to be sorted at
483 qsort (cl_options
, N_OPTS
, sizeof (struct cl_option
), opt_comp
);
486 /* Set up the trigraph map. This doesn't need to do anything if
487 we were compiled with a compiler that supports C99 designated
489 init_trigraph_map ();
493 /* Initialize a cpp_reader structure. */
495 cpp_create_reader (lang
)
498 struct spec_nodes
*s
;
501 /* Initialise this instance of the library if it hasn't been already. */
504 pfile
= (cpp_reader
*) xcalloc (1, sizeof (cpp_reader
));
506 CPP_OPTION (pfile
, warn_import
) = 1;
507 CPP_OPTION (pfile
, discard_comments
) = 1;
508 CPP_OPTION (pfile
, show_column
) = 1;
509 CPP_OPTION (pfile
, tabstop
) = 8;
510 CPP_OPTION (pfile
, operator_names
) = 1;
512 CPP_OPTION (pfile
, pending
) =
513 (struct cpp_pending
*) xcalloc (1, sizeof (struct cpp_pending
));
515 /* After creating pfile->pending. */
516 set_lang (pfile
, lang
);
518 /* It's simplest to just create this struct whether or not it will
520 pfile
->deps
= deps_init ();
522 /* Initialize lexer state. */
523 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
525 /* Indicate date and time not yet calculated. */
526 pfile
->date
.type
= CPP_EOF
;
528 /* Initialise the base context. */
529 pfile
->context
= &pfile
->base_context
;
530 pfile
->base_context
.macro
= 0;
531 pfile
->base_context
.prev
= pfile
->base_context
.next
= 0;
533 /* Identifier pool initially 8K. Unaligned, permanent pool. */
534 _cpp_init_pool (&pfile
->ident_pool
, 8 * 1024, 1, 0);
536 /* Argument pool initially 8K. Aligned, temporary pool. */
537 _cpp_init_pool (&pfile
->argument_pool
, 8 * 1024, 0, 1);
539 /* Macro pool initially 8K. Aligned, permanent pool. */
540 _cpp_init_pool (&pfile
->macro_pool
, 8 * 1024, 0, 0);
542 _cpp_init_hashtable (pfile
);
543 _cpp_init_stacks (pfile
);
544 _cpp_init_includes (pfile
);
545 _cpp_init_internal_pragmas (pfile
);
547 /* Initialize the special nodes. */
548 s
= &pfile
->spec_nodes
;
549 s
->n_L
= cpp_lookup (pfile
, DSC("L"));
550 s
->n_defined
= cpp_lookup (pfile
, DSC("defined"));
551 s
->n__Pragma
= cpp_lookup (pfile
, DSC("_Pragma"));
552 s
->n__STRICT_ANSI__
= cpp_lookup (pfile
, DSC("__STRICT_ANSI__"));
553 s
->n__CHAR_UNSIGNED__
= cpp_lookup (pfile
, DSC("__CHAR_UNSIGNED__"));
554 s
->n__VA_ARGS__
= cpp_lookup (pfile
, DSC("__VA_ARGS__"));
555 s
->n__VA_ARGS__
->flags
|= NODE_DIAGNOSTIC
;
560 /* Free resources used by PFILE.
561 This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology). */
566 struct file_name_list
*dir
, *dirn
;
567 cpp_context
*context
, *contextn
;
569 while (CPP_BUFFER (pfile
) != NULL
)
570 cpp_pop_buffer (pfile
);
572 if (pfile
->macro_buffer
)
573 free ((PTR
) pfile
->macro_buffer
);
575 deps_free (pfile
->deps
);
577 _cpp_cleanup_includes (pfile
);
578 _cpp_cleanup_stacks (pfile
);
579 _cpp_cleanup_hashtable (pfile
);
581 _cpp_free_lookaheads (pfile
);
583 _cpp_free_pool (&pfile
->ident_pool
);
584 _cpp_free_pool (&pfile
->macro_pool
);
585 _cpp_free_pool (&pfile
->argument_pool
);
587 for (dir
= CPP_OPTION (pfile
, quote_include
); dir
; dir
= dirn
)
594 for (context
= pfile
->base_context
.next
; context
; context
= contextn
)
596 contextn
= context
->next
;
602 /* This structure defines one built-in identifier. A node will be
603 entered in the hash table under the name NAME, with value VALUE (if
604 any). If flags has OPERATOR, the node's operator field is used; if
605 flags has BUILTIN the node's builtin field is used.
607 Two values are not compile time constants, so we tag
608 them in the FLAGS field instead:
609 VERS value is the global version_string, quoted
610 ULP value is the global user_label_prefix
612 Also, macros with CPLUS set in the flags field are entered only for C++. */
618 unsigned char builtin
;
619 unsigned char operator;
620 unsigned short flags
;
627 #define OPERATOR 0x10
629 #define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
630 #define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 }
631 #define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 }
632 #define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
633 static const struct builtin builtin_array
[] =
635 B("__TIME__", BT_TIME
),
636 B("__DATE__", BT_DATE
),
637 B("__FILE__", BT_FILE
),
638 B("__BASE_FILE__", BT_BASE_FILE
),
639 B("__LINE__", BT_SPECLINE
),
640 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL
),
641 B("__STDC__", BT_STDC
),
643 X("__VERSION__", VERS
),
644 X("__USER_LABEL_PREFIX__", ULP
),
645 C("__REGISTER_PREFIX__", REGISTER_PREFIX
),
646 C("__HAVE_BUILTIN_SETJMP__", "1"),
647 #ifndef NO_BUILTIN_SIZE_TYPE
648 C("__SIZE_TYPE__", SIZE_TYPE
),
650 #ifndef NO_BUILTIN_PTRDIFF_TYPE
651 C("__PTRDIFF_TYPE__", PTRDIFF_TYPE
),
653 #ifndef NO_BUILTIN_WCHAR_TYPE
654 C("__WCHAR_TYPE__", WCHAR_TYPE
),
656 #ifndef NO_BUILTIN_WINT_TYPE
657 C("__WINT_TYPE__", WINT_TYPE
),
660 /* Named operators known to the preprocessor. These cannot be #defined
661 and always have their stated meaning. They are treated like normal
662 identifiers except for the type code and the meaning. Most of them
663 are only for C++ (but see iso646.h). */
664 O("and", CPP_AND_AND
, CPLUS
),
665 O("and_eq", CPP_AND_EQ
, CPLUS
),
666 O("bitand", CPP_AND
, CPLUS
),
667 O("bitor", CPP_OR
, CPLUS
),
668 O("compl", CPP_COMPL
, CPLUS
),
669 O("not", CPP_NOT
, CPLUS
),
670 O("not_eq", CPP_NOT_EQ
, CPLUS
),
671 O("or", CPP_OR_OR
, CPLUS
),
672 O("or_eq", CPP_OR_EQ
, CPLUS
),
673 O("xor", CPP_XOR
, CPLUS
),
674 O("xor_eq", CPP_XOR_EQ
, CPLUS
)
680 #define builtin_array_end \
681 builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
683 /* Subroutine of cpp_start_read; reads the builtins table above and
684 enters the macros into the hash table. */
686 init_builtins (pfile
)
689 const struct builtin
*b
;
691 for(b
= builtin_array
; b
< builtin_array_end
; b
++)
693 if ((b
->flags
& CPLUS
) && ! CPP_OPTION (pfile
, cplusplus
))
696 if ((b
->flags
& OPERATOR
) && ! CPP_OPTION (pfile
, operator_names
))
699 if (b
->flags
& (OPERATOR
| BUILTIN
))
701 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
702 if (b
->flags
& OPERATOR
)
704 hp
->flags
|= NODE_OPERATOR
;
705 hp
->value
.operator = b
->operator;
710 hp
->flags
|= NODE_BUILTIN
;
711 hp
->value
.builtin
= b
->builtin
;
714 else /* A standard macro of some kind. */
721 /* Allocate enough space for 'name "value"\n\0'. */
722 str
= alloca (b
->len
+ strlen (version_string
) + 5);
723 sprintf (str
, "%s \"%s\"\n", b
->name
, version_string
);
728 val
= CPP_OPTION (pfile
, user_label_prefix
);
732 /* Allocate enough space for "name value\n\0". */
733 str
= alloca (b
->len
+ strlen (val
) + 3);
734 sprintf(str
, "%s %s\n", b
->name
, val
);
737 _cpp_define_builtin (pfile
, str
);
746 #undef builtin_array_end
748 /* And another subroutine. This one sets up the standard include path. */
750 init_standard_includes (pfile
)
754 const struct default_include
*p
;
755 const char *specd_prefix
= CPP_OPTION (pfile
, include_prefix
);
757 /* Several environment variables may add to the include search path.
758 CPATH specifies an additional list of directories to be searched
759 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
760 etc. specify an additional list of directories to be searched as
761 if specified with -isystem, for the language indicated. */
763 GET_ENV_PATH_LIST (path
, "CPATH");
764 if (path
!= 0 && *path
!= 0)
765 path_include (pfile
, path
, BRACKET
);
767 switch ((CPP_OPTION (pfile
, objc
) << 1) + CPP_OPTION (pfile
, cplusplus
))
770 GET_ENV_PATH_LIST (path
, "C_INCLUDE_PATH");
773 GET_ENV_PATH_LIST (path
, "CPLUS_INCLUDE_PATH");
776 GET_ENV_PATH_LIST (path
, "OBJC_INCLUDE_PATH");
779 GET_ENV_PATH_LIST (path
, "OBJCPLUS_INCLUDE_PATH");
782 if (path
!= 0 && *path
!= 0)
783 path_include (pfile
, path
, SYSTEM
);
785 /* Search "translated" versions of GNU directories.
786 These have /usr/local/lib/gcc... replaced by specd_prefix. */
787 if (specd_prefix
!= 0 && cpp_GCC_INCLUDE_DIR_len
)
789 /* Remove the `include' from /usr/local/lib/gcc.../include.
790 GCC_INCLUDE_DIR will always end in /include. */
791 int default_len
= cpp_GCC_INCLUDE_DIR_len
;
792 char *default_prefix
= (char *) alloca (default_len
+ 1);
793 int specd_len
= strlen (specd_prefix
);
795 memcpy (default_prefix
, cpp_GCC_INCLUDE_DIR
, default_len
);
796 default_prefix
[default_len
] = '\0';
798 for (p
= cpp_include_defaults
; p
->fname
; p
++)
800 /* Some standard dirs are only for C++. */
802 || (CPP_OPTION (pfile
, cplusplus
)
803 && !CPP_OPTION (pfile
, no_standard_cplusplus_includes
)))
805 /* Does this dir start with the prefix? */
806 if (!memcmp (p
->fname
, default_prefix
, default_len
))
808 /* Yes; change prefix and add to search list. */
809 int flen
= strlen (p
->fname
);
810 int this_len
= specd_len
+ flen
- default_len
;
811 char *str
= (char *) xmalloc (this_len
+ 1);
812 memcpy (str
, specd_prefix
, specd_len
);
813 memcpy (str
+ specd_len
,
814 p
->fname
+ default_len
,
815 flen
- default_len
+ 1);
817 append_include_chain (pfile
, str
, SYSTEM
, p
->cxx_aware
);
823 /* Search ordinary names for GNU include directories. */
824 for (p
= cpp_include_defaults
; p
->fname
; p
++)
826 /* Some standard dirs are only for C++. */
828 || (CPP_OPTION (pfile
, cplusplus
)
829 && !CPP_OPTION (pfile
, no_standard_cplusplus_includes
)))
831 char *str
= xstrdup (update_path (p
->fname
, p
->component
));
832 append_include_chain (pfile
, str
, SYSTEM
, p
->cxx_aware
);
837 /* Handles -imacro and -include from the command line. */
839 do_includes (pfile
, p
, scan
)
841 struct pending_option
*p
;
846 struct pending_option
*q
;
848 /* Later: maybe update this to use the #include "" search path
849 if cpp_read_file fails. */
850 if (_cpp_read_file (pfile
, p
->arg
) && scan
)
851 cpp_scan_buffer_nooutput (pfile
, 0);
858 /* This is called after options have been processed. Check options
859 for consistency, and setup for processing input from the file named
860 FNAME. (Use standard input if FNAME == NULL.) Return 1 on success,
864 cpp_start_read (pfile
, fname
)
868 struct pending_option
*p
, *q
;
870 /* Set up the include search path now. */
871 if (! CPP_OPTION (pfile
, no_standard_includes
))
872 init_standard_includes (pfile
);
874 merge_include_chains (pfile
);
876 /* With -v, print the list of dirs to search. */
877 if (CPP_OPTION (pfile
, verbose
))
879 struct file_name_list
*l
;
880 fprintf (stderr
, _("#include \"...\" search starts here:\n"));
881 for (l
= CPP_OPTION (pfile
, quote_include
); l
; l
= l
->next
)
883 if (l
== CPP_OPTION (pfile
, bracket_include
))
884 fprintf (stderr
, _("#include <...> search starts here:\n"));
885 fprintf (stderr
, " %s\n", l
->name
);
887 fprintf (stderr
, _("End of search list.\n"));
890 if (CPP_OPTION (pfile
, in_fname
) == NULL
891 || *CPP_OPTION (pfile
, in_fname
) == 0)
893 CPP_OPTION (pfile
, in_fname
) = fname
;
894 if (CPP_OPTION (pfile
, in_fname
) == NULL
)
895 CPP_OPTION (pfile
, in_fname
) = "";
897 if (CPP_OPTION (pfile
, out_fname
) == NULL
)
898 CPP_OPTION (pfile
, out_fname
) = "";
900 if (CPP_OPTION (pfile
, print_deps
))
902 /* Set the default target (if there is none already). */
903 deps_add_default_target (pfile
->deps
, CPP_OPTION (pfile
, in_fname
));
905 if (CPP_OPTION (pfile
, in_fname
))
906 deps_add_dep (pfile
->deps
, CPP_OPTION (pfile
, in_fname
));
909 /* Open the main input file. This must be done early, so we have a
910 buffer to stand on. */
911 if (!_cpp_read_file (pfile
, fname
))
914 /* Install __LINE__, etc. */
915 init_builtins (pfile
);
917 /* Do -U's, -D's and -A's in the order they were seen. */
918 p
= CPP_OPTION (pfile
, pending
)->directive_head
;
921 (*p
->handler
) (pfile
, p
->arg
);
926 pfile
->done_initializing
= 1;
928 /* The -imacros files can be scanned now, but the -include files
929 have to be pushed onto the buffer stack and processed later,
930 otherwise cppmain.c won't see the tokens. include_head was built
931 up as a stack, and popping this stack onto the buffer stack means
932 we preserve the order of the command line. */
933 do_includes (pfile
, CPP_OPTION (pfile
, pending
)->imacros_head
, 1);
934 do_includes (pfile
, CPP_OPTION (pfile
, pending
)->include_head
, 0);
936 free (CPP_OPTION (pfile
, pending
));
937 CPP_OPTION (pfile
, pending
) = NULL
;
946 /* Stream on which to print the dependency information. */
947 FILE *deps_stream
= 0;
948 const char *deps_mode
= CPP_OPTION (pfile
, print_deps_append
) ? "a" : "w";
950 if (CPP_OPTION (pfile
, deps_file
) == 0)
951 deps_stream
= stdout
;
954 deps_stream
= fopen (CPP_OPTION (pfile
, deps_file
), deps_mode
);
955 if (deps_stream
== 0)
957 cpp_notice_from_errno (pfile
, CPP_OPTION (pfile
, deps_file
));
962 deps_write (pfile
->deps
, deps_stream
, 72);
964 if (CPP_OPTION (pfile
, deps_phony_targets
))
965 deps_phony_targets (pfile
->deps
, deps_stream
);
967 /* Don't close stdout. */
968 if (CPP_OPTION (pfile
, deps_file
))
970 if (ferror (deps_stream
) || fclose (deps_stream
) != 0)
971 cpp_fatal (pfile
, "I/O error on output");
975 /* This is called at the end of preprocessing. It pops the
976 last buffer and writes dependency output. It should also
977 clear macro definitions, such that you could call cpp_start_read
978 with a new filename to restart processing. */
983 if (CPP_BUFFER (pfile
))
985 cpp_ice (pfile
, "buffers still stacked in cpp_finish");
986 while (CPP_BUFFER (pfile
))
987 cpp_pop_buffer (pfile
);
990 /* Don't write the deps file if preprocessing has failed. */
991 if (CPP_OPTION (pfile
, print_deps
) && pfile
->errors
== 0)
994 /* Report on headers that could use multiple include guards. */
995 if (CPP_OPTION (pfile
, print_include_names
))
996 _cpp_report_missing_guards (pfile
);
1000 new_pending_directive (pend
, text
, handler
)
1001 struct cpp_pending
*pend
;
1003 cl_directive_handler handler
;
1005 struct pending_option
*o
= (struct pending_option
*)
1006 xmalloc (sizeof (struct pending_option
));
1010 o
->handler
= handler
;
1011 APPEND (pend
, directive
, o
);
1014 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1015 I.e. a const string initializer with parens around it. That is
1016 what N_("string") resolves to, so we make no_* be macros instead. */
1017 #define no_arg N_("Argument missing after %s")
1018 #define no_ass N_("Assertion missing after %s")
1019 #define no_dir N_("Directory name missing after %s")
1020 #define no_fil N_("File name missing after %s")
1021 #define no_mac N_("Macro name missing after %s")
1022 #define no_pth N_("Path name missing after %s")
1023 #define no_num N_("Number missing after %s")
1024 #define no_tgt N_("Target missing after %s")
1026 /* This is the list of all command line options, with the leading
1027 "-" removed. It must be sorted in ASCII collating order. */
1028 #define COMMAND_LINE_OPTIONS \
1029 DEF_OPT("", 0, OPT_stdin_stdout) \
1030 DEF_OPT("$", 0, OPT_dollar) \
1031 DEF_OPT("+", 0, OPT_plus) \
1032 DEF_OPT("-help", 0, OPT__help) \
1033 DEF_OPT("-target-help", 0, OPT_target__help) \
1034 DEF_OPT("-version", 0, OPT__version) \
1035 DEF_OPT("A", no_ass, OPT_A) \
1036 DEF_OPT("C", 0, OPT_C) \
1037 DEF_OPT("D", no_mac, OPT_D) \
1038 DEF_OPT("H", 0, OPT_H) \
1039 DEF_OPT("I", no_dir, OPT_I) \
1040 DEF_OPT("M", 0, OPT_M) \
1041 DEF_OPT("MF", no_fil, OPT_MF) \
1042 DEF_OPT("MG", 0, OPT_MG) \
1043 DEF_OPT("MM", 0, OPT_MM) \
1044 DEF_OPT("MP", 0, OPT_MP) \
1045 DEF_OPT("MQ", no_tgt, OPT_MQ) \
1046 DEF_OPT("MT", no_tgt, OPT_MT) \
1047 DEF_OPT("P", 0, OPT_P) \
1048 DEF_OPT("U", no_mac, OPT_U) \
1049 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1050 DEF_OPT("d", no_arg, OPT_d) \
1051 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1052 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1053 DEF_OPT("fno-operator-names", 0, OPT_fno_operator_names) \
1054 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1055 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1056 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1057 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1058 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1059 DEF_OPT("g", no_arg, OPT_g) /* arg optional */ \
1060 DEF_OPT("h", 0, OPT_h) \
1061 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1062 DEF_OPT("imacros", no_fil, OPT_imacros) \
1063 DEF_OPT("include", no_fil, OPT_include) \
1064 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1065 DEF_OPT("isystem", no_dir, OPT_isystem) \
1066 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1067 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1068 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1069 DEF_OPT("lang-c", 0, OPT_lang_c) \
1070 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1071 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1072 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1073 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1074 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1075 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1076 DEF_OPT("o", no_fil, OPT_o) \
1077 DEF_OPT("pedantic", 0, OPT_pedantic) \
1078 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1079 DEF_OPT("remap", 0, OPT_remap) \
1080 DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
1081 DEF_OPT("std=c89", 0, OPT_std_c89) \
1082 DEF_OPT("std=c99", 0, OPT_std_c99) \
1083 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1084 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1085 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1086 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1087 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1088 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1089 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1090 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1091 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1092 DEF_OPT("v", 0, OPT_v) \
1093 DEF_OPT("version", 0, OPT_version) \
1094 DEF_OPT("w", 0, OPT_w)
1096 #define DEF_OPT(text, msg, code) code,
1099 COMMAND_LINE_OPTIONS
1106 const char *opt_text
;
1109 enum opt_code opt_code
;
1112 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1114 static struct cl_option cl_options
[] =
1116 static const struct cl_option cl_options
[] =
1119 COMMAND_LINE_OPTIONS
1122 #undef COMMAND_LINE_OPTIONS
1124 /* Perform a binary search to find which, if any, option the given
1125 command-line matches. Returns its index in the option array,
1126 negative on failure. Complications arise since some options can be
1127 suffixed with an argument, and multiple complete matches can occur,
1128 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we want to
1129 accept options beginning with -g and -W that we do not recognise,
1130 but not to swallow any subsequent command line argument; these are
1131 handled as special cases in cpp_handle_option. */
1133 parse_option (input
)
1136 unsigned int md
, mn
, mx
;
1147 opt_len
= cl_options
[md
].opt_len
;
1148 comp
= memcmp (input
, cl_options
[md
].opt_text
, opt_len
);
1156 if (input
[opt_len
] == '\0')
1158 /* We were passed more text. If the option takes an argument,
1159 we may match a later option or we may have been passed the
1160 argument. The longest possible option match succeeds.
1161 If the option takes no arguments we have not matched and
1162 continue the search (e.g. input="stdc++" match was "stdc"). */
1164 if (cl_options
[md
].msg
)
1166 /* Scan forwards. If we get an exact match, return it.
1167 Otherwise, return the longest option-accepting match.
1168 This loops no more than twice with current options. */
1170 for (; mn
< N_OPTS
; mn
++)
1172 opt_len
= cl_options
[mn
].opt_len
;
1173 if (memcmp (input
, cl_options
[mn
].opt_text
, opt_len
))
1175 if (input
[opt_len
] == '\0')
1177 if (cl_options
[mn
].msg
)
1188 /* Handle one command-line option in (argc, argv).
1189 Can be called multiple times, to handle multiple sets of options.
1190 Returns number of strings consumed. */
1193 cpp_handle_option (pfile
, argc
, argv
)
1199 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
1201 if (argv
[i
][0] != '-')
1203 if (CPP_OPTION (pfile
, out_fname
) != NULL
)
1204 cpp_fatal (pfile
, "Too many arguments. Type %s --help for usage info",
1206 else if (CPP_OPTION (pfile
, in_fname
) != NULL
)
1207 CPP_OPTION (pfile
, out_fname
) = argv
[i
];
1209 CPP_OPTION (pfile
, in_fname
) = argv
[i
];
1213 enum opt_code opt_code
;
1215 const char *arg
= 0;
1217 /* Skip over '-'. */
1218 opt_index
= parse_option (&argv
[i
][1]);
1222 opt_code
= cl_options
[opt_index
].opt_code
;
1223 if (cl_options
[opt_index
].msg
)
1225 arg
= &argv
[i
][cl_options
[opt_index
].opt_len
+ 1];
1227 /* Yuk. Special case for -g and -W as they must not swallow
1228 up any following argument. If this becomes common, add
1229 another field to the cl_options table. */
1230 if (arg
[0] == '\0' && !(opt_code
== OPT_g
|| opt_code
== OPT_W
))
1235 cpp_fatal (pfile
, cl_options
[opt_index
].msg
, argv
[i
- 1]);
1243 case N_OPTS
: /* Shut GCC up. */
1245 case OPT_fleading_underscore
:
1246 CPP_OPTION (pfile
, user_label_prefix
) = "_";
1248 case OPT_fno_leading_underscore
:
1249 CPP_OPTION (pfile
, user_label_prefix
) = "";
1251 case OPT_fno_operator_names
:
1252 CPP_OPTION (pfile
, operator_names
) = 0;
1254 case OPT_fpreprocessed
:
1255 CPP_OPTION (pfile
, preprocessed
) = 1;
1257 case OPT_fno_preprocessed
:
1258 CPP_OPTION (pfile
, preprocessed
) = 0;
1260 case OPT_fshow_column
:
1261 CPP_OPTION (pfile
, show_column
) = 1;
1263 case OPT_fno_show_column
:
1264 CPP_OPTION (pfile
, show_column
) = 0;
1267 /* Silently ignore empty string, non-longs and silly values. */
1271 long tabstop
= strtol (arg
, &endptr
, 10);
1272 if (*endptr
== '\0' && tabstop
>= 1 && tabstop
<= 100)
1273 CPP_OPTION (pfile
, tabstop
) = tabstop
;
1277 CPP_OPTION (pfile
, inhibit_warnings
) = 1;
1279 case OPT_g
: /* Silently ignore anything but -g3. */
1280 if (!strcmp(&argv
[i
][2], "3"))
1281 CPP_OPTION (pfile
, debug_output
) = 1;
1286 pfile
->help_only
= 1;
1288 case OPT_target__help
:
1289 /* Print if any target specific options. cpplib has none, but
1290 make sure help_only gets set. */
1291 pfile
->help_only
= 1;
1294 /* --version inhibits compilation, -version doesn't. -v means
1295 verbose and -version. Historical reasons, don't ask. */
1297 pfile
->help_only
= 1;
1300 CPP_OPTION (pfile
, verbose
) = 1;
1305 fprintf (stderr
, _("GNU CPP version %s (cpplib)"), version_string
);
1306 #ifdef TARGET_VERSION
1309 fputc ('\n', stderr
);
1313 CPP_OPTION (pfile
, discard_comments
) = 0;
1316 CPP_OPTION (pfile
, no_line_commands
) = 1;
1318 case OPT_dollar
: /* Don't include $ in identifiers. */
1319 CPP_OPTION (pfile
, dollars_in_ident
) = 0;
1322 CPP_OPTION (pfile
, print_include_names
) = 1;
1325 new_pending_directive (pend
, arg
, cpp_define
);
1327 case OPT_pedantic_errors
:
1328 CPP_OPTION (pfile
, pedantic_errors
) = 1;
1331 CPP_OPTION (pfile
, pedantic
) = 1;
1334 CPP_OPTION (pfile
, trigraphs
) = 1;
1337 CPP_OPTION (pfile
, cplusplus
) = 1;
1338 CPP_OPTION (pfile
, cplusplus_comments
) = 1;
1341 CPP_OPTION (pfile
, remap
) = 1;
1344 CPP_OPTION (pfile
, include_prefix
) = arg
;
1345 CPP_OPTION (pfile
, include_prefix_len
) = strlen (arg
);
1348 set_lang (pfile
, CLK_GNUC89
);
1350 case OPT_lang_cplusplus
:
1351 set_lang (pfile
, CLK_GNUCXX
);
1354 set_lang (pfile
, CLK_OBJC
);
1356 case OPT_lang_objcplusplus
:
1357 set_lang (pfile
, CLK_OBJCXX
);
1360 set_lang (pfile
, CLK_ASM
);
1362 case OPT_std_cplusplus98
:
1363 set_lang (pfile
, CLK_CXX98
);
1366 set_lang (pfile
, CLK_GNUC89
);
1370 set_lang (pfile
, CLK_GNUC99
);
1372 case OPT_std_iso9899_199409
:
1373 set_lang (pfile
, CLK_STDC94
);
1375 case OPT_std_iso9899_1990
:
1378 set_lang (pfile
, CLK_STDC89
);
1380 case OPT_std_iso9899_199x
:
1381 case OPT_std_iso9899_1999
:
1384 set_lang (pfile
, CLK_STDC99
);
1387 /* -nostdinc causes no default include directories.
1388 You must specify all include-file directories with -I. */
1389 CPP_OPTION (pfile
, no_standard_includes
) = 1;
1391 case OPT_nostdincplusplus
:
1392 /* -nostdinc++ causes no default C++-specific include directories. */
1393 CPP_OPTION (pfile
, no_standard_cplusplus_includes
) = 1;
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
) = "";
1405 case OPT_stdin_stdout
:
1406 /* JF handle '-' as file name meaning stdin or stdout. */
1407 if (CPP_OPTION (pfile
, in_fname
) == NULL
)
1408 CPP_OPTION (pfile
, in_fname
) = "";
1409 else if (CPP_OPTION (pfile
, out_fname
) == NULL
)
1410 CPP_OPTION (pfile
, out_fname
) = "";
1413 /* Args to -d specify what parts of macros to dump.
1414 Silently ignore unrecognised options; they may
1415 be aimed at the compiler proper. */
1419 while ((c
= *arg
++) != '\0')
1423 CPP_OPTION (pfile
, dump_macros
) = dump_only
;
1424 CPP_OPTION (pfile
, no_output
) = 1;
1427 CPP_OPTION (pfile
, dump_macros
) = dump_names
;
1430 CPP_OPTION (pfile
, dump_macros
) = dump_definitions
;
1433 CPP_OPTION (pfile
, dump_includes
) = 1;
1440 CPP_OPTION (pfile
, print_deps_missing_files
) = 1;
1443 CPP_OPTION (pfile
, print_deps
) = 2;
1446 CPP_OPTION (pfile
, print_deps
) = 1;
1449 CPP_OPTION (pfile
, deps_file
) = arg
;
1452 CPP_OPTION (pfile
, deps_phony_targets
) = 1;
1456 /* Add a target. -MQ quotes for Make. */
1457 deps_add_target (pfile
->deps
, arg
, opt_code
== OPT_MQ
);
1463 /* -A with an argument beginning with '-' acts as
1464 #unassert on whatever immediately follows the '-'.
1465 If "-" is the whole argument, we eliminate all
1466 predefined macros and assertions, including those
1467 that were specified earlier on the command line.
1468 That way we can get rid of any that were passed
1469 automatically in from GCC. */
1473 struct pending_option
*o1
, *o2
;
1475 o1
= pend
->directive_head
;
1482 pend
->directive_head
= NULL
;
1483 pend
->directive_tail
= NULL
;
1486 new_pending_directive (pend
, arg
+ 1, cpp_unassert
);
1489 new_pending_directive (pend
, arg
, cpp_assert
);
1492 new_pending_directive (pend
, arg
, cpp_undef
);
1494 case OPT_I
: /* Add directory to path for includes. */
1495 if (!strcmp (arg
, "-"))
1498 Use the preceding -I directories for #include "..."
1499 but not #include <...>.
1500 Don't search the directory of the present file
1501 for #include "...". (Note that -I. -I- is not the same as
1502 the default setup; -I. uses the compiler's working dir.) */
1503 if (! CPP_OPTION (pfile
, ignore_srcdir
))
1505 pend
->quote_head
= pend
->brack_head
;
1506 pend
->quote_tail
= pend
->brack_tail
;
1507 pend
->brack_head
= 0;
1508 pend
->brack_tail
= 0;
1509 CPP_OPTION (pfile
, ignore_srcdir
) = 1;
1513 cpp_fatal (pfile
, "-I- specified twice");
1518 append_include_chain (pfile
, xstrdup (arg
), BRACKET
, 0);
1521 /* Add directory to beginning of system include path, as a system
1522 include directory. */
1523 append_include_chain (pfile
, xstrdup (arg
), SYSTEM
, 0);
1527 struct pending_option
*o
= (struct pending_option
*)
1528 xmalloc (sizeof (struct pending_option
));
1531 /* This list has to be built in reverse order so that
1532 when cpp_start_read pushes all the -include files onto
1533 the buffer stack, they will be scanned in forward order. */
1534 o
->next
= pend
->include_head
;
1535 pend
->include_head
= o
;
1540 struct pending_option
*o
= (struct pending_option
*)
1541 xmalloc (sizeof (struct pending_option
));
1545 APPEND (pend
, imacros
, o
);
1548 case OPT_iwithprefix
:
1549 /* Add directory to end of path for includes,
1550 with the default prefix at the front of its name. */
1552 case OPT_iwithprefixbefore
:
1553 /* Add directory to main path for includes,
1554 with the default prefix at the front of its name. */
1561 if (CPP_OPTION (pfile
, include_prefix
) != 0)
1563 size_t ipl
= CPP_OPTION (pfile
, include_prefix_len
);
1564 fname
= xmalloc (ipl
+ len
+ 1);
1565 memcpy (fname
, CPP_OPTION (pfile
, include_prefix
), ipl
);
1566 memcpy (fname
+ ipl
, arg
, len
+ 1);
1568 else if (cpp_GCC_INCLUDE_DIR_len
)
1570 fname
= xmalloc (cpp_GCC_INCLUDE_DIR_len
+ len
+ 1);
1571 memcpy (fname
, cpp_GCC_INCLUDE_DIR
, cpp_GCC_INCLUDE_DIR_len
);
1572 memcpy (fname
+ cpp_GCC_INCLUDE_DIR_len
, arg
, len
+ 1);
1575 fname
= xstrdup (arg
);
1577 append_include_chain (pfile
, fname
,
1578 opt_code
== OPT_iwithprefix
? SYSTEM
: BRACKET
, 0);
1582 /* Add directory to end of path for includes. */
1583 append_include_chain (pfile
, xstrdup (arg
), AFTER
, 0);
1586 /* Silently ignore unrecognised options. */
1587 if (!strcmp (argv
[i
], "-Wall"))
1589 CPP_OPTION (pfile
, warn_trigraphs
) = 1;
1590 CPP_OPTION (pfile
, warn_comments
) = 1;
1592 else if (!strcmp (argv
[i
], "-Wtraditional"))
1593 CPP_OPTION (pfile
, warn_traditional
) = 1;
1594 else if (!strcmp (argv
[i
], "-Wtrigraphs"))
1595 CPP_OPTION (pfile
, warn_trigraphs
) = 1;
1596 else if (!strcmp (argv
[i
], "-Wcomment"))
1597 CPP_OPTION (pfile
, warn_comments
) = 1;
1598 else if (!strcmp (argv
[i
], "-Wcomments"))
1599 CPP_OPTION (pfile
, warn_comments
) = 1;
1600 else if (!strcmp (argv
[i
], "-Wundef"))
1601 CPP_OPTION (pfile
, warn_undef
) = 1;
1602 else if (!strcmp (argv
[i
], "-Wimport"))
1603 CPP_OPTION (pfile
, warn_import
) = 1;
1604 else if (!strcmp (argv
[i
], "-Werror"))
1605 CPP_OPTION (pfile
, warnings_are_errors
) = 1;
1606 else if (!strcmp (argv
[i
], "-Wsystem-headers"))
1607 CPP_OPTION (pfile
, warn_system_headers
) = 1;
1608 else if (!strcmp (argv
[i
], "-Wno-traditional"))
1609 CPP_OPTION (pfile
, warn_traditional
) = 0;
1610 else if (!strcmp (argv
[i
], "-Wno-trigraphs"))
1611 CPP_OPTION (pfile
, warn_trigraphs
) = 0;
1612 else if (!strcmp (argv
[i
], "-Wno-comment"))
1613 CPP_OPTION (pfile
, warn_comments
) = 0;
1614 else if (!strcmp (argv
[i
], "-Wno-comments"))
1615 CPP_OPTION (pfile
, warn_comments
) = 0;
1616 else if (!strcmp (argv
[i
], "-Wno-undef"))
1617 CPP_OPTION (pfile
, warn_undef
) = 0;
1618 else if (!strcmp (argv
[i
], "-Wno-import"))
1619 CPP_OPTION (pfile
, warn_import
) = 0;
1620 else if (!strcmp (argv
[i
], "-Wno-error"))
1621 CPP_OPTION (pfile
, warnings_are_errors
) = 0;
1622 else if (!strcmp (argv
[i
], "-Wno-system-headers"))
1623 CPP_OPTION (pfile
, warn_system_headers
) = 0;
1630 /* Handle command-line options in (argc, argv).
1631 Can be called multiple times, to handle multiple sets of options.
1632 Returns if an unrecognized option is seen.
1633 Returns number of strings consumed. */
1635 cpp_handle_options (pfile
, argc
, argv
)
1641 int strings_processed
;
1643 for (i
= 0; i
< argc
; i
+= strings_processed
)
1645 strings_processed
= cpp_handle_option (pfile
, argc
- i
, argv
+ i
);
1646 if (strings_processed
== 0)
1653 /* Extra processing when all options are parsed, after all calls to
1654 cpp_handle_option[s]. Consistency checks etc. */
1656 cpp_post_options (pfile
)
1659 /* -Wtraditional is not useful in C++ mode. */
1660 if (CPP_OPTION (pfile
, cplusplus
))
1661 CPP_OPTION (pfile
, warn_traditional
) = 0;
1663 /* Set this if it hasn't been set already. */
1664 if (CPP_OPTION (pfile
, user_label_prefix
) == NULL
)
1665 CPP_OPTION (pfile
, user_label_prefix
) = USER_LABEL_PREFIX
;
1667 /* We need to do this after option processing and before
1668 cpp_start_read, as cppmain.c relies on the options->no_output to
1669 set its callbacks correctly before calling cpp_start_read. */
1670 init_dependency_output (pfile
);
1672 /* -MG doesn't select the form of output and must be specified with
1673 one of -M or -MM. -MG doesn't make sense unless preprocessed
1674 output (and compilation) is inhibited. */
1675 if (CPP_OPTION (pfile
, print_deps_missing_files
)
1676 && CPP_OPTION (pfile
, print_deps
) == 0)
1677 cpp_fatal (pfile
, "-MG must be specified with one of -M or -MM");
1680 /* Set up dependency-file output. */
1682 init_dependency_output (pfile
)
1685 char *spec
, *s
, *output_file
;
1687 /* Either of two environment variables can specify output of deps.
1688 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1689 where OUTPUT_FILE is the file to write deps info to
1690 and DEPS_TARGET is the target to mention in the deps. */
1692 if (CPP_OPTION (pfile
, print_deps
) == 0)
1694 spec
= getenv ("DEPENDENCIES_OUTPUT");
1696 CPP_OPTION (pfile
, print_deps
) = 1;
1699 spec
= getenv ("SUNPRO_DEPENDENCIES");
1701 CPP_OPTION (pfile
, print_deps
) = 2;
1706 /* Find the space before the DEPS_TARGET, if there is one. */
1707 s
= strchr (spec
, ' ');
1710 /* Let the caller perform MAKE quoting. */
1711 deps_add_target (pfile
->deps
, s
+ 1, 0);
1712 output_file
= (char *) xmalloc (s
- spec
+ 1);
1713 memcpy (output_file
, spec
, s
- spec
);
1714 output_file
[s
- spec
] = 0;
1719 /* Command line overrides environment variables. */
1720 if (CPP_OPTION (pfile
, deps_file
) == 0)
1721 CPP_OPTION (pfile
, deps_file
) = output_file
;
1722 CPP_OPTION (pfile
, print_deps_append
) = 1;
1725 /* If dependencies go to standard output, we need to suppress
1726 output. The user may be requesting other stuff to stdout, with
1727 -dM, -v etc. We let them shoot themselves in the foot. */
1728 if (CPP_OPTION (pfile
, deps_file
) == 0)
1729 CPP_OPTION (pfile
, no_output
) = 1;
1735 fprintf (stderr
, _("Usage: %s [switches] input output\n"), progname
);
1736 /* To keep the lines from getting too long for some compilers, limit
1737 to about 500 characters (6 lines) per chunk. */
1740 -include <file> Include the contents of <file> before other files\n\
1741 -imacros <file> Accept definition of macros in <file>\n\
1742 -iprefix <path> Specify <path> as a prefix for next two options\n\
1743 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1744 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1745 -isystem <dir> Add <dir> to the start of the system include path\n\
1748 -idirafter <dir> Add <dir> to the end of the system include path\n\
1749 -I <dir> Add <dir> to the end of the main include path\n\
1750 -I- Fine-grained include path control; see info docs\n\
1751 -nostdinc Do not search system include directories\n\
1752 (dirs specified with -isystem will still be used)\n\
1753 -nostdinc++ Do not search system include directories for C++\n\
1754 -o <file> Put output into <file>\n\
1757 -pedantic Issue all warnings demanded by strict ISO C\n\
1758 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1759 -trigraphs Support ISO C trigraphs\n\
1760 -lang-c Assume that the input sources are in C\n\
1761 -lang-c89 Assume that the input sources are in C89\n\
1764 -lang-c++ Assume that the input sources are in C++\n\
1765 -lang-objc Assume that the input sources are in ObjectiveC\n\
1766 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1767 -lang-asm Assume that the input sources are in assembler\n\
1770 -std=<std name> Specify the conformance standard; one of:\n\
1771 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1772 iso9899:199409, iso9899:1999\n\
1773 -+ Allow parsing of C++ style features\n\
1774 -w Inhibit warning messages\n\
1775 -Wtrigraphs Warn if trigraphs are encountered\n\
1776 -Wno-trigraphs Do not warn about trigraphs\n\
1777 -Wcomment{s} Warn if one comment starts inside another\n\
1780 -Wno-comment{s} Do not warn about comments\n\
1781 -Wtraditional Warn about features not present in traditional C\n\
1782 -Wno-traditional Do not warn about traditional C\n\
1783 -Wundef Warn if an undefined macro is used by #if\n\
1784 -Wno-undef Do not warn about testing undefined macros\n\
1785 -Wimport Warn about the use of the #import directive\n\
1788 -Wno-import Do not warn about the use of #import\n\
1789 -Werror Treat all warnings as errors\n\
1790 -Wno-error Do not treat warnings as errors\n\
1791 -Wsystem-headers Do not suppress warnings from system headers\n\
1792 -Wno-system-headers Suppress warnings from system headers\n\
1793 -Wall Enable all preprocessor warnings\n\
1796 -M Generate make dependencies\n\
1797 -MM As -M, but ignore system header files\n\
1798 -MF <file> Write dependency output to the given file\n\
1799 -MG Treat missing header file as generated files\n\
1802 -MP Generate phony targets for all headers\n\
1803 -MQ <target> Add a MAKE-quoted target\n\
1804 -MT <target> Add an unquoted target\n\
1805 -g3 Include #define and #undef directives in the output\n\
1808 -D<macro> Define a <macro> with string '1' as its value\n\
1809 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1810 -A<question> (<answer>) Assert the <answer> to <question>\n\
1811 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1812 -U<macro> Undefine <macro> \n\
1813 -v Display the version number\n\
1816 -H Print the name of header files as they are used\n\
1817 -C Do not discard comments\n\
1818 -dM Display a list of macro definitions active at end\n\
1819 -dD Preserve macro definitions in output\n\
1820 -dN As -dD except that only the names are preserved\n\
1821 -dI Include #include directives in the output\n\
1824 -ftabstop=<number> Distance between tab stops for column reporting\n\
1825 -P Do not generate #line directives\n\
1826 -$ Do not allow '$' in identifiers\n\
1827 -remap Remap file names when including files.\n\
1828 --version Display version information\n\
1829 -h or --help Display this information\n\