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