2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 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. */
29 #include "cppdefault.h"
31 /* Windows does not natively support inodes, and neither does MSDOS.
32 Cygwin's emulation can generate non-unique inodes, so don't use it.
33 VMS has non-numeric inodes. */
35 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
36 # define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
38 # if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
39 # define INO_T_EQ(A, B) 0
41 # define INO_T_EQ(A, B) ((A) == (B))
43 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
46 /* Internal structures and prototypes. */
48 /* A `struct pending_option' remembers one -D, -A, -U, -include, or
50 typedef void (* cl_directive_handler
) PARAMS ((cpp_reader
*, const char *));
53 struct pending_option
*next
;
55 cl_directive_handler handler
;
58 /* The `pending' structure accumulates all the options that are not
59 actually processed until we hit cpp_read_main_file. It consists of
60 several lists, one for each type of option. We keep both head and
61 tail pointers for quick insertion. */
64 struct pending_option
*directive_head
, *directive_tail
;
66 struct search_path
*quote_head
, *quote_tail
;
67 struct search_path
*brack_head
, *brack_tail
;
68 struct search_path
*systm_head
, *systm_tail
;
69 struct search_path
*after_head
, *after_tail
;
71 struct pending_option
*imacros_head
, *imacros_tail
;
72 struct pending_option
*include_head
, *include_tail
;
76 #define APPEND(pend, list, elt) \
77 do { if (!(pend)->list##_head) (pend)->list##_head = (elt); \
78 else (pend)->list##_tail->next = (elt); \
79 (pend)->list##_tail = (elt); \
82 #define APPEND(pend, list, elt) \
83 do { if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
84 else (pend)->list/**/_tail->next = (elt); \
85 (pend)->list/**/_tail = (elt); \
89 static void path_include
PARAMS ((cpp_reader
*,
91 static void init_library
PARAMS ((void));
92 static void init_builtins
PARAMS ((cpp_reader
*));
93 static void mark_named_operators
PARAMS ((cpp_reader
*));
94 static void append_include_chain
PARAMS ((cpp_reader
*,
96 static struct search_path
* remove_dup_dir
PARAMS ((cpp_reader
*,
98 struct search_path
**));
99 static struct search_path
* remove_dup_nonsys_dirs
PARAMS ((cpp_reader
*,
100 struct search_path
**,
101 struct search_path
*));
102 static struct search_path
* remove_dup_dirs
PARAMS ((cpp_reader
*,
103 struct search_path
**));
104 static void merge_include_chains
PARAMS ((cpp_reader
*));
105 static bool push_include
PARAMS ((cpp_reader
*,
106 struct pending_option
*));
107 static void free_chain
PARAMS ((struct pending_option
*));
108 static void init_standard_includes
PARAMS ((cpp_reader
*));
109 static void read_original_filename
PARAMS ((cpp_reader
*));
110 static void new_pending_directive
PARAMS ((struct cpp_pending
*,
112 cl_directive_handler
));
113 static int parse_option
PARAMS ((const char *));
114 static void post_options
PARAMS ((cpp_reader
*));
116 /* Fourth argument to append_include_chain: chain to use.
117 Note it's never asked to append to the quote chain. */
118 enum { BRACKET
= 0, SYSTEM
, AFTER
};
120 /* If we have designated initializers (GCC >2.7) these tables can be
121 initialized, constant data. Otherwise, they have to be filled in at
123 #if HAVE_DESIGNATED_INITIALIZERS
125 #define init_trigraph_map() /* Nothing. */
126 #define TRIGRAPH_MAP \
127 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
130 #define s(p, v) [p] = v,
134 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
135 static void init_trigraph_map PARAMS ((void)) { \
136 unsigned char *x = _cpp_trigraph_map;
139 #define s(p, v) x[p] = v;
144 s('=', '#') s(')', ']') s('!', '|')
145 s('(', '[') s('\'', '^') s('>', '}')
146 s('/', '\\') s('<', '{') s('-', '~')
153 /* Given a colon-separated list of file names PATH,
154 add all the names to the search path for include files. */
156 path_include (pfile
, list
, path
)
167 /* Find the end of this name. */
169 while (*q
!= 0 && *q
!= PATH_SEPARATOR
) q
++;
172 /* An empty name in the path stands for the current directory. */
173 name
= (char *) xmalloc (2);
179 /* Otherwise use the directory that is named. */
180 name
= (char *) xmalloc (q
- p
+ 1);
181 memcpy (name
, p
, q
- p
);
185 append_include_chain (pfile
, name
, path
, path
== SYSTEM
);
187 /* Advance past this name. */
195 /* Append DIR to include path PATH. DIR must be allocated on the
196 heap; this routine takes responsibility for freeing it. CXX_AWARE
197 is nonzero if the header contains extern "C" guards for C++,
198 otherwise it is zero. */
200 append_include_chain (pfile
, dir
, path
, cxx_aware
)
206 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
207 struct search_path
*new;
216 _cpp_simplify_pathname (dir
);
220 /* Dirs that don't exist are silently ignored. */
222 cpp_errno (pfile
, DL_ERROR
, dir
);
223 else if (CPP_OPTION (pfile
, verbose
))
224 fprintf (stderr
, _("ignoring nonexistent directory \"%s\"\n"), dir
);
229 if (!S_ISDIR (st
.st_mode
))
231 cpp_error_with_line (pfile
, DL_ERROR
, 0, 0, "%s: Not a directory", dir
);
237 if (len
> pfile
->max_include_len
)
238 pfile
->max_include_len
= len
;
240 new = (struct search_path
*) xmalloc (sizeof (struct search_path
));
243 INO_T_COPY (new->ino
, st
.st_ino
);
244 new->dev
= st
.st_dev
;
245 /* Both systm and after include file lists should be treated as system
246 include files since these two lists are really just a concatenation
247 of one "system" list. */
248 if (path
== SYSTEM
|| path
== AFTER
)
249 new->sysp
= cxx_aware
? 1 : 2;
252 new->name_map
= NULL
;
257 case BRACKET
: APPEND (pend
, brack
, new); break;
258 case SYSTEM
: APPEND (pend
, systm
, new); break;
259 case AFTER
: APPEND (pend
, after
, new); break;
263 /* Handle a duplicated include path. PREV is the link in the chain
264 before the duplicate, or NULL if the duplicate is at the head of
265 the chain. The duplicate is removed from the chain and freed.
267 static struct search_path
*
268 remove_dup_dir (pfile
, prev
, head_ptr
)
270 struct search_path
*prev
;
271 struct search_path
**head_ptr
;
273 struct search_path
*cur
;
278 prev
->next
= cur
->next
;
283 *head_ptr
= cur
->next
;
286 if (CPP_OPTION (pfile
, verbose
))
287 fprintf (stderr
, _("ignoring duplicate directory \"%s\"\n"), cur
->name
);
289 free ((PTR
) cur
->name
);
295 /* Remove duplicate non-system directories for which there is an equivalent
296 system directory latter in the chain. The range for removal is between
297 *HEAD_PTR and END. Returns the directory before END, or NULL if none.
298 This algorithm is quadratic in the number system directories, which is
299 acceptable since there aren't usually that many of them. */
300 static struct search_path
*
301 remove_dup_nonsys_dirs (pfile
, head_ptr
, end
)
303 struct search_path
**head_ptr
;
304 struct search_path
*end
;
307 struct search_path
*prev
= NULL
, *cur
, *other
;
309 for (cur
= *head_ptr
; cur
; cur
= cur
->next
)
314 for (other
= *head_ptr
, prev
= NULL
;
316 other
= other
? other
->next
: *head_ptr
)
319 && INO_T_EQ (cur
->ino
, other
->ino
)
320 && cur
->dev
== other
->dev
)
322 other
= remove_dup_dir (pfile
, prev
, head_ptr
);
323 if (CPP_OPTION (pfile
, verbose
))
325 _(" as it is a non-system directory that duplicates a system directory\n"));
333 for (cur
= *head_ptr
; cur
!= end
; cur
= cur
->next
)
339 /* Remove duplicate directories from a chain. Returns the tail of the
340 chain, or NULL if the chain is empty. This algorithm is quadratic
341 in the number of -I switches, which is acceptable since there
342 aren't usually that many of them. */
343 static struct search_path
*
344 remove_dup_dirs (pfile
, head_ptr
)
346 struct search_path
**head_ptr
;
348 struct search_path
*prev
= NULL
, *cur
, *other
;
350 for (cur
= *head_ptr
; cur
; cur
= cur
->next
)
352 for (other
= *head_ptr
; other
!= cur
; other
= other
->next
)
353 if (INO_T_EQ (cur
->ino
, other
->ino
) && cur
->dev
== other
->dev
)
355 cur
= remove_dup_dir (pfile
, prev
, head_ptr
);
364 /* Merge the four include chains together in the order quote, bracket,
365 system, after. Remove duplicate dirs (as determined by
366 INO_T_EQ()). The system_include and after_include chains are never
367 referred to again after this function; all access is through the
368 bracket_include path. */
370 merge_include_chains (pfile
)
373 struct search_path
*quote
, *brack
, *systm
, *qtail
;
375 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
377 quote
= pend
->quote_head
;
378 brack
= pend
->brack_head
;
379 systm
= pend
->systm_head
;
380 qtail
= pend
->quote_tail
;
382 /* Paste together bracket, system, and after include chains. */
384 pend
->systm_tail
->next
= pend
->after_head
;
386 systm
= pend
->after_head
;
389 pend
->brack_tail
->next
= systm
;
393 /* This is a bit tricky. First we drop non-system dupes of system
394 directories from the merged bracket-include list. Next we drop
395 dupes from the bracket and quote include lists. Then we drop
396 non-system dupes from the merged quote-include list. Finally,
397 if qtail and brack are the same directory, we cut out brack and
398 move brack up to point to qtail.
400 We can't just merge the lists and then uniquify them because
401 then we may lose directories from the <> search path that should
402 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
403 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
404 -Ibar -I- -Ifoo -Iquux. */
406 remove_dup_nonsys_dirs (pfile
, &brack
, systm
);
407 remove_dup_dirs (pfile
, &brack
);
411 qtail
= remove_dup_dirs (pfile
, "e
);
414 qtail
= remove_dup_nonsys_dirs (pfile
, "e
, brack
);
416 /* If brack == qtail, remove brack as it's simpler. */
417 if (qtail
&& brack
&& INO_T_EQ (qtail
->ino
, brack
->ino
)
418 && qtail
->dev
== brack
->dev
)
419 brack
= remove_dup_dir (pfile
, qtail
, "e
);
424 CPP_OPTION (pfile
, quote_include
) = quote
;
425 CPP_OPTION (pfile
, bracket_include
) = brack
;
428 /* A set of booleans indicating what CPP features each source language
434 char extended_numbers
;
436 char dollars_in_ident
;
437 char cplusplus_comments
;
441 /* ??? Enable $ in identifiers in assembly? */
442 static const struct lang_flags lang_defaults
[] =
443 { /* c99 c++ xnum std dollar c++comm digr */
444 /* GNUC89 */ { 0, 0, 1, 0, 1, 1, 1 },
445 /* GNUC99 */ { 1, 0, 1, 0, 1, 1, 1 },
446 /* STDC89 */ { 0, 0, 0, 1, 0, 0, 0 },
447 /* STDC94 */ { 0, 0, 0, 1, 0, 0, 1 },
448 /* STDC99 */ { 1, 0, 1, 1, 0, 1, 1 },
449 /* GNUCXX */ { 0, 1, 1, 0, 1, 1, 1 },
450 /* CXX98 */ { 0, 1, 1, 1, 0, 1, 1 },
451 /* ASM */ { 0, 0, 1, 0, 0, 1, 0 }
454 /* Sets internal flags correctly for a given language. */
456 cpp_set_lang (pfile
, lang
)
460 const struct lang_flags
*l
= &lang_defaults
[(int) lang
];
462 CPP_OPTION (pfile
, lang
) = lang
;
464 CPP_OPTION (pfile
, c99
) = l
->c99
;
465 CPP_OPTION (pfile
, cplusplus
) = l
->cplusplus
;
466 CPP_OPTION (pfile
, extended_numbers
) = l
->extended_numbers
;
467 CPP_OPTION (pfile
, std
) = l
->std
;
468 CPP_OPTION (pfile
, trigraphs
) = l
->std
;
469 CPP_OPTION (pfile
, dollars_in_ident
) = l
->dollars_in_ident
;
470 CPP_OPTION (pfile
, cplusplus_comments
) = l
->cplusplus_comments
;
471 CPP_OPTION (pfile
, digraphs
) = l
->digraphs
;
475 static int opt_comp
PARAMS ((const void *, const void *));
477 /* Run-time sorting of options array. */
482 return strcmp (((struct cl_option
*) p1
)->opt_text
,
483 ((struct cl_option
*) p2
)->opt_text
);
487 /* init initializes library global state. It might not need to
488 do anything depending on the platform and compiler. */
492 static int initialized
= 0;
499 /* For non-ASCII hosts, the cl_options array needs to be sorted at
501 qsort (cl_options
, N_OPTS
, sizeof (struct cl_option
), opt_comp
);
504 /* Set up the trigraph map. This doesn't need to do anything if
505 we were compiled with a compiler that supports C99 designated
507 init_trigraph_map ();
511 /* Initialize a cpp_reader structure. */
513 cpp_create_reader (lang
)
518 /* Initialize this instance of the library if it hasn't been already. */
521 pfile
= (cpp_reader
*) xcalloc (1, sizeof (cpp_reader
));
523 cpp_set_lang (pfile
, lang
);
524 CPP_OPTION (pfile
, warn_import
) = 1;
525 CPP_OPTION (pfile
, warn_multichar
) = 1;
526 CPP_OPTION (pfile
, discard_comments
) = 1;
527 CPP_OPTION (pfile
, discard_comments_in_macro_exp
) = 1;
528 CPP_OPTION (pfile
, show_column
) = 1;
529 CPP_OPTION (pfile
, tabstop
) = 8;
530 CPP_OPTION (pfile
, operator_names
) = 1;
531 CPP_OPTION (pfile
, warn_endif_labels
) = 1;
532 CPP_OPTION (pfile
, warn_long_long
) = !CPP_OPTION (pfile
, c99
);
533 CPP_OPTION (pfile
, sysroot
) = cpp_SYSROOT
;
535 CPP_OPTION (pfile
, pending
) =
536 (struct cpp_pending
*) xcalloc (1, sizeof (struct cpp_pending
));
538 /* Default CPP arithmetic to something sensible for the host for the
539 benefit of dumb users like fix-header. */
540 CPP_OPTION (pfile
, precision
) = CHAR_BIT
* sizeof (long);
541 CPP_OPTION (pfile
, char_precision
) = CHAR_BIT
;
542 CPP_OPTION (pfile
, wchar_precision
) = CHAR_BIT
* sizeof (int);
543 CPP_OPTION (pfile
, int_precision
) = CHAR_BIT
* sizeof (int);
544 CPP_OPTION (pfile
, unsigned_char
) = 0;
545 CPP_OPTION (pfile
, unsigned_wchar
) = 1;
547 /* Initialize the line map. Start at logical line 1, so we can use
548 a line number of zero for special states. */
549 init_line_maps (&pfile
->line_maps
);
552 /* Initialize lexer state. */
553 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
555 /* Set up static tokens. */
556 pfile
->avoid_paste
.type
= CPP_PADDING
;
557 pfile
->avoid_paste
.val
.source
= NULL
;
558 pfile
->eof
.type
= CPP_EOF
;
559 pfile
->eof
.flags
= 0;
561 /* Create a token buffer for the lexer. */
562 _cpp_init_tokenrun (&pfile
->base_run
, 250);
563 pfile
->cur_run
= &pfile
->base_run
;
564 pfile
->cur_token
= pfile
->base_run
.base
;
566 /* Initialize the base context. */
567 pfile
->context
= &pfile
->base_context
;
568 pfile
->base_context
.macro
= 0;
569 pfile
->base_context
.prev
= pfile
->base_context
.next
= 0;
571 /* Aligned and unaligned storage. */
572 pfile
->a_buff
= _cpp_get_buff (pfile
, 0);
573 pfile
->u_buff
= _cpp_get_buff (pfile
, 0);
575 /* The expression parser stack. */
576 _cpp_expand_op_stack (pfile
);
578 /* Initialize the buffer obstack. */
579 gcc_obstack_init (&pfile
->buffer_ob
);
581 _cpp_init_includes (pfile
);
586 /* Free resources used by PFILE. Accessing PFILE after this function
587 returns leads to undefined behavior. Returns the error count. */
592 struct search_path
*dir
, *dirn
;
593 cpp_context
*context
, *contextn
;
594 tokenrun
*run
, *runn
;
596 free_chain (CPP_OPTION (pfile
, pending
)->include_head
);
597 free (CPP_OPTION (pfile
, pending
));
598 free (pfile
->op_stack
);
600 while (CPP_BUFFER (pfile
) != NULL
)
601 _cpp_pop_buffer (pfile
);
604 free (pfile
->out
.base
);
606 if (pfile
->macro_buffer
)
608 free ((PTR
) pfile
->macro_buffer
);
609 pfile
->macro_buffer
= NULL
;
610 pfile
->macro_buffer_len
= 0;
614 deps_free (pfile
->deps
);
615 obstack_free (&pfile
->buffer_ob
, 0);
617 _cpp_destroy_hashtable (pfile
);
618 _cpp_cleanup_includes (pfile
);
620 _cpp_free_buff (pfile
->a_buff
);
621 _cpp_free_buff (pfile
->u_buff
);
622 _cpp_free_buff (pfile
->free_buffs
);
624 for (run
= &pfile
->base_run
; run
; run
= runn
)
628 if (run
!= &pfile
->base_run
)
632 for (dir
= CPP_OPTION (pfile
, quote_include
); dir
; dir
= dirn
)
635 free ((PTR
) dir
->name
);
639 for (context
= pfile
->base_context
.next
; context
; context
= contextn
)
641 contextn
= context
->next
;
645 free_line_maps (&pfile
->line_maps
);
649 /* This structure defines one built-in identifier. A node will be
650 entered in the hash table under the name NAME, with value VALUE.
652 There are two tables of these. builtin_array holds all the
653 "builtin" macros: these are handled by builtin_macro() in
654 cppmacro.c. Builtin is somewhat of a misnomer -- the property of
655 interest is that these macros require special code to compute their
656 expansions. The value is a "builtin_type" enumerator.
658 operator_array holds the C++ named operators. These are keywords
659 which act as aliases for punctuators. In C++, they cannot be
660 altered through #define, and #if recognizes them as operators. In
661 C, these are not entered into the hash table at all (but see
662 <iso646.h>). The value is a token-type enumerator. */
667 unsigned short value
;
670 #define B(n, t) { DSC(n), t }
671 static const struct builtin builtin_array
[] =
673 B("__TIME__", BT_TIME
),
674 B("__DATE__", BT_DATE
),
675 B("__FILE__", BT_FILE
),
676 B("__BASE_FILE__", BT_BASE_FILE
),
677 B("__LINE__", BT_SPECLINE
),
678 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL
),
679 /* Keep builtins not used for -traditional-cpp at the end, and
680 update init_builtins() if any more are added. */
681 B("_Pragma", BT_PRAGMA
),
682 B("__STDC__", BT_STDC
),
685 static const struct builtin operator_array
[] =
687 B("and", CPP_AND_AND
),
688 B("and_eq", CPP_AND_EQ
),
689 B("bitand", CPP_AND
),
691 B("compl", CPP_COMPL
),
693 B("not_eq", CPP_NOT_EQ
),
695 B("or_eq", CPP_OR_EQ
),
697 B("xor_eq", CPP_XOR_EQ
)
701 /* Mark the C++ named operators in the hash table. */
703 mark_named_operators (pfile
)
706 const struct builtin
*b
;
708 for (b
= operator_array
;
709 b
< (operator_array
+ ARRAY_SIZE (operator_array
));
712 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
713 hp
->flags
|= NODE_OPERATOR
;
714 hp
->value
.operator = b
->value
;
718 /* Subroutine of cpp_read_main_file; reads the builtins table above and
719 enters them, and language-specific macros, into the hash table. */
721 init_builtins (pfile
)
724 const struct builtin
*b
;
725 size_t n
= ARRAY_SIZE (builtin_array
);
727 if (CPP_OPTION (pfile
, traditional
))
730 for(b
= builtin_array
; b
< builtin_array
+ n
; b
++)
732 cpp_hashnode
*hp
= cpp_lookup (pfile
, b
->name
, b
->len
);
734 hp
->flags
|= NODE_BUILTIN
| NODE_WARN
;
735 hp
->value
.builtin
= b
->value
;
738 if (CPP_OPTION (pfile
, cplusplus
))
739 _cpp_define_builtin (pfile
, "__cplusplus 1");
740 else if (CPP_OPTION (pfile
, lang
) == CLK_ASM
)
741 _cpp_define_builtin (pfile
, "__ASSEMBLER__ 1");
742 else if (CPP_OPTION (pfile
, lang
) == CLK_STDC94
)
743 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199409L");
744 else if (CPP_OPTION (pfile
, c99
))
745 _cpp_define_builtin (pfile
, "__STDC_VERSION__ 199901L");
747 if (CPP_OPTION (pfile
, objc
))
748 _cpp_define_builtin (pfile
, "__OBJC__ 1");
750 if (pfile
->cb
.register_builtins
)
751 (*pfile
->cb
.register_builtins
) (pfile
);
754 /* And another subroutine. This one sets up the standard include path. */
756 init_standard_includes (pfile
)
760 const struct default_include
*p
;
761 const char *specd_prefix
= CPP_OPTION (pfile
, include_prefix
);
762 int default_len
, specd_len
;
763 char *default_prefix
;
765 /* Several environment variables may add to the include search path.
766 CPATH specifies an additional list of directories to be searched
767 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
768 etc. specify an additional list of directories to be searched as
769 if specified with -isystem, for the language indicated. */
771 GET_ENVIRONMENT (path
, "CPATH");
772 if (path
!= 0 && *path
!= 0)
773 path_include (pfile
, path
, BRACKET
);
775 switch ((CPP_OPTION (pfile
, objc
) << 1) + CPP_OPTION (pfile
, cplusplus
))
778 GET_ENVIRONMENT (path
, "C_INCLUDE_PATH");
781 GET_ENVIRONMENT (path
, "CPLUS_INCLUDE_PATH");
784 GET_ENVIRONMENT (path
, "OBJC_INCLUDE_PATH");
787 GET_ENVIRONMENT (path
, "OBJCPLUS_INCLUDE_PATH");
790 if (path
!= 0 && *path
!= 0)
791 path_include (pfile
, path
, SYSTEM
);
793 /* Search "translated" versions of GNU directories.
794 These have /usr/local/lib/gcc... replaced by specd_prefix. */
797 default_prefix
= NULL
;
798 if (specd_prefix
!= 0 && cpp_GCC_INCLUDE_DIR_len
)
800 /* Remove the `include' from /usr/local/lib/gcc.../include.
801 GCC_INCLUDE_DIR will always end in /include. */
802 default_len
= cpp_GCC_INCLUDE_DIR_len
;
803 default_prefix
= (char *) alloca (default_len
+ 1);
804 specd_len
= strlen (specd_prefix
);
806 memcpy (default_prefix
, cpp_GCC_INCLUDE_DIR
, default_len
);
807 default_prefix
[default_len
] = '\0';
809 for (p
= cpp_include_defaults
; p
->fname
; p
++)
811 /* Some standard dirs are only for C++. */
813 || (CPP_OPTION (pfile
, cplusplus
)
814 && !CPP_OPTION (pfile
, no_standard_cplusplus_includes
)))
818 /* Should we be translating sysrooted dirs too? Assume
819 that iprefix and sysroot are mutually exclusive, for
821 if (p
->add_sysroot
&& CPP_OPTION (pfile
, sysroot
))
824 /* Does this dir start with the prefix? */
825 if (!strncmp (p
->fname
, default_prefix
, default_len
))
827 /* Yes; change prefix and add to search list. */
828 int flen
= strlen (p
->fname
);
829 int this_len
= specd_len
+ flen
- default_len
;
831 str
= (char *) xmalloc (this_len
+ 1);
832 memcpy (str
, specd_prefix
, specd_len
);
833 memcpy (str
+ specd_len
,
834 p
->fname
+ default_len
,
835 flen
- default_len
+ 1);
837 append_include_chain (pfile
, str
, SYSTEM
, p
->cxx_aware
);
843 for (p
= cpp_include_defaults
; p
->fname
; p
++)
845 /* Some standard dirs are only for C++. */
847 || (CPP_OPTION (pfile
, cplusplus
)
848 && !CPP_OPTION (pfile
, no_standard_cplusplus_includes
)))
852 /* Should this dir start with the sysroot? */
853 if (p
->add_sysroot
&& CPP_OPTION (pfile
, sysroot
))
854 str
= concat (CPP_OPTION (pfile
, sysroot
), p
->fname
, NULL
);
857 str
= update_path (p
->fname
, p
->component
);
859 append_include_chain (pfile
, str
, SYSTEM
, p
->cxx_aware
);
864 /* Pushes a command line -imacro and -include file indicated by P onto
865 the buffer stack. Returns nonzero if successful. */
867 push_include (pfile
, p
)
869 struct pending_option
*p
;
873 /* Later: maybe update this to use the #include "" search path
874 if cpp_read_file fails. */
875 header
.type
= CPP_STRING
;
876 header
.val
.str
.text
= (const unsigned char *) p
->arg
;
877 header
.val
.str
.len
= strlen (p
->arg
);
878 /* Make the command line directive take up a line. */
881 return _cpp_execute_include (pfile
, &header
, IT_CMDLINE
);
884 /* Frees a pending_option chain. */
887 struct pending_option
*head
;
889 struct pending_option
*next
;
899 /* Sanity-checks are dependent on command-line options, so it is
900 called as a subroutine of cpp_read_main_file (). */
902 static void sanity_checks
PARAMS ((cpp_reader
*));
903 static void sanity_checks (pfile
)
907 size_t max_precision
= 2 * CHAR_BIT
* sizeof (cpp_num_part
);
909 /* Sanity checks for assumptions about CPP arithmetic and target
910 type precisions made by cpplib. */
913 cpp_error (pfile
, DL_ICE
, "cppchar_t must be an unsigned type");
915 if (CPP_OPTION (pfile
, precision
) > max_precision
)
916 cpp_error (pfile
, DL_ICE
,
917 "preprocessor arithmetic has maximum precision of %lu bits; target requires %lu bits",
918 (unsigned long) max_precision
,
919 (unsigned long) CPP_OPTION (pfile
, precision
));
921 if (CPP_OPTION (pfile
, precision
) < CPP_OPTION (pfile
, int_precision
))
922 cpp_error (pfile
, DL_ICE
,
923 "CPP arithmetic must be at least as precise as a target int");
925 if (CPP_OPTION (pfile
, char_precision
) < 8)
926 cpp_error (pfile
, DL_ICE
, "target char is less than 8 bits wide");
928 if (CPP_OPTION (pfile
, wchar_precision
) < CPP_OPTION (pfile
, char_precision
))
929 cpp_error (pfile
, DL_ICE
,
930 "target wchar_t is narrower than target char");
932 if (CPP_OPTION (pfile
, int_precision
) < CPP_OPTION (pfile
, char_precision
))
933 cpp_error (pfile
, DL_ICE
,
934 "target int is narrower than target char");
936 /* This is assumed in eval_token() and could be fixed if necessary. */
937 if (sizeof (cppchar_t
) > sizeof (cpp_num_part
))
938 cpp_error (pfile
, DL_ICE
, "CPP half-integer narrower than CPP character");
940 if (CPP_OPTION (pfile
, wchar_precision
) > BITS_PER_CPPCHAR_T
)
941 cpp_error (pfile
, DL_ICE
,
942 "CPP on this host cannot handle wide character constants over %lu bits, but the target requires %lu bits",
943 (unsigned long) BITS_PER_CPPCHAR_T
,
944 (unsigned long) CPP_OPTION (pfile
, wchar_precision
));
947 # define sanity_checks(PFILE)
950 /* Add a dependency target. Can be called any number of times before
951 cpp_read_main_file(). If no targets have been added before
952 cpp_read_main_file(), then the default target is used. */
954 cpp_add_dependency_target (pfile
, target
, quote
)
960 pfile
->deps
= deps_init ();
962 deps_add_target (pfile
->deps
, target
, quote
);
965 /* This is called after options have been parsed, and partially
966 processed. Setup for processing input from the file named FNAME,
967 or stdin if it is the empty string. Return the original filename
968 on success (e.g. foo.i->foo.c), or NULL on failure. */
970 cpp_read_main_file (pfile
, fname
, table
)
975 sanity_checks (pfile
);
977 post_options (pfile
);
979 /* The front ends don't set up the hash table until they have
980 finished processing the command line options, so initializing the
981 hashtable is deferred until now. */
982 _cpp_init_hashtable (pfile
, table
);
984 /* Set up the include search path now. */
985 if (! CPP_OPTION (pfile
, no_standard_includes
))
986 init_standard_includes (pfile
);
988 merge_include_chains (pfile
);
990 /* With -v, print the list of dirs to search. */
991 if (CPP_OPTION (pfile
, verbose
))
993 struct search_path
*l
;
994 fprintf (stderr
, _("#include \"...\" search starts here:\n"));
995 for (l
= CPP_OPTION (pfile
, quote_include
); l
; l
= l
->next
)
997 if (l
== CPP_OPTION (pfile
, bracket_include
))
998 fprintf (stderr
, _("#include <...> search starts here:\n"));
999 fprintf (stderr
, " %s\n", l
->name
);
1001 fprintf (stderr
, _("End of search list.\n"));
1004 if (CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
)
1007 pfile
->deps
= deps_init ();
1009 /* Set the default target (if there is none already). */
1010 deps_add_default_target (pfile
->deps
, fname
);
1013 /* Open the main input file. */
1014 if (!_cpp_read_file (pfile
, fname
))
1017 /* Set this here so the client can change the option if it wishes,
1018 and after stacking the main file so we don't trace the main
1020 pfile
->line_maps
.trace_includes
= CPP_OPTION (pfile
, print_include_names
);
1022 /* For foo.i, read the original filename foo.c now, for the benefit
1023 of the front ends. */
1024 if (CPP_OPTION (pfile
, preprocessed
))
1025 read_original_filename (pfile
);
1027 return pfile
->map
->to_file
;
1030 /* For preprocessed files, if the first tokens are of the form # NUM.
1031 handle the directive so we know the original file name. This will
1032 generate file_change callbacks, which the front ends must handle
1033 appropriately given their state of initialization. */
1035 read_original_filename (pfile
)
1038 const cpp_token
*token
, *token1
;
1040 /* Lex ahead; if the first tokens are of the form # NUM, then
1041 process the directive, otherwise back up. */
1042 token
= _cpp_lex_direct (pfile
);
1043 if (token
->type
== CPP_HASH
)
1045 token1
= _cpp_lex_direct (pfile
);
1046 _cpp_backup_tokens (pfile
, 1);
1048 /* If it's a #line directive, handle it. */
1049 if (token1
->type
== CPP_NUMBER
)
1051 _cpp_handle_directive (pfile
, token
->flags
& PREV_WHITE
);
1056 /* Backup as if nothing happened. */
1057 _cpp_backup_tokens (pfile
, 1);
1060 /* Handle pending command line options: -D, -U, -A, -imacros and
1061 -include. This should be called after debugging has been properly
1062 set up in the front ends. */
1064 cpp_finish_options (pfile
)
1067 /* Mark named operators before handling command line macros. */
1068 if (CPP_OPTION (pfile
, cplusplus
) && CPP_OPTION (pfile
, operator_names
))
1069 mark_named_operators (pfile
);
1071 /* Install builtins and process command line macros etc. in the order
1072 they appeared, but only if not already preprocessed. */
1073 if (! CPP_OPTION (pfile
, preprocessed
))
1075 struct pending_option
*p
;
1077 /* Prevent -Wunused-macros with command-line redefinitions. */
1078 pfile
->first_unused_line
= (unsigned int) -1;
1079 _cpp_do_file_change (pfile
, LC_RENAME
, _("<built-in>"), 1, 0);
1080 init_builtins (pfile
);
1081 _cpp_do_file_change (pfile
, LC_RENAME
, _("<command line>"), 1, 0);
1082 for (p
= CPP_OPTION (pfile
, pending
)->directive_head
; p
; p
= p
->next
)
1083 (*p
->handler
) (pfile
, p
->arg
);
1085 /* Scan -imacros files after -D, -U, but before -include.
1086 pfile->next_include_file is NULL, so _cpp_pop_buffer does not
1087 push -include files. */
1088 for (p
= CPP_OPTION (pfile
, pending
)->imacros_head
; p
; p
= p
->next
)
1089 if (push_include (pfile
, p
))
1090 cpp_scan_nooutput (pfile
);
1092 pfile
->next_include_file
= &CPP_OPTION (pfile
, pending
)->include_head
;
1093 _cpp_maybe_push_include_file (pfile
);
1096 pfile
->first_unused_line
= pfile
->line
;
1098 free_chain (CPP_OPTION (pfile
, pending
)->imacros_head
);
1099 free_chain (CPP_OPTION (pfile
, pending
)->directive_head
);
1102 /* Push the next buffer on the stack given by -include, if any. */
1104 _cpp_maybe_push_include_file (pfile
)
1107 if (pfile
->next_include_file
)
1109 struct pending_option
*head
= *pfile
->next_include_file
;
1111 while (head
&& !push_include (pfile
, head
))
1115 pfile
->next_include_file
= &head
->next
;
1118 /* All done; restore the line map from <command line>. */
1119 _cpp_do_file_change (pfile
, LC_RENAME
,
1120 pfile
->line_maps
.maps
[0].to_file
, 1, 0);
1121 /* Don't come back here again. */
1122 pfile
->next_include_file
= NULL
;
1127 /* This is called at the end of preprocessing. It pops the last
1128 buffer and writes dependency output, and returns the number of
1131 Maybe it should also reset state, such that you could call
1132 cpp_start_read with a new filename to restart processing. */
1134 cpp_finish (pfile
, deps_stream
)
1138 /* Warn about unused macros before popping the final buffer. */
1139 if (CPP_OPTION (pfile
, warn_unused_macros
))
1140 cpp_forall_identifiers (pfile
, _cpp_warn_if_unused_macro
, NULL
);
1142 /* cpplex.c leaves the final buffer on the stack. This it so that
1143 it returns an unending stream of CPP_EOFs to the client. If we
1144 popped the buffer, we'd dereference a NULL buffer pointer and
1145 segfault. It's nice to allow the client to do worry-free excess
1146 cpp_get_token calls. */
1147 while (pfile
->buffer
)
1148 _cpp_pop_buffer (pfile
);
1150 /* Don't write the deps file if there are errors. */
1151 if (CPP_OPTION (pfile
, deps
.style
) != DEPS_NONE
1152 && deps_stream
&& pfile
->errors
== 0)
1154 deps_write (pfile
->deps
, deps_stream
, 72);
1156 if (CPP_OPTION (pfile
, deps
.phony_targets
))
1157 deps_phony_targets (pfile
->deps
, deps_stream
);
1160 /* Report on headers that could use multiple include guards. */
1161 if (CPP_OPTION (pfile
, print_include_names
))
1162 _cpp_report_missing_guards (pfile
);
1164 return pfile
->errors
;
1167 /* Add a directive to be handled later in the initialization phase. */
1169 new_pending_directive (pend
, text
, handler
)
1170 struct cpp_pending
*pend
;
1172 cl_directive_handler handler
;
1174 struct pending_option
*o
= (struct pending_option
*)
1175 xmalloc (sizeof (struct pending_option
));
1179 o
->handler
= handler
;
1180 APPEND (pend
, directive
, o
);
1183 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1184 I.e. a const string initializer with parens around it. That is
1185 what N_("string") resolves to, so we make no_* be macros instead. */
1186 #define no_ass N_("assertion missing after %s")
1187 #define no_dir N_("directory name missing after %s")
1188 #define no_fil N_("file name missing after %s")
1189 #define no_mac N_("macro name missing after %s")
1190 #define no_pth N_("path name missing after %s")
1192 /* This is the list of all command line options, with the leading
1193 "-" removed. It must be sorted in ASCII collating order. */
1194 #define COMMAND_LINE_OPTIONS \
1195 DEF_OPT("A", no_ass, OPT_A) \
1196 DEF_OPT("D", no_mac, OPT_D) \
1197 DEF_OPT("I", no_dir, OPT_I) \
1198 DEF_OPT("U", no_mac, OPT_U) \
1199 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1200 DEF_OPT("imacros", no_fil, OPT_imacros) \
1201 DEF_OPT("include", no_fil, OPT_include) \
1202 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1203 DEF_OPT("isysroot", no_dir, OPT_isysroot) \
1204 DEF_OPT("isystem", no_dir, OPT_isystem) \
1205 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1206 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore)
1208 #define DEF_OPT(text, msg, code) code,
1211 COMMAND_LINE_OPTIONS
1218 const char *opt_text
;
1221 enum opt_code opt_code
;
1224 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1226 static struct cl_option cl_options
[] =
1228 static const struct cl_option cl_options
[] =
1231 COMMAND_LINE_OPTIONS
1234 #undef COMMAND_LINE_OPTIONS
1236 /* Perform a binary search to find which, if any, option the given
1237 command-line matches. Returns its index in the option array,
1238 negative on failure. Complications arise since some options can be
1239 suffixed with an argument, and multiple complete matches can occur,
1240 e.g. -pedantic and -pedantic-errors. */
1242 parse_option (input
)
1245 unsigned int md
, mn
, mx
;
1256 opt_len
= cl_options
[md
].opt_len
;
1257 comp
= strncmp (input
, cl_options
[md
].opt_text
, opt_len
);
1265 if (input
[opt_len
] == '\0')
1267 /* We were passed more text. If the option takes an argument,
1268 we may match a later option or we may have been passed the
1269 argument. The longest possible option match succeeds.
1270 If the option takes no arguments we have not matched and
1271 continue the search (e.g. input="stdc++" match was "stdc"). */
1273 if (cl_options
[md
].msg
)
1275 /* Scan forwards. If we get an exact match, return it.
1276 Otherwise, return the longest option-accepting match.
1277 This loops no more than twice with current options. */
1279 for (; mn
< (unsigned int) N_OPTS
; mn
++)
1281 opt_len
= cl_options
[mn
].opt_len
;
1282 if (strncmp (input
, cl_options
[mn
].opt_text
, opt_len
))
1284 if (input
[opt_len
] == '\0')
1286 if (cl_options
[mn
].msg
)
1297 /* Handle one command-line option in (argc, argv).
1298 Can be called multiple times, to handle multiple sets of options.
1299 Returns number of strings consumed. */
1301 cpp_handle_option (pfile
, argc
, argv
)
1307 struct cpp_pending
*pend
= CPP_OPTION (pfile
, pending
);
1310 enum opt_code opt_code
;
1312 const char *arg
= 0;
1314 /* Skip over '-'. */
1315 opt_index
= parse_option (&argv
[i
][1]);
1319 opt_code
= cl_options
[opt_index
].opt_code
;
1320 if (cl_options
[opt_index
].msg
)
1322 arg
= &argv
[i
][cl_options
[opt_index
].opt_len
+ 1];
1328 cpp_error (pfile
, DL_ERROR
,
1329 cl_options
[opt_index
].msg
, argv
[i
- 1]);
1337 case N_OPTS
: /* Shut GCC up. */
1341 new_pending_directive (pend
, arg
, cpp_define
);
1344 CPP_OPTION (pfile
, include_prefix
) = arg
;
1345 CPP_OPTION (pfile
, include_prefix_len
) = strlen (arg
);
1349 CPP_OPTION (pfile
, sysroot
) = arg
;
1354 new_pending_directive (pend
, arg
+ 1, cpp_unassert
);
1356 new_pending_directive (pend
, arg
, cpp_assert
);
1359 new_pending_directive (pend
, arg
, cpp_undef
);
1361 case OPT_I
: /* Add directory to path for includes. */
1362 if (!strcmp (arg
, "-"))
1365 Use the preceding -I directories for #include "..."
1366 but not #include <...>.
1367 Don't search the directory of the present file
1368 for #include "...". (Note that -I. -I- is not the same as
1369 the default setup; -I. uses the compiler's working dir.) */
1370 if (! CPP_OPTION (pfile
, ignore_srcdir
))
1372 pend
->quote_head
= pend
->brack_head
;
1373 pend
->quote_tail
= pend
->brack_tail
;
1374 pend
->brack_head
= 0;
1375 pend
->brack_tail
= 0;
1376 CPP_OPTION (pfile
, ignore_srcdir
) = 1;
1380 cpp_error (pfile
, DL_ERROR
, "-I- specified twice");
1385 append_include_chain (pfile
, xstrdup (arg
), BRACKET
, 0);
1388 /* Add directory to beginning of system include path, as a system
1389 include directory. */
1390 append_include_chain (pfile
, xstrdup (arg
), SYSTEM
, 0);
1395 struct pending_option
*o
= (struct pending_option
*)
1396 xmalloc (sizeof (struct pending_option
));
1400 if (opt_code
== OPT_include
)
1401 APPEND (pend
, include
, o
);
1403 APPEND (pend
, imacros
, o
);
1406 case OPT_iwithprefix
:
1407 /* Add directory to end of path for includes,
1408 with the default prefix at the front of its name. */
1410 case OPT_iwithprefixbefore
:
1411 /* Add directory to main path for includes,
1412 with the default prefix at the front of its name. */
1419 if (CPP_OPTION (pfile
, include_prefix
) != 0)
1421 size_t ipl
= CPP_OPTION (pfile
, include_prefix_len
);
1422 fname
= xmalloc (ipl
+ len
+ 1);
1423 memcpy (fname
, CPP_OPTION (pfile
, include_prefix
), ipl
);
1424 memcpy (fname
+ ipl
, arg
, len
+ 1);
1426 else if (cpp_GCC_INCLUDE_DIR_len
)
1428 fname
= xmalloc (cpp_GCC_INCLUDE_DIR_len
+ len
+ 1);
1429 memcpy (fname
, cpp_GCC_INCLUDE_DIR
, cpp_GCC_INCLUDE_DIR_len
);
1430 memcpy (fname
+ cpp_GCC_INCLUDE_DIR_len
, arg
, len
+ 1);
1433 fname
= xstrdup (arg
);
1435 append_include_chain (pfile
, fname
,
1436 opt_code
== OPT_iwithprefix
? SYSTEM
: BRACKET
, 0);
1440 /* Add directory to end of path for includes. */
1441 append_include_chain (pfile
, xstrdup (arg
), AFTER
, 0);
1448 /* Handle command-line options in (argc, argv).
1449 Can be called multiple times, to handle multiple sets of options.
1450 Returns if an unrecognized option is seen.
1451 Returns number of strings consumed. */
1453 cpp_handle_options (pfile
, argc
, argv
)
1459 int strings_processed
;
1461 for (i
= 0; i
< argc
; i
+= strings_processed
)
1463 strings_processed
= cpp_handle_option (pfile
, argc
- i
, argv
+ i
);
1464 if (strings_processed
== 0)
1472 post_options (pfile
)
1475 /* -Wtraditional is not useful in C++ mode. */
1476 if (CPP_OPTION (pfile
, cplusplus
))
1477 CPP_OPTION (pfile
, warn_traditional
) = 0;
1479 /* Permanently disable macro expansion if we are rescanning
1480 preprocessed text. Read preprocesed source in ISO mode. */
1481 if (CPP_OPTION (pfile
, preprocessed
))
1483 pfile
->state
.prevent_expansion
= 1;
1484 CPP_OPTION (pfile
, traditional
) = 0;
1487 /* Traditional CPP does not accurately track column information. */
1488 if (CPP_OPTION (pfile
, traditional
))
1489 CPP_OPTION (pfile
, show_column
) = 0;