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