gcc/cpplib.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 87, 89, 92-6, 1997 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  In other words, you are welcome to use, share and improve this program.
  22  You are forbidden to forbid anyone else to use, share and improve
  23  what you give them.   Help stamp out software-hoarding!  */
  24
  25 #ifdef EMACS
  26 #define NO_SHORTNAMES
  27 #include "../src/config.h"
  28 #ifdef open
  29 #undef open
  30 #undef read
  31 #undef write
  32 #endif /* open */
  33 #endif /* EMACS */
  34
  35 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
  36    for the sake of machines with limited C compilers.  */
  37 #ifndef EMACS
  38 #include "config.h"
  39 #endif /* not EMACS */
  40
  41 #ifndef STANDARD_INCLUDE_DIR
  42 #define STANDARD_INCLUDE_DIR "/usr/include"
  43 #endif
  44
  45 #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE.  */
  46 #ifdef __STDC__
  47 #define PTR_INT_TYPE ptrdiff_t
  48 #else
  49 #define PTR_INT_TYPE long
  50 #endif
  51 #endif /* 0 */
  52
  53 #include "cpplib.h"
  54 #include "cpphash.h"
  55
  56 #ifndef STDC_VALUE
  57 #define STDC_VALUE 1
  58 #endif
  59
  60 /* By default, colon separates directories in a path.  */
  61 #ifndef PATH_SEPARATOR
  62 #define PATH_SEPARATOR ':'
  63 #endif
  64
  65 #include <ctype.h>
  66 #include <stdio.h>
  67 #include <signal.h>
  68 #ifdef __STDC__
  69 #include <stdlib.h>
  70 #endif
  71
  72 #ifndef VMS
  73 #ifndef USG
  74 #include <sys/time.h>           /* for __DATE__ and __TIME__ */
  75 #include <sys/resource.h>
  76 #else
  77 #include <sys/times.h>
  78 #include <time.h>
  79 #include <fcntl.h>
  80 #endif /* USG */
  81 #endif /* not VMS */
  82
  83 /* This defines "errno" properly for VMS, and gives us EACCES.  */
  84 #include <errno.h>
  85
  86 extern char *index ();
  87 extern char *rindex ();
  88
  89 #ifndef O_RDONLY
  90 #define O_RDONLY 0
  91 #endif
  92
  93 #undef MIN
  94 #undef MAX
  95 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
  96 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
  97
  98 /* Find the largest host integer type and set its size and type.  */
  99
 100 #ifndef HOST_BITS_PER_WIDE_INT
 101
 102 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
 103 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
 104 #define HOST_WIDE_INT long
 105 #else
 106 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
 107 #define HOST_WIDE_INT int
 108 #endif
 109
 110 #endif
 111
 112 #ifndef S_ISREG
 113 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 114 #endif
 115
 116 #ifndef S_ISDIR
 117 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 118 #endif
 119
 120 /* Define a generic NULL if one hasn't already been defined.  */
 121
 122 #ifndef NULL
 123 #define NULL 0
 124 #endif
 125
 126 #ifndef GENERIC_PTR
 127 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
 128 #define GENERIC_PTR void *
 129 #else
 130 #define GENERIC_PTR char *
 131 #endif
 132 #endif
 133
 134 #ifndef NULL_PTR
 135 #define NULL_PTR ((GENERIC_PTR) 0)
 136 #endif
 137
 138 #ifndef INCLUDE_LEN_FUDGE
 139 #define INCLUDE_LEN_FUDGE 0
 140 #endif
 141
 142 /* Symbols to predefine.  */
 143
 144 #ifdef CPP_PREDEFINES
 145 static char *predefs = CPP_PREDEFINES;
 146 #else
 147 static char *predefs = "";
 148 #endif
 149 \f
 150 /* We let tm.h override the types used here, to handle trivial differences
 151    such as the choice of unsigned int or long unsigned int for size_t.
 152    When machines start needing nontrivial differences in the size type,
 153    it would be best to do something here to figure out automatically
 154    from other information what type to use.  */
 155
 156 /* The string value for __SIZE_TYPE__.  */
 157
 158 #ifndef SIZE_TYPE
 159 #define SIZE_TYPE "long unsigned int"
 160 #endif
 161
 162 /* The string value for __PTRDIFF_TYPE__.  */
 163
 164 #ifndef PTRDIFF_TYPE
 165 #define PTRDIFF_TYPE "long int"
 166 #endif
 167
 168 /* The string value for __WCHAR_TYPE__.  */
 169
 170 #ifndef WCHAR_TYPE
 171 #define WCHAR_TYPE "int"
 172 #endif
 173 #define CPP_WCHAR_TYPE(PFILE) \
 174         (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
 175
 176 /* The string value for __USER_LABEL_PREFIX__ */
 177
 178 #ifndef USER_LABEL_PREFIX
 179 #define USER_LABEL_PREFIX ""
 180 #endif
 181
 182 /* The string value for __REGISTER_PREFIX__ */
 183
 184 #ifndef REGISTER_PREFIX
 185 #define REGISTER_PREFIX ""
 186 #endif
 187 \f
 188 /* In the definition of a #assert name, this structure forms
 189    a list of the individual values asserted.
 190    Each value is itself a list of "tokens".
 191    These are strings that are compared by name.  */
 192
 193 struct tokenlist_list {
 194   struct tokenlist_list *next;
 195   struct arglist *tokens;
 196 };
 197
 198 struct assertion_hashnode {
 199   struct assertion_hashnode *next;      /* double links for easy deletion */
 200   struct assertion_hashnode *prev;
 201   /* also, a back pointer to this node's hash
 202      chain is kept, in case the node is the head
 203      of the chain and gets deleted.  */
 204   struct assertion_hashnode **bucket_hdr;
 205   int length;                   /* length of token, for quick comparison */
 206   U_CHAR *name;                 /* the actual name */
 207   /* List of token-sequences.  */
 208   struct tokenlist_list *value;
 209 };
 210 \f
 211 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
 212 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
 213
 214 #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
 215 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
 216 #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
 217 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
 218 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
 219    (Note that it is false while we're expanding marco *arguments*.) */
 220 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->cleanup == macro_cleanup)
 221
 222 /* Move all backslash-newline pairs out of embarrassing places.
 223    Exchange all such pairs following BP
 224    with any potentially-embarrassing characters that follow them.
 225    Potentially-embarrassing characters are / and *
 226    (because a backslash-newline inside a comment delimiter
 227    would cause it not to be recognized).  */
 228
 229 #define NEWLINE_FIX \
 230   do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
 231
 232 /* Same, but assume we've already read the potential '\\' into C.  */
 233 #define NEWLINE_FIX1(C) do { \
 234     while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
 235   } while(0)
 236
 237 struct cpp_pending {
 238   struct cpp_pending *next;
 239   char *cmd;
 240   char *arg;
 241 };
 242
 243 /* Forward declarations.  */
 244
 245 extern char *xmalloc ();
 246
 247 static void add_import ();
 248 static void append_include_chain ();
 249 static void make_undef ();
 250 static void make_assertion ();
 251 static void path_include ();
 252 static void initialize_builtins ();
 253 static void initialize_char_syntax ();
 254 static void dump_arg_n ();
 255 static void dump_defn_1 ();
 256 extern void delete_macro ();
 257 static void trigraph_pcp ();
 258 static int finclude ();
 259 static void validate_else ();
 260 static int comp_def_part ();
 261 #ifdef abort
 262 extern void fancy_abort ();
 263 #endif
 264 static void pipe_closed ();
 265 static void print_containing_files ();
 266 static int lookup_import ();
 267 static int redundant_include_p ();
 268 static is_system_include ();
 269 static struct file_name_map *read_name_map ();
 270 static char *read_filename_string ();
 271 static int open_include_file ();
 272 static int check_preconditions ();
 273 static void pcfinclude ();
 274 static void pcstring_used ();
 275 static int check_macro_name ();
 276 static int compare_defs ();
 277 static int compare_token_lists ();
 278 static HOST_WIDE_INT eval_if_expression ();
 279 static int change_newlines ();
 280 extern int hashf ();
 281 static int file_size_and_mode ();
 282 static struct arglist *read_token_list ();
 283 static void free_token_list ();
 284 static int safe_read ();
 285 static void push_macro_expansion PARAMS ((cpp_reader *,
 286                                           U_CHAR *, int, HASHNODE *));
 287 static struct cpp_pending *nreverse_pending PARAMS ((struct cpp_pending *));
 288 extern char *xrealloc ();
 289 static char *xcalloc ();
 290 static char *savestring ();
 291
 292 static void conditional_skip ();
 293 static void skip_if_group ();
 294
 295 /* Last arg to output_line_command.  */
 296 enum file_change_code {same_file, enter_file, leave_file};
 297
 298 /* External declarations.  */
 299
 300 extern HOST_WIDE_INT cpp_parse_expr PARAMS ((cpp_reader *));
 301
 302 extern char *getenv ();
 303 extern FILE *fdopen ();
 304 extern char *version_string;
 305 extern struct tm *localtime ();
 306
 307 /* These functions are declared to return int instead of void since they
 308    are going to be placed in a table and some old compilers have trouble with
 309    pointers to functions returning void.  */
 310
 311 static int do_define ();
 312 static int do_line ();
 313 static int do_include ();
 314 static int do_undef ();
 315 static int do_error ();
 316 static int do_pragma ();
 317 static int do_ident ();
 318 static int do_if ();
 319 static int do_xifdef ();
 320 static int do_else ();
 321 static int do_elif ();
 322 static int do_endif ();
 323 static int do_sccs ();
 324 static int do_once ();
 325 static int do_assert ();
 326 static int do_unassert ();
 327 static int do_warning ();
 328 \f
 329 struct file_name_list
 330   {
 331     struct file_name_list *next;
 332     char *fname;
 333     /* If the following is nonzero, it is a macro name.
 334        Don't include the file again if that macro is defined.  */
 335     U_CHAR *control_macro;
 336     /* If the following is nonzero, it is a C-language system include
 337        directory.  */
 338     int c_system_include_path;
 339     /* Mapping of file names for this directory.  */
 340     struct file_name_map *name_map;
 341     /* Non-zero if name_map is valid.  */
 342     int got_name_map;
 343   };
 344
 345 /* If a buffer's dir field is SELF_DIR_DUMMY, it means the file was found
 346    via the same directory as the file that #included it.  */
 347 #define SELF_DIR_DUMMY ((struct file_name_list *) (~0))
 348
 349 /* #include "file" looks in source file dir, then stack.  */
 350 /* #include <file> just looks in the stack.  */
 351 /* -I directories are added to the end, then the defaults are added.  */
 352 /* The */
 353 static struct default_include {
 354   char *fname;                  /* The name of the directory.  */
 355   int cplusplus;                /* Only look here if we're compiling C++.  */
 356   int cxx_aware;                /* Includes in this directory don't need to
 357                                    be wrapped in extern "C" when compiling
 358                                    C++.  */
 359 } include_defaults_array[]
 360 #ifdef INCLUDE_DEFAULTS
 361   = INCLUDE_DEFAULTS;
 362 #else
 363   = {
 364     /* Pick up GNU C++ specific include files.  */
 365     { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
 366     { OLD_GPLUSPLUS_INCLUDE_DIR, 1, 1 },
 367 #ifdef CROSS_COMPILE
 368     /* This is the dir for fixincludes.  Put it just before
 369        the files that we fix.  */
 370     { GCC_INCLUDE_DIR, 0, 0 },
 371     /* For cross-compilation, this dir name is generated
 372        automatically in Makefile.in.  */
 373     { CROSS_INCLUDE_DIR, 0, 0 },
 374 #ifdef TOOL_INCLUDE_DIR
 375     /* This is another place that the target system's headers might be.  */
 376     { TOOL_INCLUDE_DIR, 0, 1 },
 377 #endif
 378 #else /* not CROSS_COMPILE */
 379 #ifdef LOCAL_INCLUDE_DIR
 380     /* This should be /usr/local/include and should come before
 381        the fixincludes-fixed header files.  */
 382     { LOCAL_INCLUDE_DIR, 0, 1 },
 383 #endif
 384 #ifdef TOOL_INCLUDE_DIR
 385     /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
 386        Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h.  */
 387     { TOOL_INCLUDE_DIR, 0, 1 },
 388 #endif
 389     /* This is the dir for fixincludes.  Put it just before
 390        the files that we fix.  */
 391     { GCC_INCLUDE_DIR, 0, 0 },
 392     /* Some systems have an extra dir of include files.  */
 393 #ifdef SYSTEM_INCLUDE_DIR
 394     { SYSTEM_INCLUDE_DIR, 0, 0 },
 395 #endif
 396     { STANDARD_INCLUDE_DIR, 0, 0 },
 397 #endif /* not CROSS_COMPILE */
 398     { 0, 0, 0 }
 399     };
 400 #endif /* no INCLUDE_DEFAULTS */
 401
 402 /* `struct directive' defines one #-directive, including how to handle it.  */
 403
 404 struct directive {
 405   int length;                   /* Length of name */
 406   int (*func)();                /* Function to handle directive */
 407   char *name;                   /* Name of directive */
 408   enum node_type type;          /* Code which describes which directive.  */
 409   char command_reads_line;      /* One if rest of line is read by func.  */
 410   char traditional_comments;    /* Nonzero: keep comments if -traditional.  */
 411   char pass_thru;               /* Copy preprocessed directive to output file.*/
 412 };
 413
 414 /* Here is the actual list of #-directives, most-often-used first.
 415    The initialize_builtins function assumes #define is the very first.  */
 416
 417 static struct directive directive_table[] = {
 418   {  6, do_define, "define", T_DEFINE, 0, 1},
 419   {  5, do_xifdef, "ifdef", T_IFDEF, 1},
 420   {  6, do_xifdef, "ifndef", T_IFNDEF, 1},
 421   {  7, do_include, "include", T_INCLUDE, 1},
 422   { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
 423   {  6, do_include, "import", T_IMPORT, 1},
 424   {  5, do_endif, "endif", T_ENDIF, 1},
 425   {  4, do_else, "else", T_ELSE, 1},
 426   {  2, do_if, "if", T_IF, 1},
 427   {  4, do_elif, "elif", T_ELIF, 1},
 428   {  5, do_undef, "undef", T_UNDEF},
 429   {  5, do_error, "error", T_ERROR},
 430   {  7, do_warning, "warning", T_WARNING},
 431   {  6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
 432   {  4, do_line, "line", T_LINE, 1},
 433   {  5, do_ident, "ident", T_IDENT, 1, 0, 1},
 434 #ifdef SCCS_DIRECTIVE
 435   {  4, do_sccs, "sccs", T_SCCS},
 436 #endif
 437   {  6, do_assert, "assert", T_ASSERT, 1},
 438   {  8, do_unassert, "unassert", T_UNASSERT, 1},
 439   {  -1, 0, "", T_UNUSED},
 440 };
 441 \f
 442 /* table to tell if char can be part of a C identifier.  */
 443 U_CHAR is_idchar[256];
 444 /* table to tell if char can be first char of a c identifier.  */
 445 U_CHAR is_idstart[256];
 446 /* table to tell if c is horizontal space.  */
 447 U_CHAR is_hor_space[256];
 448 /* table to tell if c is horizontal or vertical space.  */
 449 static U_CHAR is_space[256];
 450
 451 /* Initialize syntactic classifications of characters.  */
 452
 453 static void
 454 initialize_char_syntax (opts)
 455      struct cpp_options *opts;
 456 {
 457   register int i;
 458
 459   /*
 460    * Set up is_idchar and is_idstart tables.  These should be
 461    * faster than saying (is_alpha (c) || c == '_'), etc.
 462    * Set up these things before calling any routines tthat
 463    * refer to them.
 464    */
 465   for (i = 'a'; i <= 'z'; i++) {
 466     is_idchar[i - 'a' + 'A'] = 1;
 467     is_idchar[i] = 1;
 468     is_idstart[i - 'a' + 'A'] = 1;
 469     is_idstart[i] = 1;
 470   }
 471   for (i = '0'; i <= '9'; i++)
 472     is_idchar[i] = 1;
 473   is_idchar['_'] = 1;
 474   is_idstart['_'] = 1;
 475   is_idchar['$'] = opts->dollars_in_ident;
 476   is_idstart['$'] = opts->dollars_in_ident;
 477
 478   /* horizontal space table */
 479   is_hor_space[' '] = 1;
 480   is_hor_space['\t'] = 1;
 481   is_hor_space['\v'] = 1;
 482   is_hor_space['\f'] = 1;
 483   is_hor_space['\r'] = 1;
 484
 485   is_space[' '] = 1;
 486   is_space['\t'] = 1;
 487   is_space['\v'] = 1;
 488   is_space['\f'] = 1;
 489   is_space['\n'] = 1;
 490   is_space['\r'] = 1;
 491 }
 492
 493
 494 /* Place into PFILE a quoted string representing the string SRC.
 495    Caller must reserve enough space in pfile->token_buffer.  */
 496
 497 static void
 498 quote_string (pfile, src)
 499      cpp_reader *pfile;
 500      char *src;
 501 {
 502   U_CHAR c;
 503
 504   CPP_PUTC_Q (pfile, '\"');
 505   for (;;)
 506     switch ((c = *src++))
 507       {
 508       default:
 509         if (isprint (c))
 510           CPP_PUTC_Q (pfile, c);
 511         else
 512           {
 513             sprintf (CPP_PWRITTEN (pfile), "\\%03o", c);
 514             CPP_ADJUST_WRITTEN (pfile, 4);
 515           }
 516         break;
 517
 518       case '\"':
 519       case '\\':
 520         CPP_PUTC_Q (pfile, '\\');
 521         CPP_PUTC_Q (pfile, c);
 522         break;
 523
 524       case '\0':
 525         CPP_PUTC_Q (pfile, '\"');
 526         CPP_NUL_TERMINATE_Q (pfile);
 527         return;
 528       }
 529 }
 530
 531 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars.  */
 532
 533 void
 534 cpp_grow_buffer (pfile, n)
 535      cpp_reader *pfile;
 536      long n;
 537 {
 538   long old_written = CPP_WRITTEN (pfile);
 539   pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
 540   pfile->token_buffer = (U_CHAR *)
 541     xrealloc(pfile->token_buffer, pfile->token_buffer_size);
 542   CPP_SET_WRITTEN (pfile, old_written);
 543 }
 544
 545 \f
 546 /*
 547  * process a given definition string, for initialization
 548  * If STR is just an identifier, define it with value 1.
 549  * If STR has anything after the identifier, then it should
 550  * be identifier=definition.
 551  */
 552
 553 void
 554 cpp_define (pfile, str)
 555      cpp_reader *pfile;
 556      U_CHAR *str;
 557 {
 558   U_CHAR *buf, *p;
 559
 560   buf = str;
 561   p = str;
 562   if (!is_idstart[*p])
 563     {
 564       cpp_error (pfile, "malformed option `-D %s'", str);
 565       return;
 566     }
 567   while (is_idchar[*++p])
 568     ;
 569   if (*p == 0)
 570     {
 571       buf = (U_CHAR *) alloca (p - buf + 4);
 572       strcpy ((char *)buf, str);
 573       strcat ((char *)buf, " 1");
 574     }
 575   else if (*p != '=')
 576     {
 577       cpp_error (pfile, "malformed option `-D %s'", str);
 578       return;
 579     }
 580   else
 581     {
 582       U_CHAR *q;
 583       /* Copy the entire option so we can modify it.  */
 584       buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
 585       strncpy (buf, str, p - str);
 586       /* Change the = to a space.  */
 587       buf[p - str] = ' ';
 588       /* Scan for any backslash-newline and remove it.  */
 589       p++;
 590       q = &buf[p - str];
 591       while (*p)
 592         {
 593       if (*p == '\\' && p[1] == '\n')
 594         p += 2;
 595       else
 596         *q++ = *p++;
 597     }
 598     *q = 0;
 599   }
 600
 601   do_define (pfile, NULL, buf, buf + strlen (buf));
 602 }
 603 \f
 604 /* Process the string STR as if it appeared as the body of a #assert.
 605    OPTION is the option name for which STR was the argument.  */
 606
 607 static void
 608 make_assertion (pfile, option, str)
 609      cpp_reader *pfile;
 610      char *option;
 611      U_CHAR *str;
 612 {
 613   struct directive *kt;
 614   U_CHAR *buf, *p, *q;
 615
 616   /* Copy the entire option so we can modify it.  */
 617   buf = (U_CHAR *) alloca (strlen (str) + 1);
 618   strcpy ((char *) buf, str);
 619   /* Scan for any backslash-newline and remove it.  */
 620   p = q = buf;
 621   while (*p) {
 622 #if 0
 623     if (*p == '\\' && p[1] == '\n')
 624       p += 2;
 625     else
 626 #endif
 627       *q++ = *p++;
 628   }
 629   *q = 0;
 630
 631   p = buf;
 632   if (!is_idstart[*p]) {
 633     cpp_error (pfile, "malformed option `%s %s'", option, str);
 634     return;
 635   }
 636   while (is_idchar[*++p])
 637     ;
 638   while (*p == ' ' || *p == '\t') p++;
 639   if (! (*p == 0 || *p == '(')) {
 640     cpp_error (pfile, "malformed option `%s %s'", option, str);
 641     return;
 642   }
 643
 644   if (cpp_push_buffer (pfile, buf, strlen (buf)) != NULL)
 645     {
 646       do_assert (pfile, NULL, NULL, NULL);
 647       cpp_pop_buffer (pfile);
 648     }
 649 }
 650 \f
 651 /* Append a chain of `struct file_name_list's
 652    to the end of the main include chain.
 653    FIRST is the beginning of the chain to append, and LAST is the end.  */
 654
 655 static void
 656 append_include_chain (pfile, first, last)
 657      cpp_reader *pfile;
 658      struct file_name_list *first, *last;
 659 {
 660   struct cpp_options *opts = CPP_OPTIONS (pfile);
 661   struct file_name_list *dir;
 662
 663   if (!first || !last)
 664     return;
 665
 666   if (opts->include == 0)
 667     opts->include = first;
 668   else
 669     opts->last_include->next = first;
 670
 671   if (opts->first_bracket_include == 0)
 672     opts->first_bracket_include = first;
 673
 674   for (dir = first; ; dir = dir->next) {
 675     int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
 676     if (len > pfile->max_include_len)
 677       pfile->max_include_len = len;
 678     if (dir == last)
 679       break;
 680   }
 681
 682   last->next = NULL;
 683   opts->last_include = last;
 684 }
 685 \f
 686 /* Add output to `deps_buffer' for the -M switch.
 687    STRING points to the text to be output.
 688    SPACER is ':' for targets, ' ' for dependencies, zero for text
 689    to be inserted literally.  */
 690
 691 static void
 692 deps_output (pfile, string, spacer)
 693      cpp_reader *pfile;
 694      char *string;
 695      int spacer;
 696 {
 697   int size = strlen (string);
 698
 699   if (size == 0)
 700     return;
 701
 702 #ifndef MAX_OUTPUT_COLUMNS
 703 #define MAX_OUTPUT_COLUMNS 72
 704 #endif
 705   if (spacer
 706       && pfile->deps_column > 0
 707       && (pfile->deps_column + size) > MAX_OUTPUT_COLUMNS)
 708     {
 709       deps_output (pfile, " \\\n  ", 0);
 710       pfile->deps_column = 0;
 711     }
 712
 713   if (pfile->deps_size + size + 8 > pfile->deps_allocated_size)
 714     {
 715       pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
 716       pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
 717                                               pfile->deps_allocated_size);
 718     }
 719   if (spacer == ' ' && pfile->deps_column > 0)
 720     pfile->deps_buffer[pfile->deps_size++] = ' ';
 721   bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
 722   pfile->deps_size += size;
 723   pfile->deps_column += size;
 724   if (spacer == ':')
 725     pfile->deps_buffer[pfile->deps_size++] = ':';
 726   pfile->deps_buffer[pfile->deps_size] = 0;
 727 }
 728 \f
 729 /* Given a colon-separated list of file names PATH,
 730    add all the names to the search path for include files.  */
 731
 732 static void
 733 path_include (pfile, path)
 734      cpp_reader *pfile;
 735      char *path;
 736 {
 737   char *p;
 738
 739   p = path;
 740
 741   if (*p)
 742     while (1) {
 743       char *q = p;
 744       char *name;
 745       struct file_name_list *dirtmp;
 746
 747       /* Find the end of this name.  */
 748       while (*q != 0 && *q != PATH_SEPARATOR) q++;
 749       if (p == q) {
 750         /* An empty name in the path stands for the current directory.  */
 751         name = (char *) xmalloc (2);
 752         name[0] = '.';
 753         name[1] = 0;
 754       } else {
 755         /* Otherwise use the directory that is named.  */
 756         name = (char *) xmalloc (q - p + 1);
 757         bcopy (p, name, q - p);
 758         name[q - p] = 0;
 759       }
 760
 761       dirtmp = (struct file_name_list *)
 762         xmalloc (sizeof (struct file_name_list));
 763       dirtmp->next = 0;         /* New one goes on the end */
 764       dirtmp->control_macro = 0;
 765       dirtmp->c_system_include_path = 0;
 766       dirtmp->fname = name;
 767       dirtmp->got_name_map = 0;
 768       append_include_chain (pfile, dirtmp, dirtmp);
 769
 770       /* Advance past this name.  */
 771       p = q;
 772       if (*p == 0)
 773         break;
 774       /* Skip the colon.  */
 775       p++;
 776     }
 777 }
 778 \f
 779 void
 780 cpp_options_init (opts)
 781      cpp_options *opts;
 782 {
 783   bzero ((char *) opts, sizeof *opts);
 784   opts->in_fname = NULL;
 785   opts->out_fname = NULL;
 786
 787   /* Initialize is_idchar to allow $.  */
 788   opts->dollars_in_ident = 1;
 789   initialize_char_syntax (opts);
 790
 791   opts->no_line_commands = 0;
 792   opts->no_trigraphs = 1;
 793   opts->put_out_comments = 0;
 794   opts->print_include_names = 0;
 795   opts->dump_macros = dump_none;
 796   opts->no_output = 0;
 797   opts->cplusplus = 0;
 798   opts->cplusplus_comments = 0;
 799
 800   opts->verbose = 0;
 801   opts->objc = 0;
 802   opts->lang_asm = 0;
 803   opts->for_lint = 0;
 804   opts->chill = 0;
 805   opts->pedantic_errors = 0;
 806   opts->inhibit_warnings = 0;
 807   opts->warn_comments = 0;
 808   opts->warn_import = 1;
 809   opts->warnings_are_errors = 0;
 810 }
 811
 812 enum cpp_token
 813 null_underflow (pfile)
 814      cpp_reader *pfile;
 815 {
 816   return CPP_EOF;
 817 }
 818
 819 int
 820 null_cleanup (pbuf, pfile)
 821      cpp_buffer *pbuf;
 822      cpp_reader *pfile;
 823 {
 824   return 0;
 825 }
 826
 827 int
 828 macro_cleanup (pbuf, pfile)
 829      cpp_buffer *pbuf;
 830      cpp_reader *pfile;
 831 {
 832   HASHNODE *macro = (HASHNODE *) pbuf->data;
 833   if (macro->type == T_DISABLED)
 834     macro->type = T_MACRO;
 835   if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
 836     free (pbuf->buf);
 837   return 0;
 838 }
 839
 840 int
 841 file_cleanup (pbuf, pfile)
 842      cpp_buffer *pbuf;
 843      cpp_reader *pfile;
 844 {
 845   if (pbuf->buf)
 846     {
 847       free (pbuf->buf);
 848       pbuf->buf = 0;
 849     }
 850   return 0;
 851 }
 852
 853 /* Assuming we have read '/'.
 854    If this is the start of a comment (followed by '*' or '/'),
 855    skip to the end of the comment, and return ' '.
 856    Return EOF if we reached the end of file before the end of the comment.
 857    If not the start of a comment, return '/'.  */
 858
 859 static int
 860 skip_comment (pfile, linep)
 861      cpp_reader *pfile;
 862      long *linep;
 863 {
 864   int c = 0;
 865   while (PEEKC() == '\\' && PEEKN(1) == '\n')
 866     {
 867       if (linep)
 868         (*linep)++;
 869       FORWARD(2);
 870     }
 871   if (PEEKC() == '*')
 872     {
 873       FORWARD(1);
 874       for (;;)
 875         {
 876           int prev_c = c;
 877           c = GETC ();
 878           if (c == EOF)
 879             return EOF;
 880           while (c == '\\' && PEEKC() == '\n')
 881             {
 882               if (linep)
 883                 (*linep)++;
 884               FORWARD(1), c = GETC();
 885             }
 886           if (prev_c == '*' && c == '/')
 887             return ' ';
 888           if (c == '\n' && linep)
 889             (*linep)++;
 890         }
 891     }
 892   else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
 893     {
 894       FORWARD(1);
 895       for (;;)
 896         {
 897           c = GETC ();
 898           if (c == EOF)
 899             return ' '; /* Allow // to be terminated by EOF.  */
 900           while (c == '\\' && PEEKC() == '\n')
 901             {
 902               FORWARD(1);
 903               c = GETC();
 904               if (linep)
 905                 (*linep)++;
 906             }
 907           if (c == '\n')
 908             {
 909               /* Don't consider final '\n' to be part of comment.  */
 910               FORWARD(-1);
 911               return ' ';
 912             }
 913         }
 914     }
 915   else
 916     return '/';
 917 }
 918
 919 /* Skip whitespace \-newline and comments.  Does not macro-expand.  */
 920
 921 void
 922 cpp_skip_hspace (pfile)
 923      cpp_reader *pfile;
 924 {
 925   while (1)
 926     {
 927       int c = PEEKC();
 928       if (c == EOF)
 929         return; /* FIXME */
 930       if (is_hor_space[c])
 931         {
 932           if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
 933             cpp_pedwarn (pfile, "%s in preprocessing directive",
 934                          c == '\f' ? "formfeed" : "vertical tab");
 935           FORWARD(1);
 936         }
 937       else if (c == '/')
 938         {
 939           FORWARD (1);
 940           c = skip_comment (pfile, NULL);
 941           if (c == '/')
 942             FORWARD(-1);
 943           if (c == EOF || c == '/')
 944             return;
 945         }
 946       else if (c == '\\' && PEEKN(1) == '\n') {
 947         FORWARD(2);
 948       }
 949       else if (c == '@' && CPP_BUFFER (pfile)->has_escapes
 950                && is_hor_space[PEEKN(1)])
 951         FORWARD(2);
 952       else return;
 953     }
 954 }
 955
 956 /* Read the rest of the current line.
 957    The line is appended to PFILE's output buffer.  */
 958
 959 static void
 960 copy_rest_of_line (pfile)
 961      cpp_reader *pfile;
 962 {
 963   struct cpp_options *opts = CPP_OPTIONS (pfile);
 964   for (;;)
 965     {
 966       int c = GETC();
 967       int nextc;
 968       switch (c)
 969         {
 970         case EOF:
 971           goto end_directive;
 972         case '\\':
 973           if (PEEKC() == '\n')
 974             {
 975               FORWARD (1);
 976               continue;
 977             }
 978         case '\'':
 979         case '\"':
 980           goto scan_directive_token;
 981           break;
 982         case '/':
 983           nextc = PEEKC();
 984           if (nextc == '*' || (opts->cplusplus_comments && nextc == '*'))
 985             goto scan_directive_token;
 986           break;
 987         case '\f':
 988         case '\v':
 989           if (CPP_PEDANTIC (pfile))
 990             cpp_pedwarn (pfile, "%s in preprocessing directive",
 991                          c == '\f' ? "formfeed" : "vertical tab");
 992           break;
 993
 994         case '\n':
 995           FORWARD(-1);
 996           goto end_directive;
 997         scan_directive_token:
 998           FORWARD(-1);
 999           cpp_get_token (pfile);
1000           continue;
1001         }
1002       CPP_PUTC (pfile, c);
1003     }
1004  end_directive: ;
1005   CPP_NUL_TERMINATE (pfile);
1006 }
1007
1008 void
1009 skip_rest_of_line (pfile)
1010      cpp_reader *pfile;
1011 {
1012   long old = CPP_WRITTEN (pfile);
1013   copy_rest_of_line (pfile);
1014   CPP_SET_WRITTEN (pfile, old);
1015 }
1016
1017 /* Handle a possible # directive.
1018    '#' has already been read.  */
1019
1020 int
1021 handle_directive (pfile)
1022      cpp_reader *pfile;
1023 { int c;
1024   register struct directive *kt;
1025   int ident_length;
1026   long after_ident;
1027   U_CHAR *ident, *line_end;
1028   long old_written = CPP_WRITTEN (pfile);
1029
1030   cpp_skip_hspace (pfile);
1031
1032   c = PEEKC ();
1033   if (c >= '0' && c <= '9')
1034     {
1035       /* Handle # followed by a line number.  */
1036       if (CPP_PEDANTIC (pfile))
1037         cpp_pedwarn (pfile, "`#' followed by integer");
1038       do_line (pfile, NULL);
1039       goto done_a_directive;
1040     }
1041
1042   /* Now find the directive name.  */
1043   CPP_PUTC (pfile, '#');
1044   parse_name (pfile, GETC());
1045   ident = pfile->token_buffer + old_written + 1;
1046   ident_length = CPP_PWRITTEN (pfile) - ident;
1047   if (ident_length == 0 && PEEKC() == '\n')
1048     {
1049       /* A line of just `#' becomes blank.  */
1050       goto done_a_directive;
1051     }
1052
1053 #if 0
1054   if (ident_length == 0 || !is_idstart[*ident]) {
1055     U_CHAR *p = ident;
1056     while (is_idchar[*p]) {
1057       if (*p < '0' || *p > '9')
1058         break;
1059       p++;
1060     }
1061     /* Avoid error for `###' and similar cases unless -pedantic.  */
1062     if (p == ident) {
1063       while (*p == '#' || is_hor_space[*p]) p++;
1064       if (*p == '\n') {
1065         if (pedantic && !lang_asm)
1066           cpp_warning (pfile, "invalid preprocessor directive");
1067         return 0;
1068       }
1069     }
1070
1071     if (!lang_asm)
1072       cpp_error (pfile, "invalid preprocessor directive name");
1073
1074     return 0;
1075   }
1076 #endif
1077   /*
1078    * Decode the keyword and call the appropriate expansion
1079    * routine, after moving the input pointer up to the next line.
1080    */
1081   for (kt = directive_table; ; kt++) {
1082     if (kt->length <= 0)
1083       goto not_a_directive;
1084     if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length))
1085       break;
1086   }
1087
1088   if (kt->command_reads_line)
1089     after_ident = 0;
1090   else
1091     {
1092       /* Nonzero means do not delete comments within the directive.
1093          #define needs this when -traditional.  */
1094         int comments = CPP_TRADITIONAL (pfile) && kt->traditional_comments;
1095         int save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
1096         CPP_OPTIONS (pfile)->put_out_comments = comments;
1097         after_ident = CPP_WRITTEN (pfile);
1098         copy_rest_of_line (pfile);
1099         CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
1100     }
1101
1102   /* For #pragma and #define, we may want to pass through the directive.
1103      Other directives may create output, but we don't want the directive
1104      itself out, so we pop it now.  For example #include may write a #line
1105      command (see comment in do_include), and conditionals may emit
1106      #failed ... #endfailed stuff.  But note that popping the buffer
1107      means the parameters to kt->func may point after pfile->limit
1108      so these parameters are invalid as soon as something gets appended
1109      to the token_buffer.  */
1110
1111   line_end = CPP_PWRITTEN (pfile);
1112   if (!kt->pass_thru && kt->type != T_DEFINE)
1113     CPP_SET_WRITTEN (pfile, old_written);
1114
1115   (*kt->func) (pfile, kt, pfile->token_buffer + after_ident, line_end);
1116   if (kt->pass_thru
1117       || (kt->type == T_DEFINE
1118           && CPP_OPTIONS (pfile)->dump_macros == dump_definitions))
1119     {
1120       /* Just leave the entire #define in the output stack.  */
1121     }
1122   else if (kt->type == T_DEFINE
1123            && CPP_OPTIONS (pfile)->dump_macros == dump_names)
1124     {
1125       U_CHAR *p = pfile->token_buffer + old_written + 7;  /* Skip "#define". */
1126       SKIP_WHITE_SPACE (p);
1127       while (is_idchar[*p]) p++;
1128       pfile->limit = p;
1129       CPP_PUTC (pfile, '\n');
1130     }
1131   else if (kt->type == T_DEFINE)
1132     CPP_SET_WRITTEN (pfile, old_written);
1133  done_a_directive:
1134   return 1;
1135
1136  not_a_directive:
1137   return 0;
1138 }
1139
1140 /* Pass a directive through to the output file.
1141    BUF points to the contents of the directive, as a contiguous string.
1142    LIMIT points to the first character past the end of the directive.
1143    KEYWORD is the keyword-table entry for the directive.  */
1144
1145 static void
1146 pass_thru_directive (buf, limit, pfile, keyword)
1147      U_CHAR *buf, *limit;
1148      cpp_reader *pfile;
1149      struct directive *keyword;
1150 {
1151   register unsigned keyword_length = keyword->length;
1152
1153   CPP_RESERVE (pfile, 1 + keyword_length + (limit - buf));
1154   CPP_PUTC_Q (pfile, '#');
1155   CPP_PUTS_Q (pfile, keyword->name, keyword_length);
1156   if (limit != buf && buf[0] != ' ')
1157     CPP_PUTC_Q (pfile, ' ');
1158   CPP_PUTS_Q (pfile, buf, limit - buf);
1159 #if 0
1160   CPP_PUTS_Q (pfile, '\n');
1161   /* Count the line we have just made in the output,
1162      to get in sync properly.  */
1163   pfile->lineno++;
1164 #endif
1165 }
1166 \f
1167 /* The arglist structure is built by do_define to tell
1168    collect_definition where the argument names begin.  That
1169    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
1170    would contain pointers to the strings x, y, and z.
1171    Collect_definition would then build a DEFINITION node,
1172    with reflist nodes pointing to the places x, y, and z had
1173    appeared.  So the arglist is just convenience data passed
1174    between these two routines.  It is not kept around after
1175    the current #define has been processed and entered into the
1176    hash table.  */
1177
1178 struct arglist {
1179   struct arglist *next;
1180   U_CHAR *name;
1181   int length;
1182   int argno;
1183   char rest_args;
1184 };
1185
1186 /* Read a replacement list for a macro with parameters.
1187    Build the DEFINITION structure.
1188    Reads characters of text starting at BUF until END.
1189    ARGLIST specifies the formal parameters to look for
1190    in the text of the definition; NARGS is the number of args
1191    in that list, or -1 for a macro name that wants no argument list.
1192    MACRONAME is the macro name itself (so we can avoid recursive expansion)
1193    and NAMELEN is its length in characters.
1194
1195    Note that comments, backslash-newlines, and leading white space
1196    have already been deleted from the argument.  */
1197
1198 static DEFINITION *
1199 collect_expansion (pfile, buf, limit, nargs, arglist)
1200      cpp_reader *pfile;
1201      U_CHAR *buf, *limit;
1202      int nargs;
1203      struct arglist *arglist;
1204 {
1205   DEFINITION *defn;
1206   register U_CHAR *p, *lastp, *exp_p;
1207   struct reflist *endpat = NULL;
1208   /* Pointer to first nonspace after last ## seen.  */
1209   U_CHAR *concat = 0;
1210   /* Pointer to first nonspace after last single-# seen.  */
1211   U_CHAR *stringify = 0;
1212   int maxsize;
1213   int expected_delimiter = '\0';
1214
1215   /* Scan thru the replacement list, ignoring comments and quoted
1216      strings, picking up on the macro calls.  It does a linear search
1217      thru the arg list on every potential symbol.  Profiling might say
1218      that something smarter should happen.  */
1219
1220   if (limit < buf)
1221     abort ();
1222
1223   /* Find the beginning of the trailing whitespace.  */
1224   p = buf;
1225   while (p < limit && is_space[limit[-1]]) limit--;
1226
1227   /* Allocate space for the text in the macro definition.
1228      Leading and trailing whitespace chars need 2 bytes each.
1229      Each other input char may or may not need 1 byte,
1230      so this is an upper bound.  The extra 5 are for invented
1231      leading and trailing newline-marker and final null.  */
1232   maxsize = (sizeof (DEFINITION)
1233              + (limit - p) + 5);
1234   /* Occurrences of '@' get doubled, so allocate extra space for them.  */
1235   while (p < limit)
1236     if (*p++ == '@')
1237       maxsize++;
1238   defn = (DEFINITION *) xcalloc (1, maxsize);
1239
1240   defn->nargs = nargs;
1241   exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
1242   lastp = exp_p;
1243
1244   p = buf;
1245
1246   /* Add one initial space escape-marker to prevent accidental
1247      token-pasting (often removed by macroexpand).  */
1248   *exp_p++ = '@';
1249   *exp_p++ = ' ';
1250
1251   if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
1252     cpp_error (pfile, "`##' at start of macro definition");
1253     p += 2;
1254   }
1255
1256   /* Process the main body of the definition.  */
1257   while (p < limit) {
1258     int skipped_arg = 0;
1259     register U_CHAR c = *p++;
1260
1261     *exp_p++ = c;
1262
1263     if (!CPP_TRADITIONAL (pfile)) {
1264       switch (c) {
1265       case '\'':
1266       case '\"':
1267         if (expected_delimiter != '\0') {
1268           if (c == expected_delimiter)
1269             expected_delimiter = '\0';
1270         } else
1271           expected_delimiter = c;
1272         break;
1273
1274       case '\\':
1275         if (p < limit && expected_delimiter) {
1276           /* In a string, backslash goes through
1277              and makes next char ordinary.  */
1278           *exp_p++ = *p++;
1279         }
1280         break;
1281
1282       case '@':
1283         /* An '@' in a string or character constant stands for itself,
1284            and does not need to be escaped.  */
1285         if (!expected_delimiter)
1286           *exp_p++ = c;
1287         break;
1288
1289       case '#':
1290         /* # is ordinary inside a string.  */
1291         if (expected_delimiter)
1292           break;
1293         if (p < limit && *p == '#') {
1294           /* ##: concatenate preceding and following tokens.  */
1295           /* Take out the first #, discard preceding whitespace.  */
1296           exp_p--;
1297           while (exp_p > lastp && is_hor_space[exp_p[-1]])
1298             --exp_p;
1299           /* Skip the second #.  */
1300           p++;
1301           /* Discard following whitespace.  */
1302           SKIP_WHITE_SPACE (p);
1303           concat = p;
1304           if (p == limit)
1305             cpp_error (pfile, "`##' at end of macro definition");
1306         } else if (nargs >= 0) {
1307           /* Single #: stringify following argument ref.
1308              Don't leave the # in the expansion.  */
1309           exp_p--;
1310           SKIP_WHITE_SPACE (p);
1311           if (p == limit || ! is_idstart[*p]
1312               || (*p == 'L' && p + 1 < limit && (p[1] == '\'' || p[1] == '"')))
1313             cpp_error (pfile,
1314                      "`#' operator is not followed by a macro argument name");
1315           else
1316             stringify = p;
1317         }
1318         break;
1319       }
1320     } else {
1321       /* In -traditional mode, recognize arguments inside strings and
1322          and character constants, and ignore special properties of #.
1323          Arguments inside strings are considered "stringified", but no
1324          extra quote marks are supplied.  */
1325       switch (c) {
1326       case '\'':
1327       case '\"':
1328         if (expected_delimiter != '\0') {
1329           if (c == expected_delimiter)
1330             expected_delimiter = '\0';
1331         } else
1332           expected_delimiter = c;
1333         break;
1334
1335       case '\\':
1336         /* Backslash quotes delimiters and itself, but not macro args.  */
1337         if (expected_delimiter != 0 && p < limit
1338             && (*p == expected_delimiter || *p == '\\')) {
1339           *exp_p++ = *p++;
1340           continue;
1341         }
1342         break;
1343
1344       case '/':
1345         if (expected_delimiter != '\0') /* No comments inside strings.  */
1346           break;
1347         if (*p == '*') {
1348           /* If we find a comment that wasn't removed by handle_directive,
1349              this must be -traditional.  So replace the comment with
1350              nothing at all.  */
1351           exp_p--;
1352           p += 1;
1353           while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
1354             p++;
1355 #if 0
1356           /* Mark this as a concatenation-point, as if it had been ##.  */
1357           concat = p;
1358 #endif
1359         }
1360         break;
1361       }
1362     }
1363
1364     /* Handle the start of a symbol.  */
1365     if (is_idchar[c] && nargs > 0) {
1366       U_CHAR *id_beg = p - 1;
1367       int id_len;
1368
1369       --exp_p;
1370       while (p != limit && is_idchar[*p]) p++;
1371       id_len = p - id_beg;
1372
1373       if (is_idstart[c]
1374           && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
1375         register struct arglist *arg;
1376
1377         for (arg = arglist; arg != NULL; arg = arg->next) {
1378           struct reflist *tpat;
1379
1380           if (arg->name[0] == c
1381               && arg->length == id_len
1382               && strncmp (arg->name, id_beg, id_len) == 0) {
1383             if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
1384               if (CPP_TRADITIONAL (pfile)) {
1385                 cpp_warning (pfile, "macro argument `%.*s' is stringified.",
1386                              id_len, arg->name);
1387               } else {
1388                 cpp_warning (pfile,
1389                     "macro arg `%.*s' would be stringified with -traditional.",
1390                              id_len, arg->name);
1391               }
1392             }
1393             /* If ANSI, don't actually substitute inside a string.  */
1394             if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
1395               break;
1396             /* make a pat node for this arg and append it to the end of
1397                the pat list */
1398             tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
1399             tpat->next = NULL;
1400             tpat->raw_before = concat == id_beg;
1401             tpat->raw_after = 0;
1402             tpat->rest_args = arg->rest_args;
1403             tpat->stringify = (CPP_TRADITIONAL (pfile)
1404                                ? expected_delimiter != '\0'
1405                                : stringify == id_beg);
1406
1407             if (endpat == NULL)
1408               defn->pattern = tpat;
1409             else
1410               endpat->next = tpat;
1411             endpat = tpat;
1412
1413             tpat->argno = arg->argno;
1414             tpat->nchars = exp_p - lastp;
1415             {
1416               register U_CHAR *p1 = p;
1417               SKIP_WHITE_SPACE (p1);
1418               if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
1419                 tpat->raw_after = 1;
1420             }
1421             lastp = exp_p;      /* place to start copying from next time */
1422             skipped_arg = 1;
1423             break;
1424           }
1425         }
1426       }
1427
1428       /* If this was not a macro arg, copy it into the expansion.  */
1429       if (! skipped_arg) {
1430         register U_CHAR *lim1 = p;
1431         p = id_beg;
1432         while (p != lim1)
1433           *exp_p++ = *p++;
1434         if (stringify == id_beg)
1435           cpp_error (pfile,
1436                    "`#' operator should be followed by a macro argument name");
1437       }
1438     }
1439   }
1440
1441   if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
1442     {
1443       /* If ANSI, put in a "@ " marker to prevent token pasting.
1444          But not if "inside a string" (which in ANSI mode
1445          happens only for -D option).  */
1446       *exp_p++ = '@';
1447       *exp_p++ = ' ';
1448     }
1449
1450   *exp_p = '\0';
1451
1452   defn->length = exp_p - defn->expansion;
1453
1454   /* Crash now if we overrun the allocated size.  */
1455   if (defn->length + 1 > maxsize)
1456     abort ();
1457
1458 #if 0
1459 /* This isn't worth the time it takes.  */
1460   /* give back excess storage */
1461   defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
1462 #endif
1463
1464   return defn;
1465 }
1466
1467 /*
1468  * special extension string that can be added to the last macro argument to
1469  * allow it to absorb the "rest" of the arguments when expanded.  Ex:
1470  *              #define wow(a, b...)            process (b, a, b)
1471  *              { wow (1, 2, 3); }      ->      { process (2, 3, 1, 2, 3); }
1472  *              { wow (one, two); }     ->      { process (two, one, two); }
1473  * if this "rest_arg" is used with the concat token '##' and if it is not
1474  * supplied then the token attached to with ## will not be outputted.  Ex:
1475  *              #define wow (a, b...)           process (b ## , a, ## b)
1476  *              { wow (1, 2); }         ->      { process (2, 1, 2); }
1477  *              { wow (one); }          ->      { process (one); {
1478  */
1479 static char rest_extension[] = "...";
1480 #define REST_EXTENSION_LENGTH   (sizeof (rest_extension) - 1)
1481
1482 /* Create a DEFINITION node from a #define directive.  Arguments are
1483    as for do_define.  */
1484
1485 static MACRODEF
1486 create_definition (buf, limit, pfile, predefinition)
1487      U_CHAR *buf, *limit;
1488      cpp_reader *pfile;
1489      int predefinition;
1490 {
1491   U_CHAR *bp;                   /* temp ptr into input buffer */
1492   U_CHAR *symname;              /* remember where symbol name starts */
1493   int sym_length;               /* and how long it is */
1494   int rest_args = 0;
1495   long line, col;
1496   char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
1497   DEFINITION *defn;
1498   int arglengths = 0;           /* Accumulate lengths of arg names
1499                                    plus number of args.  */
1500   MACRODEF mdef;
1501   cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
1502
1503   bp = buf;
1504
1505   while (is_hor_space[*bp])
1506     bp++;
1507
1508   symname = bp;                 /* remember where it starts */
1509
1510   sym_length = check_macro_name (pfile, bp, "macro");
1511   bp += sym_length;
1512
1513   /* Lossage will occur if identifiers or control keywords are broken
1514      across lines using backslash.  This is not the right place to take
1515      care of that.  */
1516
1517   if (*bp == '(') {
1518     struct arglist *arg_ptrs = NULL;
1519     int argno = 0;
1520
1521     bp++;                       /* skip '(' */
1522     SKIP_WHITE_SPACE (bp);
1523
1524     /* Loop over macro argument names.  */
1525     while (*bp != ')') {
1526       struct arglist *temp;
1527
1528       temp = (struct arglist *) alloca (sizeof (struct arglist));
1529       temp->name = bp;
1530       temp->next = arg_ptrs;
1531       temp->argno = argno++;
1532       temp->rest_args = 0;
1533       arg_ptrs = temp;
1534
1535       if (rest_args)
1536         cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
1537
1538       if (!is_idstart[*bp])
1539         cpp_pedwarn (pfile, "invalid character in macro parameter name");
1540
1541       /* Find the end of the arg name.  */
1542       while (is_idchar[*bp]) {
1543         bp++;
1544         /* do we have a "special" rest-args extension here? */
1545         if (limit - bp > REST_EXTENSION_LENGTH &&
1546             strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
1547           rest_args = 1;
1548           temp->rest_args = 1;
1549           break;
1550         }
1551       }
1552       temp->length = bp - temp->name;
1553       if (rest_args == 1)
1554         bp += REST_EXTENSION_LENGTH;
1555       arglengths += temp->length + 2;
1556       SKIP_WHITE_SPACE (bp);
1557       if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
1558         cpp_error (pfile, "badly punctuated parameter list in `#define'");
1559         goto nope;
1560       }
1561       if (*bp == ',') {
1562         bp++;
1563         SKIP_WHITE_SPACE (bp);
1564       }
1565       if (bp >= limit) {
1566         cpp_error (pfile, "unterminated parameter list in `#define'");
1567         goto nope;
1568       }
1569       {
1570         struct arglist *otemp;
1571
1572         for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
1573           if (temp->length == otemp->length &&
1574             strncmp (temp->name, otemp->name, temp->length) == 0) {
1575               U_CHAR *name;
1576
1577               name = (U_CHAR *) alloca (temp->length + 1);
1578               (void) strncpy (name, temp->name, temp->length);
1579               name[temp->length] = '\0';
1580               cpp_error (pfile,
1581                          "duplicate argument name `%s' in `#define'", name);
1582               goto nope;
1583           }
1584       }
1585     }
1586
1587     ++bp;                       /* skip paren */
1588     SKIP_WHITE_SPACE (bp);
1589     /* now everything from bp before limit is the definition.  */
1590     defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
1591     defn->rest_args = rest_args;
1592
1593     /* Now set defn->args.argnames to the result of concatenating
1594        the argument names in reverse order
1595        with comma-space between them.  */
1596     defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
1597     {
1598       struct arglist *temp;
1599       int i = 0;
1600       for (temp = arg_ptrs; temp; temp = temp->next) {
1601         bcopy (temp->name, &defn->args.argnames[i], temp->length);
1602         i += temp->length;
1603         if (temp->next != 0) {
1604           defn->args.argnames[i++] = ',';
1605           defn->args.argnames[i++] = ' ';
1606         }
1607       }
1608       defn->args.argnames[i] = 0;
1609     }
1610   } else {
1611     /* Simple expansion or empty definition.  */
1612
1613     if (bp < limit)
1614       {
1615         if (is_hor_space[*bp]) {
1616           bp++;
1617           SKIP_WHITE_SPACE (bp);
1618         } else {
1619           switch (*bp) {
1620             case '!':  case '"':  case '#':  case '%':  case '&':  case '\'':
1621             case ')':  case '*':  case '+':  case ',':  case '-':  case '.':
1622             case '/':  case ':':  case ';':  case '<':  case '=':  case '>':
1623             case '?':  case '[':  case '\\': case ']':  case '^':  case '{':
1624             case '|':  case '}':  case '~':
1625               cpp_warning (pfile, "missing white space after `#define %.*s'",
1626                            sym_length, symname);
1627               break;
1628
1629             default:
1630               cpp_pedwarn (pfile, "missing white space after `#define %.*s'",
1631                            sym_length, symname);
1632               break;
1633           }
1634         }
1635       }
1636     /* now everything from bp before limit is the definition.  */
1637     defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
1638     defn->args.argnames = (U_CHAR *) "";
1639   }
1640
1641   defn->line = line;
1642   defn->file = file;
1643
1644   /* OP is null if this is a predefinition */
1645   defn->predefined = predefinition;
1646   mdef.defn = defn;
1647   mdef.symnam = symname;
1648   mdef.symlen = sym_length;
1649
1650   return mdef;
1651
1652  nope:
1653   mdef.defn = 0;
1654   return mdef;
1655 }
1656
1657 /* Check a purported macro name SYMNAME, and yield its length.
1658    USAGE is the kind of name this is intended for.  */
1659
1660 static int
1661 check_macro_name (pfile, symname, usage)
1662      cpp_reader *pfile;
1663      U_CHAR *symname;
1664      char *usage;
1665 {
1666   U_CHAR *p;
1667   int sym_length;
1668
1669   for (p = symname; is_idchar[*p]; p++)
1670     ;
1671   sym_length = p - symname;
1672   if (sym_length == 0
1673       || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
1674     cpp_error (pfile, "invalid %s name", usage);
1675   else if (!is_idstart[*symname]) {
1676     U_CHAR *msg;                        /* what pain...  */
1677     msg = (U_CHAR *) alloca (sym_length + 1);
1678     bcopy (symname, msg, sym_length);
1679     msg[sym_length] = 0;
1680     cpp_error (pfile, "invalid %s name `%s'", usage, msg);
1681   } else {
1682     if (! strncmp (symname, "defined", 7) && sym_length == 7)
1683       cpp_error (pfile, "invalid %s name `defined'", usage);
1684   }
1685   return sym_length;
1686 }
1687
1688 /* Return zero if two DEFINITIONs are isomorphic.  */
1689
1690 static int
1691 compare_defs (d1, d2)
1692      DEFINITION *d1, *d2;
1693 {
1694   register struct reflist *a1, *a2;
1695   register U_CHAR *p1 = d1->expansion;
1696   register U_CHAR *p2 = d2->expansion;
1697   int first = 1;
1698
1699   if (d1->nargs != d2->nargs)
1700     return 1;
1701   if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
1702     return 1;
1703   for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1704        a1 = a1->next, a2 = a2->next) {
1705     if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
1706           || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1707         || a1->argno != a2->argno
1708         || a1->stringify != a2->stringify
1709         || a1->raw_before != a2->raw_before
1710         || a1->raw_after != a2->raw_after)
1711       return 1;
1712     first = 0;
1713     p1 += a1->nchars;
1714     p2 += a2->nchars;
1715   }
1716   if (a1 != a2)
1717     return 1;
1718   if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1719                      p2, d2->length - (p2 - d2->expansion), 1))
1720     return 1;
1721   return 0;
1722 }
1723
1724 /* Return 1 if two parts of two macro definitions are effectively different.
1725    One of the parts starts at BEG1 and has LEN1 chars;
1726    the other has LEN2 chars at BEG2.
1727    Any sequence of whitespace matches any other sequence of whitespace.
1728    FIRST means these parts are the first of a macro definition;
1729     so ignore leading whitespace entirely.
1730    LAST means these parts are the last of a macro definition;
1731     so ignore trailing whitespace entirely.  */
1732
1733 static int
1734 comp_def_part (first, beg1, len1, beg2, len2, last)
1735      int first;
1736      U_CHAR *beg1, *beg2;
1737      int len1, len2;
1738      int last;
1739 {
1740   register U_CHAR *end1 = beg1 + len1;
1741   register U_CHAR *end2 = beg2 + len2;
1742   if (first) {
1743     while (beg1 != end1 && is_space[*beg1]) beg1++;
1744     while (beg2 != end2 && is_space[*beg2]) beg2++;
1745   }
1746   if (last) {
1747     while (beg1 != end1 && is_space[end1[-1]]) end1--;
1748     while (beg2 != end2 && is_space[end2[-1]]) end2--;
1749   }
1750   while (beg1 != end1 && beg2 != end2) {
1751     if (is_space[*beg1] && is_space[*beg2]) {
1752       while (beg1 != end1 && is_space[*beg1]) beg1++;
1753       while (beg2 != end2 && is_space[*beg2]) beg2++;
1754     } else if (*beg1 == *beg2) {
1755       beg1++; beg2++;
1756     } else break;
1757   }
1758   return (beg1 != end1) || (beg2 != end2);
1759 }
1760
1761 /* Process a #define command.
1762 BUF points to the contents of the #define command, as a contiguous string.
1763 LIMIT points to the first character past the end of the definition.
1764 KEYWORD is the keyword-table entry for #define,
1765 or NULL for a "predefined" macro.  */
1766
1767 static int
1768 do_define (pfile, keyword, buf, limit)
1769      cpp_reader *pfile;
1770      struct directive *keyword;
1771      U_CHAR *buf, *limit;
1772 {
1773   int hashcode;
1774   MACRODEF mdef;
1775   HASHNODE *hp;
1776
1777 #if 0
1778   /* If this is a precompiler run (with -pcp) pass thru #define commands.  */
1779   if (pcp_outfile && keyword)
1780     pass_thru_directive (buf, limit, pfile, keyword);
1781 #endif
1782
1783   mdef = create_definition (buf, limit, pfile, keyword == NULL);
1784   if (mdef.defn == 0)
1785     goto nope;
1786
1787   hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
1788
1789   if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
1790     {
1791       int ok = 0;
1792       /* Redefining a precompiled key is ok.  */
1793       if (hp->type == T_PCSTRING)
1794         ok = 1;
1795       /* Redefining a macro is ok if the definitions are the same.  */
1796       else if (hp->type == T_MACRO)
1797         ok = ! compare_defs (mdef.defn, hp->value.defn);
1798       /* Redefining a constant is ok with -D.  */
1799       else if (hp->type == T_CONST)
1800         ok = ! CPP_OPTIONS (pfile)->done_initializing;
1801       /* Print the warning if it's not ok.  */
1802       if (!ok)
1803         {
1804           U_CHAR *msg;          /* what pain...  */
1805
1806           /* If we are passing through #define and #undef directives, do
1807              that for this re-definition now.  */
1808           if (CPP_OPTIONS (pfile)->debug_output && keyword)
1809             pass_thru_directive (buf, limit, pfile, keyword);
1810
1811           msg = (U_CHAR *) alloca (mdef.symlen + 22);
1812           *msg = '`';
1813           bcopy (mdef.symnam, msg + 1, mdef.symlen);
1814           strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
1815           cpp_pedwarn (pfile, msg);
1816           if (hp->type == T_MACRO)
1817             cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, hp->value.defn->line,
1818                                       "this is the location of the previous definition");
1819         }
1820       /* Replace the old definition.  */
1821       hp->type = T_MACRO;
1822       hp->value.defn = mdef.defn;
1823     }
1824   else
1825     {
1826       /* If we are passing through #define and #undef directives, do
1827          that for this new definition now.  */
1828       if (CPP_OPTIONS (pfile)->debug_output && keyword)
1829         pass_thru_directive (buf, limit, pfile, keyword);
1830       install (mdef.symnam, mdef.symlen, T_MACRO, 0,
1831                (char *) mdef.defn, hashcode);
1832     }
1833
1834   return 0;
1835
1836 nope:
1837
1838   return 1;
1839 }
1840
1841 /* This structure represents one parsed argument in a macro call.
1842    `raw' points to the argument text as written (`raw_length' is its length).
1843    `expanded' points to the argument's macro-expansion
1844    (its length is `expand_length').
1845    `stringified_length' is the length the argument would have
1846    if stringified.
1847    `use_count' is the number of times this macro arg is substituted
1848    into the macro.  If the actual use count exceeds 10,
1849    the value stored is 10.  */
1850
1851 /* raw and expanded are relative to ARG_BASE */
1852 #define ARG_BASE ((pfile)->token_buffer)
1853
1854 struct argdata {
1855   /* Strings relative to pfile->token_buffer */
1856   long raw, expanded, stringified;
1857   int raw_length, expand_length;
1858   int stringified_length;
1859   char newlines;
1860   char use_count;
1861 };
1862
1863 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
1864    If BUFFER != NULL, then use the LENGTH characters in BUFFER
1865    as the new input buffer.
1866    Return the new buffer, or NULL on failure.  */
1867
1868 cpp_buffer *
1869 cpp_push_buffer (pfile, buffer, length)
1870      cpp_reader *pfile;
1871      U_CHAR *buffer;
1872      long length;
1873 {
1874   register cpp_buffer *buf = CPP_BUFFER (pfile);
1875   if (buf == pfile->buffer_stack)
1876     {
1877       cpp_fatal (pfile, "%s: macro or `#include' recursion too deep",
1878                  buf->fname);
1879       return NULL;
1880     }
1881   buf--;
1882   bzero ((char *) buf, sizeof (cpp_buffer));
1883   CPP_BUFFER (pfile) = buf;
1884   buf->if_stack = pfile->if_stack;
1885   buf->cleanup = null_cleanup;
1886   buf->underflow = null_underflow;
1887   buf->buf = buf->cur = buffer;
1888   buf->alimit = buf->rlimit = buffer + length;
1889
1890   return buf;
1891 }
1892
1893 cpp_buffer *
1894 cpp_pop_buffer (pfile)
1895      cpp_reader *pfile;
1896 {
1897   cpp_buffer *buf = CPP_BUFFER (pfile);
1898   (*buf->cleanup) (buf, pfile);
1899   return ++CPP_BUFFER (pfile);
1900 }
1901
1902 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
1903    Pop the buffer when done.  */
1904
1905 void
1906 cpp_scan_buffer (pfile)
1907      cpp_reader *pfile;
1908 {
1909   cpp_buffer *buffer = CPP_BUFFER (pfile);
1910   for (;;)
1911     {
1912       enum cpp_token token = cpp_get_token (pfile);
1913       if (token == CPP_EOF) /* Should not happen ...  */
1914         break;
1915       if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
1916         {
1917           cpp_pop_buffer (pfile);
1918           break;
1919         }
1920     }
1921 }
1922
1923 /*
1924  * Rescan a string (which may have escape marks) into pfile's buffer.
1925  * Place the result in pfile->token_buffer.
1926  *
1927  * The input is copied before it is scanned, so it is safe to pass
1928  * it something from the token_buffer that will get overwritten
1929  * (because it follows CPP_WRITTEN).  This is used by do_include.
1930  */
1931
1932 static void
1933 cpp_expand_to_buffer (pfile, buf, length)
1934      cpp_reader *pfile;
1935      U_CHAR *buf;
1936      int length;
1937 {
1938   register cpp_buffer *ip;
1939   cpp_buffer obuf;
1940   U_CHAR *limit = buf + length;
1941   U_CHAR *buf1;
1942 #if 0
1943   int odepth = indepth;
1944 #endif
1945
1946   if (length < 0)
1947     abort ();
1948
1949   /* Set up the input on the input stack.  */
1950
1951   buf1 = (U_CHAR *) alloca (length + 1);
1952   {
1953     register U_CHAR *p1 = buf;
1954     register U_CHAR *p2 = buf1;
1955
1956     while (p1 != limit)
1957       *p2++ = *p1++;
1958   }
1959   buf1[length] = 0;
1960
1961   ip = cpp_push_buffer (pfile, buf1, length);
1962   if (ip == NULL)
1963     return;
1964   ip->has_escapes = 1;
1965 #if 0
1966   ip->lineno = obuf.lineno = 1;
1967 #endif
1968
1969   /* Scan the input, create the output.  */
1970   cpp_scan_buffer (pfile);
1971
1972 #if 0
1973   if (indepth != odepth)
1974     abort ();
1975 #endif
1976
1977   CPP_NUL_TERMINATE (pfile);
1978 }
1979
1980 \f
1981 static void
1982 adjust_position (buf, limit, linep, colp)
1983      U_CHAR *buf;
1984      U_CHAR *limit;
1985      long *linep;
1986      long *colp;
1987 {
1988   while (buf < limit)
1989     {
1990       U_CHAR ch = *buf++;
1991       if (ch == '\n')
1992         (*linep)++, (*colp) = 1;
1993       else
1994         (*colp)++;
1995     }
1996 }
1997
1998 /* Move line_base forward, updating lineno and colno.  */
1999
2000 static void
2001 update_position (pbuf)
2002      register cpp_buffer *pbuf;
2003 {
2004   unsigned char *old_pos = pbuf->buf + pbuf->line_base;
2005   unsigned char *new_pos = pbuf->cur;
2006   register struct parse_marker *mark;
2007   for (mark = pbuf->marks;  mark != NULL; mark = mark->next)
2008     {
2009       if (pbuf->buf + mark->position < new_pos)
2010         new_pos = pbuf->buf + mark->position;
2011     }
2012   pbuf->line_base += new_pos - old_pos;
2013   adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
2014 }
2015
2016 void
2017 cpp_buf_line_and_col (pbuf, linep, colp)
2018      register cpp_buffer *pbuf;
2019      long *linep, *colp;
2020 {
2021   long dummy;
2022   if (colp == NULL)
2023     colp = &dummy;
2024   if (pbuf)
2025     {
2026       *linep = pbuf->lineno;
2027       *colp = pbuf->colno;
2028       adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
2029     }
2030   else
2031     {
2032       *linep = 0;
2033       *colp = 0;
2034     }
2035 }
2036
2037 /* Return the cpp_buffer that corresponds to a file (not a macro).  */
2038
2039 cpp_buffer *
2040 cpp_file_buffer (pfile)
2041      cpp_reader *pfile;
2042 {
2043   cpp_buffer *ip = CPP_BUFFER (pfile);
2044
2045   for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
2046     if (ip->fname != NULL)
2047       return ip;
2048   return NULL;
2049 }
2050
2051 static long
2052 count_newlines (buf, limit)
2053      register U_CHAR *buf;
2054      register U_CHAR *limit;
2055 {
2056   register long count = 0;
2057   while (buf < limit)
2058     {
2059       U_CHAR ch = *buf++;
2060       if (ch == '\n')
2061         count++;
2062     }
2063   return count;
2064 }
2065
2066 /*
2067  * write out a #line command, for instance, after an #include file.
2068  * If CONDITIONAL is nonzero, we can omit the #line if it would
2069  * appear to be a no-op, and we can output a few newlines instead
2070  * if we want to increase the line number by a small amount.
2071  * FILE_CHANGE says whether we are entering a file, leaving, or neither.
2072  */
2073
2074 static void
2075 output_line_command (pfile, conditional, file_change)
2076      cpp_reader *pfile;
2077      int conditional;
2078      enum file_change_code file_change;
2079 {
2080   int len;
2081   char *line_cmd_buf, *line_end;
2082   long line, col;
2083   cpp_buffer *ip = CPP_BUFFER (pfile);
2084
2085   if (ip->fname == NULL)
2086     return;
2087
2088   update_position (ip);
2089
2090   if (CPP_OPTIONS (pfile)->no_line_commands
2091       || CPP_OPTIONS (pfile)->no_output)
2092     return;
2093
2094   line = CPP_BUFFER (pfile)->lineno;
2095   col = CPP_BUFFER (pfile)->colno;
2096   adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
2097
2098   if (CPP_OPTIONS (pfile)->no_line_commands)
2099     return;
2100
2101   if (conditional) {
2102     if (line == pfile->lineno)
2103       return;
2104
2105     /* If the inherited line number is a little too small,
2106        output some newlines instead of a #line command.  */
2107     if (line > pfile->lineno && line < pfile->lineno + 8) {
2108       CPP_RESERVE (pfile, 20);
2109       while (line > pfile->lineno) {
2110         CPP_PUTC_Q (pfile, '\n');
2111         pfile->lineno++;
2112       }
2113       return;
2114     }
2115   }
2116
2117 #if 0
2118   /* Don't output a line number of 0 if we can help it.  */
2119   if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
2120       && *ip->bufp == '\n') {
2121     ip->lineno++;
2122     ip->bufp++;
2123   }
2124 #endif
2125
2126   CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
2127   {
2128 #ifdef OUTPUT_LINE_COMMANDS
2129     static char sharp_line[] = "#line ";
2130 #else
2131     static char sharp_line[] = "# ";
2132 #endif
2133     CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
2134   }
2135
2136   sprintf (CPP_PWRITTEN (pfile), "%d ", line);
2137   CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
2138
2139   quote_string (pfile, ip->nominal_fname);
2140   if (file_change != same_file) {
2141     CPP_PUTC_Q (pfile, ' ');
2142     CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
2143   }
2144   /* Tell cc1 if following text comes from a system header file.  */
2145   if (ip->system_header_p) {
2146     CPP_PUTC_Q (pfile, ' ');
2147     CPP_PUTC_Q (pfile, '3');
2148   }
2149 #ifndef NO_IMPLICIT_EXTERN_C
2150   /* Tell cc1plus if following text should be treated as C.  */
2151   if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) {
2152     CPP_PUTC_Q (pfile, ' ');
2153     CPP_PUTC_Q (pfile, '4');
2154   }
2155 #endif
2156   CPP_PUTC_Q (pfile, '\n');
2157   pfile->lineno = line;
2158 }
2159 \f
2160 /*
2161  * Parse a macro argument and append the info on PFILE's token_buffer.
2162  * REST_ARGS means to absorb the rest of the args.
2163  * Return nonzero to indicate a syntax error.
2164  */
2165
2166 static enum cpp_token
2167 macarg (pfile, rest_args)
2168      cpp_reader *pfile;
2169      int rest_args;
2170 {
2171   int paren = 0;
2172   enum cpp_token token;
2173   long arg_start = CPP_WRITTEN (pfile);
2174   char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
2175   CPP_OPTIONS (pfile)->put_out_comments = 0;
2176
2177   /* Try to parse as much of the argument as exists at this
2178      input stack level.  */
2179   pfile->no_macro_expand++;
2180   for (;;)
2181     {
2182       token = cpp_get_token (pfile);
2183       switch (token)
2184         {
2185         case CPP_EOF:
2186           goto done;
2187         case CPP_POP:
2188           /* If we've hit end of file, it's an error (reported by caller).
2189              Ditto if it's the end of cpp_expand_to_buffer text.
2190              If we've hit end of macro, just continue.  */
2191           if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
2192             goto done;
2193           break;
2194         case CPP_LPAREN:
2195           paren++;
2196           break;
2197         case CPP_RPAREN:
2198           if (--paren < 0)
2199             goto found;
2200           break;
2201         case CPP_COMMA:
2202           /* if we've returned to lowest level and
2203              we aren't absorbing all args */
2204           if (paren == 0 && rest_args == 0)
2205             goto found;
2206           break;
2207         found:
2208           /* Remove ',' or ')' from argument buffer.  */
2209           CPP_ADJUST_WRITTEN (pfile, -1);
2210           goto done;
2211       default: ;
2212         }
2213     }
2214
2215  done:
2216   CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
2217   pfile->no_macro_expand--;
2218
2219   return token;
2220 }
2221 \f
2222 /* Turn newlines to spaces in the string of length LENGTH at START,
2223    except inside of string constants.
2224    The string is copied into itself with its beginning staying fixed.  */
2225
2226 static int
2227 change_newlines (start, length)
2228      U_CHAR *start;
2229      int length;
2230 {
2231   register U_CHAR *ibp;
2232   register U_CHAR *obp;
2233   register U_CHAR *limit;
2234   register int c;
2235
2236   ibp = start;
2237   limit = start + length;
2238   obp = start;
2239
2240   while (ibp < limit) {
2241     *obp++ = c = *ibp++;
2242     switch (c) {
2243
2244     case '\'':
2245     case '\"':
2246       /* Notice and skip strings, so that we don't delete newlines in them.  */
2247       {
2248         int quotec = c;
2249         while (ibp < limit) {
2250           *obp++ = c = *ibp++;
2251           if (c == quotec)
2252             break;
2253           if (c == '\n' && quotec == '\'')
2254             break;
2255         }
2256       }
2257       break;
2258     }
2259   }
2260
2261   return obp - start;
2262 }
2263
2264 \f
2265 static struct tm *
2266 timestamp (pfile)
2267      cpp_reader *pfile;
2268 {
2269   if (!pfile->timebuf) {
2270     time_t t = time ((time_t *) 0);
2271     pfile->timebuf = localtime (&t);
2272   }
2273   return pfile->timebuf;
2274 }
2275
2276 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2277                              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
2278                             };
2279
2280 /*
2281  * expand things like __FILE__.  Place the expansion into the output
2282  * buffer *without* rescanning.
2283  */
2284
2285 static void
2286 special_symbol (hp, pfile)
2287      HASHNODE *hp;
2288      cpp_reader *pfile;
2289 {
2290   char *buf;
2291   int i, len;
2292   int true_indepth;
2293   cpp_buffer *ip = NULL;
2294   struct tm *timebuf;
2295
2296   int paren = 0;                /* For special `defined' keyword */
2297
2298 #if 0
2299   if (pcp_outfile && pcp_inside_if
2300       && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
2301     cpp_error (pfile,
2302                "Predefined macro `%s' used inside `#if' during precompilation",
2303                hp->name);
2304 #endif
2305
2306   for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
2307     {
2308       if (ip == CPP_NULL_BUFFER (pfile))
2309         {
2310           cpp_error (pfile, "cccp error: not in any file?!");
2311           return;                       /* the show must go on */
2312         }
2313       if (ip->fname != NULL)
2314         break;
2315     }
2316
2317   switch (hp->type)
2318     {
2319     case T_FILE:
2320     case T_BASE_FILE:
2321       {
2322         char *string;
2323         if (hp->type == T_BASE_FILE)
2324           {
2325             while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
2326               ip = CPP_PREV_BUFFER (ip);
2327           }
2328         string = ip->nominal_fname;
2329
2330         if (!string)
2331           string = "";
2332         CPP_RESERVE (pfile, 3 + 4 * strlen (string));
2333         quote_string (pfile, string);
2334         return;
2335       }
2336
2337     case T_INCLUDE_LEVEL:
2338       true_indepth = 0;
2339       ip = CPP_BUFFER (pfile);
2340       for (;  ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
2341         if (ip->fname != NULL)
2342           true_indepth++;
2343
2344       buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
2345       sprintf (buf, "%d", true_indepth - 1);
2346       break;
2347
2348   case T_VERSION:
2349       buf = (char *) alloca (3 + strlen (version_string));
2350       sprintf (buf, "\"%s\"", version_string);
2351       break;
2352
2353 #ifndef NO_BUILTIN_SIZE_TYPE
2354     case T_SIZE_TYPE:
2355       buf = SIZE_TYPE;
2356       break;
2357 #endif
2358
2359 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2360     case T_PTRDIFF_TYPE:
2361       buf = PTRDIFF_TYPE;
2362       break;
2363 #endif
2364
2365     case T_WCHAR_TYPE:
2366       buf = CPP_WCHAR_TYPE (pfile);
2367     break;
2368
2369     case T_USER_LABEL_PREFIX_TYPE:
2370       buf = USER_LABEL_PREFIX;
2371       break;
2372
2373     case T_REGISTER_PREFIX_TYPE:
2374       buf = REGISTER_PREFIX;
2375       break;
2376
2377   case T_CONST:
2378       buf = (char *) alloca (4 * sizeof (int));
2379       sprintf (buf, "%d", hp->value.ival);
2380 #if 0
2381       if (pcp_inside_if && pcp_outfile)
2382         /* Output a precondition for this macro use */
2383         fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
2384 #endif
2385       break;
2386
2387     case T_SPECLINE:
2388       {
2389         long line = ip->lineno;
2390         long col = ip->colno;
2391         adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
2392
2393         buf = (char *) alloca (10);
2394         sprintf (buf, "%d", line);
2395       }
2396       break;
2397
2398     case T_DATE:
2399     case T_TIME:
2400       buf = (char *) alloca (20);
2401       timebuf = timestamp (pfile);
2402       if (hp->type == T_DATE)
2403         sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2404                  timebuf->tm_mday, timebuf->tm_year + 1900);
2405       else
2406         sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2407                  timebuf->tm_sec);
2408       break;
2409
2410     case T_SPEC_DEFINED:
2411       buf = " 0 ";              /* Assume symbol is not defined */
2412       ip = CPP_BUFFER (pfile);
2413       SKIP_WHITE_SPACE (ip->cur);
2414       if (*ip->cur == '(')
2415         {
2416           paren++;
2417           ip->cur++;                    /* Skip over the paren */
2418           SKIP_WHITE_SPACE (ip->cur);
2419         }
2420
2421       if (!is_idstart[*ip->cur])
2422         goto oops;
2423       if (ip->cur[0] == 'L' && (ip->cur[1] == '\'' || ip->cur[1] == '"'))
2424         goto oops;
2425       if (hp = cpp_lookup (pfile, ip->cur, -1, -1))
2426         {
2427 #if 0
2428           if (pcp_outfile && pcp_inside_if
2429               && (hp->type == T_CONST
2430                   || (hp->type == T_MACRO && hp->value.defn->predefined)))
2431             /* Output a precondition for this macro use.  */
2432             fprintf (pcp_outfile, "#define %s\n", hp->name);
2433 #endif
2434           buf = " 1 ";
2435         }
2436 #if 0
2437       else
2438         if (pcp_outfile && pcp_inside_if)
2439           {
2440             /* Output a precondition for this macro use */
2441             U_CHAR *cp = ip->bufp;
2442             fprintf (pcp_outfile, "#undef ");
2443             while (is_idchar[*cp]) /* Ick! */
2444               fputc (*cp++, pcp_outfile);
2445             putc ('\n', pcp_outfile);
2446           }
2447 #endif
2448       while (is_idchar[*ip->cur])
2449         ++ip->cur;
2450       SKIP_WHITE_SPACE (ip->cur);
2451       if (paren)
2452         {
2453           if (*ip->cur != ')')
2454             goto oops;
2455           ++ip->cur;
2456         }
2457       break;
2458
2459     oops:
2460
2461       cpp_error (pfile, "`defined' without an identifier");
2462       break;
2463
2464     default:
2465       cpp_error (pfile, "cccp error: invalid special hash type"); /* time for gdb */
2466       abort ();
2467     }
2468   len = strlen (buf);
2469   CPP_RESERVE (pfile, len + 1);
2470   CPP_PUTS_Q (pfile, buf, len);
2471   CPP_NUL_TERMINATE_Q (pfile);
2472
2473   return;
2474 }
2475
2476 /* Write out a #define command for the special named MACRO_NAME
2477    to PFILE's token_buffer.  */
2478
2479 static void
2480 dump_special_to_buffer (pfile, macro_name)
2481      cpp_reader *pfile;
2482      char *macro_name;
2483 {
2484   static char define_directive[] = "#define ";
2485   int macro_name_length = strlen (macro_name);
2486   output_line_command (pfile, 0, same_file);
2487   CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
2488   CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
2489   CPP_PUTS_Q (pfile, macro_name, macro_name_length);
2490   CPP_PUTC_Q (pfile, ' ');
2491   cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
2492   CPP_PUTC (pfile, '\n');
2493 }
2494
2495 /* Initialize the built-in macros.  */
2496
2497 static void
2498 initialize_builtins (pfile)
2499      cpp_reader *pfile;
2500 {
2501   install ("__LINE__", -1, T_SPECLINE, 0, 0, -1);
2502   install ("__DATE__", -1, T_DATE, 0, 0, -1);
2503   install ("__FILE__", -1, T_FILE, 0, 0, -1);
2504   install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
2505   install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
2506   install ("__VERSION__", -1, T_VERSION, 0, 0, -1);
2507 #ifndef NO_BUILTIN_SIZE_TYPE
2508   install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
2509 #endif
2510 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2511   install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
2512 #endif
2513   install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
2514   install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1);
2515   install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
2516   install ("__TIME__", -1, T_TIME, 0, 0, -1);
2517   if (!CPP_TRADITIONAL (pfile))
2518     install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
2519   if (CPP_OPTIONS (pfile)->objc)
2520     install ("__OBJC__", -1, T_CONST, 1, 0, -1);
2521 /*  This is supplied using a -D by the compiler driver
2522     so that it is present only when truly compiling with GNU C.  */
2523 /*  install ("__GNUC__", -1, T_CONST, 2, 0, -1);  */
2524
2525   if (CPP_OPTIONS (pfile)->debug_output)
2526     {
2527       dump_special_to_buffer (pfile, "__BASE_FILE__");
2528       dump_special_to_buffer (pfile, "__VERSION__");
2529 #ifndef NO_BUILTIN_SIZE_TYPE
2530       dump_special_to_buffer (pfile, "__SIZE_TYPE__");
2531 #endif
2532 #ifndef NO_BUILTIN_PTRDIFF_TYPE
2533       dump_special_to_buffer (pfile, "__PTRDIFF_TYPE__");
2534 #endif
2535       dump_special_to_buffer (pfile, "__WCHAR_TYPE__");
2536       dump_special_to_buffer (pfile, "__DATE__");
2537       dump_special_to_buffer (pfile, "__TIME__");
2538       if (!CPP_TRADITIONAL (pfile))
2539         dump_special_to_buffer (pfile, "__STDC__");
2540       if (CPP_OPTIONS (pfile)->objc)
2541         dump_special_to_buffer (pfile, "__OBJC__");
2542     }
2543 }
2544 \f
2545 /* Return 1 iff a token ending in C1 followed directly by a token C2
2546    could cause mis-tokenization.  */
2547
2548 static int
2549 unsafe_chars (c1, c2)
2550      int c1, c2;
2551 {
2552   switch (c1)
2553     {
2554     case '+': case '-':
2555       if (c2 == c1 || c2 == '=')
2556         return 1;
2557       goto letter;
2558     case '.':
2559     case '0': case '1': case '2': case '3': case '4':
2560     case '5': case '6': case '7': case '8': case '9':
2561     case 'e': case 'E':
2562       if (c2 == '-' || c2 == '+')
2563         return 1; /* could extend a pre-processing number */
2564       goto letter;
2565     case 'L':
2566       if (c2 == '\'' || c2 == '\"')
2567         return 1;   /* Could turn into L"xxx" or L'xxx'.  */
2568       goto letter;
2569     letter:
2570     case '_':
2571     case 'a': case 'b': case 'c': case 'd':           case 'f':
2572     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2573     case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
2574     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2575     case 'y': case 'z':
2576     case 'A': case 'B': case 'C': case 'D':           case 'F':
2577     case 'G': case 'H': case 'I': case 'J': case 'K':
2578     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
2579     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2580     case 'Y': case 'Z':
2581       /* We're in the middle of either a name or a pre-processing number.  */
2582       return (is_idchar[c2] || c2 == '.');
2583     case '<': case '>': case '!': case '%': case '#': case ':':
2584     case '^': case '&': case '|': case '*': case '/': case '=':
2585       return (c2 == c1 || c2 == '=');
2586     }
2587   return 0;
2588 }
2589
2590 /* Expand a macro call.
2591    HP points to the symbol that is the macro being called.
2592    Put the result of expansion onto the input stack
2593    so that subsequent input by our caller will use it.
2594
2595    If macro wants arguments, caller has already verified that
2596    an argument list follows; arguments come from the input stack.  */
2597
2598 static void
2599 macroexpand (pfile, hp)
2600      cpp_reader *pfile;
2601      HASHNODE *hp;
2602 {
2603   int nargs;
2604   DEFINITION *defn = hp->value.defn;
2605   register U_CHAR *xbuf;
2606   long start_line, start_column;
2607   int xbuf_len;
2608   struct argdata *args;
2609   long old_written = CPP_WRITTEN (pfile);
2610 #if 0
2611   int start_line = instack[indepth].lineno;
2612 #endif
2613   int rest_args, rest_zero;
2614       register int i;
2615
2616 #if 0
2617   CHECK_DEPTH (return;);
2618 #endif
2619
2620 #if 0
2621   /* This macro is being used inside a #if, which means it must be */
2622   /* recorded as a precondition.  */
2623   if (pcp_inside_if && pcp_outfile && defn->predefined)
2624     dump_single_macro (hp, pcp_outfile);
2625 #endif
2626
2627   pfile->output_escapes++;
2628   cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
2629
2630   nargs = defn->nargs;
2631
2632   if (nargs >= 0)
2633     {
2634       enum cpp_token token;
2635
2636       args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
2637
2638       for (i = 0; i < nargs; i++)
2639         {
2640           args[i].raw = args[i].expanded = 0;
2641           args[i].raw_length = 0;
2642           args[i].expand_length = args[i].stringified_length = -1;
2643           args[i].use_count = 0;
2644         }
2645
2646       /* Parse all the macro args that are supplied.  I counts them.
2647          The first NARGS args are stored in ARGS.
2648          The rest are discarded.  If rest_args is set then we assume
2649          macarg absorbed the rest of the args.  */
2650       i = 0;
2651       rest_args = 0;
2652       rest_args = 0;
2653       FORWARD(1); /* Discard the open-parenthesis before the first arg.  */
2654       do
2655         {
2656           if (rest_args)
2657             continue;
2658           if (i < nargs || (nargs == 0 && i == 0))
2659             {
2660               /* if we are working on last arg which absorbs rest of args... */
2661               if (i == nargs - 1 && defn->rest_args)
2662                 rest_args = 1;
2663               args[i].raw = CPP_WRITTEN (pfile);
2664               token = macarg (pfile, rest_args);
2665               args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
2666               args[i].newlines = 0; /* FIXME */
2667             }
2668           else
2669             token = macarg (pfile, 0);
2670           if (token == CPP_EOF || token == CPP_POP)
2671             {
2672               cpp_error_with_line (pfile, start_line, start_column,
2673                                    "unterminated macro call");
2674               return;
2675             }
2676           i++;
2677         } while (token == CPP_COMMA);
2678
2679       /* If we got one arg but it was just whitespace, call that 0 args.  */
2680       if (i == 1)
2681         {
2682           register U_CHAR *bp = ARG_BASE + args[0].raw;
2683           register U_CHAR *lim = bp + args[0].raw_length;
2684           /* cpp.texi says for foo ( ) we provide one argument.
2685              However, if foo wants just 0 arguments, treat this as 0.  */
2686           if (nargs == 0)
2687             while (bp != lim && is_space[*bp]) bp++;
2688           if (bp == lim)
2689             i = 0;
2690         }
2691
2692       /* Don't output an error message if we have already output one for
2693          a parse error above.  */
2694       rest_zero = 0;
2695       if (nargs == 0 && i > 0)
2696         {
2697           cpp_error (pfile, "arguments given to macro `%s'", hp->name);
2698         }
2699       else if (i < nargs)
2700         {
2701           /* traditional C allows foo() if foo wants one argument.  */
2702           if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
2703             ;
2704           /* the rest args token is allowed to absorb 0 tokens */
2705           else if (i == nargs - 1 && defn->rest_args)
2706             rest_zero = 1;
2707           else if (i == 0)
2708             cpp_error (pfile, "macro `%s' used without args", hp->name);
2709           else if (i == 1)
2710             cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
2711           else
2712             cpp_error (pfile, "macro `%s' used with only %d args",
2713                        hp->name, i);
2714       }
2715       else if (i > nargs)
2716         {
2717           cpp_error (pfile,
2718                      "macro `%s' used with too many (%d) args", hp->name, i);
2719         }
2720     }
2721
2722   /* If macro wants zero args, we parsed the arglist for checking only.
2723      Read directly from the macro definition.  */
2724   if (nargs <= 0)
2725     {
2726       xbuf = defn->expansion;
2727       xbuf_len = defn->length;
2728     }
2729   else
2730     {
2731       register U_CHAR *exp = defn->expansion;
2732       register int offset;      /* offset in expansion,
2733                                    copied a piece at a time */
2734       register int totlen;      /* total amount of exp buffer filled so far */
2735
2736       register struct reflist *ap, *last_ap;
2737
2738       /* Macro really takes args.  Compute the expansion of this call.  */
2739
2740       /* Compute length in characters of the macro's expansion.
2741          Also count number of times each arg is used.  */
2742       xbuf_len = defn->length;
2743       for (ap = defn->pattern; ap != NULL; ap = ap->next)
2744         {
2745           if (ap->stringify)
2746             {
2747               register struct argdata *arg = &args[ap->argno];
2748               /* Stringify it it hasn't already been */
2749               if (arg->stringified_length < 0)
2750                 {
2751                   int arglen = arg->raw_length;
2752                   int escaped = 0;
2753                   int in_string = 0;
2754                   int c;
2755                   /* Initially need_space is -1.  Otherwise, 1 means the
2756                      previous character was a space, but we suppressed it;
2757                      0 means the previous character was a non-space.  */
2758                   int need_space = -1;
2759                   i = 0;
2760                   arg->stringified = CPP_WRITTEN (pfile);
2761                   if (!CPP_TRADITIONAL (pfile))
2762                     CPP_PUTC (pfile, '\"'); /* insert beginning quote */
2763                   for (; i < arglen; i++)
2764                     {
2765                       c = (ARG_BASE + arg->raw)[i];
2766
2767                       if (! in_string)
2768                         {
2769                           /* Internal sequences of whitespace are replaced by
2770                              one space except within an string or char token.*/
2771                           if (is_space[c])
2772                             {
2773                               if (CPP_WRITTEN (pfile) > arg->stringified
2774                                   && (CPP_PWRITTEN (pfile))[-1] == '@')
2775                                 {
2776                                   /* "@ " escape markers are removed */
2777                                   CPP_ADJUST_WRITTEN (pfile, -1);
2778                                   continue;
2779                                 }
2780                               if (need_space == 0)
2781                                 need_space = 1;
2782                               continue;
2783                             }
2784                           else if (need_space > 0)
2785                             CPP_PUTC (pfile, ' ');
2786                           need_space = 0;
2787                         }
2788
2789                       if (escaped)
2790                         escaped = 0;
2791                       else
2792                         {
2793                           if (c == '\\')
2794                             escaped = 1;
2795                           if (in_string)
2796                             {
2797                               if (c == in_string)
2798                                 in_string = 0;
2799                             }
2800                           else if (c == '\"' || c == '\'')
2801                             in_string = c;
2802                         }
2803
2804                       /* Escape these chars */
2805                       if (c == '\"' || (in_string && c == '\\'))
2806                         CPP_PUTC (pfile, '\\');
2807                       if (isprint (c))
2808                         CPP_PUTC (pfile, c);
2809                       else
2810                         {
2811                           CPP_RESERVE (pfile, 4);
2812                           sprintf (CPP_PWRITTEN (pfile), "\\%03o",
2813                                    (unsigned int) c);
2814                           CPP_ADJUST_WRITTEN (pfile, 4);
2815                         }
2816                     }
2817                   if (!CPP_TRADITIONAL (pfile))
2818                     CPP_PUTC (pfile, '\"'); /* insert ending quote */
2819                   arg->stringified_length
2820                     = CPP_WRITTEN (pfile) - arg->stringified;
2821                 }
2822               xbuf_len += args[ap->argno].stringified_length;
2823             }
2824           else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
2825             /* Add 4 for two newline-space markers to prevent
2826                token concatenation.  */
2827             xbuf_len += args[ap->argno].raw_length + 4;
2828           else
2829             {
2830               /* We have an ordinary (expanded) occurrence of the arg.
2831                  So compute its expansion, if we have not already.  */
2832               if (args[ap->argno].expand_length < 0)
2833                 {
2834                   args[ap->argno].expanded = CPP_WRITTEN (pfile);
2835                   cpp_expand_to_buffer (pfile,
2836                                         ARG_BASE + args[ap->argno].raw,
2837                                         args[ap->argno].raw_length);
2838
2839                   args[ap->argno].expand_length
2840                     = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
2841                 }
2842
2843               /* Add 4 for two newline-space markers to prevent
2844                  token concatenation.  */
2845               xbuf_len += args[ap->argno].expand_length + 4;
2846             }
2847           if (args[ap->argno].use_count < 10)
2848             args[ap->argno].use_count++;
2849         }
2850
2851       xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
2852
2853       /* Generate in XBUF the complete expansion
2854          with arguments substituted in.
2855          TOTLEN is the total size generated so far.
2856          OFFSET is the index in the definition
2857          of where we are copying from.  */
2858       offset = totlen = 0;
2859       for (last_ap = NULL, ap = defn->pattern; ap != NULL;
2860            last_ap = ap, ap = ap->next)
2861         {
2862           register struct argdata *arg = &args[ap->argno];
2863           int count_before = totlen;
2864
2865           /* Add chars to XBUF.  */
2866           for (i = 0; i < ap->nchars; i++, offset++)
2867             xbuf[totlen++] = exp[offset];
2868
2869           /* If followed by an empty rest arg with concatenation,
2870              delete the last run of nonwhite chars.  */
2871           if (rest_zero && totlen > count_before
2872               && ((ap->rest_args && ap->raw_before)
2873                   || (last_ap != NULL && last_ap->rest_args
2874                       && last_ap->raw_after)))
2875             {
2876               /* Delete final whitespace.  */
2877               while (totlen > count_before && is_space[xbuf[totlen - 1]])
2878                 totlen--;
2879
2880               /* Delete the nonwhites before them.  */
2881               while (totlen > count_before && ! is_space[xbuf[totlen - 1]])
2882                 totlen--;
2883             }
2884
2885           if (ap->stringify != 0)
2886             {
2887               bcopy (ARG_BASE + arg->stringified,
2888                      xbuf + totlen, arg->stringified_length);
2889               totlen += arg->stringified_length;
2890             }
2891           else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
2892             {
2893               U_CHAR *p1 = ARG_BASE + arg->raw;
2894               U_CHAR *l1 = p1 + arg->raw_length;
2895               if (ap->raw_before)
2896                 {
2897                   while (p1 != l1 && is_space[*p1]) p1++;
2898                   while (p1 != l1 && is_idchar[*p1])
2899                     xbuf[totlen++] = *p1++;
2900                   /* Delete any no-reexpansion marker that follows
2901                      an identifier at the beginning of the argument
2902                      if the argument is concatenated with what precedes it.  */
2903                   if (p1[0] == '@' && p1[1] == '-')
2904                     p1 += 2;
2905                 }
2906               if (ap->raw_after)
2907                 {
2908                   /* Arg is concatenated after: delete trailing whitespace,
2909                      whitespace markers, and no-reexpansion markers.  */
2910                   while (p1 != l1)
2911                     {
2912                       if (is_space[l1[-1]]) l1--;
2913                       else if (l1[-1] == '-')
2914                         {
2915                           U_CHAR *p2 = l1 - 1;
2916                           /* If a `-' is preceded by an odd number of newlines then it
2917                              and the last newline are a no-reexpansion marker.  */
2918                           while (p2 != p1 && p2[-1] == '\n') p2--;
2919                           if ((l1 - 1 - p2) & 1) {
2920                             l1 -= 2;
2921                           }
2922                           else break;
2923                         }
2924                       else break;
2925                     }
2926                 }
2927
2928               bcopy (p1, xbuf + totlen, l1 - p1);
2929               totlen += l1 - p1;
2930             }
2931           else
2932             {
2933               U_CHAR *expanded = ARG_BASE + arg->expanded;
2934               if (!ap->raw_before && totlen > 0 && arg->expand_length
2935                   && !CPP_TRADITIONAL(pfile)
2936                   && unsafe_chars (xbuf[totlen-1], expanded[0]))
2937                 {
2938                   xbuf[totlen++] = '@';
2939                   xbuf[totlen++] = ' ';
2940                 }
2941
2942               bcopy (expanded, xbuf + totlen, arg->expand_length);
2943               totlen += arg->expand_length;
2944
2945               if (!ap->raw_after && totlen > 0 && offset < defn->length
2946                   && !CPP_TRADITIONAL(pfile)
2947                   && unsafe_chars (xbuf[totlen-1], exp[offset]))
2948                 {
2949                   xbuf[totlen++] = '@';
2950                   xbuf[totlen++] = ' ';
2951                 }
2952
2953               /* If a macro argument with newlines is used multiple times,
2954                  then only expand the newlines once.  This avoids creating
2955                  output lines which don't correspond to any input line,
2956                  which confuses gdb and gcov.  */
2957               if (arg->use_count > 1 && arg->newlines > 0)
2958                 {
2959                   /* Don't bother doing change_newlines for subsequent
2960                      uses of arg.  */
2961                   arg->use_count = 1;
2962                   arg->expand_length
2963                     = change_newlines (expanded, arg->expand_length);
2964                 }
2965             }
2966
2967           if (totlen > xbuf_len)
2968             abort ();
2969       }
2970
2971       /* if there is anything left of the definition
2972          after handling the arg list, copy that in too.  */
2973
2974       for (i = offset; i < defn->length; i++)
2975         {
2976           /* if we've reached the end of the macro */
2977           if (exp[i] == ')')
2978             rest_zero = 0;
2979           if (! (rest_zero && last_ap != NULL && last_ap->rest_args
2980                  && last_ap->raw_after))
2981             xbuf[totlen++] = exp[i];
2982         }
2983
2984       xbuf[totlen] = 0;
2985       xbuf_len = totlen;
2986
2987     }
2988
2989   pfile->output_escapes--;
2990
2991   /* Now put the expansion on the input stack
2992      so our caller will commence reading from it.  */
2993   push_macro_expansion (pfile, xbuf, xbuf_len, hp);
2994   CPP_BUFFER (pfile)->has_escapes = 1;
2995
2996   /* Pop the space we've used in the token_buffer for argument expansion.  */
2997   CPP_SET_WRITTEN (pfile, old_written);
2998
2999   /* Recursive macro use sometimes works traditionally.
3000      #define foo(x,y) bar (x (y,0), y)
3001      foo (foo, baz)  */
3002
3003   if (!CPP_TRADITIONAL (pfile))
3004     hp->type = T_DISABLED;
3005 }
3006
3007 static void
3008 push_macro_expansion (pfile, xbuf, xbuf_len, hp)
3009      cpp_reader *pfile;
3010      register U_CHAR *xbuf;
3011      int xbuf_len;
3012      HASHNODE *hp;
3013 {
3014   register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
3015   if (mbuf == NULL)
3016     return;
3017   mbuf->cleanup = macro_cleanup;
3018   mbuf->data = hp;
3019
3020   /* The first chars of the expansion should be a "@ " added by
3021      collect_expansion.  This is to prevent accidental token-pasting
3022      between the text preceding the macro invocation, and the macro
3023      expansion text.
3024
3025      We would like to avoid adding unneeded spaces (for the sake of
3026      tools that use cpp, such as imake).  In some common cases we can
3027      tell that it is safe to omit the space.
3028
3029      The character before the macro invocation cannot have been an
3030      idchar (or else it would have been pasted with the idchars of
3031      the macro name).  Therefore, if the first non-space character
3032      of the expansion is an idchar, we do not need the extra space
3033      to prevent token pasting.
3034
3035      Also, we don't need the extra space if the first char is '(',
3036      or some other (less common) characters.  */
3037
3038   if (xbuf[0] == '@' && xbuf[1] == ' '
3039       && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
3040           || xbuf[2] == '\"'))
3041     mbuf->cur += 2;
3042 }
3043 \f
3044 /* Like cpp_get_token, except that it does not read past end-of-line.
3045    Also, horizontal space is skipped, and macros are popped.  */
3046
3047 static enum cpp_token
3048 get_directive_token (pfile)
3049      cpp_reader *pfile;
3050 {
3051   for (;;)
3052     {
3053       long old_written = CPP_WRITTEN (pfile);
3054       enum cpp_token token;
3055       cpp_skip_hspace (pfile);
3056       if (PEEKC () == '\n')
3057           return CPP_VSPACE;
3058       token = cpp_get_token (pfile);
3059       switch (token)
3060       {
3061       case CPP_POP:
3062           if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
3063               return token;
3064           /* ... else fall though ...  */
3065       case CPP_HSPACE:  case CPP_COMMENT:
3066           CPP_SET_WRITTEN (pfile, old_written);
3067           break;
3068       default:
3069           return token;
3070       }
3071     }
3072 }
3073 \f
3074 /* Handle #include and #import.
3075    This function expects to see "fname" or <fname> on the input.
3076
3077    The input is normally in part of the output_buffer following
3078    CPP_WRITTEN, and will get overwritten by output_line_command.
3079    I.e. in input file specification has been popped by handle_directive.
3080    This is safe.  */
3081
3082 static int
3083 do_include (pfile, keyword, unused1, unused2)
3084      cpp_reader *pfile;
3085      struct directive *keyword;
3086      U_CHAR *unused1, *unused2;
3087 {
3088   int importing = (keyword->type == T_IMPORT);
3089   int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
3090   char *fname;          /* Dynamically allocated fname buffer */
3091   char *pcftry;
3092   char *pcfname;
3093   U_CHAR *fbeg, *fend;          /* Beginning and end of fname */
3094   enum cpp_token token;
3095
3096   /* Chain of dirs to search */
3097   struct file_name_list *search_start = CPP_OPTIONS (pfile)->include;
3098   struct file_name_list dsp[1]; /* First in chain, if #include "..." */
3099   struct file_name_list *searchptr = 0;
3100   long old_written = CPP_WRITTEN (pfile);
3101
3102   int flen;
3103
3104   int f;                        /* file number */
3105
3106   int retried = 0;              /* Have already tried macro
3107                                    expanding the include line */
3108   int angle_brackets = 0;       /* 0 for "...", 1 for <...> */
3109   int pcf = -1;
3110   char *pcfbuf;
3111   char *pcfbuflimit;
3112   int pcfnum;
3113   f= -1;                        /* JF we iz paranoid! */
3114
3115   if (importing && CPP_OPTIONS (pfile)->warn_import
3116       && !CPP_OPTIONS (pfile)->inhibit_warnings
3117       && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
3118     {
3119       pfile->import_warning = 1;
3120       cpp_warning (pfile, "using `#import' is not recommended");
3121       fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
3122       fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
3123       fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
3124       fprintf (stderr, "  #ifndef _FOO_H_INCLUDED\n");
3125       fprintf (stderr, "  #define _FOO_H_INCLUDED\n");
3126       fprintf (stderr, "  ... <real contents of file> ...\n");
3127       fprintf (stderr, "  #endif /* Not _FOO_H_INCLUDED */\n\n");
3128       fprintf (stderr, "Then users can use `#include' any number of times.\n");
3129       fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
3130       fprintf (stderr, "when it is equipped with such a conditional.\n");
3131     }
3132
3133   pfile->parsing_include_directive++;
3134   token = get_directive_token (pfile);
3135   pfile->parsing_include_directive--;
3136
3137   if (token == CPP_STRING)
3138     {
3139       /* FIXME - check no trailing garbage */
3140       fbeg = pfile->token_buffer + old_written + 1;
3141       fend = CPP_PWRITTEN (pfile) - 1;
3142       if (fbeg[-1] == '<')
3143         {
3144           angle_brackets = 1;
3145           /* If -I-, start with the first -I dir after the -I-.  */
3146           if (CPP_OPTIONS (pfile)->first_bracket_include)
3147             search_start = CPP_OPTIONS (pfile)->first_bracket_include;
3148         }
3149       /* If -I- was specified, don't search current dir, only spec'd ones.  */
3150       else if (! CPP_OPTIONS (pfile)->ignore_srcdir)
3151         {
3152           cpp_buffer *fp = CPP_BUFFER (pfile);
3153           /* We have "filename".  Figure out directory this source
3154              file is coming from and put it on the front of the list.  */
3155
3156           for ( ; fp != CPP_NULL_BUFFER (pfile); fp = CPP_PREV_BUFFER (fp))
3157             {
3158               int n;
3159               char *ep,*nam;
3160
3161               if ((nam = fp->nominal_fname) != NULL)
3162                 {
3163                   /* Found a named file.  Figure out dir of the file,
3164                      and put it in front of the search list.  */
3165                   dsp[0].next = search_start;
3166                   search_start = dsp;
3167 #ifndef VMS
3168                   ep = rindex (nam, '/');
3169 #else                           /* VMS */
3170                   ep = rindex (nam, ']');
3171                   if (ep == NULL) ep = rindex (nam, '>');
3172                   if (ep == NULL) ep = rindex (nam, ':');
3173                   if (ep != NULL) ep++;
3174 #endif                          /* VMS */
3175                   if (ep != NULL)
3176                     {
3177                       n = ep - nam;
3178                       dsp[0].fname = (char *) alloca (n + 1);
3179                       strncpy (dsp[0].fname, nam, n);
3180                       dsp[0].fname[n] = '\0';
3181                       if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
3182                         pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
3183                     }
3184                   else
3185                     {
3186                       dsp[0].fname = 0; /* Current directory */
3187                     }
3188                   dsp[0].got_name_map = 0;
3189                   break;
3190                 }
3191             }
3192         }
3193     }
3194 #ifdef VMS
3195   else if (token == CPP_NAME)
3196     {
3197       /*
3198        * Support '#include xyz' like VAX-C to allow for easy use of all the
3199        * decwindow include files. It defaults to '#include <xyz.h>' (so the
3200        * code from case '<' is repeated here) and generates a warning.
3201        */
3202       cpp_warning (pfile,
3203                    "VAX-C-style include specification found, use '#include <filename.h>' !");
3204       angle_brackets = 1;
3205       /* If -I-, start with the first -I dir after the -I-.  */
3206       if (CPP_OPTIONS (pfile)->first_bracket_include)
3207         search_start = CPP_OPTIONS (pfile)->first_bracket_include;
3208       fbeg = pfile->token_buffer + old_written;
3209       fend = CPP_PWRITTEN (pfile);
3210     }
3211 #endif
3212   else
3213     {
3214       cpp_error (pfile,
3215                  "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
3216       CPP_SET_WRITTEN (pfile, old_written);
3217       skip_rest_of_line (pfile);
3218       return 0;
3219     }
3220
3221   *fend = 0;
3222
3223   token = get_directive_token (pfile);
3224   if (token != CPP_VSPACE)
3225     {
3226       cpp_error (pfile, "junk at end of `#include'");
3227       while (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
3228         token = get_directive_token (pfile);
3229     }
3230
3231   /* For #include_next, skip in the search path
3232      past the dir in which the containing file was found.  */
3233   if (skip_dirs)
3234     {
3235       cpp_buffer *fp = CPP_BUFFER (pfile);
3236       for (; fp != CPP_NULL_BUFFER (pfile); fp = CPP_PREV_BUFFER (fp))
3237         if (fp->fname != NULL)
3238           {
3239             /* fp->dir is null if the containing file was specified with
3240                an absolute file name.  In that case, don't skip anything.  */
3241             if (fp->dir == SELF_DIR_DUMMY)
3242               search_start = CPP_OPTIONS (pfile)->include;
3243             else if (fp->dir)
3244               search_start = fp->dir->next;
3245             break;
3246           }
3247     }
3248
3249   CPP_SET_WRITTEN (pfile, old_written);
3250
3251   flen = fend - fbeg;
3252
3253   if (flen == 0)
3254     {
3255       cpp_error (pfile, "empty file name in `#%s'", keyword->name);
3256       return 0;
3257     }
3258
3259   /* Allocate this permanently, because it gets stored in the definitions
3260      of macros.  */
3261   fname = (char *) xmalloc (pfile->max_include_len + flen + 4);
3262   /* + 2 above for slash and terminating null.  */
3263   /* + 2 added for '.h' on VMS (to support '#include filename') */
3264
3265   /* If specified file name is absolute, just open it.  */
3266
3267   if (*fbeg == '/') {
3268     strncpy (fname, fbeg, flen);
3269     fname[flen] = 0;
3270     if (redundant_include_p (pfile, fname))
3271       return 0;
3272     if (importing)
3273       f = lookup_import (pfile, fname, NULL_PTR);
3274     else
3275       f = open_include_file (pfile, fname, NULL_PTR);
3276     if (f == -2)
3277       return 0;         /* Already included this file */
3278   } else {
3279     /* Search directory path, trying to open the file.
3280        Copy each filename tried into FNAME.  */
3281
3282     for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
3283       if (searchptr->fname) {
3284         /* The empty string in a search path is ignored.
3285            This makes it possible to turn off entirely
3286            a standard piece of the list.  */
3287         if (searchptr->fname[0] == 0)
3288           continue;
3289         strcpy (fname, searchptr->fname);
3290         strcat (fname, "/");
3291         fname[strlen (fname) + flen] = 0;
3292       } else {
3293         fname[0] = 0;
3294       }
3295       strncat (fname, fbeg, flen);
3296 #ifdef VMS
3297       /* Change this 1/2 Unix 1/2 VMS file specification into a
3298          full VMS file specification */
3299       if (searchptr->fname && (searchptr->fname[0] != 0)) {
3300         /* Fix up the filename */
3301         hack_vms_include_specification (fname);
3302       } else {
3303         /* This is a normal VMS filespec, so use it unchanged.  */
3304         strncpy (fname, fbeg, flen);
3305         fname[flen] = 0;
3306         /* if it's '#include filename', add the missing .h */
3307         if (index(fname,'.')==NULL) {
3308           strcat (fname, ".h");
3309         }
3310       }
3311 #endif /* VMS */
3312       /* ??? There are currently 3 separate mechanisms for avoiding processing
3313          of redundant include files: #import, #pragma once, and
3314          redundant_include_p.  It would be nice if they were unified.  */
3315       if (redundant_include_p (pfile, fname))
3316         return 0;
3317       if (importing)
3318         f = lookup_import (pfile, fname, searchptr);
3319       else
3320         f = open_include_file (pfile, fname, searchptr);
3321       if (f == -2)
3322         return 0;                       /* Already included this file */
3323 #ifdef EACCES
3324       else if (f == -1 && errno == EACCES)
3325         cpp_warning (pfile, "Header file %s exists, but is not readable",
3326                      fname);
3327 #endif
3328       if (f >= 0)
3329         break;
3330     }
3331   }
3332
3333   if (f < 0)
3334     {
3335       /* A file that was not found.  */
3336       strncpy (fname, fbeg, flen);
3337       fname[flen] = 0;
3338       /* If generating dependencies and -MG was specified, we assume missing
3339          files are leaf files, living in the same directory as the source file
3340          or other similar place; these missing files may be generated from
3341          other files and may not exist yet (eg: y.tab.h).  */
3342
3343       if (CPP_OPTIONS(pfile)->print_deps_missing_files
3344           && CPP_PRINT_DEPS (pfile)
3345           > (angle_brackets || (pfile->system_include_depth > 0)))
3346         {
3347           /* If it was requested as a system header file,
3348              then assume it belongs in the first place to look for such.  */
3349           if (angle_brackets)
3350             {
3351               for (searchptr = search_start; searchptr;
3352                    searchptr = searchptr->next)
3353                 {
3354                   if (searchptr->fname)
3355                     {
3356                       char *p;
3357
3358                       if (searchptr->fname[0] == 0)
3359                         continue;
3360                       p = (char *) alloca (strlen (searchptr->fname)
3361                                            + strlen (fname) + 2);
3362                       strcpy (p, searchptr->fname);
3363                       strcat (p, "/");
3364                       strcat (p, fname);
3365                       deps_output (pfile, p, ' ');
3366                       break;
3367                     }
3368                 }
3369             }
3370           else
3371             {
3372               /* Otherwise, omit the directory, as if the file existed
3373                  in the directory with the source.  */
3374               deps_output (pfile, fname, ' ');
3375             }
3376         }
3377       /* If -M was specified, and this header file won't be added to the
3378          dependency list, then don't count this as an error, because we can
3379          still produce correct output.  Otherwise, we can't produce correct
3380          output, because there may be dependencies we need inside the missing
3381          file, and we don't know what directory this missing file exists in.*/
3382       else if (CPP_PRINT_DEPS (pfile)
3383                && (CPP_PRINT_DEPS (pfile)
3384                    <= (angle_brackets || (pfile->system_include_depth > 0))))
3385         cpp_warning (pfile, "No include path in which to find %s", fname);
3386       else if (search_start)
3387         cpp_error_from_errno (pfile, fname);
3388       else
3389         cpp_error (pfile, "No include path in which to find %s", fname);
3390     }
3391   else {
3392     /* Check to see if this include file is a once-only include file.
3393        If so, give up.  */
3394
3395     struct file_name_list *ptr;
3396
3397     for (ptr = pfile->dont_repeat_files; ptr; ptr = ptr->next) {
3398       if (!strcmp (ptr->fname, fname)) {
3399         close (f);
3400         return 0;                               /* This file was once'd.  */
3401       }
3402     }
3403
3404     for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
3405       if (!strcmp (ptr->fname, fname))
3406         break;                          /* This file was included before.  */
3407     }
3408
3409     if (ptr == 0) {
3410       /* This is the first time for this file.  */
3411       /* Add it to list of files included.  */
3412
3413       ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
3414       ptr->control_macro = 0;
3415       ptr->c_system_include_path = 0;
3416       ptr->next = pfile->all_include_files;
3417       pfile->all_include_files = ptr;
3418       ptr->fname = savestring (fname);
3419       ptr->got_name_map = 0;
3420
3421       /* For -M, add this file to the dependencies.  */
3422       if (CPP_PRINT_DEPS (pfile)
3423           > (angle_brackets || (pfile->system_include_depth > 0)))
3424         deps_output (pfile, fname, ' ');
3425     }
3426
3427     /* Handle -H option.  */
3428     if (CPP_OPTIONS(pfile)->print_include_names)
3429       {
3430         cpp_buffer *buf = CPP_BUFFER (pfile);
3431         while ((buf = CPP_PREV_BUFFER (buf)) != CPP_NULL_BUFFER (pfile))
3432           putc ('.', stderr);
3433         fprintf (stderr, "%s\n", fname);
3434       }
3435
3436     if (angle_brackets)
3437       pfile->system_include_depth++;
3438
3439     /* Actually process the file.  */
3440
3441     /* Record file on "seen" list for #import.  */
3442     add_import (pfile, f, fname);
3443
3444     pcftry = (char *) alloca (strlen (fname) + 30);
3445     pcfbuf = 0;
3446     pcfnum = 0;
3447
3448 #if 0
3449     if (!no_precomp)
3450       {
3451         struct stat stat_f;
3452
3453         fstat (f, &stat_f);
3454
3455         do {
3456           sprintf (pcftry, "%s%d", fname, pcfnum++);
3457
3458           pcf = open (pcftry, O_RDONLY, 0666);
3459           if (pcf != -1)
3460             {
3461               struct stat s;
3462
3463               fstat (pcf, &s);
3464               if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
3465                         sizeof (s.st_ino))
3466                   || stat_f.st_dev != s.st_dev)
3467                 {
3468                   pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
3469                   /* Don't need it any more.  */
3470                   close (pcf);
3471                 }
3472               else
3473                 {
3474                   /* Don't need it at all.  */
3475                   close (pcf);
3476                   break;
3477                 }
3478             }
3479         } while (pcf != -1 && !pcfbuf);
3480       }
3481 #endif
3482
3483     /* Actually process the file */
3484     if (cpp_push_buffer (pfile, NULL, 0) == NULL)
3485       return 0;
3486     if (finclude (pfile, f, fname, is_system_include (pfile, fname),
3487                   searchptr != dsp ? searchptr : SELF_DIR_DUMMY))
3488       {
3489         output_line_command (pfile, 0, enter_file);
3490         pfile->only_seen_white = 2;
3491       }
3492
3493     if (angle_brackets)
3494       pfile->system_include_depth--;
3495   }
3496   return 0;
3497 }
3498
3499 /* Return nonzero if there is no need to include file NAME
3500    because it has already been included and it contains a conditional
3501    to make a repeated include do nothing.  */
3502
3503 static int
3504 redundant_include_p (pfile, name)
3505      cpp_reader *pfile;
3506      char *name;
3507 {
3508   struct file_name_list *l = pfile->all_include_files;
3509   for (; l; l = l->next)
3510     if (! strcmp (name, l->fname)
3511         && l->control_macro
3512         && cpp_lookup (pfile, l->control_macro, -1, -1))
3513       return 1;
3514   return 0;
3515 }
3516
3517 /* Return nonzero if the given FILENAME is an absolute pathname which
3518    designates a file within one of the known "system" include file
3519    directories.  We assume here that if the given FILENAME looks like
3520    it is the name of a file which resides either directly in a "system"
3521    include file directory, or within any subdirectory thereof, then the
3522    given file must be a "system" include file.  This function tells us
3523    if we should suppress pedantic errors/warnings for the given FILENAME.
3524
3525    The value is 2 if the file is a C-language system header file
3526    for which C++ should (on most systems) assume `extern "C"'.  */
3527
3528 static int
3529 is_system_include (pfile, filename)
3530      cpp_reader *pfile;
3531      register char *filename;
3532 {
3533   struct file_name_list *searchptr;
3534
3535   for (searchptr = CPP_OPTIONS (pfile)->first_system_include; searchptr;
3536        searchptr = searchptr->next)
3537     if (searchptr->fname) {
3538       register char *sys_dir = searchptr->fname;
3539       register unsigned length = strlen (sys_dir);
3540
3541       if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
3542         {
3543           if (searchptr->c_system_include_path)
3544             return 2;
3545           else
3546             return 1;
3547         }
3548     }
3549   return 0;
3550 }
3551
3552 \f
3553 /*
3554  * Install a name in the assertion hash table.
3555  *
3556  * If LEN is >= 0, it is the length of the name.
3557  * Otherwise, compute the length by scanning the entire name.
3558  *
3559  * If HASH is >= 0, it is the precomputed hash code.
3560  * Otherwise, compute the hash code.
3561  */
3562
3563 static ASSERTION_HASHNODE *
3564 assertion_install (pfile, name, len, hash)
3565      cpp_reader *pfile;
3566      U_CHAR *name;
3567      int len;
3568      int hash;
3569 {
3570   register ASSERTION_HASHNODE *hp;
3571   register int i, bucket;
3572   register U_CHAR *p, *q;
3573
3574   i = sizeof (ASSERTION_HASHNODE) + len + 1;
3575   hp = (ASSERTION_HASHNODE *) xmalloc (i);
3576   bucket = hash;
3577   hp->bucket_hdr = &pfile->assertion_hashtab[bucket];
3578   hp->next = pfile->assertion_hashtab[bucket];
3579   pfile->assertion_hashtab[bucket] = hp;
3580   hp->prev = NULL;
3581   if (hp->next != NULL)
3582     hp->next->prev = hp;
3583   hp->length = len;
3584   hp->value = 0;
3585   hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
3586   p = hp->name;
3587   q = name;
3588   for (i = 0; i < len; i++)
3589     *p++ = *q++;
3590   hp->name[len] = 0;
3591   return hp;
3592 }
3593 /*
3594  * find the most recent hash node for name name (ending with first
3595  * non-identifier char) installed by install
3596  *
3597  * If LEN is >= 0, it is the length of the name.
3598  * Otherwise, compute the length by scanning the entire name.
3599  *
3600  * If HASH is >= 0, it is the precomputed hash code.
3601  * Otherwise, compute the hash code.
3602  */
3603
3604 static ASSERTION_HASHNODE *
3605 assertion_lookup (pfile, name, len, hash)
3606      cpp_reader *pfile;
3607      U_CHAR *name;
3608      int len;
3609      int hash;
3610 {
3611   register ASSERTION_HASHNODE *bucket;
3612
3613   bucket = pfile->assertion_hashtab[hash];
3614   while (bucket) {
3615     if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
3616       return bucket;
3617     bucket = bucket->next;
3618   }
3619   return NULL;
3620 }
3621
3622 static void
3623 delete_assertion (hp)
3624      ASSERTION_HASHNODE *hp;
3625 {
3626   struct tokenlist_list *tail;
3627   if (hp->prev != NULL)
3628     hp->prev->next = hp->next;
3629   if (hp->next != NULL)
3630     hp->next->prev = hp->prev;
3631
3632   for (tail = hp->value; tail; )
3633     {
3634       struct tokenlist_list *next = tail->next;
3635       free_token_list (tail->tokens);
3636       free (tail);
3637       tail = next;
3638     }
3639
3640   /* Make sure that the bucket chain header that
3641      the deleted guy was on points to the right thing afterwards.  */
3642   if (hp == *hp->bucket_hdr)
3643     *hp->bucket_hdr = hp->next;
3644
3645   free (hp);
3646 }
3647 \f
3648 /* Convert a character string literal into a nul-terminated string.
3649    The input string is [IN ... LIMIT).
3650    The result is placed in RESULT.  RESULT can be the same as IN.
3651    The value returned in the end of the string written to RESULT,
3652    or NULL on error.  */
3653
3654 static U_CHAR *
3655 convert_string (pfile, result, in, limit, handle_escapes)
3656      cpp_reader *pfile;
3657      register U_CHAR *result, *in, *limit;
3658      int handle_escapes;
3659 {
3660   U_CHAR c;
3661   c = *in++;
3662   if (c != '\"')
3663     return NULL;
3664   while (in < limit)
3665     {
3666       U_CHAR c = *in++;
3667       switch (c)
3668         {
3669         case '\0':
3670           return NULL;
3671         case '\"':
3672           limit = in;
3673           break;
3674         case '\\':
3675           if (handle_escapes)
3676             {
3677               char *bpc = (char *) in;
3678               int i = (U_CHAR) cpp_parse_escape (pfile, &bpc);
3679               in = (U_CHAR *) bpc;
3680               if (i >= 0)
3681                 *result++ = (U_CHAR)c;
3682               break;
3683             }
3684           /* else fall through */
3685         default:
3686           *result++ = c;
3687         }
3688     }
3689   *result = 0;
3690   return result;
3691 }
3692
3693 /*
3694  * interpret #line command.  Remembers previously seen fnames
3695  * in its very own hash table.
3696  */
3697 #define FNAME_HASHSIZE 37
3698
3699 static int
3700 do_line (pfile, keyword)
3701      cpp_reader *pfile;
3702      struct directive *keyword;
3703 {
3704   cpp_buffer *ip = CPP_BUFFER (pfile);
3705   int new_lineno;
3706   long old_written = CPP_WRITTEN (pfile);
3707   enum file_change_code file_change = same_file;
3708   enum cpp_token token;
3709   int i;
3710
3711   token = get_directive_token (pfile);
3712
3713   if (token != CPP_NUMBER
3714       || !isdigit(pfile->token_buffer[old_written]))
3715     {
3716       cpp_error (pfile, "invalid format `#line' command");
3717       goto bad_line_directive;
3718     }
3719
3720   /* The Newline at the end of this line remains to be processed.
3721      To put the next line at the specified line number,
3722      we must store a line number now that is one less.  */
3723   new_lineno = atoi (pfile->token_buffer + old_written) - 1;
3724   CPP_SET_WRITTEN (pfile, old_written);
3725
3726   /* NEW_LINENO is one less than the actual line number here.  */
3727   if (CPP_PEDANTIC (pfile) && new_lineno < 0)
3728     cpp_pedwarn (pfile, "line number out of range in `#line' command");
3729
3730 #if 0 /* #line 10"foo.c" is supposed to be allowed.  */
3731   if (PEEKC() && !is_space[PEEKC()]) {
3732     cpp_error (pfile, "invalid format `#line' command");
3733     goto bad_line_directive;
3734   }
3735 #endif
3736
3737   token = get_directive_token (pfile);
3738
3739   if (token == CPP_STRING) {
3740     U_CHAR *fname = pfile->token_buffer + old_written;
3741     U_CHAR *end_name;
3742     static HASHNODE *fname_table[FNAME_HASHSIZE];
3743     HASHNODE *hp, **hash_bucket;
3744     U_CHAR *p;
3745     long num_start;
3746     int fname_length;
3747
3748     /* Turn the file name, which is a character string literal,
3749        into a null-terminated string.  Do this in place.  */
3750     end_name = convert_string (pfile, fname, fname, CPP_PWRITTEN (pfile), 1);
3751     if (end_name == NULL)
3752     {
3753         cpp_error (pfile, "invalid format `#line' command");
3754         goto bad_line_directive;
3755     }
3756
3757     fname_length = end_name - fname;
3758
3759     num_start = CPP_WRITTEN (pfile);
3760     token = get_directive_token (pfile);
3761     if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
3762       p = pfile->token_buffer + num_start;
3763       if (CPP_PEDANTIC (pfile))
3764         cpp_pedwarn (pfile, "garbage at end of `#line' command");
3765
3766       if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
3767       {
3768         cpp_error (pfile, "invalid format `#line' command");
3769         goto bad_line_directive;
3770       }
3771       if (*p == '1')
3772         file_change = enter_file;
3773       else if (*p == 2)
3774         file_change = leave_file;
3775       else if (*p == 3)
3776         ip->system_header_p = 1;
3777       else /* if (*p == 4) */
3778         ip->system_header_p = 2;
3779
3780       CPP_SET_WRITTEN (pfile, num_start);
3781       token = get_directive_token (pfile);
3782       p = pfile->token_buffer + num_start;
3783       if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
3784         ip->system_header_p = *p == 3 ? 1 : 2;
3785         token = get_directive_token (pfile);
3786       }
3787       if (token != CPP_VSPACE) {
3788         cpp_error (pfile, "invalid format `#line' command");
3789         goto bad_line_directive;
3790       }
3791     }
3792
3793     hash_bucket =
3794       &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
3795     for (hp = *hash_bucket; hp != NULL; hp = hp->next)
3796       if (hp->length == fname_length &&
3797           strncmp (hp->value.cpval, fname, fname_length) == 0) {
3798         ip->nominal_fname = hp->value.cpval;
3799         break;
3800       }
3801     if (hp == 0) {
3802       /* Didn't find it; cons up a new one.  */
3803       hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
3804       hp->next = *hash_bucket;
3805       *hash_bucket = hp;
3806
3807       hp->length = fname_length;
3808       ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
3809       bcopy (fname, hp->value.cpval, fname_length);
3810     }
3811   }
3812   else if (token != CPP_VSPACE && token != CPP_EOF) {
3813     cpp_error (pfile, "invalid format `#line' command");
3814     goto bad_line_directive;
3815   }
3816
3817   ip->lineno = new_lineno;
3818  bad_line_directive:
3819   skip_rest_of_line (pfile);
3820   CPP_SET_WRITTEN (pfile, old_written);
3821   output_line_command (pfile, 0, file_change);
3822   return 0;
3823 }
3824
3825 /*
3826  * remove the definition of a symbol from the symbol table.
3827  * according to un*x /lib/cpp, it is not an error to undef
3828  * something that has no definitions, so it isn't one here either.
3829  */
3830
3831 static int
3832 do_undef (pfile, keyword, buf, limit)
3833      cpp_reader *pfile;
3834      struct directive *keyword;
3835      U_CHAR *buf, *limit;
3836 {
3837   int sym_length;
3838   HASHNODE *hp;
3839   U_CHAR *orig_buf = buf;
3840
3841 #if 0
3842   /* If this is a precompiler run (with -pcp) pass thru #undef commands.  */
3843   if (pcp_outfile && keyword)
3844     pass_thru_directive (buf, limit, pfile, keyword);
3845 #endif
3846
3847   SKIP_WHITE_SPACE (buf);
3848   sym_length = check_macro_name (pfile, buf, "macro");
3849
3850   while ((hp = cpp_lookup (pfile, buf, sym_length, -1)) != NULL)
3851     {
3852       /* If we are generating additional info for debugging (with -g) we
3853          need to pass through all effective #undef commands.  */
3854       if (CPP_OPTIONS (pfile)->debug_output && keyword)
3855         pass_thru_directive (orig_buf, limit, pfile, keyword);
3856       if (hp->type != T_MACRO)
3857         cpp_warning (pfile, "undefining `%s'", hp->name);
3858       delete_macro (hp);
3859     }
3860
3861   if (CPP_PEDANTIC (pfile)) {
3862     buf += sym_length;
3863     SKIP_WHITE_SPACE (buf);
3864     if (buf != limit)
3865       cpp_pedwarn (pfile, "garbage after `#undef' directive");
3866   }
3867   return 0;
3868 }
3869 \f
3870 /*
3871  * Report an error detected by the program we are processing.
3872  * Use the text of the line in the error message.
3873  * (We use error because it prints the filename & line#.)
3874  */
3875
3876 static int
3877 do_error (pfile, keyword, buf, limit)
3878      cpp_reader *pfile;
3879      struct directive *keyword;
3880      U_CHAR *buf, *limit;
3881 {
3882   int length = limit - buf;
3883   U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
3884   bcopy (buf, copy, length);
3885   copy[length] = 0;
3886   SKIP_WHITE_SPACE (copy);
3887   cpp_error (pfile, "#error %s", copy);
3888   return 0;
3889 }
3890
3891 /*
3892  * Report a warning detected by the program we are processing.
3893  * Use the text of the line in the warning message, then continue.
3894  * (We use error because it prints the filename & line#.)
3895  */
3896
3897 static int
3898 do_warning (pfile, keyword, buf, limit)
3899      cpp_reader *pfile;
3900      struct directive *keyword;
3901      U_CHAR *buf, *limit;
3902 {
3903   int length = limit - buf;
3904   U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
3905   bcopy (buf, copy, length);
3906   copy[length] = 0;
3907   SKIP_WHITE_SPACE (copy);
3908   cpp_warning (pfile, "#warning %s", copy);
3909   return 0;
3910 }
3911
3912 /* Remember the name of the current file being read from so that we can
3913    avoid ever including it again.  */
3914
3915 static int
3916 do_once (pfile)
3917      cpp_reader *pfile;
3918 {
3919   cpp_buffer *ip = NULL;
3920   struct file_name_list *new;
3921
3922   for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
3923     {
3924       if (ip == CPP_NULL_BUFFER (pfile))
3925         return 0;
3926       if (ip->fname != NULL)
3927         break;
3928     }
3929
3930
3931   new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
3932   new->next = pfile->dont_repeat_files;
3933   pfile->dont_repeat_files = new;
3934   new->fname = savestring (ip->fname);
3935   new->control_macro = 0;
3936   new->got_name_map = 0;
3937   new->c_system_include_path = 0;
3938
3939   return 0;
3940 }
3941
3942 /* #ident has already been copied to the output file, so just ignore it.  */
3943
3944 static int
3945 do_ident (pfile, keyword, buf, limit)
3946      cpp_reader *pfile;
3947      struct directive *keyword;
3948      U_CHAR *buf, *limit;
3949 {
3950 /*  long old_written = CPP_WRITTEN (pfile);*/
3951   int len;
3952
3953   /* Allow #ident in system headers, since that's not user's fault.  */
3954   if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
3955     cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");
3956
3957   /* Leave rest of line to be read by later calls to cpp_get_token.  */
3958
3959   return 0;
3960 }
3961
3962 /* #pragma and its argument line have already been copied to the output file.
3963    Just check for some recognized pragmas that need validation here.  */
3964
3965 static int
3966 do_pragma (pfile, keyword, buf, limit)
3967      cpp_reader *pfile;
3968      struct directive *keyword;
3969      U_CHAR *buf, *limit;
3970 {
3971   while (*buf == ' ' || *buf == '\t')
3972     buf++;
3973   if (!strncmp (buf, "once", 4)) {
3974     /* Allow #pragma once in system headers, since that's not the user's
3975        fault.  */
3976     if (!CPP_BUFFER (pfile)->system_header_p)
3977       cpp_warning (pfile, "`#pragma once' is obsolete");
3978     do_once (pfile);
3979   }
3980
3981   if (!strncmp (buf, "implementation", 14)) {
3982     /* Be quiet about `#pragma implementation' for a file only if it hasn't
3983        been included yet.  */
3984     struct file_name_list *ptr;
3985     U_CHAR *p = buf + 14, *fname, *inc_fname;
3986     int fname_len;
3987     SKIP_WHITE_SPACE (p);
3988     if (*p == '\n' || *p != '\"')
3989       return 0;
3990
3991     fname = p + 1;
3992     p = (U_CHAR *) index (fname, '\"');
3993     fname_len = p != NULL ? p - fname : strlen (fname);
3994
3995     for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
3996       inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
3997       inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
3998       if (inc_fname && !strncmp (inc_fname, fname, fname_len))
3999         cpp_warning (pfile,
4000            "`#pragma implementation' for `%s' appears after file is included",
4001                      fname);
4002     }
4003   }
4004
4005   return 0;
4006 }
4007
4008 #if 0
4009 /* This was a fun hack, but #pragma seems to start to be useful.
4010    By failing to recognize it, we pass it through unchanged to cc1.  */
4011
4012 /*
4013  * the behavior of the #pragma directive is implementation defined.
4014  * this implementation defines it as follows.
4015  */
4016
4017 static int
4018 do_pragma ()
4019 {
4020   close (0);
4021   if (open ("/dev/tty", O_RDONLY, 0666) != 0)
4022     goto nope;
4023   close (1);
4024   if (open ("/dev/tty", O_WRONLY, 0666) != 1)
4025     goto nope;
4026   execl ("/usr/games/hack", "#pragma", 0);
4027   execl ("/usr/games/rogue", "#pragma", 0);
4028   execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
4029   execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
4030 nope:
4031   fatal ("You are in a maze of twisty compiler features, all different");
4032 }
4033 #endif
4034
4035 /* Just ignore #sccs, on systems where we define it at all.  */
4036
4037 static int
4038 do_sccs (pfile, keyword, buf, limit)
4039      cpp_reader *pfile;
4040      struct directive *keyword;
4041      U_CHAR *buf, *limit;
4042 {
4043   if (CPP_PEDANTIC (pfile))
4044     cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
4045   return 0;
4046 }
4047 \f
4048 /*
4049  * handle #if command by
4050  *   1) inserting special `defined' keyword into the hash table
4051  *      that gets turned into 0 or 1 by special_symbol (thus,
4052  *      if the luser has a symbol called `defined' already, it won't
4053  *      work inside the #if command)
4054  *   2) rescan the input into a temporary output buffer
4055  *   3) pass the output buffer to the yacc parser and collect a value
4056  *   4) clean up the mess left from steps 1 and 2.
4057  *   5) call conditional_skip to skip til the next #endif (etc.),
4058  *      or not, depending on the value from step 3.
4059  */
4060
4061 static int
4062 do_if (pfile, keyword, buf, limit)
4063      cpp_reader *pfile;
4064      struct directive *keyword;
4065      U_CHAR *buf, *limit;
4066 {
4067   HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
4068   conditional_skip (pfile, value == 0, T_IF, NULL_PTR);
4069   return 0;
4070 }
4071
4072 /*
4073  * handle a #elif directive by not changing  if_stack  either.
4074  * see the comment above do_else.
4075  */
4076
4077 static int
4078 do_elif (pfile, keyword, buf, limit)
4079      cpp_reader *pfile;
4080      struct directive *keyword;
4081      U_CHAR *buf, *limit;
4082 {
4083   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
4084     cpp_error (pfile, "`#elif' not within a conditional");
4085     return 0;
4086   } else {
4087     if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
4088       cpp_error (pfile, "`#elif' after `#else'");
4089 #if 0
4090       fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
4091 #endif
4092       if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
4093           && strcmp (pfile->if_stack->fname,
4094                      CPP_BUFFER (pfile)->nominal_fname) != 0)
4095         fprintf (stderr, ", file %s", pfile->if_stack->fname);
4096       fprintf (stderr, ")\n");
4097     }
4098     pfile->if_stack->type = T_ELIF;
4099   }
4100
4101   if (pfile->if_stack->if_succeeded)
4102     skip_if_group (pfile, 0);
4103   else {
4104     HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
4105     if (value == 0)
4106       skip_if_group (pfile, 0);
4107     else {
4108       ++pfile->if_stack->if_succeeded;  /* continue processing input */
4109       output_line_command (pfile, 1, same_file);
4110     }
4111   }
4112   return 0;
4113 }
4114
4115 /*
4116  * evaluate a #if expression in BUF, of length LENGTH,
4117  * then parse the result as a C expression and return the value as an int.
4118  */
4119
4120 static HOST_WIDE_INT
4121 eval_if_expression (pfile, buf, length)
4122      cpp_reader *pfile;
4123      U_CHAR *buf;
4124      int length;
4125 {
4126   HASHNODE *save_defined;
4127   HOST_WIDE_INT value;
4128   long old_written = CPP_WRITTEN (pfile);
4129
4130   save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1);
4131   pfile->pcp_inside_if = 1;
4132
4133   value = cpp_parse_expr (pfile);
4134   pfile->pcp_inside_if = 0;
4135   delete_macro (save_defined);  /* clean up special symbol */
4136
4137   CPP_SET_WRITTEN (pfile, old_written); /* Pop */
4138
4139   return value;
4140 }
4141
4142 /*
4143  * routine to handle ifdef/ifndef.  Try to look up the symbol,
4144  * then do or don't skip to the #endif/#else/#elif depending
4145  * on what directive is actually being processed.
4146  */
4147
4148 static int
4149 do_xifdef (pfile, keyword, unused1, unused2)
4150      cpp_reader *pfile;
4151      struct directive *keyword;
4152      U_CHAR *unused1, *unused2;
4153 {
4154   int skip;
4155   cpp_buffer *ip = CPP_BUFFER (pfile);
4156   U_CHAR *ident;
4157   int ident_length;
4158   enum cpp_token token;
4159   int start_of_file = 0;
4160   U_CHAR *control_macro = 0;
4161   int old_written = CPP_WRITTEN (pfile);
4162
4163   /* Detect a #ifndef at start of file (not counting comments).  */
4164   if (ip->fname != 0 && keyword->type == T_IFNDEF)
4165     start_of_file = pfile->only_seen_white == 2;
4166
4167   pfile->no_macro_expand++;
4168   token = get_directive_token (pfile);
4169   pfile->no_macro_expand--;
4170
4171   ident = pfile->token_buffer + old_written;
4172   ident_length = CPP_WRITTEN (pfile) - old_written;
4173   CPP_SET_WRITTEN (pfile, old_written); /* Pop */
4174
4175   if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
4176     {
4177       skip = (keyword->type == T_IFDEF);
4178       if (! CPP_TRADITIONAL (pfile))
4179         cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
4180     }
4181   else if (token == CPP_NAME)
4182     {
4183       HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
4184       skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
4185       if (start_of_file && !skip)
4186         {
4187           control_macro = (U_CHAR *) xmalloc (ident_length + 1);
4188           bcopy (ident, control_macro, ident_length + 1);
4189         }
4190     }
4191   else
4192     {
4193       skip = (keyword->type == T_IFDEF);
4194       if (! CPP_TRADITIONAL (pfile))
4195         cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
4196     }
4197
4198   if (!CPP_TRADITIONAL (pfile))
4199     { int c;
4200       cpp_skip_hspace (pfile);
4201       c = PEEKC ();
4202       if (c != EOF && c != '\n')
4203         cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
4204     }
4205   skip_rest_of_line (pfile);
4206
4207 #if 0
4208     if (pcp_outfile) {
4209       /* Output a precondition for this macro.  */
4210       if (hp && hp->value.defn->predefined)
4211         fprintf (pcp_outfile, "#define %s\n", hp->name);
4212       else {
4213         U_CHAR *cp = buf;
4214         fprintf (pcp_outfile, "#undef ");
4215         while (is_idchar[*cp]) /* Ick! */
4216           fputc (*cp++, pcp_outfile);
4217         putc ('\n', pcp_outfile);
4218       }
4219 #endif
4220
4221   conditional_skip (pfile, skip, T_IF, control_macro);
4222   return 0;
4223 }
4224
4225 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
4226    If this is a #ifndef starting at the beginning of a file,
4227    CONTROL_MACRO is the macro name tested by the #ifndef.
4228    Otherwise, CONTROL_MACRO is 0.  */
4229
4230 static void
4231 conditional_skip (pfile, skip, type, control_macro)
4232      cpp_reader *pfile;
4233      int skip;
4234      enum node_type type;
4235      U_CHAR *control_macro;
4236 {
4237   IF_STACK_FRAME *temp;
4238
4239   temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
4240   temp->fname = CPP_BUFFER (pfile)->nominal_fname;
4241 #if 0
4242   temp->lineno = CPP_BUFFER (pfile)->lineno;
4243 #endif
4244   temp->next = pfile->if_stack;
4245   temp->control_macro = control_macro;
4246   pfile->if_stack = temp;
4247
4248   pfile->if_stack->type = type;
4249
4250   if (skip != 0) {
4251     skip_if_group (pfile, 0);
4252     return;
4253   } else {
4254     ++pfile->if_stack->if_succeeded;
4255     output_line_command (pfile, 1, same_file);
4256   }
4257 }
4258
4259 /*
4260  * skip to #endif, #else, or #elif.  adjust line numbers, etc.
4261  * leaves input ptr at the sharp sign found.
4262  * If ANY is nonzero, return at next directive of any sort.
4263  */
4264
4265 static void
4266 skip_if_group (pfile, any)
4267      cpp_reader *pfile;
4268      int any;
4269 {
4270   int c;
4271   int at_beg_of_line = 1;
4272   struct directive *kt;
4273   IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
4274 #if 0
4275   U_CHAR *beg_of_line = bp;
4276 #endif
4277   register int ident_length;
4278   U_CHAR *ident, *after_ident;
4279   struct parse_marker line_start_mark;
4280
4281   parse_set_mark (&line_start_mark, pfile);
4282
4283   if (CPP_OPTIONS (pfile)->output_conditionals) {
4284     static char failed[] = "#failed\n";
4285     CPP_PUTS (pfile, failed, sizeof(failed)-1);
4286     pfile->lineno++;
4287     output_line_command (pfile, 1, same_file);
4288   }
4289
4290  beg_of_line:
4291   if (CPP_OPTIONS (pfile)->output_conditionals)
4292     {
4293       cpp_buffer *pbuf = CPP_BUFFER (pfile);
4294       U_CHAR *start_line = pbuf->buf + line_start_mark.position;
4295       CPP_PUTS (pfile, start_line, pbuf->cur - start_line);
4296     }
4297   parse_move_mark (&line_start_mark, pfile);
4298   if (!CPP_TRADITIONAL (pfile))
4299       cpp_skip_hspace (pfile);
4300   c  = GETC();
4301   if (c == '#')
4302     {
4303       int old_written = CPP_WRITTEN (pfile);
4304       cpp_skip_hspace (pfile);
4305
4306       parse_name (pfile, GETC());
4307       ident_length = CPP_WRITTEN (pfile) - old_written;
4308       ident = pfile->token_buffer + old_written;
4309       pfile->limit = ident;
4310 #if 0
4311       if (ident_length == 0)
4312         goto not_a_directive;
4313
4314       /* Handle # followed by a line number.  */
4315
4316       /* Avoid error for `###' and similar cases unless -pedantic.  */
4317 #endif
4318
4319       for (kt = directive_table; kt->length >= 0; kt++)
4320         {
4321           IF_STACK_FRAME *temp;
4322           if (ident_length == kt->length
4323               && strncmp (ident, kt->name, kt->length) == 0)
4324             {
4325               /* If we are asked to return on next directive, do so now.  */
4326               if (any)
4327                 goto done;
4328
4329               switch (kt->type)
4330                 {
4331                 case T_IF:
4332                 case T_IFDEF:
4333                 case T_IFNDEF:
4334                   temp
4335                     = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
4336                   temp->next = pfile->if_stack;
4337                   pfile->if_stack = temp;
4338 #if 0
4339                   temp->lineno = CPP_BUFFER(pfile)->lineno;
4340 #endif
4341                   temp->fname = CPP_BUFFER(pfile)->nominal_fname;
4342                   temp->type = kt->type;
4343                   break;
4344                 case T_ELSE:
4345                 case T_ENDIF:
4346                   if (CPP_PEDANTIC (pfile) && pfile->if_stack != save_if_stack)
4347                     validate_else (pfile,
4348                                    kt->type == T_ELSE ? "#else" : "#endif");
4349                 case T_ELIF:
4350                   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
4351                     {
4352                       cpp_error (pfile,
4353                                  "`#%s' not within a conditional", kt->name);
4354                       break;
4355                     }
4356                   else if (pfile->if_stack == save_if_stack)
4357                     goto done;          /* found what we came for */
4358
4359                   if (kt->type != T_ENDIF)
4360                     {
4361                       if (pfile->if_stack->type == T_ELSE)
4362                         cpp_error (pfile, "`#else' or `#elif' after `#else'");
4363                       pfile->if_stack->type = kt->type;
4364                       break;
4365                     }
4366
4367                   temp = pfile->if_stack;
4368                   pfile->if_stack = temp->next;
4369                   free (temp);
4370                   break;
4371               default: ;
4372                 }
4373               break;
4374             }
4375           /* Don't let erroneous code go by.  */
4376           if (kt->length < 0 && !CPP_OPTIONS (pfile)->lang_asm
4377               && CPP_PEDANTIC (pfile))
4378             cpp_pedwarn (pfile, "invalid preprocessor directive name");
4379         }
4380       c = GETC ();
4381     }
4382   /* We're in the middle of a line.  Skip the rest of it.  */
4383   for (;;) {
4384     switch (c)
4385       {
4386         long old;
4387       case EOF:
4388         goto done;
4389       case '/':                 /* possible comment */
4390         c = skip_comment (pfile, NULL);
4391         if (c == EOF)
4392           goto done;
4393         break;
4394       case '\"':
4395       case '\'':
4396         FORWARD(-1);
4397         old = CPP_WRITTEN (pfile);
4398         cpp_get_token (pfile);
4399         CPP_SET_WRITTEN (pfile, old);
4400         break;
4401       case '\\':
4402         /* Char after backslash loses its special meaning.  */
4403         if (PEEKC() == '\n')
4404           FORWARD (1);
4405         break;
4406       case '\n':
4407         goto beg_of_line;
4408         break;
4409       }
4410     c = GETC ();
4411   }
4412  done:
4413   if (CPP_OPTIONS (pfile)->output_conditionals) {
4414     static char end_failed[] = "#endfailed\n";
4415     CPP_PUTS (pfile, end_failed, sizeof(end_failed)-1);
4416     pfile->lineno++;
4417   }
4418   pfile->only_seen_white = 1;
4419   parse_goto_mark (&line_start_mark, pfile);
4420   parse_clear_mark (&line_start_mark);
4421 }
4422
4423 /*
4424  * handle a #else directive.  Do this by just continuing processing
4425  * without changing  if_stack ;  this is so that the error message
4426  * for missing #endif's etc. will point to the original #if.  It
4427  * is possible that something different would be better.
4428  */
4429
4430 static int
4431 do_else (pfile, keyword, buf, limit)
4432      cpp_reader *pfile;
4433      struct directive *keyword;
4434      U_CHAR *buf, *limit;
4435 {
4436   cpp_buffer *ip = CPP_BUFFER (pfile);
4437
4438   if (CPP_PEDANTIC (pfile))
4439     validate_else (pfile, "#else");
4440   skip_rest_of_line (pfile);
4441
4442   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
4443     cpp_error (pfile, "`#else' not within a conditional");
4444     return 0;
4445   } else {
4446     /* #ifndef can't have its special treatment for containing the whole file
4447        if it has a #else clause.  */
4448     pfile->if_stack->control_macro = 0;
4449
4450     if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
4451       cpp_error (pfile, "`#else' after `#else'");
4452       fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
4453       if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
4454         fprintf (stderr, ", file %s", pfile->if_stack->fname);
4455       fprintf (stderr, ")\n");
4456     }
4457     pfile->if_stack->type = T_ELSE;
4458   }
4459
4460   if (pfile->if_stack->if_succeeded)
4461     skip_if_group (pfile, 0);
4462   else {
4463     ++pfile->if_stack->if_succeeded;    /* continue processing input */
4464     output_line_command (pfile, 1, same_file);
4465   }
4466   return 0;
4467 }
4468
4469 /*
4470  * unstack after #endif command
4471  */
4472
4473 static int
4474 do_endif (pfile, keyword, buf, limit)
4475      cpp_reader *pfile;
4476      struct directive *keyword;
4477      U_CHAR *buf, *limit;
4478 {
4479   if (CPP_PEDANTIC (pfile))
4480     validate_else (pfile, "#endif");
4481   skip_rest_of_line (pfile);
4482
4483   if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
4484     cpp_error (pfile, "unbalanced `#endif'");
4485   else
4486     {
4487       IF_STACK_FRAME *temp = pfile->if_stack;
4488       pfile->if_stack = temp->next;
4489       if (temp->control_macro != 0)
4490         {
4491           /* This #endif matched a #ifndef at the start of the file.
4492              See if it is at the end of the file.  */
4493           struct parse_marker start_mark;
4494           int c;
4495
4496           parse_set_mark (&start_mark, pfile);
4497
4498           for (;;)
4499             {
4500               cpp_skip_hspace (pfile);
4501               c = GETC ();
4502               if (c != '\n')
4503                 break;
4504             }
4505           parse_goto_mark (&start_mark, pfile);
4506           parse_clear_mark (&start_mark);
4507
4508           if (c == EOF)
4509             {
4510               /* If we get here, this #endif ends a #ifndef
4511                  that contains all of the file (aside from whitespace).
4512                  Arrange not to include the file again
4513                  if the macro that was tested is defined.
4514
4515                  Do not do this for the top-level file in a -include or any
4516                  file in a -imacros.  */
4517 #if 0
4518 FIXME!
4519               if (indepth != 0
4520                   && ! (indepth == 1 && pfile->no_record_file)
4521                   && ! (pfile->no_record_file && no_output))
4522 #endif
4523                 {
4524                   struct file_name_list *ifile = pfile->all_include_files;
4525
4526                   for ( ; ifile != NULL; ifile = ifile->next)
4527                     {
4528                       if (!strcmp (ifile->fname, CPP_BUFFER (pfile)->fname))
4529                         {
4530                           ifile->control_macro = temp->control_macro;
4531                           break;
4532                         }
4533                     }
4534                 }
4535             }
4536         }
4537       free (temp);
4538       output_line_command (pfile, 1, same_file);
4539     }
4540   return 0;
4541 }
4542
4543 /* When an #else or #endif is found while skipping failed conditional,
4544    if -pedantic was specified, this is called to warn about text after
4545    the command name.  P points to the first char after the command name.  */
4546
4547 static void
4548 validate_else (pfile, directive)
4549      cpp_reader *pfile;
4550      char *directive;
4551 {
4552   int c;
4553   cpp_skip_hspace (pfile);
4554   c = PEEKC ();
4555   if (c != EOF && c != '\n')
4556     cpp_pedwarn (pfile,
4557                  "text following `%s' violates ANSI standard", directive);
4558 }
4559
4560 /* Get the next token, and add it to the text in pfile->token_buffer.
4561    Return the kind of token we got.  */
4562
4563 enum cpp_token
4564 cpp_get_token (pfile)
4565      cpp_reader *pfile;
4566 {
4567   register int c, c2, c3;
4568   long old_written;
4569   long start_line, start_column;
4570   enum cpp_token token;
4571   struct cpp_options *opts = CPP_OPTIONS (pfile);
4572   CPP_BUFFER (pfile)->prev = CPP_BUFFER (pfile)->cur;
4573  get_next:
4574   c = GETC();
4575   if (c == EOF)
4576     {
4577     handle_eof:
4578       if (CPP_BUFFER (pfile)->seen_eof)
4579         {
4580           if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
4581             goto get_next;
4582           else
4583             return CPP_EOF;
4584         }
4585       else
4586         {
4587           cpp_buffer *next_buf
4588             = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
4589           CPP_BUFFER (pfile)->seen_eof = 1;
4590           if (CPP_BUFFER (pfile)->nominal_fname
4591               && next_buf != CPP_NULL_BUFFER (pfile))
4592             {
4593               /* We're about to return from an #include file.
4594                  Emit #line information now (as part of the CPP_POP) result.
4595                  But the #line refers to the file we will pop to.  */
4596               cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
4597               CPP_BUFFER (pfile) = next_buf;
4598               pfile->input_stack_listing_current = 0;
4599               output_line_command (pfile, 0, leave_file);
4600               CPP_BUFFER (pfile) = cur_buffer;
4601             }
4602           return CPP_POP;
4603         }
4604     }
4605   else
4606     {
4607       switch (c)
4608         {
4609           long newlines;
4610           struct parse_marker start_mark;
4611         case '/':
4612           if (PEEKC () == '=')
4613             goto op2;
4614           if (opts->put_out_comments)
4615             parse_set_mark (&start_mark, pfile);
4616           newlines = 0;
4617           cpp_buf_line_and_col (cpp_file_buffer (pfile),
4618                                 &start_line, &start_column);
4619           c = skip_comment (pfile, &newlines);
4620           if (opts->put_out_comments && (c == '/' || c == EOF))
4621             parse_clear_mark (&start_mark);
4622           if (c == '/')
4623             goto randomchar;
4624           if (c == EOF)
4625             {
4626               cpp_error_with_line (pfile, start_line, start_column,
4627                                    "unterminated comment");
4628               goto handle_eof;
4629             }
4630           c = '/';  /* Initial letter of comment.  */
4631         return_comment:
4632           /* Comments are equivalent to spaces.
4633              For -traditional, a comment is equivalent to nothing.  */
4634           if (opts->put_out_comments)
4635             {
4636               cpp_buffer *pbuf = CPP_BUFFER (pfile);
4637               long dummy;
4638               U_CHAR *start = pbuf->buf + start_mark.position;
4639               int len = pbuf->cur - start;
4640               CPP_RESERVE(pfile, 1 + len);
4641               CPP_PUTC_Q (pfile, c);
4642               CPP_PUTS_Q (pfile, start, len);
4643               pfile->lineno += newlines;
4644               parse_clear_mark (&start_mark);
4645               return CPP_COMMENT;
4646             }
4647           else if (CPP_TRADITIONAL (pfile))
4648             {
4649               return CPP_COMMENT;
4650             }
4651           else
4652             {
4653 #if 0
4654               /* This may not work if cpp_get_token is called recursively,
4655                  since many places look for horizontal space.  */
4656               if (newlines)
4657                 {
4658                   /* Copy the newlines into the output buffer, in order to
4659                      avoid the pain of a #line every time a multiline comment
4660                      is seen.  */
4661                   CPP_RESERVE(pfile, newlines);
4662                   while (--newlines >= 0)
4663                     {
4664                       CPP_PUTC_Q (pfile, '\n');
4665                       pfile->lineno++;
4666                     }
4667                   return CPP_VSPACE;
4668                 }
4669 #endif
4670               CPP_RESERVE(pfile, 1);
4671               CPP_PUTC_Q (pfile, ' ');
4672               return CPP_HSPACE;
4673             }
4674 #if 0
4675           if (opts->for_lint) {
4676             U_CHAR *argbp;
4677             int cmdlen, arglen;
4678             char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
4679
4680             if (lintcmd != NULL) {
4681               /* I believe it is always safe to emit this newline: */
4682               obp[-1] = '\n';
4683               bcopy ("#pragma lint ", (char *) obp, 13);
4684               obp += 13;
4685               bcopy (lintcmd, (char *) obp, cmdlen);
4686               obp += cmdlen;
4687
4688               if (arglen != 0) {
4689                 *(obp++) = ' ';
4690                 bcopy (argbp, (char *) obp, arglen);
4691                 obp += arglen;
4692               }
4693
4694               /* OK, now bring us back to the state we were in before we entered
4695                  this branch.  We need #line b/c the newline for the pragma
4696                  could fuck things up.  */
4697               output_line_command (pfile, 0, same_file);
4698               *(obp++) = ' ';   /* just in case, if comments are copied thru */
4699               *(obp++) = '/';
4700             }
4701           }
4702 #endif
4703
4704         case '#':
4705 #if 0
4706           /* If this is expanding a macro definition, don't recognize
4707              preprocessor directives.  */
4708           if (ip->macro != 0)
4709             goto randomchar;
4710           /* If this is expand_into_temp_buffer, recognize them
4711              only after an actual newline at this level,
4712              not at the beginning of the input level.  */
4713           if (ip->fname == 0 && beg_of_line == ip->buf)
4714             goto randomchar;
4715           if (ident_length)
4716             goto specialchar;
4717 #endif
4718
4719           if (!pfile->only_seen_white)
4720             goto randomchar;
4721           if (handle_directive (pfile))
4722             return CPP_DIRECTIVE;
4723           pfile->only_seen_white = 0;
4724           return CPP_OTHER;
4725
4726         case '\"':
4727         case '\'':
4728           /* A single quoted string is treated like a double -- some
4729              programs (e.g., troff) are perverse this way */
4730           cpp_buf_line_and_col (cpp_file_buffer (pfile),
4731                                 &start_line, &start_column);
4732           old_written = CPP_WRITTEN (pfile);
4733         string:
4734           CPP_PUTC (pfile, c);
4735           while (1)
4736             {
4737               int cc = GETC();
4738               if (cc == EOF)
4739                 {
4740                   if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
4741                     {
4742                       /* try harder: this string crosses a macro expansion
4743                          boundary.  This can happen naturally if -traditional.
4744                          Otherwise, only -D can make a macro with an unmatched
4745                          quote.  */
4746                         cpp_buffer *next_buf
4747                             = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
4748                         (*CPP_BUFFER (pfile)->cleanup)
4749                             (CPP_BUFFER (pfile), pfile);
4750                         CPP_BUFFER (pfile) = next_buf;
4751                         continue;
4752                     }
4753                   if (!CPP_TRADITIONAL (pfile))
4754                     {
4755                       cpp_error_with_line (pfile, start_line, start_column,
4756                               "unterminated string or character constant");
4757                       if (pfile->multiline_string_line != start_line
4758                           && pfile->multiline_string_line != 0)
4759                         cpp_error_with_line (pfile,
4760                                              pfile->multiline_string_line, -1,
4761                                "possible real start of unterminated constant");
4762                       pfile->multiline_string_line = 0;
4763                     }
4764                   break;
4765                 }
4766               CPP_PUTC (pfile, cc);
4767               switch (cc)
4768                 {
4769                 case '\n':
4770                   /* Traditionally, end of line ends a string constant with
4771                  no error.  So exit the loop and record the new line.  */
4772                   if (CPP_TRADITIONAL (pfile))
4773                     goto while2end;
4774                   if (c == '\'')
4775                     {
4776                       cpp_error_with_line (pfile, start_line, start_column,
4777                                            "unterminated character constant");
4778                       goto while2end;
4779                     }
4780                   if (CPP_PEDANTIC (pfile)
4781                       && pfile->multiline_string_line == 0)
4782                     {
4783                       cpp_pedwarn_with_line (pfile, start_line, start_column,
4784                                "string constant runs past end of line");
4785                     }
4786                   if (pfile->multiline_string_line == 0)
4787                     pfile->multiline_string_line = start_line;
4788                   break;
4789
4790                 case '\\':
4791                   cc = GETC();
4792                   if (cc == '\n')
4793                     {
4794                       /* Backslash newline is replaced by nothing at all.  */
4795                       CPP_ADJUST_WRITTEN (pfile, -1);
4796                       pfile->lineno++;
4797                     }
4798                   else
4799                     {
4800                       /* ANSI stupidly requires that in \\ the second \
4801                          is *not* prevented from combining with a newline.  */
4802                       NEWLINE_FIX1(cc);
4803                       if (cc != EOF)
4804                         CPP_PUTC (pfile, cc);
4805                     }
4806                   break;
4807
4808                 case '\"':
4809                 case '\'':
4810                   if (cc == c)
4811                     goto while2end;
4812                   break;
4813                 }
4814             }
4815         while2end:
4816           pfile->lineno += count_newlines (pfile->token_buffer + old_written,
4817                                            CPP_PWRITTEN (pfile));
4818           pfile->only_seen_white = 0;
4819           return c == '\'' ? CPP_CHAR : CPP_STRING;
4820
4821         case '$':
4822           if (!opts->dollars_in_ident)
4823             goto randomchar;
4824           goto letter;
4825
4826         case ':':
4827           if (opts->cplusplus && PEEKC () == ':')
4828             goto op2;
4829           goto randomchar;
4830
4831         case '&':
4832         case '+':
4833         case '|':
4834           NEWLINE_FIX;
4835           c2 = PEEKC ();
4836           if (c2 == c || c2 == '=')
4837             goto op2;
4838           goto randomchar;
4839
4840         case '*':
4841         case '!':
4842         case '%':
4843         case '=':
4844         case '^':
4845           NEWLINE_FIX;
4846           if (PEEKC () == '=')
4847             goto op2;
4848           goto randomchar;
4849
4850         case '-':
4851           NEWLINE_FIX;
4852           c2 = PEEKC ();
4853           if (c2 == '-' && opts->chill)
4854             {
4855               /* Chill style comment */
4856               if (opts->put_out_comments)
4857                 parse_set_mark (&start_mark, pfile);
4858               FORWARD(1);  /* Skip second '-'.  */
4859               for (;;)
4860                 {
4861                   c = GETC ();
4862                   if (c == EOF)
4863                     break;
4864                   if (c == '\n')
4865                     {
4866                       /* Don't consider final '\n' to be part of comment.  */
4867                       FORWARD(-1);
4868                       break;
4869                     }
4870                 }
4871               c = '-';
4872               goto return_comment;
4873             }
4874           if (c2 == '-' || c2 == '=' || c2 == '>')
4875             goto op2;
4876           goto randomchar;
4877
4878         case '<':
4879           if (pfile->parsing_include_directive)
4880             {
4881               for (;;)
4882                 {
4883                   CPP_PUTC (pfile, c);
4884                   if (c == '>')
4885                     break;
4886                   c = GETC ();
4887                   NEWLINE_FIX1 (c);
4888                   if (c == '\n' || c == EOF)
4889                     {
4890                       cpp_error (pfile,
4891                                  "missing '>' in `#include <FILENAME>'");
4892                       break;
4893                     }
4894                 }
4895               return CPP_STRING;
4896             }
4897           /* else fall through */
4898         case '>':
4899           NEWLINE_FIX;
4900           c2 = PEEKC ();
4901           if (c2 == '=')
4902             goto op2;
4903           if (c2 != c)
4904             goto randomchar;
4905           FORWARD(1);
4906           CPP_RESERVE (pfile, 4);
4907           CPP_PUTC (pfile, c);
4908           CPP_PUTC (pfile, c2);
4909           NEWLINE_FIX;
4910           c3 = PEEKC ();
4911           if (c3 == '=')
4912             CPP_PUTC_Q (pfile, GETC ());
4913           CPP_NUL_TERMINATE_Q (pfile);
4914           pfile->only_seen_white = 0;
4915           return CPP_OTHER;
4916
4917         case '@':
4918           if (CPP_BUFFER (pfile)->has_escapes)
4919             {
4920               c = GETC ();
4921               if (c == '-')
4922                 {
4923                   if (pfile->output_escapes)
4924                     CPP_PUTS (pfile, "@-", 2);
4925                   parse_name (pfile, GETC ());
4926                   return CPP_NAME;
4927                 }
4928               else if (is_space [c])
4929                 {
4930                   CPP_RESERVE (pfile, 2);
4931                   if (pfile->output_escapes)
4932                     CPP_PUTC_Q (pfile, '@');
4933                   CPP_PUTC_Q (pfile, c);
4934                   return CPP_HSPACE;
4935                 }
4936             }
4937           if (pfile->output_escapes)
4938             {
4939               CPP_PUTS (pfile, "@@", 2);
4940               return CPP_OTHER;
4941             }
4942           goto randomchar;
4943
4944         case '.':
4945           NEWLINE_FIX;
4946           c2 = PEEKC ();
4947           if (isdigit(c2))
4948             {
4949               CPP_RESERVE(pfile, 2);
4950               CPP_PUTC_Q (pfile, '.');
4951               c = GETC ();
4952               goto number;
4953             }
4954           /* FIXME - misses the case "..\\\n." */
4955           if (c2 == '.' && PEEKN(1) == '.')
4956             {
4957               CPP_RESERVE(pfile, 4);
4958               CPP_PUTC_Q (pfile, '.');
4959               CPP_PUTC_Q (pfile, '.');
4960               CPP_PUTC_Q (pfile, '.');
4961               FORWARD (2);
4962               CPP_NUL_TERMINATE_Q (pfile);
4963               pfile->only_seen_white = 0;
4964               return CPP_3DOTS;
4965             }
4966           goto randomchar;
4967
4968         op2:
4969           token = CPP_OTHER;
4970           pfile->only_seen_white = 0;
4971         op2any:
4972           CPP_RESERVE(pfile, 3);
4973           CPP_PUTC_Q (pfile, c);
4974           CPP_PUTC_Q (pfile, GETC ());
4975           CPP_NUL_TERMINATE_Q (pfile);
4976           return token;
4977
4978         case 'L':
4979           NEWLINE_FIX;
4980           c2 = PEEKC ();
4981           if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
4982             {
4983               CPP_PUTC (pfile, c);
4984               c = GETC ();
4985               goto string;
4986             }
4987           goto letter;
4988
4989         case '0': case '1': case '2': case '3': case '4':
4990         case '5': case '6': case '7': case '8': case '9':
4991         number:
4992           c2  = '.';
4993           for (;;)
4994             {
4995               CPP_RESERVE (pfile, 2);
4996               CPP_PUTC_Q (pfile, c);
4997               NEWLINE_FIX;
4998               c = PEEKC ();
4999               if (c == EOF)
5000                 break;
5001               if (!is_idchar[c] && c != '.'
5002                   && ((c2 != 'e' && c2 != 'E') || (c != '+' && c != '-')))
5003                 break;
5004               FORWARD(1);
5005               c2= c;
5006             }
5007           CPP_NUL_TERMINATE_Q (pfile);
5008           pfile->only_seen_white = 0;
5009           return CPP_NUMBER;
5010         case 'b': case 'c': case 'd': case 'h': case 'o':
5011         case 'B': case 'C': case 'D': case 'H': case 'O':
5012           if (opts->chill && PEEKC () == '\'')
5013             {
5014               pfile->only_seen_white = 0;
5015               CPP_RESERVE (pfile, 2);
5016               CPP_PUTC_Q (pfile, c);
5017               CPP_PUTC_Q (pfile, '\'');
5018               FORWARD(1);
5019               for (;;)
5020                 {
5021                   c = GETC();
5022                   if (c == EOF)
5023                     goto chill_number_eof;
5024                   if (!is_idchar[c])
5025                     {
5026                       if (c == '\\' && PEEKC() == '\n')
5027                         {
5028                           FORWARD(2);
5029                           continue;
5030                         }
5031                       break;
5032                     }
5033                   CPP_PUTC (pfile, c);
5034                 }
5035               if (c == '\'')
5036                 {
5037                   CPP_RESERVE (pfile, 2);
5038                   CPP_PUTC_Q (pfile, c);
5039                   CPP_NUL_TERMINATE_Q (pfile);
5040                   return CPP_STRING;
5041                 }
5042               else
5043                 {
5044                   FORWARD(-1);
5045                 chill_number_eof:
5046                   CPP_NUL_TERMINATE (pfile);
5047                   return CPP_NUMBER;
5048                 }
5049             }
5050           else
5051             goto letter;
5052         case '_':
5053         case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
5054         case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
5055         case 'r': case 's': case 't': case 'u': case 'v': case 'w':
5056         case 'x': case 'y': case 'z':
5057         case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
5058         case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
5059         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
5060         case 'Y': case 'Z':
5061         letter:
5062           {
5063             HASHNODE *hp;
5064             unsigned char *ident;
5065             int before_name_written = CPP_WRITTEN (pfile);
5066             int ident_len;
5067             parse_name (pfile, c);
5068             pfile->only_seen_white = 0;
5069             if (pfile->no_macro_expand)
5070               return CPP_NAME;
5071             ident = pfile->token_buffer + before_name_written;
5072             ident_len = CPP_PWRITTEN (pfile) - ident;
5073             hp = cpp_lookup (pfile, ident, ident_len, -1);
5074             if (!hp)
5075               return CPP_NAME;
5076             if (hp->type == T_DISABLED)
5077               {
5078                 if (pfile->output_escapes)
5079                   { /* Return "@-IDENT", followed by '\0'.  */
5080                     int i;
5081                     CPP_RESERVE (pfile, 3);
5082                     ident = pfile->token_buffer + before_name_written;
5083                     CPP_ADJUST_WRITTEN (pfile, 2);
5084                     for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
5085                     ident[0] = '@';
5086                     ident[1] = '-';
5087                   }
5088                 return CPP_NAME;
5089               }
5090
5091             /* If macro wants an arglist, verify that a '(' follows.
5092                first skip all whitespace, copying it to the output
5093                after the macro name.  Then, if there is no '(',
5094                decide this is not a macro call and leave things that way.  */
5095             if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
5096             {
5097               struct parse_marker macro_mark;
5098               int is_macro_call;
5099               while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
5100                 {
5101                   cpp_buffer *next_buf;
5102                   cpp_skip_hspace (pfile);
5103                   if (PEEKC () != EOF)
5104                     break;
5105                   next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
5106                   (*CPP_BUFFER (pfile)->cleanup) (CPP_BUFFER (pfile), pfile);
5107                   CPP_BUFFER (pfile) = next_buf;
5108                 }
5109               parse_set_mark (&macro_mark, pfile);
5110               for (;;)
5111                 {
5112                   cpp_skip_hspace (pfile);
5113                   c = PEEKC ();
5114                   is_macro_call = c == '(';
5115                   if (c != '\n')
5116                     break;
5117                   FORWARD (1);
5118                 }
5119               if (!is_macro_call)
5120                 parse_goto_mark (&macro_mark, pfile);
5121               parse_clear_mark (&macro_mark);
5122               if (!is_macro_call)
5123                 return CPP_NAME;
5124             }
5125             /* This is now known to be a macro call.  */
5126
5127             /* it might not actually be a macro.  */
5128             if (hp->type != T_MACRO) {
5129               int xbuf_len;  U_CHAR *xbuf;
5130               CPP_SET_WRITTEN (pfile, before_name_written);
5131               special_symbol (hp, pfile);
5132               xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
5133               xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
5134               CPP_SET_WRITTEN (pfile, before_name_written);
5135               bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
5136               push_macro_expansion (pfile, xbuf, xbuf_len, hp);
5137             }
5138             else
5139               {
5140                 /* Expand the macro, reading arguments as needed,
5141                    and push the expansion on the input stack.  */
5142                 macroexpand (pfile, hp);
5143                 CPP_SET_WRITTEN (pfile, before_name_written);
5144               }
5145
5146             /* An extra "@ " is added to the end of a macro expansion
5147                to prevent accidental token pasting.  We prefer to avoid
5148                unneeded extra spaces (for the sake of cpp-using tools like
5149                imake).  Here we remove the space if it is safe to do so.  */
5150             if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
5151                 && pfile->buffer->rlimit[-2] == '@'
5152                 && pfile->buffer->rlimit[-1] == ' ')
5153               {
5154                 int c1 = pfile->buffer->rlimit[-3];
5155                 int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
5156                 if (c2 == EOF || ! unsafe_chars (c1, c2))
5157                   pfile->buffer->rlimit -= 2;
5158               }
5159           }
5160           goto get_next;
5161
5162         case ' ':  case '\t':  case '\v':  case '\r':
5163           for (;;)
5164             {
5165               CPP_PUTC (pfile, c);
5166               c = PEEKC ();
5167               if (c == EOF || !is_hor_space[c])
5168                 break;
5169               FORWARD(1);
5170             }
5171           return CPP_HSPACE;
5172
5173         case '\\':
5174           c2 = PEEKC ();
5175           if (c2 != '\n')
5176             goto randomchar;
5177           token = CPP_HSPACE;
5178           goto op2any;
5179
5180         case '\n':
5181           CPP_PUTC (pfile, c);
5182           if (pfile->only_seen_white == 0)
5183             pfile->only_seen_white = 1;
5184           pfile->lineno++;
5185           output_line_command (pfile, 1, same_file);
5186           return CPP_VSPACE;
5187
5188         case '(': token = CPP_LPAREN;    goto char1;
5189         case ')': token = CPP_RPAREN;    goto char1;
5190         case '{': token = CPP_LBRACE;    goto char1;
5191         case '}': token = CPP_RBRACE;    goto char1;
5192         case ',': token = CPP_COMMA;     goto char1;
5193         case ';': token = CPP_SEMICOLON; goto char1;
5194
5195         randomchar:
5196         default:
5197           token = CPP_OTHER;
5198         char1:
5199           pfile->only_seen_white = 0;
5200           CPP_PUTC (pfile, c);
5201           return token;
5202         }
5203     }
5204 }
5205
5206 /* Like cpp_get_token, but skip spaces and comments.  */
5207
5208 enum cpp_token
5209 cpp_get_non_space_token (pfile)
5210      cpp_reader *pfile;
5211 {
5212   int old_written = CPP_WRITTEN (pfile);
5213   for (;;)
5214     {
5215       enum cpp_token token = cpp_get_token (pfile);
5216       if (token != CPP_COMMENT && token != CPP_POP
5217           && token != CPP_HSPACE && token != CPP_VSPACE)
5218         return token;
5219       CPP_SET_WRITTEN (pfile, old_written);
5220     }
5221 }
5222
5223 /* Parse an identifier starting with C.  */
5224
5225 int
5226 parse_name (pfile, c)
5227      cpp_reader *pfile; int c;
5228 {
5229   for (;;)
5230   {
5231       if (! is_idchar[c])
5232       {
5233           if (c == '\\' && PEEKC() == '\n')
5234           {
5235               FORWARD(2);
5236               continue;
5237           }
5238           FORWARD (-1);
5239           break;
5240       }
5241
5242       if (c == '$' && CPP_PEDANTIC (pfile))
5243         cpp_pedwarn ("`$' in identifier");
5244
5245       CPP_RESERVE(pfile, 2); /* One more for final NUL.  */
5246       CPP_PUTC_Q (pfile, c);
5247       c = GETC();
5248       if (c == EOF)
5249         break;
5250   }
5251   CPP_NUL_TERMINATE_Q (pfile);
5252   return 1;
5253 }
5254
5255 \f
5256 /* Maintain and search list of included files, for #import.  */
5257
5258 /* Hash a file name for import_hash_table.  */
5259
5260 static int
5261 import_hash (f)
5262      char *f;
5263 {
5264   int val = 0;
5265
5266   while (*f) val += *f++;
5267   return (val%IMPORT_HASH_SIZE);
5268 }
5269
5270 /* Search for file FILENAME in import_hash_table.
5271    Return -2 if found, either a matching name or a matching inode.
5272    Otherwise, open the file and return a file descriptor if successful
5273    or -1 if unsuccessful.  */
5274
5275 static int
5276 lookup_import (pfile, filename, searchptr)
5277      cpp_reader *pfile;
5278      char *filename;
5279      struct file_name_list *searchptr;
5280 {
5281   struct import_file *i;
5282   int h;
5283   int hashval;
5284   struct stat sb;
5285   int fd;
5286
5287   hashval = import_hash (filename);
5288
5289   /* Attempt to find file in list of already included files */
5290   i = pfile->import_hash_table[hashval];
5291
5292   while (i) {
5293     if (!strcmp (filename, i->name))
5294       return -2;                /* return found */
5295     i = i->next;
5296   }
5297   /* Open it and try a match on inode/dev */
5298   fd = open_include_file (pfile, filename, searchptr);
5299   if (fd < 0)
5300     return fd;
5301   fstat (fd, &sb);
5302   for (h = 0; h < IMPORT_HASH_SIZE; h++) {
5303     i = pfile->import_hash_table[h];
5304     while (i) {
5305       /* Compare the inode and the device.
5306          Supposedly on some systems the inode is not a scalar.  */
5307       if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
5308           && i->dev == sb.st_dev) {
5309         close (fd);
5310         return -2;              /* return found */
5311       }
5312       i = i->next;
5313     }
5314   }
5315   return fd;                    /* Not found, return open file */
5316 }
5317
5318 /* Add the file FNAME, open on descriptor FD, to import_hash_table.  */
5319
5320 static void
5321 add_import (pfile, fd, fname)
5322      cpp_reader *pfile;
5323      int fd;
5324      char *fname;
5325 {
5326   struct import_file *i;
5327   int hashval;
5328   struct stat sb;
5329
5330   hashval = import_hash (fname);
5331   fstat (fd, &sb);
5332   i = (struct import_file *)xmalloc (sizeof (struct import_file));
5333   i->name = (char *)xmalloc (strlen (fname)+1);
5334   strcpy (i->name, fname);
5335   bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
5336   i->dev = sb.st_dev;
5337   i->next = pfile->import_hash_table[hashval];
5338   pfile->import_hash_table[hashval] = i;
5339 }
5340 \f
5341 /* The file_name_map structure holds a mapping of file names for a
5342    particular directory.  This mapping is read from the file named
5343    FILE_NAME_MAP_FILE in that directory.  Such a file can be used to
5344    map filenames on a file system with severe filename restrictions,
5345    such as DOS.  The format of the file name map file is just a series
5346    of lines with two tokens on each line.  The first token is the name
5347    to map, and the second token is the actual name to use.  */
5348
5349 struct file_name_map
5350 {
5351   struct file_name_map *map_next;
5352   char *map_from;
5353   char *map_to;
5354 };
5355
5356 #define FILE_NAME_MAP_FILE "header.gcc"
5357
5358 /* Read a space delimited string of unlimited length from a stdio
5359    file.  */
5360
5361 static char *
5362 read_filename_string (ch, f)
5363      int ch;
5364      FILE *f;
5365 {
5366   char *alloc, *set;
5367   int len;
5368
5369   len = 20;
5370   set = alloc = xmalloc (len + 1);
5371   if (! is_space[ch])
5372     {
5373       *set++ = ch;
5374       while ((ch = getc (f)) != EOF && ! is_space[ch])
5375         {
5376           if (set - alloc == len)
5377             {
5378               len *= 2;
5379               alloc = xrealloc (alloc, len + 1);
5380               set = alloc + len / 2;
5381             }
5382           *set++ = ch;
5383         }
5384     }
5385   *set = '\0';
5386   ungetc (ch, f);
5387   return alloc;
5388 }
5389
5390 /* This structure holds a linked list of file name maps, one per directory.  */
5391
5392 struct file_name_map_list
5393 {
5394   struct file_name_map_list *map_list_next;
5395   char *map_list_name;
5396   struct file_name_map *map_list_map;
5397 };
5398
5399 /* Read the file name map file for DIRNAME.  */
5400
5401 static struct file_name_map *
5402 read_name_map (pfile, dirname)
5403      cpp_reader *pfile;
5404      char *dirname;
5405 {
5406   register struct file_name_map_list *map_list_ptr;
5407   char *name;
5408   FILE *f;
5409
5410   for (map_list_ptr = CPP_OPTIONS (pfile)->map_list; map_list_ptr;
5411        map_list_ptr = map_list_ptr->map_list_next)
5412     if (! strcmp (map_list_ptr->map_list_name, dirname))
5413       return map_list_ptr->map_list_map;
5414
5415   map_list_ptr = ((struct file_name_map_list *)
5416                   xmalloc (sizeof (struct file_name_map_list)));
5417   map_list_ptr->map_list_name = savestring (dirname);
5418   map_list_ptr->map_list_map = NULL;
5419
5420   name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
5421   strcpy (name, dirname);
5422   if (*dirname)
5423     strcat (name, "/");
5424   strcat (name, FILE_NAME_MAP_FILE);
5425   f = fopen (name, "r");
5426   if (!f)
5427     map_list_ptr->map_list_map = NULL;
5428   else
5429     {
5430       int ch;
5431       int dirlen = strlen (dirname);
5432
5433       while ((ch = getc (f)) != EOF)
5434         {
5435           char *from, *to;
5436           struct file_name_map *ptr;
5437
5438           if (is_space[ch])
5439             continue;
5440           from = read_filename_string (ch, f);
5441           while ((ch = getc (f)) != EOF && is_hor_space[ch])
5442             ;
5443           to = read_filename_string (ch, f);
5444
5445           ptr = ((struct file_name_map *)
5446                  xmalloc (sizeof (struct file_name_map)));
5447           ptr->map_from = from;
5448
5449           /* Make the real filename absolute.  */
5450           if (*to == '/')
5451             ptr->map_to = to;
5452           else
5453             {
5454               ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
5455               strcpy (ptr->map_to, dirname);
5456               ptr->map_to[dirlen] = '/';
5457               strcpy (ptr->map_to + dirlen + 1, to);
5458               free (to);
5459             }
5460
5461           ptr->map_next = map_list_ptr->map_list_map;
5462           map_list_ptr->map_list_map = ptr;
5463
5464           while ((ch = getc (f)) != '\n')
5465             if (ch == EOF)
5466               break;
5467         }
5468       fclose (f);
5469     }
5470
5471   map_list_ptr->map_list_next = CPP_OPTIONS (pfile)->map_list;
5472   CPP_OPTIONS (pfile)->map_list = map_list_ptr;
5473
5474   return map_list_ptr->map_list_map;
5475 }
5476
5477 /* Try to open include file FILENAME.  SEARCHPTR is the directory
5478    being tried from the include file search path.  This function maps
5479    filenames on file systems based on information read by
5480    read_name_map.  */
5481
5482 static int
5483 open_include_file (pfile, filename, searchptr)
5484      cpp_reader *pfile;
5485      char *filename;
5486      struct file_name_list *searchptr;
5487 {
5488   register struct file_name_map *map;
5489   register char *from;
5490   char *p, *dir;
5491
5492   if (searchptr && ! searchptr->got_name_map)
5493     {
5494       searchptr->name_map = read_name_map (pfile,
5495                                            searchptr->fname
5496                                            ? searchptr->fname : ".");
5497       searchptr->got_name_map = 1;
5498     }
5499
5500   /* First check the mapping for the directory we are using.  */
5501   if (searchptr && searchptr->name_map)
5502     {
5503       from = filename;
5504       if (searchptr->fname)
5505         from += strlen (searchptr->fname) + 1;
5506       for (map = searchptr->name_map; map; map = map->map_next)
5507         {
5508           if (! strcmp (map->map_from, from))
5509             {
5510               /* Found a match.  */
5511               return open (map->map_to, O_RDONLY, 0666);
5512             }
5513         }
5514     }
5515
5516   /* Try to find a mapping file for the particular directory we are
5517      looking in.  Thus #include <sys/types.h> will look up sys/types.h
5518      in /usr/include/header.gcc and look up types.h in
5519      /usr/include/sys/header.gcc.  */
5520   p = rindex (filename, '/');
5521   if (! p)
5522     p = filename;
5523   if (searchptr
5524       && searchptr->fname
5525       && strlen (searchptr->fname) == p - filename
5526       && ! strncmp (searchptr->fname, filename, p - filename))
5527     {
5528       /* FILENAME is in SEARCHPTR, which we've already checked.  */
5529       return open (filename, O_RDONLY, 0666);
5530     }
5531
5532   if (p == filename)
5533     {
5534       dir = ".";
5535       from = filename;
5536     }
5537   else
5538     {
5539       dir = (char *) alloca (p - filename + 1);
5540       bcopy (filename, dir, p - filename);
5541       dir[p - filename] = '\0';
5542       from = p + 1;
5543     }
5544   for (map = read_name_map (pfile, dir); map; map = map->map_next)
5545     if (! strcmp (map->map_from, from))
5546       return open (map->map_to, O_RDONLY, 0666);
5547
5548   return open (filename, O_RDONLY, 0666);
5549 }
5550
5551 /* Process the contents of include file FNAME, already open on descriptor F,
5552    with output to OP.
5553    SYSTEM_HEADER_P is 1 if this file resides in any one of the known
5554    "system" include directories (as decided by the `is_system_include'
5555    function above).
5556    DIRPTR is the link in the dir path through which this file was found,
5557    or 0 if the file name was absolute or via the current directory.
5558    Return 1 on success, 0 on failure.
5559
5560    The caller is responsible for the cpp_push_buffer.  */
5561
5562 static int
5563 finclude (pfile, f, fname, system_header_p, dirptr)
5564      cpp_reader *pfile;
5565      int f;
5566      char *fname;
5567      int system_header_p;
5568      struct file_name_list *dirptr;
5569 {
5570   int st_mode;
5571   long st_size;
5572   long i;
5573   int length;
5574   cpp_buffer *fp;                       /* For input stack frame */
5575   int missing_newline = 0;
5576
5577   if (file_size_and_mode (f, &st_mode, &st_size) < 0)
5578     {
5579       cpp_perror_with_name (pfile, fname);
5580       close (f);
5581       cpp_pop_buffer (pfile);
5582       return 0;
5583     }
5584
5585   fp = CPP_BUFFER (pfile);
5586   fp->nominal_fname = fp->fname = fname;
5587 #if 0
5588   fp->length = 0;
5589 #endif
5590   fp->dir = dirptr;
5591   fp->system_header_p = system_header_p;
5592   fp->lineno = 1;
5593   fp->colno = 1;
5594   fp->cleanup = file_cleanup;
5595
5596   if (S_ISREG (st_mode)) {
5597     fp->buf = (U_CHAR *) xmalloc (st_size + 2);
5598     fp->alimit = fp->buf + st_size + 2;
5599     fp->cur = fp->buf;
5600
5601     /* Read the file contents, knowing that st_size is an upper bound
5602        on the number of bytes we can read.  */
5603     length = safe_read (f, fp->buf, st_size);
5604     fp->rlimit = fp->buf + length;
5605     if (length < 0) goto nope;
5606   }
5607   else if (S_ISDIR (st_mode)) {
5608     cpp_error (pfile, "directory `%s' specified in #include", fname);
5609     close (f);
5610     return 0;
5611   } else {
5612     /* Cannot count its file size before reading.
5613        First read the entire file into heap and
5614        copy them into buffer on stack.  */
5615
5616     int bsize = 2000;
5617
5618     st_size = 0;
5619     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5620
5621     for (;;) {
5622       i = safe_read (f, fp->buf + st_size, bsize - st_size);
5623       if (i < 0)
5624         goto nope;      /* error! */
5625       st_size += i;
5626       if (st_size != bsize)
5627         break;  /* End of file */
5628       bsize *= 2;
5629       fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5630     }
5631     fp->cur = fp->buf;
5632     length = st_size;
5633   }
5634
5635   if ((length > 0 && fp->buf[length - 1] != '\n')
5636       /* Backslash-newline at end is not good enough.  */
5637       || (length > 1 && fp->buf[length - 2] == '\\')) {
5638     fp->buf[length++] = '\n';
5639 #if 0
5640     missing_newline = 1;
5641 #endif
5642   }
5643   fp->buf[length] = '\0';
5644   fp->rlimit = fp->buf + length;
5645
5646   /* Close descriptor now, so nesting does not use lots of descriptors.  */
5647   close (f);
5648
5649   /* Must do this before calling trigraph_pcp, so that the correct file name
5650      will be printed in warning messages.  */
5651
5652   pfile->input_stack_listing_current = 0;
5653
5654 #if 0
5655   if (!no_trigraphs)
5656     trigraph_pcp (fp);
5657 #endif
5658
5659 #if 0
5660   rescan (op, 0);
5661
5662   if (missing_newline)
5663     fp->lineno--;
5664
5665   if (CPP_PEDANTIC (pfile) && missing_newline)
5666     pedwarn ("file does not end in newline");
5667
5668   indepth--;
5669   input_file_stack_tick++;
5670   free (fp->buf);
5671 #endif
5672   return 1;
5673
5674  nope:
5675
5676   cpp_perror_with_name (pfile, fname);
5677   close (f);
5678   free (fp->buf);
5679   return 1;
5680 }
5681
5682 /* This is called after options have been processed.
5683  * Check options for consistency, and setup for processing input
5684  * from the file named FNAME.  (Use standard input if FNAME==NULL.)
5685  * Return 1 on succes, 0 on failure.
5686  */
5687
5688 int
5689 cpp_start_read (pfile, fname)
5690      cpp_reader *pfile;
5691      char *fname;
5692 {
5693   struct cpp_options *opts = CPP_OPTIONS (pfile);
5694   struct cpp_pending *pend;
5695   char *p;
5696   int f;
5697   cpp_buffer *fp;
5698
5699   /* The code looks at the defaults through this pointer, rather than through
5700      the constant structure above.  This pointer gets changed if an environment
5701      variable specifies other defaults.  */
5702   struct default_include *include_defaults = include_defaults_array;
5703
5704   /* Add dirs from CPATH after dirs from -I.  */
5705   /* There seems to be confusion about what CPATH should do,
5706      so for the moment it is not documented.  */
5707   /* Some people say that CPATH should replace the standard include dirs,
5708      but that seems pointless: it comes before them, so it overrides them
5709      anyway.  */
5710   p = (char *) getenv ("CPATH");
5711   if (p != 0 && ! opts->no_standard_includes)
5712     path_include (pfile, p);
5713
5714   /* Now that dollars_in_ident is known, initialize is_idchar.  */
5715   initialize_char_syntax (opts);
5716
5717   /* Do partial setup of input buffer for the sake of generating
5718      early #line directives (when -g is in effect).  */
5719   fp = cpp_push_buffer (pfile, NULL, 0);
5720   if (!fp)
5721     return 0;
5722   if (opts->in_fname == NULL)
5723     opts->in_fname = "";
5724   fp->nominal_fname = fp->fname = opts->in_fname;
5725   fp->lineno = 0;
5726
5727   /* Install __LINE__, etc.  Must follow initialize_char_syntax
5728      and option processing.  */
5729   initialize_builtins (pfile);
5730
5731   /* Do standard #defines and assertions
5732      that identify system and machine type.  */
5733
5734   if (!opts->inhibit_predefs) {
5735     char *p = (char *) alloca (strlen (predefs) + 1);
5736     strcpy (p, predefs);
5737     while (*p) {
5738       char *q;
5739       while (*p == ' ' || *p == '\t')
5740         p++;
5741       /* Handle -D options.  */
5742       if (p[0] == '-' && p[1] == 'D') {
5743         q = &p[2];
5744         while (*p && *p != ' ' && *p != '\t')
5745           p++;
5746         if (*p != 0)
5747           *p++= 0;
5748         if (opts->debug_output)
5749           output_line_command (pfile, 0, same_file);
5750         cpp_define (pfile, q);
5751         while (*p == ' ' || *p == '\t')
5752           p++;
5753       } else if (p[0] == '-' && p[1] == 'A') {
5754         /* Handle -A options (assertions).  */
5755         char *assertion;
5756         char *past_name;
5757         char *value;
5758         char *past_value;
5759         char *termination;
5760         int save_char;
5761
5762         assertion = &p[2];
5763         past_name = assertion;
5764         /* Locate end of name.  */
5765         while (*past_name && *past_name != ' '
5766                && *past_name != '\t' && *past_name != '(')
5767           past_name++;
5768         /* Locate `(' at start of value.  */
5769         value = past_name;
5770         while (*value && (*value == ' ' || *value == '\t'))
5771           value++;
5772         if (*value++ != '(')
5773           abort ();
5774         while (*value && (*value == ' ' || *value == '\t'))
5775           value++;
5776         past_value = value;
5777         /* Locate end of value.  */
5778         while (*past_value && *past_value != ' '
5779                && *past_value != '\t' && *past_value != ')')
5780           past_value++;
5781         termination = past_value;
5782         while (*termination && (*termination == ' ' || *termination == '\t'))
5783           termination++;
5784         if (*termination++ != ')')
5785           abort ();
5786         if (*termination && *termination != ' ' && *termination != '\t')
5787           abort ();
5788         /* Temporarily null-terminate the value.  */
5789         save_char = *termination;
5790         *termination = '\0';
5791         /* Install the assertion.  */
5792         make_assertion (pfile, "-A", assertion);
5793         *termination = (char) save_char;
5794         p = termination;
5795         while (*p == ' ' || *p == '\t')
5796           p++;
5797       } else {
5798         abort ();
5799       }
5800     }
5801   }
5802
5803   /* Now handle the command line options.  */
5804
5805   /* Do -U's, -D's and -A's in the order they were seen.  */
5806   /* First reverse the list.  */
5807   opts->pending = nreverse_pending (opts->pending);
5808
5809   for (pend = opts->pending;  pend;  pend = pend->next)
5810     {
5811       if (pend->cmd != NULL && pend->cmd[0] == '-')
5812         {
5813           switch (pend->cmd[1])
5814             {
5815             case 'U':
5816               if (opts->debug_output)
5817                 output_line_command (pfile, 0, same_file);
5818               do_undef (pfile, NULL, pend->arg, pend->arg + strlen (pend->arg));
5819               break;
5820             case 'D':
5821               if (opts->debug_output)
5822                 output_line_command (pfile, 0, same_file);
5823               cpp_define (pfile, pend->arg);
5824               break;
5825             case 'A':
5826               make_assertion (pfile, "-A", pend->arg);
5827               break;
5828             }
5829         }
5830     }
5831
5832   opts->done_initializing = 1;
5833
5834   { /* Read the appropriate environment variable and if it exists
5835        replace include_defaults with the listed path.  */
5836     char *epath = 0;
5837     switch ((opts->objc << 1) + opts->cplusplus)
5838       {
5839       case 0:
5840         epath = getenv ("C_INCLUDE_PATH");
5841         break;
5842       case 1:
5843         epath = getenv ("CPLUS_INCLUDE_PATH");
5844         break;
5845       case 2:
5846         epath = getenv ("OBJC_INCLUDE_PATH");
5847         break;
5848       case 3:
5849         epath = getenv ("OBJCPLUS_INCLUDE_PATH");
5850         break;
5851       }
5852     /* If the environment var for this language is set,
5853        add to the default list of include directories.  */
5854     if (epath) {
5855       char *nstore = (char *) alloca (strlen (epath) + 2);
5856       int num_dirs;
5857       char *startp, *endp;
5858
5859       for (num_dirs = 1, startp = epath; *startp; startp++)
5860         if (*startp == PATH_SEPARATOR)
5861           num_dirs++;
5862       include_defaults
5863         = (struct default_include *) xmalloc ((num_dirs
5864                                                * sizeof (struct default_include))
5865                                               + sizeof (include_defaults_array));
5866       startp = endp = epath;
5867       num_dirs = 0;
5868       while (1) {
5869         /* Handle cases like c:/usr/lib:d:/gcc/lib */
5870         if ((*endp == PATH_SEPARATOR)
5871             || *endp == 0) {
5872           strncpy (nstore, startp, endp-startp);
5873           if (endp == startp)
5874             strcpy (nstore, ".");
5875           else
5876             nstore[endp-startp] = '\0';
5877
5878           include_defaults[num_dirs].fname = savestring (nstore);
5879           include_defaults[num_dirs].cplusplus = opts->cplusplus;
5880           include_defaults[num_dirs].cxx_aware = 1;
5881           num_dirs++;
5882           if (*endp == '\0')
5883             break;
5884           endp = startp = endp + 1;
5885         } else
5886           endp++;
5887       }
5888       /* Put the usual defaults back in at the end.  */
5889       bcopy ((char *) include_defaults_array,
5890              (char *) &include_defaults[num_dirs],
5891              sizeof (include_defaults_array));
5892     }
5893   }
5894
5895   append_include_chain (pfile, opts->before_system, opts->last_before_system);
5896   opts->first_system_include = opts->before_system;
5897
5898   /* Unless -fnostdinc,
5899      tack on the standard include file dirs to the specified list */
5900   if (!opts->no_standard_includes) {
5901     struct default_include *p = include_defaults;
5902     char *specd_prefix = opts->include_prefix;
5903     char *default_prefix = savestring (GCC_INCLUDE_DIR);
5904     int default_len = 0;
5905     /* Remove the `include' from /usr/local/lib/gcc.../include.  */
5906     if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
5907       default_len = strlen (default_prefix) - 7;
5908       default_prefix[default_len] = 0;
5909     }
5910     /* Search "translated" versions of GNU directories.
5911        These have /usr/local/lib/gcc... replaced by specd_prefix.  */
5912     if (specd_prefix != 0 && default_len != 0)
5913       for (p = include_defaults; p->fname; p++) {
5914         /* Some standard dirs are only for C++.  */
5915         if (!p->cplusplus
5916             || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
5917           /* Does this dir start with the prefix?  */
5918           if (!strncmp (p->fname, default_prefix, default_len)) {
5919             /* Yes; change prefix and add to search list.  */
5920             struct file_name_list *new
5921               = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
5922             int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
5923             char *str = (char *) xmalloc (this_len + 1);
5924             strcpy (str, specd_prefix);
5925             strcat (str, p->fname + default_len);
5926             new->fname = str;
5927             new->control_macro = 0;
5928             new->c_system_include_path = !p->cxx_aware;
5929             new->got_name_map = 0;
5930             append_include_chain (pfile, new, new);
5931             if (opts->first_system_include == 0)
5932               opts->first_system_include = new;
5933           }
5934         }
5935       }
5936     /* Search ordinary names for GNU include directories.  */
5937     for (p = include_defaults; p->fname; p++) {
5938       /* Some standard dirs are only for C++.  */
5939       if (!p->cplusplus
5940           || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
5941         struct file_name_list *new
5942           = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
5943         new->control_macro = 0;
5944         new->c_system_include_path = !p->cxx_aware;
5945         new->fname = p->fname;
5946         new->got_name_map = 0;
5947         append_include_chain (pfile, new, new);
5948         if (opts->first_system_include == 0)
5949           opts->first_system_include = new;
5950       }
5951     }
5952   }
5953
5954   /* Tack the after_include chain at the end of the include chain.  */
5955   append_include_chain (pfile, opts->after_include, opts->last_after_include);
5956   if (opts->first_system_include == 0)
5957     opts->first_system_include = opts->after_include;
5958
5959   /* With -v, print the list of dirs to search.  */
5960   if (opts->verbose) {
5961     struct file_name_list *p;
5962     fprintf (stderr, "#include \"...\" search starts here:\n");
5963     for (p = opts->include; p; p = p->next) {
5964       if (p == opts->first_bracket_include)
5965         fprintf (stderr, "#include <...> search starts here:\n");
5966       fprintf (stderr, " %s\n", p->fname);
5967     }
5968     fprintf (stderr, "End of search list.\n");
5969   }
5970
5971   /* Scan the -imacros files before the main input.
5972      Much like #including them, but with no_output set
5973      so that only their macro definitions matter.  */
5974
5975   opts->no_output++; pfile->no_record_file++;
5976   for (pend = opts->pending;  pend;  pend = pend->next)
5977     {
5978       if (pend->cmd != NULL && strcmp (pend->cmd, "-imacros") == 0)
5979         {
5980           int fd = open (pend->arg, O_RDONLY, 0666);
5981           if (fd < 0)
5982             {
5983               cpp_perror_with_name (pfile, pend->arg);
5984               return 0;
5985             }
5986           if (!cpp_push_buffer (pfile, NULL, 0))
5987               return 0;
5988           finclude (pfile, fd, pend->arg, 0, NULL_PTR);
5989           cpp_scan_buffer (pfile);
5990         }
5991     }
5992   opts->no_output--; pfile->no_record_file--;
5993
5994   /* Copy the entire contents of the main input file into
5995      the stacked input buffer previously allocated for it.  */
5996   if (fname == NULL || *fname == 0) {
5997     fname = "";
5998     f = 0;
5999   } else if ((f = open (fname, O_RDONLY, 0666)) < 0)
6000     cpp_pfatal_with_name (pfile, fname);
6001
6002   /* -MG doesn't select the form of output and must be specified with one of
6003      -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
6004      inhibit compilation.  */
6005   if (opts->print_deps_missing_files
6006       && (opts->print_deps == 0 || !opts->no_output))
6007     {
6008       cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
6009       return 0;
6010     }
6011
6012   /* Either of two environment variables can specify output of deps.
6013      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
6014      where OUTPUT_FILE is the file to write deps info to
6015      and DEPS_TARGET is the target to mention in the deps.  */
6016
6017   if (opts->print_deps == 0
6018       && (getenv ("SUNPRO_DEPENDENCIES") != 0
6019           || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
6020     char *spec = getenv ("DEPENDENCIES_OUTPUT");
6021     char *s;
6022     char *output_file;
6023
6024     if (spec == 0)
6025       {
6026         spec = getenv ("SUNPRO_DEPENDENCIES");
6027         opts->print_deps = 2;
6028       }
6029     else
6030       opts->print_deps = 1;
6031
6032     s = spec;
6033     /* Find the space before the DEPS_TARGET, if there is one.  */
6034     /* This should use index.  (mrs) */
6035     while (*s != 0 && *s != ' ') s++;
6036     if (*s != 0)
6037       {
6038         opts->deps_target = s + 1;
6039         output_file = (char *) xmalloc (s - spec + 1);
6040         bcopy (spec, output_file, s - spec);
6041         output_file[s - spec] = 0;
6042       }
6043     else
6044       {
6045         opts->deps_target = 0;
6046         output_file = spec;
6047       }
6048
6049     opts->deps_file = output_file;
6050     opts->print_deps_append = 1;
6051   }
6052
6053   /* For -M, print the expected object file name
6054      as the target of this Make-rule.  */
6055   if (opts->print_deps)
6056     {
6057       pfile->deps_allocated_size = 200;
6058       pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
6059       pfile->deps_buffer[0] = 0;
6060       pfile->deps_size = 0;
6061       pfile->deps_column = 0;
6062
6063       if (opts->deps_target)
6064         deps_output (pfile, opts->deps_target, ':');
6065       else if (*opts->in_fname == 0)
6066         deps_output (pfile, "-", ':');
6067       else
6068         {
6069           char *p, *q;
6070           int len;
6071
6072           /* Discard all directory prefixes from filename.  */
6073           if ((q = rindex (opts->in_fname, '/')) != NULL
6074 #ifdef DIR_SEPARATOR
6075               && (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
6076 #endif
6077               )
6078             ++q;
6079           else
6080             q = opts->in_fname;
6081
6082           /* Copy remainder to mungable area.  */
6083           p = (char *) alloca (strlen(q) + 8);
6084           strcpy (p, q);
6085
6086           /* Output P, but remove known suffixes.  */
6087           len = strlen (p);
6088           q = p + len;
6089           if (len >= 2
6090               && p[len - 2] == '.'
6091               && index("cCsSm", p[len - 1]))
6092             q = p + (len - 2);
6093           else if (len >= 3
6094                    && p[len - 3] == '.'
6095                    && p[len - 2] == 'c'
6096                    && p[len - 1] == 'c')
6097             q = p + (len - 3);
6098           else if (len >= 4
6099                    && p[len - 4] == '.'
6100                    && p[len - 3] == 'c'
6101                    && p[len - 2] == 'x'
6102                    && p[len - 1] == 'x')
6103             q = p + (len - 4);
6104           else if (len >= 4
6105                    && p[len - 4] == '.'
6106                    && p[len - 3] == 'c'
6107                    && p[len - 2] == 'p'
6108                    && p[len - 1] == 'p')
6109             q = p + (len - 4);
6110
6111           /* Supply our own suffix.  */
6112 #ifndef VMS
6113           strcpy (q, ".o");
6114 #else
6115           strcpy (q, ".obj");
6116 #endif
6117
6118           deps_output (pfile, p, ':');
6119           deps_output (pfile, opts->in_fname, ' ');
6120         }
6121     }
6122
6123 #if 0
6124   /* Make sure data ends with a newline.  And put a null after it.  */
6125
6126   if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
6127       /* Backslash-newline at end is not good enough.  */
6128       || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
6129     fp->buf[fp->length++] = '\n';
6130     missing_newline = 1;
6131   }
6132   fp->buf[fp->length] = '\0';
6133
6134   /* Unless inhibited, convert trigraphs in the input.  */
6135
6136   if (!no_trigraphs)
6137     trigraph_pcp (fp);
6138 #endif
6139
6140   /* Scan the -include files before the main input.
6141    We push these in reverse order, so that the first one is handled first.  */
6142
6143   pfile->no_record_file++;
6144   opts->pending = nreverse_pending (opts->pending);
6145   for (pend = opts->pending;  pend;  pend = pend->next)
6146     {
6147       if (pend->cmd != NULL && strcmp (pend->cmd, "-include") == 0)
6148         {
6149           int fd = open (pend->arg, O_RDONLY, 0666);
6150           if (fd < 0)
6151             {
6152               cpp_perror_with_name (pfile, pend->arg);
6153               return 0;
6154             }
6155           if (!cpp_push_buffer (pfile, NULL, 0))
6156             return 0;
6157           finclude (pfile, fd, pend->arg, 0, NULL_PTR);
6158         }
6159     }
6160   pfile->no_record_file--;
6161
6162   /* Free the pending list.  */
6163   for (pend = opts->pending;  pend; )
6164     {
6165       struct cpp_pending *next = pend->next;
6166       free (pend);
6167       pend = next;
6168     }
6169   opts->pending = NULL;
6170
6171 #if 0
6172   /* Scan the input, processing macros and directives.  */
6173
6174   rescan (&outbuf, 0);
6175
6176   if (missing_newline)
6177     fp->lineno--;
6178
6179   if (CPP_PEDANTIC (pfile) && missing_newline)
6180     pedwarn ("file does not end in newline");
6181
6182 #endif
6183   if (finclude (pfile, f, fname, 0, NULL_PTR))
6184     output_line_command (pfile, 0, same_file);
6185   return 1;
6186 }
6187
6188 void
6189 cpp_reader_init (pfile)
6190      cpp_reader *pfile;
6191 {
6192   bzero ((char *) pfile, sizeof (cpp_reader));
6193   pfile->get_token = cpp_get_token;
6194
6195   pfile->token_buffer_size = 200;
6196   pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
6197   CPP_SET_WRITTEN (pfile, 0);
6198
6199   pfile->system_include_depth = 0;
6200   pfile->dont_repeat_files = 0;
6201   pfile->all_include_files = 0;
6202   pfile->max_include_len = 0;
6203   pfile->timebuf = NULL;
6204   pfile->only_seen_white = 1;
6205   pfile->buffer = CPP_NULL_BUFFER(pfile);
6206 }
6207
6208 static struct cpp_pending *
6209 nreverse_pending (list)
6210      struct cpp_pending *list;
6211
6212 {
6213   register struct cpp_pending *prev = 0, *next, *pend;
6214   for (pend = list;  pend;  pend = next)
6215     {
6216       next = pend->next;
6217       pend->next = prev;
6218       prev = pend;
6219     }
6220   return prev;
6221 }
6222
6223 static void
6224 push_pending (pfile, cmd, arg)
6225      cpp_reader *pfile;
6226      char *cmd;
6227      char *arg;
6228 {
6229   struct cpp_pending *pend
6230     = (struct cpp_pending *) xmalloc (sizeof (struct cpp_pending));
6231   pend->cmd = cmd;
6232   pend->arg = arg;
6233   pend->next = CPP_OPTIONS (pfile)->pending;
6234   CPP_OPTIONS (pfile)->pending = pend;
6235 }
6236
6237 /* Handle command-line options in (argc, argv).
6238    Can be called multiple times, to handle multiple sets of options.
6239    Returns if an unrecognized option is seen.
6240    Returns number of handled arguments.  */
6241
6242 int
6243 cpp_handle_options (pfile, argc, argv)
6244      cpp_reader *pfile;
6245      int argc;
6246      char **argv;
6247 {
6248   int i;
6249   struct cpp_options *opts = CPP_OPTIONS (pfile);
6250   for (i = 0; i < argc; i++) {
6251     if (argv[i][0] != '-') {
6252       if (opts->out_fname != NULL)
6253         {
6254           cpp_fatal (pfile, "Usage: %s [switches] input output", argv[0]);
6255           return argc;
6256         }
6257       else if (opts->in_fname != NULL)
6258         opts->out_fname = argv[i];
6259       else
6260         opts->in_fname = argv[i];
6261     } else {
6262       switch (argv[i][1]) {
6263
6264       missing_filename:
6265         cpp_fatal (pfile, "Filename missing after `%s' option", argv[i]);
6266         return argc;
6267       missing_dirname:
6268         cpp_fatal (pfile, "Directory name missing after `%s' option", argv[i]);
6269         return argc;
6270
6271       case 'i':
6272         if (!strcmp (argv[i], "-include")
6273             || !strcmp (argv[i], "-imacros")) {
6274           if (i + 1 == argc)
6275             goto missing_filename;
6276           else
6277             push_pending (pfile, argv[i], argv[i+1]), i++;
6278         }
6279         if (!strcmp (argv[i], "-iprefix")) {
6280           if (i + 1 == argc)
6281             goto missing_filename;
6282           else
6283             opts->include_prefix = argv[++i];
6284         }
6285         if (!strcmp (argv[i], "-ifoutput")) {
6286           opts->output_conditionals = 1;
6287         }
6288         if (!strcmp (argv[i], "-isystem")) {
6289           struct file_name_list *dirtmp;
6290
6291           if (i + 1 == argc)
6292             goto missing_filename;
6293
6294           dirtmp = (struct file_name_list *)
6295             xmalloc (sizeof (struct file_name_list));
6296           dirtmp->next = 0;
6297           dirtmp->control_macro = 0;
6298           dirtmp->c_system_include_path = 1;
6299           dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) + 1);
6300           strcpy (dirtmp->fname, argv[++i]);
6301           dirtmp->got_name_map = 0;
6302
6303           if (opts->before_system == 0)
6304             opts->before_system = dirtmp;
6305           else
6306             opts->last_before_system->next = dirtmp;
6307           opts->last_before_system = dirtmp; /* Tail follows the last one */
6308         }
6309         /* Add directory to end of path for includes,
6310            with the default prefix at the front of its name.  */
6311         if (!strcmp (argv[i], "-iwithprefix")) {
6312           struct file_name_list *dirtmp;
6313           char *prefix;
6314
6315           if (opts->include_prefix != 0)
6316             prefix = opts->include_prefix;
6317           else {
6318             prefix = savestring (GCC_INCLUDE_DIR);
6319             /* Remove the `include' from /usr/local/lib/gcc.../include.  */
6320             if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
6321               prefix[strlen (prefix) - 7] = 0;
6322           }
6323
6324           dirtmp = (struct file_name_list *)
6325             xmalloc (sizeof (struct file_name_list));
6326           dirtmp->next = 0;     /* New one goes on the end */
6327           dirtmp->control_macro = 0;
6328           dirtmp->c_system_include_path = 0;
6329           if (i + 1 == argc)
6330             goto missing_dirname;
6331
6332           dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
6333                                             + strlen (prefix) + 1);
6334           strcpy (dirtmp->fname, prefix);
6335           strcat (dirtmp->fname, argv[++i]);
6336           dirtmp->got_name_map = 0;
6337
6338           if (opts->after_include == 0)
6339             opts->after_include = dirtmp;
6340           else
6341             opts->last_after_include->next = dirtmp;
6342           opts->last_after_include = dirtmp; /* Tail follows the last one */
6343         }
6344         /* Add directory to main path for includes,
6345            with the default prefix at the front of its name.  */
6346         if (!strcmp (argv[i], "-iwithprefixbefore")) {
6347           struct file_name_list *dirtmp;
6348           char *prefix;
6349
6350           if (opts->include_prefix != 0)
6351             prefix = opts->include_prefix;
6352           else {
6353             prefix = savestring (GCC_INCLUDE_DIR);
6354             /* Remove the `include' from /usr/local/lib/gcc.../include.  */
6355             if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
6356               prefix[strlen (prefix) - 7] = 0;
6357           }
6358
6359           dirtmp = (struct file_name_list *)
6360             xmalloc (sizeof (struct file_name_list));
6361           dirtmp->next = 0;     /* New one goes on the end */
6362           dirtmp->control_macro = 0;
6363           dirtmp->c_system_include_path = 0;
6364           if (i + 1 == argc)
6365             goto missing_dirname;
6366
6367           dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
6368                                             + strlen (prefix) + 1);
6369           strcpy (dirtmp->fname, prefix);
6370           strcat (dirtmp->fname, argv[++i]);
6371           dirtmp->got_name_map = 0;
6372
6373           append_include_chain (pfile, dirtmp, dirtmp);
6374         }
6375         /* Add directory to end of path for includes.  */
6376         if (!strcmp (argv[i], "-idirafter")) {
6377           struct file_name_list *dirtmp;
6378
6379           dirtmp = (struct file_name_list *)
6380             xmalloc (sizeof (struct file_name_list));
6381           dirtmp->next = 0;     /* New one goes on the end */
6382           dirtmp->control_macro = 0;
6383           dirtmp->c_system_include_path = 0;
6384           if (i + 1 == argc)
6385             goto missing_dirname;
6386           else
6387             dirtmp->fname = argv[++i];
6388           dirtmp->got_name_map = 0;
6389
6390           if (opts->after_include == 0)
6391             opts->after_include = dirtmp;
6392           else
6393             opts->last_after_include->next = dirtmp;
6394           opts->last_after_include = dirtmp; /* Tail follows the last one */
6395         }
6396         break;
6397
6398       case 'o':
6399         if (opts->out_fname != NULL)
6400           {
6401             cpp_fatal (pfile, "Output filename specified twice");
6402             return argc;
6403           }
6404         if (i + 1 == argc)
6405           goto missing_filename;
6406         opts->out_fname = argv[++i];
6407         if (!strcmp (opts->out_fname, "-"))
6408           opts->out_fname = "";
6409         break;
6410
6411       case 'p':
6412         if (!strcmp (argv[i], "-pedantic"))
6413           CPP_PEDANTIC (pfile) = 1;
6414         else if (!strcmp (argv[i], "-pedantic-errors")) {
6415           CPP_PEDANTIC (pfile) = 1;
6416           opts->pedantic_errors = 1;
6417         }
6418 #if 0
6419         else if (!strcmp (argv[i], "-pcp")) {
6420           char *pcp_fname = argv[++i];
6421           pcp_outfile =
6422             ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
6423              ? fopen (pcp_fname, "w")
6424              : fdopen (dup (fileno (stdout)), "w"));
6425           if (pcp_outfile == 0)
6426             cpp_pfatal_with_name (pfile, pcp_fname);
6427           no_precomp = 1;
6428         }
6429 #endif
6430         break;
6431
6432       case 't':
6433         if (!strcmp (argv[i], "-traditional")) {
6434           opts->traditional = 1;
6435         } else if (!strcmp (argv[i], "-trigraphs")) {
6436           if (!opts->chill)
6437             opts->no_trigraphs = 0;
6438         }
6439         break;
6440
6441       case 'l':
6442         if (! strcmp (argv[i], "-lang-c"))
6443           opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->objc = 0;
6444         if (! strcmp (argv[i], "-lang-c++"))
6445           opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->objc = 0;
6446         if (! strcmp (argv[i], "-lang-c-c++-comments"))
6447           opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->objc = 0;
6448         if (! strcmp (argv[i], "-lang-objc"))
6449           opts->objc = 1, opts->cplusplus = 0, opts->cplusplus_comments = 1;
6450         if (! strcmp (argv[i], "-lang-objc++"))
6451           opts->objc = 1, opts->cplusplus = 1, opts->cplusplus_comments = 1;
6452         if (! strcmp (argv[i], "-lang-asm"))
6453           opts->lang_asm = 1;
6454         if (! strcmp (argv[i], "-lint"))
6455           opts->for_lint = 1;
6456         if (! strcmp (argv[i], "-lang-chill"))
6457           opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
6458           opts->traditional = 1, opts->no_trigraphs = 1;
6459         break;
6460
6461       case '+':
6462         opts->cplusplus = 1, opts->cplusplus_comments = 1;
6463         break;
6464
6465       case 'w':
6466         opts->inhibit_warnings = 1;
6467         break;
6468
6469       case 'W':
6470         if (!strcmp (argv[i], "-Wtrigraphs"))
6471           opts->warn_trigraphs = 1;
6472         else if (!strcmp (argv[i], "-Wno-trigraphs"))
6473           opts->warn_trigraphs = 0;
6474         else if (!strcmp (argv[i], "-Wcomment"))
6475           opts->warn_comments = 1;
6476         else if (!strcmp (argv[i], "-Wno-comment"))
6477           opts->warn_comments = 0;
6478         else if (!strcmp (argv[i], "-Wcomments"))
6479           opts->warn_comments = 1;
6480         else if (!strcmp (argv[i], "-Wno-comments"))
6481           opts->warn_comments = 0;
6482         else if (!strcmp (argv[i], "-Wtraditional"))
6483           opts->warn_stringify = 1;
6484         else if (!strcmp (argv[i], "-Wno-traditional"))
6485           opts->warn_stringify = 0;
6486         else if (!strcmp (argv[i], "-Wimport"))
6487           opts->warn_import = 1;
6488         else if (!strcmp (argv[i], "-Wno-import"))
6489           opts->warn_import = 0;
6490         else if (!strcmp (argv[i], "-Werror"))
6491           opts->warnings_are_errors = 1;
6492         else if (!strcmp (argv[i], "-Wno-error"))
6493           opts->warnings_are_errors = 0;
6494         else if (!strcmp (argv[i], "-Wall"))
6495           {
6496             opts->warn_trigraphs = 1;
6497             opts->warn_comments = 1;
6498           }
6499         break;
6500
6501       case 'M':
6502         /* The style of the choices here is a bit mixed.
6503            The chosen scheme is a hybrid of keeping all options in one string
6504            and specifying each option in a separate argument:
6505            -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
6506            -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
6507            -M[M][G][D file].  This is awkward to handle in specs, and is not
6508            as extensible.  */
6509         /* ??? -MG must be specified in addition to one of -M or -MM.
6510            This can be relaxed in the future without breaking anything.
6511            The converse isn't true.  */
6512
6513         /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
6514         if (!strcmp (argv[i], "-MG"))
6515           {
6516             opts->print_deps_missing_files = 1;
6517             break;
6518           }
6519         if (!strcmp (argv[i], "-M"))
6520           opts->print_deps = 2;
6521         else if (!strcmp (argv[i], "-MM"))
6522           opts->print_deps = 1;
6523         else if (!strcmp (argv[i], "-MD"))
6524           opts->print_deps = 2;
6525         else if (!strcmp (argv[i], "-MMD"))
6526           opts->print_deps = 1;
6527         /* For -MD and -MMD options, write deps on file named by next arg.  */
6528         if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
6529           {
6530             if (i+1 == argc)
6531               goto missing_filename;
6532             opts->deps_file = argv[++i];
6533           }
6534         else
6535           {
6536             /* For -M and -MM, write deps on standard output
6537                and suppress the usual output.  */
6538             opts->no_output = 1;
6539           }
6540         break;
6541
6542       case 'd':
6543         {
6544           char *p = argv[i] + 2;
6545           char c;
6546           while ((c = *p++) != 0) {
6547             /* Arg to -d specifies what parts of macros to dump */
6548             switch (c) {
6549             case 'M':
6550               opts->dump_macros = dump_only;
6551               opts->no_output = 1;
6552               break;
6553             case 'N':
6554               opts->dump_macros = dump_names;
6555               break;
6556             case 'D':
6557               opts->dump_macros = dump_definitions;
6558               break;
6559             }
6560           }
6561         }
6562         break;
6563
6564       case 'g':
6565         if (argv[i][2] == '3')
6566           opts->debug_output = 1;
6567         break;
6568
6569       case 'v':
6570         fprintf (stderr, "GNU CPP version %s", version_string);
6571 #ifdef TARGET_VERSION
6572         TARGET_VERSION;
6573 #endif
6574         fprintf (stderr, "\n");
6575         opts->verbose = 1;
6576         break;
6577
6578       case 'H':
6579         opts->print_include_names = 1;
6580         break;
6581
6582       case 'D':
6583         if (argv[i][2] != 0)
6584           push_pending (pfile, "-D", argv[i] + 2);
6585         else if (i + 1 == argc)
6586           {
6587             cpp_fatal (pfile, "Macro name missing after -D option");
6588             return argc;
6589           }
6590         else
6591           i++, push_pending (pfile, "-D", argv[i]);
6592         break;
6593
6594       case 'A':
6595         {
6596           char *p;
6597
6598           if (argv[i][2] != 0)
6599             p = argv[i] + 2;
6600           else if (i + 1 == argc)
6601             {
6602               cpp_fatal (pfile, "Assertion missing after -A option");
6603               return argc;
6604             }
6605           else
6606             p = argv[++i];
6607
6608           if (!strcmp (p, "-")) {
6609             struct cpp_pending **ptr;
6610             /* -A- eliminates all predefined macros and assertions.
6611                Let's include also any that were specified earlier
6612                on the command line.  That way we can get rid of any
6613                that were passed automatically in from GCC.  */
6614             int j;
6615             opts->inhibit_predefs = 1;
6616             for (ptr = &opts->pending; *ptr != NULL; )
6617               {
6618                 struct cpp_pending *pend = *ptr;
6619                 if (pend->cmd && pend->cmd[0] == '-'
6620                     && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
6621                   {
6622                     *ptr = pend->next;
6623                     free (pend);
6624                   }
6625                 else
6626                   ptr = &pend->next;
6627               }
6628           } else {
6629             push_pending (pfile, "-A", p);
6630           }
6631         }
6632         break;
6633
6634       case 'U':         /* JF #undef something */
6635         if (argv[i][2] != 0)
6636           push_pending (pfile, "-U", argv[i] + 2);
6637         else if (i + 1 == argc)
6638           {
6639             cpp_fatal (pfile, "Macro name missing after -U option", NULL);
6640             return argc;
6641           }
6642         else
6643           push_pending (pfile, "-U", argv[i+1]), i++;
6644         break;
6645
6646       case 'C':
6647         opts->put_out_comments = 1;
6648         break;
6649
6650       case 'E':                 /* -E comes from cc -E; ignore it.  */
6651         break;
6652
6653       case 'P':
6654         opts->no_line_commands = 1;
6655         break;
6656
6657       case '$':                 /* Don't include $ in identifiers.  */
6658         opts->dollars_in_ident = 0;
6659         break;
6660
6661       case 'I':                 /* Add directory to path for includes.  */
6662         {
6663           struct file_name_list *dirtmp;
6664
6665           if (! CPP_OPTIONS(pfile)->ignore_srcdir
6666               && !strcmp (argv[i] + 2, "-")) {
6667             CPP_OPTIONS (pfile)->ignore_srcdir = 1;
6668             /* Don't use any preceding -I directories for #include <...>.  */
6669             CPP_OPTIONS (pfile)->first_bracket_include = 0;
6670           }
6671           else {
6672             dirtmp = (struct file_name_list *)
6673               xmalloc (sizeof (struct file_name_list));
6674             dirtmp->next = 0;           /* New one goes on the end */
6675             dirtmp->control_macro = 0;
6676             dirtmp->c_system_include_path = 0;
6677             if (argv[i][2] != 0)
6678               dirtmp->fname = argv[i] + 2;
6679             else if (i + 1 == argc)
6680               goto missing_dirname;
6681             else
6682               dirtmp->fname = argv[++i];
6683             dirtmp->got_name_map = 0;
6684             append_include_chain (pfile, dirtmp, dirtmp);
6685           }
6686         }
6687         break;
6688
6689       case 'n':
6690         if (!strcmp (argv[i], "-nostdinc"))
6691           /* -nostdinc causes no default include directories.
6692              You must specify all include-file directories with -I.  */
6693           opts->no_standard_includes = 1;
6694         else if (!strcmp (argv[i], "-nostdinc++"))
6695           /* -nostdinc++ causes no default C++-specific include directories. */
6696           opts->no_standard_cplusplus_includes = 1;
6697 #if 0
6698         else if (!strcmp (argv[i], "-noprecomp"))
6699           no_precomp = 1;
6700 #endif
6701         break;
6702
6703       case 'u':
6704         /* Sun compiler passes undocumented switch "-undef".
6705            Let's assume it means to inhibit the predefined symbols.  */
6706         opts->inhibit_predefs = 1;
6707         break;
6708
6709       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
6710         if (opts->in_fname == NULL) {
6711           opts->in_fname = "";
6712           break;
6713         } else if (opts->out_fname == NULL) {
6714           opts->out_fname = "";
6715           break;
6716         }       /* else fall through into error */
6717
6718       default:
6719         return i;
6720       }
6721     }
6722   }
6723   return i;
6724 }
6725 \f
6726 void
6727 cpp_finish (pfile)
6728      cpp_reader *pfile;
6729 {
6730   struct cpp_options *opts = CPP_OPTIONS (pfile);
6731
6732   if (opts->print_deps)
6733     {
6734       /* Stream on which to print the dependency information.  */
6735       FILE *deps_stream;
6736
6737       /* Don't actually write the deps file if compilation has failed.  */
6738       if (pfile->errors == 0)
6739         {
6740           char *deps_mode = opts->print_deps_append ? "a" : "w";
6741           if (opts->deps_file == 0)
6742             deps_stream = stdout;
6743           else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
6744             cpp_pfatal_with_name (pfile, opts->deps_file);
6745           fputs (pfile->deps_buffer, deps_stream);
6746           putc ('\n', deps_stream);
6747           if (opts->deps_file)
6748             {
6749               if (ferror (deps_stream) || fclose (deps_stream) != 0)
6750                 cpp_fatal (pfile, "I/O error on output");
6751             }
6752         }
6753     }
6754 }
6755
6756 /* Free resources used by PFILE.
6757    This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology).  */
6758
6759 void
6760 cpp_cleanup (pfile)
6761      cpp_reader *pfile;
6762 {
6763   int i;
6764   while ( CPP_BUFFER (pfile) != CPP_NULL_BUFFER (pfile))
6765     cpp_pop_buffer (pfile);
6766
6767   if (pfile->token_buffer)
6768     {
6769       free (pfile->token_buffer);
6770       pfile->token_buffer = NULL;
6771     }
6772
6773   if (pfile->deps_buffer)
6774     {
6775       free (pfile->deps_buffer);
6776       pfile->deps_buffer = NULL;
6777       pfile->deps_allocated_size = 0;
6778     }
6779
6780   while (pfile->if_stack)
6781     {
6782       IF_STACK_FRAME *temp = pfile->if_stack;
6783       pfile->if_stack = temp->next;
6784       free (temp);
6785     }
6786
6787   while (pfile->dont_repeat_files)
6788     {
6789       struct file_name_list *temp = pfile->dont_repeat_files;
6790       pfile->dont_repeat_files = temp->next;
6791       free (temp->fname);
6792       free (temp);
6793     }
6794
6795   while (pfile->all_include_files)
6796     {
6797       struct file_name_list *temp = pfile->all_include_files;
6798       pfile->all_include_files = temp->next;
6799       free (temp->fname);
6800       free (temp);
6801     }
6802
6803   for (i = IMPORT_HASH_SIZE; --i >= 0; )
6804     {
6805       register struct import_file *imp = pfile->import_hash_table[i];
6806       while (imp)
6807         {
6808           struct import_file *next = imp->next;
6809           free (imp->name);
6810           free (imp);
6811           imp = next;
6812         }
6813       pfile->import_hash_table[i] = 0;
6814     }
6815
6816   for (i = ASSERTION_HASHSIZE; --i >= 0; )
6817     {
6818       while (pfile->assertion_hashtab[i])
6819         delete_assertion (pfile->assertion_hashtab[i]);
6820     }
6821
6822   cpp_hash_cleanup (pfile);
6823 }
6824 \f
6825 static int
6826 do_assert (pfile, keyword, buf, limit)
6827      cpp_reader *pfile;
6828      struct directive *keyword;
6829      U_CHAR *buf, *limit;
6830 {
6831   long symstart;                /* remember where symbol name starts */
6832   int c;
6833   int sym_length;               /* and how long it is */
6834   struct arglist *tokens = NULL;
6835
6836   if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
6837       && !CPP_BUFFER (pfile)->system_header_p)
6838     cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
6839
6840   cpp_skip_hspace (pfile);
6841   symstart = CPP_WRITTEN (pfile);       /* remember where it starts */
6842   parse_name (pfile, GETC());
6843   sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
6844                                  "assertion");
6845
6846   cpp_skip_hspace (pfile);
6847   if (PEEKC() != '(') {
6848     cpp_error (pfile, "missing token-sequence in `#assert'");
6849     goto error;
6850   }
6851
6852   {
6853     int error_flag = 0;
6854     tokens = read_token_list (pfile, &error_flag);
6855     if (error_flag)
6856       goto error;
6857     if (tokens == 0) {
6858       cpp_error (pfile, "empty token-sequence in `#assert'");
6859       goto error;
6860     }
6861   cpp_skip_hspace (pfile);
6862   c = PEEKC ();
6863   if (c != EOF && c != '\n')
6864       cpp_pedwarn (pfile, "junk at end of `#assert'");
6865   skip_rest_of_line (pfile);
6866   }
6867
6868   /* If this name isn't already an assertion name, make it one.
6869      Error if it was already in use in some other way.  */
6870
6871   {
6872     ASSERTION_HASHNODE *hp;
6873     U_CHAR *symname = pfile->token_buffer + symstart;
6874     int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6875     struct tokenlist_list *value
6876       = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6877
6878     hp = assertion_lookup (pfile, symname, sym_length, hashcode);
6879     if (hp == NULL) {
6880       if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
6881         cpp_error (pfile, "`defined' redefined as assertion");
6882       hp = assertion_install (pfile, symname, sym_length, hashcode);
6883     }
6884
6885     /* Add the spec'd token-sequence to the list of such.  */
6886     value->tokens = tokens;
6887     value->next = hp->value;
6888     hp->value = value;
6889   }
6890   CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6891   return 0;
6892  error:
6893   CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6894   skip_rest_of_line (pfile);
6895   return 1;
6896 }
6897 \f
6898 static int
6899 do_unassert (pfile, keyword, buf, limit)
6900      cpp_reader *pfile;
6901      struct directive *keyword;
6902      U_CHAR *buf, *limit;
6903 {
6904   long symstart;                /* remember where symbol name starts */
6905   int sym_length;       /* and how long it is */
6906   int c;
6907
6908   struct arglist *tokens = NULL;
6909   int tokens_specified = 0;
6910
6911   if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
6912       && !CPP_BUFFER (pfile)->system_header_p)
6913     cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
6914
6915   cpp_skip_hspace (pfile);
6916
6917   symstart = CPP_WRITTEN (pfile);       /* remember where it starts */
6918   parse_name (pfile, GETC());
6919   sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
6920                                  "assertion");
6921
6922   cpp_skip_hspace (pfile);
6923   if (PEEKC() == '(') {
6924     int error_flag = 0;
6925
6926     tokens = read_token_list (pfile, &error_flag);
6927     if (error_flag)
6928       goto error;
6929     if (tokens == 0) {
6930       cpp_error (pfile, "empty token list in `#unassert'");
6931       goto error;
6932     }
6933
6934     tokens_specified = 1;
6935   }
6936
6937   cpp_skip_hspace (pfile);
6938   c = PEEKC ();
6939   if (c != EOF && c != '\n')
6940       cpp_error (pfile, "junk at end of `#unassert'");
6941   skip_rest_of_line (pfile);
6942
6943   {
6944     ASSERTION_HASHNODE *hp;
6945     U_CHAR *symname = pfile->token_buffer + symstart;
6946     int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6947     struct tokenlist_list *tail, *prev;
6948
6949     hp = assertion_lookup (pfile, symname, sym_length, hashcode);
6950     if (hp == NULL)
6951       return 1;
6952
6953     /* If no token list was specified, then eliminate this assertion
6954        entirely.  */
6955     if (! tokens_specified)
6956       delete_assertion (hp);
6957     else {
6958       /* If a list of tokens was given, then delete any matching list.  */
6959
6960       tail = hp->value;
6961       prev = 0;
6962       while (tail) {
6963         struct tokenlist_list *next = tail->next;
6964         if (compare_token_lists (tail->tokens, tokens)) {
6965           if (prev)
6966             prev->next = next;
6967           else
6968             hp->value = tail->next;
6969           free_token_list (tail->tokens);
6970           free (tail);
6971         } else {
6972           prev = tail;
6973         }
6974         tail = next;
6975       }
6976     }
6977   }
6978
6979   CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6980   return 0;
6981  error:
6982   CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6983   skip_rest_of_line (pfile);
6984   return 1;
6985 }
6986 \f
6987 /* Test whether there is an assertion named NAME
6988    and optionally whether it has an asserted token list TOKENS.
6989    NAME is not null terminated; its length is SYM_LENGTH.
6990    If TOKENS_SPECIFIED is 0, then don't check for any token list.  */
6991
6992 int
6993 check_assertion (pfile, name, sym_length, tokens_specified, tokens)
6994      cpp_reader *pfile;
6995      U_CHAR *name;
6996      int sym_length;
6997      int tokens_specified;
6998      struct arglist *tokens;
6999 {
7000   ASSERTION_HASHNODE *hp;
7001   int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
7002
7003   if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
7004     cpp_pedwarn (pfile, "ANSI C does not allow testing assertions");
7005
7006   hp = assertion_lookup (pfile, name, sym_length, hashcode);
7007   if (hp == NULL)
7008     /* It is not an assertion; just return false.  */
7009     return 0;
7010
7011   /* If no token list was specified, then value is 1.  */
7012   if (! tokens_specified)
7013     return 1;
7014
7015   {
7016     struct tokenlist_list *tail;
7017
7018     tail = hp->value;
7019
7020     /* If a list of tokens was given,
7021        then succeed if the assertion records a matching list.  */
7022
7023     while (tail) {
7024       if (compare_token_lists (tail->tokens, tokens))
7025         return 1;
7026       tail = tail->next;
7027     }
7028
7029     /* Fail if the assertion has no matching list.  */
7030     return 0;
7031   }
7032 }
7033
7034 /* Compare two lists of tokens for equality including order of tokens.  */
7035
7036 static int
7037 compare_token_lists (l1, l2)
7038      struct arglist *l1, *l2;
7039 {
7040   while (l1 && l2) {
7041     if (l1->length != l2->length)
7042       return 0;
7043     if (strncmp (l1->name, l2->name, l1->length))
7044       return 0;
7045     l1 = l1->next;
7046     l2 = l2->next;
7047   }
7048
7049   /* Succeed if both lists end at the same time.  */
7050   return l1 == l2;
7051 }
7052 \f
7053 struct arglist *
7054 reverse_token_list (tokens)
7055      struct arglist *tokens;
7056 {
7057   register struct arglist *prev = 0, *this, *next;
7058   for (this = tokens; this; this = next)
7059     {
7060       next = this->next;
7061       this->next = prev;
7062       prev = this;
7063     }
7064   return prev;
7065 }
7066
7067 /* Read a space-separated list of tokens ending in a close parenthesis.
7068    Return a list of strings, in the order they were written.
7069    (In case of error, return 0 and store -1 in *ERROR_FLAG.) */
7070
7071 static struct arglist *
7072 read_token_list (pfile, error_flag)
7073      cpp_reader *pfile;
7074      int *error_flag;
7075 {
7076   struct arglist *token_ptrs = 0;
7077   int depth = 1;
7078   int length;
7079
7080   *error_flag = 0;
7081   FORWARD (1);  /* Skip '(' */
7082
7083   /* Loop over the assertion value tokens.  */
7084   while (depth > 0)
7085     {
7086       struct arglist *temp;
7087       long name_written = CPP_WRITTEN (pfile);
7088       int eofp = 0;  int c;
7089
7090       cpp_skip_hspace (pfile);
7091
7092       c = GETC ();
7093
7094       /* Find the end of the token.  */
7095       if (c == '(')
7096         {
7097           CPP_PUTC (pfile, c);
7098           depth++;
7099         }
7100       else if (c == ')')
7101         {
7102           depth--;
7103           if (depth == 0)
7104             break;
7105           CPP_PUTC (pfile, c);
7106         }
7107       else if (c == '"' || c == '\'')
7108         {
7109           FORWARD(-1);
7110           cpp_get_token (pfile);
7111         }
7112       else if (c == '\n')
7113         break;
7114       else
7115         {
7116           while (c != EOF && ! is_space[c] && c != '(' && c != ')'
7117                  && c != '"' && c != '\'')
7118             {
7119               CPP_PUTC (pfile, c);
7120               c = GETC();
7121             }
7122           if (c != EOF)  FORWARD(-1);
7123         }
7124
7125       length = CPP_WRITTEN (pfile) - name_written;
7126       temp = (struct arglist *)
7127           xmalloc (sizeof (struct arglist) + length + 1);
7128       temp->name = (U_CHAR *) (temp + 1);
7129       bcopy ((char *) (pfile->token_buffer + name_written),
7130              (char *) temp->name, length);
7131       temp->name[length] = 0;
7132       temp->next = token_ptrs;
7133       token_ptrs = temp;
7134       temp->length = length;
7135
7136       CPP_ADJUST_WRITTEN (pfile, -length); /* pop */
7137
7138       if (c == EOF || c == '\n')
7139         { /* FIXME */
7140           cpp_error (pfile,
7141                      "unterminated token sequence following  `#' operator");
7142           return 0;
7143         }
7144     }
7145
7146   /* We accumulated the names in reverse order.
7147      Now reverse them to get the proper order.  */
7148   return reverse_token_list (token_ptrs);
7149 }
7150
7151 static void
7152 free_token_list (tokens)
7153      struct arglist *tokens;
7154 {
7155   while (tokens) {
7156     struct arglist *next = tokens->next;
7157     free (tokens->name);
7158     free (tokens);
7159     tokens = next;
7160   }
7161 }
7162 \f
7163 /* Get the file-mode and data size of the file open on FD
7164    and store them in *MODE_POINTER and *SIZE_POINTER.  */
7165
7166 static int
7167 file_size_and_mode (fd, mode_pointer, size_pointer)
7168      int fd;
7169      int *mode_pointer;
7170      long int *size_pointer;
7171 {
7172   struct stat sbuf;
7173
7174   if (fstat (fd, &sbuf) < 0) return (-1);
7175   if (mode_pointer) *mode_pointer = sbuf.st_mode;
7176   if (size_pointer) *size_pointer = sbuf.st_size;
7177   return 0;
7178 }
7179
7180 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
7181    retrying if necessary.  Return a negative value if an error occurs,
7182    otherwise return the actual number of bytes read,
7183    which must be LEN unless end-of-file was reached.  */
7184
7185 static int
7186 safe_read (desc, ptr, len)
7187      int desc;
7188      char *ptr;
7189      int len;
7190 {
7191   int left = len;
7192   while (left > 0) {
7193     int nchars = read (desc, ptr, left);
7194     if (nchars < 0)
7195       {
7196 #ifdef EINTR
7197         if (errno == EINTR)
7198           continue;
7199 #endif
7200         return nchars;
7201       }
7202     if (nchars == 0)
7203       break;
7204     ptr += nchars;
7205     left -= nchars;
7206   }
7207   return len - left;
7208 }
7209
7210 static char *
7211 xcalloc (number, size)
7212      unsigned number, size;
7213 {
7214   register unsigned total = number * size;
7215   register char *ptr = (char *) xmalloc (total);
7216   bzero (ptr, total);
7217   return ptr;
7218 }
7219
7220 static char *
7221 savestring (input)
7222      char *input;
7223 {
7224   unsigned size = strlen (input);
7225   char *output = xmalloc (size + 1);
7226   strcpy (output, input);
7227   return output;
7228 }
7229 \f
7230 /* Initialize PMARK to remember the current position of PFILE.  */
7231
7232 void
7233 parse_set_mark (pmark, pfile)
7234      struct parse_marker *pmark;
7235      cpp_reader *pfile;
7236 {
7237   cpp_buffer *pbuf = CPP_BUFFER (pfile);
7238   pmark->next = pbuf->marks;
7239   pbuf->marks = pmark;
7240   pmark->buf = pbuf;
7241   pmark->position = pbuf->cur - pbuf->buf;
7242 }
7243
7244 /* Cleanup PMARK - we no longer need it.  */
7245
7246 void
7247 parse_clear_mark (pmark)
7248      struct parse_marker *pmark;
7249 {
7250   struct parse_marker **pp = &pmark->buf->marks;
7251   for (; ; pp = &(*pp)->next) {
7252     if (*pp == NULL) abort ();
7253     if (*pp == pmark) break;
7254   }
7255   *pp = pmark->next;
7256 }
7257
7258 /* Backup the current position of PFILE to that saved in PMARK.  */
7259
7260 void
7261 parse_goto_mark (pmark, pfile)
7262      struct parse_marker *pmark;
7263      cpp_reader *pfile;
7264 {
7265   cpp_buffer *pbuf = CPP_BUFFER (pfile);
7266   if (pbuf != pmark->buf)
7267     cpp_fatal (pfile, "internal error %s", "parse_goto_mark");
7268   pbuf->cur = pbuf->buf + pmark->position;
7269 }
7270
7271 /* Reset PMARK to point to the current position of PFILE.  (Same
7272    as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster.  */
7273
7274 void
7275 parse_move_mark (pmark, pfile)
7276      struct parse_marker *pmark;
7277      cpp_reader *pfile;
7278 {
7279   cpp_buffer *pbuf = CPP_BUFFER (pfile);
7280   if (pbuf != pmark->buf)
7281     cpp_fatal (pfile, "internal error %s", "parse_move_mark");
7282   pmark->position = pbuf->cur - pbuf->buf;
7283 }
7284
7285 int
7286 cpp_read_check_assertion (pfile)
7287      cpp_reader *pfile;
7288 {
7289   int name_start = CPP_WRITTEN (pfile);
7290   int name_length, name_written;
7291   int result;
7292   FORWARD (1);  /* Skip '#' */
7293   cpp_skip_hspace (pfile);
7294   parse_name (pfile, GETC ());
7295   name_written = CPP_WRITTEN (pfile);
7296   name_length = name_written - name_start;
7297   cpp_skip_hspace (pfile);
7298   if (CPP_BUF_PEEK (CPP_BUFFER (pfile)) == '(')
7299     {
7300       int error_flag;
7301       struct arglist *token_ptrs = read_token_list (pfile, &error_flag);
7302       result = check_assertion (pfile,
7303                                 pfile->token_buffer + name_start, name_length,
7304                                 1, token_ptrs);
7305     }
7306   else
7307     result = check_assertion (pfile,
7308                               pfile->token_buffer + name_start, name_length,
7309                               0, NULL_PTR);
7310   CPP_ADJUST_WRITTEN (pfile, - name_length);  /* pop */
7311   return result;
7312 }
7313 \f
7314 void
7315 cpp_print_file_and_line (pfile)
7316      cpp_reader *pfile;
7317 {
7318   cpp_buffer *ip = cpp_file_buffer (pfile);
7319
7320   if (ip != NULL)
7321     {
7322       long line, col;
7323       cpp_buf_line_and_col (ip, &line, &col);
7324       cpp_file_line_for_message (pfile, ip->nominal_fname,
7325                                  line, pfile->show_column ? col : -1);
7326     }
7327 }
7328
7329 void
7330 cpp_error (pfile, msg, arg1, arg2, arg3)
7331      cpp_reader *pfile;
7332      char *msg;
7333      char *arg1, *arg2, *arg3;
7334 {
7335   cpp_print_containing_files (pfile);
7336   cpp_print_file_and_line (pfile);
7337   cpp_message (pfile, 1, msg, arg1, arg2, arg3);
7338 }
7339
7340 /* Print error message but don't count it.  */
7341
7342 void
7343 cpp_warning (pfile, msg, arg1, arg2, arg3)
7344      cpp_reader *pfile;
7345      char *msg;
7346      char *arg1, *arg2, *arg3;
7347 {
7348   if (CPP_OPTIONS (pfile)->inhibit_warnings)
7349     return;
7350
7351   if (CPP_OPTIONS (pfile)->warnings_are_errors)
7352     pfile->errors++;
7353
7354   cpp_print_containing_files (pfile);
7355   cpp_print_file_and_line (pfile);
7356   cpp_message (pfile, 0, msg, arg1, arg2, arg3);
7357 }
7358
7359 /* Print an error message and maybe count it.  */
7360
7361 void
7362 cpp_pedwarn (pfile, msg, arg1, arg2, arg3)
7363      cpp_reader *pfile;
7364      char *msg;
7365      char *arg1, *arg2, *arg3;
7366 {
7367   if (CPP_OPTIONS (pfile)->pedantic_errors)
7368     cpp_error (pfile, msg, arg1, arg2, arg3);
7369   else
7370     cpp_warning (pfile, msg, arg1, arg2, arg3);
7371 }
7372
7373 void
7374 cpp_error_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7375      cpp_reader *pfile;
7376      int line, column;
7377      char *msg;
7378      char *arg1, *arg2, *arg3;
7379 {
7380   int i;
7381   cpp_buffer *ip = cpp_file_buffer (pfile);
7382
7383   cpp_print_containing_files (pfile);
7384
7385   if (ip != NULL)
7386     cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
7387
7388   cpp_message (pfile, 1, msg, arg1, arg2, arg3);
7389 }
7390
7391 static void
7392 cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7393      cpp_reader *pfile;
7394      int line, column;
7395      char *msg;
7396      char *arg1, *arg2, *arg3;
7397 {
7398   int i;
7399   cpp_buffer *ip;
7400
7401   if (CPP_OPTIONS (pfile)->inhibit_warnings)
7402     return;
7403
7404   if (CPP_OPTIONS (pfile)->warnings_are_errors)
7405     pfile->errors++;
7406
7407   cpp_print_containing_files (pfile);
7408
7409   ip = cpp_file_buffer (pfile);
7410
7411   if (ip != NULL)
7412     cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
7413
7414   cpp_message (pfile, 0, msg, arg1, arg2, arg3);
7415 }
7416
7417 void
7418 cpp_pedwarn_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7419      cpp_reader *pfile;
7420      int line;
7421      char *msg;
7422      char *arg1, *arg2, *arg3;
7423 {
7424   if (CPP_OPTIONS (pfile)->pedantic_errors)
7425     cpp_error_with_line (pfile, column, line, msg, arg1, arg2, arg3);
7426   else
7427     cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3);
7428 }
7429
7430 /* Report a warning (or an error if pedantic_errors)
7431    giving specified file name and line number, not current.  */
7432
7433 void
7434 cpp_pedwarn_with_file_and_line (pfile, file, line, msg, arg1, arg2, arg3)
7435      cpp_reader *pfile;
7436      char *file;
7437      int line;
7438      char *msg;
7439      char *arg1, *arg2, *arg3;
7440 {
7441   if (!CPP_OPTIONS (pfile)->pedantic_errors
7442       && CPP_OPTIONS (pfile)->inhibit_warnings)
7443     return;
7444   if (file != NULL)
7445     cpp_file_line_for_message (pfile, file, line, -1);
7446   cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
7447                msg, arg1, arg2, arg3);
7448 }
7449
7450 /* This defines "errno" properly for VMS, and gives us EACCES.  */
7451 #include <errno.h>
7452 #ifndef errno
7453 extern int errno;
7454 #endif
7455
7456 #ifndef VMS
7457 #ifndef HAVE_STRERROR
7458 extern int sys_nerr;
7459 #if defined(bsd4_4)
7460 extern const char *const sys_errlist[];
7461 #else
7462 extern char *sys_errlist[];
7463 #endif
7464 #else   /* HAVE_STRERROR */
7465 char *strerror ();
7466 #endif
7467 #else   /* VMS */
7468 char *strerror (int,...);
7469 #endif
7470
7471 /* my_strerror - return the descriptive text associated with an
7472    `errno' code.  */
7473
7474 char *
7475 my_strerror (errnum)
7476      int errnum;
7477 {
7478   char *result;
7479
7480 #ifndef VMS
7481 #ifndef HAVE_STRERROR
7482   result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
7483 #else
7484   result = strerror (errnum);
7485 #endif
7486 #else   /* VMS */
7487   /* VAXCRTL's strerror() takes an optional second argument, which only
7488      matters when the first argument is EVMSERR.  However, it's simplest
7489      just to pass it unconditionally.  `vaxc$errno' is declared in
7490      <errno.h>, and maintained by the library in parallel with `errno'.
7491      We assume that caller's `errnum' either matches the last setting of
7492      `errno' by the library or else does not have the value `EVMSERR'.  */
7493
7494   result = strerror (errnum, vaxc$errno);
7495 #endif
7496
7497   if (!result)
7498     result = "undocumented I/O error";
7499
7500   return result;
7501 }
7502
7503 /* Error including a message from `errno'.  */
7504
7505 void
7506 cpp_error_from_errno (pfile, name)
7507      cpp_reader *pfile;
7508      char *name;
7509 {
7510   int i;
7511   cpp_buffer *ip = cpp_file_buffer (pfile);
7512
7513   cpp_print_containing_files (pfile);
7514
7515   if (ip != NULL)
7516     cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
7517
7518   cpp_message (pfile, 1, "%s: %s", name, my_strerror (errno));
7519 }
7520
7521 void
7522 cpp_perror_with_name (pfile, name)
7523      cpp_reader *pfile;
7524      char *name;
7525 {
7526   cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
7527 }
7528
7529 /* TODO:
7530  * No pre-compiled header file support.
7531  *
7532  * Possibly different enum token codes for each C/C++ token.
7533  *
7534  * Should clean up remaining directives to that do_XXX functions
7535  *   only take two arguments and all have command_reads_line.
7536  *
7537  * Find and cleanup remaining uses of static variables,
7538  *
7539  * Support for trigraphs.
7540  *
7541  * Support -dM flag (dump_all_macros).
7542  *
7543  * Support for_lint flag.
7544  */