gcc/cppinit.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 87, 89, 92-98, 1999 Free Software Foundation, Inc.
   3    Contributed by Per Bothner, 1994-95.
   4    Based on CCCP program by Paul Rubin, June 1986
   5    Adapted to ANSI C, Richard Stallman, Jan 1987
   6
   7 This program is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by the
   9 Free Software Foundation; either version 2, or (at your option) any
  10 later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23
  24 #define FAKE_CONST
  25 #include "cpplib.h"
  26 #include "cpphash.h"
  27 #include "output.h"
  28 #include "prefix.h"
  29 #include "intl.h"
  30
  31 /* XXX Should be in a header file. */
  32 extern char *version_string;
  33
  34 /* Predefined symbols, built-in macros, and the default include path. */
  35
  36 #ifndef GET_ENV_PATH_LIST
  37 #define GET_ENV_PATH_LIST(VAR,NAME)     do { (VAR) = getenv (NAME); } while (0)
  38 #endif
  39
  40 #ifndef STANDARD_INCLUDE_DIR
  41 #define STANDARD_INCLUDE_DIR "/usr/include"
  42 #endif
  43
  44 /* We let tm.h override the types used here, to handle trivial differences
  45    such as the choice of unsigned int or long unsigned int for size_t.
  46    When machines start needing nontrivial differences in the size type,
  47    it would be best to do something here to figure out automatically
  48    from other information what type to use.  */
  49
  50 /* The string value for __SIZE_TYPE__.  */
  51
  52 #ifndef SIZE_TYPE
  53 #define SIZE_TYPE "long unsigned int"
  54 #endif
  55
  56 /* The string value for __PTRDIFF_TYPE__.  */
  57
  58 #ifndef PTRDIFF_TYPE
  59 #define PTRDIFF_TYPE "long int"
  60 #endif
  61
  62 /* The string value for __WCHAR_TYPE__.  */
  63
  64 #ifndef WCHAR_TYPE
  65 #define WCHAR_TYPE "int"
  66 #endif
  67 #define CPP_WCHAR_TYPE(PFILE) \
  68         (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
  69
  70 /* The string value for __USER_LABEL_PREFIX__ */
  71
  72 #ifndef USER_LABEL_PREFIX
  73 #define USER_LABEL_PREFIX ""
  74 #endif
  75
  76 /* The string value for __REGISTER_PREFIX__ */
  77
  78 #ifndef REGISTER_PREFIX
  79 #define REGISTER_PREFIX ""
  80 #endif
  81
  82 /* Suffix for object files, and known input-file extensions. */
  83 static const char * const known_suffixes[] =
  84 {
  85   ".c",  ".C",   ".s",   ".S",   ".m",
  86   ".cc", ".cxx", ".cpp", ".cp",  ".c++",
  87   NULL
  88 };
  89
  90 #ifndef OBJECT_SUFFIX
  91 # ifdef VMS
  92 #  define OBJECT_SUFFIX ".obj"
  93 # else
  94 #  define OBJECT_SUFFIX ".o"
  95 # endif
  96 #endif
  97
  98
  99 /* This is the default list of directories to search for include files.
 100    It may be overridden by the various -I and -ixxx options.
 101
 102    #include "file" looks in the same directory as the current file,
 103    then this list.
 104    #include <file> just looks in this list.
 105
 106    All these directories are treated as `system' include directories
 107    (they are not subject to pedantic warnings in some cases).  */
 108
 109 static struct default_include
 110 {
 111   const char *fname;            /* The name of the directory.  */
 112   const char *component;        /* The component containing the directory
 113                                    (see update_path in prefix.c) */
 114   int cplusplus;                /* Only look here if we're compiling C++.  */
 115   int cxx_aware;                /* Includes in this directory don't need to
 116                                    be wrapped in extern "C" when compiling
 117                                    C++.  This is not used anymore.  */
 118 }
 119 include_defaults_array[]
 120 #ifdef INCLUDE_DEFAULTS
 121 = INCLUDE_DEFAULTS;
 122 #else
 123 = {
 124     /* Pick up GNU C++ specific include files.  */
 125     { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1 },
 126 #ifdef CROSS_COMPILE
 127     /* This is the dir for fixincludes.  Put it just before
 128        the files that we fix.  */
 129     { GCC_INCLUDE_DIR, "GCC", 0, 0 },
 130     /* For cross-compilation, this dir name is generated
 131        automatically in Makefile.in.  */
 132     { CROSS_INCLUDE_DIR, "GCC", 0, 0 },
 133 #ifdef TOOL_INCLUDE_DIR
 134     /* This is another place that the target system's headers might be.  */
 135     { TOOL_INCLUDE_DIR, "BINUTILS", 0, 1 },
 136 #endif
 137 #else /* not CROSS_COMPILE */
 138 #ifdef LOCAL_INCLUDE_DIR
 139     /* This should be /usr/local/include and should come before
 140        the fixincludes-fixed header files.  */
 141     { LOCAL_INCLUDE_DIR, 0, 0, 1 },
 142 #endif
 143 #ifdef TOOL_INCLUDE_DIR
 144     /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
 145        Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h.  */
 146     { TOOL_INCLUDE_DIR, "BINUTILS", 0, 1 },
 147 #endif
 148     /* This is the dir for fixincludes.  Put it just before
 149        the files that we fix.  */
 150     { GCC_INCLUDE_DIR, "GCC", 0, 0 },
 151     /* Some systems have an extra dir of include files.  */
 152 #ifdef SYSTEM_INCLUDE_DIR
 153     { SYSTEM_INCLUDE_DIR, 0, 0, 0 },
 154 #endif
 155 #ifndef STANDARD_INCLUDE_COMPONENT
 156 #define STANDARD_INCLUDE_COMPONENT 0
 157 #endif
 158     { STANDARD_INCLUDE_DIR, STANDARD_INCLUDE_COMPONENT, 0, 0 },
 159 #endif /* not CROSS_COMPILE */
 160     { 0, 0, 0, 0 }
 161   };
 162 #endif /* no INCLUDE_DEFAULTS */
 163
 164 /* Internal structures and prototypes. */
 165
 166 /* A `struct pending_option' remembers one -D, -A, -U, -include, or -imacros
 167    switch.  There are four lists: one for -D and -U, one for -A, one
 168    for -include, one for -imacros.  `undef' is set for -U, clear for
 169    -D, ignored for the others.
 170    (Future: add an equivalent of -U for -A) */
 171 struct pending_option
 172 {
 173   struct pending_option *next;
 174   char *arg;
 175   int undef;
 176 };
 177
 178 #ifdef __STDC__
 179 #define APPEND(pend, list, elt) \
 180   do {  if (!(pend)->list##_head) (pend)->list##_head = (elt); \
 181         else (pend)->list##_tail->next = (elt); \
 182         (pend)->list##_tail = (elt); \
 183   } while (0)
 184 #else
 185 #define APPEND(pend, list, elt) \
 186   do {  if (!(pend)->list/**/_head) (pend)->list/**/_head = (elt); \
 187         else (pend)->list/**/_tail->next = (elt); \
 188         (pend)->list/**/_tail = (elt); \
 189   } while (0)
 190 #endif
 191
 192 static void print_help                  PARAMS ((void));
 193 static void path_include                PARAMS ((cpp_reader *,
 194                                                  struct cpp_pending *,
 195                                                  char *, int));
 196 static void initialize_builtins         PARAMS ((cpp_reader *));
 197 static void append_include_chain        PARAMS ((cpp_reader *,
 198                                                  struct cpp_pending *,
 199                                                  char *, int));
 200 static char *base_name                  PARAMS ((const char *));
 201 static void dump_special_to_buffer      PARAMS ((cpp_reader *, const char *));
 202 static void initialize_dependency_output PARAMS ((cpp_reader *));
 203
 204 /* Last argument to append_include_chain: chain to use */
 205 enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
 206
 207 /* If gcc is in use (stage2/stage3) we can make this table initialized data. */
 208 #ifdef __STDC__
 209 #define CAT(a, b) a##b
 210 #else
 211 #define CAT(a, b) a/**/b
 212 #endif
 213
 214 #if (GCC_VERSION >= 2007)
 215 #define TABLE(id) static inline void CAT(init_, id) PARAMS ((void)) {} \
 216 unsigned char id[256] = {
 217 #define s(p, v) [p] = v,
 218 #define END };
 219 #else
 220 #define TABLE(id) unsigned char id[256] = { 0 }; \
 221 static void CAT(init_,id) PARAMS ((void)) { \
 222 unsigned char *x = id;
 223 #define s(p, v) x[p] = v;
 224 #define END }
 225 #endif
 226
 227 #define A(x) s(x, ISidnum|ISidstart)
 228 #define N(x) s(x, ISidnum|ISnumstart)
 229 #define H(x) s(x, IShspace|ISspace)
 230 #define S(x) s(x, ISspace)
 231
 232 TABLE (IStable)
 233   A('_')
 234
 235   A('a') A('b') A('c') A('d') A('e') A('f') A('g') A('h') A('i')
 236   A('j') A('k') A('l') A('m') A('n') A('o') A('p') A('q') A('r')
 237   A('s') A('t') A('u') A('v') A('w') A('x') A('y') A('z')
 238
 239   A('A') A('B') A('C') A('D') A('E') A('F') A('G') A('H') A('I')
 240   A('J') A('K') A('L') A('M') A('N') A('O') A('P') A('Q') A('R')
 241   A('S') A('T') A('U') A('V') A('W') A('X') A('Y') A('Z')
 242
 243   N('1') N('2') N('3') N('4') N('5') N('6') N('7') N('8') N('9') N('0')
 244
 245   H(' ') H('\t') H('\v') H('\f')
 246
 247   S('\n')
 248 END
 249
 250 #undef A
 251 #undef N
 252 #undef H
 253 #undef S
 254 #undef TABLE
 255 #undef END
 256 #undef s
 257 #undef CAT
 258
 259 /* Given a colon-separated list of file names PATH,
 260    add all the names to the search path for include files.  */
 261
 262 static void
 263 path_include (pfile, pend, list, path)
 264      cpp_reader *pfile;
 265      struct cpp_pending *pend;
 266      char *list;
 267      int path;
 268 {
 269   char *p, *q, *name;
 270
 271   p = list;
 272
 273   do
 274     {
 275       /* Find the end of this name.  */
 276       q = p;
 277       while (*q != 0 && *q != PATH_SEPARATOR) q++;
 278       if (q == p)
 279         {
 280           /* An empty name in the path stands for the current directory.  */
 281           name = (char *) xmalloc (2);
 282           name[0] = '.';
 283           name[1] = 0;
 284         }
 285       else
 286         {
 287           /* Otherwise use the directory that is named.  */
 288           name = (char *) xmalloc (q - p + 1);
 289           memcpy (name, p, q - p);
 290           name[q - p] = 0;
 291         }
 292
 293       append_include_chain (pfile, pend, name, path);
 294
 295       /* Advance past this name.  */
 296       if (*q == 0)
 297         break;
 298       p = q + 1;
 299     }
 300   while (1);
 301 }
 302
 303 /* Find the base name of a (partial) pathname FNAME.
 304    Returns a pointer into the string passed in.
 305    Accepts Unix (/-separated) paths on all systems,
 306    DOS and VMS paths on those systems.  */
 307 static char *
 308 base_name (fname)
 309      const char *fname;
 310 {
 311   char *s = (char *)fname;
 312   char *p;
 313 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 314   if (ISALPHA (s[0]) && s[1] == ':') s += 2;
 315   if ((p = rindex (s, '\\'))) s = p + 1;
 316 #elif defined VMS
 317   if ((p = rindex (s, ':'))) s = p + 1; /* Skip device.  */
 318   if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory.  */
 319   if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir.  */
 320 #endif
 321   if ((p = rindex (s, '/'))) s = p + 1;
 322   return s;
 323 }
 324
 325
 326 /* Append DIR to include path PATH.  DIR must be permanently allocated
 327    and writable. */
 328 static void
 329 append_include_chain (pfile, pend, dir, path)
 330      cpp_reader *pfile;
 331      struct cpp_pending *pend;
 332      char *dir;
 333      int path;
 334 {
 335   struct file_name_list *new;
 336   struct stat st;
 337   unsigned int len;
 338
 339   simplify_pathname (dir);
 340   if (stat (dir, &st))
 341     {
 342       /* Dirs that don't exist are silently ignored. */
 343       if (errno != ENOENT)
 344         cpp_perror_with_name (pfile, dir);
 345       else if (CPP_OPTIONS (pfile)->verbose)
 346         cpp_notice ("ignoring nonexistent directory `%s'\n", dir);
 347       return;
 348     }
 349
 350   if (!S_ISDIR (st.st_mode))
 351     {
 352       cpp_message (pfile, 1, "%s: %s: Not a directory", progname, dir);
 353       return;
 354     }
 355
 356   len = strlen (dir);
 357   if (len > pfile->max_include_len)
 358     pfile->max_include_len = len;
 359
 360   new = (struct file_name_list *)xmalloc (sizeof (struct file_name_list));
 361   new->name = dir;
 362   new->nlen = len;
 363   new->ino  = st.st_ino;
 364   new->dev  = st.st_dev;
 365   new->sysp = (path == SYSTEM);
 366   new->name_map = NULL;
 367   new->next = NULL;
 368   new->alloc = NULL;
 369
 370   switch (path)
 371     {
 372     case QUOTE:         APPEND (pend, quote, new); break;
 373     case BRACKET:       APPEND (pend, brack, new); break;
 374     case SYSTEM:        APPEND (pend, systm, new); break;
 375     case AFTER:         APPEND (pend, after, new); break;
 376     }
 377 }
 378
 379
 380 /* Write out a #define command for the special named MACRO_NAME
 381    to PFILE's token_buffer.  */
 382
 383 static void
 384 dump_special_to_buffer (pfile, macro_name)
 385      cpp_reader *pfile;
 386      const char *macro_name;
 387 {
 388   static char define_directive[] = "#define ";
 389   int macro_name_length = strlen (macro_name);
 390   output_line_command (pfile, same_file);
 391   CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
 392   CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
 393   CPP_PUTS_Q (pfile, macro_name, macro_name_length);
 394   CPP_PUTC_Q (pfile, ' ');
 395   cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
 396   CPP_PUTC (pfile, '\n');
 397 }
 398
 399 /* Initialize a cpp_options structure. */
 400 void
 401 cpp_options_init (opts)
 402      cpp_options *opts;
 403 {
 404   bzero ((char *) opts, sizeof (struct cpp_options));
 405
 406   opts->dollars_in_ident = 1;
 407   opts->cplusplus_comments = 1;
 408   opts->warn_import = 1;
 409
 410   opts->pending =
 411     (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
 412 }
 413
 414 /* Initialize a cpp_reader structure. */
 415 void
 416 cpp_reader_init (pfile)
 417      cpp_reader *pfile;
 418 {
 419   bzero ((char *) pfile, sizeof (cpp_reader));
 420 #if 0
 421   pfile->get_token = cpp_get_token;
 422 #endif
 423
 424   pfile->token_buffer_size = 200;
 425   pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
 426   CPP_SET_WRITTEN (pfile, 0);
 427
 428   pfile->hashtab = (HASHNODE **) xcalloc (HASHSIZE, sizeof (HASHNODE *));
 429 }
 430
 431 /* Free resources used by PFILE.
 432    This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology).  */
 433 void
 434 cpp_cleanup (pfile)
 435      cpp_reader *pfile;
 436 {
 437   int i;
 438   while (CPP_BUFFER (pfile) != CPP_NULL_BUFFER (pfile))
 439     cpp_pop_buffer (pfile);
 440
 441   if (pfile->token_buffer)
 442     {
 443       free (pfile->token_buffer);
 444       pfile->token_buffer = NULL;
 445     }
 446
 447   if (pfile->deps_buffer)
 448     {
 449       free (pfile->deps_buffer);
 450       pfile->deps_buffer = NULL;
 451       pfile->deps_allocated_size = 0;
 452     }
 453
 454   if (pfile->input_buffer)
 455     {
 456       free (pfile->input_buffer);
 457       free (pfile->input_speccase);
 458       pfile->input_buffer = pfile->input_speccase = NULL;
 459       pfile->input_buffer_len = 0;
 460     }
 461
 462   while (pfile->if_stack)
 463     {
 464       IF_STACK_FRAME *temp = pfile->if_stack;
 465       pfile->if_stack = temp->next;
 466       free (temp);
 467     }
 468
 469   for (i = ALL_INCLUDE_HASHSIZE; --i >= 0; )
 470     {
 471       struct include_hash *imp = pfile->all_include_files[i];
 472       while (imp)
 473         {
 474           struct include_hash *next = imp->next;
 475 #if 0
 476           /* This gets freed elsewhere - I think. */
 477           free (imp->name);
 478 #endif
 479           free (imp);
 480           imp = next;
 481         }
 482       pfile->all_include_files[i] = 0;
 483     }
 484
 485   for (i = HASHSIZE; --i >= 0;)
 486     {
 487       while (pfile->hashtab[i])
 488         delete_macro (pfile->hashtab[i]);
 489     }
 490   free (pfile->hashtab);
 491 }
 492
 493
 494 /* This structure defines one built-in macro.  A node of type TYPE will
 495    be entered in the macro hash table under the name NAME, with value
 496    VALUE (if any).  FLAGS tweaks the behavior a little:
 497    DUMP         write debug info for this macro
 498    STDC         define only if not -traditional
 499    ULP          value is the global user_label_prefix (which can't be
 500                 put directly into the table).
 501  */
 502
 503 struct builtin
 504 {
 505   const char *name;
 506   const char *value;
 507   unsigned short type;
 508   unsigned short flags;
 509 };
 510 #define DUMP 0x01
 511 #define STDC 0x02
 512 #define ULP  0x10
 513
 514 static const struct builtin builtin_array[] =
 515 {
 516   { "__TIME__",                 0, T_TIME,              DUMP },
 517   { "__DATE__",                 0, T_DATE,              DUMP },
 518   { "__FILE__",                 0, T_FILE,              0    },
 519   { "__BASE_FILE__",            0, T_BASE_FILE,         DUMP },
 520   { "__LINE__",                 0, T_SPECLINE,          0    },
 521   { "__INCLUDE_LEVEL__",        0, T_INCLUDE_LEVEL,     0    },
 522   { "__VERSION__",              0, T_VERSION,           DUMP },
 523   { "__STDC__",                 0, T_STDC,              DUMP|STDC },
 524
 525   { "__USER_LABEL_PREFIX__",    0,               T_CONST, ULP  },
 526   { "__REGISTER_PREFIX__",      REGISTER_PREFIX, T_CONST, 0    },
 527   { "__HAVE_BUILTIN_SETJMP__",  "1",             T_CONST, 0    },
 528 #ifndef NO_BUILTIN_SIZE_TYPE
 529   { "__SIZE_TYPE__",            SIZE_TYPE,       T_CONST, DUMP },
 530 #endif
 531 #ifndef NO_BUILTIN_PTRDIFF_TYPE
 532   { "__PTRDIFF_TYPE__",         PTRDIFF_TYPE,    T_CONST, DUMP },
 533 #endif
 534   { "__WCHAR_TYPE__",           WCHAR_TYPE,      T_CONST, DUMP },
 535   { 0, 0, 0, 0 }
 536 };
 537
 538 /* Subroutine of cpp_start_read; reads the builtins table above and
 539    enters the macros into the hash table.  */
 540
 541 static void
 542 initialize_builtins (pfile)
 543      cpp_reader *pfile;
 544 {
 545   int len;
 546   const struct builtin *b;
 547   const char *val;
 548   for(b = builtin_array; b->name; b++)
 549     {
 550       if ((b->flags & STDC) && CPP_TRADITIONAL (pfile))
 551         continue;
 552
 553       val = (b->flags & ULP) ? user_label_prefix : b->value;
 554       len = strlen (b->name);
 555
 556       cpp_install (pfile, b->name, len, b->type, val, -1);
 557       if ((b->flags & DUMP) && CPP_OPTIONS (pfile)->debug_output)
 558         dump_special_to_buffer (pfile, b->name);
 559     }
 560
 561 }
 562 #undef DUMP
 563 #undef STDC
 564 #undef ULP
 565
 566 /* Another subroutine of cpp_start_read.  This one sets up to do
 567    dependency-file output. */
 568 static void
 569 initialize_dependency_output (pfile)
 570      cpp_reader *pfile;
 571 {
 572   cpp_options *opts = CPP_OPTIONS (pfile);
 573   char *spec, *s, *output_file;
 574
 575   /* Either of two environment variables can specify output of deps.
 576      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
 577      where OUTPUT_FILE is the file to write deps info to
 578      and DEPS_TARGET is the target to mention in the deps.  */
 579
 580   if (opts->print_deps == 0)
 581     {
 582       spec = getenv ("DEPENDENCIES_OUTPUT");
 583       if (spec)
 584         opts->print_deps = 1;
 585       else
 586         {
 587           spec = getenv ("SUNPRO_DEPENDENCIES");
 588           if (spec)
 589             opts->print_deps = 2;
 590           else
 591             return;
 592         }
 593
 594       /* Find the space before the DEPS_TARGET, if there is one.  */
 595       s = strchr (spec, ' ');
 596       if (s)
 597         {
 598           opts->deps_target = s + 1;
 599           output_file = (char *) xmalloc (s - spec + 1);
 600           memcpy (output_file, spec, s - spec);
 601           output_file[s - spec] = 0;
 602         }
 603       else
 604         {
 605           opts->deps_target = 0;
 606           output_file = spec;
 607         }
 608
 609       opts->deps_file = output_file;
 610       opts->print_deps_append = 1;
 611     }
 612
 613   /* Print the expected object file name as the target of this Make-rule.  */
 614   pfile->deps_allocated_size = 200;
 615   pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
 616   pfile->deps_buffer[0] = 0;
 617   pfile->deps_size = 0;
 618   pfile->deps_column = 0;
 619
 620   if (opts->deps_target)
 621     deps_output (pfile, opts->deps_target, ':');
 622   else if (*opts->in_fname == 0)
 623     deps_output (pfile, "-", ':');
 624   else
 625     {
 626       char *p, *q, *r;
 627       int len, x;
 628
 629       /* Discard all directory prefixes from filename.  */
 630       q = base_name (opts->in_fname);
 631
 632       /* Copy remainder to mungable area.  */
 633       len = strlen (q);
 634       p = (char *) alloca (len + 8);
 635       strcpy (p, q);
 636
 637       /* Output P, but remove known suffixes.  */
 638       q = p + len;
 639       /* Point to the filename suffix.  */
 640       r = rindex (p, '.');
 641       /* Compare against the known suffixes.  */
 642       for (x = 0; known_suffixes[x]; x++)
 643         {
 644           if (strncmp (known_suffixes[x], r, q - r) == 0)
 645             {
 646               /* Make q point to the bit we're going to overwrite
 647                  with an object suffix.  */
 648               q = r;
 649               break;
 650             }
 651         }
 652
 653       /* Supply our own suffix.  */
 654       strcpy (q, OBJECT_SUFFIX);
 655
 656       deps_output (pfile, p, ':');
 657       deps_output (pfile, opts->in_fname, ' ');
 658     }
 659 }
 660
 661 /* This is called after options have been processed.
 662  * Check options for consistency, and setup for processing input
 663  * from the file named FNAME.  (Use standard input if FNAME==NULL.)
 664  * Return 1 on success, 0 on failure.
 665  */
 666
 667 int
 668 cpp_start_read (pfile, fname)
 669      cpp_reader *pfile;
 670      char *fname;
 671 {
 672   struct cpp_options *opts = CPP_OPTIONS (pfile);
 673   struct pending_option *p, *q;
 674   int f;
 675   cpp_buffer *fp;
 676   struct include_hash *ih_fake;
 677
 678   /* -MG doesn't select the form of output and must be specified with one of
 679      -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
 680      inhibit compilation.  */
 681   if (opts->print_deps_missing_files
 682       && (opts->print_deps == 0 || !opts->no_output))
 683     {
 684       cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
 685       return 0;
 686     }
 687
 688   /* Chill should not be used with -trigraphs. */
 689   if (opts->chill && opts->trigraphs)
 690     {
 691       cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive");
 692       opts->trigraphs = 0;
 693     }
 694
 695   /* Set this if it hasn't been set already. */
 696   if (user_label_prefix == NULL)
 697     user_label_prefix = USER_LABEL_PREFIX;
 698
 699   /* Now that we know dollars_in_ident, we can initialize the syntax
 700      tables. */
 701   init_IStable ();
 702   /* XXX Get rid of code that depends on this, then IStable can
 703      be truly const.  */
 704   if (opts->dollars_in_ident)
 705     IStable['$'] = ISidstart|ISidnum;
 706
 707   /* Do partial setup of input buffer for the sake of generating
 708      early #line directives (when -g is in effect).  */
 709   fp = cpp_push_buffer (pfile, NULL, 0);
 710   if (!fp)
 711     return 0;
 712   if (opts->in_fname == NULL || *opts->in_fname == 0)
 713     {
 714       opts->in_fname = fname;
 715       if (opts->in_fname == NULL)
 716         opts->in_fname = "";
 717     }
 718   fp->nominal_fname = fp->fname = opts->in_fname;
 719   fp->lineno = 0;
 720
 721   /* Install __LINE__, etc.  Must follow initialize_char_syntax
 722      and option processing.  */
 723   initialize_builtins (pfile);
 724
 725   /* Do -U's, -D's and -A's in the order they were seen.  */
 726   p = opts->pending->define_head;
 727   while (p)
 728     {
 729       if (opts->debug_output)
 730         output_line_command (pfile, same_file);
 731       if (p->undef)
 732         cpp_undef (pfile, p->arg);
 733       else
 734         cpp_define (pfile, p->arg);
 735
 736       q = p->next;
 737       free (p);
 738       p = q;
 739     }
 740
 741   p = opts->pending->assert_head;
 742   while (p)
 743     {
 744       if (opts->debug_output)
 745         output_line_command (pfile, same_file);
 746       if (p->undef)
 747         cpp_unassert (pfile, p->arg);
 748       else
 749         cpp_assert (pfile, p->arg);
 750
 751       q = p->next;
 752       free (p);
 753       p = q;
 754     }
 755
 756   opts->done_initializing = 1;
 757
 758   /* Several environment variables may add to the include search path.
 759      CPATH specifies an additional list of directories to be searched
 760      as if specified with -I, while C_INCLUDE_PATH, CPLUS_INCLUDE_PATH,
 761      etc. specify an additional list of directories to be searched as
 762      if specified with -isystem, for the language indicated.
 763
 764      These variables are ignored if -nostdinc is on.  */
 765   if (! opts->no_standard_includes)
 766     {
 767       char *path;
 768       GET_ENV_PATH_LIST (path, "CPATH");
 769       if (path != 0 && *path != 0)
 770         path_include (pfile, opts->pending, path, BRACKET);
 771
 772       switch ((opts->objc << 1) + opts->cplusplus)
 773         {
 774         case 0:
 775           GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
 776           break;
 777         case 1:
 778           GET_ENV_PATH_LIST (path, "CPLUS_INCLUDE_PATH");
 779           break;
 780         case 2:
 781           GET_ENV_PATH_LIST (path, "OBJC_INCLUDE_PATH");
 782           break;
 783         case 3:
 784           GET_ENV_PATH_LIST (path, "OBJCPLUS_INCLUDE_PATH");
 785           break;
 786         }
 787       if (path != 0 && *path != 0)
 788         path_include (pfile, opts->pending, path, SYSTEM);
 789     }
 790
 791   /* Unless -nostdinc, add the compiled-in include path to the list,
 792      translating prefixes. */
 793   if (!opts->no_standard_includes)
 794     {
 795       struct default_include *p = include_defaults_array;
 796       char *specd_prefix = opts->include_prefix;
 797
 798       /* Search "translated" versions of GNU directories.
 799          These have /usr/local/lib/gcc... replaced by specd_prefix.  */
 800       if (specd_prefix != 0)
 801         {
 802           char *default_prefix = alloca (sizeof GCC_INCLUDE_DIR - 7);
 803           /* Remove the `include' from /usr/local/lib/gcc.../include.
 804              GCC_INCLUDE_DIR will always end in /include. */
 805           int default_len = sizeof GCC_INCLUDE_DIR - 8;
 806           int specd_len = strlen (specd_prefix);
 807
 808           default_len = sizeof GCC_INCLUDE_DIR - 8;
 809           memcpy (default_prefix, GCC_INCLUDE_DIR, default_len);
 810           default_prefix[default_len] = '\0';
 811
 812           for (p = include_defaults_array; p->fname; p++)
 813             {
 814               /* Some standard dirs are only for C++.  */
 815               if (!p->cplusplus
 816                   || (opts->cplusplus
 817                       && !opts->no_standard_cplusplus_includes))
 818                 {
 819                   /* Does this dir start with the prefix?  */
 820                   if (!strncmp (p->fname, default_prefix, default_len))
 821                     {
 822                       /* Yes; change prefix and add to search list.  */
 823                       int flen = strlen (p->fname);
 824                       int this_len = specd_len + flen - default_len;
 825                       char *str = (char *) xmalloc (this_len + 1);
 826                       memcpy (str, specd_prefix, specd_len);
 827                       memcpy (str + specd_len,
 828                               p->fname + default_len,
 829                               flen - default_len + 1);
 830
 831                       append_include_chain (pfile, opts->pending,
 832                                             str, SYSTEM);
 833                     }
 834                 }
 835             }
 836         }
 837
 838       /* Search ordinary names for GNU include directories.  */
 839       for (p = include_defaults_array; p->fname; p++)
 840         {
 841           /* Some standard dirs are only for C++.  */
 842           if (!p->cplusplus
 843               || (opts->cplusplus
 844                   && !opts->no_standard_cplusplus_includes))
 845             {
 846               /* XXX Potential memory leak! */
 847               char *str = xstrdup (update_path (p->fname, p->component));
 848               append_include_chain (pfile, opts->pending, str, SYSTEM);
 849             }
 850         }
 851     }
 852
 853   merge_include_chains (opts);
 854
 855   /* With -v, print the list of dirs to search.  */
 856   if (opts->verbose)
 857     {
 858       struct file_name_list *p;
 859       cpp_message (pfile, -1, "#include \"...\" search starts here:\n");
 860       for (p = opts->quote_include; p; p = p->next)
 861         {
 862           if (p == opts->bracket_include)
 863             cpp_message (pfile, -1, "#include <...> search starts here:\n");
 864           fprintf (stderr, " %s\n", p->name);
 865         }
 866       cpp_message (pfile, -1, "End of search list.\n");
 867     }
 868
 869   /* Don't bother trying to do macro expansion if we've already done
 870      preprocessing.  */
 871   if (opts->preprocessed)
 872     pfile->no_macro_expand++;
 873
 874   /* Open the main input file.
 875      We do this in nonblocking mode so we don't get stuck here if
 876      someone clever has asked cpp to process /dev/rmt0;
 877      finclude() will check that we have a real file to work with.  */
 878   if (fname == NULL || *fname == 0)
 879     {
 880       fname = "";
 881       f = 0;
 882     }
 883   else if ((f = open (fname, O_RDONLY|O_NONBLOCK|O_NOCTTY, 0666)) < 0)
 884     cpp_pfatal_with_name (pfile, fname);
 885
 886   initialize_dependency_output (pfile);
 887
 888   /* Must call finclude() on the main input before processing
 889      -include switches; otherwise the -included text winds up
 890      after the main input. */
 891   ih_fake = (struct include_hash *) xmalloc (sizeof (struct include_hash));
 892   ih_fake->next = 0;
 893   ih_fake->next_this_file = 0;
 894   ih_fake->foundhere = ABSOLUTE_PATH;  /* well sort of ... */
 895   ih_fake->name = fname;
 896   ih_fake->control_macro = 0;
 897   ih_fake->buf = (char *)-1;
 898   ih_fake->limit = 0;
 899   if (!finclude (pfile, f, ih_fake))
 900     return 0;
 901   if (opts->preprocessed)
 902     /* If we've already processed this code, we want to trust the #line
 903        directives in the input.  But we still need to update our line
 904        counter accordingly.  */
 905     pfile->lineno = CPP_BUFFER (pfile)->lineno;
 906   else
 907     output_line_command (pfile, same_file);
 908   pfile->only_seen_white = 2;
 909
 910   /* The -imacros files can be scanned now, but the -include files
 911      have to be pushed onto the include stack and processed later,
 912      in the main loop calling cpp_get_token.  */
 913
 914   pfile->no_record_file++;
 915   opts->no_output++;
 916   p = opts->pending->imacros_head;
 917   while (p)
 918     {
 919       int fd = open (p->arg, O_RDONLY|O_NONBLOCK|O_NOCTTY, 0666);
 920       if (fd < 0)
 921         {
 922           cpp_perror_with_name (pfile, p->arg);
 923           return 0;
 924         }
 925       if (!cpp_push_buffer (pfile, NULL, 0))
 926         return 0;
 927
 928       ih_fake = (struct include_hash *)
 929         xmalloc (sizeof (struct include_hash));
 930       ih_fake->next = 0;
 931       ih_fake->next_this_file = 0;
 932       ih_fake->foundhere = ABSOLUTE_PATH;  /* well sort of ... */
 933       ih_fake->name = p->arg;
 934       ih_fake->control_macro = 0;
 935       ih_fake->buf = (char *)-1;
 936       ih_fake->limit = 0;
 937       if (finclude (pfile, fd, ih_fake))
 938         {
 939           if (CPP_PRINT_DEPS (pfile))
 940             deps_output (pfile, ih_fake->name, ' ');
 941
 942           cpp_scan_buffer (pfile);
 943         }
 944       else
 945         cpp_pop_buffer (pfile);
 946       free (ih_fake);
 947
 948       q = p->next;
 949       free (p);
 950       p = q;
 951     }
 952
 953   opts->no_output--;
 954
 955   p = opts->pending->include_head;
 956   while (p)
 957     {
 958       int fd = open (p->arg, O_RDONLY|O_NONBLOCK|O_NOCTTY, 0666);
 959       if (fd < 0)
 960         {
 961           cpp_perror_with_name (pfile, p->arg);
 962           return 0;
 963         }
 964       if (!cpp_push_buffer (pfile, NULL, 0))
 965         return 0;
 966
 967       ih_fake = (struct include_hash *)
 968         xmalloc (sizeof (struct include_hash));
 969       ih_fake->next = 0;
 970       ih_fake->next_this_file = 0;
 971       ih_fake->foundhere = ABSOLUTE_PATH;  /* well sort of ... */
 972       ih_fake->name = p->arg;
 973       ih_fake->control_macro = 0;
 974       ih_fake->buf = (char *)-1;
 975       ih_fake->limit = 0;
 976       if (finclude (pfile, fd, ih_fake))
 977         {
 978           if (CPP_PRINT_DEPS (pfile))
 979             deps_output (pfile, ih_fake->name, ' ');
 980
 981           output_line_command (pfile, enter_file);
 982         }
 983       else
 984         cpp_pop_buffer (pfile);
 985       q = p->next;
 986       free (p);
 987       p = q;
 988     }
 989   pfile->no_record_file--;
 990
 991   free (opts->pending);
 992   opts->pending = NULL;
 993
 994   return 1;
 995 }
 996
 997 /* This is called at the end of preprocessing.  It pops the
 998    last buffer and writes dependency output.  It should also
 999    clear macro definitions, such that you could call cpp_start_read
1000    with a new filename to restart processing. */
1001 void
1002 cpp_finish (pfile)
1003      cpp_reader *pfile;
1004 {
1005   struct cpp_options *opts = CPP_OPTIONS (pfile);
1006
1007   if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)) != CPP_NULL_BUFFER (pfile))
1008     cpp_fatal (pfile,
1009                "cpplib internal error: buffers still stacked in cpp_finish");
1010   cpp_pop_buffer (pfile);
1011
1012   if (opts->print_deps)
1013     {
1014       /* Stream on which to print the dependency information.  */
1015       FILE *deps_stream;
1016
1017       /* Don't actually write the deps file if compilation has failed.  */
1018       if (pfile->errors == 0)
1019         {
1020           const char *deps_mode = opts->print_deps_append ? "a" : "w";
1021           if (opts->deps_file == 0)
1022             deps_stream = stdout;
1023           else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
1024             cpp_pfatal_with_name (pfile, opts->deps_file);
1025           fputs (pfile->deps_buffer, deps_stream);
1026           putc ('\n', deps_stream);
1027           if (opts->deps_file)
1028             {
1029               if (ferror (deps_stream) || fclose (deps_stream) != 0)
1030                 cpp_fatal (pfile, "I/O error on output");
1031             }
1032         }
1033     }
1034
1035   if (opts->dump_macros == dump_only)
1036     {
1037       int i;
1038       HASHNODE *h;
1039       MACRODEF m;
1040       for (i = HASHSIZE; --i >= 0;)
1041         {
1042           for (h = pfile->hashtab[i]; h; h = h->next)
1043             if (h->type == T_MACRO)
1044               {
1045                 m.defn = h->value.defn;
1046                 m.symnam = h->name;
1047                 m.symlen = h->length;
1048                 dump_definition (pfile, m);
1049                 CPP_PUTC (pfile, '\n');
1050               }
1051         }
1052     }
1053 }
1054
1055 static void
1056 new_pending_define (opts, text)
1057      struct cpp_options *opts;
1058      const char *text;
1059 {
1060   struct pending_option *o = (struct pending_option *)
1061     xmalloc (sizeof (struct pending_option));
1062
1063   o->arg = text;
1064   o->next = NULL;
1065   o->undef = 0;
1066   APPEND (opts->pending, define, o);
1067 }
1068
1069 /* Handle one command-line option in (argc, argv).
1070    Can be called multiple times, to handle multiple sets of options.
1071    Returns number of strings consumed.  */
1072 int
1073 cpp_handle_option (pfile, argc, argv)
1074      cpp_reader *pfile;
1075      int argc;
1076      char **argv;
1077 {
1078   struct cpp_options *opts = CPP_OPTIONS (pfile);
1079   int i = 0;
1080
1081   if (argv[i][0] != '-')
1082     {
1083       if (opts->out_fname != NULL)
1084         {
1085           print_help ();
1086           cpp_fatal (pfile, "Too many arguments");
1087         }
1088       else if (opts->in_fname != NULL)
1089         opts->out_fname = argv[i];
1090       else
1091         opts->in_fname = argv[i];
1092     }
1093   else
1094     switch (argv[i][1])
1095       {
1096       case 'f':
1097         if (!strcmp (argv[i], "-fleading-underscore"))
1098           user_label_prefix = "_";
1099         else if (!strcmp (argv[i], "-fno-leading-underscore"))
1100           user_label_prefix = "";
1101         else if (!strcmp (argv[i], "-fpreprocessed"))
1102           opts->preprocessed = 1;
1103         else if (!strcmp (argv[i], "-fno-preprocessed"))
1104           opts->preprocessed = 0;
1105         else
1106           {
1107             return i;
1108           }
1109         break;
1110
1111       case 'I':                 /* Add directory to path for includes.  */
1112         if (!strcmp (argv[i] + 2, "-"))
1113           {
1114             /* -I- means:
1115                Use the preceding -I directories for #include "..."
1116                but not #include <...>.
1117                Don't search the directory of the present file
1118                for #include "...".  (Note that -I. -I- is not the same as
1119                the default setup; -I. uses the compiler's working dir.)  */
1120             if (! opts->ignore_srcdir)
1121               {
1122                 opts->ignore_srcdir = 1;
1123                 opts->pending->quote_head = opts->pending->brack_head;
1124                 opts->pending->quote_tail = opts->pending->brack_tail;
1125                 opts->pending->brack_head = 0;
1126                 opts->pending->brack_tail = 0;
1127               }
1128             else
1129               {
1130                 cpp_fatal (pfile, "-I- specified twice");
1131                 return argc;
1132               }
1133           }
1134         else
1135           {
1136             char *fname;
1137             if (argv[i][2] != 0)
1138               fname = argv[i] + 2;
1139             else if (i + 1 == argc)
1140               goto missing_dirname;
1141             else
1142               fname = argv[++i];
1143             append_include_chain (pfile, opts->pending,
1144                                   xstrdup (fname), BRACKET);
1145           }
1146         break;
1147
1148       case 'i':
1149         /* Add directory to beginning of system include path, as a system
1150            include directory. */
1151         if (!strcmp (argv[i], "-isystem"))
1152           {
1153             if (i + 1 == argc)
1154               goto missing_filename;
1155             append_include_chain (pfile, opts->pending,
1156                                   xstrdup (argv[++i]), SYSTEM);
1157           }
1158         else if (!strcmp (argv[i], "-include"))
1159           {
1160             if (i + 1 == argc)
1161               goto missing_filename;
1162             else
1163               {
1164                 struct pending_option *o = (struct pending_option *)
1165                   xmalloc (sizeof (struct pending_option));
1166                 o->arg = argv[++i];
1167
1168                 /* This list has to be built in reverse order so that
1169                    when cpp_start_read pushes all the -include files onto
1170                    the buffer stack, they will be scanned in forward order.  */
1171                 o->next = opts->pending->include_head;
1172                 opts->pending->include_head = o;
1173               }
1174           }
1175         else if (!strcmp (argv[i], "-imacros"))
1176           {
1177             if (i + 1 == argc)
1178               goto missing_filename;
1179             else
1180               {
1181                 struct pending_option *o = (struct pending_option *)
1182                   xmalloc (sizeof (struct pending_option));
1183                 o->arg = argv[++i];
1184                 o->next = NULL;
1185
1186                 APPEND (opts->pending, imacros, o);
1187               }
1188           }
1189         /* Add directory to end of path for includes,
1190            with the default prefix at the front of its name.  */
1191         else if (!strcmp (argv[i], "-iwithprefix"))
1192           {
1193             char *fname;
1194             int len;
1195             if (i + 1 == argc)
1196               goto missing_dirname;
1197             ++i;
1198             len = strlen (argv[i]);
1199
1200             if (opts->include_prefix != 0)
1201               {
1202                 fname = xmalloc (opts->include_prefix_len + len + 1);
1203                 memcpy (fname, opts->include_prefix, opts->include_prefix_len);
1204                 memcpy (fname + opts->include_prefix_len, argv[i], len + 1);
1205               }
1206             else
1207               {
1208                 fname = xmalloc (sizeof GCC_INCLUDE_DIR - 8 + len);
1209                 memcpy (fname, GCC_INCLUDE_DIR, sizeof GCC_INCLUDE_DIR - 9);
1210                 memcpy (fname + sizeof GCC_INCLUDE_DIR - 9, argv[i], len + 1);
1211               }
1212
1213             append_include_chain (pfile, opts->pending, fname, SYSTEM);
1214           }
1215         /* Add directory to main path for includes,
1216            with the default prefix at the front of its name.  */
1217         else if (!strcmp (argv[i], "-iwithprefixbefore"))
1218           {
1219             char *fname;
1220             int len;
1221             if (i + 1 == argc)
1222               goto missing_dirname;
1223             ++i;
1224             len = strlen (argv[i]);
1225
1226             if (opts->include_prefix != 0)
1227               {
1228                 fname = xmalloc (opts->include_prefix_len + len + 1);
1229                 memcpy (fname, opts->include_prefix, opts->include_prefix_len);
1230                 memcpy (fname + opts->include_prefix_len, argv[i], len + 1);
1231               }
1232             else
1233               {
1234                 fname = xmalloc (sizeof GCC_INCLUDE_DIR - 8 + len);
1235                 memcpy (fname, GCC_INCLUDE_DIR, sizeof GCC_INCLUDE_DIR - 9);
1236                 memcpy (fname + sizeof GCC_INCLUDE_DIR - 9, argv[i], len + 1);
1237               }
1238
1239             append_include_chain (pfile, opts->pending, fname, BRACKET);
1240           }
1241         /* Add directory to end of path for includes.  */
1242         else if (!strcmp (argv[i], "-idirafter"))
1243           {
1244             if (i + 1 == argc)
1245               goto missing_dirname;
1246             append_include_chain (pfile, opts->pending,
1247                                   xstrdup (argv[++i]), AFTER);
1248           }
1249         else if (!strcmp (argv[i], "-iprefix"))
1250           {
1251             if (i + 1 == argc)
1252               goto missing_filename;
1253             else
1254               {
1255                 opts->include_prefix = argv[++i];
1256                 opts->include_prefix_len = strlen (argv[i]);
1257               }
1258           }
1259         else if (!strcmp (argv[i], "-ifoutput"))
1260           opts->output_conditionals = 1;
1261
1262         break;
1263
1264       case 'o':
1265         if (opts->out_fname != NULL)
1266           {
1267             cpp_fatal (pfile, "Output filename specified twice");
1268             return argc;
1269           }
1270         if (i + 1 == argc)
1271           goto missing_filename;
1272         opts->out_fname = argv[++i];
1273         if (!strcmp (opts->out_fname, "-"))
1274           opts->out_fname = "";
1275         break;
1276
1277       case 'p':
1278         if (!strcmp (argv[i], "-pedantic"))
1279           CPP_PEDANTIC (pfile) = 1;
1280         else if (!strcmp (argv[i], "-pedantic-errors"))
1281           {
1282             CPP_PEDANTIC (pfile) = 1;
1283             opts->pedantic_errors = 1;
1284           }
1285 #if 0
1286         else if (!strcmp (argv[i], "-pcp")) {
1287           char *pcp_fname = argv[++i];
1288           pcp_outfile = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1289                          ? fopen (pcp_fname, "w")
1290                          : fdopen (dup (fileno (stdout)), "w"));
1291           if (pcp_outfile == 0)
1292             cpp_pfatal_with_name (pfile, pcp_fname);
1293           no_precomp = 1;
1294         }
1295 #endif
1296         break;
1297
1298       case 't':
1299         if (!strcmp (argv[i], "-traditional"))
1300           {
1301             opts->traditional = 1;
1302             opts->cplusplus_comments = 0;
1303             opts->trigraphs = 0;
1304             opts->warn_trigraphs = 0;
1305           }
1306         else if (!strcmp (argv[i], "-trigraphs"))
1307           opts->trigraphs = 1;
1308         break;
1309
1310       case 'l':
1311         if (! strcmp (argv[i], "-lang-c"))
1312           opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
1313             opts->c9x = 1, opts->objc = 0;
1314         if (! strcmp (argv[i], "-lang-c89"))
1315           {
1316             opts->cplusplus = 0, opts->cplusplus_comments = 0;
1317             opts->c89 = 1, opts->c9x = 0, opts->objc = 0;
1318             opts->trigraphs = 1;
1319             new_pending_define (opts, "__STRICT_ANSI__");
1320           }
1321         if (! strcmp (argv[i], "-lang-c++"))
1322           opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
1323             opts->c9x = 0, opts->objc = 0;
1324         if (! strcmp (argv[i], "-lang-objc"))
1325           opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
1326             opts->c9x = 0, opts->objc = 1;
1327         if (! strcmp (argv[i], "-lang-objc++"))
1328           opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
1329             opts->c9x = 0, opts->objc = 1;
1330         if (! strcmp (argv[i], "-lang-asm"))
1331           opts->lang_asm = 1;
1332         if (! strcmp (argv[i], "-lang-fortran"))
1333           opts->lang_fortran = 1, opts->cplusplus_comments = 0;
1334         if (! strcmp (argv[i], "-lint"))
1335           opts->for_lint = 1;
1336         if (! strcmp (argv[i], "-lang-chill"))
1337           opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
1338             opts->traditional = 1;
1339         break;
1340
1341       case '+':
1342         opts->cplusplus = 1, opts->cplusplus_comments = 1;
1343         break;
1344
1345       case 's':
1346         if (!strcmp (argv[i], "-std=gnu89"))
1347           {
1348             opts->cplusplus = 0, opts->cplusplus_comments = 0;
1349             opts->c89 = 1, opts->c9x = 0, opts->objc = 0;
1350           }
1351         else if (!strcmp (argv[i], "-std=gnu9x"))
1352           {
1353             opts->cplusplus = 0, opts->cplusplus_comments = 1;
1354             opts->c89 = 0, opts->c9x = 1, opts->objc = 0;
1355             new_pending_define (opts, "__STDC_VERSION__=199901L");
1356           }
1357         else if (!strcmp (argv[i], "-std=iso9899:1990")
1358                  || !strcmp (argv[i], "-std=c89"))
1359           {
1360             opts->cplusplus = 0, opts->cplusplus_comments = 0;
1361             opts->c89 = 1, opts->c9x = 0, opts->objc = 0;
1362             opts->trigraphs = 1;
1363             new_pending_define (opts, "__STRICT_ANSI__");
1364           }
1365         else if (!strcmp (argv[i], "-std=iso9899:199409"))
1366           {
1367             opts->cplusplus = 0, opts->cplusplus_comments = 0;
1368             opts->c89 = 1, opts->c9x = 0, opts->objc = 0;
1369             opts->trigraphs = 1;
1370             new_pending_define (opts, "__STRICT_ANSI__");
1371             new_pending_define (opts, "__STDC_VERSION__=199409L");
1372           }
1373         else if (!strcmp (argv[i], "-std=iso9899:199x")
1374                  || !strcmp (argv[i], "-std=iso9899:1999")
1375                  || !strcmp (argv[i], "-std=c9x")
1376                  || !strcmp (argv[i], "-std=c99"))
1377           {
1378             opts->cplusplus = 0, opts->cplusplus_comments = 1;
1379             opts->c89 = 0, opts->c9x = 1, opts->objc = 0;
1380             opts->trigraphs = 1;
1381             new_pending_define (opts, "__STRICT_ANSI__");
1382             new_pending_define (opts, "__STDC_VERSION__=199901L");
1383           }
1384         break;
1385
1386       case 'w':
1387         opts->inhibit_warnings = 1;
1388         break;
1389
1390       case 'W':
1391         if (!strcmp (argv[i], "-Wtrigraphs"))
1392           opts->warn_trigraphs = 1;
1393         else if (!strcmp (argv[i], "-Wno-trigraphs"))
1394           opts->warn_trigraphs = 0;
1395         else if (!strcmp (argv[i], "-Wcomment"))
1396           opts->warn_comments = 1;
1397         else if (!strcmp (argv[i], "-Wno-comment"))
1398           opts->warn_comments = 0;
1399         else if (!strcmp (argv[i], "-Wcomments"))
1400           opts->warn_comments = 1;
1401         else if (!strcmp (argv[i], "-Wno-comments"))
1402           opts->warn_comments = 0;
1403         else if (!strcmp (argv[i], "-Wtraditional"))
1404           opts->warn_stringify = 1;
1405         else if (!strcmp (argv[i], "-Wno-traditional"))
1406           opts->warn_stringify = 0;
1407         else if (!strcmp (argv[i], "-Wundef"))
1408           opts->warn_undef = 1;
1409         else if (!strcmp (argv[i], "-Wno-undef"))
1410           opts->warn_undef = 0;
1411         else if (!strcmp (argv[i], "-Wimport"))
1412           opts->warn_import = 1;
1413         else if (!strcmp (argv[i], "-Wno-import"))
1414           opts->warn_import = 0;
1415         else if (!strcmp (argv[i], "-Werror"))
1416           opts->warnings_are_errors = 1;
1417         else if (!strcmp (argv[i], "-Wno-error"))
1418           opts->warnings_are_errors = 0;
1419         else if (!strcmp (argv[i], "-Wall"))
1420           {
1421             opts->warn_trigraphs = 1;
1422             opts->warn_comments = 1;
1423           }
1424         break;
1425
1426       case 'M':
1427         /* The style of the choices here is a bit mixed.
1428            The chosen scheme is a hybrid of keeping all options in one string
1429            and specifying each option in a separate argument:
1430            -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
1431            -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1432            -M[M][G][D file].  This is awkward to handle in specs, and is not
1433            as extensible.  */
1434         /* ??? -MG must be specified in addition to one of -M or -MM.
1435            This can be relaxed in the future without breaking anything.
1436            The converse isn't true.  */
1437
1438         /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
1439         if (!strcmp (argv[i], "-MG"))
1440           {
1441             opts->print_deps_missing_files = 1;
1442             break;
1443           }
1444         if (!strcmp (argv[i], "-M"))
1445           opts->print_deps = 2;
1446         else if (!strcmp (argv[i], "-MM"))
1447           opts->print_deps = 1;
1448         else if (!strcmp (argv[i], "-MD"))
1449           opts->print_deps = 2;
1450         else if (!strcmp (argv[i], "-MMD"))
1451           opts->print_deps = 1;
1452         /* For -MD and -MMD options, write deps on file named by next arg.  */
1453         if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
1454           {
1455             if (i+1 == argc)
1456               goto missing_filename;
1457             opts->deps_file = argv[++i];
1458           }
1459         else
1460           {
1461             /* For -M and -MM, write deps on standard output
1462                and suppress the usual output.  */
1463             opts->no_output = 1;
1464           }
1465         break;
1466
1467       case 'd':
1468         {
1469           char *p = argv[i] + 2;
1470           char c;
1471           while ((c = *p++) != 0)
1472             {
1473               /* Arg to -d specifies what parts of macros to dump */
1474               switch (c)
1475                 {
1476                 case 'M':
1477                   opts->dump_macros = dump_only;
1478                   opts->no_output = 1;
1479                   break;
1480                 case 'N':
1481                   opts->dump_macros = dump_names;
1482                   break;
1483                 case 'D':
1484                   opts->dump_macros = dump_definitions;
1485                   break;
1486                 case 'I':
1487                   opts->dump_includes = 1;
1488                   break;
1489                 }
1490             }
1491         }
1492         break;
1493
1494       case 'g':
1495         if (argv[i][2] == '3')
1496           opts->debug_output = 1;
1497         break;
1498
1499       case '-':
1500         if (!strcmp (argv[i], "--help"))
1501           print_help ();
1502         else if (!strcmp (argv[i], "--version"))
1503           cpp_notice ("GNU CPP version %s\n", version_string);
1504         exit (0);  /* XXX */
1505         break;
1506
1507       case 'v':
1508         cpp_notice ("GNU CPP version %s", version_string);
1509 #ifdef TARGET_VERSION
1510         TARGET_VERSION;
1511 #endif
1512         fputc ('\n', stderr);
1513         opts->verbose = 1;
1514         break;
1515
1516       case 'H':
1517         opts->print_include_names = 1;
1518         break;
1519
1520       case 'D':
1521         {
1522           const char *text;
1523           if (argv[i][2] != 0)
1524             text = argv[i] + 2;
1525           else if (i + 1 == argc)
1526             {
1527               cpp_fatal (pfile, "Macro name missing after -D option");
1528               return argc;
1529             }
1530           else
1531             text = argv[++i];
1532           new_pending_define (opts, text);
1533         }
1534         break;
1535
1536       case 'A':
1537         {
1538           char *p;
1539
1540           if (argv[i][2] != 0)
1541             p = argv[i] + 2;
1542           else if (i + 1 == argc)
1543             {
1544               cpp_fatal (pfile, "Assertion missing after -A option");
1545               return argc;
1546             }
1547           else
1548             p = argv[++i];
1549
1550           if (strcmp (p, "-"))
1551             {
1552               struct pending_option *o = (struct pending_option *)
1553                 xmalloc (sizeof (struct pending_option));
1554
1555               o->arg = p;
1556               o->next = NULL;
1557               o->undef = 0;
1558               APPEND (opts->pending, assert, o);
1559             }
1560           else
1561             {
1562               /* -A- eliminates all predefined macros and assertions.
1563                  Let's include also any that were specified earlier
1564                  on the command line.  That way we can get rid of any
1565                  that were passed automatically in from GCC.  */
1566               struct pending_option *o1, *o2;
1567
1568               o1 = opts->pending->define_head;
1569               while (o1)
1570                 {
1571                   o2 = o1->next;
1572                   free (o1);
1573                   o1 = o2;
1574                 }
1575               o1 = opts->pending->assert_head;
1576               while (o1)
1577                 {
1578                   o2 = o1->next;
1579                   free (o1);
1580                   o1 = o2;
1581                 }
1582               opts->pending->assert_head = NULL;
1583               opts->pending->assert_tail = NULL;
1584               opts->pending->define_head = NULL;
1585               opts->pending->define_tail = NULL;
1586             }
1587         }
1588         break;
1589
1590       case 'U':
1591         {
1592           struct pending_option *o = (struct pending_option *)
1593             xmalloc (sizeof (struct pending_option));
1594
1595           if (argv[i][2] != 0)
1596             o->arg = argv[i] + 2;
1597           else if (i + 1 == argc)
1598             {
1599               cpp_fatal (pfile, "Macro name missing after -U option");
1600               return argc;
1601             }
1602           else
1603             o->arg = argv[++i];
1604
1605           o->next = NULL;
1606           o->undef = 1;
1607           APPEND (opts->pending, define, o);
1608         }
1609         break;
1610
1611       case 'C':
1612         opts->put_out_comments = 1;
1613         break;
1614
1615       case 'E':                 /* -E comes from cc -E; ignore it.  */
1616         break;
1617
1618       case 'P':
1619         opts->no_line_commands = 1;
1620         break;
1621
1622       case '$':                 /* Don't include $ in identifiers.  */
1623         opts->dollars_in_ident = 0;
1624         break;
1625
1626       case 'n':
1627         if (!strcmp (argv[i], "-nostdinc"))
1628           /* -nostdinc causes no default include directories.
1629              You must specify all include-file directories with -I.  */
1630           opts->no_standard_includes = 1;
1631         else if (!strcmp (argv[i], "-nostdinc++"))
1632           /* -nostdinc++ causes no default C++-specific include directories. */
1633           opts->no_standard_cplusplus_includes = 1;
1634 #if 0
1635         else if (!strcmp (argv[i], "-noprecomp"))
1636           no_precomp = 1;
1637 #endif
1638         break;
1639
1640       case 'r':
1641         if (!strcmp (argv[i], "-remap"))
1642           opts->remap = 1;
1643         break;
1644
1645       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1646         if (opts->in_fname == NULL)
1647           opts->in_fname = "";
1648         else if (opts->out_fname == NULL)
1649           opts->out_fname = "";
1650         else
1651           return i;  /* error */
1652         break;
1653
1654       default:
1655         return i;
1656       }
1657
1658   return i + 1;
1659
1660  missing_filename:
1661   cpp_fatal (pfile, "Filename missing after `%s' option", argv[i]);
1662   return argc;
1663  missing_dirname:
1664   cpp_fatal (pfile, "Directory name missing after `%s' option", argv[i]);
1665   return argc;
1666 }
1667
1668 /* Handle command-line options in (argc, argv).
1669    Can be called multiple times, to handle multiple sets of options.
1670    Returns if an unrecognized option is seen.
1671    Returns number of strings consumed.  */
1672
1673 int
1674 cpp_handle_options (pfile, argc, argv)
1675      cpp_reader *pfile;
1676      int argc;
1677      char **argv;
1678 {
1679   int i;
1680   int strings_processed;
1681   for (i = 0; i < argc; i += strings_processed)
1682     {
1683       strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1684       if (strings_processed == 0)
1685         break;
1686     }
1687   return i;
1688 }
1689
1690 static void
1691 print_help ()
1692 {
1693   cpp_notice ("Usage: %s [switches] input output\n", progname);
1694   fputs (_("\
1695 Switches:\n\
1696   -include <file>           Include the contents of <file> before other files\n\
1697   -imacros <file>           Accept definition of macros in <file>\n\
1698   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1699   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1700   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1701   -isystem <dir>            Add <dir> to the start of the system include path\n\
1702   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1703   -I <dir>                  Add <dir> to the end of the main include path\n\
1704   -nostdinc                 Do not search system include directories\n\
1705                              (dirs specified with -isystem will still be used)\n\
1706   -nostdinc++               Do not search system include directories for C++\n\
1707   -o <file>                 Put output into <file>\n\
1708   -pedantic                 Issue all warnings demanded by strict ANSI C\n\
1709   -traditional              Follow K&R pre-processor behaviour\n\
1710   -trigraphs                Support ANSI C trigraphs\n\
1711   -lang-c                   Assume that the input sources are in C\n\
1712   -lang-c89                 Assume that the input sources are in C89\n\
1713   -lang-c++                 Assume that the input sources are in C++\n\
1714   -lang-objc                Assume that the input sources are in ObjectiveC\n\
1715   -lang-objc++              Assume that the input sources are in ObjectiveC++\n\
1716   -lang-asm                 Assume that the input sources are in assembler\n\
1717   -lang-fortran             Assume that the input sources are in Fortran\n\
1718   -lang-chill               Assume that the input sources are in Chill\n\
1719   -std=<std name>           Specify the conformance standard; one of:\n\
1720                             gnu89, gnu9x, c89, c9x, iso9899:1990,\n\
1721                             iso9899:199409, iso9899:199x\n\
1722   -+                        Allow parsing of C++ style features\n\
1723   -w                        Inhibit warning messages\n\
1724   -Wtrigraphs               Warn if trigraphs are encountered\n\
1725   -Wno-trigraphs            Do not warn about trigraphs\n\
1726   -Wcomment{s}              Warn if one comment starts inside another\n\
1727   -Wno-comment{s}           Do not warn about comments\n\
1728   -Wtraditional             Warn if a macro argument is/would be turned into\n\
1729                              a string if -traditional is specified\n\
1730   -Wno-traditional          Do not warn about stringification\n\
1731   -Wundef                   Warn if an undefined macro is used by #if\n\
1732   -Wno-undef                Do not warn about testing undefined macros\n\
1733   -Wimport                  Warn about the use of the #import directive\n\
1734   -Wno-import               Do not warn about the use of #import\n\
1735   -Werror                   Treat all warnings as errors\n\
1736   -Wno-error                Do not treat warnings as errors\n\
1737   -Wall                     Enable all preprocessor warnings\n\
1738   -M                        Generate make dependencies\n\
1739   -MM                       As -M, but ignore system header files\n\
1740   -MD                       As -M, but put output in a .d file\n\
1741   -MMD                      As -MD, but ignore system header files\n\
1742   -MG                       Treat missing header file as generated files\n\
1743   -g                        Include #define and #undef directives in the output\n\
1744   -D<macro>                 Define a <macro> with string '1' as its value\n\
1745   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1746   -A<question> (<answer>)   Assert the <answer> to <question>\n\
1747   -U<macro>                 Undefine <macro> \n\
1748   -v                        Display the version number\n\
1749   -H                        Print the name of header files as they are used\n\
1750   -C                        Do not discard comments\n\
1751   -dM                       Display a list of macro definitions active at end\n\
1752   -dD                       Preserve macro definitions in output\n\
1753   -dN                       As -dD except that only the names are preserved\n\
1754   -dI                       Include #include directives in the output\n\
1755   -ifoutput                 Describe skipped code blocks in output \n\
1756   -P                        Do not generate #line directives\n\
1757   -$                        Do not allow '$' in identifiers\n\
1758   -remap                    Remap file names when including files.\n\
1759   -h or --help              Display this information\n\
1760 "), stdout);
1761 }