alias.c: Fix typos in comments.
[gcc.git] / gcc / cppinit.c
1 /* CPP Library.
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
7
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
11 later version.
12
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.
17
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. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "cpplib.h"
25 #include "cpphash.h"
26 #include "output.h"
27 #include "prefix.h"
28 #include "intl.h"
29 #include "version.h"
30 #include "mkdeps.h"
31 #include "cppdefault.h"
32
33 /* Predefined symbols, built-in macros, and the default include path. */
34
35 #ifndef GET_ENV_PATH_LIST
36 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
37 #endif
38
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. */
42 #ifdef VMS
43 # define INO_T_EQ(a, b) (!memcmp (&(a), &(b), sizeof (a)))
44 #else
45 # if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
46 # define INO_T_EQ(a, b) 0
47 # else
48 # define INO_T_EQ(a, b) ((a) == (b))
49 # endif
50 #endif
51
52 /* Internal structures and prototypes. */
53
54 /* A `struct pending_option' remembers one -D, -A, -U, -include, or
55 -imacros switch. */
56
57 typedef void (* cl_directive_handler) PARAMS ((cpp_reader *, const char *));
58 struct pending_option
59 {
60 struct pending_option *next;
61 const char *arg;
62 cl_directive_handler handler;
63 };
64
65 /* The `pending' structure accumulates all the options that are not
66 actually processed until we hit cpp_start_read. It consists of
67 several lists, one for each type of option. We keep both head and
68 tail pointers for quick insertion. */
69 struct cpp_pending
70 {
71 struct pending_option *directive_head, *directive_tail;
72
73 struct search_path *quote_head, *quote_tail;
74 struct search_path *brack_head, *brack_tail;
75 struct search_path *systm_head, *systm_tail;
76 struct search_path *after_head, *after_tail;
77
78 struct pending_option *imacros_head, *imacros_tail;
79 struct pending_option *include_head, *include_tail;
80 };
81
82 #ifdef __STDC__
83 #define APPEND(pend, list, elt) \
84 do { if (!(pend)->list##_head) (pend)->list##_head = (elt); \
85 else (pend)->list##_tail->next = (elt); \
86 (pend)->list##_tail = (elt); \
87 } while (0)
88 #else
89 #define APPEND(pend, list, elt) \
90 do { if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
91 else (pend)->list/**/_tail->next = (elt); \
92 (pend)->list/**/_tail = (elt); \
93 } while (0)
94 #endif
95
96 static void print_help PARAMS ((void));
97 static void path_include PARAMS ((cpp_reader *,
98 char *, int));
99 static void init_library PARAMS ((void));
100 static void init_builtins PARAMS ((cpp_reader *));
101 static void append_include_chain PARAMS ((cpp_reader *,
102 char *, int, int));
103 static struct search_path * remove_dup_dir PARAMS ((cpp_reader *,
104 struct search_path *));
105 static struct search_path * remove_dup_dirs PARAMS ((cpp_reader *,
106 struct search_path *));
107 static void merge_include_chains PARAMS ((cpp_reader *));
108 static bool push_include PARAMS ((cpp_reader *,
109 struct pending_option *));
110 static void free_chain PARAMS ((struct pending_option *));
111 static void set_lang PARAMS ((cpp_reader *, enum c_lang));
112 static void init_dependency_output PARAMS ((cpp_reader *));
113 static void init_standard_includes PARAMS ((cpp_reader *));
114 static void new_pending_directive PARAMS ((struct cpp_pending *,
115 const char *,
116 cl_directive_handler));
117 static void output_deps PARAMS ((cpp_reader *));
118 static int parse_option PARAMS ((const char *));
119
120 /* Fourth argument to append_include_chain: chain to use.
121 Note it's never asked to append to the quote chain. */
122 enum { BRACKET = 0, SYSTEM, AFTER };
123
124 /* If we have designated initializers (GCC >2.7) these tables can be
125 initialized, constant data. Otherwise, they have to be filled in at
126 runtime. */
127 #if HAVE_DESIGNATED_INITIALIZERS
128
129 #define init_trigraph_map() /* Nothing. */
130 #define TRIGRAPH_MAP \
131 __extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
132
133 #define END };
134 #define s(p, v) [p] = v,
135
136 #else
137
138 #define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
139 static void init_trigraph_map PARAMS ((void)) { \
140 unsigned char *x = _cpp_trigraph_map;
141
142 #define END }
143 #define s(p, v) x[p] = v;
144
145 #endif
146
147 TRIGRAPH_MAP
148 s('=', '#') s(')', ']') s('!', '|')
149 s('(', '[') s('\'', '^') s('>', '}')
150 s('/', '\\') s('<', '{') s('-', '~')
151 END
152
153 #undef s
154 #undef END
155 #undef TRIGRAPH_MAP
156
157 /* Given a colon-separated list of file names PATH,
158 add all the names to the search path for include files. */
159
160 static void
161 path_include (pfile, list, path)
162 cpp_reader *pfile;
163 char *list;
164 int path;
165 {
166 char *p, *q, *name;
167
168 p = list;
169
170 do
171 {
172 /* Find the end of this name. */
173 q = p;
174 while (*q != 0 && *q != PATH_SEPARATOR) q++;
175 if (q == p)
176 {
177 /* An empty name in the path stands for the current directory. */
178 name = (char *) xmalloc (2);
179 name[0] = '.';
180 name[1] = 0;
181 }
182 else
183 {
184 /* Otherwise use the directory that is named. */
185 name = (char *) xmalloc (q - p + 1);
186 memcpy (name, p, q - p);
187 name[q - p] = 0;
188 }
189
190 append_include_chain (pfile, name, path, 0);
191
192 /* Advance past this name. */
193 if (*q == 0)
194 break;
195 p = q + 1;
196 }
197 while (1);
198 }
199
200 /* Append DIR to include path PATH. DIR must be allocated on the
201 heap; this routine takes responsibility for freeing it. */
202 static void
203 append_include_chain (pfile, dir, path, cxx_aware)
204 cpp_reader *pfile;
205 char *dir;
206 int path;
207 int cxx_aware ATTRIBUTE_UNUSED;
208 {
209 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
210 struct search_path *new;
211 struct stat st;
212 unsigned int len;
213
214 if (*dir == '\0')
215 {
216 free (dir);
217 dir = xstrdup (".");
218 }
219 _cpp_simplify_pathname (dir);
220
221 if (stat (dir, &st))
222 {
223 /* Dirs that don't exist are silently ignored. */
224 if (errno != ENOENT)
225 cpp_notice_from_errno (pfile, dir);
226 else if (CPP_OPTION (pfile, verbose))
227 fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
228 free (dir);
229 return;
230 }
231
232 if (!S_ISDIR (st.st_mode))
233 {
234 cpp_notice (pfile, "%s: Not a directory", dir);
235 free (dir);
236 return;
237 }
238
239 len = strlen (dir);
240 if (len > pfile->max_include_len)
241 pfile->max_include_len = len;
242
243 new = (struct search_path *) xmalloc (sizeof (struct search_path));
244 new->name = dir;
245 new->len = len;
246 new->ino = st.st_ino;
247 new->dev = st.st_dev;
248 /* Both systm and after include file lists should be treated as system
249 include files since these two lists are really just a concatenation
250 of one "system" list. */
251 if (path == SYSTEM || path == AFTER)
252 #ifdef NO_IMPLICIT_EXTERN_C
253 new->sysp = 1;
254 #else
255 new->sysp = cxx_aware ? 1 : 2;
256 #endif
257 else
258 new->sysp = 0;
259 new->name_map = NULL;
260 new->next = NULL;
261
262 switch (path)
263 {
264 case BRACKET: APPEND (pend, brack, new); break;
265 case SYSTEM: APPEND (pend, systm, new); break;
266 case AFTER: APPEND (pend, after, new); break;
267 }
268 }
269
270 /* Handle a duplicated include path. PREV is the link in the chain
271 before the duplicate. The duplicate is removed from the chain and
272 freed. Returns PREV. */
273 static struct search_path *
274 remove_dup_dir (pfile, prev)
275 cpp_reader *pfile;
276 struct search_path *prev;
277 {
278 struct search_path *cur = prev->next;
279
280 if (CPP_OPTION (pfile, verbose))
281 fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
282
283 prev->next = cur->next;
284 free ((PTR) cur->name);
285 free (cur);
286
287 return prev;
288 }
289
290 /* Remove duplicate directories from a chain. Returns the tail of the
291 chain, or NULL if the chain is empty. This algorithm is quadratic
292 in the number of -I switches, which is acceptable since there
293 aren't usually that many of them. */
294 static struct search_path *
295 remove_dup_dirs (pfile, head)
296 cpp_reader *pfile;
297 struct search_path *head;
298 {
299 struct search_path *prev = NULL, *cur, *other;
300
301 for (cur = head; cur; cur = cur->next)
302 {
303 for (other = head; other != cur; other = other->next)
304 if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
305 {
306 if (cur->sysp && !other->sysp)
307 {
308 cpp_warning (pfile,
309 "changing search order for system directory \"%s\"",
310 cur->name);
311 if (strcmp (cur->name, other->name))
312 cpp_warning (pfile,
313 " as it is the same as non-system directory \"%s\"",
314 other->name);
315 else
316 cpp_warning (pfile,
317 " as it has already been specified as a non-system directory");
318 }
319 cur = remove_dup_dir (pfile, prev);
320 break;
321 }
322 prev = cur;
323 }
324
325 return prev;
326 }
327
328 /* Merge the four include chains together in the order quote, bracket,
329 system, after. Remove duplicate dirs (as determined by
330 INO_T_EQ()). The system_include and after_include chains are never
331 referred to again after this function; all access is through the
332 bracket_include path.
333
334 For the future: Check if the directory is empty (but
335 how?) and possibly preload the include hash. */
336
337 static void
338 merge_include_chains (pfile)
339 cpp_reader *pfile;
340 {
341 struct search_path *quote, *brack, *systm, *qtail;
342
343 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
344
345 quote = pend->quote_head;
346 brack = pend->brack_head;
347 systm = pend->systm_head;
348 qtail = pend->quote_tail;
349
350 /* Paste together bracket, system, and after include chains. */
351 if (systm)
352 pend->systm_tail->next = pend->after_head;
353 else
354 systm = pend->after_head;
355
356 if (brack)
357 pend->brack_tail->next = systm;
358 else
359 brack = systm;
360
361 /* This is a bit tricky. First we drop dupes from the quote-include
362 list. Then we drop dupes from the bracket-include list.
363 Finally, if qtail and brack are the same directory, we cut out
364 brack and move brack up to point to qtail.
365
366 We can't just merge the lists and then uniquify them because
367 then we may lose directories from the <> search path that should
368 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
369 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
370 -Ibar -I- -Ifoo -Iquux. */
371
372 remove_dup_dirs (pfile, brack);
373 qtail = remove_dup_dirs (pfile, quote);
374
375 if (quote)
376 {
377 qtail->next = brack;
378
379 /* If brack == qtail, remove brack as it's simpler. */
380 if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
381 brack = remove_dup_dir (pfile, qtail);
382 }
383 else
384 quote = brack;
385
386 CPP_OPTION (pfile, quote_include) = quote;
387 CPP_OPTION (pfile, bracket_include) = brack;
388 }
389
390 /* Sets internal flags correctly for a given language, and defines
391 macros if necessary. */
392
393 struct lang_flags
394 {
395 char c99;
396 char objc;
397 char cplusplus;
398 char extended_numbers;
399 char trigraphs;
400 char dollars_in_ident;
401 char cplusplus_comments;
402 char digraphs;
403 };
404
405 /* ??? Enable $ in identifiers in assembly? */
406 static const struct lang_flags lang_defaults[] =
407 { /* c99 objc c++ xnum trig dollar c++comm digr */
408 /* GNUC89 */ { 0, 0, 0, 1, 0, 1, 1, 1 },
409 /* GNUC99 */ { 1, 0, 0, 1, 0, 1, 1, 1 },
410 /* STDC89 */ { 0, 0, 0, 0, 1, 0, 0, 0 },
411 /* STDC94 */ { 0, 0, 0, 0, 1, 0, 0, 1 },
412 /* STDC99 */ { 1, 0, 0, 1, 1, 0, 1, 1 },
413 /* GNUCXX */ { 0, 0, 1, 1, 0, 1, 1, 1 },
414 /* CXX98 */ { 0, 0, 1, 1, 1, 0, 1, 1 },
415 /* OBJC */ { 0, 1, 0, 1, 0, 1, 1, 1 },
416 /* OBJCXX */ { 0, 1, 1, 1, 0, 1, 1, 1 },
417 /* ASM */ { 0, 0, 0, 1, 0, 0, 1, 0 }
418 };
419
420 static void
421 set_lang (pfile, lang)
422 cpp_reader *pfile;
423 enum c_lang lang;
424 {
425 const struct lang_flags *l = &lang_defaults[(int) lang];
426
427 CPP_OPTION (pfile, lang) = lang;
428
429 CPP_OPTION (pfile, c99) = l->c99;
430 CPP_OPTION (pfile, objc) = l->objc;
431 CPP_OPTION (pfile, cplusplus) = l->cplusplus;
432 CPP_OPTION (pfile, extended_numbers) = l->extended_numbers;
433 CPP_OPTION (pfile, trigraphs) = l->trigraphs;
434 CPP_OPTION (pfile, dollars_in_ident) = l->dollars_in_ident;
435 CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
436 CPP_OPTION (pfile, digraphs) = l->digraphs;
437 }
438
439 #ifdef HOST_EBCDIC
440 static int opt_comp PARAMS ((const void *, const void *));
441
442 /* Run-time sorting of options array. */
443 static int
444 opt_comp (p1, p2)
445 const void *p1, *p2;
446 {
447 return strcmp (((struct cl_option *) p1)->opt_text,
448 ((struct cl_option *) p2)->opt_text);
449 }
450 #endif
451
452 /* init initializes library global state. It might not need to
453 do anything depending on the platform and compiler. */
454
455 static void
456 init_library ()
457 {
458 static int initialized = 0;
459
460 if (! initialized)
461 {
462 initialized = 1;
463
464 #ifdef HOST_EBCDIC
465 /* For non-ASCII hosts, the cl_options array needs to be sorted at
466 runtime. */
467 qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
468 #endif
469
470 /* Set up the trigraph map. This doesn't need to do anything if
471 we were compiled with a compiler that supports C99 designated
472 initializers. */
473 init_trigraph_map ();
474 }
475 }
476
477 /* Initialize a cpp_reader structure. */
478 cpp_reader *
479 cpp_create_reader (table, lang)
480 hash_table *table;
481 enum c_lang lang;
482 {
483 struct spec_nodes *s;
484 cpp_reader *pfile;
485
486 /* Initialise this instance of the library if it hasn't been already. */
487 init_library ();
488
489 pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
490
491 set_lang (pfile, lang);
492 CPP_OPTION (pfile, warn_import) = 1;
493 CPP_OPTION (pfile, discard_comments) = 1;
494 CPP_OPTION (pfile, show_column) = 1;
495 CPP_OPTION (pfile, tabstop) = 8;
496 CPP_OPTION (pfile, operator_names) = 1;
497
498 CPP_OPTION (pfile, pending) =
499 (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
500
501 /* It's simplest to just create this struct whether or not it will
502 be needed. */
503 pfile->deps = deps_init ();
504
505 /* Initialise the line map. Start at logical line 1, so we can use
506 a line number of zero for special states. */
507 init_line_maps (&pfile->line_maps);
508 pfile->line = 1;
509
510 /* Initialize lexer state. */
511 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
512
513 /* Indicate date and time not yet calculated. */
514 pfile->date.type = CPP_EOF;
515
516 /* Create a token buffer for the lexer. */
517 _cpp_init_tokenrun (&pfile->base_run, 250);
518 pfile->cur_run = &pfile->base_run;
519 pfile->cur_token = pfile->base_run.base;
520
521 /* Initialise the base context. */
522 pfile->context = &pfile->base_context;
523 pfile->base_context.macro = 0;
524 pfile->base_context.prev = pfile->base_context.next = 0;
525
526 /* Identifier pool initially 8K. Unaligned, permanent pool. */
527 _cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0);
528
529 /* Argument pool initially 8K. Aligned, temporary pool. */
530 _cpp_init_pool (&pfile->argument_pool, 8 * 1024, 0, 1);
531
532 /* Macro pool initially 8K. Aligned, permanent pool. */
533 _cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
534
535 /* Initialise the buffer obstack. */
536 gcc_obstack_init (&pfile->buffer_ob);
537
538 /* Initialise the hashtable. */
539 _cpp_init_hashtable (pfile, table);
540
541 _cpp_init_directives (pfile);
542 _cpp_init_includes (pfile);
543 _cpp_init_internal_pragmas (pfile);
544
545 /* Initialize the special nodes. */
546 s = &pfile->spec_nodes;
547 s->n_L = cpp_lookup (pfile, DSC("L"));
548 s->n_defined = cpp_lookup (pfile, DSC("defined"));
549 s->n_true = cpp_lookup (pfile, DSC("true"));
550 s->n_false = cpp_lookup (pfile, DSC("false"));
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;
556
557 return pfile;
558 }
559
560 /* Free resources used by PFILE. Accessing PFILE after this function
561 returns leads to undefined behaviour. */
562 int
563 cpp_destroy (pfile)
564 cpp_reader *pfile;
565 {
566 int result;
567 struct search_path *dir, *dirn;
568 cpp_context *context, *contextn;
569 tokenrun *run, *runn;
570
571 while (CPP_BUFFER (pfile) != NULL)
572 _cpp_pop_buffer (pfile);
573
574 if (pfile->macro_buffer)
575 {
576 free ((PTR) pfile->macro_buffer);
577 pfile->macro_buffer = NULL;
578 pfile->macro_buffer_len = 0;
579 }
580
581 deps_free (pfile->deps);
582 obstack_free (&pfile->buffer_ob, 0);
583
584 _cpp_destroy_hashtable (pfile);
585 _cpp_cleanup_includes (pfile);
586
587 _cpp_free_pool (&pfile->ident_pool);
588 _cpp_free_pool (&pfile->macro_pool);
589 _cpp_free_pool (&pfile->argument_pool);
590
591 for (run = &pfile->base_run; run; run = runn)
592 {
593 runn = run->next;
594 free (run->base);
595 if (run != &pfile->base_run)
596 free (run);
597 }
598
599 for (dir = CPP_OPTION (pfile, quote_include); dir; dir = dirn)
600 {
601 dirn = dir->next;
602 free ((PTR) dir->name);
603 free (dir);
604 }
605
606 for (context = pfile->base_context.next; context; context = contextn)
607 {
608 contextn = context->next;
609 free (context);
610 }
611
612 free_line_maps (&pfile->line_maps);
613
614 result = pfile->errors;
615 free (pfile);
616
617 return result;
618 }
619
620
621 /* This structure defines one built-in identifier. A node will be
622 entered in the hash table under the name NAME, with value VALUE (if
623 any). If flags has OPERATOR, the node's operator field is used; if
624 flags has BUILTIN the node's builtin field is used. Macros that are
625 known at build time should not be flagged BUILTIN, as then they do
626 not appear in macro dumps with e.g. -dM or -dD.
627
628 Two values are not compile time constants, so we tag
629 them in the FLAGS field instead:
630 VERS value is the global version_string, quoted
631 ULP value is the global user_label_prefix
632
633 Also, macros with CPLUS set in the flags field are entered only for C++. */
634
635 struct builtin
636 {
637 const U_CHAR *name;
638 const char *value;
639 unsigned char builtin;
640 unsigned char operator;
641 unsigned short flags;
642 unsigned short len;
643 };
644 #define VERS 0x01
645 #define ULP 0x02
646 #define CPLUS 0x04
647 #define BUILTIN 0x08
648 #define OPERATOR 0x10
649
650 #define B(n, t) { U n, 0, t, 0, BUILTIN, sizeof n - 1 }
651 #define C(n, v) { U n, v, 0, 0, 0, sizeof n - 1 }
652 #define X(n, f) { U n, 0, 0, 0, f, sizeof n - 1 }
653 #define O(n, c, f) { U n, 0, 0, c, OPERATOR | f, sizeof n - 1 }
654 static const struct builtin builtin_array[] =
655 {
656 B("__TIME__", BT_TIME),
657 B("__DATE__", BT_DATE),
658 B("__FILE__", BT_FILE),
659 B("__BASE_FILE__", BT_BASE_FILE),
660 B("__LINE__", BT_SPECLINE),
661 B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
662
663 X("__VERSION__", VERS),
664 X("__USER_LABEL_PREFIX__", ULP),
665 C("__REGISTER_PREFIX__", REGISTER_PREFIX),
666 C("__HAVE_BUILTIN_SETJMP__", "1"),
667 #ifndef NO_BUILTIN_SIZE_TYPE
668 C("__SIZE_TYPE__", SIZE_TYPE),
669 #endif
670 #ifndef NO_BUILTIN_PTRDIFF_TYPE
671 C("__PTRDIFF_TYPE__", PTRDIFF_TYPE),
672 #endif
673 #ifndef NO_BUILTIN_WCHAR_TYPE
674 C("__WCHAR_TYPE__", WCHAR_TYPE),
675 #endif
676 #ifndef NO_BUILTIN_WINT_TYPE
677 C("__WINT_TYPE__", WINT_TYPE),
678 #endif
679 #ifdef STDC_0_IN_SYSTEM_HEADERS
680 B("__STDC__", BT_STDC),
681 #else
682 C("__STDC__", "1"),
683 #endif
684
685 /* Named operators known to the preprocessor. These cannot be #defined
686 and always have their stated meaning. They are treated like normal
687 identifiers except for the type code and the meaning. Most of them
688 are only for C++ (but see iso646.h). */
689 O("and", CPP_AND_AND, CPLUS),
690 O("and_eq", CPP_AND_EQ, CPLUS),
691 O("bitand", CPP_AND, CPLUS),
692 O("bitor", CPP_OR, CPLUS),
693 O("compl", CPP_COMPL, CPLUS),
694 O("not", CPP_NOT, CPLUS),
695 O("not_eq", CPP_NOT_EQ, CPLUS),
696 O("or", CPP_OR_OR, CPLUS),
697 O("or_eq", CPP_OR_EQ, CPLUS),
698 O("xor", CPP_XOR, CPLUS),
699 O("xor_eq", CPP_XOR_EQ, CPLUS)
700 };
701 #undef B
702 #undef C
703 #undef X
704 #undef O
705 #define builtin_array_end \
706 builtin_array + sizeof(builtin_array)/sizeof(struct builtin)
707
708 /* Subroutine of cpp_start_read; reads the builtins table above and
709 enters the macros into the hash table. */
710 static void
711 init_builtins (pfile)
712 cpp_reader *pfile;
713 {
714 const struct builtin *b;
715
716 for(b = builtin_array; b < builtin_array_end; b++)
717 {
718 if ((b->flags & CPLUS) && ! CPP_OPTION (pfile, cplusplus))
719 continue;
720
721 if ((b->flags & OPERATOR) && ! CPP_OPTION (pfile, operator_names))
722 continue;
723
724 if (b->flags & (OPERATOR | BUILTIN))
725 {
726 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
727 if (b->flags & OPERATOR)
728 {
729 hp->flags |= NODE_OPERATOR;
730 hp->value.operator = b->operator;
731 }
732 else
733 {
734 hp->type = NT_MACRO;
735 hp->flags |= NODE_BUILTIN | NODE_WARN;
736 hp->value.builtin = b->builtin;
737 }
738 }
739 else /* A standard macro of some kind. */
740 {
741 const char *val;
742 char *str;
743
744 if (b->flags & VERS)
745 {
746 /* Allocate enough space for 'name "value"\n\0'. */
747 str = alloca (b->len + strlen (version_string) + 5);
748 sprintf (str, "%s \"%s\"\n", b->name, version_string);
749 }
750 else
751 {
752 if (b->flags & ULP)
753 val = CPP_OPTION (pfile, user_label_prefix);
754 else
755 val = b->value;
756
757 /* Allocate enough space for "name value\n\0". */
758 str = alloca (b->len + strlen (val) + 3);
759 sprintf(str, "%s %s\n", b->name, val);
760 }
761
762 _cpp_define_builtin (pfile, str);
763 }
764 }
765
766 if (CPP_OPTION (pfile, cplusplus))
767 {
768 _cpp_define_builtin (pfile, "__cplusplus 1");
769 if (SUPPORTS_ONE_ONLY)
770 _cpp_define_builtin (pfile, "__GXX_WEAK__ 1");
771 else
772 _cpp_define_builtin (pfile, "__GXX_WEAK__ 0");
773 }
774 if (CPP_OPTION (pfile, objc))
775 _cpp_define_builtin (pfile, "__OBJC__ 1");
776
777 if (CPP_OPTION (pfile, lang) == CLK_STDC94)
778 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
779 else if (CPP_OPTION (pfile, c99))
780 _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
781
782 if (CPP_OPTION (pfile, lang) == CLK_STDC89
783 || CPP_OPTION (pfile, lang) == CLK_STDC94
784 || CPP_OPTION (pfile, lang) == CLK_STDC99)
785 _cpp_define_builtin (pfile, "__STRICT_ANSI__ 1");
786 else if (CPP_OPTION (pfile, lang) == CLK_ASM)
787 _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
788 }
789 #undef BUILTIN
790 #undef OPERATOR
791 #undef VERS
792 #undef ULP
793 #undef CPLUS
794 #undef builtin_array_end
795
796 /* And another subroutine. This one sets up the standard include path. */
797 static void
798 init_standard_includes (pfile)
799 cpp_reader *pfile;
800 {
801 char *path;
802 const struct default_include *p;
803 const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
804
805 /* Several environment variables may add to the include search path.
806 CPATH specifies an additional list of directories to be searched
807 as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
808 etc. specify an additional list of directories to be searched as
809 if specified with -isystem, for the language indicated. */
810
811 GET_ENV_PATH_LIST (path, "CPATH");
812 if (path != 0 && *path != 0)
813 path_include (pfile, path, BRACKET);
814
815 switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
816 {
817 case 0:
818 GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
819 break;
820 case 1:
821 GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
822 break;
823 case 2:
824 GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
825 break;
826 case 3:
827 GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
828 break;
829 }
830 if (path != 0 && *path != 0)
831 path_include (pfile, path, SYSTEM);
832
833 /* Search "translated" versions of GNU directories.
834 These have /usr/local/lib/gcc... replaced by specd_prefix. */
835 if (specd_prefix != 0 && cpp_GCC_INCLUDE_DIR_len)
836 {
837 /* Remove the `include' from /usr/local/lib/gcc.../include.
838 GCC_INCLUDE_DIR will always end in /include. */
839 int default_len = cpp_GCC_INCLUDE_DIR_len;
840 char *default_prefix = (char *) alloca (default_len + 1);
841 int specd_len = strlen (specd_prefix);
842
843 memcpy (default_prefix, cpp_GCC_INCLUDE_DIR, default_len);
844 default_prefix[default_len] = '\0';
845
846 for (p = cpp_include_defaults; p->fname; p++)
847 {
848 /* Some standard dirs are only for C++. */
849 if (!p->cplusplus
850 || (CPP_OPTION (pfile, cplusplus)
851 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
852 {
853 /* Does this dir start with the prefix? */
854 if (!memcmp (p->fname, default_prefix, default_len))
855 {
856 /* Yes; change prefix and add to search list. */
857 int flen = strlen (p->fname);
858 int this_len = specd_len + flen - default_len;
859 char *str = (char *) xmalloc (this_len + 1);
860 memcpy (str, specd_prefix, specd_len);
861 memcpy (str + specd_len,
862 p->fname + default_len,
863 flen - default_len + 1);
864
865 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
866 }
867 }
868 }
869 }
870
871 /* Search ordinary names for GNU include directories. */
872 for (p = cpp_include_defaults; p->fname; p++)
873 {
874 /* Some standard dirs are only for C++. */
875 if (!p->cplusplus
876 || (CPP_OPTION (pfile, cplusplus)
877 && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
878 {
879 char *str = update_path (p->fname, p->component);
880 append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
881 }
882 }
883 }
884
885 /* Pushes a -imacro and -include file given on the command line onto
886 the buffer stack. Returns non-zero if successful. */
887 static bool
888 push_include (pfile, p)
889 cpp_reader *pfile;
890 struct pending_option *p;
891 {
892 cpp_token header;
893
894 /* Later: maybe update this to use the #include "" search path
895 if cpp_read_file fails. */
896 header.type = CPP_STRING;
897 header.val.str.text = (const unsigned char *) p->arg;
898 header.val.str.len = strlen (p->arg);
899 /* Make the command line directive take up a line. */
900 pfile->line++;
901
902 return _cpp_execute_include (pfile, &header, IT_CMDLINE);
903 }
904
905 /* Frees a pending_option chain. */
906 static void
907 free_chain (head)
908 struct pending_option *head;
909 {
910 struct pending_option *next;
911
912 while (head)
913 {
914 next = head->next;
915 free (head);
916 head = next;
917 }
918 }
919
920 /* This is called after options have been processed. Setup for
921 processing input from the file named FNAME, or stdin if it is the
922 empty string. Return 1 on success, 0 on failure. */
923 int
924 cpp_start_read (pfile, fname)
925 cpp_reader *pfile;
926 const char *fname;
927 {
928 /* Set up the include search path now. */
929 if (! CPP_OPTION (pfile, no_standard_includes))
930 init_standard_includes (pfile);
931
932 merge_include_chains (pfile);
933
934 /* With -v, print the list of dirs to search. */
935 if (CPP_OPTION (pfile, verbose))
936 {
937 struct search_path *l;
938 fprintf (stderr, _("#include \"...\" search starts here:\n"));
939 for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
940 {
941 if (l == CPP_OPTION (pfile, bracket_include))
942 fprintf (stderr, _("#include <...> search starts here:\n"));
943 fprintf (stderr, " %s\n", l->name);
944 }
945 fprintf (stderr, _("End of search list.\n"));
946 }
947
948 if (CPP_OPTION (pfile, print_deps))
949 /* Set the default target (if there is none already). */
950 deps_add_default_target (pfile->deps, fname);
951
952 /* Open the main input file. This must be done early, so we have a
953 buffer to stand on. */
954 if (!_cpp_read_file (pfile, fname))
955 return 0;
956
957 /* Set this after cpp_post_options so the client can change the
958 option if it wishes, and after stacking the main file so we don't
959 trace the main file. */
960 pfile->line_maps.trace_includes = CPP_OPTION (pfile, print_include_names);
961
962 /* Install builtins and process command line macros etc. in the order
963 they appeared, but only if not already preprocessed. */
964 if (! CPP_OPTION (pfile, preprocessed))
965 {
966 struct pending_option *p;
967
968 _cpp_do_file_change (pfile, LC_RENAME, _("<builtin>"), 1, 0);
969 init_builtins (pfile);
970 _cpp_do_file_change (pfile, LC_RENAME, _("<command line>"), 1, 0);
971 for (p = CPP_OPTION (pfile, pending)->directive_head; p; p = p->next)
972 (*p->handler) (pfile, p->arg);
973
974 /* Scan -imacros files after command line defines, but before
975 files given with -include. */
976 while ((p = CPP_OPTION (pfile, pending)->imacros_head) != NULL)
977 {
978 if (push_include (pfile, p))
979 {
980 pfile->buffer->return_at_eof = true;
981 cpp_scan_nooutput (pfile);
982 }
983 CPP_OPTION (pfile, pending)->imacros_head = p->next;
984 free (p);
985 }
986 }
987
988 free_chain (CPP_OPTION (pfile, pending)->directive_head);
989 _cpp_push_next_buffer (pfile);
990
991 return 1;
992 }
993
994 /* Called to push the next buffer on the stack given by -include. If
995 there are none, free the pending structure and restore the line map
996 for the main file. */
997 bool
998 _cpp_push_next_buffer (pfile)
999 cpp_reader *pfile;
1000 {
1001 bool pushed = false;
1002
1003 /* This is't pretty; we'd rather not be relying on this as a boolean
1004 for reverting the line map. Further, we only free the chains in
1005 this conditional, so an early call to cpp_finish / cpp_destroy
1006 will leak that memory. */
1007 if (CPP_OPTION (pfile, pending)
1008 && CPP_OPTION (pfile, pending)->imacros_head == NULL)
1009 {
1010 while (!pushed)
1011 {
1012 struct pending_option *p = CPP_OPTION (pfile, pending)->include_head;
1013
1014 if (p == NULL)
1015 break;
1016 if (! CPP_OPTION (pfile, preprocessed))
1017 pushed = push_include (pfile, p);
1018 CPP_OPTION (pfile, pending)->include_head = p->next;
1019 free (p);
1020 }
1021
1022 if (!pushed)
1023 {
1024 free (CPP_OPTION (pfile, pending));
1025 CPP_OPTION (pfile, pending) = NULL;
1026
1027 /* Restore the line map for the main file. */
1028 if (! CPP_OPTION (pfile, preprocessed))
1029 _cpp_do_file_change (pfile, LC_RENAME,
1030 pfile->line_maps.maps[0].to_file, 1, 0);
1031 }
1032 }
1033
1034 return pushed;
1035 }
1036
1037 /* Use mkdeps.c to output dependency information. */
1038 static void
1039 output_deps (pfile)
1040 cpp_reader *pfile;
1041 {
1042 /* Stream on which to print the dependency information. */
1043 FILE *deps_stream = 0;
1044 const char *const deps_mode =
1045 CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
1046
1047 if (CPP_OPTION (pfile, deps_file) == 0)
1048 deps_stream = stdout;
1049 else
1050 {
1051 deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
1052 if (deps_stream == 0)
1053 {
1054 cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
1055 return;
1056 }
1057 }
1058
1059 deps_write (pfile->deps, deps_stream, 72);
1060
1061 if (CPP_OPTION (pfile, deps_phony_targets))
1062 deps_phony_targets (pfile->deps, deps_stream);
1063
1064 /* Don't close stdout. */
1065 if (CPP_OPTION (pfile, deps_file))
1066 {
1067 if (ferror (deps_stream) || fclose (deps_stream) != 0)
1068 cpp_fatal (pfile, "I/O error on output");
1069 }
1070 }
1071
1072 /* This is called at the end of preprocessing. It pops the
1073 last buffer and writes dependency output. It should also
1074 clear macro definitions, such that you could call cpp_start_read
1075 with a new filename to restart processing. */
1076 void
1077 cpp_finish (pfile)
1078 cpp_reader *pfile;
1079 {
1080 /* cpplex.c leaves the final buffer on the stack. This it so that
1081 it returns an unending stream of CPP_EOFs to the client. If we
1082 popped the buffer, we'd derefence a NULL buffer pointer and
1083 segfault. It's nice to allow the client to do worry-free excess
1084 cpp_get_token calls. */
1085 while (pfile->buffer)
1086 _cpp_pop_buffer (pfile);
1087
1088 /* Don't write the deps file if preprocessing has failed. */
1089 if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
1090 output_deps (pfile);
1091
1092 /* Report on headers that could use multiple include guards. */
1093 if (CPP_OPTION (pfile, print_include_names))
1094 _cpp_report_missing_guards (pfile);
1095 }
1096
1097 static void
1098 new_pending_directive (pend, text, handler)
1099 struct cpp_pending *pend;
1100 const char *text;
1101 cl_directive_handler handler;
1102 {
1103 struct pending_option *o = (struct pending_option *)
1104 xmalloc (sizeof (struct pending_option));
1105
1106 o->arg = text;
1107 o->next = NULL;
1108 o->handler = handler;
1109 APPEND (pend, directive, o);
1110 }
1111
1112 /* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
1113 I.e. a const string initializer with parens around it. That is
1114 what N_("string") resolves to, so we make no_* be macros instead. */
1115 #define no_arg N_("Argument missing after %s")
1116 #define no_ass N_("Assertion missing after %s")
1117 #define no_dir N_("Directory name missing after %s")
1118 #define no_fil N_("File name missing after %s")
1119 #define no_mac N_("Macro name missing after %s")
1120 #define no_pth N_("Path name missing after %s")
1121 #define no_num N_("Number missing after %s")
1122 #define no_tgt N_("Target missing after %s")
1123
1124 /* This is the list of all command line options, with the leading
1125 "-" removed. It must be sorted in ASCII collating order. */
1126 #define COMMAND_LINE_OPTIONS \
1127 DEF_OPT("$", 0, OPT_dollar) \
1128 DEF_OPT("+", 0, OPT_plus) \
1129 DEF_OPT("-help", 0, OPT__help) \
1130 DEF_OPT("-target-help", 0, OPT_target__help) \
1131 DEF_OPT("-version", 0, OPT__version) \
1132 DEF_OPT("A", no_ass, OPT_A) \
1133 DEF_OPT("C", 0, OPT_C) \
1134 DEF_OPT("D", no_mac, OPT_D) \
1135 DEF_OPT("H", 0, OPT_H) \
1136 DEF_OPT("I", no_dir, OPT_I) \
1137 DEF_OPT("M", 0, OPT_M) \
1138 DEF_OPT("MD", no_fil, OPT_MD) \
1139 DEF_OPT("MF", no_fil, OPT_MF) \
1140 DEF_OPT("MG", 0, OPT_MG) \
1141 DEF_OPT("MM", 0, OPT_MM) \
1142 DEF_OPT("MMD", no_fil, OPT_MMD) \
1143 DEF_OPT("MP", 0, OPT_MP) \
1144 DEF_OPT("MQ", no_tgt, OPT_MQ) \
1145 DEF_OPT("MT", no_tgt, OPT_MT) \
1146 DEF_OPT("P", 0, OPT_P) \
1147 DEF_OPT("U", no_mac, OPT_U) \
1148 DEF_OPT("W", no_arg, OPT_W) /* arg optional */ \
1149 DEF_OPT("d", no_arg, OPT_d) \
1150 DEF_OPT("fleading-underscore", 0, OPT_fleading_underscore) \
1151 DEF_OPT("fno-leading-underscore", 0, OPT_fno_leading_underscore) \
1152 DEF_OPT("fno-operator-names", 0, OPT_fno_operator_names) \
1153 DEF_OPT("fno-preprocessed", 0, OPT_fno_preprocessed) \
1154 DEF_OPT("fno-show-column", 0, OPT_fno_show_column) \
1155 DEF_OPT("fpreprocessed", 0, OPT_fpreprocessed) \
1156 DEF_OPT("fshow-column", 0, OPT_fshow_column) \
1157 DEF_OPT("ftabstop=", no_num, OPT_ftabstop) \
1158 DEF_OPT("h", 0, OPT_h) \
1159 DEF_OPT("idirafter", no_dir, OPT_idirafter) \
1160 DEF_OPT("imacros", no_fil, OPT_imacros) \
1161 DEF_OPT("include", no_fil, OPT_include) \
1162 DEF_OPT("iprefix", no_pth, OPT_iprefix) \
1163 DEF_OPT("isystem", no_dir, OPT_isystem) \
1164 DEF_OPT("iwithprefix", no_dir, OPT_iwithprefix) \
1165 DEF_OPT("iwithprefixbefore", no_dir, OPT_iwithprefixbefore) \
1166 DEF_OPT("lang-asm", 0, OPT_lang_asm) \
1167 DEF_OPT("lang-c", 0, OPT_lang_c) \
1168 DEF_OPT("lang-c++", 0, OPT_lang_cplusplus) \
1169 DEF_OPT("lang-c89", 0, OPT_lang_c89) \
1170 DEF_OPT("lang-objc", 0, OPT_lang_objc) \
1171 DEF_OPT("lang-objc++", 0, OPT_lang_objcplusplus) \
1172 DEF_OPT("nostdinc", 0, OPT_nostdinc) \
1173 DEF_OPT("nostdinc++", 0, OPT_nostdincplusplus) \
1174 DEF_OPT("o", no_fil, OPT_o) \
1175 DEF_OPT("pedantic", 0, OPT_pedantic) \
1176 DEF_OPT("pedantic-errors", 0, OPT_pedantic_errors) \
1177 DEF_OPT("remap", 0, OPT_remap) \
1178 DEF_OPT("std=c++98", 0, OPT_std_cplusplus98) \
1179 DEF_OPT("std=c89", 0, OPT_std_c89) \
1180 DEF_OPT("std=c99", 0, OPT_std_c99) \
1181 DEF_OPT("std=c9x", 0, OPT_std_c9x) \
1182 DEF_OPT("std=gnu89", 0, OPT_std_gnu89) \
1183 DEF_OPT("std=gnu99", 0, OPT_std_gnu99) \
1184 DEF_OPT("std=gnu9x", 0, OPT_std_gnu9x) \
1185 DEF_OPT("std=iso9899:1990", 0, OPT_std_iso9899_1990) \
1186 DEF_OPT("std=iso9899:199409", 0, OPT_std_iso9899_199409) \
1187 DEF_OPT("std=iso9899:1999", 0, OPT_std_iso9899_1999) \
1188 DEF_OPT("std=iso9899:199x", 0, OPT_std_iso9899_199x) \
1189 DEF_OPT("trigraphs", 0, OPT_trigraphs) \
1190 DEF_OPT("v", 0, OPT_v) \
1191 DEF_OPT("version", 0, OPT_version) \
1192 DEF_OPT("w", 0, OPT_w)
1193
1194 #define DEF_OPT(text, msg, code) code,
1195 enum opt_code
1196 {
1197 COMMAND_LINE_OPTIONS
1198 N_OPTS
1199 };
1200 #undef DEF_OPT
1201
1202 struct cl_option
1203 {
1204 const char *opt_text;
1205 const char *msg;
1206 size_t opt_len;
1207 enum opt_code opt_code;
1208 };
1209
1210 #define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
1211 #ifdef HOST_EBCDIC
1212 static struct cl_option cl_options[] =
1213 #else
1214 static const struct cl_option cl_options[] =
1215 #endif
1216 {
1217 COMMAND_LINE_OPTIONS
1218 };
1219 #undef DEF_OPT
1220 #undef COMMAND_LINE_OPTIONS
1221
1222 /* Perform a binary search to find which, if any, option the given
1223 command-line matches. Returns its index in the option array,
1224 negative on failure. Complications arise since some options can be
1225 suffixed with an argument, and multiple complete matches can occur,
1226 e.g. -iwithprefix and -iwithprefixbefore. Moreover, we need to
1227 accept options beginning with -W that we do not recognise, but not
1228 to swallow any subsequent command line argument; this is handled as
1229 special cases in cpp_handle_option. */
1230 static int
1231 parse_option (input)
1232 const char *input;
1233 {
1234 unsigned int md, mn, mx;
1235 size_t opt_len;
1236 int comp;
1237
1238 mn = 0;
1239 mx = N_OPTS;
1240
1241 while (mx > mn)
1242 {
1243 md = (mn + mx) / 2;
1244
1245 opt_len = cl_options[md].opt_len;
1246 comp = memcmp (input, cl_options[md].opt_text, opt_len);
1247
1248 if (comp > 0)
1249 mn = md + 1;
1250 else if (comp < 0)
1251 mx = md;
1252 else
1253 {
1254 if (input[opt_len] == '\0')
1255 return md;
1256 /* We were passed more text. If the option takes an argument,
1257 we may match a later option or we may have been passed the
1258 argument. The longest possible option match succeeds.
1259 If the option takes no arguments we have not matched and
1260 continue the search (e.g. input="stdc++" match was "stdc"). */
1261 mn = md + 1;
1262 if (cl_options[md].msg)
1263 {
1264 /* Scan forwards. If we get an exact match, return it.
1265 Otherwise, return the longest option-accepting match.
1266 This loops no more than twice with current options. */
1267 mx = md;
1268 for (; mn < (unsigned int) N_OPTS; mn++)
1269 {
1270 opt_len = cl_options[mn].opt_len;
1271 if (memcmp (input, cl_options[mn].opt_text, opt_len))
1272 break;
1273 if (input[opt_len] == '\0')
1274 return mn;
1275 if (cl_options[mn].msg)
1276 mx = mn;
1277 }
1278 return mx;
1279 }
1280 }
1281 }
1282
1283 return -1;
1284 }
1285
1286 /* Handle one command-line option in (argc, argv).
1287 Can be called multiple times, to handle multiple sets of options.
1288 Returns number of strings consumed. */
1289
1290 int
1291 cpp_handle_option (pfile, argc, argv)
1292 cpp_reader *pfile;
1293 int argc;
1294 char **argv;
1295 {
1296 int i = 0;
1297 struct cpp_pending *pend = CPP_OPTION (pfile, pending);
1298
1299 /* Interpret "-" or a non-option as a file name. */
1300 if (argv[i][0] != '-' || argv[i][1] == '\0')
1301 {
1302 if (CPP_OPTION (pfile, in_fname) == NULL)
1303 CPP_OPTION (pfile, in_fname) = argv[i];
1304 else if (CPP_OPTION (pfile, out_fname) == NULL)
1305 CPP_OPTION (pfile, out_fname) = argv[i];
1306 else
1307 cpp_fatal (pfile, "Too many filenames. Type %s --help for usage info",
1308 progname);
1309 }
1310 else
1311 {
1312 enum opt_code opt_code;
1313 int opt_index;
1314 const char *arg = 0;
1315
1316 /* Skip over '-'. */
1317 opt_index = parse_option (&argv[i][1]);
1318 if (opt_index < 0)
1319 return i;
1320
1321 opt_code = cl_options[opt_index].opt_code;
1322 if (cl_options[opt_index].msg)
1323 {
1324 arg = &argv[i][cl_options[opt_index].opt_len + 1];
1325
1326 /* Yuk. Special case for -W as it must not swallow
1327 up any following argument. If this becomes common, add
1328 another field to the cl_options table. */
1329 if (arg[0] == '\0' && opt_code != OPT_W)
1330 {
1331 arg = argv[++i];
1332 if (!arg)
1333 {
1334 cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
1335 return argc;
1336 }
1337 }
1338 }
1339
1340 switch (opt_code)
1341 {
1342 case N_OPTS: /* Shut GCC up. */
1343 break;
1344 case OPT_fleading_underscore:
1345 CPP_OPTION (pfile, user_label_prefix) = "_";
1346 break;
1347 case OPT_fno_leading_underscore:
1348 CPP_OPTION (pfile, user_label_prefix) = "";
1349 break;
1350 case OPT_fno_operator_names:
1351 CPP_OPTION (pfile, operator_names) = 0;
1352 break;
1353 case OPT_fpreprocessed:
1354 CPP_OPTION (pfile, preprocessed) = 1;
1355 break;
1356 case OPT_fno_preprocessed:
1357 CPP_OPTION (pfile, preprocessed) = 0;
1358 break;
1359 case OPT_fshow_column:
1360 CPP_OPTION (pfile, show_column) = 1;
1361 break;
1362 case OPT_fno_show_column:
1363 CPP_OPTION (pfile, show_column) = 0;
1364 break;
1365 case OPT_ftabstop:
1366 /* Silently ignore empty string, non-longs and silly values. */
1367 if (arg[0] != '\0')
1368 {
1369 char *endptr;
1370 long tabstop = strtol (arg, &endptr, 10);
1371 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1372 CPP_OPTION (pfile, tabstop) = tabstop;
1373 }
1374 break;
1375 case OPT_w:
1376 CPP_OPTION (pfile, inhibit_warnings) = 1;
1377 break;
1378 case OPT_h:
1379 case OPT__help:
1380 print_help ();
1381 CPP_OPTION (pfile, help_only) = 1;
1382 break;
1383 case OPT_target__help:
1384 /* Print if any target specific options. cpplib has none, but
1385 make sure help_only gets set. */
1386 CPP_OPTION (pfile, help_only) = 1;
1387 break;
1388
1389 /* --version inhibits compilation, -version doesn't. -v means
1390 verbose and -version. Historical reasons, don't ask. */
1391 case OPT__version:
1392 CPP_OPTION (pfile, help_only) = 1;
1393 pfile->print_version = 1;
1394 break;
1395 case OPT_v:
1396 CPP_OPTION (pfile, verbose) = 1;
1397 pfile->print_version = 1;
1398 break;
1399 case OPT_version:
1400 pfile->print_version = 1;
1401 break;
1402
1403 case OPT_C:
1404 CPP_OPTION (pfile, discard_comments) = 0;
1405 break;
1406 case OPT_P:
1407 CPP_OPTION (pfile, no_line_commands) = 1;
1408 break;
1409 case OPT_dollar: /* Don't include $ in identifiers. */
1410 CPP_OPTION (pfile, dollars_in_ident) = 0;
1411 break;
1412 case OPT_H:
1413 CPP_OPTION (pfile, print_include_names) = 1;
1414 break;
1415 case OPT_D:
1416 new_pending_directive (pend, arg, cpp_define);
1417 break;
1418 case OPT_pedantic_errors:
1419 CPP_OPTION (pfile, pedantic_errors) = 1;
1420 /* fall through */
1421 case OPT_pedantic:
1422 CPP_OPTION (pfile, pedantic) = 1;
1423 break;
1424 case OPT_trigraphs:
1425 CPP_OPTION (pfile, trigraphs) = 1;
1426 break;
1427 case OPT_plus:
1428 CPP_OPTION (pfile, cplusplus) = 1;
1429 CPP_OPTION (pfile, cplusplus_comments) = 1;
1430 break;
1431 case OPT_remap:
1432 CPP_OPTION (pfile, remap) = 1;
1433 break;
1434 case OPT_iprefix:
1435 CPP_OPTION (pfile, include_prefix) = arg;
1436 CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
1437 break;
1438 case OPT_lang_c:
1439 set_lang (pfile, CLK_GNUC89);
1440 break;
1441 case OPT_lang_cplusplus:
1442 set_lang (pfile, CLK_GNUCXX);
1443 break;
1444 case OPT_lang_objc:
1445 set_lang (pfile, CLK_OBJC);
1446 break;
1447 case OPT_lang_objcplusplus:
1448 set_lang (pfile, CLK_OBJCXX);
1449 break;
1450 case OPT_lang_asm:
1451 set_lang (pfile, CLK_ASM);
1452 break;
1453 case OPT_std_cplusplus98:
1454 set_lang (pfile, CLK_CXX98);
1455 break;
1456 case OPT_std_gnu89:
1457 set_lang (pfile, CLK_GNUC89);
1458 break;
1459 case OPT_std_gnu9x:
1460 case OPT_std_gnu99:
1461 set_lang (pfile, CLK_GNUC99);
1462 break;
1463 case OPT_std_iso9899_199409:
1464 set_lang (pfile, CLK_STDC94);
1465 break;
1466 case OPT_std_iso9899_1990:
1467 case OPT_std_c89:
1468 case OPT_lang_c89:
1469 set_lang (pfile, CLK_STDC89);
1470 break;
1471 case OPT_std_iso9899_199x:
1472 case OPT_std_iso9899_1999:
1473 case OPT_std_c9x:
1474 case OPT_std_c99:
1475 set_lang (pfile, CLK_STDC99);
1476 break;
1477 case OPT_nostdinc:
1478 /* -nostdinc causes no default include directories.
1479 You must specify all include-file directories with -I. */
1480 CPP_OPTION (pfile, no_standard_includes) = 1;
1481 break;
1482 case OPT_nostdincplusplus:
1483 /* -nostdinc++ causes no default C++-specific include directories. */
1484 CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
1485 break;
1486 case OPT_o:
1487 if (CPP_OPTION (pfile, out_fname) == NULL)
1488 CPP_OPTION (pfile, out_fname) = arg;
1489 else
1490 {
1491 cpp_fatal (pfile, "Output filename specified twice");
1492 return argc;
1493 }
1494 break;
1495 case OPT_d:
1496 /* Args to -d specify what parts of macros to dump.
1497 Silently ignore unrecognised options; they may
1498 be aimed at the compiler proper. */
1499 {
1500 char c;
1501
1502 while ((c = *arg++) != '\0')
1503 switch (c)
1504 {
1505 case 'M':
1506 CPP_OPTION (pfile, dump_macros) = dump_only;
1507 CPP_OPTION (pfile, no_output) = 1;
1508 break;
1509 case 'N':
1510 CPP_OPTION (pfile, dump_macros) = dump_names;
1511 break;
1512 case 'D':
1513 CPP_OPTION (pfile, dump_macros) = dump_definitions;
1514 break;
1515 case 'I':
1516 CPP_OPTION (pfile, dump_includes) = 1;
1517 break;
1518 }
1519 }
1520 break;
1521
1522 case OPT_MG:
1523 CPP_OPTION (pfile, print_deps_missing_files) = 1;
1524 break;
1525 case OPT_M:
1526 CPP_OPTION (pfile, print_deps) = 2;
1527 break;
1528 case OPT_MM:
1529 CPP_OPTION (pfile, print_deps) = 1;
1530 break;
1531 case OPT_MF:
1532 CPP_OPTION (pfile, deps_file) = arg;
1533 break;
1534 case OPT_MP:
1535 CPP_OPTION (pfile, deps_phony_targets) = 1;
1536 break;
1537 case OPT_MQ:
1538 case OPT_MT:
1539 /* Add a target. -MQ quotes for Make. */
1540 deps_add_target (pfile->deps, arg, opt_code == OPT_MQ);
1541 break;
1542
1543 /* -MD and -MMD for cpp0 are deprecated and undocumented
1544 (use -M or -MM with -MF instead), and probably should be
1545 removed with the next major GCC version. For the moment
1546 we allow these for the benefit of Automake 1.4, which
1547 uses these when dependency tracking is enabled. Automake
1548 1.5 will fix this. */
1549 case OPT_MD:
1550 CPP_OPTION (pfile, print_deps) = 2;
1551 CPP_OPTION (pfile, deps_file) = arg;
1552 break;
1553 case OPT_MMD:
1554 CPP_OPTION (pfile, print_deps) = 1;
1555 CPP_OPTION (pfile, deps_file) = arg;
1556 break;
1557
1558 case OPT_A:
1559 if (arg[0] == '-')
1560 {
1561 /* -A with an argument beginning with '-' acts as
1562 #unassert on whatever immediately follows the '-'.
1563 If "-" is the whole argument, we eliminate all
1564 predefined macros and assertions, including those
1565 that were specified earlier on the command line.
1566 That way we can get rid of any that were passed
1567 automatically in from GCC. */
1568
1569 if (arg[1] == '\0')
1570 {
1571 free_chain (pend->directive_head);
1572 pend->directive_head = NULL;
1573 pend->directive_tail = NULL;
1574 }
1575 else
1576 new_pending_directive (pend, arg + 1, cpp_unassert);
1577 }
1578 else
1579 new_pending_directive (pend, arg, cpp_assert);
1580 break;
1581 case OPT_U:
1582 new_pending_directive (pend, arg, cpp_undef);
1583 break;
1584 case OPT_I: /* Add directory to path for includes. */
1585 if (!strcmp (arg, "-"))
1586 {
1587 /* -I- means:
1588 Use the preceding -I directories for #include "..."
1589 but not #include <...>.
1590 Don't search the directory of the present file
1591 for #include "...". (Note that -I. -I- is not the same as
1592 the default setup; -I. uses the compiler's working dir.) */
1593 if (! CPP_OPTION (pfile, ignore_srcdir))
1594 {
1595 pend->quote_head = pend->brack_head;
1596 pend->quote_tail = pend->brack_tail;
1597 pend->brack_head = 0;
1598 pend->brack_tail = 0;
1599 CPP_OPTION (pfile, ignore_srcdir) = 1;
1600 }
1601 else
1602 {
1603 cpp_fatal (pfile, "-I- specified twice");
1604 return argc;
1605 }
1606 }
1607 else
1608 append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
1609 break;
1610 case OPT_isystem:
1611 /* Add directory to beginning of system include path, as a system
1612 include directory. */
1613 append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
1614 break;
1615 case OPT_include:
1616 case OPT_imacros:
1617 {
1618 struct pending_option *o = (struct pending_option *)
1619 xmalloc (sizeof (struct pending_option));
1620 o->arg = arg;
1621 o->next = NULL;
1622
1623 if (opt_code == OPT_include)
1624 APPEND (pend, include, o);
1625 else
1626 APPEND (pend, imacros, o);
1627 }
1628 break;
1629 case OPT_iwithprefix:
1630 /* Add directory to end of path for includes,
1631 with the default prefix at the front of its name. */
1632 /* fall through */
1633 case OPT_iwithprefixbefore:
1634 /* Add directory to main path for includes,
1635 with the default prefix at the front of its name. */
1636 {
1637 char *fname;
1638 int len;
1639
1640 len = strlen (arg);
1641
1642 if (CPP_OPTION (pfile, include_prefix) != 0)
1643 {
1644 size_t ipl = CPP_OPTION (pfile, include_prefix_len);
1645 fname = xmalloc (ipl + len + 1);
1646 memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
1647 memcpy (fname + ipl, arg, len + 1);
1648 }
1649 else if (cpp_GCC_INCLUDE_DIR_len)
1650 {
1651 fname = xmalloc (cpp_GCC_INCLUDE_DIR_len + len + 1);
1652 memcpy (fname, cpp_GCC_INCLUDE_DIR, cpp_GCC_INCLUDE_DIR_len);
1653 memcpy (fname + cpp_GCC_INCLUDE_DIR_len, arg, len + 1);
1654 }
1655 else
1656 fname = xstrdup (arg);
1657
1658 append_include_chain (pfile, fname,
1659 opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
1660 }
1661 break;
1662 case OPT_idirafter:
1663 /* Add directory to end of path for includes. */
1664 append_include_chain (pfile, xstrdup (arg), AFTER, 0);
1665 break;
1666 case OPT_W:
1667 /* Silently ignore unrecognised options. */
1668 if (!strcmp (argv[i], "-Wall"))
1669 {
1670 CPP_OPTION (pfile, warn_trigraphs) = 1;
1671 CPP_OPTION (pfile, warn_comments) = 1;
1672 }
1673 else if (!strcmp (argv[i], "-Wtraditional"))
1674 CPP_OPTION (pfile, warn_traditional) = 1;
1675 else if (!strcmp (argv[i], "-Wtrigraphs"))
1676 CPP_OPTION (pfile, warn_trigraphs) = 1;
1677 else if (!strcmp (argv[i], "-Wcomment"))
1678 CPP_OPTION (pfile, warn_comments) = 1;
1679 else if (!strcmp (argv[i], "-Wcomments"))
1680 CPP_OPTION (pfile, warn_comments) = 1;
1681 else if (!strcmp (argv[i], "-Wundef"))
1682 CPP_OPTION (pfile, warn_undef) = 1;
1683 else if (!strcmp (argv[i], "-Wimport"))
1684 CPP_OPTION (pfile, warn_import) = 1;
1685 else if (!strcmp (argv[i], "-Werror"))
1686 CPP_OPTION (pfile, warnings_are_errors) = 1;
1687 else if (!strcmp (argv[i], "-Wsystem-headers"))
1688 CPP_OPTION (pfile, warn_system_headers) = 1;
1689 else if (!strcmp (argv[i], "-Wno-traditional"))
1690 CPP_OPTION (pfile, warn_traditional) = 0;
1691 else if (!strcmp (argv[i], "-Wno-trigraphs"))
1692 CPP_OPTION (pfile, warn_trigraphs) = 0;
1693 else if (!strcmp (argv[i], "-Wno-comment"))
1694 CPP_OPTION (pfile, warn_comments) = 0;
1695 else if (!strcmp (argv[i], "-Wno-comments"))
1696 CPP_OPTION (pfile, warn_comments) = 0;
1697 else if (!strcmp (argv[i], "-Wno-undef"))
1698 CPP_OPTION (pfile, warn_undef) = 0;
1699 else if (!strcmp (argv[i], "-Wno-import"))
1700 CPP_OPTION (pfile, warn_import) = 0;
1701 else if (!strcmp (argv[i], "-Wno-error"))
1702 CPP_OPTION (pfile, warnings_are_errors) = 0;
1703 else if (!strcmp (argv[i], "-Wno-system-headers"))
1704 CPP_OPTION (pfile, warn_system_headers) = 0;
1705 break;
1706 }
1707 }
1708 return i + 1;
1709 }
1710
1711 /* Handle command-line options in (argc, argv).
1712 Can be called multiple times, to handle multiple sets of options.
1713 Returns if an unrecognized option is seen.
1714 Returns number of strings consumed. */
1715 int
1716 cpp_handle_options (pfile, argc, argv)
1717 cpp_reader *pfile;
1718 int argc;
1719 char **argv;
1720 {
1721 int i;
1722 int strings_processed;
1723
1724 for (i = 0; i < argc; i += strings_processed)
1725 {
1726 strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1727 if (strings_processed == 0)
1728 break;
1729 }
1730
1731 return i;
1732 }
1733
1734 /* Extra processing when all options are parsed, after all calls to
1735 cpp_handle_option[s]. Consistency checks etc. */
1736 void
1737 cpp_post_options (pfile)
1738 cpp_reader *pfile;
1739 {
1740 if (pfile->print_version)
1741 {
1742 fprintf (stderr, _("GNU CPP version %s (cpplib)"), version_string);
1743 #ifdef TARGET_VERSION
1744 TARGET_VERSION;
1745 #endif
1746 fputc ('\n', stderr);
1747 }
1748
1749 /* Canonicalize in_fname and out_fname. We guarantee they are not
1750 NULL, and that the empty string represents stdin / stdout. */
1751 if (CPP_OPTION (pfile, in_fname) == NULL
1752 || !strcmp (CPP_OPTION (pfile, in_fname), "-"))
1753 CPP_OPTION (pfile, in_fname) = "";
1754
1755 if (CPP_OPTION (pfile, out_fname) == NULL
1756 || !strcmp (CPP_OPTION (pfile, out_fname), "-"))
1757 CPP_OPTION (pfile, out_fname) = "";
1758
1759 /* -Wtraditional is not useful in C++ mode. */
1760 if (CPP_OPTION (pfile, cplusplus))
1761 CPP_OPTION (pfile, warn_traditional) = 0;
1762
1763 /* Set this if it hasn't been set already. */
1764 if (CPP_OPTION (pfile, user_label_prefix) == NULL)
1765 CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
1766
1767 /* Permanently disable macro expansion if we are rescanning
1768 preprocessed text. */
1769 if (CPP_OPTION (pfile, preprocessed))
1770 pfile->state.prevent_expansion = 1;
1771
1772 /* We need to do this after option processing and before
1773 cpp_start_read, as cppmain.c relies on the options->no_output to
1774 set its callbacks correctly before calling cpp_start_read. */
1775 init_dependency_output (pfile);
1776
1777 /* After checking the environment variables, check if -M or -MM has
1778 not been specified, but other -M options have. */
1779 if (CPP_OPTION (pfile, print_deps) == 0 &&
1780 (CPP_OPTION (pfile, print_deps_missing_files)
1781 || CPP_OPTION (pfile, deps_file)
1782 || CPP_OPTION (pfile, deps_phony_targets)))
1783 cpp_fatal (pfile, "you must additionally specify either -M or -MM");
1784 }
1785
1786 /* Set up dependency-file output. */
1787 static void
1788 init_dependency_output (pfile)
1789 cpp_reader *pfile;
1790 {
1791 char *spec, *s, *output_file;
1792
1793 /* Either of two environment variables can specify output of deps.
1794 Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
1795 where OUTPUT_FILE is the file to write deps info to
1796 and DEPS_TARGET is the target to mention in the deps. */
1797
1798 if (CPP_OPTION (pfile, print_deps) == 0)
1799 {
1800 spec = getenv ("DEPENDENCIES_OUTPUT");
1801 if (spec)
1802 CPP_OPTION (pfile, print_deps) = 1;
1803 else
1804 {
1805 spec = getenv ("SUNPRO_DEPENDENCIES");
1806 if (spec)
1807 CPP_OPTION (pfile, print_deps) = 2;
1808 else
1809 return;
1810 }
1811
1812 /* Find the space before the DEPS_TARGET, if there is one. */
1813 s = strchr (spec, ' ');
1814 if (s)
1815 {
1816 /* Let the caller perform MAKE quoting. */
1817 deps_add_target (pfile->deps, s + 1, 0);
1818 output_file = (char *) xmalloc (s - spec + 1);
1819 memcpy (output_file, spec, s - spec);
1820 output_file[s - spec] = 0;
1821 }
1822 else
1823 output_file = spec;
1824
1825 /* Command line overrides environment variables. */
1826 if (CPP_OPTION (pfile, deps_file) == 0)
1827 CPP_OPTION (pfile, deps_file) = output_file;
1828 CPP_OPTION (pfile, print_deps_append) = 1;
1829 }
1830
1831 /* If dependencies go to standard output, or -MG is used, we should
1832 suppress output, including -dM, -dI etc. */
1833 if (CPP_OPTION (pfile, deps_file) == 0
1834 || CPP_OPTION (pfile, print_deps_missing_files))
1835 {
1836 CPP_OPTION (pfile, no_output) = 1;
1837 CPP_OPTION (pfile, dump_macros) = 0;
1838 CPP_OPTION (pfile, dump_includes) = 0;
1839 }
1840 }
1841
1842 static void
1843 print_help ()
1844 {
1845 fprintf (stderr, _("Usage: %s [switches] input output\n"), progname);
1846 /* To keep the lines from getting too long for some compilers, limit
1847 to about 500 characters (6 lines) per chunk. */
1848 fputs (_("\
1849 Switches:\n\
1850 -include <file> Include the contents of <file> before other files\n\
1851 -imacros <file> Accept definition of macros in <file>\n\
1852 -iprefix <path> Specify <path> as a prefix for next two options\n\
1853 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1854 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1855 -isystem <dir> Add <dir> to the start of the system include path\n\
1856 "), stdout);
1857 fputs (_("\
1858 -idirafter <dir> Add <dir> to the end of the system include path\n\
1859 -I <dir> Add <dir> to the end of the main include path\n\
1860 -I- Fine-grained include path control; see info docs\n\
1861 -nostdinc Do not search system include directories\n\
1862 (dirs specified with -isystem will still be used)\n\
1863 -nostdinc++ Do not search system include directories for C++\n\
1864 -o <file> Put output into <file>\n\
1865 "), stdout);
1866 fputs (_("\
1867 -pedantic Issue all warnings demanded by strict ISO C\n\
1868 -pedantic-errors Issue -pedantic warnings as errors instead\n\
1869 -trigraphs Support ISO C trigraphs\n\
1870 -lang-c Assume that the input sources are in C\n\
1871 -lang-c89 Assume that the input sources are in C89\n\
1872 "), stdout);
1873 fputs (_("\
1874 -lang-c++ Assume that the input sources are in C++\n\
1875 -lang-objc Assume that the input sources are in ObjectiveC\n\
1876 -lang-objc++ Assume that the input sources are in ObjectiveC++\n\
1877 -lang-asm Assume that the input sources are in assembler\n\
1878 "), stdout);
1879 fputs (_("\
1880 -std=<std name> Specify the conformance standard; one of:\n\
1881 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1882 iso9899:199409, iso9899:1999\n\
1883 -+ Allow parsing of C++ style features\n\
1884 -w Inhibit warning messages\n\
1885 -Wtrigraphs Warn if trigraphs are encountered\n\
1886 -Wno-trigraphs Do not warn about trigraphs\n\
1887 -Wcomment{s} Warn if one comment starts inside another\n\
1888 "), stdout);
1889 fputs (_("\
1890 -Wno-comment{s} Do not warn about comments\n\
1891 -Wtraditional Warn about features not present in traditional C\n\
1892 -Wno-traditional Do not warn about traditional C\n\
1893 -Wundef Warn if an undefined macro is used by #if\n\
1894 -Wno-undef Do not warn about testing undefined macros\n\
1895 -Wimport Warn about the use of the #import directive\n\
1896 "), stdout);
1897 fputs (_("\
1898 -Wno-import Do not warn about the use of #import\n\
1899 -Werror Treat all warnings as errors\n\
1900 -Wno-error Do not treat warnings as errors\n\
1901 -Wsystem-headers Do not suppress warnings from system headers\n\
1902 -Wno-system-headers Suppress warnings from system headers\n\
1903 -Wall Enable all preprocessor warnings\n\
1904 "), stdout);
1905 fputs (_("\
1906 -M Generate make dependencies\n\
1907 -MM As -M, but ignore system header files\n\
1908 -MF <file> Write dependency output to the given file\n\
1909 -MG Treat missing header file as generated files\n\
1910 "), stdout);
1911 fputs (_("\
1912 -MP Generate phony targets for all headers\n\
1913 -MQ <target> Add a MAKE-quoted target\n\
1914 -MT <target> Add an unquoted target\n\
1915 "), stdout);
1916 fputs (_("\
1917 -D<macro> Define a <macro> with string '1' as its value\n\
1918 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1919 -A<question> (<answer>) Assert the <answer> to <question>\n\
1920 -A-<question> (<answer>) Disable the <answer> to <question>\n\
1921 -U<macro> Undefine <macro> \n\
1922 -v Display the version number\n\
1923 "), stdout);
1924 fputs (_("\
1925 -H Print the name of header files as they are used\n\
1926 -C Do not discard comments\n\
1927 -dM Display a list of macro definitions active at end\n\
1928 -dD Preserve macro definitions in output\n\
1929 -dN As -dD except that only the names are preserved\n\
1930 -dI Include #include directives in the output\n\
1931 "), stdout);
1932 fputs (_("\
1933 -fpreprocessed Treat the input file as already preprocessed\n\
1934 -ftabstop=<number> Distance between tab stops for column reporting\n\
1935 -P Do not generate #line directives\n\
1936 -$ Do not allow '$' in identifiers\n\
1937 -remap Remap file names when including files.\n\
1938 --version Display version information\n\
1939 -h or --help Display this information\n\
1940 "), stdout);
1941 }