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