gcc/cppinit.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 87, 89, 92-98, 1999, 2000 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->c99 = 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->c99 = 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->c99 = 0, opts->objc = 0;
1324         if (! strcmp (argv[i], "-lang-objc"))
1325           opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
1326             opts->c99 = 0, opts->objc = 1;
1327         if (! strcmp (argv[i], "-lang-objc++"))
1328           opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
1329             opts->c99 = 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 = 1;
1349             opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
1350           }
1351         else if (!strcmp (argv[i], "-std=gnu9x")
1352                  || !strcmp (argv[i], "-std=gnu99"))
1353           {
1354             opts->cplusplus = 0, opts->cplusplus_comments = 1;
1355             opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
1356             new_pending_define (opts, "__STDC_VERSION__=199901L");
1357           }
1358         else if (!strcmp (argv[i], "-std=iso9899:1990")
1359                  || !strcmp (argv[i], "-std=c89"))
1360           {
1361             opts->cplusplus = 0, opts->cplusplus_comments = 0;
1362             opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
1363             opts->trigraphs = 1;
1364             new_pending_define (opts, "__STRICT_ANSI__");
1365           }
1366         else if (!strcmp (argv[i], "-std=iso9899:199409"))
1367           {
1368             opts->cplusplus = 0, opts->cplusplus_comments = 0;
1369             opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
1370             opts->trigraphs = 1;
1371             new_pending_define (opts, "__STRICT_ANSI__");
1372             new_pending_define (opts, "__STDC_VERSION__=199409L");
1373           }
1374         else if (!strcmp (argv[i], "-std=iso9899:199x")
1375                  || !strcmp (argv[i], "-std=iso9899:1999")
1376                  || !strcmp (argv[i], "-std=c9x")
1377                  || !strcmp (argv[i], "-std=c99"))
1378           {
1379             opts->cplusplus = 0, opts->cplusplus_comments = 1;
1380             opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
1381             opts->trigraphs = 1;
1382             new_pending_define (opts, "__STRICT_ANSI__");
1383             new_pending_define (opts, "__STDC_VERSION__=199901L");
1384           }
1385         break;
1386
1387       case 'w':
1388         opts->inhibit_warnings = 1;
1389         break;
1390
1391       case 'W':
1392         if (!strcmp (argv[i], "-Wtrigraphs"))
1393           opts->warn_trigraphs = 1;
1394         else if (!strcmp (argv[i], "-Wno-trigraphs"))
1395           opts->warn_trigraphs = 0;
1396         else if (!strcmp (argv[i], "-Wcomment"))
1397           opts->warn_comments = 1;
1398         else if (!strcmp (argv[i], "-Wno-comment"))
1399           opts->warn_comments = 0;
1400         else if (!strcmp (argv[i], "-Wcomments"))
1401           opts->warn_comments = 1;
1402         else if (!strcmp (argv[i], "-Wno-comments"))
1403           opts->warn_comments = 0;
1404         else if (!strcmp (argv[i], "-Wtraditional"))
1405           opts->warn_stringify = 1;
1406         else if (!strcmp (argv[i], "-Wno-traditional"))
1407           opts->warn_stringify = 0;
1408         else if (!strcmp (argv[i], "-Wundef"))
1409           opts->warn_undef = 1;
1410         else if (!strcmp (argv[i], "-Wno-undef"))
1411           opts->warn_undef = 0;
1412         else if (!strcmp (argv[i], "-Wimport"))
1413           opts->warn_import = 1;
1414         else if (!strcmp (argv[i], "-Wno-import"))
1415           opts->warn_import = 0;
1416         else if (!strcmp (argv[i], "-Werror"))
1417           opts->warnings_are_errors = 1;
1418         else if (!strcmp (argv[i], "-Wno-error"))
1419           opts->warnings_are_errors = 0;
1420         else if (!strcmp (argv[i], "-Wall"))
1421           {
1422             opts->warn_trigraphs = 1;
1423             opts->warn_comments = 1;
1424           }
1425         break;
1426
1427       case 'M':
1428         /* The style of the choices here is a bit mixed.
1429            The chosen scheme is a hybrid of keeping all options in one string
1430            and specifying each option in a separate argument:
1431            -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
1432            -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1433            -M[M][G][D file].  This is awkward to handle in specs, and is not
1434            as extensible.  */
1435         /* ??? -MG must be specified in addition to one of -M or -MM.
1436            This can be relaxed in the future without breaking anything.
1437            The converse isn't true.  */
1438
1439         /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
1440         if (!strcmp (argv[i], "-MG"))
1441           {
1442             opts->print_deps_missing_files = 1;
1443             break;
1444           }
1445         if (!strcmp (argv[i], "-M"))
1446           opts->print_deps = 2;
1447         else if (!strcmp (argv[i], "-MM"))
1448           opts->print_deps = 1;
1449         else if (!strcmp (argv[i], "-MD"))
1450           opts->print_deps = 2;
1451         else if (!strcmp (argv[i], "-MMD"))
1452           opts->print_deps = 1;
1453         /* For -MD and -MMD options, write deps on file named by next arg.  */
1454         if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
1455           {
1456             if (i+1 == argc)
1457               goto missing_filename;
1458             opts->deps_file = argv[++i];
1459           }
1460         else
1461           {
1462             /* For -M and -MM, write deps on standard output
1463                and suppress the usual output.  */
1464             opts->no_output = 1;
1465           }
1466         break;
1467
1468       case 'd':
1469         {
1470           char *p = argv[i] + 2;
1471           char c;
1472           while ((c = *p++) != 0)
1473             {
1474               /* Arg to -d specifies what parts of macros to dump */
1475               switch (c)
1476                 {
1477                 case 'M':
1478                   opts->dump_macros = dump_only;
1479                   opts->no_output = 1;
1480                   break;
1481                 case 'N':
1482                   opts->dump_macros = dump_names;
1483                   break;
1484                 case 'D':
1485                   opts->dump_macros = dump_definitions;
1486                   break;
1487                 case 'I':
1488                   opts->dump_includes = 1;
1489                   break;
1490                 }
1491             }
1492         }
1493         break;
1494
1495       case 'g':
1496         if (argv[i][2] == '3')
1497           opts->debug_output = 1;
1498         break;
1499
1500       case '-':
1501         if (!strcmp (argv[i], "--help"))
1502           print_help ();
1503         else if (!strcmp (argv[i], "--version"))
1504           cpp_notice ("GNU CPP version %s (cpplib)\n", version_string);
1505         exit (0);  /* XXX */
1506         break;
1507
1508       case 'v':
1509         cpp_notice ("GNU CPP version %s (cpplib)", version_string);
1510 #ifdef TARGET_VERSION
1511         TARGET_VERSION;
1512 #endif
1513         fputc ('\n', stderr);
1514         opts->verbose = 1;
1515         break;
1516
1517       case 'H':
1518         opts->print_include_names = 1;
1519         break;
1520
1521       case 'D':
1522         {
1523           const char *text;
1524           if (argv[i][2] != 0)
1525             text = argv[i] + 2;
1526           else if (i + 1 == argc)
1527             {
1528               cpp_fatal (pfile, "Macro name missing after -D option");
1529               return argc;
1530             }
1531           else
1532             text = argv[++i];
1533           new_pending_define (opts, text);
1534         }
1535         break;
1536
1537       case 'A':
1538         {
1539           char *p;
1540
1541           if (argv[i][2] != 0)
1542             p = argv[i] + 2;
1543           else if (i + 1 == argc)
1544             {
1545               cpp_fatal (pfile, "Assertion missing after -A option");
1546               return argc;
1547             }
1548           else
1549             p = argv[++i];
1550
1551           if (strcmp (p, "-"))
1552             {
1553               struct pending_option *o = (struct pending_option *)
1554                 xmalloc (sizeof (struct pending_option));
1555
1556               o->arg = p;
1557               o->next = NULL;
1558               o->undef = 0;
1559               APPEND (opts->pending, assert, o);
1560             }
1561           else
1562             {
1563               /* -A- eliminates all predefined macros and assertions.
1564                  Let's include also any that were specified earlier
1565                  on the command line.  That way we can get rid of any
1566                  that were passed automatically in from GCC.  */
1567               struct pending_option *o1, *o2;
1568
1569               o1 = opts->pending->define_head;
1570               while (o1)
1571                 {
1572                   o2 = o1->next;
1573                   free (o1);
1574                   o1 = o2;
1575                 }
1576               o1 = opts->pending->assert_head;
1577               while (o1)
1578                 {
1579                   o2 = o1->next;
1580                   free (o1);
1581                   o1 = o2;
1582                 }
1583               opts->pending->assert_head = NULL;
1584               opts->pending->assert_tail = NULL;
1585               opts->pending->define_head = NULL;
1586               opts->pending->define_tail = NULL;
1587             }
1588         }
1589         break;
1590
1591       case 'U':
1592         {
1593           struct pending_option *o = (struct pending_option *)
1594             xmalloc (sizeof (struct pending_option));
1595
1596           if (argv[i][2] != 0)
1597             o->arg = argv[i] + 2;
1598           else if (i + 1 == argc)
1599             {
1600               cpp_fatal (pfile, "Macro name missing after -U option");
1601               return argc;
1602             }
1603           else
1604             o->arg = argv[++i];
1605
1606           o->next = NULL;
1607           o->undef = 1;
1608           APPEND (opts->pending, define, o);
1609         }
1610         break;
1611
1612       case 'C':
1613         opts->put_out_comments = 1;
1614         break;
1615
1616       case 'E':                 /* -E comes from cc -E; ignore it.  */
1617         break;
1618
1619       case 'P':
1620         opts->no_line_commands = 1;
1621         break;
1622
1623       case '$':                 /* Don't include $ in identifiers.  */
1624         opts->dollars_in_ident = 0;
1625         break;
1626
1627       case 'n':
1628         if (!strcmp (argv[i], "-nostdinc"))
1629           /* -nostdinc causes no default include directories.
1630              You must specify all include-file directories with -I.  */
1631           opts->no_standard_includes = 1;
1632         else if (!strcmp (argv[i], "-nostdinc++"))
1633           /* -nostdinc++ causes no default C++-specific include directories. */
1634           opts->no_standard_cplusplus_includes = 1;
1635 #if 0
1636         else if (!strcmp (argv[i], "-noprecomp"))
1637           no_precomp = 1;
1638 #endif
1639         break;
1640
1641       case 'r':
1642         if (!strcmp (argv[i], "-remap"))
1643           opts->remap = 1;
1644         break;
1645
1646       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1647         if (opts->in_fname == NULL)
1648           opts->in_fname = "";
1649         else if (opts->out_fname == NULL)
1650           opts->out_fname = "";
1651         else
1652           return i;  /* error */
1653         break;
1654
1655       default:
1656         return i;
1657       }
1658
1659   return i + 1;
1660
1661  missing_filename:
1662   cpp_fatal (pfile, "Filename missing after `%s' option", argv[i]);
1663   return argc;
1664  missing_dirname:
1665   cpp_fatal (pfile, "Directory name missing after `%s' option", argv[i]);
1666   return argc;
1667 }
1668
1669 /* Handle command-line options in (argc, argv).
1670    Can be called multiple times, to handle multiple sets of options.
1671    Returns if an unrecognized option is seen.
1672    Returns number of strings consumed.  */
1673
1674 int
1675 cpp_handle_options (pfile, argc, argv)
1676      cpp_reader *pfile;
1677      int argc;
1678      char **argv;
1679 {
1680   int i;
1681   int strings_processed;
1682   for (i = 0; i < argc; i += strings_processed)
1683     {
1684       strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
1685       if (strings_processed == 0)
1686         break;
1687     }
1688   return i;
1689 }
1690
1691 static void
1692 print_help ()
1693 {
1694   cpp_notice ("Usage: %s [switches] input output\n", progname);
1695   fputs (_("\
1696 Switches:\n\
1697   -include <file>           Include the contents of <file> before other files\n\
1698   -imacros <file>           Accept definition of macros in <file>\n\
1699   -iprefix <path>           Specify <path> as a prefix for next two options\n\
1700   -iwithprefix <dir>        Add <dir> to the end of the system include path\n\
1701   -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n\
1702   -isystem <dir>            Add <dir> to the start of the system include path\n\
1703   -idirafter <dir>          Add <dir> to the end of the system include path\n\
1704   -I <dir>                  Add <dir> to the end of the main include path\n\
1705   -nostdinc                 Do not search system include directories\n\
1706                              (dirs specified with -isystem will still be used)\n\
1707   -nostdinc++               Do not search system include directories for C++\n\
1708   -o <file>                 Put output into <file>\n\
1709   -pedantic                 Issue all warnings demanded by strict ANSI C\n\
1710   -traditional              Follow K&R pre-processor behaviour\n\
1711   -trigraphs                Support ANSI C trigraphs\n\
1712   -lang-c                   Assume that the input sources are in C\n\
1713   -lang-c89                 Assume that the input sources are in C89\n\
1714   -lang-c++                 Assume that the input sources are in C++\n\
1715   -lang-objc                Assume that the input sources are in ObjectiveC\n\
1716   -lang-objc++              Assume that the input sources are in ObjectiveC++\n\
1717   -lang-asm                 Assume that the input sources are in assembler\n\
1718   -lang-fortran             Assume that the input sources are in Fortran\n\
1719   -lang-chill               Assume that the input sources are in Chill\n\
1720   -std=<std name>           Specify the conformance standard; one of:\n\
1721                             gnu89, gnu99, c89, c99, iso9899:1990,\n\
1722                             iso9899:199409, iso9899:1999\n\
1723   -+                        Allow parsing of C++ style features\n\
1724   -w                        Inhibit warning messages\n\
1725   -Wtrigraphs               Warn if trigraphs are encountered\n\
1726   -Wno-trigraphs            Do not warn about trigraphs\n\
1727   -Wcomment{s}              Warn if one comment starts inside another\n\
1728   -Wno-comment{s}           Do not warn about comments\n\
1729   -Wtraditional             Warn if a macro argument is/would be turned into\n\
1730                              a string if -traditional is specified\n\
1731   -Wno-traditional          Do not warn about stringification\n\
1732   -Wundef                   Warn if an undefined macro is used by #if\n\
1733   -Wno-undef                Do not warn about testing undefined macros\n\
1734   -Wimport                  Warn about the use of the #import directive\n\
1735   -Wno-import               Do not warn about the use of #import\n\
1736   -Werror                   Treat all warnings as errors\n\
1737   -Wno-error                Do not treat warnings as errors\n\
1738   -Wall                     Enable all preprocessor warnings\n\
1739   -M                        Generate make dependencies\n\
1740   -MM                       As -M, but ignore system header files\n\
1741   -MD                       As -M, but put output in a .d file\n\
1742   -MMD                      As -MD, but ignore system header files\n\
1743   -MG                       Treat missing header file as generated files\n\
1744   -g                        Include #define and #undef directives in the output\n\
1745   -D<macro>                 Define a <macro> with string '1' as its value\n\
1746   -D<macro>=<val>           Define a <macro> with <val> as its value\n\
1747   -A<question> (<answer>)   Assert the <answer> to <question>\n\
1748   -U<macro>                 Undefine <macro> \n\
1749   -v                        Display the version number\n\
1750   -H                        Print the name of header files as they are used\n\
1751   -C                        Do not discard comments\n\
1752   -dM                       Display a list of macro definitions active at end\n\
1753   -dD                       Preserve macro definitions in output\n\
1754   -dN                       As -dD except that only the names are preserved\n\
1755   -dI                       Include #include directives in the output\n\
1756   -ifoutput                 Describe skipped code blocks in output \n\
1757   -P                        Do not generate #line directives\n\
1758   -$                        Do not allow '$' in identifiers\n\
1759   -remap                    Remap file names when including files.\n\
1760   -h or --help              Display this information\n\
1761 "), stdout);
1762 }