gcc/cccp.c

   1 /* C Compatible Compiler Preprocessor (CCCP)
   2    Copyright (C) 1986, 87, 89, 92-95, 1996 Free Software Foundation, Inc.
   3    Written by Paul Rubin, June 1986
   4    Adapted to ANSI C, Richard Stallman, Jan 1987
   5
   6 This program is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, 59 Temple Place - Suite 330,
  19 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 \f
  25 typedef unsigned char U_CHAR;
  26
  27 #ifdef EMACS
  28 #define NO_SHORTNAMES
  29 #include "../src/config.h"
  30 #ifdef open
  31 #undef open
  32 #undef read
  33 #undef write
  34 #endif /* open */
  35 #endif /* EMACS */
  36
  37 /* The macro EMACS is defined when cpp is distributed as part of Emacs,
  38    for the sake of machines with limited C compilers.  */
  39 #ifndef EMACS
  40 #include "config.h"
  41 #endif /* not EMACS */
  42
  43 #ifndef STANDARD_INCLUDE_DIR
  44 #define STANDARD_INCLUDE_DIR "/usr/include"
  45 #endif
  46
  47 #include "pcp.h"
  48
  49 /* By default, colon separates directories in a path.  */
  50 #ifndef PATH_SEPARATOR
  51 #define PATH_SEPARATOR ':'
  52 #endif
  53
  54 #include <sys/types.h>
  55 #include <sys/stat.h>
  56 #include <ctype.h>
  57 #include <stdio.h>
  58 #include <signal.h>
  59
  60 /* The following symbols should be autoconfigured:
  61         HAVE_FCNTL_H
  62         HAVE_STDLIB_H
  63         HAVE_SYS_TIME_H
  64         HAVE_UNISTD_H
  65         STDC_HEADERS
  66         TIME_WITH_SYS_TIME
  67    In the mean time, we'll get by with approximations based
  68    on existing GCC configuration symbols.  */
  69
  70 #ifdef POSIX
  71 # ifndef HAVE_STDLIB_H
  72 # define HAVE_STDLIB_H 1
  73 # endif
  74 # ifndef HAVE_UNISTD_H
  75 # define HAVE_UNISTD_H 1
  76 # endif
  77 # ifndef STDC_HEADERS
  78 # define STDC_HEADERS 1
  79 # endif
  80 #endif /* defined (POSIX) */
  81
  82 #if defined (POSIX) || (defined (USG) && !defined (VMS))
  83 # ifndef HAVE_FCNTL_H
  84 # define HAVE_FCNTL_H 1
  85 # endif
  86 #endif
  87
  88 #ifndef RLIMIT_STACK
  89 # include <time.h>
  90 #else
  91 # if TIME_WITH_SYS_TIME
  92 #  include <sys/time.h>
  93 #  include <time.h>
  94 # else
  95 #  if HAVE_SYS_TIME_H
  96 #   include <sys/time.h>
  97 #  else
  98 #   include <time.h>
  99 #  endif
 100 # endif
 101 # include <sys/resource.h>
 102 #endif
 103
 104 #if HAVE_FCNTL_H
 105 # include <fcntl.h>
 106 #endif
 107
 108 #include <errno.h>
 109
 110 #if HAVE_STDLIB_H
 111 # include <stdlib.h>
 112 #else
 113 char *getenv ();
 114 #endif
 115
 116 #if STDC_HEADERS
 117 # include <string.h>
 118 # ifndef bcmp
 119 # define bcmp(a, b, n) memcmp (a, b, n)
 120 # endif
 121 # ifndef bcopy
 122 # define bcopy(s, d, n) memcpy (d, s, n)
 123 # endif
 124 # ifndef bzero
 125 # define bzero(d, n) memset (d, 0, n)
 126 # endif
 127 #else /* !STDC_HEADERS */
 128 char *index ();
 129 char *rindex ();
 130
 131 # if !defined (BSTRING) && (defined (USG) || defined (VMS))
 132
 133 #  ifndef bcmp
 134 #  define bcmp my_bcmp
 135 static int
 136 my_bcmp (a, b, n)
 137      register char *a;
 138      register char *b;
 139      register unsigned n;
 140 {
 141    while (n-- > 0)
 142      if (*a++ != *b++)
 143        return 1;
 144
 145    return 0;
 146 }
 147 #  endif /* !defined (bcmp) */
 148
 149 #  ifndef bcopy
 150 #  define bcopy my_bcopy
 151 static void
 152 my_bcopy (s, d, n)
 153      register char *s;
 154      register char *d;
 155      register unsigned n;
 156 {
 157   while (n-- > 0)
 158     *d++ = *s++;
 159 }
 160 #  endif /* !defined (bcopy) */
 161
 162 #  ifndef bzero
 163 #  define bzero my_bzero
 164 static void
 165 my_bzero (b, length)
 166      register char *b;
 167      register unsigned length;
 168 {
 169   while (length-- > 0)
 170     *b++ = 0;
 171 }
 172 #  endif /* !defined (bzero) */
 173
 174 # endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
 175 #endif /* ! STDC_HEADERS */
 176
 177 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 6)
 178 # define __attribute__(x)
 179 #endif
 180
 181 #ifndef PROTO
 182 # if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
 183 #  define PROTO(ARGS) ARGS
 184 # else
 185 #  define PROTO(ARGS) ()
 186 # endif
 187 #endif
 188
 189 #if defined (__STDC__) && defined (HAVE_VPRINTF)
 190 # include <stdarg.h>
 191 # define VA_START(va_list, var) va_start (va_list, var)
 192 # define PRINTF_ALIST(msg) char *msg, ...
 193 # define PRINTF_DCL(msg)
 194 # define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (printf, m, n)))
 195 #else
 196 # include <varargs.h>
 197 # define VA_START(va_list, var) va_start (va_list)
 198 # define PRINTF_ALIST(msg) msg, va_alist
 199 # define PRINTF_DCL(msg) char *msg; va_dcl
 200 # define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (printf, m, n)))
 201 # define vfprintf(file, msg, args) \
 202     { \
 203       char *a0 = va_arg(args, char *); \
 204       char *a1 = va_arg(args, char *); \
 205       char *a2 = va_arg(args, char *); \
 206       char *a3 = va_arg(args, char *); \
 207       fprintf (file, msg, a0, a1, a2, a3); \
 208     }
 209 #endif
 210
 211 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
 212 #define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
 213 #define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
 214
 215 #if HAVE_UNISTD_H
 216 # include <unistd.h>
 217 #endif
 218
 219 /* VMS-specific definitions */
 220 #ifdef VMS
 221 #include <descrip.h>
 222 #define O_RDONLY        0       /* Open arg for Read/Only  */
 223 #define O_WRONLY        1       /* Open arg for Write/Only */
 224 #define read(fd,buf,size)       VMS_read (fd,buf,size)
 225 #define write(fd,buf,size)      VMS_write (fd,buf,size)
 226 #define open(fname,mode,prot)   VMS_open (fname,mode,prot)
 227 #define fopen(fname,mode)       VMS_fopen (fname,mode)
 228 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
 229 #define fstat(fd,stbuf)         VMS_fstat (fd,stbuf)
 230 static int VMS_fstat (), VMS_stat ();
 231 static int VMS_read ();
 232 static int VMS_write ();
 233 static int VMS_open ();
 234 static FILE * VMS_fopen ();
 235 static FILE * VMS_freopen ();
 236 static void hack_vms_include_specification ();
 237 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
 238 #define INO_T_HASH(a) 0
 239 #define INCLUDE_LEN_FUDGE 12    /* leave room for VMS syntax conversion */
 240 #ifdef __GNUC__
 241 #define BSTRING                 /* VMS/GCC supplies the bstring routines */
 242 #endif /* __GNUC__ */
 243 #endif /* VMS */
 244
 245 #ifndef O_RDONLY
 246 #define O_RDONLY 0
 247 #endif
 248
 249 #undef MIN
 250 #undef MAX
 251 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
 252 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
 253
 254 /* Find the largest host integer type and set its size and type.
 255    Don't blindly use `long'; on some crazy hosts it is shorter than `int'.  */
 256
 257 #ifndef HOST_BITS_PER_WIDE_INT
 258
 259 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
 260 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
 261 #define HOST_WIDE_INT long
 262 #else
 263 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
 264 #define HOST_WIDE_INT int
 265 #endif
 266
 267 #endif
 268
 269 #ifndef S_ISREG
 270 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 271 #endif
 272
 273 #ifndef S_ISDIR
 274 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 275 #endif
 276
 277 #ifndef INO_T_EQ
 278 #define INO_T_EQ(a, b) ((a) == (b))
 279 #endif
 280
 281 #ifndef INO_T_HASH
 282 #define INO_T_HASH(a) (a)
 283 #endif
 284
 285 /* Define a generic NULL if one hasn't already been defined.  */
 286
 287 #ifndef NULL
 288 #define NULL 0
 289 #endif
 290
 291 #ifndef GENERIC_PTR
 292 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
 293 #define GENERIC_PTR void *
 294 #else
 295 #define GENERIC_PTR char *
 296 #endif
 297 #endif
 298
 299 #ifndef NULL_PTR
 300 #define NULL_PTR ((GENERIC_PTR) 0)
 301 #endif
 302
 303 #ifndef INCLUDE_LEN_FUDGE
 304 #define INCLUDE_LEN_FUDGE 0
 305 #endif
 306
 307 /* External declarations.  */
 308
 309 extern char *version_string;
 310 #ifndef VMS
 311 #ifndef HAVE_STRERROR
 312 extern int sys_nerr;
 313 #if defined(bsd4_4)
 314 extern const char *const sys_errlist[];
 315 #else
 316 extern char *sys_errlist[];
 317 #endif
 318 #else   /* HAVE_STRERROR */
 319 char *strerror ();
 320 #endif
 321 #else   /* VMS */
 322 char *strerror (int,...);
 323 #endif
 324 HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
 325 HOST_WIDE_INT parse_c_expression PROTO((char *));
 326
 327 #ifndef errno
 328 extern int errno;
 329 #endif
 330 \f
 331 /* Name under which this program was invoked.  */
 332
 333 static char *progname;
 334
 335 /* Nonzero means use extra default include directories for C++.  */
 336
 337 static int cplusplus;
 338
 339 /* Nonzero means handle cplusplus style comments */
 340
 341 static int cplusplus_comments;
 342
 343 /* Nonzero means handle #import, for objective C.  */
 344
 345 static int objc;
 346
 347 /* Nonzero means this is an assembly file, and allow
 348    unknown directives, which could be comments.  */
 349
 350 static int lang_asm;
 351
 352 /* Current maximum length of directory names in the search path
 353    for include files.  (Altered as we get more of them.)  */
 354
 355 static int max_include_len;
 356
 357 /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
 358
 359 static int for_lint = 0;
 360
 361 /* Nonzero means copy comments into the output file.  */
 362
 363 static int put_out_comments = 0;
 364
 365 /* Nonzero means don't process the ANSI trigraph sequences.  */
 366
 367 static int no_trigraphs = 0;
 368
 369 /* Nonzero means print the names of included files rather than
 370    the preprocessed output.  1 means just the #include "...",
 371    2 means #include <...> as well.  */
 372
 373 static int print_deps = 0;
 374
 375 /* Nonzero if missing .h files in -M output are assumed to be generated
 376    files and not errors.  */
 377
 378 static int print_deps_missing_files = 0;
 379
 380 /* Nonzero means print names of header files (-H).  */
 381
 382 static int print_include_names = 0;
 383
 384 /* Nonzero means don't output line number information.  */
 385
 386 static int no_line_directives;
 387
 388 /* Nonzero means output the text in failing conditionals,
 389    inside #failed ... #endfailed.  */
 390
 391 static int output_conditionals;
 392
 393 /* dump_only means inhibit output of the preprocessed text
 394              and instead output the definitions of all user-defined
 395              macros in a form suitable for use as input to cccp.
 396    dump_names means pass #define and the macro name through to output.
 397    dump_definitions means pass the whole definition (plus #define) through
 398 */
 399
 400 static enum {dump_none, dump_only, dump_names, dump_definitions}
 401      dump_macros = dump_none;
 402
 403 /* Nonzero means pass all #define and #undef directives which we actually
 404    process through to the output stream.  This feature is used primarily
 405    to allow cc1 to record the #defines and #undefs for the sake of
 406    debuggers which understand about preprocessor macros, but it may
 407    also be useful with -E to figure out how symbols are defined, and
 408    where they are defined.  */
 409 static int debug_output = 0;
 410
 411 /* Nonzero indicates special processing used by the pcp program.  The
 412    special effects of this mode are:
 413
 414      Inhibit all macro expansion, except those inside #if directives.
 415
 416      Process #define directives normally, and output their contents
 417      to the output file.
 418
 419      Output preconditions to pcp_outfile indicating all the relevant
 420      preconditions for use of this file in a later cpp run.
 421 */
 422 static FILE *pcp_outfile;
 423
 424 /* Nonzero means we are inside an IF during a -pcp run.  In this mode
 425    macro expansion is done, and preconditions are output for all macro
 426    uses requiring them.  */
 427 static int pcp_inside_if;
 428
 429 /* Nonzero means never to include precompiled files.
 430    This is 1 since there's no way now to make precompiled files,
 431    so it's not worth testing for them.  */
 432 static int no_precomp = 1;
 433
 434 /* Nonzero means give all the error messages the ANSI standard requires.  */
 435
 436 int pedantic;
 437
 438 /* Nonzero means try to make failure to fit ANSI C an error.  */
 439
 440 static int pedantic_errors;
 441
 442 /* Nonzero means don't print warning messages.  -w.  */
 443
 444 static int inhibit_warnings = 0;
 445
 446 /* Nonzero means warn if slash-star appears in a slash-star comment,
 447    or if newline-backslash appears in a slash-slash comment.  */
 448
 449 static int warn_comments;
 450
 451 /* Nonzero means warn if a macro argument is (or would be)
 452    stringified with -traditional.  */
 453
 454 static int warn_stringify;
 455
 456 /* Nonzero means warn if there are any trigraphs.  */
 457
 458 static int warn_trigraphs;
 459
 460 /* Nonzero means warn if #import is used.  */
 461
 462 static int warn_import = 1;
 463
 464 /* Nonzero means turn warnings into errors.  */
 465
 466 static int warnings_are_errors;
 467
 468 /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
 469
 470 int traditional;
 471
 472 /* Nonzero causes output not to be done,
 473    but directives such as #define that have side effects
 474    are still obeyed.  */
 475
 476 static int no_output;
 477
 478 /* Nonzero means this file was included with a -imacros or -include
 479    command line and should not be recorded as an include file.  */
 480
 481 static int no_record_file;
 482
 483 /* Nonzero means that we have finished processing the command line options.
 484    This flag is used to decide whether or not to issue certain errors
 485    and/or warnings.  */
 486
 487 static int done_initializing = 0;
 488
 489 /* Line where a newline was first seen in a string constant.  */
 490
 491 static int multiline_string_line = 0;
 492 \f
 493 /* I/O buffer structure.
 494    The `fname' field is nonzero for source files and #include files
 495    and for the dummy text used for -D and -U.
 496    It is zero for rescanning results of macro expansion
 497    and for expanding macro arguments.  */
 498 #define INPUT_STACK_MAX 400
 499 static struct file_buf {
 500   char *fname;
 501   /* Filename specified with #line directive.  */
 502   char *nominal_fname;
 503   /* Include file description.  */
 504   struct include_file *inc;
 505   /* Record where in the search path this file was found.
 506      For #include_next.  */
 507   struct file_name_list *dir;
 508   int lineno;
 509   int length;
 510   U_CHAR *buf;
 511   U_CHAR *bufp;
 512   /* Macro that this level is the expansion of.
 513      Included so that we can reenable the macro
 514      at the end of this level.  */
 515   struct hashnode *macro;
 516   /* Value of if_stack at start of this file.
 517      Used to prohibit unmatched #endif (etc) in an include file.  */
 518   struct if_stack *if_stack;
 519   /* Object to be freed at end of input at this level.  */
 520   U_CHAR *free_ptr;
 521   /* True if this is a header file included using <FILENAME>.  */
 522   char system_header_p;
 523 } instack[INPUT_STACK_MAX];
 524
 525 static int last_error_tick;        /* Incremented each time we print it.  */
 526 static int input_file_stack_tick;  /* Incremented when the status changes.  */
 527
 528 /* Current nesting level of input sources.
 529    `instack[indepth]' is the level currently being read.  */
 530 static int indepth = -1;
 531 #define CHECK_DEPTH(code) \
 532   if (indepth >= (INPUT_STACK_MAX - 1))                                 \
 533     {                                                                   \
 534       error_with_line (line_for_error (instack[indepth].lineno),        \
 535                        "macro or `#include' recursion too deep");       \
 536       code;                                                             \
 537     }
 538
 539 /* Current depth in #include directives that use <...>.  */
 540 static int system_include_depth = 0;
 541
 542 typedef struct file_buf FILE_BUF;
 543
 544 /* The output buffer.  Its LENGTH field is the amount of room allocated
 545    for the buffer, not the number of chars actually present.  To get
 546    that, subtract outbuf.buf from outbuf.bufp.  */
 547
 548 #define OUTBUF_SIZE 10  /* initial size of output buffer */
 549 static FILE_BUF outbuf;
 550
 551 /* Grow output buffer OBUF points at
 552    so it can hold at least NEEDED more chars.  */
 553
 554 #define check_expand(OBUF, NEEDED)  \
 555   (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED))   \
 556    ? grow_outbuf ((OBUF), (NEEDED)) : 0)
 557
 558 struct file_name_list
 559   {
 560     struct file_name_list *next;
 561     /* If the following is 1, it is a C-language system include
 562        directory.  */
 563     int c_system_include_path;
 564     /* Mapping of file names for this directory.  */
 565     struct file_name_map *name_map;
 566     /* Non-zero if name_map is valid.  */
 567     int got_name_map;
 568     /* The include directory status.  */
 569     struct stat st;
 570     /* The include prefix: "" denotes the working directory,
 571        otherwise fname must end in '/'.
 572        The actual size is dynamically allocated.  */
 573     char fname[1];
 574   };
 575
 576 /* #include "file" looks in source file dir, then stack.  */
 577 /* #include <file> just looks in the stack.  */
 578 /* -I directories are added to the end, then the defaults are added.  */
 579 /* The */
 580 static struct default_include {
 581   char *fname;                  /* The name of the directory.  */
 582   int cplusplus;                /* Only look here if we're compiling C++.  */
 583   int cxx_aware;                /* Includes in this directory don't need to
 584                                    be wrapped in extern "C" when compiling
 585                                    C++.  */
 586 } include_defaults_array[]
 587 #ifdef INCLUDE_DEFAULTS
 588   = INCLUDE_DEFAULTS;
 589 #else
 590   = {
 591     /* Pick up GNU C++ specific include files.  */
 592     { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
 593     { OLD_GPLUSPLUS_INCLUDE_DIR, 1, 1 },
 594 #ifdef CROSS_COMPILE
 595     /* This is the dir for fixincludes.  Put it just before
 596        the files that we fix.  */
 597     { GCC_INCLUDE_DIR, 0, 0 },
 598     /* For cross-compilation, this dir name is generated
 599        automatically in Makefile.in.  */
 600     { CROSS_INCLUDE_DIR, 0, 0 },
 601 #ifdef TOOL_INCLUDE_DIR
 602     /* This is another place that the target system's headers might be.  */
 603     { TOOL_INCLUDE_DIR, 0, 0 },
 604 #endif
 605 #else /* not CROSS_COMPILE */
 606 #ifdef LOCAL_INCLUDE_DIR
 607     /* This should be /usr/local/include and should come before
 608        the fixincludes-fixed header files.  */
 609     { LOCAL_INCLUDE_DIR, 0, 1 },
 610 #endif
 611 #ifdef TOOL_INCLUDE_DIR
 612     /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
 613        Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h.  */
 614     { TOOL_INCLUDE_DIR, 0, 0 },
 615 #endif
 616     /* This is the dir for fixincludes.  Put it just before
 617        the files that we fix.  */
 618     { GCC_INCLUDE_DIR, 0, 0 },
 619     /* Some systems have an extra dir of include files.  */
 620 #ifdef SYSTEM_INCLUDE_DIR
 621     { SYSTEM_INCLUDE_DIR, 0, 0 },
 622 #endif
 623     { STANDARD_INCLUDE_DIR, 0, 0 },
 624 #endif /* not CROSS_COMPILE */
 625     { 0, 0, 0 }
 626     };
 627 #endif /* no INCLUDE_DEFAULTS */
 628
 629 /* The code looks at the defaults through this pointer, rather than through
 630    the constant structure above.  This pointer gets changed if an environment
 631    variable specifies other defaults.  */
 632 static struct default_include *include_defaults = include_defaults_array;
 633
 634 static struct file_name_list *include = 0;      /* First dir to search */
 635         /* First dir to search for <file> */
 636 /* This is the first element to use for #include <...>.
 637    If it is 0, use the entire chain for such includes.  */
 638 static struct file_name_list *first_bracket_include = 0;
 639 /* This is the first element in the chain that corresponds to
 640    a directory of system header files.  */
 641 static struct file_name_list *first_system_include = 0;
 642 static struct file_name_list *last_include = 0; /* Last in chain */
 643
 644 /* Chain of include directories to put at the end of the other chain.  */
 645 static struct file_name_list *after_include = 0;
 646 static struct file_name_list *last_after_include = 0;   /* Last in chain */
 647
 648 /* Chain to put at the start of the system include files.  */
 649 static struct file_name_list *before_system = 0;
 650 static struct file_name_list *last_before_system = 0;   /* Last in chain */
 651
 652 /* Directory prefix that should replace `/usr' in the standard
 653    include file directories.  */
 654 static char *include_prefix;
 655
 656 /* Maintain and search list of included files.  */
 657
 658 struct include_file {
 659   struct include_file *next; /* for include_hashtab */
 660   struct include_file *next_ino; /* for include_ino_hashtab */
 661   char *fname;
 662   /* If the following is the empty string, it means #pragma once
 663      was seen in this include file, or #import was applied to the file.
 664      Otherwise, if it is nonzero, it is a macro name.
 665      Don't include the file again if that macro is defined.  */
 666   U_CHAR *control_macro;
 667   /* Nonzero if the dependency on this include file has been output.  */
 668   int deps_output;
 669   struct stat st;
 670 };
 671
 672 /* Hash tables of files already included with #include or #import.
 673    include_hashtab is by full name; include_ino_hashtab is by inode number.  */
 674
 675 #define INCLUDE_HASHSIZE 61
 676 static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
 677 static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
 678
 679 /* Global list of strings read in from precompiled files.  This list
 680    is kept in the order the strings are read in, with new strings being
 681    added at the end through stringlist_tailp.  We use this list to output
 682    the strings at the end of the run.
 683 */
 684 static STRINGDEF *stringlist;
 685 static STRINGDEF **stringlist_tailp = &stringlist;
 686
 687
 688 /* Structure returned by create_definition */
 689 typedef struct macrodef MACRODEF;
 690 struct macrodef
 691 {
 692   struct definition *defn;
 693   U_CHAR *symnam;
 694   int symlen;
 695 };
 696 \f
 697 enum sharp_token_type {
 698   NO_SHARP_TOKEN = 0,           /* token not present */
 699
 700   SHARP_TOKEN = '#',            /* token spelled with # only */
 701   WHITE_SHARP_TOKEN,            /* token spelled with # and white space */
 702
 703   PERCENT_COLON_TOKEN = '%',    /* token spelled with %: only */
 704   WHITE_PERCENT_COLON_TOKEN     /* token spelled with %: and white space */
 705 };
 706
 707 /* Structure allocated for every #define.  For a simple replacement
 708    such as
 709         #define foo bar ,
 710    nargs = -1, the `pattern' list is null, and the expansion is just
 711    the replacement text.  Nargs = 0 means a functionlike macro with no args,
 712    e.g.,
 713        #define getchar() getc (stdin) .
 714    When there are args, the expansion is the replacement text with the
 715    args squashed out, and the reflist is a list describing how to
 716    build the output from the input: e.g., "3 chars, then the 1st arg,
 717    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
 718    The chars here come from the expansion.  Whatever is left of the
 719    expansion after the last arg-occurrence is copied after that arg.
 720    Note that the reflist can be arbitrarily long---
 721    its length depends on the number of times the arguments appear in
 722    the replacement text, not how many args there are.  Example:
 723    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
 724    pattern list
 725      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
 726    where (x, y) means (nchars, argno).  */
 727
 728 typedef struct definition DEFINITION;
 729 struct definition {
 730   int nargs;
 731   int length;                   /* length of expansion string */
 732   int predefined;               /* True if the macro was builtin or */
 733                                 /* came from the command line */
 734   U_CHAR *expansion;
 735   int line;                     /* Line number of definition */
 736   char *file;                   /* File of definition */
 737   char rest_args;               /* Nonzero if last arg. absorbs the rest */
 738   struct reflist {
 739     struct reflist *next;
 740
 741     enum sharp_token_type stringify;    /* set if a # operator before arg */
 742     enum sharp_token_type raw_before;   /* set if a ## operator before arg */
 743     enum sharp_token_type raw_after;    /* set if a ## operator after arg */
 744
 745     char rest_args;             /* Nonzero if this arg. absorbs the rest */
 746     int nchars;                 /* Number of literal chars to copy before
 747                                    this arg occurrence.  */
 748     int argno;                  /* Number of arg to substitute (origin-0) */
 749   } *pattern;
 750   union {
 751     /* Names of macro args, concatenated in reverse order
 752        with comma-space between them.
 753        The only use of this is that we warn on redefinition
 754        if this differs between the old and new definitions.  */
 755     U_CHAR *argnames;
 756   } args;
 757 };
 758
 759 /* different kinds of things that can appear in the value field
 760    of a hash node.  Actually, this may be useless now.  */
 761 union hashval {
 762   char *cpval;
 763   DEFINITION *defn;
 764   KEYDEF *keydef;
 765 };
 766
 767 /*
 768  * special extension string that can be added to the last macro argument to
 769  * allow it to absorb the "rest" of the arguments when expanded.  Ex:
 770  *              #define wow(a, b...)            process (b, a, b)
 771  *              { wow (1, 2, 3); }      ->      { process (2, 3, 1, 2, 3); }
 772  *              { wow (one, two); }     ->      { process (two, one, two); }
 773  * if this "rest_arg" is used with the concat token '##' and if it is not
 774  * supplied then the token attached to with ## will not be outputted.  Ex:
 775  *              #define wow (a, b...)           process (b ## , a, ## b)
 776  *              { wow (1, 2); }         ->      { process (2, 1, 2); }
 777  *              { wow (one); }          ->      { process (one); {
 778  */
 779 static char rest_extension[] = "...";
 780 #define REST_EXTENSION_LENGTH   (sizeof (rest_extension) - 1)
 781
 782 /* The structure of a node in the hash table.  The hash table
 783    has entries for all tokens defined by #define directives (type T_MACRO),
 784    plus some special tokens like __LINE__ (these each have their own
 785    type, and the appropriate code is run when that type of node is seen.
 786    It does not contain control words like "#define", which are recognized
 787    by a separate piece of code.  */
 788
 789 /* different flavors of hash nodes --- also used in keyword table */
 790 enum node_type {
 791  T_DEFINE = 1,  /* the `#define' keyword */
 792  T_INCLUDE,     /* the `#include' keyword */
 793  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 794  T_IMPORT,      /* the `#import' keyword */
 795  T_IFDEF,       /* the `#ifdef' keyword */
 796  T_IFNDEF,      /* the `#ifndef' keyword */
 797  T_IF,          /* the `#if' keyword */
 798  T_ELSE,        /* `#else' */
 799  T_PRAGMA,      /* `#pragma' */
 800  T_ELIF,        /* `#elif' */
 801  T_UNDEF,       /* `#undef' */
 802  T_LINE,        /* `#line' */
 803  T_ERROR,       /* `#error' */
 804  T_WARNING,     /* `#warning' */
 805  T_ENDIF,       /* `#endif' */
 806  T_SCCS,        /* `#sccs', used on system V.  */
 807  T_IDENT,       /* `#ident', used on system V.  */
 808  T_ASSERT,      /* `#assert', taken from system V.  */
 809  T_UNASSERT,    /* `#unassert', taken from system V.  */
 810  T_SPECLINE,    /* special symbol `__LINE__' */
 811  T_DATE,        /* `__DATE__' */
 812  T_FILE,        /* `__FILE__' */
 813  T_BASE_FILE,   /* `__BASE_FILE__' */
 814  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 815  T_VERSION,     /* `__VERSION__' */
 816  T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
 817  T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
 818  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
 819  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
 820  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
 821  T_IMMEDIATE_PREFIX_TYPE,  /* `__IMMEDIATE_PREFIX__' */
 822  T_TIME,        /* `__TIME__' */
 823  T_CONST,       /* Constant value, used by `__STDC__' */
 824  T_MACRO,       /* macro defined by `#define' */
 825  T_DISABLED,    /* macro temporarily turned off for rescan */
 826  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
 827  T_PCSTRING,    /* precompiled string (hashval is KEYDEF *) */
 828  T_UNUSED       /* Used for something not defined.  */
 829  };
 830
 831 struct hashnode {
 832   struct hashnode *next;        /* double links for easy deletion */
 833   struct hashnode *prev;
 834   struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
 835                                    chain is kept, in case the node is the head
 836                                    of the chain and gets deleted.  */
 837   enum node_type type;          /* type of special token */
 838   int length;                   /* length of token, for quick comparison */
 839   U_CHAR *name;                 /* the actual name */
 840   union hashval value;          /* pointer to expansion, or whatever */
 841 };
 842
 843 typedef struct hashnode HASHNODE;
 844
 845 /* Some definitions for the hash table.  The hash function MUST be
 846    computed as shown in hashf () below.  That is because the rescan
 847    loop computes the hash value `on the fly' for most tokens,
 848    in order to avoid the overhead of a lot of procedure calls to
 849    the hashf () function.  Hashf () only exists for the sake of
 850    politeness, for use when speed isn't so important.  */
 851
 852 #define HASHSIZE 1403
 853 static HASHNODE *hashtab[HASHSIZE];
 854 #define HASHSTEP(old, c) ((old << 2) + c)
 855 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
 856
 857 /* Symbols to predefine.  */
 858
 859 #ifdef CPP_PREDEFINES
 860 static char *predefs = CPP_PREDEFINES;
 861 #else
 862 static char *predefs = "";
 863 #endif
 864 \f
 865 /* We let tm.h override the types used here, to handle trivial differences
 866    such as the choice of unsigned int or long unsigned int for size_t.
 867    When machines start needing nontrivial differences in the size type,
 868    it would be best to do something here to figure out automatically
 869    from other information what type to use.  */
 870
 871 /* The string value for __SIZE_TYPE__.  */
 872
 873 #ifndef SIZE_TYPE
 874 #define SIZE_TYPE "long unsigned int"
 875 #endif
 876
 877 /* The string value for __PTRDIFF_TYPE__.  */
 878
 879 #ifndef PTRDIFF_TYPE
 880 #define PTRDIFF_TYPE "long int"
 881 #endif
 882
 883 /* The string value for __WCHAR_TYPE__.  */
 884
 885 #ifndef WCHAR_TYPE
 886 #define WCHAR_TYPE "int"
 887 #endif
 888 char * wchar_type = WCHAR_TYPE;
 889 #undef WCHAR_TYPE
 890
 891 /* The string value for __USER_LABEL_PREFIX__ */
 892
 893 #ifndef USER_LABEL_PREFIX
 894 #define USER_LABEL_PREFIX ""
 895 #endif
 896
 897 /* The string value for __REGISTER_PREFIX__ */
 898
 899 #ifndef REGISTER_PREFIX
 900 #define REGISTER_PREFIX ""
 901 #endif
 902
 903 /* The string value for __IMMEDIATE_PREFIX__ */
 904
 905 #ifndef IMMEDIATE_PREFIX
 906 #define IMMEDIATE_PREFIX ""
 907 #endif
 908 \f
 909 /* In the definition of a #assert name, this structure forms
 910    a list of the individual values asserted.
 911    Each value is itself a list of "tokens".
 912    These are strings that are compared by name.  */
 913
 914 struct tokenlist_list {
 915   struct tokenlist_list *next;
 916   struct arglist *tokens;
 917 };
 918
 919 struct assertion_hashnode {
 920   struct assertion_hashnode *next;      /* double links for easy deletion */
 921   struct assertion_hashnode *prev;
 922   /* also, a back pointer to this node's hash
 923      chain is kept, in case the node is the head
 924      of the chain and gets deleted.  */
 925   struct assertion_hashnode **bucket_hdr;
 926   int length;                   /* length of token, for quick comparison */
 927   U_CHAR *name;                 /* the actual name */
 928   /* List of token-sequences.  */
 929   struct tokenlist_list *value;
 930 };
 931
 932 typedef struct assertion_hashnode ASSERTION_HASHNODE;
 933
 934 /* Some definitions for the hash table.  The hash function MUST be
 935    computed as shown in hashf below.  That is because the rescan
 936    loop computes the hash value `on the fly' for most tokens,
 937    in order to avoid the overhead of a lot of procedure calls to
 938    the hashf function.  hashf only exists for the sake of
 939    politeness, for use when speed isn't so important.  */
 940
 941 #define ASSERTION_HASHSIZE 37
 942 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
 943
 944 /* Nonzero means inhibit macroexpansion of what seem to be
 945    assertion tests, in rescan.  For #if.  */
 946 static int assertions_flag;
 947 \f
 948 /* `struct directive' defines one #-directive, including how to handle it.  */
 949
 950 #define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
 951
 952 struct directive {
 953   int length;                   /* Length of name */
 954   int (*func) DO_PROTO; /* Function to handle directive */
 955   char *name;                   /* Name of directive */
 956   enum node_type type;          /* Code which describes which directive.  */
 957   char angle_brackets;          /* Nonzero => <...> is special.  */
 958   char traditional_comments;    /* Nonzero: keep comments if -traditional.  */
 959   char pass_thru;               /* Copy directive to output:
 960                                    if 1, copy if dumping definitions;
 961                                    if 2, always copy, after preprocessing.  */
 962 };
 963
 964 /* These functions are declared to return int instead of void since they
 965    are going to be placed in the table and some old compilers have trouble with
 966    pointers to functions returning void.  */
 967
 968 static int do_assert DO_PROTO;
 969 static int do_define DO_PROTO;
 970 static int do_elif DO_PROTO;
 971 static int do_else DO_PROTO;
 972 static int do_endif DO_PROTO;
 973 static int do_error DO_PROTO;
 974 static int do_ident DO_PROTO;
 975 static int do_if DO_PROTO;
 976 static int do_include DO_PROTO;
 977 static int do_line DO_PROTO;
 978 static int do_pragma DO_PROTO;
 979 #ifdef SCCS_DIRECTIVE
 980 static int do_sccs DO_PROTO;
 981 #endif
 982 static int do_unassert DO_PROTO;
 983 static int do_undef DO_PROTO;
 984 static int do_warning DO_PROTO;
 985 static int do_xifdef DO_PROTO;
 986
 987 /* Here is the actual list of #-directives, most-often-used first.  */
 988
 989 static struct directive directive_table[] = {
 990   {  6, do_define, "define", T_DEFINE, 0, 1, 1},
 991   {  2, do_if, "if", T_IF},
 992   {  5, do_xifdef, "ifdef", T_IFDEF},
 993   {  6, do_xifdef, "ifndef", T_IFNDEF},
 994   {  5, do_endif, "endif", T_ENDIF},
 995   {  4, do_else, "else", T_ELSE},
 996   {  4, do_elif, "elif", T_ELIF},
 997   {  4, do_line, "line", T_LINE},
 998   {  7, do_include, "include", T_INCLUDE, 1},
 999   { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
1000   {  6, do_include, "import", T_IMPORT, 1},
1001   {  5, do_undef, "undef", T_UNDEF},
1002   {  5, do_error, "error", T_ERROR},
1003   {  7, do_warning, "warning", T_WARNING},
1004 #ifdef SCCS_DIRECTIVE
1005   {  4, do_sccs, "sccs", T_SCCS},
1006 #endif
1007   {  6, do_pragma, "pragma", T_PRAGMA, 0, 0, 2},
1008   {  5, do_ident, "ident", T_IDENT},
1009   {  6, do_assert, "assert", T_ASSERT},
1010   {  8, do_unassert, "unassert", T_UNASSERT},
1011   {  -1, 0, "", T_UNUSED},
1012 };
1013
1014 /* When a directive handler is called,
1015    this points to the # (or the : of the %:) that started the directive.  */
1016 U_CHAR *directive_start;
1017
1018 /* table to tell if char can be part of a C identifier.  */
1019 U_CHAR is_idchar[256];
1020 /* table to tell if char can be first char of a c identifier.  */
1021 U_CHAR is_idstart[256];
1022 /* table to tell if c is horizontal space.  */
1023 U_CHAR is_hor_space[256];
1024 /* table to tell if c is horizontal or vertical space.  */
1025 static U_CHAR is_space[256];
1026 /* names of some characters */
1027 static char *char_name[256];
1028
1029 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
1030 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
1031
1032 static int errors = 0;                  /* Error counter for exit code */
1033
1034 /* Name of output file, for error messages.  */
1035 static char *out_fname;
1036
1037
1038 /* Stack of conditionals currently in progress
1039    (including both successful and failing conditionals).  */
1040
1041 struct if_stack {
1042   struct if_stack *next;        /* for chaining to the next stack frame */
1043   char *fname;          /* copied from input when frame is made */
1044   int lineno;                   /* similarly */
1045   int if_succeeded;             /* true if a leg of this if-group
1046                                     has been passed through rescan */
1047   U_CHAR *control_macro;        /* For #ifndef at start of file,
1048                                    this is the macro name tested.  */
1049   enum node_type type;          /* type of last directive seen in this group */
1050 };
1051 typedef struct if_stack IF_STACK_FRAME;
1052 static IF_STACK_FRAME *if_stack = NULL;
1053
1054 /* Buffer of -M output.  */
1055 static char *deps_buffer;
1056
1057 /* Number of bytes allocated in above.  */
1058 static int deps_allocated_size;
1059
1060 /* Number of bytes used.  */
1061 static int deps_size;
1062
1063 /* Number of bytes since the last newline.  */
1064 static int deps_column;
1065
1066 /* Nonzero means -I- has been seen,
1067    so don't look for #include "foo" the source-file directory.  */
1068 static int ignore_srcdir;
1069 \f
1070 static int safe_read PROTO((int, char *, int));
1071 static void safe_write PROTO((int, char *, int));
1072
1073 int main PROTO((int, char **));
1074
1075 static void path_include PROTO((char *));
1076
1077 static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
1078
1079 static void trigraph_pcp PROTO((FILE_BUF *));
1080
1081 static void newline_fix PROTO((U_CHAR *));
1082 static void name_newline_fix PROTO((U_CHAR *));
1083
1084 static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
1085
1086 static void rescan PROTO((FILE_BUF *, int));
1087
1088 static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
1089
1090 static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
1091
1092 static struct tm *timestamp PROTO((void));
1093 static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
1094
1095 static int is_system_include PROTO((char *));
1096 static char *base_name PROTO((char *));
1097 static int absolute_filename PROTO((char *));
1098 static size_t simplify_filename PROTO((char *));
1099
1100 static char *read_filename_string PROTO((int, FILE *));
1101 static struct file_name_map *read_name_map PROTO((char *));
1102 static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
1103 static char *remap_include_file PROTO((char *, struct file_name_list *));
1104 static int lookup_ino_include PROTO((struct include_file *));
1105
1106 static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
1107 static void record_control_macro PROTO((struct include_file *, U_CHAR *));
1108
1109 static char *check_precompiled PROTO((int, struct stat *, char *, char **));
1110 static int check_preconditions PROTO((char *));
1111 static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
1112 static void pcstring_used PROTO((HASHNODE *));
1113 static void write_output PROTO((void));
1114 static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
1115
1116 static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
1117
1118 static int check_macro_name PROTO((U_CHAR *, char *));
1119 static int compare_defs PROTO((DEFINITION *, DEFINITION *));
1120 static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
1121
1122 static DEFINITION *collect_expansion  PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
1123
1124 int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
1125 static int compare_token_lists PROTO((struct arglist *, struct arglist *));
1126
1127 static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
1128 static void free_token_list PROTO((struct arglist *));
1129
1130 static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
1131 static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
1132 static void delete_assertion PROTO((ASSERTION_HASHNODE *));
1133
1134 static void do_once PROTO((void));
1135
1136 static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
1137 static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
1138 static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
1139 static void validate_else PROTO((U_CHAR *, U_CHAR *));
1140
1141 static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
1142 static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
1143 static char *quote_string PROTO((char *, char *));
1144 static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
1145
1146 /* Last arg to output_line_directive.  */
1147 enum file_change_code {same_file, enter_file, leave_file};
1148 static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
1149
1150 static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
1151
1152 struct argdata;
1153 static char *macarg PROTO((struct argdata *, int));
1154
1155 static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
1156
1157 static int discard_comments PROTO((U_CHAR *, int, int));
1158
1159 static int change_newlines PROTO((U_CHAR *, int));
1160
1161 char *my_strerror PROTO((int));
1162 void error PRINTF_PROTO_1((char *, ...));
1163 static void verror PROTO((char *, va_list));
1164 static void error_from_errno PROTO((char *));
1165 void warning PRINTF_PROTO_1((char *, ...));
1166 static void vwarning PROTO((char *, va_list));
1167 static void error_with_line PRINTF_PROTO_2((int, char *, ...));
1168 static void verror_with_line PROTO((int, char *, va_list));
1169 static void vwarning_with_line PROTO((int, char *, va_list));
1170 static void warning_with_line PRINTF_PROTO_2((int, char *, ...));
1171 void pedwarn PRINTF_PROTO_1((char *, ...));
1172 void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
1173 static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
1174
1175 static void print_containing_files PROTO((void));
1176
1177 static int line_for_error PROTO((int));
1178 static int grow_outbuf PROTO((FILE_BUF *, int));
1179
1180 static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
1181 HASHNODE *lookup PROTO((U_CHAR *, int, int));
1182 static void delete_macro PROTO((HASHNODE *));
1183 static int hashf PROTO((U_CHAR *, int, int));
1184
1185 static void dump_single_macro PROTO((HASHNODE *, FILE *));
1186 static void dump_all_macros PROTO((void));
1187 static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
1188 static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
1189
1190 static void initialize_char_syntax PROTO((void));
1191 static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
1192
1193 static void make_definition PROTO((char *, FILE_BUF *));
1194 static void make_undef PROTO((char *, FILE_BUF *));
1195
1196 static void make_assertion PROTO((char *, char *));
1197
1198 static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, char *, char *));
1199 static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
1200
1201 static void deps_output PROTO((char *, int));
1202
1203 static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
1204 void fancy_abort PROTO((void)) __attribute__ ((noreturn));
1205 static void perror_with_name PROTO((char *));
1206 static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
1207 static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
1208
1209 static void memory_full PROTO((void)) __attribute__ ((noreturn));
1210 GENERIC_PTR xmalloc PROTO((size_t));
1211 static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
1212 static GENERIC_PTR xcalloc PROTO((size_t, size_t));
1213 static char *savestring PROTO((char *));
1214 \f
1215 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
1216    retrying if necessary.  Return a negative value if an error occurs,
1217    otherwise return the actual number of bytes read,
1218    which must be LEN unless end-of-file was reached.  */
1219
1220 static int
1221 safe_read (desc, ptr, len)
1222      int desc;
1223      char *ptr;
1224      int len;
1225 {
1226   int left = len;
1227   while (left > 0) {
1228     int nchars = read (desc, ptr, left);
1229     if (nchars < 0)
1230       {
1231 #ifdef EINTR
1232         if (errno == EINTR)
1233           continue;
1234 #endif
1235         return nchars;
1236       }
1237     if (nchars == 0)
1238       break;
1239     ptr += nchars;
1240     left -= nchars;
1241   }
1242   return len - left;
1243 }
1244
1245 /* Write LEN bytes at PTR to descriptor DESC,
1246    retrying if necessary, and treating any real error as fatal.  */
1247
1248 static void
1249 safe_write (desc, ptr, len)
1250      int desc;
1251      char *ptr;
1252      int len;
1253 {
1254   while (len > 0) {
1255     int written = write (desc, ptr, len);
1256     if (written < 0)
1257       {
1258 #ifdef EINTR
1259         if (errno == EINTR)
1260           continue;
1261 #endif
1262         pfatal_with_name (out_fname);
1263       }
1264     ptr += written;
1265     len -= written;
1266   }
1267 }
1268 \f
1269 int
1270 main (argc, argv)
1271      int argc;
1272      char **argv;
1273 {
1274   struct stat st;
1275   char *in_fname;
1276   char *cp;
1277   int f, i;
1278   FILE_BUF *fp;
1279   char **pend_files = (char **) xmalloc (argc * sizeof (char *));
1280   char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
1281   char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
1282   char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
1283   char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
1284
1285   /* Record the option used with each element of pend_assertions.
1286      This is preparation for supporting more than one option for making
1287      an assertion.  */
1288   char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
1289   int inhibit_predefs = 0;
1290   int no_standard_includes = 0;
1291   int no_standard_cplusplus_includes = 0;
1292   int missing_newline = 0;
1293
1294   /* Non-0 means don't output the preprocessed program.  */
1295   int inhibit_output = 0;
1296   /* Non-0 means -v, so print the full set of include dirs.  */
1297   int verbose = 0;
1298
1299   /* File name which deps are being written to.
1300      This is 0 if deps are being written to stdout.  */
1301   char *deps_file = 0;
1302   /* Fopen file mode to open deps_file with.  */
1303   char *deps_mode = "a";
1304   /* Stream on which to print the dependency information.  */
1305   FILE *deps_stream = 0;
1306   /* Target-name to write with the dependency information.  */
1307   char *deps_target = 0;
1308
1309 #ifdef RLIMIT_STACK
1310   /* Get rid of any avoidable limit on stack size.  */
1311   {
1312     struct rlimit rlim;
1313
1314     /* Set the stack limit huge so that alloca (particularly stringtab
1315        in dbxread.c) does not fail.  */
1316     getrlimit (RLIMIT_STACK, &rlim);
1317     rlim.rlim_cur = rlim.rlim_max;
1318     setrlimit (RLIMIT_STACK, &rlim);
1319   }
1320 #endif /* RLIMIT_STACK defined */
1321
1322 #ifdef SIGPIPE
1323   signal (SIGPIPE, pipe_closed);
1324 #endif
1325
1326   progname = base_name (argv[0]);
1327
1328 #ifdef VMS
1329   {
1330     /* Remove extension from PROGNAME.  */
1331     char *p;
1332     char *s = progname = savestring (progname);
1333
1334     if ((p = rindex (s, ';')) != 0) *p = '\0';  /* strip version number */
1335     if ((p = rindex (s, '.')) != 0              /* strip type iff ".exe" */
1336         && (p[1] == 'e' || p[1] == 'E')
1337         && (p[2] == 'x' || p[2] == 'X')
1338         && (p[3] == 'e' || p[3] == 'E')
1339         && !p[4])
1340       *p = '\0';
1341   }
1342 #endif
1343
1344   in_fname = NULL;
1345   out_fname = NULL;
1346
1347   /* Initialize is_idchar.  */
1348   initialize_char_syntax ();
1349
1350   no_line_directives = 0;
1351   no_trigraphs = 1;
1352   dump_macros = dump_none;
1353   no_output = 0;
1354   cplusplus = 0;
1355   cplusplus_comments = 1;
1356
1357   bzero ((char *) pend_files, argc * sizeof (char *));
1358   bzero ((char *) pend_defs, argc * sizeof (char *));
1359   bzero ((char *) pend_undefs, argc * sizeof (char *));
1360   bzero ((char *) pend_assertions, argc * sizeof (char *));
1361   bzero ((char *) pend_includes, argc * sizeof (char *));
1362
1363   /* Process switches and find input file name.  */
1364
1365   for (i = 1; i < argc; i++) {
1366     if (argv[i][0] != '-') {
1367       if (out_fname != NULL)
1368         fatal ("Usage: %s [switches] input output", argv[0]);
1369       else if (in_fname != NULL)
1370         out_fname = argv[i];
1371       else
1372         in_fname = argv[i];
1373     } else {
1374       switch (argv[i][1]) {
1375
1376       case 'i':
1377         if (!strcmp (argv[i], "-include")) {
1378           if (i + 1 == argc)
1379             fatal ("Filename missing after `-include' option");
1380           else
1381             simplify_filename (pend_includes[i] = argv[++i]);
1382         }
1383         if (!strcmp (argv[i], "-imacros")) {
1384           if (i + 1 == argc)
1385             fatal ("Filename missing after `-imacros' option");
1386           else
1387             simplify_filename (pend_files[i] = argv[++i]);
1388         }
1389         if (!strcmp (argv[i], "-iprefix")) {
1390           if (i + 1 == argc)
1391             fatal ("Filename missing after `-iprefix' option");
1392           else
1393             include_prefix = argv[++i];
1394         }
1395         if (!strcmp (argv[i], "-ifoutput")) {
1396           output_conditionals = 1;
1397         }
1398         if (!strcmp (argv[i], "-isystem")) {
1399           struct file_name_list *dirtmp;
1400
1401           if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
1402             break;
1403           dirtmp->c_system_include_path = 1;
1404
1405           if (before_system == 0)
1406             before_system = dirtmp;
1407           else
1408             last_before_system->next = dirtmp;
1409           last_before_system = dirtmp; /* Tail follows the last one */
1410         }
1411         /* Add directory to end of path for includes,
1412            with the default prefix at the front of its name.  */
1413         if (!strcmp (argv[i], "-iwithprefix")) {
1414           struct file_name_list *dirtmp;
1415           char *prefix;
1416
1417           if (include_prefix != 0)
1418             prefix = include_prefix;
1419           else {
1420             prefix = savestring (GCC_INCLUDE_DIR);
1421             /* Remove the `include' from /usr/local/lib/gcc.../include.  */
1422             if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1423               prefix[strlen (prefix) - 7] = 0;
1424           }
1425
1426           if (! (dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i])))
1427             break;
1428
1429           if (after_include == 0)
1430             after_include = dirtmp;
1431           else
1432             last_after_include->next = dirtmp;
1433           last_after_include = dirtmp; /* Tail follows the last one */
1434         }
1435         /* Add directory to main path for includes,
1436            with the default prefix at the front of its name.  */
1437         if (!strcmp (argv[i], "-iwithprefixbefore")) {
1438           struct file_name_list *dirtmp;
1439           char *prefix;
1440
1441           if (include_prefix != 0)
1442             prefix = include_prefix;
1443           else {
1444             prefix = savestring (GCC_INCLUDE_DIR);
1445             /* Remove the `include' from /usr/local/lib/gcc.../include.  */
1446             if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
1447               prefix[strlen (prefix) - 7] = 0;
1448           }
1449
1450           dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i]);
1451           append_include_chain (dirtmp, dirtmp);
1452         }
1453         /* Add directory to end of path for includes.  */
1454         if (!strcmp (argv[i], "-idirafter")) {
1455           struct file_name_list *dirtmp;
1456
1457           if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
1458             break;
1459
1460           if (after_include == 0)
1461             after_include = dirtmp;
1462           else
1463             last_after_include->next = dirtmp;
1464           last_after_include = dirtmp; /* Tail follows the last one */
1465         }
1466         break;
1467
1468       case 'o':
1469         if (out_fname != NULL)
1470           fatal ("Output filename specified twice");
1471         if (i + 1 == argc)
1472           fatal ("Filename missing after -o option");
1473         out_fname = argv[++i];
1474         if (!strcmp (out_fname, "-"))
1475           out_fname = "";
1476         break;
1477
1478       case 'p':
1479         if (!strcmp (argv[i], "-pedantic"))
1480           pedantic = 1;
1481         else if (!strcmp (argv[i], "-pedantic-errors")) {
1482           pedantic = 1;
1483           pedantic_errors = 1;
1484         } else if (!strcmp (argv[i], "-pcp")) {
1485           char *pcp_fname;
1486           if (i + 1 == argc)
1487             fatal ("Filename missing after -pcp option");
1488           pcp_fname = argv[++i];
1489           pcp_outfile =
1490             ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
1491              ? fopen (pcp_fname, "w")
1492              : stdout);
1493           if (pcp_outfile == 0)
1494             pfatal_with_name (pcp_fname);
1495           no_precomp = 1;
1496         }
1497         break;
1498
1499       case 't':
1500         if (!strcmp (argv[i], "-traditional")) {
1501           traditional = 1;
1502           cplusplus_comments = 0;
1503         } else if (!strcmp (argv[i], "-trigraphs")) {
1504           no_trigraphs = 0;
1505         }
1506         break;
1507
1508       case 'l':
1509         if (! strcmp (argv[i], "-lang-c"))
1510           cplusplus = 0, cplusplus_comments = 1, objc = 0;
1511         if (! strcmp (argv[i], "-lang-c89"))
1512           cplusplus = 0, cplusplus_comments = 0, objc = 0;
1513         if (! strcmp (argv[i], "-lang-c++"))
1514           cplusplus = 1, cplusplus_comments = 1, objc = 0;
1515         if (! strcmp (argv[i], "-lang-objc"))
1516           objc = 1, cplusplus = 0, cplusplus_comments = 1;
1517         if (! strcmp (argv[i], "-lang-objc++"))
1518           objc = 1, cplusplus = 1, cplusplus_comments = 1;
1519         if (! strcmp (argv[i], "-lang-asm"))
1520           lang_asm = 1;
1521         if (! strcmp (argv[i], "-lint"))
1522           for_lint = 1;
1523         break;
1524
1525       case '+':
1526         cplusplus = 1, cplusplus_comments = 1;
1527         break;
1528
1529       case 'w':
1530         inhibit_warnings = 1;
1531         break;
1532
1533       case 'W':
1534         if (!strcmp (argv[i], "-Wtrigraphs"))
1535           warn_trigraphs = 1;
1536         else if (!strcmp (argv[i], "-Wno-trigraphs"))
1537           warn_trigraphs = 0;
1538         else if (!strcmp (argv[i], "-Wcomment"))
1539           warn_comments = 1;
1540         else if (!strcmp (argv[i], "-Wno-comment"))
1541           warn_comments = 0;
1542         else if (!strcmp (argv[i], "-Wcomments"))
1543           warn_comments = 1;
1544         else if (!strcmp (argv[i], "-Wno-comments"))
1545           warn_comments = 0;
1546         else if (!strcmp (argv[i], "-Wtraditional"))
1547           warn_stringify = 1;
1548         else if (!strcmp (argv[i], "-Wno-traditional"))
1549           warn_stringify = 0;
1550         else if (!strcmp (argv[i], "-Wimport"))
1551           warn_import = 1;
1552         else if (!strcmp (argv[i], "-Wno-import"))
1553           warn_import = 0;
1554         else if (!strcmp (argv[i], "-Werror"))
1555           warnings_are_errors = 1;
1556         else if (!strcmp (argv[i], "-Wno-error"))
1557           warnings_are_errors = 0;
1558         else if (!strcmp (argv[i], "-Wall"))
1559           {
1560             warn_trigraphs = 1;
1561             warn_comments = 1;
1562           }
1563         break;
1564
1565       case 'M':
1566         /* The style of the choices here is a bit mixed.
1567            The chosen scheme is a hybrid of keeping all options in one string
1568            and specifying each option in a separate argument:
1569            -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
1570            -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
1571            -M[M][G][D file].  This is awkward to handle in specs, and is not
1572            as extensible.  */
1573         /* ??? -MG must be specified in addition to one of -M or -MM.
1574            This can be relaxed in the future without breaking anything.
1575            The converse isn't true.  */
1576
1577         /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
1578         if (!strcmp (argv[i], "-MG"))
1579           {
1580             print_deps_missing_files = 1;
1581             break;
1582           }
1583         if (!strcmp (argv[i], "-M"))
1584           print_deps = 2;
1585         else if (!strcmp (argv[i], "-MM"))
1586           print_deps = 1;
1587         else if (!strcmp (argv[i], "-MD"))
1588           print_deps = 2;
1589         else if (!strcmp (argv[i], "-MMD"))
1590           print_deps = 1;
1591         /* For -MD and -MMD options, write deps on file named by next arg.  */
1592         if (!strcmp (argv[i], "-MD")
1593             || !strcmp (argv[i], "-MMD")) {
1594           if (i + 1 == argc)
1595             fatal ("Filename missing after %s option", argv[i]);
1596           i++;
1597           deps_file = argv[i];
1598           deps_mode = "w";
1599         } else {
1600           /* For -M and -MM, write deps on standard output
1601              and suppress the usual output.  */
1602           deps_stream = stdout;
1603           inhibit_output = 1;
1604         }
1605         break;
1606
1607       case 'd':
1608         {
1609           char *p = argv[i] + 2;
1610           char c;
1611           while ((c = *p++)) {
1612             /* Arg to -d specifies what parts of macros to dump */
1613             switch (c) {
1614             case 'M':
1615               dump_macros = dump_only;
1616               no_output = 1;
1617               break;
1618             case 'N':
1619               dump_macros = dump_names;
1620               break;
1621             case 'D':
1622               dump_macros = dump_definitions;
1623               break;
1624             }
1625           }
1626         }
1627         break;
1628
1629       case 'g':
1630         if (argv[i][2] == '3')
1631           debug_output = 1;
1632         break;
1633
1634       case 'v':
1635         fprintf (stderr, "GNU CPP version %s", version_string);
1636 #ifdef TARGET_VERSION
1637         TARGET_VERSION;
1638 #endif
1639         fprintf (stderr, "\n");
1640         verbose = 1;
1641         break;
1642
1643       case 'H':
1644         print_include_names = 1;
1645         break;
1646
1647       case 'D':
1648         if (argv[i][2] != 0)
1649           pend_defs[i] = argv[i] + 2;
1650         else if (i + 1 == argc)
1651           fatal ("Macro name missing after -D option");
1652         else
1653           i++, pend_defs[i] = argv[i];
1654         break;
1655
1656       case 'A':
1657         {
1658           char *p;
1659
1660           if (argv[i][2] != 0)
1661             p = argv[i] + 2;
1662           else if (i + 1 == argc)
1663             fatal ("Assertion missing after -A option");
1664           else
1665             p = argv[++i];
1666
1667           if (!strcmp (p, "-")) {
1668             /* -A- eliminates all predefined macros and assertions.
1669                Let's include also any that were specified earlier
1670                on the command line.  That way we can get rid of any
1671                that were passed automatically in from GCC.  */
1672             int j;
1673             inhibit_predefs = 1;
1674             for (j = 0; j < i; j++)
1675               pend_defs[j] = pend_assertions[j] = 0;
1676           } else {
1677             pend_assertions[i] = p;
1678             pend_assertion_options[i] = "-A";
1679           }
1680         }
1681         break;
1682
1683       case 'U':         /* JF #undef something */
1684         if (argv[i][2] != 0)
1685           pend_undefs[i] = argv[i] + 2;
1686         else if (i + 1 == argc)
1687           fatal ("Macro name missing after -U option");
1688         else
1689           pend_undefs[i] = argv[i+1], i++;
1690         break;
1691
1692       case 'C':
1693         put_out_comments = 1;
1694         break;
1695
1696       case 'E':                 /* -E comes from cc -E; ignore it.  */
1697         break;
1698
1699       case 'P':
1700         no_line_directives = 1;
1701         break;
1702
1703       case '$':                 /* Don't include $ in identifiers.  */
1704         is_idchar['$'] = is_idstart['$'] = 0;
1705         break;
1706
1707       case 'I':                 /* Add directory to path for includes.  */
1708         {
1709           struct file_name_list *dirtmp;
1710
1711           if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
1712             ignore_srcdir = 1;
1713             /* Don't use any preceding -I directories for #include <...>.  */
1714             first_bracket_include = 0;
1715           }
1716           else {
1717             dirtmp = new_include_prefix (last_include, "",
1718                                          argv[i][2] ? argv[i] + 2 : argv[++i]);
1719             append_include_chain (dirtmp, dirtmp);
1720           }
1721         }
1722         break;
1723
1724       case 'n':
1725         if (!strcmp (argv[i], "-nostdinc"))
1726           /* -nostdinc causes no default include directories.
1727              You must specify all include-file directories with -I.  */
1728           no_standard_includes = 1;
1729         else if (!strcmp (argv[i], "-nostdinc++"))
1730           /* -nostdinc++ causes no default C++-specific include directories. */
1731           no_standard_cplusplus_includes = 1;
1732         else if (!strcmp (argv[i], "-noprecomp"))
1733           no_precomp = 1;
1734         break;
1735
1736       case 'u':
1737         /* Sun compiler passes undocumented switch "-undef".
1738            Let's assume it means to inhibit the predefined symbols.  */
1739         inhibit_predefs = 1;
1740         break;
1741
1742       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
1743         if (in_fname == NULL) {
1744           in_fname = "";
1745           break;
1746         } else if (out_fname == NULL) {
1747           out_fname = "";
1748           break;
1749         }       /* else fall through into error */
1750
1751       default:
1752         fatal ("Invalid option `%s'", argv[i]);
1753       }
1754     }
1755   }
1756
1757   /* Add dirs from CPATH after dirs from -I.  */
1758   /* There seems to be confusion about what CPATH should do,
1759      so for the moment it is not documented.  */
1760   /* Some people say that CPATH should replace the standard include dirs,
1761      but that seems pointless: it comes before them, so it overrides them
1762      anyway.  */
1763   cp = getenv ("CPATH");
1764   if (cp && ! no_standard_includes)
1765     path_include (cp);
1766
1767   /* Initialize output buffer */
1768
1769   outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
1770   outbuf.bufp = outbuf.buf;
1771   outbuf.length = OUTBUF_SIZE;
1772
1773   /* Do partial setup of input buffer for the sake of generating
1774      early #line directives (when -g is in effect).  */
1775
1776   fp = &instack[++indepth];
1777   if (in_fname == NULL)
1778     in_fname = "";
1779   fp->nominal_fname = fp->fname = in_fname;
1780   fp->lineno = 0;
1781
1782   /* In C++, wchar_t is a distinct basic type, and we can expect
1783      __wchar_t to be defined by cc1plus.  */
1784   if (cplusplus)
1785     wchar_type = "__wchar_t";
1786
1787   /* Install __LINE__, etc.  Must follow initialize_char_syntax
1788      and option processing.  */
1789   initialize_builtins (fp, &outbuf);
1790
1791   /* Do standard #defines and assertions
1792      that identify system and machine type.  */
1793
1794   if (!inhibit_predefs) {
1795     char *p = (char *) alloca (strlen (predefs) + 1);
1796     strcpy (p, predefs);
1797     while (*p) {
1798       char *q;
1799       while (*p == ' ' || *p == '\t')
1800         p++;
1801       /* Handle -D options.  */
1802       if (p[0] == '-' && p[1] == 'D') {
1803         q = &p[2];
1804         while (*p && *p != ' ' && *p != '\t')
1805           p++;
1806         if (*p != 0)
1807           *p++= 0;
1808         if (debug_output)
1809           output_line_directive (fp, &outbuf, 0, same_file);
1810         make_definition (q, &outbuf);
1811         while (*p == ' ' || *p == '\t')
1812           p++;
1813       } else if (p[0] == '-' && p[1] == 'A') {
1814         /* Handle -A options (assertions).  */
1815         char *assertion;
1816         char *past_name;
1817         char *value;
1818         char *past_value;
1819         char *termination;
1820         int save_char;
1821
1822         assertion = &p[2];
1823         past_name = assertion;
1824         /* Locate end of name.  */
1825         while (*past_name && *past_name != ' '
1826                && *past_name != '\t' && *past_name != '(')
1827           past_name++;
1828         /* Locate `(' at start of value.  */
1829         value = past_name;
1830         while (*value && (*value == ' ' || *value == '\t'))
1831           value++;
1832         if (*value++ != '(')
1833           abort ();
1834         while (*value && (*value == ' ' || *value == '\t'))
1835           value++;
1836         past_value = value;
1837         /* Locate end of value.  */
1838         while (*past_value && *past_value != ' '
1839                && *past_value != '\t' && *past_value != ')')
1840           past_value++;
1841         termination = past_value;
1842         while (*termination && (*termination == ' ' || *termination == '\t'))
1843           termination++;
1844         if (*termination++ != ')')
1845           abort ();
1846         if (*termination && *termination != ' ' && *termination != '\t')
1847           abort ();
1848         /* Temporarily null-terminate the value.  */
1849         save_char = *termination;
1850         *termination = '\0';
1851         /* Install the assertion.  */
1852         make_assertion ("-A", assertion);
1853         *termination = (char) save_char;
1854         p = termination;
1855         while (*p == ' ' || *p == '\t')
1856           p++;
1857       } else {
1858         abort ();
1859       }
1860     }
1861   }
1862
1863   /* Now handle the command line options.  */
1864
1865   /* Do -U's, -D's and -A's in the order they were seen.  */
1866   for (i = 1; i < argc; i++) {
1867     if (pend_undefs[i]) {
1868       if (debug_output)
1869         output_line_directive (fp, &outbuf, 0, same_file);
1870       make_undef (pend_undefs[i], &outbuf);
1871     }
1872     if (pend_defs[i]) {
1873       if (debug_output)
1874         output_line_directive (fp, &outbuf, 0, same_file);
1875       make_definition (pend_defs[i], &outbuf);
1876     }
1877     if (pend_assertions[i])
1878       make_assertion (pend_assertion_options[i], pend_assertions[i]);
1879   }
1880
1881   done_initializing = 1;
1882
1883   { /* Read the appropriate environment variable and if it exists
1884        replace include_defaults with the listed path.  */
1885     char *epath = 0;
1886     switch ((objc << 1) + cplusplus)
1887       {
1888       case 0:
1889         epath = getenv ("C_INCLUDE_PATH");
1890         break;
1891       case 1:
1892         epath = getenv ("CPLUS_INCLUDE_PATH");
1893         break;
1894       case 2:
1895         epath = getenv ("OBJC_INCLUDE_PATH");
1896         break;
1897       case 3:
1898         epath = getenv ("OBJCPLUS_INCLUDE_PATH");
1899         break;
1900       }
1901     /* If the environment var for this language is set,
1902        add to the default list of include directories.  */
1903     if (epath) {
1904       int num_dirs;
1905       char *startp, *endp;
1906
1907       for (num_dirs = 1, startp = epath; *startp; startp++)
1908         if (*startp == PATH_SEPARATOR)
1909           num_dirs++;
1910       include_defaults
1911         = (struct default_include *) xmalloc ((num_dirs
1912                                                * sizeof (struct default_include))
1913                                               + sizeof (include_defaults_array));
1914       startp = endp = epath;
1915       num_dirs = 0;
1916       while (1) {
1917         char c = *endp++;
1918         if (c == PATH_SEPARATOR || !c) {
1919           endp[-1] = 0;
1920           include_defaults[num_dirs].fname
1921             = startp == endp ? "." : savestring (startp);
1922           endp[-1] = c;
1923           include_defaults[num_dirs].cplusplus = cplusplus;
1924           include_defaults[num_dirs].cxx_aware = 1;
1925           num_dirs++;
1926           if (!c)
1927             break;
1928           startp = endp;
1929         }
1930       }
1931       /* Put the usual defaults back in at the end.  */
1932       bcopy ((char *) include_defaults_array,
1933              (char *) &include_defaults[num_dirs],
1934              sizeof (include_defaults_array));
1935     }
1936   }
1937
1938   append_include_chain (before_system, last_before_system);
1939   first_system_include = before_system;
1940
1941   /* Unless -fnostdinc,
1942      tack on the standard include file dirs to the specified list */
1943   if (!no_standard_includes) {
1944     struct default_include *p = include_defaults;
1945     char *specd_prefix = include_prefix;
1946     char *default_prefix = savestring (GCC_INCLUDE_DIR);
1947     int default_len = 0;
1948     /* Remove the `include' from /usr/local/lib/gcc.../include.  */
1949     if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
1950       default_len = strlen (default_prefix) - 7;
1951       default_prefix[default_len] = 0;
1952     }
1953     /* Search "translated" versions of GNU directories.
1954        These have /usr/local/lib/gcc... replaced by specd_prefix.  */
1955     if (specd_prefix != 0 && default_len != 0)
1956       for (p = include_defaults; p->fname; p++) {
1957         /* Some standard dirs are only for C++.  */
1958         if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1959           /* Does this dir start with the prefix?  */
1960           if (!strncmp (p->fname, default_prefix, default_len)) {
1961             /* Yes; change prefix and add to search list.  */
1962             struct file_name_list *new
1963               = new_include_prefix (NULL_PTR, specd_prefix,
1964                                     p->fname + default_len);
1965             if (new) {
1966               new->c_system_include_path = !p->cxx_aware;
1967               append_include_chain (new, new);
1968               if (first_system_include == 0)
1969                 first_system_include = new;
1970             }
1971           }
1972         }
1973       }
1974     /* Search ordinary names for GNU include directories.  */
1975     for (p = include_defaults; p->fname; p++) {
1976       /* Some standard dirs are only for C++.  */
1977       if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
1978         struct file_name_list *new
1979           = new_include_prefix (NULL_PTR, "", p->fname);
1980         if (new) {
1981           new->c_system_include_path = !p->cxx_aware;
1982           append_include_chain (new, new);
1983           if (first_system_include == 0)
1984             first_system_include = new;
1985         }
1986       }
1987     }
1988   }
1989
1990   /* Tack the after_include chain at the end of the include chain.  */
1991   append_include_chain (after_include, last_after_include);
1992   if (first_system_include == 0)
1993     first_system_include = after_include;
1994
1995   /* With -v, print the list of dirs to search.  */
1996   if (verbose) {
1997     struct file_name_list *p;
1998     fprintf (stderr, "#include \"...\" search starts here:\n");
1999     for (p = include; p; p = p->next) {
2000       if (p == first_bracket_include)
2001         fprintf (stderr, "#include <...> search starts here:\n");
2002       if (!p->fname[0])
2003         fprintf (stderr, " .\n");
2004       else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
2005         fprintf (stderr, " %s\n", p->fname);
2006       else
2007         /* Omit trailing '/'.  */
2008         fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, p->fname);
2009     }
2010     fprintf (stderr, "End of search list.\n");
2011   }
2012
2013   /* -MG doesn't select the form of output and must be specified with one of
2014      -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
2015      inhibit compilation.  */
2016   if (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
2017     fatal ("-MG must be specified with one of -M or -MM");
2018
2019   /* Either of two environment variables can specify output of deps.
2020      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
2021      where OUTPUT_FILE is the file to write deps info to
2022      and DEPS_TARGET is the target to mention in the deps.  */
2023
2024   if (print_deps == 0
2025       && (getenv ("SUNPRO_DEPENDENCIES") != 0
2026           || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
2027     char *spec = getenv ("DEPENDENCIES_OUTPUT");
2028     char *s;
2029     char *output_file;
2030
2031     if (spec == 0) {
2032       spec = getenv ("SUNPRO_DEPENDENCIES");
2033       print_deps = 2;
2034     }
2035     else
2036       print_deps = 1;
2037
2038     s = spec;
2039     /* Find the space before the DEPS_TARGET, if there is one.  */
2040     /* This should use index.  (mrs) */
2041     while (*s != 0 && *s != ' ') s++;
2042     if (*s != 0) {
2043       deps_target = s + 1;
2044       output_file = xmalloc (s - spec + 1);
2045       bcopy (spec, output_file, s - spec);
2046       output_file[s - spec] = 0;
2047     }
2048     else {
2049       deps_target = 0;
2050       output_file = spec;
2051     }
2052
2053     deps_file = output_file;
2054     deps_mode = "a";
2055   }
2056
2057   /* For -M, print the expected object file name
2058      as the target of this Make-rule.  */
2059   if (print_deps) {
2060     deps_allocated_size = 200;
2061     deps_buffer = xmalloc (deps_allocated_size);
2062     deps_buffer[0] = 0;
2063     deps_size = 0;
2064     deps_column = 0;
2065
2066     if (deps_target) {
2067       deps_output (deps_target, ':');
2068     } else if (*in_fname == 0) {
2069       deps_output ("-", ':');
2070     } else {
2071       char *p, *q;
2072       int len;
2073
2074       q = base_name (in_fname);
2075
2076       /* Copy remainder to mungable area.  */
2077       p = (char *) alloca (strlen(q) + 8);
2078       strcpy (p, q);
2079
2080       /* Output P, but remove known suffixes.  */
2081       len = strlen (p);
2082       q = p + len;
2083       if (len >= 2
2084           && p[len - 2] == '.'
2085           && index("cCsSm", p[len - 1]))
2086         q = p + (len - 2);
2087       else if (len >= 3
2088                && p[len - 3] == '.'
2089                && p[len - 2] == 'c'
2090                && p[len - 1] == 'c')
2091         q = p + (len - 3);
2092       else if (len >= 4
2093                && p[len - 4] == '.'
2094                && p[len - 3] == 'c'
2095                && p[len - 2] == 'x'
2096                && p[len - 1] == 'x')
2097         q = p + (len - 4);
2098       else if (len >= 4
2099                && p[len - 4] == '.'
2100                && p[len - 3] == 'c'
2101                && p[len - 2] == 'p'
2102                && p[len - 1] == 'p')
2103         q = p + (len - 4);
2104
2105       /* Supply our own suffix.  */
2106 #ifndef VMS
2107       strcpy (q, ".o");
2108 #else
2109       strcpy (q, ".obj");
2110 #endif
2111
2112       deps_output (p, ':');
2113       deps_output (in_fname, ' ');
2114     }
2115   }
2116
2117   /* Scan the -imacros files before the main input.
2118      Much like #including them, but with no_output set
2119      so that only their macro definitions matter.  */
2120
2121   no_output++; no_record_file++;
2122   for (i = 1; i < argc; i++)
2123     if (pend_files[i]) {
2124       struct include_file *inc;
2125       int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
2126       if (fd < 0) {
2127         perror_with_name (pend_files[i]);
2128         return FATAL_EXIT_CODE;
2129       }
2130       finclude (fd, inc, &outbuf, 0, NULL_PTR);
2131     }
2132   no_output--; no_record_file--;
2133
2134   /* Copy the entire contents of the main input file into
2135      the stacked input buffer previously allocated for it.  */
2136
2137   /* JF check for stdin */
2138   if (in_fname == NULL || *in_fname == 0) {
2139     in_fname = "";
2140     f = 0;
2141   } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
2142     goto perror;
2143
2144   if (fstat (f, &st) != 0)
2145     pfatal_with_name (in_fname);
2146   fp->nominal_fname = fp->fname = in_fname;
2147   fp->lineno = 1;
2148   fp->system_header_p = 0;
2149   /* JF all this is mine about reading pipes and ttys */
2150   if (! S_ISREG (st.st_mode)) {
2151     /* Read input from a file that is not a normal disk file.
2152        We cannot preallocate a buffer with the correct size,
2153        so we must read in the file a piece at the time and make it bigger.  */
2154     int size;
2155     int bsize;
2156     int cnt;
2157
2158     if (S_ISDIR (st.st_mode))
2159       fatal ("Input file `%s' is a directory", in_fname);
2160
2161     bsize = 2000;
2162     size = 0;
2163     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
2164     for (;;) {
2165       cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
2166       if (cnt < 0) goto perror; /* error! */
2167       size += cnt;
2168       if (size != bsize) break; /* End of file */
2169       bsize *= 2;
2170       fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
2171     }
2172     fp->length = size;
2173   } else {
2174     /* Read a file whose size we can determine in advance.
2175        For the sake of VMS, st.st_size is just an upper bound.  */
2176     fp->buf = (U_CHAR *) xmalloc (st.st_size + 2);
2177     fp->length = safe_read (f, (char *) fp->buf, st.st_size);
2178     if (fp->length < 0) goto perror;
2179   }
2180   fp->bufp = fp->buf;
2181   fp->if_stack = if_stack;
2182
2183   /* Make sure data ends with a newline.  And put a null after it.  */
2184
2185   if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
2186       /* Backslash-newline at end is not good enough.  */
2187       || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
2188     fp->buf[fp->length++] = '\n';
2189     missing_newline = 1;
2190   }
2191   fp->buf[fp->length] = '\0';
2192
2193   /* Unless inhibited, convert trigraphs in the input.  */
2194
2195   if (!no_trigraphs)
2196     trigraph_pcp (fp);
2197
2198   /* Now that we know the input file is valid, open the output.  */
2199
2200   if (!out_fname || !strcmp (out_fname, ""))
2201     out_fname = "stdout";
2202   else if (! freopen (out_fname, "w", stdout))
2203     pfatal_with_name (out_fname);
2204
2205   output_line_directive (fp, &outbuf, 0, same_file);
2206
2207   /* Scan the -include files before the main input.  */
2208
2209   no_record_file++;
2210   for (i = 1; i < argc; i++)
2211     if (pend_includes[i]) {
2212       struct include_file *inc;
2213       int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
2214       if (fd < 0) {
2215         perror_with_name (pend_includes[i]);
2216         return FATAL_EXIT_CODE;
2217       }
2218       finclude (fd, inc, &outbuf, 0, NULL_PTR);
2219     }
2220   no_record_file--;
2221
2222   /* Scan the input, processing macros and directives.  */
2223
2224   rescan (&outbuf, 0);
2225
2226   if (missing_newline)
2227     fp->lineno--;
2228
2229   if (pedantic && missing_newline)
2230     pedwarn ("file does not end in newline");
2231
2232   /* Now we have processed the entire input
2233      Write whichever kind of output has been requested.  */
2234
2235   if (dump_macros == dump_only)
2236     dump_all_macros ();
2237   else if (! inhibit_output) {
2238     write_output ();
2239   }
2240
2241   if (print_deps) {
2242     /* Don't actually write the deps file if compilation has failed.  */
2243     if (errors == 0) {
2244       if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
2245         pfatal_with_name (deps_file);
2246       fputs (deps_buffer, deps_stream);
2247       putc ('\n', deps_stream);
2248       if (deps_file) {
2249         if (ferror (deps_stream) || fclose (deps_stream) != 0)
2250           fatal ("I/O error on output");
2251       }
2252     }
2253   }
2254
2255   if (pcp_outfile && pcp_outfile != stdout
2256       && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
2257     fatal ("I/O error on `-pcp' output");
2258
2259   if (ferror (stdout) || fclose (stdout) != 0)
2260     fatal ("I/O error on output");
2261
2262   if (errors)
2263     exit (FATAL_EXIT_CODE);
2264   exit (SUCCESS_EXIT_CODE);
2265
2266  perror:
2267   pfatal_with_name (in_fname);
2268   return 0;
2269 }
2270 \f
2271 /* Given a colon-separated list of file names PATH,
2272    add all the names to the search path for include files.  */
2273
2274 static void
2275 path_include (path)
2276      char *path;
2277 {
2278   char *p;
2279
2280   p = path;
2281
2282   if (*p)
2283     while (1) {
2284       char *q = p;
2285       char c;
2286       struct file_name_list *dirtmp;
2287
2288       /* Find the end of this name.  */
2289       while ((c = *q++) != PATH_SEPARATOR && c)
2290         continue;
2291
2292       q[-1] = 0;
2293       dirtmp = new_include_prefix (last_include, "", p == q ? "." : p);
2294       q[-1] = c;
2295       append_include_chain (dirtmp, dirtmp);
2296
2297       /* Advance past this name.  */
2298       p = q;
2299       if (! c)
2300         break;
2301     }
2302 }
2303 \f
2304 /* Return the address of the first character in S that equals C.
2305    S is an array of length N, possibly containing '\0's, and followed by '\0'.
2306    Return 0 if there is no such character.  Assume that C itself is not '\0'.
2307    If we knew we could use memchr, we could just invoke memchr (S, C, N),
2308    but unfortunately memchr isn't autoconfigured yet.  */
2309
2310 static U_CHAR *
2311 index0 (s, c, n)
2312      U_CHAR *s;
2313      int c;
2314      size_t n;
2315 {
2316   char *p = (char *) s;
2317   for (;;) {
2318     char *q = index (p, c);
2319     if (q)
2320       return (U_CHAR *) q;
2321     else {
2322       size_t l = strlen (p);
2323       if (l == n)
2324         return 0;
2325       l++;
2326       p += l;
2327       n -= l;
2328     }
2329   }
2330 }
2331 \f
2332 /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
2333    before main CCCP processing.  Name `pcp' is also in honor of the
2334    drugs the trigraph designers must have been on.
2335
2336    Using an extra pass through the buffer takes a little extra time,
2337    but is infinitely less hairy than trying to handle trigraphs inside
2338    strings, etc. everywhere, and also makes sure that trigraphs are
2339    only translated in the top level of processing.  */
2340
2341 static void
2342 trigraph_pcp (buf)
2343      FILE_BUF *buf;
2344 {
2345   register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
2346   int len;
2347
2348   fptr = bptr = sptr = buf->buf;
2349   lptr = fptr + buf->length;
2350   while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
2351     if (*++sptr != '?')
2352       continue;
2353     switch (*++sptr) {
2354       case '=':
2355       c = '#';
2356       break;
2357     case '(':
2358       c = '[';
2359       break;
2360     case '/':
2361       c = '\\';
2362       break;
2363     case ')':
2364       c = ']';
2365       break;
2366     case '\'':
2367       c = '^';
2368       break;
2369     case '<':
2370       c = '{';
2371       break;
2372     case '!':
2373       c = '|';
2374       break;
2375     case '>':
2376       c = '}';
2377       break;
2378     case '-':
2379       c  = '~';
2380       break;
2381     case '?':
2382       sptr--;
2383       continue;
2384     default:
2385       continue;
2386     }
2387     len = sptr - fptr - 2;
2388
2389     /* BSD doc says bcopy () works right for overlapping strings.  In ANSI
2390        C, this will be memmove ().  */
2391     if (bptr != fptr && len > 0)
2392       bcopy ((char *) fptr, (char *) bptr, len);
2393
2394     bptr += len;
2395     *bptr++ = c;
2396     fptr = ++sptr;
2397   }
2398   len = buf->length - (fptr - buf->buf);
2399   if (bptr != fptr && len > 0)
2400     bcopy ((char *) fptr, (char *) bptr, len);
2401   buf->length -= fptr - bptr;
2402   buf->buf[buf->length] = '\0';
2403   if (warn_trigraphs && fptr != bptr)
2404     warning_with_line (0, "%lu trigraph(s) encountered",
2405                        (unsigned long) (fptr - bptr) / 2);
2406 }
2407 \f
2408 /* Move all backslash-newline pairs out of embarrassing places.
2409    Exchange all such pairs following BP
2410    with any potentially-embarrassing characters that follow them.
2411    Potentially-embarrassing characters are / and *
2412    (because a backslash-newline inside a comment delimiter
2413    would cause it not to be recognized).  */
2414
2415 static void
2416 newline_fix (bp)
2417      U_CHAR *bp;
2418 {
2419   register U_CHAR *p = bp;
2420
2421   /* First count the backslash-newline pairs here.  */
2422
2423   while (p[0] == '\\' && p[1] == '\n')
2424     p += 2;
2425
2426   /* What follows the backslash-newlines is not embarrassing.  */
2427
2428   if (*p != '/' && *p != '*')
2429     return;
2430
2431   /* Copy all potentially embarrassing characters
2432      that follow the backslash-newline pairs
2433      down to where the pairs originally started.  */
2434
2435   while (*p == '*' || *p == '/')
2436     *bp++ = *p++;
2437
2438   /* Now write the same number of pairs after the embarrassing chars.  */
2439   while (bp < p) {
2440     *bp++ = '\\';
2441     *bp++ = '\n';
2442   }
2443 }
2444
2445 /* Like newline_fix but for use within a directive-name.
2446    Move any backslash-newlines up past any following symbol constituents.  */
2447
2448 static void
2449 name_newline_fix (bp)
2450      U_CHAR *bp;
2451 {
2452   register U_CHAR *p = bp;
2453
2454   /* First count the backslash-newline pairs here.  */
2455   while (p[0] == '\\' && p[1] == '\n')
2456     p += 2;
2457
2458   /* What follows the backslash-newlines is not embarrassing.  */
2459
2460   if (!is_idchar[*p])
2461     return;
2462
2463   /* Copy all potentially embarrassing characters
2464      that follow the backslash-newline pairs
2465      down to where the pairs originally started.  */
2466
2467   while (is_idchar[*p])
2468     *bp++ = *p++;
2469
2470   /* Now write the same number of pairs after the embarrassing chars.  */
2471   while (bp < p) {
2472     *bp++ = '\\';
2473     *bp++ = '\n';
2474   }
2475 }
2476 \f
2477 /* Look for lint commands in comments.
2478
2479    When we come in here, ibp points into a comment.  Limit is as one expects.
2480    scan within the comment -- it should start, after lwsp, with a lint command.
2481    If so that command is returned as a (constant) string.
2482
2483    Upon return, any arg will be pointed to with argstart and will be
2484    arglen long.  Note that we don't parse that arg since it will just
2485    be printed out again.  */
2486
2487 static char *
2488 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
2489      register U_CHAR *ibp;
2490      register U_CHAR *limit;
2491      U_CHAR **argstart;         /* point to command arg */
2492      int *arglen, *cmdlen;      /* how long they are */
2493 {
2494   HOST_WIDE_INT linsize;
2495   register U_CHAR *numptr;      /* temp for arg parsing */
2496
2497   *arglen = 0;
2498
2499   SKIP_WHITE_SPACE (ibp);
2500
2501   if (ibp >= limit) return NULL;
2502
2503   linsize = limit - ibp;
2504
2505   /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
2506   if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
2507     *cmdlen = 10;
2508     return "NOTREACHED";
2509   }
2510   if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
2511     *cmdlen = 8;
2512     return "ARGSUSED";
2513   }
2514   if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
2515     *cmdlen = 11;
2516     return "LINTLIBRARY";
2517   }
2518   if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
2519     *cmdlen = 7;
2520     ibp += 7; linsize -= 7;
2521     if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
2522
2523     /* OK, read a number */
2524     for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
2525          numptr++);
2526     *arglen = numptr - *argstart;
2527     return "VARARGS";
2528   }
2529   return NULL;
2530 }
2531 \f
2532 /*
2533  * The main loop of the program.
2534  *
2535  * Read characters from the input stack, transferring them to the
2536  * output buffer OP.
2537  *
2538  * Macros are expanded and push levels on the input stack.
2539  * At the end of such a level it is popped off and we keep reading.
2540  * At the end of any other kind of level, we return.
2541  * #-directives are handled, except within macros.
2542  *
2543  * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
2544  * and insert them when appropriate.  This is set while scanning macro
2545  * arguments before substitution.  It is zero when scanning for final output.
2546  *   There are three types of Newline markers:
2547  *   * Newline -  follows a macro name that was not expanded
2548  *     because it appeared inside an expansion of the same macro.
2549  *     This marker prevents future expansion of that identifier.
2550  *     When the input is rescanned into the final output, these are deleted.
2551  *     These are also deleted by ## concatenation.
2552  *   * Newline Space (or Newline and any other whitespace character)
2553  *     stands for a place that tokens must be separated or whitespace
2554  *     is otherwise desirable, but where the ANSI standard specifies there
2555  *     is no whitespace.  This marker turns into a Space (or whichever other
2556  *     whitespace char appears in the marker) in the final output,
2557  *     but it turns into nothing in an argument that is stringified with #.
2558  *     Such stringified arguments are the only place where the ANSI standard
2559  *     specifies with precision that whitespace may not appear.
2560  *
2561  * During this function, IP->bufp is kept cached in IBP for speed of access.
2562  * Likewise, OP->bufp is kept in OBP.  Before calling a subroutine
2563  * IBP, IP and OBP must be copied back to memory.  IP and IBP are
2564  * copied back with the RECACHE macro.  OBP must be copied back from OP->bufp
2565  * explicitly, and before RECACHE, since RECACHE uses OBP.
2566  */
2567
2568 static void
2569 rescan (op, output_marks)
2570      FILE_BUF *op;
2571      int output_marks;
2572 {
2573   /* Character being scanned in main loop.  */
2574   register U_CHAR c;
2575
2576   /* Length of pending accumulated identifier.  */
2577   register int ident_length = 0;
2578
2579   /* Hash code of pending accumulated identifier.  */
2580   register int hash = 0;
2581
2582   /* Current input level (&instack[indepth]).  */
2583   FILE_BUF *ip;
2584
2585   /* Pointer for scanning input.  */
2586   register U_CHAR *ibp;
2587
2588   /* Pointer to end of input.  End of scan is controlled by LIMIT.  */
2589   register U_CHAR *limit;
2590
2591   /* Pointer for storing output.  */
2592   register U_CHAR *obp;
2593
2594   /* REDO_CHAR is nonzero if we are processing an identifier
2595      after backing up over the terminating character.
2596      Sometimes we process an identifier without backing up over
2597      the terminating character, if the terminating character
2598      is not special.  Backing up is done so that the terminating character
2599      will be dispatched on again once the identifier is dealt with.  */
2600   int redo_char = 0;
2601
2602   /* 1 if within an identifier inside of which a concatenation
2603      marker (Newline -) has been seen.  */
2604   int concatenated = 0;
2605
2606   /* While scanning a comment or a string constant,
2607      this records the line it started on, for error messages.  */
2608   int start_line;
2609
2610   /* Record position of last `real' newline.  */
2611   U_CHAR *beg_of_line;
2612
2613 /* Pop the innermost input stack level, assuming it is a macro expansion.  */
2614
2615 #define POPMACRO \
2616 do { ip->macro->type = T_MACRO;         \
2617      if (ip->free_ptr) free (ip->free_ptr);     \
2618      --indepth; } while (0)
2619
2620 /* Reload `rescan's local variables that describe the current
2621    level of the input stack.  */
2622
2623 #define RECACHE  \
2624 do { ip = &instack[indepth];            \
2625      ibp = ip->bufp;                    \
2626      limit = ip->buf + ip->length;      \
2627      op->bufp = obp;                    \
2628      check_expand (op, limit - ibp);    \
2629      beg_of_line = 0;                   \
2630      obp = op->bufp; } while (0)
2631
2632   if (no_output && instack[indepth].fname != 0)
2633     skip_if_group (&instack[indepth], 1, NULL);
2634
2635   obp = op->bufp;
2636   RECACHE;
2637
2638   beg_of_line = ibp;
2639
2640   /* Our caller must always put a null after the end of
2641      the input at each input stack level.  */
2642   if (*limit != 0)
2643     abort ();
2644
2645   while (1) {
2646     c = *ibp++;
2647     *obp++ = c;
2648
2649     switch (c) {
2650     case '\\':
2651       if (*ibp == '\n' && !ip->macro) {
2652         /* At the top level, always merge lines ending with backslash-newline,
2653            even in middle of identifier.  But do not merge lines in a macro,
2654            since backslash might be followed by a newline-space marker.  */
2655         ++ibp;
2656         ++ip->lineno;
2657         --obp;          /* remove backslash from obuf */
2658         break;
2659       }
2660       /* If ANSI, backslash is just another character outside a string.  */
2661       if (!traditional)
2662         goto randomchar;
2663       /* Otherwise, backslash suppresses specialness of following char,
2664          so copy it here to prevent the switch from seeing it.
2665          But first get any pending identifier processed.  */
2666       if (ident_length > 0)
2667         goto specialchar;
2668       if (ibp < limit)
2669         *obp++ = *ibp++;
2670       break;
2671
2672     case '%':
2673       if (ident_length || ip->macro || traditional)
2674         goto randomchar;
2675       while (*ibp == '\\' && ibp[1] == '\n') {
2676         ibp += 2;
2677         ++ip->lineno;
2678       }
2679       if (*ibp != ':')
2680         break;
2681       /* Treat this %: digraph as if it were #.  */
2682       /* Fall through.  */
2683
2684     case '#':
2685       if (assertions_flag) {
2686         if (ident_length)
2687           goto specialchar;
2688         /* Copy #foo (bar lose) without macro expansion.  */
2689         obp[-1] = '#';  /* In case it was '%'.  */
2690         SKIP_WHITE_SPACE (ibp);
2691         while (is_idchar[*ibp])
2692           *obp++ = *ibp++;
2693         SKIP_WHITE_SPACE (ibp);
2694         if (*ibp == '(') {
2695           ip->bufp = ibp;
2696           skip_paren_group (ip);
2697           bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
2698           obp += ip->bufp - ibp;
2699           ibp = ip->bufp;
2700         }
2701         break;
2702       }
2703
2704       /* If this is expanding a macro definition, don't recognize
2705          preprocessing directives.  */
2706       if (ip->macro != 0)
2707         goto randomchar;
2708       /* If this is expand_into_temp_buffer,
2709          don't recognize them either.  Warn about them
2710          only after an actual newline at this level,
2711          not at the beginning of the input level.  */
2712       if (! ip->fname) {
2713         if (ip->buf != beg_of_line)
2714           warning ("preprocessing directive not recognized within macro arg");
2715         goto randomchar;
2716       }
2717       if (ident_length)
2718         goto specialchar;
2719
2720
2721       /* # keyword: a # must be first nonblank char on the line */
2722       if (beg_of_line == 0)
2723         goto randomchar;
2724       {
2725         U_CHAR *bp;
2726
2727         /* Scan from start of line, skipping whitespace, comments
2728            and backslash-newlines, and see if we reach this #.
2729            If not, this # is not special.  */
2730         bp = beg_of_line;
2731         /* If -traditional, require # to be at beginning of line.  */
2732         if (!traditional) {
2733           while (1) {
2734             if (is_hor_space[*bp])
2735               bp++;
2736             else if (*bp == '\\' && bp[1] == '\n')
2737               bp += 2;
2738             else if (*bp == '/' && bp[1] == '*') {
2739               bp += 2;
2740               while (!(*bp == '*' && bp[1] == '/'))
2741                 bp++;
2742               bp += 2;
2743             }
2744             /* There is no point in trying to deal with C++ // comments here,
2745                because if there is one, then this # must be part of the
2746                comment and we would never reach here.  */
2747             else break;
2748           }
2749           if (c == '%') {
2750             if (bp[0] != '%')
2751               break;
2752             while (bp[1] == '\\' && bp[2] == '\n')
2753               bp += 2;
2754             if (bp + 1 != ibp)
2755               break;
2756             /* %: appears at start of line; skip past the ':' too.  */
2757             bp++;
2758             ibp++;
2759           }
2760         }
2761         if (bp + 1 != ibp)
2762           goto randomchar;
2763       }
2764
2765       /* This # can start a directive.  */
2766
2767       --obp;            /* Don't copy the '#' */
2768
2769       ip->bufp = ibp;
2770       op->bufp = obp;
2771       if (! handle_directive (ip, op)) {
2772 #ifdef USE_C_ALLOCA
2773         alloca (0);
2774 #endif
2775         /* Not a known directive: treat it as ordinary text.
2776            IP, OP, IBP, etc. have not been changed.  */
2777         if (no_output && instack[indepth].fname) {
2778           /* If not generating expanded output,
2779              what we do with ordinary text is skip it.
2780              Discard everything until next # directive.  */
2781           skip_if_group (&instack[indepth], 1, 0);
2782           RECACHE;
2783           beg_of_line = ibp;
2784           break;
2785         }
2786         *obp++ = '#';   /* Copy # (even if it was originally %:).  */
2787         /* Don't expand an identifier that could be a macro directive.
2788            (Section 3.8.3 of the ANSI C standard)                       */
2789         SKIP_WHITE_SPACE (ibp);
2790         if (is_idstart[*ibp])
2791           {
2792             *obp++ = *ibp++;
2793             while (is_idchar[*ibp])
2794               *obp++ = *ibp++;
2795           }
2796         goto randomchar;
2797       }
2798 #ifdef USE_C_ALLOCA
2799       alloca (0);
2800 #endif
2801       /* A # directive has been successfully processed.  */
2802       /* If not generating expanded output, ignore everything until
2803          next # directive.  */
2804       if (no_output && instack[indepth].fname)
2805         skip_if_group (&instack[indepth], 1, 0);
2806       obp = op->bufp;
2807       RECACHE;
2808       beg_of_line = ibp;
2809       break;
2810
2811     case '\"':                  /* skip quoted string */
2812     case '\'':
2813       /* A single quoted string is treated like a double -- some
2814          programs (e.g., troff) are perverse this way */
2815
2816       if (ident_length)
2817         goto specialchar;
2818
2819       start_line = ip->lineno;
2820
2821       /* Skip ahead to a matching quote.  */
2822
2823       while (1) {
2824         if (ibp >= limit) {
2825           if (ip->macro != 0) {
2826             /* try harder: this string crosses a macro expansion boundary.
2827                This can happen naturally if -traditional.
2828                Otherwise, only -D can make a macro with an unmatched quote.  */
2829             POPMACRO;
2830             RECACHE;
2831             continue;
2832           }
2833           if (!traditional) {
2834             error_with_line (line_for_error (start_line),
2835                              "unterminated string or character constant");
2836             error_with_line (multiline_string_line,
2837                              "possible real start of unterminated constant");
2838             multiline_string_line = 0;
2839           }
2840           break;
2841         }
2842         *obp++ = *ibp;
2843         switch (*ibp++) {
2844         case '\n':
2845           ++ip->lineno;
2846           ++op->lineno;
2847           /* Traditionally, end of line ends a string constant with no error.
2848              So exit the loop and record the new line.  */
2849           if (traditional) {
2850             beg_of_line = ibp;
2851             goto while2end;
2852           }
2853           if (c == '\'') {
2854             error_with_line (line_for_error (start_line),
2855                              "unterminated character constant");
2856             goto while2end;
2857           }
2858           if (multiline_string_line == 0) {
2859             if (pedantic)
2860               pedwarn_with_line (line_for_error (start_line),
2861                                  "string constant runs past end of line");
2862             multiline_string_line = ip->lineno - 1;
2863           }
2864           break;
2865
2866         case '\\':
2867           if (ibp >= limit)
2868             break;
2869           if (*ibp == '\n') {
2870             /* Backslash newline is replaced by nothing at all,
2871                but keep the line counts correct.  */
2872             --obp;
2873             ++ibp;
2874             ++ip->lineno;
2875           } else {
2876             /* ANSI stupidly requires that in \\ the second \
2877                is *not* prevented from combining with a newline.  */
2878             while (*ibp == '\\' && ibp[1] == '\n') {
2879               ibp += 2;
2880               ++ip->lineno;
2881             }
2882             *obp++ = *ibp++;
2883           }
2884           break;
2885
2886         case '\"':
2887         case '\'':
2888           if (ibp[-1] == c)
2889             goto while2end;
2890           break;
2891         }
2892       }
2893     while2end:
2894       break;
2895
2896     case '/':
2897       if (*ibp == '\\' && ibp[1] == '\n')
2898         newline_fix (ibp);
2899
2900       if (*ibp != '*'
2901           && !(cplusplus_comments && *ibp == '/'))
2902         goto randomchar;
2903       if (ip->macro != 0)
2904         goto randomchar;
2905       if (ident_length)
2906         goto specialchar;
2907
2908       if (*ibp == '/') {
2909         /* C++ style comment...  */
2910         start_line = ip->lineno;
2911
2912         /* Comments are equivalent to spaces.  */
2913         if (! put_out_comments)
2914           obp[-1] = ' ';
2915
2916         {
2917           U_CHAR *before_bp = ibp;
2918
2919           while (++ibp < limit) {
2920             if (*ibp == '\n') {
2921               if (ibp[-1] != '\\') {
2922                 if (put_out_comments) {
2923                   bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
2924                   obp += ibp - before_bp;
2925                 }
2926                 break;
2927               }
2928               if (warn_comments)
2929                 warning ("multiline `//' comment");
2930               ++ip->lineno;
2931               /* Copy the newline into the output buffer, in order to
2932                  avoid the pain of a #line every time a multiline comment
2933                  is seen.  */
2934               if (!put_out_comments)
2935                 *obp++ = '\n';
2936               ++op->lineno;
2937             }
2938           }
2939           break;
2940         }
2941       }
2942
2943       /* Ordinary C comment.  Skip it, optionally copying it to output.  */
2944
2945       start_line = ip->lineno;
2946
2947       ++ibp;                    /* Skip the star.  */
2948
2949       /* If this cpp is for lint, we peek inside the comments: */
2950       if (for_lint) {
2951         U_CHAR *argbp;
2952         int cmdlen, arglen;
2953         char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
2954
2955         if (lintcmd != NULL) {
2956           op->bufp = obp;
2957           check_expand (op, cmdlen + arglen + 14);
2958           obp = op->bufp;
2959           /* I believe it is always safe to emit this newline: */
2960           obp[-1] = '\n';
2961           bcopy ("#pragma lint ", (char *) obp, 13);
2962           obp += 13;
2963           bcopy (lintcmd, (char *) obp, cmdlen);
2964           obp += cmdlen;
2965
2966           if (arglen != 0) {
2967             *(obp++) = ' ';
2968             bcopy (argbp, (char *) obp, arglen);
2969             obp += arglen;
2970           }
2971
2972           /* OK, now bring us back to the state we were in before we entered
2973              this branch.  We need #line because the #pragma's newline always
2974              messes up the line count.  */
2975           op->bufp = obp;
2976           output_line_directive (ip, op, 0, same_file);
2977           check_expand (op, limit - ibp + 2);
2978           obp = op->bufp;
2979           *(obp++) = '/';
2980         }
2981       }
2982
2983       /* Comments are equivalent to spaces.
2984          Note that we already output the slash; we might not want it.
2985          For -traditional, a comment is equivalent to nothing.  */
2986       if (! put_out_comments) {
2987         if (traditional)
2988           obp--;
2989         else
2990           obp[-1] = ' ';
2991       }
2992       else
2993         *obp++ = '*';
2994
2995       {
2996         U_CHAR *before_bp = ibp;
2997
2998         for (;;) {
2999           switch (*ibp++) {
3000           case '*':
3001             if (ibp[-2] == '/' && warn_comments)
3002               warning ("`/*' within comment");
3003             if (*ibp == '\\' && ibp[1] == '\n')
3004               newline_fix (ibp);
3005             if (*ibp == '/')
3006               goto comment_end;
3007             break;
3008
3009           case '\n':
3010             ++ip->lineno;
3011             /* Copy the newline into the output buffer, in order to
3012                avoid the pain of a #line every time a multiline comment
3013                is seen.  */
3014             if (!put_out_comments)
3015               *obp++ = '\n';
3016             ++op->lineno;
3017             break;
3018
3019           case 0:
3020             if (limit < ibp) {
3021               error_with_line (line_for_error (start_line),
3022                                "unterminated comment");
3023               goto limit_reached;
3024             }
3025             break;
3026           }
3027         }
3028       comment_end:
3029
3030         ibp++;
3031         if (put_out_comments) {
3032           bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
3033           obp += ibp - before_bp;
3034         }
3035       }
3036       break;
3037
3038     case '$':
3039       if (! is_idchar['$'])
3040         goto randomchar;
3041       if (pedantic)
3042         pedwarn ("`$' in identifier");
3043       goto letter;
3044
3045     case '0': case '1': case '2': case '3': case '4':
3046     case '5': case '6': case '7': case '8': case '9':
3047       /* If digit is not part of identifier, it starts a number,
3048          which means that following letters are not an identifier.
3049          "0x5" does not refer to an identifier "x5".
3050          So copy all alphanumerics that follow without accumulating
3051          as an identifier.  Periods also, for sake of "3.e7".  */
3052
3053       if (ident_length == 0) {
3054         for (;;) {
3055           while (ibp[0] == '\\' && ibp[1] == '\n') {
3056             ++ip->lineno;
3057             ibp += 2;
3058           }
3059           c = *ibp++;
3060           if (!is_idchar[c] && c != '.') {
3061             --ibp;
3062             break;
3063           }
3064           *obp++ = c;
3065           /* A sign can be part of a preprocessing number
3066              if it follows an e.  */
3067           if (c == 'e' || c == 'E') {
3068             while (ibp[0] == '\\' && ibp[1] == '\n') {
3069               ++ip->lineno;
3070               ibp += 2;
3071             }
3072             if (*ibp == '+' || *ibp == '-') {
3073               *obp++ = *ibp++;
3074               /* But traditional C does not let the token go past the sign.  */
3075               if (traditional)
3076                 break;
3077             }
3078           }
3079         }
3080         break;
3081       }
3082       /* fall through */
3083
3084     case '_':
3085     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3086     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3087     case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3088     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
3089     case 'y': case 'z':
3090     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3091     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
3092     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
3093     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
3094     case 'Y': case 'Z':
3095     letter:
3096       ident_length++;
3097       /* Compute step of hash function, to avoid a proc call on every token */
3098       hash = HASHSTEP (hash, c);
3099       break;
3100
3101     case '\n':
3102       if (ip->fname == 0 && *ibp == '-') {
3103         /* Newline - inhibits expansion of preceding token.
3104            If expanding a macro arg, we keep the newline -.
3105            In final output, it is deleted.
3106            We recognize Newline - in macro bodies and macro args.  */
3107         if (! concatenated) {
3108           ident_length = 0;
3109           hash = 0;
3110         }
3111         ibp++;
3112         if (!output_marks) {
3113           obp--;
3114         } else {
3115           /* If expanding a macro arg, keep the newline -.  */
3116           *obp++ = '-';
3117         }
3118         break;
3119       }
3120
3121       /* If reprocessing a macro expansion, newline is a special marker.  */
3122       else if (ip->macro != 0) {
3123         /* Newline White is a "funny space" to separate tokens that are
3124            supposed to be separate but without space between.
3125            Here White means any whitespace character.
3126            Newline - marks a recursive macro use that is not
3127            supposed to be expandable.  */
3128
3129         if (is_space[*ibp]) {
3130           /* Newline Space does not prevent expansion of preceding token
3131              so expand the preceding token and then come back.  */
3132           if (ident_length > 0)
3133             goto specialchar;
3134
3135           /* If generating final output, newline space makes a space.  */
3136           if (!output_marks) {
3137             obp[-1] = *ibp++;
3138             /* And Newline Newline makes a newline, so count it.  */
3139             if (obp[-1] == '\n')
3140               op->lineno++;
3141           } else {
3142             /* If expanding a macro arg, keep the newline space.
3143                If the arg gets stringified, newline space makes nothing.  */
3144             *obp++ = *ibp++;
3145           }
3146         } else abort ();        /* Newline followed by something random?  */
3147         break;
3148       }
3149
3150       /* If there is a pending identifier, handle it and come back here.  */
3151       if (ident_length > 0)
3152         goto specialchar;
3153
3154       beg_of_line = ibp;
3155
3156       /* Update the line counts and output a #line if necessary.  */
3157       ++ip->lineno;
3158       ++op->lineno;
3159       if (ip->lineno != op->lineno) {
3160         op->bufp = obp;
3161         output_line_directive (ip, op, 1, same_file);
3162         check_expand (op, limit - ibp);
3163         obp = op->bufp;
3164       }
3165       break;
3166
3167       /* Come here either after (1) a null character that is part of the input
3168          or (2) at the end of the input, because there is a null there.  */
3169     case 0:
3170       if (ibp <= limit)
3171         /* Our input really contains a null character.  */
3172         goto randomchar;
3173
3174     limit_reached:
3175       /* At end of a macro-expansion level, pop it and read next level.  */
3176       if (ip->macro != 0) {
3177         obp--;
3178         ibp--;
3179         /* If traditional, and we have an identifier that ends here,
3180            process it now, so we get the right error for recursion.  */
3181         if (traditional && ident_length
3182             && ! is_idchar[*instack[indepth - 1].bufp]) {
3183           redo_char = 1;
3184           goto randomchar;
3185         }
3186         POPMACRO;
3187         RECACHE;
3188         break;
3189       }
3190
3191       /* If we don't have a pending identifier,
3192          return at end of input.  */
3193       if (ident_length == 0) {
3194         obp--;
3195         ibp--;
3196         op->bufp = obp;
3197         ip->bufp = ibp;
3198         goto ending;
3199       }
3200
3201       /* If we do have a pending identifier, just consider this null
3202          a special character and arrange to dispatch on it again.
3203          The second time, IDENT_LENGTH will be zero so we will return.  */
3204
3205       /* Fall through */
3206
3207 specialchar:
3208
3209       /* Handle the case of a character such as /, ', " or null
3210          seen following an identifier.  Back over it so that
3211          after the identifier is processed the special char
3212          will be dispatched on again.  */
3213
3214       ibp--;
3215       obp--;
3216       redo_char = 1;
3217
3218     default:
3219
3220 randomchar:
3221
3222       if (ident_length > 0) {
3223         register HASHNODE *hp;
3224
3225         /* We have just seen an identifier end.  If it's a macro, expand it.
3226
3227            IDENT_LENGTH is the length of the identifier
3228            and HASH is its hash code.
3229
3230            The identifier has already been copied to the output,
3231            so if it is a macro we must remove it.
3232
3233            If REDO_CHAR is 0, the char that terminated the identifier
3234            has been skipped in the output and the input.
3235            OBP-IDENT_LENGTH-1 points to the identifier.
3236            If the identifier is a macro, we must back over the terminator.
3237
3238            If REDO_CHAR is 1, the terminating char has already been
3239            backed over.  OBP-IDENT_LENGTH points to the identifier.  */
3240
3241         if (!pcp_outfile || pcp_inside_if) {
3242           for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
3243                hp = hp->next) {
3244
3245             if (hp->length == ident_length) {
3246               int obufp_before_macroname;
3247               int op_lineno_before_macroname;
3248               register int i = ident_length;
3249               register U_CHAR *p = hp->name;
3250               register U_CHAR *q = obp - i;
3251               int disabled;
3252
3253               if (! redo_char)
3254                 q--;
3255
3256               do {              /* All this to avoid a strncmp () */
3257                 if (*p++ != *q++)
3258                   goto hashcollision;
3259               } while (--i);
3260
3261               /* We found a use of a macro name.
3262                  see if the context shows it is a macro call.  */
3263
3264               /* Back up over terminating character if not already done.  */
3265               if (! redo_char) {
3266                 ibp--;
3267                 obp--;
3268               }
3269
3270               /* Save this as a displacement from the beginning of the output
3271                  buffer.  We can not save this as a position in the output
3272                  buffer, because it may get realloc'ed by RECACHE.  */
3273               obufp_before_macroname = (obp - op->buf) - ident_length;
3274               op_lineno_before_macroname = op->lineno;
3275
3276               if (hp->type == T_PCSTRING) {
3277                 pcstring_used (hp); /* Mark the definition of this key
3278                                        as needed, ensuring that it
3279                                        will be output.  */
3280                 break;          /* Exit loop, since the key cannot have a
3281                                    definition any longer.  */
3282               }
3283
3284               /* Record whether the macro is disabled.  */
3285               disabled = hp->type == T_DISABLED;
3286
3287               /* This looks like a macro ref, but if the macro was disabled,
3288                  just copy its name and put in a marker if requested.  */
3289
3290               if (disabled) {
3291 #if 0
3292                 /* This error check caught useful cases such as
3293                    #define foo(x,y) bar (x (y,0), y)
3294                    foo (foo, baz)  */
3295                 if (traditional)
3296                   error ("recursive use of macro `%s'", hp->name);
3297 #endif
3298
3299                 if (output_marks) {
3300                   check_expand (op, limit - ibp + 2);
3301                   *obp++ = '\n';
3302                   *obp++ = '-';
3303                 }
3304                 break;
3305               }
3306
3307               /* If macro wants an arglist, verify that a '(' follows.
3308                  first skip all whitespace, copying it to the output
3309                  after the macro name.  Then, if there is no '(',
3310                  decide this is not a macro call and leave things that way.  */
3311               if ((hp->type == T_MACRO || hp->type == T_DISABLED)
3312                   && hp->value.defn->nargs >= 0)
3313                 {
3314                   U_CHAR *old_ibp = ibp;
3315                   U_CHAR *old_obp = obp;
3316                   int old_iln = ip->lineno;
3317                   int old_oln = op->lineno;
3318
3319                   while (1) {
3320                     /* Scan forward over whitespace, copying it to the output.  */
3321                     if (ibp == limit && ip->macro != 0) {
3322                       POPMACRO;
3323                       RECACHE;
3324                       old_ibp = ibp;
3325                       old_obp = obp;
3326                       old_iln = ip->lineno;
3327                       old_oln = op->lineno;
3328                     }
3329                     /* A comment: copy it unchanged or discard it.  */
3330                     else if (*ibp == '/' && ibp[1] == '*') {
3331                       if (put_out_comments) {
3332                         *obp++ = '/';
3333                         *obp++ = '*';
3334                       } else if (! traditional) {
3335                         *obp++ = ' ';
3336                       }
3337                       ibp += 2;
3338                       while (ibp + 1 != limit
3339                              && !(ibp[0] == '*' && ibp[1] == '/')) {
3340                         /* We need not worry about newline-marks,
3341                            since they are never found in comments.  */
3342                         if (*ibp == '\n') {
3343                           /* Newline in a file.  Count it.  */
3344                           ++ip->lineno;
3345                           ++op->lineno;
3346                         }
3347                         if (put_out_comments)
3348                           *obp++ = *ibp++;
3349                         else
3350                           ibp++;
3351                       }
3352                       ibp += 2;
3353                       if (put_out_comments) {
3354                         *obp++ = '*';
3355                         *obp++ = '/';
3356                       }
3357                     }
3358                     else if (is_space[*ibp]) {
3359                       *obp++ = *ibp++;
3360                       if (ibp[-1] == '\n') {
3361                         if (ip->macro == 0) {
3362                           /* Newline in a file.  Count it.  */
3363                           ++ip->lineno;
3364                           ++op->lineno;
3365                         } else if (!output_marks) {
3366                           /* A newline mark, and we don't want marks
3367                              in the output.  If it is newline-hyphen,
3368                              discard it entirely.  Otherwise, it is
3369                              newline-whitechar, so keep the whitechar.  */
3370                           obp--;
3371                           if (*ibp == '-')
3372                             ibp++;
3373                           else {
3374                             if (*ibp == '\n')
3375                               ++op->lineno;
3376                             *obp++ = *ibp++;
3377                           }
3378                         } else {
3379                           /* A newline mark; copy both chars to the output.  */
3380                           *obp++ = *ibp++;
3381                         }
3382                       }
3383                     }
3384                     else break;
3385                   }
3386                   if (*ibp != '(') {
3387                     /* It isn't a macro call.
3388                        Put back the space that we just skipped.  */
3389                     ibp = old_ibp;
3390                     obp = old_obp;
3391                     ip->lineno = old_iln;
3392                     op->lineno = old_oln;
3393                     /* Exit the for loop.  */
3394                     break;
3395                   }
3396                 }
3397
3398               /* This is now known to be a macro call.
3399                  Discard the macro name from the output,
3400                  along with any following whitespace just copied,
3401                  but preserve newlines if not outputting marks since this
3402                  is more likely to do the right thing with line numbers.  */
3403               obp = op->buf + obufp_before_macroname;
3404               if (output_marks)
3405                 op->lineno = op_lineno_before_macroname;
3406               else {
3407                 int newlines = op->lineno - op_lineno_before_macroname;
3408                 while (0 < newlines--)
3409                   *obp++ = '\n';
3410               }
3411
3412               /* Prevent accidental token-pasting with a character
3413                  before the macro call.  */
3414               if (!traditional && obp != op->buf) {
3415                 switch (obp[-1]) {
3416                 case '!':  case '%':  case '&':  case '*':
3417                 case '+':  case '-':  case '/':  case ':':
3418                 case '<':  case '=':  case '>':  case '^':
3419                 case '|':
3420                   /* If we are expanding a macro arg, make a newline marker
3421                      to separate the tokens.  If we are making real output,
3422                      a plain space will do.  */
3423                   if (output_marks)
3424                     *obp++ = '\n';
3425                   *obp++ = ' ';
3426                 }
3427               }
3428
3429               /* Expand the macro, reading arguments as needed,
3430                  and push the expansion on the input stack.  */
3431               ip->bufp = ibp;
3432               op->bufp = obp;
3433               macroexpand (hp, op);
3434
3435               /* Reexamine input stack, since macroexpand has pushed
3436                  a new level on it.  */
3437               obp = op->bufp;
3438               RECACHE;
3439               break;
3440             }
3441 hashcollision:
3442             ;
3443           }                     /* End hash-table-search loop */
3444         }
3445         ident_length = hash = 0; /* Stop collecting identifier */
3446         redo_char = 0;
3447         concatenated = 0;
3448       }                         /* End if (ident_length > 0) */
3449     }                           /* End switch */
3450   }                             /* End per-char loop */
3451
3452   /* Come here to return -- but first give an error message
3453      if there was an unterminated successful conditional.  */
3454  ending:
3455   if (if_stack != ip->if_stack)
3456     {
3457       char *str;
3458
3459       switch (if_stack->type)
3460         {
3461         case T_IF:
3462           str = "if";
3463           break;
3464         case T_IFDEF:
3465           str = "ifdef";
3466           break;
3467         case T_IFNDEF:
3468           str = "ifndef";
3469           break;
3470         case T_ELSE:
3471           str = "else";
3472           break;
3473         case T_ELIF:
3474           str = "elif";
3475           break;
3476         default:
3477           abort ();
3478         }
3479
3480       error_with_line (line_for_error (if_stack->lineno),
3481                        "unterminated `#%s' conditional", str);
3482   }
3483   if_stack = ip->if_stack;
3484 }
3485 \f
3486 /*
3487  * Rescan a string into a temporary buffer and return the result
3488  * as a FILE_BUF.  Note this function returns a struct, not a pointer.
3489  *
3490  * OUTPUT_MARKS nonzero means keep Newline markers found in the input
3491  * and insert such markers when appropriate.  See `rescan' for details.
3492  * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
3493  * before substitution; it is 0 for other uses.
3494  */
3495 static FILE_BUF
3496 expand_to_temp_buffer (buf, limit, output_marks, assertions)
3497      U_CHAR *buf, *limit;
3498      int output_marks, assertions;
3499 {
3500   register FILE_BUF *ip;
3501   FILE_BUF obuf;
3502   int length = limit - buf;
3503   U_CHAR *buf1;
3504   int odepth = indepth;
3505   int save_assertions_flag = assertions_flag;
3506
3507   assertions_flag = assertions;
3508
3509   if (length < 0)
3510     abort ();
3511
3512   /* Set up the input on the input stack.  */
3513
3514   buf1 = (U_CHAR *) alloca (length + 1);
3515   {
3516     register U_CHAR *p1 = buf;
3517     register U_CHAR *p2 = buf1;
3518
3519     while (p1 != limit)
3520       *p2++ = *p1++;
3521   }
3522   buf1[length] = 0;
3523
3524   /* Set up to receive the output.  */
3525
3526   obuf.length = length * 2 + 100; /* Usually enough.  Why be stingy?  */
3527   obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
3528   obuf.fname = 0;
3529   obuf.macro = 0;
3530   obuf.free_ptr = 0;
3531
3532   CHECK_DEPTH ({return obuf;});
3533
3534   ++indepth;
3535
3536   ip = &instack[indepth];
3537   ip->fname = 0;
3538   ip->nominal_fname = 0;
3539   ip->inc = 0;
3540   ip->system_header_p = 0;
3541   ip->macro = 0;
3542   ip->free_ptr = 0;
3543   ip->length = length;
3544   ip->buf = ip->bufp = buf1;
3545   ip->if_stack = if_stack;
3546
3547   ip->lineno = obuf.lineno = 1;
3548
3549   /* Scan the input, create the output.  */
3550   rescan (&obuf, output_marks);
3551
3552   /* Pop input stack to original state.  */
3553   --indepth;
3554
3555   if (indepth != odepth)
3556     abort ();
3557
3558   /* Record the output.  */
3559   obuf.length = obuf.bufp - obuf.buf;
3560
3561   assertions_flag = save_assertions_flag;
3562   return obuf;
3563 }
3564 \f
3565 /*
3566  * Process a # directive.  Expects IP->bufp to point after the '#', as in
3567  * `#define foo bar'.  Passes to the directive handler
3568  * (do_define, do_include, etc.): the addresses of the 1st and
3569  * last chars of the directive (starting immediately after the #
3570  * keyword), plus op and the keyword table pointer.  If the directive
3571  * contains comments it is copied into a temporary buffer sans comments
3572  * and the temporary buffer is passed to the directive handler instead.
3573  * Likewise for backslash-newlines.
3574  *
3575  * Returns nonzero if this was a known # directive.
3576  * Otherwise, returns zero, without advancing the input pointer.
3577  */
3578
3579 static int
3580 handle_directive (ip, op)
3581      FILE_BUF *ip, *op;
3582 {
3583   register U_CHAR *bp, *cp;
3584   register struct directive *kt;
3585   register int ident_length;
3586   U_CHAR *resume_p;
3587
3588   /* Nonzero means we must copy the entire directive
3589      to get rid of comments or backslash-newlines.  */
3590   int copy_directive = 0;
3591
3592   U_CHAR *ident, *after_ident;
3593
3594   bp = ip->bufp;
3595
3596   /* Record where the directive started.  do_xifdef needs this.  */
3597   directive_start = bp - 1;
3598
3599   /* Skip whitespace and \-newline.  */
3600   while (1) {
3601     if (is_hor_space[*bp]) {
3602       if (*bp != ' ' && *bp != '\t' && pedantic)
3603         pedwarn ("%s in preprocessing directive", char_name[*bp]);
3604       bp++;
3605     } else if (*bp == '/' && (bp[1] == '*'
3606                               || (cplusplus_comments && bp[1] == '/'))) {
3607       ip->bufp = bp + 2;
3608       skip_to_end_of_comment (ip, &ip->lineno, 0);
3609       bp = ip->bufp;
3610     } else if (*bp == '\\' && bp[1] == '\n') {
3611       bp += 2; ip->lineno++;
3612     } else break;
3613   }
3614
3615   /* Now find end of directive name.
3616      If we encounter a backslash-newline, exchange it with any following
3617      symbol-constituents so that we end up with a contiguous name.  */
3618
3619   cp = bp;
3620   while (1) {
3621     if (is_idchar[*cp])
3622       cp++;
3623     else {
3624       if (*cp == '\\' && cp[1] == '\n')
3625         name_newline_fix (cp);
3626       if (is_idchar[*cp])
3627         cp++;
3628       else break;
3629     }
3630   }
3631   ident_length = cp - bp;
3632   ident = bp;
3633   after_ident = cp;
3634
3635   /* A line of just `#' becomes blank.  */
3636
3637   if (ident_length == 0 && *after_ident == '\n') {
3638     ip->bufp = after_ident;
3639     return 1;
3640   }
3641
3642   if (ident_length == 0 || !is_idstart[*ident]) {
3643     U_CHAR *p = ident;
3644     while (is_idchar[*p]) {
3645       if (*p < '0' || *p > '9')
3646         break;
3647       p++;
3648     }
3649     /* Handle # followed by a line number.  */
3650     if (p != ident && !is_idchar[*p]) {
3651       static struct directive line_directive_table[] = {
3652         {  4, do_line, "line", T_LINE},
3653       };
3654       if (pedantic)
3655         pedwarn ("`#' followed by integer");
3656       after_ident = ident;
3657       kt = line_directive_table;
3658       goto old_linenum;
3659     }
3660
3661     /* Avoid error for `###' and similar cases unless -pedantic.  */
3662     if (p == ident) {
3663       while (*p == '#' || is_hor_space[*p]) p++;
3664       if (*p == '\n') {
3665         if (pedantic && !lang_asm)
3666           warning ("invalid preprocessing directive");
3667         return 0;
3668       }
3669     }
3670
3671     if (!lang_asm)
3672       error ("invalid preprocessing directive name");
3673
3674     return 0;
3675   }
3676
3677   /*
3678    * Decode the keyword and call the appropriate expansion
3679    * routine, after moving the input pointer up to the next line.
3680    */
3681   for (kt = directive_table; kt->length > 0; kt++) {
3682     if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
3683       register U_CHAR *buf;
3684       register U_CHAR *limit;
3685       int unterminated;
3686       int junk;
3687       int *already_output;
3688
3689       /* Nonzero means do not delete comments within the directive.
3690          #define needs this when -traditional.  */
3691       int keep_comments;
3692
3693     old_linenum:
3694
3695       limit = ip->buf + ip->length;
3696       unterminated = 0;
3697       already_output = 0;
3698       keep_comments = traditional && kt->traditional_comments;
3699       /* #import is defined only in Objective C, or when on the NeXT.  */
3700       if (kt->type == T_IMPORT
3701           && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
3702         break;
3703
3704       /* Find the end of this directive (first newline not backslashed
3705          and not in a string or comment).
3706          Set COPY_DIRECTIVE if the directive must be copied
3707          (it contains a backslash-newline or a comment).  */
3708
3709       buf = bp = after_ident;
3710       while (bp < limit) {
3711         register U_CHAR c = *bp++;
3712         switch (c) {
3713         case '\\':
3714           if (bp < limit) {
3715             if (*bp == '\n') {
3716               ip->lineno++;
3717               copy_directive = 1;
3718               bp++;
3719             } else if (traditional)
3720               bp++;
3721           }
3722           break;
3723
3724         case '\'':
3725         case '\"':
3726           bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, &copy_directive, &unterminated);
3727           /* Don't bother calling the directive if we already got an error
3728              message due to unterminated string.  Skip everything and pretend
3729              we called the directive.  */
3730           if (unterminated) {
3731             if (traditional) {
3732               /* Traditional preprocessing permits unterminated strings.  */
3733               ip->bufp = bp;
3734               goto endloop1;
3735             }
3736             ip->bufp = bp;
3737             return 1;
3738           }
3739           break;
3740
3741           /* <...> is special for #include.  */
3742         case '<':
3743           if (!kt->angle_brackets)
3744             break;
3745           while (bp < limit && *bp != '>' && *bp != '\n') {
3746             if (*bp == '\\' && bp[1] == '\n') {
3747               ip->lineno++;
3748               copy_directive = 1;
3749               bp++;
3750             }
3751             bp++;
3752           }
3753           break;
3754
3755         case '/':
3756           if (*bp == '\\' && bp[1] == '\n')
3757             newline_fix (bp);
3758           if (*bp == '*'
3759               || (cplusplus_comments && *bp == '/')) {
3760             U_CHAR *obp = bp - 1;
3761             ip->bufp = bp + 1;
3762             skip_to_end_of_comment (ip, &ip->lineno, 0);
3763             bp = ip->bufp;
3764             /* No need to copy the directive because of a comment at the end;
3765                just don't include the comment in the directive.  */
3766             if (!put_out_comments) {
3767               U_CHAR *p;
3768               for (p = bp;  *p == ' ' || *p == '\t';  p++)
3769                 continue;
3770               if (*p == '\n') {
3771                 bp = obp;
3772                 goto endloop1;
3773               }
3774             }
3775             /* Don't remove the comments if -traditional.  */
3776             if (! keep_comments)
3777               copy_directive++;
3778           }
3779           break;
3780
3781         case '\f':
3782         case '\r':
3783         case '\v':
3784           if (pedantic)
3785             pedwarn ("%s in preprocessing directive", char_name[c]);
3786           break;
3787
3788         case '\n':
3789           --bp;         /* Point to the newline */
3790           ip->bufp = bp;
3791           goto endloop1;
3792         }
3793       }
3794       ip->bufp = bp;
3795
3796     endloop1:
3797       resume_p = ip->bufp;
3798       /* BP is the end of the directive.
3799          RESUME_P is the next interesting data after the directive.
3800          A comment may come between.  */
3801
3802       /* If a directive should be copied through, and -E was given,
3803          pass it through before removing comments.  */
3804       if (!no_output && put_out_comments
3805           && (dump_macros != dump_definitions) < kt->pass_thru) {
3806         int len;
3807
3808         /* Output directive name.  */
3809         check_expand (op, kt->length + 2);
3810         /* Make sure # is at the start of a line */
3811         if (op->bufp > op->buf && op->bufp[-1] != '\n') {
3812           op->lineno++;
3813           *op->bufp++ = '\n';
3814         }
3815         *op->bufp++ = '#';
3816         bcopy (kt->name, op->bufp, kt->length);
3817         op->bufp += kt->length;
3818
3819         /* Output arguments.  */
3820         len = (bp - buf);
3821         check_expand (op, len);
3822         bcopy (buf, (char *) op->bufp, len);
3823         op->bufp += len;
3824         /* Take account of any (escaped) newlines just output.  */
3825         while (--len >= 0)
3826           if (buf[len] == '\n')
3827             op->lineno++;
3828
3829         already_output = &junk;
3830       }                         /* Don't we need a newline or #line? */
3831
3832       if (copy_directive) {
3833         register U_CHAR *xp = buf;
3834         /* Need to copy entire directive into temp buffer before dispatching */
3835
3836         cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
3837                                                   some slop */
3838         buf = cp;
3839
3840         /* Copy to the new buffer, deleting comments
3841            and backslash-newlines (and whitespace surrounding the latter).  */
3842
3843         while (xp < bp) {
3844           register U_CHAR c = *xp++;
3845           *cp++ = c;
3846
3847           switch (c) {
3848           case '\n':
3849             abort ();  /* A bare newline should never part of the line.  */
3850             break;
3851
3852             /* <...> is special for #include.  */
3853           case '<':
3854             if (!kt->angle_brackets)
3855               break;
3856             while (xp < bp && c != '>') {
3857               c = *xp++;
3858               if (c == '\\' && xp < bp && *xp == '\n')
3859                 xp++;
3860               else
3861                 *cp++ = c;
3862             }
3863             break;
3864
3865           case '\\':
3866             if (*xp == '\n') {
3867               xp++;
3868               cp--;
3869               if (cp != buf && is_hor_space[cp[-1]]) {
3870                 while (cp - 1 != buf && is_hor_space[cp[-2]])
3871                   cp--;
3872                 SKIP_WHITE_SPACE (xp);
3873               } else if (is_hor_space[*xp]) {
3874                 *cp++ = *xp++;
3875                 SKIP_WHITE_SPACE (xp);
3876               }
3877             } else if (traditional && xp < bp) {
3878               *cp++ = *xp++;
3879             }
3880             break;
3881
3882           case '\'':
3883           case '\"':
3884             {
3885               register U_CHAR *bp1
3886                 = skip_quoted_string (xp - 1, bp, ip->lineno,
3887                                       NULL_PTR, NULL_PTR, NULL_PTR);
3888               while (xp != bp1)
3889                 if (*xp == '\\') {
3890                   if (*++xp != '\n')
3891                     *cp++ = '\\';
3892                   else
3893                     xp++;
3894                 } else
3895                   *cp++ = *xp++;
3896             }
3897             break;
3898
3899           case '/':
3900             if (*xp == '*'
3901                 || (cplusplus_comments && *xp == '/')) {
3902               ip->bufp = xp + 1;
3903               /* If we already copied the directive through,
3904                  already_output != 0 prevents outputting comment now.  */
3905               skip_to_end_of_comment (ip, already_output, 0);
3906               if (keep_comments)
3907                 while (xp != ip->bufp)
3908                   *cp++ = *xp++;
3909               /* Delete or replace the slash.  */
3910               else if (traditional)
3911                 cp--;
3912               else
3913                 cp[-1] = ' ';
3914               xp = ip->bufp;
3915             }
3916           }
3917         }
3918
3919         /* Null-terminate the copy.  */
3920
3921         *cp = 0;
3922       } else
3923         cp = bp;
3924
3925       ip->bufp = resume_p;
3926
3927       /* Some directives should be written out for cc1 to process,
3928          just as if they were not defined.  And sometimes we're copying
3929          definitions through.  */
3930
3931       if (!no_output && already_output == 0
3932           && (dump_macros < dump_names) < kt->pass_thru) {
3933         int len;
3934
3935         /* Output directive name.  */
3936         check_expand (op, kt->length + 1);
3937         *op->bufp++ = '#';
3938         bcopy (kt->name, (char *) op->bufp, kt->length);
3939         op->bufp += kt->length;
3940
3941         if ((dump_macros != dump_definitions) < kt->pass_thru) {
3942           /* Output arguments.  */
3943           len = (cp - buf);
3944           check_expand (op, len);
3945           bcopy (buf, (char *) op->bufp, len);
3946           op->bufp += len;
3947         } else if (kt->type == T_DEFINE && dump_macros == dump_names) {
3948           U_CHAR *xp = buf;
3949           U_CHAR *yp;
3950           SKIP_WHITE_SPACE (xp);
3951           yp = xp;
3952           while (is_idchar[*xp]) xp++;
3953           len = (xp - yp);
3954           check_expand (op, len + 1);
3955           *op->bufp++ = ' ';
3956           bcopy (yp, op->bufp, len);
3957           op->bufp += len;
3958         }
3959       }                         /* Don't we need a newline or #line? */
3960
3961       /* Call the appropriate directive handler.  buf now points to
3962          either the appropriate place in the input buffer, or to
3963          the temp buffer if it was necessary to make one.  cp
3964          points to the first char after the contents of the (possibly
3965          copied) directive, in either case.  */
3966       (*kt->func) (buf, cp, op, kt);
3967       check_expand (op, ip->length - (ip->bufp - ip->buf));
3968
3969       return 1;
3970     }
3971   }
3972
3973   /* It is deliberate that we don't warn about undefined directives.
3974      That is the responsibility of cc1.  */
3975   return 0;
3976 }
3977 \f
3978 static struct tm *
3979 timestamp ()
3980 {
3981   static struct tm *timebuf;
3982   if (!timebuf) {
3983     time_t t = time ((time_t *) 0);
3984     timebuf = localtime (&t);
3985   }
3986   return timebuf;
3987 }
3988
3989 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
3990                              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
3991                             };
3992
3993 /*
3994  * expand things like __FILE__.  Place the expansion into the output
3995  * buffer *without* rescanning.
3996  */
3997
3998 static void
3999 special_symbol (hp, op)
4000      HASHNODE *hp;
4001      FILE_BUF *op;
4002 {
4003   char *buf;
4004   int i, len;
4005   int true_indepth;
4006   FILE_BUF *ip = NULL;
4007   struct tm *timebuf;
4008
4009   int paren = 0;                /* For special `defined' keyword */
4010
4011   if (pcp_outfile && pcp_inside_if
4012       && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
4013     error ("Predefined macro `%s' used inside `#if' during precompilation",
4014            hp->name);
4015
4016   for (i = indepth; i >= 0; i--)
4017     if (instack[i].fname != NULL) {
4018       ip = &instack[i];
4019       break;
4020     }
4021   if (ip == NULL) {
4022     error ("cccp error: not in any file?!");
4023     return;                     /* the show must go on */
4024   }
4025
4026   switch (hp->type) {
4027   case T_FILE:
4028   case T_BASE_FILE:
4029     {
4030       char *string;
4031       if (hp->type == T_FILE)
4032         string = ip->nominal_fname;
4033       else
4034         string = instack[0].nominal_fname;
4035
4036       if (string)
4037         {
4038           buf = (char *) alloca (3 + 4 * strlen (string));
4039           quote_string (buf, string);
4040         }
4041       else
4042         buf = "\"\"";
4043
4044       break;
4045     }
4046
4047   case T_INCLUDE_LEVEL:
4048     true_indepth = 0;
4049     for (i = indepth; i >= 0; i--)
4050       if (instack[i].fname != NULL)
4051         true_indepth++;
4052
4053     buf = (char *) alloca (8);  /* Eight bytes ought to be more than enough */
4054     sprintf (buf, "%d", true_indepth - 1);
4055     break;
4056
4057   case T_VERSION:
4058     buf = (char *) alloca (3 + strlen (version_string));
4059     sprintf (buf, "\"%s\"", version_string);
4060     break;
4061
4062 #ifndef NO_BUILTIN_SIZE_TYPE
4063   case T_SIZE_TYPE:
4064     buf = SIZE_TYPE;
4065     break;
4066 #endif
4067
4068 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4069   case T_PTRDIFF_TYPE:
4070     buf = PTRDIFF_TYPE;
4071     break;
4072 #endif
4073
4074   case T_WCHAR_TYPE:
4075     buf = wchar_type;
4076     break;
4077
4078   case T_USER_LABEL_PREFIX_TYPE:
4079     buf = USER_LABEL_PREFIX;
4080     break;
4081
4082   case T_REGISTER_PREFIX_TYPE:
4083     buf = REGISTER_PREFIX;
4084     break;
4085
4086   case T_IMMEDIATE_PREFIX_TYPE:
4087     buf = IMMEDIATE_PREFIX;
4088     break;
4089
4090   case T_CONST:
4091     buf = hp->value.cpval;
4092     if (pcp_inside_if && pcp_outfile)
4093       /* Output a precondition for this macro use */
4094       fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
4095     break;
4096
4097   case T_SPECLINE:
4098     buf = (char *) alloca (10);
4099     sprintf (buf, "%d", ip->lineno);
4100     break;
4101
4102   case T_DATE:
4103   case T_TIME:
4104     buf = (char *) alloca (20);
4105     timebuf = timestamp ();
4106     if (hp->type == T_DATE)
4107       sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
4108               timebuf->tm_mday, timebuf->tm_year + 1900);
4109     else
4110       sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
4111               timebuf->tm_sec);
4112     break;
4113
4114   case T_SPEC_DEFINED:
4115     buf = " 0 ";                /* Assume symbol is not defined */
4116     ip = &instack[indepth];
4117     SKIP_WHITE_SPACE (ip->bufp);
4118     if (*ip->bufp == '(') {
4119       paren++;
4120       ip->bufp++;                       /* Skip over the paren */
4121       SKIP_WHITE_SPACE (ip->bufp);
4122     }
4123
4124     if (!is_idstart[*ip->bufp])
4125       goto oops;
4126     if ((hp = lookup (ip->bufp, -1, -1))) {
4127       if (pcp_outfile && pcp_inside_if
4128           && (hp->type == T_CONST
4129               || (hp->type == T_MACRO && hp->value.defn->predefined)))
4130         /* Output a precondition for this macro use.  */
4131         fprintf (pcp_outfile, "#define %s\n", hp->name);
4132       buf = " 1 ";
4133     }
4134     else
4135       if (pcp_outfile && pcp_inside_if) {
4136         /* Output a precondition for this macro use */
4137         U_CHAR *cp = ip->bufp;
4138         fprintf (pcp_outfile, "#undef ");
4139         while (is_idchar[*cp]) /* Ick! */
4140           fputc (*cp++, pcp_outfile);
4141         putc ('\n', pcp_outfile);
4142       }
4143     while (is_idchar[*ip->bufp])
4144       ++ip->bufp;
4145     SKIP_WHITE_SPACE (ip->bufp);
4146     if (paren) {
4147       if (*ip->bufp != ')')
4148         goto oops;
4149       ++ip->bufp;
4150     }
4151     break;
4152
4153 oops:
4154
4155     error ("`defined' without an identifier");
4156     break;
4157
4158   default:
4159     error ("cccp error: invalid special hash type"); /* time for gdb */
4160     abort ();
4161   }
4162   len = strlen (buf);
4163   check_expand (op, len);
4164   bcopy (buf, (char *) op->bufp, len);
4165   op->bufp += len;
4166
4167   return;
4168 }
4169
4170 \f
4171 /* Routines to handle #directives */
4172
4173 /* Handle #include and #import.
4174    This function expects to see "fname" or <fname> on the input.  */
4175
4176 static int
4177 do_include (buf, limit, op, keyword)
4178      U_CHAR *buf, *limit;
4179      FILE_BUF *op;
4180      struct directive *keyword;
4181 {
4182   U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
4183   int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
4184   static int import_warning = 0;
4185   char *fname;          /* Dynamically allocated fname buffer */
4186   char *pcftry;
4187   char *pcfname;
4188   char *fbeg, *fend;            /* Beginning and end of fname */
4189   U_CHAR *fin;
4190
4191   struct file_name_list *search_start = include; /* Chain of dirs to search */
4192   struct file_name_list *dsp;   /* First in chain, if #include "..." */
4193   struct file_name_list *searchptr = 0;
4194   size_t flen;
4195
4196   int f = -3;                   /* file number */
4197   struct include_file *inc = 0;
4198
4199   int retried = 0;              /* Have already tried macro
4200                                    expanding the include line*/
4201   int angle_brackets = 0;       /* 0 for "...", 1 for <...> */
4202   int pcf = -1;
4203   char *pcfbuf;
4204   char *pcfbuflimit;
4205   int pcfnum;
4206
4207   if (importing && warn_import && !inhibit_warnings
4208       && !instack[indepth].system_header_p && !import_warning) {
4209     import_warning = 1;
4210     warning ("using `#import' is not recommended");
4211     fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
4212     fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
4213     fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
4214     fprintf (stderr, "  #ifndef _FOO_H_INCLUDED\n");
4215     fprintf (stderr, "  #define _FOO_H_INCLUDED\n");
4216     fprintf (stderr, "  ... <real contents of file> ...\n");
4217     fprintf (stderr, "  #endif /* Not _FOO_H_INCLUDED */\n\n");
4218     fprintf (stderr, "Then users can use `#include' any number of times.\n");
4219     fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
4220     fprintf (stderr, "when it is equipped with such a conditional.\n");
4221   }
4222
4223 get_filename:
4224
4225   fin = buf;
4226   SKIP_WHITE_SPACE (fin);
4227   /* Discard trailing whitespace so we can easily see
4228      if we have parsed all the significant chars we were given.  */
4229   while (limit != fin && is_hor_space[limit[-1]]) limit--;
4230   fbeg = fend = (char *) alloca (limit - fin);
4231
4232   switch (*fin++) {
4233   case '\"':
4234     {
4235       FILE_BUF *fp;
4236       /* Copy the operand text, concatenating the strings.  */
4237       {
4238         while (fin != limit) {
4239           while (fin != limit && *fin != '\"')
4240             *fend++ = *fin++;
4241           fin++;
4242           if (fin == limit)
4243             break;
4244           /* If not at the end, there had better be another string.  */
4245           /* Skip just horiz space, and don't go past limit.  */
4246           while (fin != limit && is_hor_space[*fin]) fin++;
4247           if (fin != limit && *fin == '\"')
4248             fin++;
4249           else
4250             goto fail;
4251         }
4252       }
4253
4254       /* We have "filename".  Figure out directory this source
4255          file is coming from and put it on the front of the list.  */
4256
4257       /* If -I- was specified, don't search current dir, only spec'd ones.  */
4258       if (ignore_srcdir) break;
4259
4260       for (fp = &instack[indepth]; fp >= instack; fp--)
4261         {
4262           int n;
4263           char *nam;
4264
4265           if ((nam = fp->nominal_fname) != NULL) {
4266             /* Found a named file.  Figure out dir of the file,
4267                and put it in front of the search list.  */
4268             dsp = ((struct file_name_list *)
4269                    alloca (sizeof (struct file_name_list) + strlen (nam)));
4270             strcpy (dsp->fname, nam);
4271             simplify_filename (dsp->fname);
4272             nam = base_name (dsp->fname);
4273             *nam = 0;
4274             /* But for efficiency's sake, do not insert the dir
4275                if it matches the search list's first dir.  */
4276             dsp->next = search_start;
4277             if (!search_start || strcmp (dsp->fname, search_start->fname)) {
4278               search_start = dsp;
4279               n = nam - dsp->fname;
4280               if (n + INCLUDE_LEN_FUDGE > max_include_len)
4281                 max_include_len = n + INCLUDE_LEN_FUDGE;
4282             }
4283             dsp[0].got_name_map = 0;
4284             break;
4285           }
4286         }
4287       break;
4288     }
4289
4290   case '<':
4291     while (fin != limit && *fin != '>')
4292       *fend++ = *fin++;
4293     if (*fin == '>' && fin + 1 == limit) {
4294       angle_brackets = 1;
4295       /* If -I-, start with the first -I dir after the -I-.  */
4296       search_start = first_bracket_include;
4297       break;
4298     }
4299     goto fail;
4300
4301   default:
4302 #ifdef VMS
4303     /*
4304      * Support '#include xyz' like VAX-C to allow for easy use of all the
4305      * decwindow include files. It defaults to '#include <xyz.h>' (so the
4306      * code from case '<' is repeated here) and generates a warning.
4307      * (Note: macro expansion of `xyz' takes precedence.)
4308      */
4309     if (retried && isalpha(*(U_CHAR *) (--fbeg))) {
4310       while (fin != limit && (!isspace(*fin)))
4311         *fend++ = *fin++;
4312       warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
4313       if (fin == limit) {
4314         angle_brackets = 1;
4315         /* If -I-, start with the first -I dir after the -I-.  */
4316         search_start = first_bracket_include;
4317         break;
4318       }
4319     }
4320 #endif
4321
4322   fail:
4323     if (retried) {
4324       error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
4325       return 0;
4326     } else {
4327       /* Expand buffer and then remove any newline markers.
4328          We can't just tell expand_to_temp_buffer to omit the markers,
4329          since it would put extra spaces in include file names.  */
4330       FILE_BUF trybuf;
4331       U_CHAR *src;
4332       trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
4333       src = trybuf.buf;
4334       buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
4335       limit = buf;
4336       while (src != trybuf.bufp) {
4337         switch ((*limit++ = *src++)) {
4338           case '\n':
4339             limit--;
4340             src++;
4341             break;
4342
4343           case '\'':
4344           case '\"':
4345             {
4346               U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
4347                                                  NULL_PTR, NULL_PTR, NULL_PTR);
4348               while (src != src1)
4349                 *limit++ = *src++;
4350             }
4351             break;
4352         }
4353       }
4354       *limit = 0;
4355       free (trybuf.buf);
4356       retried++;
4357       goto get_filename;
4358     }
4359   }
4360
4361   /* For #include_next, skip in the search path
4362      past the dir in which the containing file was found.  */
4363   if (skip_dirs) {
4364     FILE_BUF *fp;
4365     for (fp = &instack[indepth]; fp >= instack; fp--)
4366       if (fp->fname != NULL) {
4367         /* fp->dir is null if the containing file was specified
4368            with an absolute file name.  In that case, don't skip anything.  */
4369         if (fp->dir)
4370           search_start = fp->dir->next;
4371         break;
4372       }
4373   }
4374
4375   *fend = 0;
4376   flen = simplify_filename (fbeg);
4377
4378   if (flen == 0)
4379     {
4380       error ("empty file name in `#%s'", keyword->name);
4381       return 0;
4382     }
4383
4384   /* Allocate this permanently, because it gets stored in the definitions
4385      of macros.  */
4386   fname = xmalloc (max_include_len + flen + 1);
4387   /* + 1 above for terminating null.  */
4388
4389   system_include_depth += angle_brackets;
4390
4391   /* If specified file name is absolute, just open it.  */
4392
4393   if (absolute_filename (fbeg)) {
4394     strcpy (fname, fbeg);
4395     f = open_include_file (fname, NULL_PTR, importing, &inc);
4396   } else {
4397
4398     struct bypass_dir {
4399       struct bypass_dir *next;
4400       char *fname;
4401       struct file_name_list *searchptr;
4402     } **bypass_slot = 0;
4403
4404     /* Search directory path, trying to open the file.
4405        Copy each filename tried into FNAME.  */
4406
4407     for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
4408
4409       if (searchptr == first_bracket_include) {
4410         /* Go to bypass directory if we know we've seen this file before.  */
4411         static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
4412         struct bypass_dir *p;
4413         bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
4414                                              INCLUDE_HASHSIZE)];
4415         for (p = *bypass_slot; p; p = p->next)
4416           if (!strcmp (fbeg, p->fname)) {
4417             searchptr = p->searchptr;
4418             bypass_slot = 0;
4419             break;
4420           }
4421       }
4422
4423       strcpy (fname, searchptr->fname);
4424       strcat (fname, fbeg);
4425 #ifdef VMS
4426       /* Change this 1/2 Unix 1/2 VMS file specification into a
4427          full VMS file specification */
4428       if (searchptr->fname[0]) {
4429         /* Fix up the filename */
4430         hack_vms_include_specification (fname);
4431       } else {
4432         /* This is a normal VMS filespec, so use it unchanged.  */
4433         strcpy (fname, fbeg);
4434         /* if it's '#include filename', add the missing .h */
4435         if (index(fname,'.')==NULL) {
4436           strcat (fname, ".h");
4437         }
4438       }
4439 #endif /* VMS */
4440       f = open_include_file (fname, searchptr, importing, &inc);
4441       if (f != -1) {
4442         if (bypass_slot && searchptr != first_bracket_include) {
4443           /* This is the first time we found this include file,
4444              and we found it after first_bracket_include.
4445              Record its location so that we can bypass to here next time.  */
4446           struct bypass_dir *p
4447             = (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
4448           p->next = *bypass_slot;
4449           p->fname = fname + strlen (searchptr->fname);
4450           p->searchptr = searchptr;
4451           *bypass_slot = p;
4452         }
4453         break;
4454       }
4455 #ifdef VMS
4456       /* Our VMS hacks can produce invalid filespecs, so don't worry
4457          about errors other than EACCES.  */
4458       if (errno == EACCES)
4459         break;
4460 #else
4461       if (errno != ENOENT && errno != ENOTDIR)
4462         break;
4463 #endif
4464     }
4465   }
4466
4467
4468   if (f < 0) {
4469
4470     if (f == -2) {
4471       /* The file was already included.  */
4472
4473     /* If generating dependencies and -MG was specified, we assume missing
4474        files are leaf files, living in the same directory as the source file
4475        or other similar place; these missing files may be generated from
4476        other files and may not exist yet (eg: y.tab.h).  */
4477     } else if (print_deps_missing_files
4478                && (system_include_depth != 0) < print_deps)
4479       {
4480         /* If it was requested as a system header file,
4481            then assume it belongs in the first place to look for such.  */
4482         if (angle_brackets)
4483           {
4484             if (search_start) {
4485               char *p = (char *) alloca (strlen (search_start->fname)
4486                                          + strlen (fbeg) + 1);
4487               strcpy (p, search_start->fname);
4488               strcat (p, fbeg);
4489               deps_output (p, ' ');
4490             }
4491           }
4492         else
4493           {
4494             /* Otherwise, omit the directory, as if the file existed
4495                in the directory with the source.  */
4496             deps_output (fbeg, ' ');
4497           }
4498       }
4499     /* If -M was specified, and this header file won't be added to the
4500        dependency list, then don't count this as an error, because we can
4501        still produce correct output.  Otherwise, we can't produce correct
4502        output, because there may be dependencies we need inside the missing
4503        file, and we don't know what directory this missing file exists in.  */
4504     else if (0 < print_deps  &&  print_deps <= (system_include_depth != 0))
4505       warning ("No include path in which to find %s", fbeg);
4506     else if (f != -3)
4507       error_from_errno (fbeg);
4508     else
4509       error ("No include path in which to find %s", fbeg);
4510
4511   } else {
4512
4513     /* Actually process the file.  */
4514
4515     pcftry = (char *) alloca (strlen (fname) + 30);
4516     pcfbuf = 0;
4517     pcfnum = 0;
4518
4519     if (!no_precomp)
4520       {
4521         do {
4522           sprintf (pcftry, "%s%d", fname, pcfnum++);
4523
4524           pcf = open (pcftry, O_RDONLY, 0666);
4525           if (pcf != -1)
4526             {
4527               struct stat s;
4528
4529               if (fstat (pcf, &s) != 0)
4530                 pfatal_with_name (pcftry);
4531               if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
4532                   || inc->st.st_dev != s.st_dev)
4533                 {
4534                   pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
4535                   /* Don't need it any more.  */
4536                   close (pcf);
4537                 }
4538               else
4539                 {
4540                   /* Don't need it at all.  */
4541                   close (pcf);
4542                   break;
4543                 }
4544             }
4545         } while (pcf != -1 && !pcfbuf);
4546       }
4547
4548     /* Actually process the file */
4549     if (pcfbuf) {
4550       pcfname = xmalloc (strlen (pcftry) + 1);
4551       strcpy (pcfname, pcftry);
4552       pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
4553                   (U_CHAR *) fname, op);
4554     }
4555     else
4556       finclude (f, inc, op, is_system_include (fname), searchptr);
4557   }
4558
4559   system_include_depth -= angle_brackets;
4560
4561   return 0;
4562 }
4563
4564 /* Return nonzero if the given FILENAME is an absolute pathname which
4565    designates a file within one of the known "system" include file
4566    directories.  We assume here that if the given FILENAME looks like
4567    it is the name of a file which resides either directly in a "system"
4568    include file directory, or within any subdirectory thereof, then the
4569    given file must be a "system" include file.  This function tells us
4570    if we should suppress pedantic errors/warnings for the given FILENAME.
4571
4572    The value is 2 if the file is a C-language system header file
4573    for which C++ should (on most systems) assume `extern "C"'.  */
4574
4575 static int
4576 is_system_include (filename)
4577     register char *filename;
4578 {
4579   struct file_name_list *searchptr;
4580
4581   for (searchptr = first_system_include; searchptr;
4582        searchptr = searchptr->next)
4583     if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
4584       return searchptr->c_system_include_path + 1;
4585   return 0;
4586 }
4587 \f
4588 /* Yield the non-directory suffix of a file name.  */
4589
4590 static char *
4591 base_name (fname)
4592      char *fname;
4593 {
4594   char *s = fname;
4595   char *p;
4596 #if defined (__MSDOS__) || defined (_WIN32)
4597   if (isalpha (s[0]) && s[1] == ':') s += 2;
4598 #endif
4599 #ifdef VMS
4600   if ((p = rindex (s, ':'))) s = p + 1; /* Skip device.  */
4601   if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory.  */
4602   if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir.  */
4603   if (s != fname)
4604     return s;
4605 #endif
4606   if ((p = rindex (s, '/'))) s = p + 1;
4607 #ifdef DIR_SEPARATOR
4608   if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
4609 #endif
4610   return s;
4611 }
4612
4613 /* Yield nonzero if FILENAME is absolute (i.e. not relative).  */
4614
4615 static int
4616 absolute_filename (filename)
4617      char *filename;
4618 {
4619 #if defined (__MSDOS__) || (defined (_WIN32) && !defined (__CYGWIN32__))
4620   if (isalpha (filename[0]) && filename[1] == ':') filename += 2;
4621 #endif
4622 #if defined (__CYGWIN32__)
4623   /* At present, any path that begins with a drive spec is absolute.  */
4624   if (isalpha (filename[0]) && filename[1] == ':') return 1;
4625 #endif
4626   if (filename[0] == '/') return 1;
4627 #ifdef DIR_SEPARATOR
4628   if (filename[0] == DIR_SEPARATOR) return 1;
4629 #endif
4630   return 0;
4631 }
4632
4633 /* Remove unnecessary characters from FILENAME in place,
4634    to avoid unnecessary filename aliasing.
4635    Return the length of the resulting string.
4636
4637    Do only the simplifications allowed by Posix.
4638    It is OK to miss simplifications on non-Posix hosts,
4639    since this merely leads to suboptimial results.  */
4640
4641 static size_t
4642 simplify_filename (filename)
4643      char *filename;
4644 {
4645   register char *from = filename;
4646   register char *to = filename;
4647   char *to0;
4648
4649   /* Remove redundant initial /s.  */
4650   if (*from == '/') {
4651     *to++ = '/';
4652     if (*++from == '/') {
4653       if (*++from == '/') {
4654         /* 3 or more initial /s are equivalent to 1 /.  */
4655         while (*++from == '/')
4656           continue;
4657       } else {
4658         /* On some hosts // differs from /; Posix allows this.  */
4659         static int slashslash_vs_slash;
4660         if (slashslash_vs_slash == 0) {
4661           struct stat s1, s2;
4662           slashslash_vs_slash = ((stat ("/", &s1) == 0 && stat ("//", &s2) == 0
4663                                   && INO_T_EQ (s1.st_ino, s2.st_ino)
4664                                   && s1.st_dev == s2.st_dev)
4665                                  ? 1 : -1);
4666         }
4667         if (slashslash_vs_slash < 0)
4668           *to++ = '/';
4669       }
4670     }
4671   }
4672   to0 = to;
4673
4674   for (;;) {
4675     if (from[0] == '.' && from[1] == '/')
4676       from += 2;
4677     else {
4678       /* Copy this component and trailing /, if any.  */
4679       while ((*to++ = *from++) != '/') {
4680         if (!to[-1]) {
4681           /* Trim . component at end of nonempty name.  */
4682           to -= filename <= to - 3 && to[-3] == '/' && to[-2] == '.';
4683
4684           /* Trim unnecessary trailing /s.  */
4685           while (to0 < --to && to[-1] == '/')
4686             continue;
4687
4688           *to = 0;
4689           return to - filename;
4690         }
4691       }
4692     }
4693
4694     /* Skip /s after a /.  */
4695     while (*from == '/')
4696       from++;
4697   }
4698 }
4699 \f
4700 /* The file_name_map structure holds a mapping of file names for a
4701    particular directory.  This mapping is read from the file named
4702    FILE_NAME_MAP_FILE in that directory.  Such a file can be used to
4703    map filenames on a file system with severe filename restrictions,
4704    such as DOS.  The format of the file name map file is just a series
4705    of lines with two tokens on each line.  The first token is the name
4706    to map, and the second token is the actual name to use.  */
4707
4708 struct file_name_map
4709 {
4710   struct file_name_map *map_next;
4711   char *map_from;
4712   char *map_to;
4713 };
4714
4715 #define FILE_NAME_MAP_FILE "header.gcc"
4716
4717 /* Read a space delimited string of unlimited length from a stdio
4718    file.  */
4719
4720 static char *
4721 read_filename_string (ch, f)
4722      int ch;
4723      FILE *f;
4724 {
4725   char *alloc, *set;
4726   int len;
4727
4728   len = 20;
4729   set = alloc = xmalloc (len + 1);
4730   if (! is_space[ch])
4731     {
4732       *set++ = ch;
4733       while ((ch = getc (f)) != EOF && ! is_space[ch])
4734         {
4735           if (set - alloc == len)
4736             {
4737               len *= 2;
4738               alloc = xrealloc (alloc, len + 1);
4739               set = alloc + len / 2;
4740             }
4741           *set++ = ch;
4742         }
4743     }
4744   *set = '\0';
4745   ungetc (ch, f);
4746   return alloc;
4747 }
4748
4749 /* Read the file name map file for DIRNAME.
4750    If DIRNAME is empty, read the map file for the working directory;
4751    otherwise DIRNAME must end in '/'.  */
4752
4753 static struct file_name_map *
4754 read_name_map (dirname)
4755      char *dirname;
4756 {
4757   /* This structure holds a linked list of file name maps, one per
4758      directory.  */
4759   struct file_name_map_list
4760     {
4761       struct file_name_map_list *map_list_next;
4762       char *map_list_name;
4763       struct file_name_map *map_list_map;
4764     };
4765   static struct file_name_map_list *map_list;
4766   register struct file_name_map_list *map_list_ptr;
4767   char *name;
4768   FILE *f;
4769   size_t dirlen;
4770
4771   for (map_list_ptr = map_list; map_list_ptr;
4772        map_list_ptr = map_list_ptr->map_list_next)
4773     if (! strcmp (map_list_ptr->map_list_name, dirname))
4774       return map_list_ptr->map_list_map;
4775
4776   map_list_ptr = ((struct file_name_map_list *)
4777                   xmalloc (sizeof (struct file_name_map_list)));
4778   map_list_ptr->map_list_name = savestring (dirname);
4779   map_list_ptr->map_list_map = NULL;
4780
4781   dirlen = strlen (dirname);
4782   name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
4783   strcpy (name, dirname);
4784   strcat (name, FILE_NAME_MAP_FILE);
4785   f = fopen (name, "r");
4786   if (!f)
4787     map_list_ptr->map_list_map = NULL;
4788   else
4789     {
4790       int ch;
4791
4792       while ((ch = getc (f)) != EOF)
4793         {
4794           char *from, *to;
4795           struct file_name_map *ptr;
4796           size_t tolen;
4797
4798           if (is_space[ch])
4799             continue;
4800           from = read_filename_string (ch, f);
4801           while ((ch = getc (f)) != EOF && is_hor_space[ch])
4802             ;
4803           to = read_filename_string (ch, f);
4804
4805           simplify_filename (from);
4806           tolen = simplify_filename (to);
4807
4808           ptr = ((struct file_name_map *)
4809                  xmalloc (sizeof (struct file_name_map)));
4810           ptr->map_from = from;
4811
4812           /* Make the real filename absolute.  */
4813           if (absolute_filename (to))
4814             ptr->map_to = to;
4815           else
4816             {
4817               ptr->map_to = xmalloc (dirlen + tolen + 1);
4818               strcpy (ptr->map_to, dirname);
4819               strcat (ptr->map_to, to);
4820               free (to);
4821             }
4822
4823           ptr->map_next = map_list_ptr->map_list_map;
4824           map_list_ptr->map_list_map = ptr;
4825
4826           while ((ch = getc (f)) != '\n')
4827             if (ch == EOF)
4828               break;
4829         }
4830       fclose (f);
4831     }
4832
4833   map_list_ptr->map_list_next = map_list;
4834   map_list = map_list_ptr;
4835
4836   return map_list_ptr->map_list_map;
4837 }
4838
4839 /* Try to open include file FILENAME.  SEARCHPTR is the directory
4840    being tried from the include file search path.
4841    IMPORTING is "" if we are importing, null otherwise.
4842    Return -2 if found, either a matching name or a matching inode.
4843    Otherwise, open the file and return a file descriptor if successful
4844    or -1 if unsuccessful.
4845    Unless unsuccessful, put a descriptor of the included file into *PINC.
4846    This function maps filenames on file systems based on information read by
4847    read_name_map.  */
4848
4849 static int
4850 open_include_file (filename, searchptr, importing, pinc)
4851      char *filename;
4852      struct file_name_list *searchptr;
4853      U_CHAR *importing;
4854      struct include_file **pinc;
4855 {
4856   char *fname = remap_include_file (filename, searchptr);
4857   int fd = -2;
4858
4859   /* Look up FNAME in include_hashtab.  */
4860   struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
4861                                                         strlen (fname),
4862                                                         INCLUDE_HASHSIZE)];
4863   struct include_file *inc, *head = *phead;
4864   for (inc = head; inc; inc = inc->next)
4865     if (!strcmp (fname, inc->fname))
4866       break;
4867
4868   if (!inc
4869       || ! inc->control_macro
4870       || (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
4871
4872     fd = open (fname, O_RDONLY, 0);
4873
4874     if (fd < 0)
4875       return fd;
4876
4877     if (!inc) {
4878       /* FNAME was not in include_hashtab; insert a new entry.  */
4879       inc = (struct include_file *) xmalloc (sizeof (struct include_file));
4880       inc->next = head;
4881       inc->fname = fname;
4882       inc->control_macro = 0;
4883       inc->deps_output = 0;
4884       if (fstat (fd, &inc->st) != 0)
4885         pfatal_with_name (fname);
4886       *phead = inc;
4887
4888       /* Look for another file with the same inode and device.  */
4889       if (lookup_ino_include (inc)
4890           && inc->control_macro
4891           && (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
4892         close (fd);
4893         fd = -2;
4894       }
4895     }
4896
4897     /* For -M, add this file to the dependencies.  */
4898     if (! inc->deps_output  &&  (system_include_depth != 0) < print_deps) {
4899       inc->deps_output = 1;
4900       deps_output (fname, ' ');
4901     }
4902
4903     /* Handle -H option.  */
4904     if (print_include_names)
4905       fprintf (stderr, "%*s%s\n", indepth, "", fname);
4906   }
4907
4908   if (importing)
4909     inc->control_macro = importing;
4910
4911   *pinc = inc;
4912   return fd;
4913 }
4914
4915 /* Return the remapped name of the the include file FILENAME.
4916    SEARCHPTR is the directory being tried from the include file path.  */
4917
4918 static char *
4919 remap_include_file (filename, searchptr)
4920      char *filename;
4921      struct file_name_list *searchptr;
4922 {
4923   register struct file_name_map *map;
4924   register char *from;
4925
4926   if (searchptr)
4927     {
4928       if (! searchptr->got_name_map)
4929         {
4930           searchptr->name_map = read_name_map (searchptr->fname);
4931           searchptr->got_name_map = 1;
4932         }
4933
4934       /* Check the mapping for the directory we are using.  */
4935       from = filename + strlen (searchptr->fname);
4936       for (map = searchptr->name_map; map; map = map->map_next)
4937         if (! strcmp (map->map_from, from))
4938           return map->map_to;
4939     }
4940
4941   from = base_name (filename);
4942
4943   if (from != filename || !searchptr)
4944     {
4945       /* Try to find a mapping file for the particular directory we are
4946          looking in.  Thus #include <sys/types.h> will look up sys/types.h
4947          in /usr/include/header.gcc and look up types.h in
4948          /usr/include/sys/header.gcc.  */
4949
4950       char *dir = (char *) alloca (from - filename + 1);
4951       bcopy (filename, dir, from - filename);
4952       dir[from - filename] = '\0';
4953
4954       for (map = read_name_map (dir); map; map = map->map_next)
4955         if (! strcmp (map->map_from, from))
4956           return map->map_to;
4957     }
4958
4959   return filename;
4960 }
4961
4962 /* Insert INC into the include file table, hashed by device and inode number.
4963    If a file with different name but same dev+ino was already in the table,
4964    return 1 and set INC's control macro to the already-known macro.  */
4965
4966 static int
4967 lookup_ino_include (inc)
4968      struct include_file *inc;
4969 {
4970   int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
4971               % INCLUDE_HASHSIZE);
4972   struct include_file *i = include_ino_hashtab[hash];
4973   inc->next_ino = i;
4974   include_ino_hashtab[hash] = inc;
4975
4976   for (; i; i = i->next_ino)
4977     if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
4978         && inc->st.st_dev == i->st.st_dev) {
4979       inc->control_macro = i->control_macro;
4980       return 1;
4981     }
4982
4983   return 0;
4984 }
4985 \f
4986 /* Process file descriptor F, which corresponds to include file INC,
4987    with output to OP.
4988    SYSTEM_HEADER_P is 1 if this file resides in any one of the known
4989    "system" include directories (as decided by the `is_system_include'
4990    function above).
4991    DIRPTR is the link in the dir path through which this file was found,
4992    or 0 if the file name was absolute.  */
4993
4994 static void
4995 finclude (f, inc, op, system_header_p, dirptr)
4996      int f;
4997      struct include_file *inc;
4998      FILE_BUF *op;
4999      int system_header_p;
5000      struct file_name_list *dirptr;
5001 {
5002   char *fname = inc->fname;
5003   int i;
5004   FILE_BUF *fp;                 /* For input stack frame */
5005   int missing_newline = 0;
5006
5007   CHECK_DEPTH (return;);
5008
5009   fp = &instack[indepth + 1];
5010   bzero ((char *) fp, sizeof (FILE_BUF));
5011   fp->nominal_fname = fp->fname = fname;
5012   fp->inc = inc;
5013   fp->length = 0;
5014   fp->lineno = 1;
5015   fp->if_stack = if_stack;
5016   fp->system_header_p = system_header_p;
5017   fp->dir = dirptr;
5018
5019   if (S_ISREG (inc->st.st_mode)) {
5020     fp->buf = (U_CHAR *) xmalloc (inc->st.st_size + 2);
5021     fp->bufp = fp->buf;
5022
5023     /* Read the file contents, knowing that inc->st.st_size is an upper bound
5024        on the number of bytes we can read.  */
5025     fp->length = safe_read (f, (char *) fp->buf, inc->st.st_size);
5026     if (fp->length < 0) goto nope;
5027   }
5028   else if (S_ISDIR (inc->st.st_mode)) {
5029     error ("directory `%s' specified in #include", fname);
5030     close (f);
5031     return;
5032   } else {
5033     /* Cannot count its file size before reading.
5034        First read the entire file into heap and
5035        copy them into buffer on stack.  */
5036
5037     int bsize = 2000;
5038     int st_size = 0;
5039
5040     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5041
5042     for (;;) {
5043       i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
5044       if (i < 0)
5045         goto nope;      /* error! */
5046       st_size += i;
5047       if (st_size != bsize)
5048         break;  /* End of file */
5049       bsize *= 2;
5050       fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5051     }
5052     fp->bufp = fp->buf;
5053     fp->length = st_size;
5054   }
5055
5056   if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
5057       /* Backslash-newline at end is not good enough.  */
5058       || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
5059     fp->buf[fp->length++] = '\n';
5060     missing_newline = 1;
5061   }
5062   fp->buf[fp->length] = '\0';
5063
5064   /* Close descriptor now, so nesting does not use lots of descriptors.  */
5065   close (f);
5066
5067   /* Must do this before calling trigraph_pcp, so that the correct file name
5068      will be printed in warning messages.  */
5069
5070   indepth++;
5071   input_file_stack_tick++;
5072
5073   if (!no_trigraphs)
5074     trigraph_pcp (fp);
5075
5076   output_line_directive (fp, op, 0, enter_file);
5077   rescan (op, 0);
5078
5079   if (missing_newline)
5080     fp->lineno--;
5081
5082   if (pedantic && missing_newline)
5083     pedwarn ("file does not end in newline");
5084
5085   indepth--;
5086   input_file_stack_tick++;
5087   output_line_directive (&instack[indepth], op, 0, leave_file);
5088   free (fp->buf);
5089   return;
5090
5091  nope:
5092
5093   perror_with_name (fname);
5094   close (f);
5095   free (fp->buf);
5096 }
5097
5098 /* Record that inclusion of the include file INC
5099    should be controlled by the macro named MACRO_NAME.
5100    This means that trying to include the file again
5101    will do something if that macro is defined.  */
5102
5103 static void
5104 record_control_macro (inc, macro_name)
5105      struct include_file *inc;
5106      U_CHAR *macro_name;
5107 {
5108   if (!inc->control_macro || inc->control_macro[0])
5109     inc->control_macro = macro_name;
5110 }
5111 \f
5112 /* Load the specified precompiled header into core, and verify its
5113    preconditions.  PCF indicates the file descriptor to read, which must
5114    be a regular file.  *ST is its file status.
5115    FNAME indicates the file name of the original header.
5116    *LIMIT will be set to an address one past the end of the file.
5117    If the preconditions of the file are not satisfied, the buffer is
5118    freed and we return 0.  If the preconditions are satisfied, return
5119    the address of the buffer following the preconditions.  The buffer, in
5120    this case, should never be freed because various pieces of it will
5121    be referred to until all precompiled strings are output at the end of
5122    the run.  */
5123
5124 static char *
5125 check_precompiled (pcf, st, fname, limit)
5126      int pcf;
5127      struct stat *st;
5128      char *fname;
5129      char **limit;
5130 {
5131   int length = 0;
5132   char *buf;
5133   char *cp;
5134
5135   if (pcp_outfile)
5136     return 0;
5137
5138   if (S_ISREG (st->st_mode))
5139     {
5140       buf = xmalloc (st->st_size + 2);
5141       length = safe_read (pcf, buf, st->st_size);
5142       if (length < 0)
5143         goto nope;
5144     }
5145   else
5146     abort ();
5147
5148   if (length > 0 && buf[length-1] != '\n')
5149     buf[length++] = '\n';
5150   buf[length] = '\0';
5151
5152   *limit = buf + length;
5153
5154   /* File is in core.  Check the preconditions.  */
5155   if (!check_preconditions (buf))
5156     goto nope;
5157   for (cp = buf; *cp; cp++)
5158     ;
5159 #ifdef DEBUG_PCP
5160   fprintf (stderr, "Using preinclude %s\n", fname);
5161 #endif
5162   return cp + 1;
5163
5164  nope:
5165 #ifdef DEBUG_PCP
5166   fprintf (stderr, "Cannot use preinclude %s\n", fname);
5167 #endif
5168   free (buf);
5169   return 0;
5170 }
5171
5172 /* PREC (null terminated) points to the preconditions of a
5173    precompiled header.  These are a series of #define and #undef
5174    lines which must match the current contents of the hash
5175    table.  */
5176
5177 static int
5178 check_preconditions (prec)
5179      char *prec;
5180 {
5181   MACRODEF mdef;
5182   char *lineend;
5183
5184   while (*prec) {
5185     lineend = index (prec, '\n');
5186
5187     if (*prec++ != '#') {
5188       error ("Bad format encountered while reading precompiled file");
5189       return 0;
5190     }
5191     if (!strncmp (prec, "define", 6)) {
5192       HASHNODE *hp;
5193
5194       prec += 6;
5195       mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
5196
5197       if (mdef.defn == 0)
5198         abort ();
5199
5200       if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
5201           || (hp->type != T_MACRO && hp->type != T_CONST)
5202           || (hp->type == T_MACRO
5203               && !compare_defs (mdef.defn, hp->value.defn)
5204               && (mdef.defn->length != 2
5205                   || mdef.defn->expansion[0] != '\n'
5206                   || mdef.defn->expansion[1] != ' ')))
5207         return 0;
5208     } else if (!strncmp (prec, "undef", 5)) {
5209       char *name;
5210       int len;
5211
5212       prec += 5;
5213       while (is_hor_space[(U_CHAR) *prec])
5214         prec++;
5215       name = prec;
5216       while (is_idchar[(U_CHAR) *prec])
5217         prec++;
5218       len = prec - name;
5219
5220       if (lookup ((U_CHAR *) name, len, -1))
5221         return 0;
5222     } else {
5223       error ("Bad format encountered while reading precompiled file");
5224       return 0;
5225     }
5226     prec = lineend + 1;
5227   }
5228   /* They all passed successfully */
5229   return 1;
5230 }
5231
5232 /* Process the main body of a precompiled file.  BUF points to the
5233    string section of the file, following the preconditions.  LIMIT is one
5234    character past the end.  NAME is the name of the file being read
5235    in.  OP is the main output buffer.  */
5236
5237 static void
5238 pcfinclude (buf, limit, name, op)
5239      U_CHAR *buf, *limit, *name;
5240      FILE_BUF *op;
5241 {
5242   FILE_BUF tmpbuf;
5243   int nstrings;
5244   U_CHAR *cp = buf;
5245
5246   /* First in the file comes 4 bytes indicating the number of strings, */
5247   /* in network byte order. (MSB first).  */
5248   nstrings = *cp++;
5249   nstrings = (nstrings << 8) | *cp++;
5250   nstrings = (nstrings << 8) | *cp++;
5251   nstrings = (nstrings << 8) | *cp++;
5252
5253   /* Looping over each string...  */
5254   while (nstrings--) {
5255     U_CHAR *string_start;
5256     U_CHAR *endofthiskey;
5257     STRINGDEF *str;
5258     int nkeys;
5259
5260     /* Each string starts with a STRINGDEF structure (str), followed */
5261     /* by the text of the string (string_start) */
5262
5263     /* First skip to a longword boundary */
5264     /* ??? Why a 4-byte boundary?  On all machines? */
5265     /* NOTE: This works correctly even if HOST_WIDE_INT
5266        is narrower than a pointer.
5267        Do not try risky measures here to get another type to use!
5268        Do not include stddef.h--it will fail!  */
5269     if ((HOST_WIDE_INT) cp & 3)
5270       cp += 4 - ((HOST_WIDE_INT) cp & 3);
5271
5272     /* Now get the string.  */
5273     str = (STRINGDEF *) (GENERIC_PTR) cp;
5274     string_start = cp += sizeof (STRINGDEF);
5275
5276     for (; *cp; cp++)           /* skip the string */
5277       ;
5278
5279     /* We need to macro expand the string here to ensure that the
5280        proper definition environment is in place.  If it were only
5281        expanded when we find out it is needed, macros necessary for
5282        its proper expansion might have had their definitions changed.  */
5283     tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
5284     /* Lineno is already set in the precompiled file */
5285     str->contents = tmpbuf.buf;
5286     str->len = tmpbuf.length;
5287     str->writeflag = 0;
5288     str->filename = name;
5289     str->output_mark = outbuf.bufp - outbuf.buf;
5290
5291     str->chain = 0;
5292     *stringlist_tailp = str;
5293     stringlist_tailp = &str->chain;
5294
5295     /* Next comes a fourbyte number indicating the number of keys
5296        for this string.  */
5297     nkeys = *cp++;
5298     nkeys = (nkeys << 8) | *cp++;
5299     nkeys = (nkeys << 8) | *cp++;
5300     nkeys = (nkeys << 8) | *cp++;
5301
5302     /* If this number is -1, then the string is mandatory.  */
5303     if (nkeys == -1)
5304       str->writeflag = 1;
5305     else
5306       /* Otherwise, for each key, */
5307       for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
5308         KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
5309         HASHNODE *hp;
5310
5311         /* It starts with a KEYDEF structure */
5312         cp += sizeof (KEYDEF);
5313
5314         /* Find the end of the key.  At the end of this for loop we
5315            advance CP to the start of the next key using this variable.  */
5316         endofthiskey = cp + strlen ((char *) cp);
5317         kp->str = str;
5318
5319         /* Expand the key, and enter it into the hash table.  */
5320         tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
5321         tmpbuf.bufp = tmpbuf.buf;
5322
5323         while (is_hor_space[*tmpbuf.bufp])
5324           tmpbuf.bufp++;
5325         if (!is_idstart[*tmpbuf.bufp]
5326             || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
5327           str->writeflag = 1;
5328           continue;
5329         }
5330
5331         hp = lookup (tmpbuf.bufp, -1, -1);
5332         if (hp == NULL) {
5333           kp->chain = 0;
5334           install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
5335         }
5336         else if (hp->type == T_PCSTRING) {
5337           kp->chain = hp->value.keydef;
5338           hp->value.keydef = kp;
5339         }
5340         else
5341           str->writeflag = 1;
5342       }
5343   }
5344   /* This output_line_directive serves to switch us back to the current
5345      input file in case some of these strings get output (which will
5346      result in line directives for the header file being output).   */
5347   output_line_directive (&instack[indepth], op, 0, enter_file);
5348 }
5349
5350 /* Called from rescan when it hits a key for strings.  Mark them all
5351    used and clean up.  */
5352
5353 static void
5354 pcstring_used (hp)
5355      HASHNODE *hp;
5356 {
5357   KEYDEF *kp;
5358
5359   for (kp = hp->value.keydef; kp; kp = kp->chain)
5360     kp->str->writeflag = 1;
5361   delete_macro (hp);
5362 }
5363
5364 /* Write the output, interspersing precompiled strings in their
5365    appropriate places.  */
5366
5367 static void
5368 write_output ()
5369 {
5370   STRINGDEF *next_string;
5371   U_CHAR *cur_buf_loc;
5372   int line_directive_len = 80;
5373   char *line_directive = xmalloc (line_directive_len);
5374   int len;
5375
5376   /* In each run through the loop, either cur_buf_loc ==
5377      next_string_loc, in which case we print a series of strings, or
5378      it is less than next_string_loc, in which case we write some of
5379      the buffer.  */
5380   cur_buf_loc = outbuf.buf;
5381   next_string = stringlist;
5382
5383   while (cur_buf_loc < outbuf.bufp || next_string) {
5384     if (next_string
5385         && cur_buf_loc - outbuf.buf == next_string->output_mark) {
5386       if (next_string->writeflag) {
5387         len = 4 * strlen ((char *) next_string->filename) + 32;
5388         while (len > line_directive_len)
5389           line_directive = xrealloc (line_directive,
5390                                      line_directive_len *= 2);
5391         sprintf (line_directive, "\n# %d ", next_string->lineno);
5392         strcpy (quote_string (line_directive + strlen (line_directive),
5393                               (char *) next_string->filename),
5394                 "\n");
5395         safe_write (fileno (stdout), line_directive, strlen (line_directive));
5396         safe_write (fileno (stdout),
5397                     (char *) next_string->contents, next_string->len);
5398       }
5399       next_string = next_string->chain;
5400     }
5401     else {
5402       len = (next_string
5403              ? (next_string->output_mark
5404                 - (cur_buf_loc - outbuf.buf))
5405              : outbuf.bufp - cur_buf_loc);
5406
5407       safe_write (fileno (stdout), (char *) cur_buf_loc, len);
5408       cur_buf_loc += len;
5409     }
5410   }
5411   free (line_directive);
5412 }
5413
5414 /* Pass a directive through to the output file.
5415    BUF points to the contents of the directive, as a contiguous string.
5416    LIMIT points to the first character past the end of the directive.
5417    KEYWORD is the keyword-table entry for the directive.  */
5418
5419 static void
5420 pass_thru_directive (buf, limit, op, keyword)
5421      U_CHAR *buf, *limit;
5422      FILE_BUF *op;
5423      struct directive *keyword;
5424 {
5425   register unsigned keyword_length = keyword->length;
5426
5427   check_expand (op, 1 + keyword_length + (limit - buf));
5428   *op->bufp++ = '#';
5429   bcopy (keyword->name, (char *) op->bufp, keyword_length);
5430   op->bufp += keyword_length;
5431   if (limit != buf && buf[0] != ' ')
5432     *op->bufp++ = ' ';
5433   bcopy ((char *) buf, (char *) op->bufp, limit - buf);
5434   op->bufp += (limit - buf);
5435 #if 0
5436   *op->bufp++ = '\n';
5437   /* Count the line we have just made in the output,
5438      to get in sync properly.  */
5439   op->lineno++;
5440 #endif
5441 }
5442 \f
5443 /* The arglist structure is built by do_define to tell
5444    collect_definition where the argument names begin.  That
5445    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
5446    would contain pointers to the strings x, y, and z.
5447    Collect_definition would then build a DEFINITION node,
5448    with reflist nodes pointing to the places x, y, and z had
5449    appeared.  So the arglist is just convenience data passed
5450    between these two routines.  It is not kept around after
5451    the current #define has been processed and entered into the
5452    hash table.  */
5453
5454 struct arglist {
5455   struct arglist *next;
5456   U_CHAR *name;
5457   int length;
5458   int argno;
5459   char rest_args;
5460 };
5461
5462 /* Create a DEFINITION node from a #define directive.  Arguments are
5463    as for do_define.  */
5464
5465 static MACRODEF
5466 create_definition (buf, limit, op)
5467      U_CHAR *buf, *limit;
5468      FILE_BUF *op;
5469 {
5470   U_CHAR *bp;                   /* temp ptr into input buffer */
5471   U_CHAR *symname;              /* remember where symbol name starts */
5472   int sym_length;               /* and how long it is */
5473   int line = instack[indepth].lineno;
5474   char *file = instack[indepth].nominal_fname;
5475   int rest_args = 0;
5476
5477   DEFINITION *defn;
5478   int arglengths = 0;           /* Accumulate lengths of arg names
5479                                    plus number of args.  */
5480   MACRODEF mdef;
5481
5482   bp = buf;
5483
5484   while (is_hor_space[*bp])
5485     bp++;
5486
5487   symname = bp;                 /* remember where it starts */
5488   sym_length = check_macro_name (bp, "macro");
5489   bp += sym_length;
5490
5491   /* Lossage will occur if identifiers or control keywords are broken
5492      across lines using backslash.  This is not the right place to take
5493      care of that.  */
5494
5495   if (*bp == '(') {
5496     struct arglist *arg_ptrs = NULL;
5497     int argno = 0;
5498
5499     bp++;                       /* skip '(' */
5500     SKIP_WHITE_SPACE (bp);
5501
5502     /* Loop over macro argument names.  */
5503     while (*bp != ')') {
5504       struct arglist *temp;
5505
5506       temp = (struct arglist *) alloca (sizeof (struct arglist));
5507       temp->name = bp;
5508       temp->next = arg_ptrs;
5509       temp->argno = argno++;
5510       temp->rest_args = 0;
5511       arg_ptrs = temp;
5512
5513       if (rest_args)
5514         pedwarn ("another parameter follows `%s'",
5515                  rest_extension);
5516
5517       if (!is_idstart[*bp])
5518         pedwarn ("invalid character in macro parameter name");
5519
5520       /* Find the end of the arg name.  */
5521       while (is_idchar[*bp]) {
5522         bp++;
5523         /* do we have a "special" rest-args extension here? */
5524         if (limit - bp > REST_EXTENSION_LENGTH &&
5525             bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
5526           rest_args = 1;
5527           temp->rest_args = 1;
5528           break;
5529         }
5530       }
5531       temp->length = bp - temp->name;
5532       if (rest_args == 1)
5533         bp += REST_EXTENSION_LENGTH;
5534       arglengths += temp->length + 2;
5535       SKIP_WHITE_SPACE (bp);
5536       if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
5537         error ("badly punctuated parameter list in `#define'");
5538         goto nope;
5539       }
5540       if (*bp == ',') {
5541         bp++;
5542         SKIP_WHITE_SPACE (bp);
5543         /* A comma at this point can only be followed by an identifier.  */
5544         if (!is_idstart[*bp]) {
5545           error ("badly punctuated parameter list in `#define'");
5546           goto nope;
5547         }
5548       }
5549       if (bp >= limit) {
5550         error ("unterminated parameter list in `#define'");
5551         goto nope;
5552       }
5553       {
5554         struct arglist *otemp;
5555
5556         for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
5557           if (temp->length == otemp->length &&
5558               bcmp (temp->name, otemp->name, temp->length) == 0) {
5559               error ("duplicate argument name `%.*s' in `#define'",
5560                      temp->length, temp->name);
5561               goto nope;
5562           }
5563       }
5564     }
5565
5566     ++bp;                       /* skip paren */
5567     SKIP_WHITE_SPACE (bp);
5568     /* now everything from bp before limit is the definition.  */
5569     defn = collect_expansion (bp, limit, argno, arg_ptrs);
5570     defn->rest_args = rest_args;
5571
5572     /* Now set defn->args.argnames to the result of concatenating
5573        the argument names in reverse order
5574        with comma-space between them.  */
5575     defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
5576     {
5577       struct arglist *temp;
5578       int i = 0;
5579       for (temp = arg_ptrs; temp; temp = temp->next) {
5580         bcopy (temp->name, &defn->args.argnames[i], temp->length);
5581         i += temp->length;
5582         if (temp->next != 0) {
5583           defn->args.argnames[i++] = ',';
5584           defn->args.argnames[i++] = ' ';
5585         }
5586       }
5587       defn->args.argnames[i] = 0;
5588     }
5589   } else {
5590     /* Simple expansion or empty definition.  */
5591
5592     if (bp < limit)
5593       {
5594         if (is_hor_space[*bp]) {
5595           bp++;
5596           SKIP_WHITE_SPACE (bp);
5597         } else if (sym_length) {
5598           switch (*bp) {
5599             case '!':  case '"':  case '#':  case '%':  case '&':  case '\'':
5600             case ')':  case '*':  case '+':  case ',':  case '-':  case '.':
5601             case '/':  case ':':  case ';':  case '<':  case '=':  case '>':
5602             case '?':  case '[':  case '\\': case ']':  case '^':  case '{':
5603             case '|':  case '}':  case '~':
5604               warning ("missing white space after `#define %.*s'",
5605                        sym_length, symname);
5606               break;
5607
5608             default:
5609               pedwarn ("missing white space after `#define %.*s'",
5610                        sym_length, symname);
5611               break;
5612           }
5613         }
5614       }
5615     /* Now everything from bp before limit is the definition.  */
5616     defn = collect_expansion (bp, limit, -1, NULL_PTR);
5617     defn->args.argnames = (U_CHAR *) "";
5618   }
5619
5620   defn->line = line;
5621   defn->file = file;
5622
5623   /* OP is null if this is a predefinition */
5624   defn->predefined = !op;
5625   mdef.defn = defn;
5626   mdef.symnam = symname;
5627   mdef.symlen = sym_length;
5628
5629   return mdef;
5630
5631  nope:
5632   mdef.defn = 0;
5633   return mdef;
5634 }
5635
5636 /* Process a #define directive.
5637 BUF points to the contents of the #define directive, as a contiguous string.
5638 LIMIT points to the first character past the end of the definition.
5639 KEYWORD is the keyword-table entry for #define.  */
5640
5641 static int
5642 do_define (buf, limit, op, keyword)
5643      U_CHAR *buf, *limit;
5644      FILE_BUF *op;
5645      struct directive *keyword;
5646 {
5647   int hashcode;
5648   MACRODEF mdef;
5649
5650   /* If this is a precompiler run (with -pcp) pass thru #define directives.  */
5651   if (pcp_outfile && op)
5652     pass_thru_directive (buf, limit, op, keyword);
5653
5654   mdef = create_definition (buf, limit, op);
5655   if (mdef.defn == 0)
5656     goto nope;
5657
5658   hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
5659
5660   {
5661     HASHNODE *hp;
5662     if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) {
5663       int ok = 0;
5664       /* Redefining a precompiled key is ok.  */
5665       if (hp->type == T_PCSTRING)
5666         ok = 1;
5667       /* Redefining a macro is ok if the definitions are the same.  */
5668       else if (hp->type == T_MACRO)
5669         ok = ! compare_defs (mdef.defn, hp->value.defn);
5670       /* Redefining a constant is ok with -D.  */
5671       else if (hp->type == T_CONST)
5672         ok = ! done_initializing;
5673       /* Print the warning if it's not ok.  */
5674       if (!ok) {
5675         /* If we are passing through #define and #undef directives, do
5676            that for this re-definition now.  */
5677         if (debug_output && op)
5678           pass_thru_directive (buf, limit, op, keyword);
5679
5680         pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
5681         if (hp->type == T_MACRO)
5682           pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
5683                                       "this is the location of the previous definition");
5684       }
5685       /* Replace the old definition.  */
5686       hp->type = T_MACRO;
5687       hp->value.defn = mdef.defn;
5688     } else {
5689       /* If we are passing through #define and #undef directives, do
5690          that for this new definition now.  */
5691       if (debug_output && op)
5692         pass_thru_directive (buf, limit, op, keyword);
5693       install (mdef.symnam, mdef.symlen, T_MACRO,
5694                (char *) mdef.defn, hashcode);
5695     }
5696   }
5697
5698   return 0;
5699
5700 nope:
5701
5702   return 1;
5703 }
5704 \f
5705 /* Check a purported macro name SYMNAME, and yield its length.
5706    USAGE is the kind of name this is intended for.  */
5707
5708 static int
5709 check_macro_name (symname, usage)
5710      U_CHAR *symname;
5711      char *usage;
5712 {
5713   U_CHAR *p;
5714   int sym_length;
5715
5716   for (p = symname; is_idchar[*p]; p++)
5717     ;
5718   sym_length = p - symname;
5719   if (sym_length == 0)
5720     error ("invalid %s name", usage);
5721   else if (!is_idstart[*symname]
5722            || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
5723     error ("invalid %s name `%.*s'", usage, sym_length, symname);
5724   return sym_length;
5725 }
5726
5727 /* Return zero if two DEFINITIONs are isomorphic.  */
5728
5729 static int
5730 compare_defs (d1, d2)
5731      DEFINITION *d1, *d2;
5732 {
5733   register struct reflist *a1, *a2;
5734   register U_CHAR *p1 = d1->expansion;
5735   register U_CHAR *p2 = d2->expansion;
5736   int first = 1;
5737
5738   if (d1->nargs != d2->nargs)
5739     return 1;
5740   if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
5741     return 1;
5742   for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
5743        a1 = a1->next, a2 = a2->next) {
5744     if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
5745           || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
5746         || a1->argno != a2->argno
5747         || a1->stringify != a2->stringify
5748         || a1->raw_before != a2->raw_before
5749         || a1->raw_after != a2->raw_after)
5750       return 1;
5751     first = 0;
5752     p1 += a1->nchars;
5753     p2 += a2->nchars;
5754   }
5755   if (a1 != a2)
5756     return 1;
5757   if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
5758                      p2, d2->length - (p2 - d2->expansion), 1))
5759     return 1;
5760   return 0;
5761 }
5762
5763 /* Return 1 if two parts of two macro definitions are effectively different.
5764    One of the parts starts at BEG1 and has LEN1 chars;
5765    the other has LEN2 chars at BEG2.
5766    Any sequence of whitespace matches any other sequence of whitespace.
5767    FIRST means these parts are the first of a macro definition;
5768     so ignore leading whitespace entirely.
5769    LAST means these parts are the last of a macro definition;
5770     so ignore trailing whitespace entirely.  */
5771
5772 static int
5773 comp_def_part (first, beg1, len1, beg2, len2, last)
5774      int first;
5775      U_CHAR *beg1, *beg2;
5776      int len1, len2;
5777      int last;
5778 {
5779   register U_CHAR *end1 = beg1 + len1;
5780   register U_CHAR *end2 = beg2 + len2;
5781   if (first) {
5782     while (beg1 != end1 && is_space[*beg1]) beg1++;
5783     while (beg2 != end2 && is_space[*beg2]) beg2++;
5784   }
5785   if (last) {
5786     while (beg1 != end1 && is_space[end1[-1]]) end1--;
5787     while (beg2 != end2 && is_space[end2[-1]]) end2--;
5788   }
5789   while (beg1 != end1 && beg2 != end2) {
5790     if (is_space[*beg1] && is_space[*beg2]) {
5791       while (beg1 != end1 && is_space[*beg1]) beg1++;
5792       while (beg2 != end2 && is_space[*beg2]) beg2++;
5793     } else if (*beg1 == *beg2) {
5794       beg1++; beg2++;
5795     } else break;
5796   }
5797   return (beg1 != end1) || (beg2 != end2);
5798 }
5799 \f
5800 /* Read a replacement list for a macro with parameters.
5801    Build the DEFINITION structure.
5802    Reads characters of text starting at BUF until END.
5803    ARGLIST specifies the formal parameters to look for
5804    in the text of the definition; NARGS is the number of args
5805    in that list, or -1 for a macro name that wants no argument list.
5806    MACRONAME is the macro name itself (so we can avoid recursive expansion)
5807    and NAMELEN is its length in characters.
5808
5809 Note that comments, backslash-newlines, and leading white space
5810 have already been deleted from the argument.  */
5811
5812 /* If there is no trailing whitespace, a Newline Space is added at the end
5813    to prevent concatenation that would be contrary to the standard.  */
5814
5815 static DEFINITION *
5816 collect_expansion (buf, end, nargs, arglist)
5817      U_CHAR *buf, *end;
5818      int nargs;
5819      struct arglist *arglist;
5820 {
5821   DEFINITION *defn;
5822   register U_CHAR *p, *limit, *lastp, *exp_p;
5823   struct reflist *endpat = NULL;
5824   /* Pointer to first nonspace after last ## seen.  */
5825   U_CHAR *concat = 0;
5826   /* Pointer to first nonspace after last single-# seen.  */
5827   U_CHAR *stringify = 0;
5828   /* How those tokens were spelled.  */
5829   enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
5830   enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
5831   int maxsize;
5832   int expected_delimiter = '\0';
5833
5834   /* Scan thru the replacement list, ignoring comments and quoted
5835      strings, picking up on the macro calls.  It does a linear search
5836      thru the arg list on every potential symbol.  Profiling might say
5837      that something smarter should happen.  */
5838
5839   if (end < buf)
5840     abort ();
5841
5842   /* Find the beginning of the trailing whitespace.  */
5843   limit = end;
5844   p = buf;
5845   while (p < limit && is_space[limit[-1]]) limit--;
5846
5847   /* Allocate space for the text in the macro definition.
5848      Each input char may or may not need 1 byte,
5849      so this is an upper bound.
5850      The extra 3 are for invented trailing newline-marker and final null.  */
5851   maxsize = (sizeof (DEFINITION)
5852              + (limit - p) + 3);
5853   defn = (DEFINITION *) xcalloc (1, maxsize);
5854
5855   defn->nargs = nargs;
5856   exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
5857   lastp = exp_p;
5858
5859   if (p[0] == '#'
5860       ? p[1] == '#'
5861       : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
5862     error ("`##' at start of macro definition");
5863     p += p[0] == '#' ? 2 : 4;
5864   }
5865
5866   /* Process the main body of the definition.  */
5867   while (p < limit) {
5868     int skipped_arg = 0;
5869     register U_CHAR c = *p++;
5870
5871     *exp_p++ = c;
5872
5873     if (!traditional) {
5874       switch (c) {
5875       case '\'':
5876       case '\"':
5877         if (expected_delimiter != '\0') {
5878           if (c == expected_delimiter)
5879             expected_delimiter = '\0';
5880         } else
5881           expected_delimiter = c;
5882         break;
5883
5884       case '\\':
5885         if (p < limit && expected_delimiter) {
5886           /* In a string, backslash goes through
5887              and makes next char ordinary.  */
5888           *exp_p++ = *p++;
5889         }
5890         break;
5891
5892       case '%':
5893         if (!expected_delimiter && *p == ':') {
5894           /* %: is not a digraph if preceded by an odd number of '<'s.  */
5895           U_CHAR *p0 = p - 1;
5896           while (buf < p0 && p0[-1] == '<')
5897             p0--;
5898           if ((p - p0) & 1) {
5899             /* Treat %:%: as ## and %: as #.  */
5900             if (p[1] == '%' && p[2] == ':') {
5901               p += 2;
5902               goto sharp_sharp_token;
5903             }
5904             if (nargs >= 0) {
5905               p++;
5906               goto sharp_token;
5907             }
5908           }
5909         }
5910         break;
5911
5912       case '#':
5913         /* # is ordinary inside a string.  */
5914         if (expected_delimiter)
5915           break;
5916         if (*p == '#') {
5917         sharp_sharp_token:
5918           /* ##: concatenate preceding and following tokens.  */
5919           /* Take out the first #, discard preceding whitespace.  */
5920           exp_p--;
5921           while (exp_p > lastp && is_hor_space[exp_p[-1]])
5922             --exp_p;
5923           /* Skip the second #.  */
5924           p++;
5925           concat_sharp_token_type = c;
5926           if (is_hor_space[*p]) {
5927             concat_sharp_token_type = c + 1;
5928             p++;
5929             SKIP_WHITE_SPACE (p);
5930           }
5931           concat = p;
5932           if (p == limit)
5933             error ("`##' at end of macro definition");
5934         } else if (nargs >= 0) {
5935           /* Single #: stringify following argument ref.
5936              Don't leave the # in the expansion.  */
5937         sharp_token:
5938           exp_p--;
5939           stringify_sharp_token_type = c;
5940           if (is_hor_space[*p]) {
5941             stringify_sharp_token_type = c + 1;
5942             p++;
5943             SKIP_WHITE_SPACE (p);
5944           }
5945           if (! is_idstart[*p] || nargs == 0)
5946             error ("`#' operator is not followed by a macro argument name");
5947           else
5948             stringify = p;
5949         }
5950         break;
5951       }
5952     } else {
5953       /* In -traditional mode, recognize arguments inside strings and
5954          and character constants, and ignore special properties of #.
5955          Arguments inside strings are considered "stringified", but no
5956          extra quote marks are supplied.  */
5957       switch (c) {
5958       case '\'':
5959       case '\"':
5960         if (expected_delimiter != '\0') {
5961           if (c == expected_delimiter)
5962             expected_delimiter = '\0';
5963         } else
5964           expected_delimiter = c;
5965         break;
5966
5967       case '\\':
5968         /* Backslash quotes delimiters and itself, but not macro args.  */
5969         if (expected_delimiter != 0 && p < limit
5970             && (*p == expected_delimiter || *p == '\\')) {
5971           *exp_p++ = *p++;
5972           continue;
5973         }
5974         break;
5975
5976       case '/':
5977         if (expected_delimiter != '\0') /* No comments inside strings.  */
5978           break;
5979         if (*p == '*') {
5980           /* If we find a comment that wasn't removed by handle_directive,
5981              this must be -traditional.  So replace the comment with
5982              nothing at all.  */
5983           exp_p--;
5984           while (++p < limit) {
5985             if (p[0] == '*' && p[1] == '/') {
5986               p += 2;
5987               break;
5988             }
5989           }
5990 #if 0
5991           /* Mark this as a concatenation-point, as if it had been ##.  */
5992           concat = p;
5993 #endif
5994         }
5995         break;
5996       }
5997     }
5998
5999     /* Handle the start of a symbol.  */
6000     if (is_idchar[c] && nargs > 0) {
6001       U_CHAR *id_beg = p - 1;
6002       int id_len;
6003
6004       --exp_p;
6005       while (p != limit && is_idchar[*p]) p++;
6006       id_len = p - id_beg;
6007
6008       if (is_idstart[c]) {
6009         register struct arglist *arg;
6010
6011         for (arg = arglist; arg != NULL; arg = arg->next) {
6012           struct reflist *tpat;
6013
6014           if (arg->name[0] == c
6015               && arg->length == id_len
6016               && bcmp (arg->name, id_beg, id_len) == 0) {
6017             enum sharp_token_type tpat_stringify;
6018             if (expected_delimiter) {
6019               if (warn_stringify) {
6020                 if (traditional) {
6021                   warning ("macro argument `%.*s' is stringified.",
6022                            id_len, arg->name);
6023                 } else {
6024                   warning ("macro arg `%.*s' would be stringified with -traditional.",
6025                            id_len, arg->name);
6026                 }
6027               }
6028               /* If ANSI, don't actually substitute inside a string.  */
6029               if (!traditional)
6030                 break;
6031               tpat_stringify = SHARP_TOKEN;
6032             } else {
6033               tpat_stringify
6034                 = (stringify == id_beg
6035                    ? stringify_sharp_token_type : NO_SHARP_TOKEN);
6036             }
6037             /* make a pat node for this arg and append it to the end of
6038                the pat list */
6039             tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
6040             tpat->next = NULL;
6041             tpat->raw_before
6042               = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
6043             tpat->raw_after = NO_SHARP_TOKEN;
6044             tpat->rest_args = arg->rest_args;
6045             tpat->stringify = tpat_stringify;
6046
6047             if (endpat == NULL)
6048               defn->pattern = tpat;
6049             else
6050               endpat->next = tpat;
6051             endpat = tpat;
6052
6053             tpat->argno = arg->argno;
6054             tpat->nchars = exp_p - lastp;
6055             {
6056               register U_CHAR *p1 = p;
6057               SKIP_WHITE_SPACE (p1);
6058               if (p1[0]=='#'
6059                   ? p1[1]=='#'
6060                   : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
6061                 tpat->raw_after = p1[0] + (p != p1);
6062             }
6063             lastp = exp_p;      /* place to start copying from next time */
6064             skipped_arg = 1;
6065             break;
6066           }
6067         }
6068       }
6069
6070       /* If this was not a macro arg, copy it into the expansion.  */
6071       if (! skipped_arg) {
6072         register U_CHAR *lim1 = p;
6073         p = id_beg;
6074         while (p != lim1)
6075           *exp_p++ = *p++;
6076         if (stringify == id_beg)
6077           error ("`#' operator should be followed by a macro argument name");
6078       }
6079     }
6080   }
6081
6082   if (!traditional && expected_delimiter == 0) {
6083     /* If ANSI, put in a newline-space marker to prevent token pasting.
6084        But not if "inside a string" (which in ANSI mode happens only for
6085        -D option).  */
6086     *exp_p++ = '\n';
6087     *exp_p++ = ' ';
6088   }
6089
6090   *exp_p = '\0';
6091
6092   defn->length = exp_p - defn->expansion;
6093
6094   /* Crash now if we overrun the allocated size.  */
6095   if (defn->length + 1 > maxsize)
6096     abort ();
6097
6098 #if 0
6099 /* This isn't worth the time it takes.  */
6100   /* give back excess storage */
6101   defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
6102 #endif
6103
6104   return defn;
6105 }
6106 \f
6107 static int
6108 do_assert (buf, limit, op, keyword)
6109      U_CHAR *buf, *limit;
6110      FILE_BUF *op;
6111      struct directive *keyword;
6112 {
6113   U_CHAR *bp;                   /* temp ptr into input buffer */
6114   U_CHAR *symname;              /* remember where symbol name starts */
6115   int sym_length;               /* and how long it is */
6116   struct arglist *tokens = NULL;
6117
6118   if (pedantic && done_initializing && !instack[indepth].system_header_p)
6119     pedwarn ("ANSI C does not allow `#assert'");
6120
6121   bp = buf;
6122
6123   while (is_hor_space[*bp])
6124     bp++;
6125
6126   symname = bp;                 /* remember where it starts */
6127   sym_length = check_macro_name (bp, "assertion");
6128   bp += sym_length;
6129   /* #define doesn't do this, but we should.  */
6130   SKIP_WHITE_SPACE (bp);
6131
6132   /* Lossage will occur if identifiers or control tokens are broken
6133      across lines using backslash.  This is not the right place to take
6134      care of that.  */
6135
6136   if (*bp != '(') {
6137     error ("missing token-sequence in `#assert'");
6138     return 1;
6139   }
6140
6141   {
6142     int error_flag = 0;
6143
6144     bp++;                       /* skip '(' */
6145     SKIP_WHITE_SPACE (bp);
6146
6147     tokens = read_token_list (&bp, limit, &error_flag);
6148     if (error_flag)
6149       return 1;
6150     if (tokens == 0) {
6151       error ("empty token-sequence in `#assert'");
6152       return 1;
6153     }
6154
6155     ++bp;                       /* skip paren */
6156     SKIP_WHITE_SPACE (bp);
6157   }
6158
6159   /* If this name isn't already an assertion name, make it one.
6160      Error if it was already in use in some other way.  */
6161
6162   {
6163     ASSERTION_HASHNODE *hp;
6164     int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6165     struct tokenlist_list *value
6166       = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6167
6168     hp = assertion_lookup (symname, sym_length, hashcode);
6169     if (hp == NULL) {
6170       if (sym_length == 7 && ! bcmp (symname, "defined", 7))
6171         error ("`defined' redefined as assertion");
6172       hp = assertion_install (symname, sym_length, hashcode);
6173     }
6174
6175     /* Add the spec'd token-sequence to the list of such.  */
6176     value->tokens = tokens;
6177     value->next = hp->value;
6178     hp->value = value;
6179   }
6180
6181   return 0;
6182 }
6183 \f
6184 static int
6185 do_unassert (buf, limit, op, keyword)
6186      U_CHAR *buf, *limit;
6187      FILE_BUF *op;
6188      struct directive *keyword;
6189 {
6190   U_CHAR *bp;                   /* temp ptr into input buffer */
6191   U_CHAR *symname;              /* remember where symbol name starts */
6192   int sym_length;               /* and how long it is */
6193
6194   struct arglist *tokens = NULL;
6195   int tokens_specified = 0;
6196
6197   if (pedantic && done_initializing && !instack[indepth].system_header_p)
6198     pedwarn ("ANSI C does not allow `#unassert'");
6199
6200   bp = buf;
6201
6202   while (is_hor_space[*bp])
6203     bp++;
6204
6205   symname = bp;                 /* remember where it starts */
6206   sym_length = check_macro_name (bp, "assertion");
6207   bp += sym_length;
6208   /* #define doesn't do this, but we should.  */
6209   SKIP_WHITE_SPACE (bp);
6210
6211   /* Lossage will occur if identifiers or control tokens are broken
6212      across lines using backslash.  This is not the right place to take
6213      care of that.  */
6214
6215   if (*bp == '(') {
6216     int error_flag = 0;
6217
6218     bp++;                       /* skip '(' */
6219     SKIP_WHITE_SPACE (bp);
6220
6221     tokens = read_token_list (&bp, limit, &error_flag);
6222     if (error_flag)
6223       return 1;
6224     if (tokens == 0) {
6225       error ("empty token list in `#unassert'");
6226       return 1;
6227     }
6228
6229     tokens_specified = 1;
6230
6231     ++bp;                       /* skip paren */
6232     SKIP_WHITE_SPACE (bp);
6233   }
6234
6235   {
6236     ASSERTION_HASHNODE *hp;
6237     int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6238     struct tokenlist_list *tail, *prev;
6239
6240     hp = assertion_lookup (symname, sym_length, hashcode);
6241     if (hp == NULL)
6242       return 1;
6243
6244     /* If no token list was specified, then eliminate this assertion
6245        entirely.  */
6246     if (! tokens_specified) {
6247       struct tokenlist_list *next;
6248       for (tail = hp->value; tail; tail = next) {
6249         next = tail->next;
6250         free_token_list (tail->tokens);
6251         free (tail);
6252       }
6253       delete_assertion (hp);
6254     } else {
6255       /* If a list of tokens was given, then delete any matching list.  */
6256
6257       tail = hp->value;
6258       prev = 0;
6259       while (tail) {
6260         struct tokenlist_list *next = tail->next;
6261         if (compare_token_lists (tail->tokens, tokens)) {
6262           if (prev)
6263             prev->next = next;
6264           else
6265             hp->value = tail->next;
6266           free_token_list (tail->tokens);
6267           free (tail);
6268         } else {
6269           prev = tail;
6270         }
6271         tail = next;
6272       }
6273     }
6274   }
6275
6276   return 0;
6277 }
6278 \f
6279 /* Test whether there is an assertion named NAME
6280    and optionally whether it has an asserted token list TOKENS.
6281    NAME is not null terminated; its length is SYM_LENGTH.
6282    If TOKENS_SPECIFIED is 0, then don't check for any token list.  */
6283
6284 int
6285 check_assertion (name, sym_length, tokens_specified, tokens)
6286      U_CHAR *name;
6287      int sym_length;
6288      int tokens_specified;
6289      struct arglist *tokens;
6290 {
6291   ASSERTION_HASHNODE *hp;
6292   int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6293
6294   if (pedantic && !instack[indepth].system_header_p)
6295     pedwarn ("ANSI C does not allow testing assertions");
6296
6297   hp = assertion_lookup (name, sym_length, hashcode);
6298   if (hp == NULL)
6299     /* It is not an assertion; just return false.  */
6300     return 0;
6301
6302   /* If no token list was specified, then value is 1.  */
6303   if (! tokens_specified)
6304     return 1;
6305
6306   {
6307     struct tokenlist_list *tail;
6308
6309     tail = hp->value;
6310
6311     /* If a list of tokens was given,
6312        then succeed if the assertion records a matching list.  */
6313
6314     while (tail) {
6315       if (compare_token_lists (tail->tokens, tokens))
6316         return 1;
6317       tail = tail->next;
6318     }
6319
6320     /* Fail if the assertion has no matching list.  */
6321     return 0;
6322   }
6323 }
6324
6325 /* Compare two lists of tokens for equality including order of tokens.  */
6326
6327 static int
6328 compare_token_lists (l1, l2)
6329      struct arglist *l1, *l2;
6330 {
6331   while (l1 && l2) {
6332     if (l1->length != l2->length)
6333       return 0;
6334     if (bcmp (l1->name, l2->name, l1->length))
6335       return 0;
6336     l1 = l1->next;
6337     l2 = l2->next;
6338   }
6339
6340   /* Succeed if both lists end at the same time.  */
6341   return l1 == l2;
6342 }
6343 \f
6344 /* Read a space-separated list of tokens ending in a close parenthesis.
6345    Return a list of strings, in the order they were written.
6346    (In case of error, return 0 and store -1 in *ERROR_FLAG.)
6347    Parse the text starting at *BPP, and update *BPP.
6348    Don't parse beyond LIMIT.  */
6349
6350 static struct arglist *
6351 read_token_list (bpp, limit, error_flag)
6352      U_CHAR **bpp;
6353      U_CHAR *limit;
6354      int *error_flag;
6355 {
6356   struct arglist *token_ptrs = 0;
6357   U_CHAR *bp = *bpp;
6358   int depth = 1;
6359
6360   *error_flag = 0;
6361
6362   /* Loop over the assertion value tokens.  */
6363   while (depth > 0) {
6364     struct arglist *temp;
6365     int eofp = 0;
6366     U_CHAR *beg = bp;
6367
6368     /* Find the end of the token.  */
6369     if (*bp == '(') {
6370       bp++;
6371       depth++;
6372     } else if (*bp == ')') {
6373       depth--;
6374       if (depth == 0)
6375         break;
6376       bp++;
6377     } else if (*bp == '"' || *bp == '\'')
6378       bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
6379     else
6380       while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
6381              && *bp != '"' && *bp != '\'' && bp != limit)
6382         bp++;
6383
6384     temp = (struct arglist *) xmalloc (sizeof (struct arglist));
6385     temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
6386     bcopy ((char *) beg, (char *) temp->name, bp - beg);
6387     temp->name[bp - beg] = 0;
6388     temp->next = token_ptrs;
6389     token_ptrs = temp;
6390     temp->length = bp - beg;
6391
6392     SKIP_WHITE_SPACE (bp);
6393
6394     if (bp >= limit) {
6395       error ("unterminated token sequence in `#assert' or `#unassert'");
6396       *error_flag = -1;
6397       return 0;
6398     }
6399   }
6400   *bpp = bp;
6401
6402   /* We accumulated the names in reverse order.
6403      Now reverse them to get the proper order.  */
6404   {
6405     register struct arglist *prev = 0, *this, *next;
6406     for (this = token_ptrs; this; this = next) {
6407       next = this->next;
6408       this->next = prev;
6409       prev = this;
6410     }
6411     return prev;
6412   }
6413 }
6414
6415 static void
6416 free_token_list (tokens)
6417      struct arglist *tokens;
6418 {
6419   while (tokens) {
6420     struct arglist *next = tokens->next;
6421     free (tokens->name);
6422     free (tokens);
6423     tokens = next;
6424   }
6425 }
6426 \f
6427 /* Install a name in the assertion hash table.
6428
6429    If LEN is >= 0, it is the length of the name.
6430    Otherwise, compute the length by scanning the entire name.
6431
6432    If HASH is >= 0, it is the precomputed hash code.
6433    Otherwise, compute the hash code.  */
6434
6435 static ASSERTION_HASHNODE *
6436 assertion_install (name, len, hash)
6437      U_CHAR *name;
6438      int len;
6439      int hash;
6440 {
6441   register ASSERTION_HASHNODE *hp;
6442   register int i, bucket;
6443   register U_CHAR *p, *q;
6444
6445   i = sizeof (ASSERTION_HASHNODE) + len + 1;
6446   hp = (ASSERTION_HASHNODE *) xmalloc (i);
6447   bucket = hash;
6448   hp->bucket_hdr = &assertion_hashtab[bucket];
6449   hp->next = assertion_hashtab[bucket];
6450   assertion_hashtab[bucket] = hp;
6451   hp->prev = NULL;
6452   if (hp->next != NULL)
6453     hp->next->prev = hp;
6454   hp->length = len;
6455   hp->value = 0;
6456   hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
6457   p = hp->name;
6458   q = name;
6459   for (i = 0; i < len; i++)
6460     *p++ = *q++;
6461   hp->name[len] = 0;
6462   return hp;
6463 }
6464
6465 /* Find the most recent hash node for name name (ending with first
6466    non-identifier char) installed by install
6467
6468    If LEN is >= 0, it is the length of the name.
6469    Otherwise, compute the length by scanning the entire name.
6470
6471    If HASH is >= 0, it is the precomputed hash code.
6472    Otherwise, compute the hash code.  */
6473
6474 static ASSERTION_HASHNODE *
6475 assertion_lookup (name, len, hash)
6476      U_CHAR *name;
6477      int len;
6478      int hash;
6479 {
6480   register ASSERTION_HASHNODE *bucket;
6481
6482   bucket = assertion_hashtab[hash];
6483   while (bucket) {
6484     if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
6485       return bucket;
6486     bucket = bucket->next;
6487   }
6488   return NULL;
6489 }
6490
6491 static void
6492 delete_assertion (hp)
6493      ASSERTION_HASHNODE *hp;
6494 {
6495
6496   if (hp->prev != NULL)
6497     hp->prev->next = hp->next;
6498   if (hp->next != NULL)
6499     hp->next->prev = hp->prev;
6500
6501   /* Make sure that the bucket chain header that the deleted guy was
6502      on points to the right thing afterwards.  */
6503   if (hp == *hp->bucket_hdr)
6504     *hp->bucket_hdr = hp->next;
6505
6506   free (hp);
6507 }
6508 \f
6509 /*
6510  * interpret #line directive.  Remembers previously seen fnames
6511  * in its very own hash table.
6512  */
6513 #define FNAME_HASHSIZE 37
6514
6515 static int
6516 do_line (buf, limit, op, keyword)
6517      U_CHAR *buf, *limit;
6518      FILE_BUF *op;
6519      struct directive *keyword;
6520 {
6521   register U_CHAR *bp;
6522   FILE_BUF *ip = &instack[indepth];
6523   FILE_BUF tem;
6524   int new_lineno;
6525   enum file_change_code file_change = same_file;
6526
6527   /* Expand any macros.  */
6528   tem = expand_to_temp_buffer (buf, limit, 0, 0);
6529
6530   /* Point to macroexpanded line, which is null-terminated now.  */
6531   bp = tem.buf;
6532   SKIP_WHITE_SPACE (bp);
6533
6534   if (!isdigit (*bp)) {
6535     error ("invalid format `#line' directive");
6536     return 0;
6537   }
6538
6539   /* The Newline at the end of this line remains to be processed.
6540      To put the next line at the specified line number,
6541      we must store a line number now that is one less.  */
6542   new_lineno = atoi ((char *) bp) - 1;
6543
6544   /* NEW_LINENO is one less than the actual line number here.  */
6545   if (pedantic && new_lineno < 0)
6546     pedwarn ("line number out of range in `#line' directive");
6547
6548   /* skip over the line number.  */
6549   while (isdigit (*bp))
6550     bp++;
6551
6552 #if 0 /* #line 10"foo.c" is supposed to be allowed.  */
6553   if (*bp && !is_space[*bp]) {
6554     error ("invalid format `#line' directive");
6555     return;
6556   }
6557 #endif
6558
6559   SKIP_WHITE_SPACE (bp);
6560
6561   if (*bp == '\"') {
6562     static HASHNODE *fname_table[FNAME_HASHSIZE];
6563     HASHNODE *hp, **hash_bucket;
6564     U_CHAR *fname, *p;
6565     int fname_length;
6566
6567     fname = ++bp;
6568
6569     /* Turn the file name, which is a character string literal,
6570        into a null-terminated string.  Do this in place.  */
6571     p = bp;
6572     for (;;)
6573       switch ((*p++ = *bp++)) {
6574       case '\0':
6575         error ("invalid format `#line' directive");
6576         return 0;
6577
6578       case '\\':
6579         {
6580           char *bpc = (char *) bp;
6581           HOST_WIDE_INT c = parse_escape (&bpc, (HOST_WIDE_INT) (U_CHAR) (-1));
6582           bp = (U_CHAR *) bpc;
6583           if (c < 0)
6584             p--;
6585           else
6586             p[-1] = c;
6587         }
6588         break;
6589
6590       case '\"':
6591         p[-1] = 0;
6592         goto fname_done;
6593       }
6594   fname_done:
6595     fname_length = p - fname;
6596
6597     SKIP_WHITE_SPACE (bp);
6598     if (*bp) {
6599       if (pedantic)
6600         pedwarn ("garbage at end of `#line' directive");
6601       if (*bp == '1')
6602         file_change = enter_file;
6603       else if (*bp == '2')
6604         file_change = leave_file;
6605       else if (*bp == '3')
6606         ip->system_header_p = 1;
6607       else if (*bp == '4')
6608         ip->system_header_p = 2;
6609       else {
6610         error ("invalid format `#line' directive");
6611         return 0;
6612       }
6613
6614       bp++;
6615       SKIP_WHITE_SPACE (bp);
6616       if (*bp == '3') {
6617         ip->system_header_p = 1;
6618         bp++;
6619         SKIP_WHITE_SPACE (bp);
6620       }
6621       if (*bp == '4') {
6622         ip->system_header_p = 2;
6623         bp++;
6624         SKIP_WHITE_SPACE (bp);
6625       }
6626       if (*bp) {
6627         error ("invalid format `#line' directive");
6628         return 0;
6629       }
6630     }
6631
6632     hash_bucket =
6633       &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
6634     for (hp = *hash_bucket; hp != NULL; hp = hp->next)
6635       if (hp->length == fname_length &&
6636           bcmp (hp->value.cpval, fname, fname_length) == 0) {
6637         ip->nominal_fname = hp->value.cpval;
6638         break;
6639       }
6640     if (hp == 0) {
6641       /* Didn't find it; cons up a new one.  */
6642       hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
6643       hp->next = *hash_bucket;
6644       *hash_bucket = hp;
6645
6646       hp->length = fname_length;
6647       ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
6648       bcopy (fname, hp->value.cpval, fname_length);
6649     }
6650   } else if (*bp) {
6651     error ("invalid format `#line' directive");
6652     return 0;
6653   }
6654
6655   ip->lineno = new_lineno;
6656   output_line_directive (ip, op, 0, file_change);
6657   check_expand (op, ip->length - (ip->bufp - ip->buf));
6658   return 0;
6659 }
6660
6661 /* Remove the definition of a symbol from the symbol table.
6662    according to un*x /lib/cpp, it is not an error to undef
6663    something that has no definitions, so it isn't one here either.  */
6664
6665 static int
6666 do_undef (buf, limit, op, keyword)
6667      U_CHAR *buf, *limit;
6668      FILE_BUF *op;
6669      struct directive *keyword;
6670 {
6671   int sym_length;
6672   HASHNODE *hp;
6673   U_CHAR *orig_buf = buf;
6674
6675   /* If this is a precompiler run (with -pcp) pass thru #undef directives.  */
6676   if (pcp_outfile && op)
6677     pass_thru_directive (buf, limit, op, keyword);
6678
6679   SKIP_WHITE_SPACE (buf);
6680   sym_length = check_macro_name (buf, "macro");
6681
6682   while ((hp = lookup (buf, sym_length, -1)) != NULL) {
6683     /* If we are generating additional info for debugging (with -g) we
6684        need to pass through all effective #undef directives.  */
6685     if (debug_output && op)
6686       pass_thru_directive (orig_buf, limit, op, keyword);
6687     if (hp->type != T_MACRO)
6688       warning ("undefining `%s'", hp->name);
6689     delete_macro (hp);
6690   }
6691
6692   if (pedantic) {
6693     buf += sym_length;
6694     SKIP_WHITE_SPACE (buf);
6695     if (buf != limit)
6696       pedwarn ("garbage after `#undef' directive");
6697   }
6698   return 0;
6699 }
6700 \f
6701 /* Report an error detected by the program we are processing.
6702    Use the text of the line in the error message.
6703    (We use error because it prints the filename & line#.)  */
6704
6705 static int
6706 do_error (buf, limit, op, keyword)
6707      U_CHAR *buf, *limit;
6708      FILE_BUF *op;
6709      struct directive *keyword;
6710 {
6711   int length = limit - buf;
6712   U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6713   bcopy ((char *) buf, (char *) copy, length);
6714   copy[length] = 0;
6715   SKIP_WHITE_SPACE (copy);
6716   error ("#error %s", copy);
6717   return 0;
6718 }
6719
6720 /* Report a warning detected by the program we are processing.
6721    Use the text of the line in the warning message, then continue.
6722    (We use error because it prints the filename & line#.)  */
6723
6724 static int
6725 do_warning (buf, limit, op, keyword)
6726      U_CHAR *buf, *limit;
6727      FILE_BUF *op;
6728      struct directive *keyword;
6729 {
6730   int length = limit - buf;
6731   U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
6732   bcopy ((char *) buf, (char *) copy, length);
6733   copy[length] = 0;
6734   SKIP_WHITE_SPACE (copy);
6735   warning ("#warning %s", copy);
6736   return 0;
6737 }
6738
6739 /* Remember the name of the current file being read from so that we can
6740    avoid ever including it again.  */
6741
6742 static void
6743 do_once ()
6744 {
6745   int i;
6746
6747   for (i = indepth; i >= 0; i--)
6748     if (instack[i].inc) {
6749       record_control_macro (instack[i].inc, (U_CHAR *) "");
6750       break;
6751     }
6752 }
6753
6754 /* #ident has already been copied to the output file, so just ignore it.  */
6755
6756 static int
6757 do_ident (buf, limit, op, keyword)
6758      U_CHAR *buf, *limit;
6759      FILE_BUF *op;
6760      struct directive *keyword;
6761 {
6762   FILE_BUF trybuf;
6763   int len;
6764
6765   /* Allow #ident in system headers, since that's not user's fault.  */
6766   if (pedantic && !instack[indepth].system_header_p)
6767     pedwarn ("ANSI C does not allow `#ident'");
6768
6769   trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
6770   buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
6771   bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
6772   limit = buf + (trybuf.bufp - trybuf.buf);
6773   len = (limit - buf);
6774   free (trybuf.buf);
6775
6776   /* Output directive name.  */
6777   check_expand (op, 7);
6778   bcopy ("#ident ", (char *) op->bufp, 7);
6779   op->bufp += 7;
6780
6781   /* Output the expanded argument line.  */
6782   check_expand (op, len);
6783   bcopy ((char *) buf, (char *) op->bufp, len);
6784   op->bufp += len;
6785
6786   return 0;
6787 }
6788
6789 /* #pragma and its argument line have already been copied to the output file.
6790    Just check for some recognized pragmas that need validation here.  */
6791
6792 static int
6793 do_pragma (buf, limit, op, keyword)
6794      U_CHAR *buf, *limit;
6795      FILE_BUF *op;
6796      struct directive *keyword;
6797 {
6798   SKIP_WHITE_SPACE (buf);
6799   if (!strncmp ((char *) buf, "once", 4)) {
6800     /* Allow #pragma once in system headers, since that's not the user's
6801        fault.  */
6802     if (!instack[indepth].system_header_p)
6803       warning ("`#pragma once' is obsolete");
6804     do_once ();
6805   }
6806
6807   if (!strncmp ((char *) buf, "implementation", 14)) {
6808     /* Be quiet about `#pragma implementation' for a file only if it hasn't
6809        been included yet.  */
6810
6811     int h;
6812     U_CHAR *p = buf + 14, *fname;
6813     SKIP_WHITE_SPACE (p);
6814     if (*p == '\n' || *p != '\"')
6815       return 0;
6816
6817     fname = p + 1;
6818     if ((p = (U_CHAR *) index ((char *) fname, '\"')))
6819       *p = '\0';
6820
6821     for (h = 0; h < INCLUDE_HASHSIZE; h++) {
6822       struct include_file *inc;
6823       for (inc = include_hashtab[h]; inc; inc = inc->next) {
6824         if (!strcmp (base_name (inc->fname), (char *) fname)) {
6825           warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
6826           return 0;
6827         }
6828       }
6829     }
6830   }
6831   return 0;
6832 }
6833
6834 #if 0
6835 /* This was a fun hack, but #pragma seems to start to be useful.
6836    By failing to recognize it, we pass it through unchanged to cc1.  */
6837
6838 /* The behavior of the #pragma directive is implementation defined.
6839    this implementation defines it as follows.  */
6840
6841 static int
6842 do_pragma ()
6843 {
6844   close (0);
6845   if (open ("/dev/tty", O_RDONLY, 0666) != 0)
6846     goto nope;
6847   close (1);
6848   if (open ("/dev/tty", O_WRONLY, 0666) != 1)
6849     goto nope;
6850   execl ("/usr/games/hack", "#pragma", 0);
6851   execl ("/usr/games/rogue", "#pragma", 0);
6852   execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
6853   execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
6854 nope:
6855   fatal ("You are in a maze of twisty compiler features, all different");
6856 }
6857 #endif
6858
6859 #ifdef SCCS_DIRECTIVE
6860
6861 /* Just ignore #sccs, on systems where we define it at all.  */
6862
6863 static int
6864 do_sccs (buf, limit, op, keyword)
6865      U_CHAR *buf, *limit;
6866      FILE_BUF *op;
6867      struct directive *keyword;
6868 {
6869   if (pedantic)
6870     pedwarn ("ANSI C does not allow `#sccs'");
6871   return 0;
6872 }
6873
6874 #endif /* defined (SCCS_DIRECTIVE) */
6875 \f
6876 /* Handle #if directive by
6877      1) inserting special `defined' keyword into the hash table
6878         that gets turned into 0 or 1 by special_symbol (thus,
6879         if the luser has a symbol called `defined' already, it won't
6880         work inside the #if directive)
6881      2) rescan the input into a temporary output buffer
6882      3) pass the output buffer to the yacc parser and collect a value
6883      4) clean up the mess left from steps 1 and 2.
6884      5) call conditional_skip to skip til the next #endif (etc.),
6885         or not, depending on the value from step 3.  */
6886
6887 static int
6888 do_if (buf, limit, op, keyword)
6889      U_CHAR *buf, *limit;
6890      FILE_BUF *op;
6891      struct directive *keyword;
6892 {
6893   HOST_WIDE_INT value;
6894   FILE_BUF *ip = &instack[indepth];
6895
6896   value = eval_if_expression (buf, limit - buf);
6897   conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
6898   return 0;
6899 }
6900
6901 /* Handle a #elif directive by not changing  if_stack  either.
6902    see the comment above do_else.  */
6903
6904 static int
6905 do_elif (buf, limit, op, keyword)
6906      U_CHAR *buf, *limit;
6907      FILE_BUF *op;
6908      struct directive *keyword;
6909 {
6910   HOST_WIDE_INT value;
6911   FILE_BUF *ip = &instack[indepth];
6912
6913   if (if_stack == instack[indepth].if_stack) {
6914     error ("`#elif' not within a conditional");
6915     return 0;
6916   } else {
6917     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
6918       error ("`#elif' after `#else'");
6919       fprintf (stderr, " (matches line %d", if_stack->lineno);
6920       if (if_stack->fname != NULL && ip->fname != NULL &&
6921           strcmp (if_stack->fname, ip->nominal_fname) != 0)
6922         fprintf (stderr, ", file %s", if_stack->fname);
6923       fprintf (stderr, ")\n");
6924     }
6925     if_stack->type = T_ELIF;
6926   }
6927
6928   if (if_stack->if_succeeded)
6929     skip_if_group (ip, 0, op);
6930   else {
6931     value = eval_if_expression (buf, limit - buf);
6932     if (value == 0)
6933       skip_if_group (ip, 0, op);
6934     else {
6935       ++if_stack->if_succeeded; /* continue processing input */
6936       output_line_directive (ip, op, 1, same_file);
6937     }
6938   }
6939   return 0;
6940 }
6941
6942 /* Evaluate a #if expression in BUF, of length LENGTH, then parse the
6943    result as a C expression and return the value as an int.  */
6944
6945 static HOST_WIDE_INT
6946 eval_if_expression (buf, length)
6947      U_CHAR *buf;
6948      int length;
6949 {
6950   FILE_BUF temp_obuf;
6951   HASHNODE *save_defined;
6952   HOST_WIDE_INT value;
6953
6954   save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
6955                           NULL_PTR, -1);
6956   pcp_inside_if = 1;
6957   temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
6958   pcp_inside_if = 0;
6959   delete_macro (save_defined);  /* clean up special symbol */
6960
6961   temp_obuf.buf[temp_obuf.length] = '\n';
6962   value = parse_c_expression ((char *) temp_obuf.buf);
6963
6964   free (temp_obuf.buf);
6965
6966   return value;
6967 }
6968
6969 /* routine to handle ifdef/ifndef.  Try to look up the symbol, then do
6970    or don't skip to the #endif/#else/#elif depending on what directive
6971    is actually being processed.  */
6972
6973 static int
6974 do_xifdef (buf, limit, op, keyword)
6975      U_CHAR *buf, *limit;
6976      FILE_BUF *op;
6977      struct directive *keyword;
6978 {
6979   int skip;
6980   FILE_BUF *ip = &instack[indepth];
6981   U_CHAR *end;
6982   int start_of_file = 0;
6983   U_CHAR *control_macro = 0;
6984
6985   /* Detect a #ifndef at start of file (not counting comments).  */
6986   if (ip->fname != 0 && keyword->type == T_IFNDEF) {
6987     U_CHAR *p = ip->buf;
6988     while (p != directive_start) {
6989       U_CHAR c = *p++;
6990       if (is_space[c])
6991         ;
6992       /* Make no special provision for backslash-newline here; this is
6993          slower if backslash-newlines are present, but it's correct,
6994          and it's not worth it to tune for the rare backslash-newline.  */
6995       else if (c == '/'
6996                && (*p == '*' || (cplusplus_comments && *p == '/'))) {
6997         /* Skip this comment.  */
6998         int junk = 0;
6999         U_CHAR *save_bufp = ip->bufp;
7000         ip->bufp = p + 1;
7001         p = skip_to_end_of_comment (ip, &junk, 1);
7002         ip->bufp = save_bufp;
7003       } else {
7004         goto fail;
7005       }
7006     }
7007     /* If we get here, this conditional is the beginning of the file.  */
7008     start_of_file = 1;
7009   fail: ;
7010   }
7011
7012   /* Discard leading and trailing whitespace.  */
7013   SKIP_WHITE_SPACE (buf);
7014   while (limit != buf && is_hor_space[limit[-1]]) limit--;
7015
7016   /* Find the end of the identifier at the beginning.  */
7017   for (end = buf; is_idchar[*end]; end++);
7018
7019   if (end == buf) {
7020     skip = (keyword->type == T_IFDEF);
7021     if (! traditional)
7022       pedwarn (end == limit ? "`#%s' with no argument"
7023                : "`#%s' argument starts with punctuation",
7024                keyword->name);
7025   } else {
7026     HASHNODE *hp;
7027
7028     if (! traditional) {
7029       if (isdigit (buf[0]))
7030         pedwarn ("`#%s' argument starts with a digit", keyword->name);
7031       else if (end != limit)
7032         pedwarn ("garbage at end of `#%s' argument", keyword->name);
7033     }
7034
7035     hp = lookup (buf, end-buf, -1);
7036
7037     if (pcp_outfile) {
7038       /* Output a precondition for this macro.  */
7039       if (hp &&
7040           (hp->type == T_CONST
7041            || (hp->type == T_MACRO && hp->value.defn->predefined)))
7042         fprintf (pcp_outfile, "#define %s\n", hp->name);
7043       else {
7044         U_CHAR *cp = buf;
7045         fprintf (pcp_outfile, "#undef ");
7046         while (is_idchar[*cp]) /* Ick! */
7047           fputc (*cp++, pcp_outfile);
7048         putc ('\n', pcp_outfile);
7049       }
7050     }
7051
7052     skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
7053     if (start_of_file && !skip) {
7054       control_macro = (U_CHAR *) xmalloc (end - buf + 1);
7055       bcopy ((char *) buf, (char *) control_macro, end - buf);
7056       control_macro[end - buf] = 0;
7057     }
7058   }
7059
7060   conditional_skip (ip, skip, T_IF, control_macro, op);
7061   return 0;
7062 }
7063
7064 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
7065    If this is a #ifndef starting at the beginning of a file,
7066    CONTROL_MACRO is the macro name tested by the #ifndef.
7067    Otherwise, CONTROL_MACRO is 0.  */
7068
7069 static void
7070 conditional_skip (ip, skip, type, control_macro, op)
7071      FILE_BUF *ip;
7072      int skip;
7073      enum node_type type;
7074      U_CHAR *control_macro;
7075      FILE_BUF *op;
7076 {
7077   IF_STACK_FRAME *temp;
7078
7079   temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7080   temp->fname = ip->nominal_fname;
7081   temp->lineno = ip->lineno;
7082   temp->next = if_stack;
7083   temp->control_macro = control_macro;
7084   if_stack = temp;
7085
7086   if_stack->type = type;
7087
7088   if (skip != 0) {
7089     skip_if_group (ip, 0, op);
7090     return;
7091   } else {
7092     ++if_stack->if_succeeded;
7093     output_line_directive (ip, &outbuf, 1, same_file);
7094   }
7095 }
7096
7097 /* Skip to #endif, #else, or #elif.  adjust line numbers, etc.
7098    Leaves input ptr at the sharp sign found.
7099    If ANY is nonzero, return at next directive of any sort.  */
7100
7101 static void
7102 skip_if_group (ip, any, op)
7103      FILE_BUF *ip;
7104      int any;
7105      FILE_BUF *op;
7106 {
7107   register U_CHAR *bp = ip->bufp, *cp;
7108   register U_CHAR *endb = ip->buf + ip->length;
7109   struct directive *kt;
7110   IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
7111   U_CHAR *beg_of_line = bp;
7112   register int ident_length;
7113   U_CHAR *ident, *after_ident;
7114   /* Save info about where the group starts.  */
7115   U_CHAR *beg_of_group = bp;
7116   int beg_lineno = ip->lineno;
7117
7118   if (output_conditionals && op != 0) {
7119     char *ptr = "#failed\n";
7120     int len = strlen (ptr);
7121
7122     if (op->bufp > op->buf && op->bufp[-1] != '\n')
7123       {
7124         *op->bufp++ = '\n';
7125         op->lineno++;
7126       }
7127     check_expand (op, len);
7128     bcopy (ptr, (char *) op->bufp, len);
7129     op->bufp += len;
7130     op->lineno++;
7131     output_line_directive (ip, op, 1, 0);
7132   }
7133
7134   while (bp < endb) {
7135     switch (*bp++) {
7136     case '/':                   /* possible comment */
7137       if (*bp == '\\' && bp[1] == '\n')
7138         newline_fix (bp);
7139       if (*bp == '*'
7140           || (cplusplus_comments && *bp == '/')) {
7141         ip->bufp = ++bp;
7142         bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
7143       }
7144       break;
7145     case '\"':
7146     case '\'':
7147       bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
7148                                NULL_PTR, NULL_PTR);
7149       break;
7150     case '\\':
7151       /* Char after backslash loses its special meaning.  */
7152       if (bp < endb) {
7153         if (*bp == '\n')
7154           ++ip->lineno;         /* But do update the line-count.  */
7155         bp++;
7156       }
7157       break;
7158     case '\n':
7159       ++ip->lineno;
7160       beg_of_line = bp;
7161       break;
7162     case '%':
7163       if (beg_of_line == 0 || traditional)
7164         break;
7165       ip->bufp = bp - 1;
7166       while (bp[0] == '\\' && bp[1] == '\n')
7167         bp += 2;
7168       if (*bp == ':')
7169         goto sharp_token;
7170       break;
7171     case '#':
7172       /* # keyword: a # must be first nonblank char on the line */
7173       if (beg_of_line == 0)
7174         break;
7175       ip->bufp = bp - 1;
7176     sharp_token:
7177       /* Scan from start of line, skipping whitespace, comments
7178          and backslash-newlines, and see if we reach this #.
7179          If not, this # is not special.  */
7180       bp = beg_of_line;
7181       /* If -traditional, require # to be at beginning of line.  */
7182       if (!traditional) {
7183         while (1) {
7184           if (is_hor_space[*bp])
7185             bp++;
7186           else if (*bp == '\\' && bp[1] == '\n')
7187             bp += 2;
7188           else if (*bp == '/' && bp[1] == '*') {
7189             bp += 2;
7190             while (!(*bp == '*' && bp[1] == '/'))
7191               bp++;
7192             bp += 2;
7193           }
7194           /* There is no point in trying to deal with C++ // comments here,
7195              because if there is one, then this # must be part of the
7196              comment and we would never reach here.  */
7197           else break;
7198         }
7199       }
7200       if (bp != ip->bufp) {
7201         bp = ip->bufp + 1;      /* Reset bp to after the #.  */
7202         break;
7203       }
7204
7205       bp = ip->bufp + 1;        /* Point after the '#' */
7206       if (ip->bufp[0] == '%') {
7207         /* Skip past the ':' again.  */
7208         while (*bp == '\\') {
7209           ip->lineno++;
7210           bp += 2;
7211         }
7212         bp++;
7213       }
7214
7215       /* Skip whitespace and \-newline.  */
7216       while (1) {
7217         if (is_hor_space[*bp])
7218           bp++;
7219         else if (*bp == '\\' && bp[1] == '\n')
7220           bp += 2;
7221         else if (*bp == '/') {
7222           if (bp[1] == '*') {
7223             for (bp += 2; ; bp++) {
7224               if (*bp == '\n')
7225                 ip->lineno++;
7226               else if (*bp == '*') {
7227                 if (bp[-1] == '/' && warn_comments)
7228                   warning ("`/*' within comment");
7229                 if (bp[1] == '/')
7230                   break;
7231               }
7232             }
7233             bp += 2;
7234           } else if (bp[1] == '/' && cplusplus_comments) {
7235             for (bp += 2; ; bp++) {
7236               if (*bp == '\n') {
7237                 if (bp[-1] != '\\')
7238                   break;
7239                 if (warn_comments)
7240                   warning ("multiline `//' comment");
7241                 ip->lineno++;
7242               }
7243             }
7244           } else
7245             break;
7246         } else
7247           break;
7248       }
7249
7250       cp = bp;
7251
7252       /* Now find end of directive name.
7253          If we encounter a backslash-newline, exchange it with any following
7254          symbol-constituents so that we end up with a contiguous name.  */
7255
7256       while (1) {
7257         if (is_idchar[*bp])
7258           bp++;
7259         else {
7260           if (*bp == '\\' && bp[1] == '\n')
7261             name_newline_fix (bp);
7262           if (is_idchar[*bp])
7263             bp++;
7264           else break;
7265         }
7266       }
7267       ident_length = bp - cp;
7268       ident = cp;
7269       after_ident = bp;
7270
7271       /* A line of just `#' becomes blank.  */
7272
7273       if (ident_length == 0 && *after_ident == '\n') {
7274         continue;
7275       }
7276
7277       if (ident_length == 0 || !is_idstart[*ident]) {
7278         U_CHAR *p = ident;
7279         while (is_idchar[*p]) {
7280           if (*p < '0' || *p > '9')
7281             break;
7282           p++;
7283         }
7284         /* Handle # followed by a line number.  */
7285         if (p != ident && !is_idchar[*p]) {
7286           if (pedantic)
7287             pedwarn ("`#' followed by integer");
7288           continue;
7289         }
7290
7291         /* Avoid error for `###' and similar cases unless -pedantic.  */
7292         if (p == ident) {
7293           while (*p == '#' || is_hor_space[*p]) p++;
7294           if (*p == '\n') {
7295             if (pedantic && !lang_asm)
7296               pedwarn ("invalid preprocessing directive");
7297             continue;
7298           }
7299         }
7300
7301         if (!lang_asm && pedantic)
7302           pedwarn ("invalid preprocessing directive name");
7303         continue;
7304       }
7305
7306       for (kt = directive_table; kt->length >= 0; kt++) {
7307         IF_STACK_FRAME *temp;
7308         if (ident_length == kt->length
7309             && bcmp (cp, kt->name, kt->length) == 0) {
7310           /* If we are asked to return on next directive, do so now.  */
7311           if (any)
7312             goto done;
7313
7314           switch (kt->type) {
7315           case T_IF:
7316           case T_IFDEF:
7317           case T_IFNDEF:
7318             temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
7319             temp->next = if_stack;
7320             if_stack = temp;
7321             temp->lineno = ip->lineno;
7322             temp->fname = ip->nominal_fname;
7323             temp->type = kt->type;
7324             break;
7325           case T_ELSE:
7326           case T_ENDIF:
7327             if (pedantic && if_stack != save_if_stack)
7328               validate_else (bp, endb);
7329           case T_ELIF:
7330             if (if_stack == instack[indepth].if_stack) {
7331               error ("`#%s' not within a conditional", kt->name);
7332               break;
7333             }
7334             else if (if_stack == save_if_stack)
7335               goto done;                /* found what we came for */
7336
7337             if (kt->type != T_ENDIF) {
7338               if (if_stack->type == T_ELSE)
7339                 error ("`#else' or `#elif' after `#else'");
7340               if_stack->type = kt->type;
7341               break;
7342             }
7343
7344             temp = if_stack;
7345             if_stack = if_stack->next;
7346             free (temp);
7347             break;
7348
7349            default:
7350             break;
7351           }
7352           break;
7353         }
7354       }
7355       /* Don't let erroneous code go by.  */
7356       if (kt->length < 0 && !lang_asm && pedantic)
7357         pedwarn ("invalid preprocessing directive name");
7358     }
7359   }
7360
7361   ip->bufp = bp;
7362   /* after this returns, rescan will exit because ip->bufp
7363      now points to the end of the buffer.
7364      rescan is responsible for the error message also.  */
7365
7366  done:
7367   if (output_conditionals && op != 0) {
7368     char *ptr = "#endfailed\n";
7369     int len = strlen (ptr);
7370
7371     if (op->bufp > op->buf && op->bufp[-1] != '\n')
7372       {
7373         *op->bufp++ = '\n';
7374         op->lineno++;
7375       }
7376     check_expand (op, beg_of_line - beg_of_group);
7377     bcopy ((char *) beg_of_group, (char *) op->bufp,
7378            beg_of_line - beg_of_group);
7379     op->bufp += beg_of_line - beg_of_group;
7380     op->lineno += ip->lineno - beg_lineno;
7381     check_expand (op, len);
7382     bcopy (ptr, (char *) op->bufp, len);
7383     op->bufp += len;
7384     op->lineno++;
7385   }
7386 }
7387
7388 /* Handle a #else directive.  Do this by just continuing processing
7389    without changing  if_stack ;  this is so that the error message
7390    for missing #endif's etc. will point to the original #if.  It
7391    is possible that something different would be better.  */
7392
7393 static int
7394 do_else (buf, limit, op, keyword)
7395      U_CHAR *buf, *limit;
7396      FILE_BUF *op;
7397      struct directive *keyword;
7398 {
7399   FILE_BUF *ip = &instack[indepth];
7400
7401   if (pedantic) {
7402     SKIP_WHITE_SPACE (buf);
7403     if (buf != limit)
7404       pedwarn ("text following `#else' violates ANSI standard");
7405   }
7406
7407   if (if_stack == instack[indepth].if_stack) {
7408     error ("`#else' not within a conditional");
7409     return 0;
7410   } else {
7411     /* #ifndef can't have its special treatment for containing the whole file
7412        if it has a #else clause.  */
7413     if_stack->control_macro = 0;
7414
7415     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
7416       error ("`#else' after `#else'");
7417       fprintf (stderr, " (matches line %d", if_stack->lineno);
7418       if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
7419         fprintf (stderr, ", file %s", if_stack->fname);
7420       fprintf (stderr, ")\n");
7421     }
7422     if_stack->type = T_ELSE;
7423   }
7424
7425   if (if_stack->if_succeeded)
7426     skip_if_group (ip, 0, op);
7427   else {
7428     ++if_stack->if_succeeded;   /* continue processing input */
7429     output_line_directive (ip, op, 1, same_file);
7430   }
7431   return 0;
7432 }
7433
7434 /* Unstack after #endif directive.  */
7435
7436 static int
7437 do_endif (buf, limit, op, keyword)
7438      U_CHAR *buf, *limit;
7439      FILE_BUF *op;
7440      struct directive *keyword;
7441 {
7442   if (pedantic) {
7443     SKIP_WHITE_SPACE (buf);
7444     if (buf != limit)
7445       pedwarn ("text following `#endif' violates ANSI standard");
7446   }
7447
7448   if (if_stack == instack[indepth].if_stack)
7449     error ("unbalanced `#endif'");
7450   else {
7451     IF_STACK_FRAME *temp = if_stack;
7452     if_stack = if_stack->next;
7453     if (temp->control_macro != 0) {
7454       /* This #endif matched a #ifndef at the start of the file.
7455          See if it is at the end of the file.  */
7456       FILE_BUF *ip = &instack[indepth];
7457       U_CHAR *p = ip->bufp;
7458       U_CHAR *ep = ip->buf + ip->length;
7459
7460       while (p != ep) {
7461         U_CHAR c = *p++;
7462         if (!is_space[c]) {
7463           if (c == '/'
7464               && (*p == '*' || (cplusplus_comments && *p == '/'))) {
7465             /* Skip this comment.  */
7466             int junk = 0;
7467             U_CHAR *save_bufp = ip->bufp;
7468             ip->bufp = p + 1;
7469             p = skip_to_end_of_comment (ip, &junk, 1);
7470             ip->bufp = save_bufp;
7471           } else
7472             goto fail;
7473         }
7474       }
7475       /* If we get here, this #endif ends a #ifndef
7476          that contains all of the file (aside from whitespace).
7477          Arrange not to include the file again
7478          if the macro that was tested is defined.
7479
7480          Do not do this for the top-level file in a -include or any
7481          file in a -imacros.  */
7482       if (indepth != 0
7483           && ! (indepth == 1 && no_record_file)
7484           && ! (no_record_file && no_output))
7485         record_control_macro (ip->inc, temp->control_macro);
7486     fail: ;
7487     }
7488     free (temp);
7489     output_line_directive (&instack[indepth], op, 1, same_file);
7490   }
7491   return 0;
7492 }
7493
7494 /* When an #else or #endif is found while skipping failed conditional,
7495    if -pedantic was specified, this is called to warn about text after
7496    the directive name.  P points to the first char after the directive
7497    name.  */
7498
7499 static void
7500 validate_else (p, limit)
7501      register U_CHAR *p;
7502      register U_CHAR *limit;
7503 {
7504   /* Advance P over whitespace and comments.  */
7505   while (1) {
7506     while (*p == '\\' && p[1] == '\n')
7507       p += 2;
7508     if (is_hor_space[*p])
7509       p++;
7510     else if (*p == '/') {
7511       while (p[1] == '\\' && p[2] == '\n')
7512         p += 2;
7513       if (p[1] == '*') {
7514         /* Don't bother warning about unterminated comments
7515            since that will happen later.  Just be sure to exit.  */
7516         for (p += 2; ; p++) {
7517           if (p == limit)
7518             return;
7519           if (*p == '*') {
7520             while (p[1] == '\\' && p[2] == '\n')
7521               p += 2;
7522             if (p[1] == '/') {
7523               p += 2;
7524               break;
7525             }
7526           }
7527         }
7528       }
7529       else if (cplusplus_comments && p[1] == '/')
7530         return;
7531       else break;
7532     } else break;
7533   }
7534   if (*p != '\n')
7535     pedwarn ("text following `#else' or `#endif' violates ANSI standard");
7536 }
7537 \f
7538 /* Skip a comment, assuming the input ptr immediately follows the
7539    initial slash-star.  Bump *LINE_COUNTER for each newline.
7540    (The canonical line counter is &ip->lineno.)
7541    Don't use this routine (or the next one) if bumping the line
7542    counter is not sufficient to deal with newlines in the string.
7543
7544    If NOWARN is nonzero, don't warn about slash-star inside a comment.
7545    This feature is useful when processing a comment that is going to
7546    be processed or was processed at another point in the preprocessor,
7547    to avoid a duplicate warning.  Likewise for unterminated comment
7548    errors.  */
7549
7550 static U_CHAR *
7551 skip_to_end_of_comment (ip, line_counter, nowarn)
7552      register FILE_BUF *ip;
7553      int *line_counter;         /* place to remember newlines, or NULL */
7554      int nowarn;
7555 {
7556   register U_CHAR *limit = ip->buf + ip->length;
7557   register U_CHAR *bp = ip->bufp;
7558   FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
7559   int start_line = line_counter ? *line_counter : 0;
7560
7561         /* JF this line_counter stuff is a crock to make sure the
7562            comment is only put out once, no matter how many times
7563            the comment is skipped.  It almost works */
7564   if (op) {
7565     *op->bufp++ = '/';
7566     *op->bufp++ = bp[-1];
7567   }
7568   if (cplusplus_comments && bp[-1] == '/') {
7569     for (; bp < limit; bp++) {
7570       if (*bp == '\n') {
7571         if (bp[-1] != '\\')
7572           break;
7573         if (!nowarn && warn_comments)
7574           warning ("multiline `//' comment");
7575         if (line_counter)
7576           ++*line_counter;
7577         if (op)
7578           ++op->lineno;
7579       }
7580       if (op)
7581         *op->bufp++ = *bp;
7582     }
7583     ip->bufp = bp;
7584     return bp;
7585   }
7586   while (bp < limit) {
7587     if (op)
7588       *op->bufp++ = *bp;
7589     switch (*bp++) {
7590     case '\n':
7591       /* If this is the end of the file, we have an unterminated comment.
7592          Don't swallow the newline.  We are guaranteed that there will be a
7593          trailing newline and various pieces assume it's there.  */
7594       if (bp == limit)
7595         {
7596           --bp;
7597           --limit;
7598           break;
7599         }
7600       if (line_counter != NULL)
7601         ++*line_counter;
7602       if (op)
7603         ++op->lineno;
7604       break;
7605     case '*':
7606       if (bp[-2] == '/' && !nowarn && warn_comments)
7607         warning ("`/*' within comment");
7608       if (*bp == '\\' && bp[1] == '\n')
7609         newline_fix (bp);
7610       if (*bp == '/') {
7611         if (op)
7612           *op->bufp++ = '/';
7613         ip->bufp = ++bp;
7614         return bp;
7615       }
7616       break;
7617     }
7618   }
7619
7620   if (!nowarn)
7621     error_with_line (line_for_error (start_line), "unterminated comment");
7622   ip->bufp = bp;
7623   return bp;
7624 }
7625
7626 /* Skip over a quoted string.  BP points to the opening quote.
7627    Returns a pointer after the closing quote.  Don't go past LIMIT.
7628    START_LINE is the line number of the starting point (but it need
7629    not be valid if the starting point is inside a macro expansion).
7630
7631    The input stack state is not changed.
7632
7633    If COUNT_NEWLINES is nonzero, it points to an int to increment
7634    for each newline passed.
7635
7636    If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
7637    if we pass a backslash-newline.
7638
7639    If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.  */
7640
7641 static U_CHAR *
7642 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
7643      register U_CHAR *bp;
7644      register U_CHAR *limit;
7645      int start_line;
7646      int *count_newlines;
7647      int *backslash_newlines_p;
7648      int *eofp;
7649 {
7650   register U_CHAR c, match;
7651
7652   match = *bp++;
7653   while (1) {
7654     if (bp >= limit) {
7655       error_with_line (line_for_error (start_line),
7656                        "unterminated string or character constant");
7657       error_with_line (multiline_string_line,
7658                        "possible real start of unterminated constant");
7659       multiline_string_line = 0;
7660       if (eofp)
7661         *eofp = 1;
7662       break;
7663     }
7664     c = *bp++;
7665     if (c == '\\') {
7666       while (*bp == '\\' && bp[1] == '\n') {
7667         if (backslash_newlines_p)
7668           *backslash_newlines_p = 1;
7669         if (count_newlines)
7670           ++*count_newlines;
7671         bp += 2;
7672       }
7673       if (*bp == '\n' && count_newlines) {
7674         if (backslash_newlines_p)
7675           *backslash_newlines_p = 1;
7676         ++*count_newlines;
7677       }
7678       bp++;
7679     } else if (c == '\n') {
7680       if (traditional) {
7681         /* Unterminated strings and character constants are 'valid'.  */
7682         bp--;   /* Don't consume the newline.  */
7683         if (eofp)
7684           *eofp = 1;
7685         break;
7686       }
7687       if (match == '\'') {
7688         error_with_line (line_for_error (start_line),
7689                          "unterminated string or character constant");
7690         bp--;
7691         if (eofp)
7692           *eofp = 1;
7693         break;
7694       }
7695       /* If not traditional, then allow newlines inside strings.  */
7696       if (count_newlines)
7697         ++*count_newlines;
7698       if (multiline_string_line == 0) {
7699         if (pedantic)
7700           pedwarn_with_line (line_for_error (start_line),
7701                              "string constant runs past end of line");
7702         multiline_string_line = start_line;
7703       }
7704     } else if (c == match)
7705       break;
7706   }
7707   return bp;
7708 }
7709
7710 /* Place into DST a quoted string representing the string SRC.
7711    Return the address of DST's terminating null.  */
7712
7713 static char *
7714 quote_string (dst, src)
7715      char *dst, *src;
7716 {
7717   U_CHAR c;
7718
7719   *dst++ = '\"';
7720   for (;;)
7721     switch ((c = *src++))
7722       {
7723       default:
7724         if (isprint (c))
7725           *dst++ = c;
7726         else
7727           {
7728             sprintf (dst, "\\%03o", c);
7729             dst += 4;
7730           }
7731         break;
7732
7733       case '\"':
7734       case '\\':
7735         *dst++ = '\\';
7736         *dst++ = c;
7737         break;
7738
7739       case '\0':
7740         *dst++ = '\"';
7741         *dst = '\0';
7742         return dst;
7743       }
7744 }
7745
7746 /* Skip across a group of balanced parens, starting from IP->bufp.
7747    IP->bufp is updated.  Use this with IP->bufp pointing at an open-paren.
7748
7749    This does not handle newlines, because it's used for the arg of #if,
7750    where there aren't any newlines.  Also, backslash-newline can't appear.  */
7751
7752 static U_CHAR *
7753 skip_paren_group (ip)
7754      register FILE_BUF *ip;
7755 {
7756   U_CHAR *limit = ip->buf + ip->length;
7757   U_CHAR *p = ip->bufp;
7758   int depth = 0;
7759   int lines_dummy = 0;
7760
7761   while (p != limit) {
7762     int c = *p++;
7763     switch (c) {
7764     case '(':
7765       depth++;
7766       break;
7767
7768     case ')':
7769       depth--;
7770       if (depth == 0)
7771         return ip->bufp = p;
7772       break;
7773
7774     case '/':
7775       if (*p == '*') {
7776         ip->bufp = p;
7777         p = skip_to_end_of_comment (ip, &lines_dummy, 0);
7778         p = ip->bufp;
7779       }
7780
7781     case '"':
7782     case '\'':
7783       {
7784         int eofp = 0;
7785         p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
7786         if (eofp)
7787           return ip->bufp = p;
7788       }
7789       break;
7790     }
7791   }
7792
7793   ip->bufp = p;
7794   return p;
7795 }
7796 \f
7797 /* Write out a #line directive, for instance, after an #include file.
7798    If CONDITIONAL is nonzero, we can omit the #line if it would
7799    appear to be a no-op, and we can output a few newlines instead
7800    if we want to increase the line number by a small amount.
7801    FILE_CHANGE says whether we are entering a file, leaving, or neither.  */
7802
7803 static void
7804 output_line_directive (ip, op, conditional, file_change)
7805      FILE_BUF *ip, *op;
7806      int conditional;
7807      enum file_change_code file_change;
7808 {
7809   int len;
7810   char *line_directive_buf, *line_end;
7811
7812   if (no_line_directives
7813       || ip->fname == NULL
7814       || no_output) {
7815     op->lineno = ip->lineno;
7816     return;
7817   }
7818
7819   if (conditional) {
7820     if (ip->lineno == op->lineno)
7821       return;
7822
7823     /* If the inherited line number is a little too small,
7824        output some newlines instead of a #line directive.  */
7825     if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
7826       check_expand (op, 10);
7827       while (ip->lineno > op->lineno) {
7828         *op->bufp++ = '\n';
7829         op->lineno++;
7830       }
7831       return;
7832     }
7833   }
7834
7835   /* Don't output a line number of 0 if we can help it.  */
7836   if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
7837       && *ip->bufp == '\n') {
7838     ip->lineno++;
7839     ip->bufp++;
7840   }
7841
7842   line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
7843   sprintf (line_directive_buf, "# %d ", ip->lineno);
7844   line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
7845                            ip->nominal_fname);
7846   if (file_change != same_file) {
7847     *line_end++ = ' ';
7848     *line_end++ = file_change == enter_file ? '1' : '2';
7849   }
7850   /* Tell cc1 if following text comes from a system header file.  */
7851   if (ip->system_header_p) {
7852     *line_end++ = ' ';
7853     *line_end++ = '3';
7854   }
7855 #ifndef NO_IMPLICIT_EXTERN_C
7856   /* Tell cc1plus if following text should be treated as C.  */
7857   if (ip->system_header_p == 2 && cplusplus) {
7858     *line_end++ = ' ';
7859     *line_end++ = '4';
7860   }
7861 #endif
7862   *line_end++ = '\n';
7863   len = line_end - line_directive_buf;
7864   check_expand (op, len + 1);
7865   if (op->bufp > op->buf && op->bufp[-1] != '\n')
7866     *op->bufp++ = '\n';
7867   bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
7868   op->bufp += len;
7869   op->lineno = ip->lineno;
7870 }
7871 \f
7872 /* This structure represents one parsed argument in a macro call.
7873    `raw' points to the argument text as written (`raw_length' is its length).
7874    `expanded' points to the argument's macro-expansion
7875    (its length is `expand_length').
7876    `stringified_length' is the length the argument would have
7877    if stringified.
7878    `use_count' is the number of times this macro arg is substituted
7879    into the macro.  If the actual use count exceeds 10,
7880    the value stored is 10.
7881    `free1' and `free2', if nonzero, point to blocks to be freed
7882    when the macro argument data is no longer needed.  */
7883
7884 struct argdata {
7885   U_CHAR *raw, *expanded;
7886   int raw_length, expand_length;
7887   int stringified_length;
7888   U_CHAR *free1, *free2;
7889   char newlines;
7890   char use_count;
7891 };
7892
7893 /* Expand a macro call.
7894    HP points to the symbol that is the macro being called.
7895    Put the result of expansion onto the input stack
7896    so that subsequent input by our caller will use it.
7897
7898    If macro wants arguments, caller has already verified that
7899    an argument list follows; arguments come from the input stack.  */
7900
7901 static void
7902 macroexpand (hp, op)
7903      HASHNODE *hp;
7904      FILE_BUF *op;
7905 {
7906   int nargs;
7907   DEFINITION *defn = hp->value.defn;
7908   register U_CHAR *xbuf;
7909   int xbuf_len;
7910   int start_line = instack[indepth].lineno;
7911   int rest_args, rest_zero;
7912
7913   CHECK_DEPTH (return;);
7914
7915   /* it might not actually be a macro.  */
7916   if (hp->type != T_MACRO) {
7917     special_symbol (hp, op);
7918     return;
7919   }
7920
7921   /* This macro is being used inside a #if, which means it must be */
7922   /* recorded as a precondition.  */
7923   if (pcp_inside_if && pcp_outfile && defn->predefined)
7924     dump_single_macro (hp, pcp_outfile);
7925
7926   nargs = defn->nargs;
7927
7928   if (nargs >= 0) {
7929     register int i;
7930     struct argdata *args;
7931     char *parse_error = 0;
7932
7933     args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
7934
7935     for (i = 0; i < nargs; i++) {
7936       args[i].raw = (U_CHAR *) "";
7937       args[i].expanded = 0;
7938       args[i].raw_length = args[i].expand_length
7939         = args[i].stringified_length = 0;
7940       args[i].free1 = args[i].free2 = 0;
7941       args[i].use_count = 0;
7942     }
7943
7944     /* Parse all the macro args that are supplied.  I counts them.
7945        The first NARGS args are stored in ARGS.
7946        The rest are discarded.
7947        If rest_args is set then we assume macarg absorbed the rest of the args.
7948        */
7949     i = 0;
7950     rest_args = 0;
7951     do {
7952       /* Discard the open-parenthesis or comma before the next arg.  */
7953       ++instack[indepth].bufp;
7954       if (rest_args)
7955         continue;
7956       if (i < nargs || (nargs == 0 && i == 0)) {
7957         /* If we are working on last arg which absorbs rest of args...  */
7958         if (i == nargs - 1 && defn->rest_args)
7959           rest_args = 1;
7960         parse_error = macarg (&args[i], rest_args);
7961       }
7962       else
7963         parse_error = macarg (NULL_PTR, 0);
7964       if (parse_error) {
7965         error_with_line (line_for_error (start_line), parse_error);
7966         break;
7967       }
7968       i++;
7969     } while (*instack[indepth].bufp != ')');
7970
7971     /* If we got one arg but it was just whitespace, call that 0 args.  */
7972     if (i == 1) {
7973       register U_CHAR *bp = args[0].raw;
7974       register U_CHAR *lim = bp + args[0].raw_length;
7975       /* cpp.texi says for foo ( ) we provide one argument.
7976          However, if foo wants just 0 arguments, treat this as 0.  */
7977       if (nargs == 0)
7978         while (bp != lim && is_space[*bp]) bp++;
7979       if (bp == lim)
7980         i = 0;
7981     }
7982
7983     /* Don't output an error message if we have already output one for
7984        a parse error above.  */
7985     rest_zero = 0;
7986     if (nargs == 0 && i > 0) {
7987       if (! parse_error)
7988         error ("arguments given to macro `%s'", hp->name);
7989     } else if (i < nargs) {
7990       /* traditional C allows foo() if foo wants one argument.  */
7991       if (nargs == 1 && i == 0 && traditional)
7992         ;
7993       /* the rest args token is allowed to absorb 0 tokens */
7994       else if (i == nargs - 1 && defn->rest_args)
7995         rest_zero = 1;
7996       else if (parse_error)
7997         ;
7998       else if (i == 0)
7999         error ("macro `%s' used without args", hp->name);
8000       else if (i == 1)
8001         error ("macro `%s' used with just one arg", hp->name);
8002       else
8003         error ("macro `%s' used with only %d args", hp->name, i);
8004     } else if (i > nargs) {
8005       if (! parse_error)
8006         error ("macro `%s' used with too many (%d) args", hp->name, i);
8007     }
8008
8009     /* Swallow the closeparen.  */
8010     ++instack[indepth].bufp;
8011
8012     /* If macro wants zero args, we parsed the arglist for checking only.
8013        Read directly from the macro definition.  */
8014     if (nargs == 0) {
8015       xbuf = defn->expansion;
8016       xbuf_len = defn->length;
8017     } else {
8018       register U_CHAR *exp = defn->expansion;
8019       register int offset;      /* offset in expansion,
8020                                    copied a piece at a time */
8021       register int totlen;      /* total amount of exp buffer filled so far */
8022
8023       register struct reflist *ap, *last_ap;
8024
8025       /* Macro really takes args.  Compute the expansion of this call.  */
8026
8027       /* Compute length in characters of the macro's expansion.
8028          Also count number of times each arg is used.  */
8029       xbuf_len = defn->length;
8030       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
8031         if (ap->stringify)
8032           xbuf_len += args[ap->argno].stringified_length;
8033         else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
8034           /* Add 4 for two newline-space markers to prevent
8035              token concatenation.  */
8036           xbuf_len += args[ap->argno].raw_length + 4;
8037         else {
8038           /* We have an ordinary (expanded) occurrence of the arg.
8039              So compute its expansion, if we have not already.  */
8040           if (args[ap->argno].expanded == 0) {
8041             FILE_BUF obuf;
8042             obuf = expand_to_temp_buffer (args[ap->argno].raw,
8043                                           args[ap->argno].raw + args[ap->argno].raw_length,
8044                                           1, 0);
8045
8046             args[ap->argno].expanded = obuf.buf;
8047             args[ap->argno].expand_length = obuf.length;
8048             args[ap->argno].free2 = obuf.buf;
8049           }
8050
8051           /* Add 4 for two newline-space markers to prevent
8052              token concatenation.  */
8053           xbuf_len += args[ap->argno].expand_length + 4;
8054         }
8055         if (args[ap->argno].use_count < 10)
8056           args[ap->argno].use_count++;
8057       }
8058
8059       xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
8060
8061       /* Generate in XBUF the complete expansion
8062          with arguments substituted in.
8063          TOTLEN is the total size generated so far.
8064          OFFSET is the index in the definition
8065          of where we are copying from.  */
8066       offset = totlen = 0;
8067       for (last_ap = NULL, ap = defn->pattern; ap != NULL;
8068            last_ap = ap, ap = ap->next) {
8069         register struct argdata *arg = &args[ap->argno];
8070         int count_before = totlen;
8071
8072         /* Add chars to XBUF.  */
8073         for (i = 0; i < ap->nchars; i++, offset++)
8074           xbuf[totlen++] = exp[offset];
8075
8076         /* If followed by an empty rest arg with concatenation,
8077            delete the last run of nonwhite chars.  */
8078         if (rest_zero && totlen > count_before
8079             && ((ap->rest_args && ap->raw_before != 0)
8080                 || (last_ap != NULL && last_ap->rest_args
8081                     && last_ap->raw_after != 0))) {
8082           /* Delete final whitespace.  */
8083           while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
8084             totlen--;
8085           }
8086
8087           /* Delete the nonwhites before them.  */
8088           while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) {
8089             totlen--;
8090           }
8091         }
8092
8093         if (ap->stringify != 0) {
8094           int arglen = arg->raw_length;
8095           int escaped = 0;
8096           int in_string = 0;
8097           int c;
8098           i = 0;
8099           while (i < arglen
8100                  && (c = arg->raw[i], is_space[c]))
8101             i++;
8102           while (i < arglen
8103                  && (c = arg->raw[arglen - 1], is_space[c]))
8104             arglen--;
8105           if (!traditional)
8106             xbuf[totlen++] = '\"'; /* insert beginning quote */
8107           for (; i < arglen; i++) {
8108             c = arg->raw[i];
8109
8110             /* Special markers Newline Space
8111                generate nothing for a stringified argument.  */
8112             if (c == '\n' && arg->raw[i+1] != '\n') {
8113               i++;
8114               continue;
8115             }
8116
8117             /* Internal sequences of whitespace are replaced by one space
8118                except within an string or char token.  */
8119             if (! in_string
8120                 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
8121               while (1) {
8122                 /* Note that Newline Space does occur within whitespace
8123                    sequences; consider it part of the sequence.  */
8124                 if (c == '\n' && is_space[arg->raw[i+1]])
8125                   i += 2;
8126                 else if (c != '\n' && is_space[c])
8127                   i++;
8128                 else break;
8129                 c = arg->raw[i];
8130               }
8131               i--;
8132               c = ' ';
8133             }
8134
8135             if (escaped)
8136               escaped = 0;
8137             else {
8138               if (c == '\\')
8139                 escaped = 1;
8140               if (in_string) {
8141                 if (c == in_string)
8142                   in_string = 0;
8143               } else if (c == '\"' || c == '\'')
8144                 in_string = c;
8145             }
8146
8147             /* Escape these chars */
8148             if (c == '\"' || (in_string && c == '\\'))
8149               xbuf[totlen++] = '\\';
8150             if (isprint (c))
8151               xbuf[totlen++] = c;
8152             else {
8153               sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
8154               totlen += 4;
8155             }
8156           }
8157           if (!traditional)
8158             xbuf[totlen++] = '\"'; /* insert ending quote */
8159         } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
8160           U_CHAR *p1 = arg->raw;
8161           U_CHAR *l1 = p1 + arg->raw_length;
8162           if (ap->raw_before != 0) {
8163             while (p1 != l1 && is_space[*p1]) p1++;
8164             while (p1 != l1 && is_idchar[*p1])
8165               xbuf[totlen++] = *p1++;
8166             /* Delete any no-reexpansion marker that follows
8167                an identifier at the beginning of the argument
8168                if the argument is concatenated with what precedes it.  */
8169             if (p1[0] == '\n' && p1[1] == '-')
8170               p1 += 2;
8171           } else if (!traditional) {
8172           /* Ordinary expanded use of the argument.
8173              Put in newline-space markers to prevent token pasting.  */
8174             xbuf[totlen++] = '\n';
8175             xbuf[totlen++] = ' ';
8176           }
8177           if (ap->raw_after != 0) {
8178             /* Arg is concatenated after: delete trailing whitespace,
8179                whitespace markers, and no-reexpansion markers.  */
8180             while (p1 != l1) {
8181               if (is_space[l1[-1]]) l1--;
8182               else if (l1[-1] == '-') {
8183                 U_CHAR *p2 = l1 - 1;
8184                 /* If a `-' is preceded by an odd number of newlines then it
8185                    and the last newline are a no-reexpansion marker.  */
8186                 while (p2 != p1 && p2[-1] == '\n') p2--;
8187                 if ((l1 - 1 - p2) & 1) {
8188                   l1 -= 2;
8189                 }
8190                 else break;
8191               }
8192               else break;
8193             }
8194           }
8195
8196           bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
8197           totlen += l1 - p1;
8198           if (!traditional && ap->raw_after == 0) {
8199             /* Ordinary expanded use of the argument.
8200                Put in newline-space markers to prevent token pasting.  */
8201             xbuf[totlen++] = '\n';
8202             xbuf[totlen++] = ' ';
8203           }
8204         } else {
8205           /* Ordinary expanded use of the argument.
8206              Put in newline-space markers to prevent token pasting.  */
8207           if (!traditional) {
8208             xbuf[totlen++] = '\n';
8209             xbuf[totlen++] = ' ';
8210           }
8211           bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
8212                  arg->expand_length);
8213           totlen += arg->expand_length;
8214           if (!traditional) {
8215             xbuf[totlen++] = '\n';
8216             xbuf[totlen++] = ' ';
8217           }
8218           /* If a macro argument with newlines is used multiple times,
8219              then only expand the newlines once.  This avoids creating output
8220              lines which don't correspond to any input line, which confuses
8221              gdb and gcov.  */
8222           if (arg->use_count > 1 && arg->newlines > 0) {
8223             /* Don't bother doing change_newlines for subsequent
8224                uses of arg.  */
8225             arg->use_count = 1;
8226             arg->expand_length
8227               = change_newlines (arg->expanded, arg->expand_length);
8228           }
8229         }
8230
8231         if (totlen > xbuf_len)
8232           abort ();
8233       }
8234
8235       /* If there is anything left of the definition after handling
8236          the arg list, copy that in too.  */
8237
8238       for (i = offset; i < defn->length; i++) {
8239         /* if we've reached the end of the macro */
8240         if (exp[i] == ')')
8241           rest_zero = 0;
8242         if (! (rest_zero && last_ap != NULL && last_ap->rest_args
8243                && last_ap->raw_after != 0))
8244           xbuf[totlen++] = exp[i];
8245       }
8246
8247       xbuf[totlen] = 0;
8248       xbuf_len = totlen;
8249
8250       for (i = 0; i < nargs; i++) {
8251         if (args[i].free1 != 0)
8252           free (args[i].free1);
8253         if (args[i].free2 != 0)
8254           free (args[i].free2);
8255       }
8256     }
8257   } else {
8258     xbuf = defn->expansion;
8259     xbuf_len = defn->length;
8260   }
8261
8262   /* Now put the expansion on the input stack
8263      so our caller will commence reading from it.  */
8264   {
8265     register FILE_BUF *ip2;
8266
8267     ip2 = &instack[++indepth];
8268
8269     ip2->fname = 0;
8270     ip2->nominal_fname = 0;
8271     ip2->inc = 0;
8272     /* This may not be exactly correct, but will give much better error
8273        messages for nested macro calls than using a line number of zero.  */
8274     ip2->lineno = start_line;
8275     ip2->buf = xbuf;
8276     ip2->length = xbuf_len;
8277     ip2->bufp = xbuf;
8278     ip2->free_ptr = (nargs > 0) ? xbuf : 0;
8279     ip2->macro = hp;
8280     ip2->if_stack = if_stack;
8281     ip2->system_header_p = 0;
8282
8283     /* Recursive macro use sometimes works traditionally.
8284        #define foo(x,y) bar (x (y,0), y)
8285        foo (foo, baz)  */
8286
8287     if (!traditional)
8288       hp->type = T_DISABLED;
8289   }
8290 }
8291 \f
8292 /* Parse a macro argument and store the info on it into *ARGPTR.
8293    REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
8294    Return nonzero to indicate a syntax error.  */
8295
8296 static char *
8297 macarg (argptr, rest_args)
8298      register struct argdata *argptr;
8299      int rest_args;
8300 {
8301   FILE_BUF *ip = &instack[indepth];
8302   int paren = 0;
8303   int newlines = 0;
8304   int comments = 0;
8305   char *result = 0;
8306
8307   /* Try to parse as much of the argument as exists at this
8308      input stack level.  */
8309   U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
8310                         &paren, &newlines, &comments, rest_args);
8311
8312   /* If we find the end of the argument at this level,
8313      set up *ARGPTR to point at it in the input stack.  */
8314   if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
8315       && bp != ip->buf + ip->length) {
8316     if (argptr != 0) {
8317       argptr->raw = ip->bufp;
8318       argptr->raw_length = bp - ip->bufp;
8319       argptr->newlines = newlines;
8320     }
8321     ip->bufp = bp;
8322   } else {
8323     /* This input stack level ends before the macro argument does.
8324        We must pop levels and keep parsing.
8325        Therefore, we must allocate a temporary buffer and copy
8326        the macro argument into it.  */
8327     int bufsize = bp - ip->bufp;
8328     int extra = newlines;
8329     U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
8330     int final_start = 0;
8331
8332     bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
8333     ip->bufp = bp;
8334     ip->lineno += newlines;
8335
8336     while (bp == ip->buf + ip->length) {
8337       if (instack[indepth].macro == 0) {
8338         result = "unterminated macro call";
8339         break;
8340       }
8341       ip->macro->type = T_MACRO;
8342       if (ip->free_ptr)
8343         free (ip->free_ptr);
8344       ip = &instack[--indepth];
8345       newlines = 0;
8346       comments = 0;
8347       bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
8348                     &newlines, &comments, rest_args);
8349       final_start = bufsize;
8350       bufsize += bp - ip->bufp;
8351       extra += newlines;
8352       buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
8353       bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
8354              bp - ip->bufp);
8355       ip->bufp = bp;
8356       ip->lineno += newlines;
8357     }
8358
8359     /* Now, if arg is actually wanted, record its raw form,
8360        discarding comments and duplicating newlines in whatever
8361        part of it did not come from a macro expansion.
8362        EXTRA space has been preallocated for duplicating the newlines.
8363        FINAL_START is the index of the start of that part.  */
8364     if (argptr != 0) {
8365       argptr->raw = buffer;
8366       argptr->raw_length = bufsize;
8367       argptr->free1 = buffer;
8368       argptr->newlines = newlines;
8369       if ((newlines || comments) && ip->fname != 0)
8370         argptr->raw_length
8371           = final_start +
8372             discard_comments (argptr->raw + final_start,
8373                               argptr->raw_length - final_start,
8374                               newlines);
8375       argptr->raw[argptr->raw_length] = 0;
8376       if (argptr->raw_length > bufsize + extra)
8377         abort ();
8378     }
8379   }
8380
8381   /* If we are not discarding this argument,
8382      macroexpand it and compute its length as stringified.
8383      All this info goes into *ARGPTR.  */
8384
8385   if (argptr != 0) {
8386     register U_CHAR *buf, *lim;
8387     register int totlen;
8388
8389     buf = argptr->raw;
8390     lim = buf + argptr->raw_length;
8391
8392     while (buf != lim && is_space[*buf])
8393       buf++;
8394     while (buf != lim && is_space[lim[-1]])
8395       lim--;
8396     totlen = traditional ? 0 : 2;       /* Count opening and closing quote.  */
8397     while (buf != lim) {
8398       register U_CHAR c = *buf++;
8399       totlen++;
8400       /* Internal sequences of whitespace are replaced by one space
8401          in most cases, but not always.  So count all the whitespace
8402          in case we need to keep it all.  */
8403 #if 0
8404       if (is_space[c])
8405         SKIP_ALL_WHITE_SPACE (buf);
8406       else
8407 #endif
8408       if (c == '\"' || c == '\\') /* escape these chars */
8409         totlen++;
8410       else if (!isprint (c))
8411         totlen += 3;
8412     }
8413     argptr->stringified_length = totlen;
8414   }
8415   return result;
8416 }
8417 \f
8418 /* Scan text from START (inclusive) up to LIMIT (exclusive),
8419    counting parens in *DEPTHPTR,
8420    and return if reach LIMIT
8421    or before a `)' that would make *DEPTHPTR negative
8422    or before a comma when *DEPTHPTR is zero.
8423    Single and double quotes are matched and termination
8424    is inhibited within them.  Comments also inhibit it.
8425    Value returned is pointer to stopping place.
8426
8427    Increment *NEWLINES each time a newline is passed.
8428    REST_ARGS notifies macarg1 that it should absorb the rest of the args.
8429    Set *COMMENTS to 1 if a comment is seen.  */
8430
8431 static U_CHAR *
8432 macarg1 (start, limit, depthptr, newlines, comments, rest_args)
8433      U_CHAR *start;
8434      register U_CHAR *limit;
8435      int *depthptr, *newlines, *comments;
8436      int rest_args;
8437 {
8438   register U_CHAR *bp = start;
8439
8440   while (bp < limit) {
8441     switch (*bp) {
8442     case '(':
8443       (*depthptr)++;
8444       break;
8445     case ')':
8446       if (--(*depthptr) < 0)
8447         return bp;
8448       break;
8449     case '\\':
8450       /* Traditionally, backslash makes following char not special.  */
8451       if (bp + 1 < limit && traditional)
8452         {
8453           bp++;
8454           /* But count source lines anyway.  */
8455           if (*bp == '\n')
8456             ++*newlines;
8457         }
8458       break;
8459     case '\n':
8460       ++*newlines;
8461       break;
8462     case '/':
8463       if (bp[1] == '\\' && bp[2] == '\n')
8464         newline_fix (bp + 1);
8465       if (bp[1] == '*') {
8466         *comments = 1;
8467         for (bp += 2; bp < limit; bp++) {
8468           if (*bp == '\n')
8469             ++*newlines;
8470           else if (*bp == '*') {
8471             if (bp[-1] == '/' && warn_comments)
8472               warning ("`/*' within comment");
8473             if (bp[1] == '\\' && bp[2] == '\n')
8474               newline_fix (bp + 1);
8475             if (bp[1] == '/') {
8476               bp++;
8477               break;
8478             }
8479           }
8480         }
8481       } else if (bp[1] == '/' && cplusplus_comments) {
8482         *comments = 1;
8483         for (bp += 2; bp < limit; bp++) {
8484           if (*bp == '\n') {
8485             ++*newlines;
8486             if (bp[-1] != '\\')
8487               break;
8488             if (warn_comments)
8489               warning ("multiline `//' comment");
8490           }
8491         }
8492       }
8493       break;
8494     case '\'':
8495     case '\"':
8496       {
8497         int quotec;
8498         for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
8499           if (*bp == '\\') {
8500             bp++;
8501             if (*bp == '\n')
8502               ++*newlines;
8503             while (*bp == '\\' && bp[1] == '\n') {
8504               bp += 2;
8505             }
8506           } else if (*bp == '\n') {
8507             ++*newlines;
8508             if (quotec == '\'')
8509               break;
8510           }
8511         }
8512       }
8513       break;
8514     case ',':
8515       /* if we've returned to lowest level and we aren't absorbing all args */
8516       if ((*depthptr) == 0 && rest_args == 0)
8517         return bp;
8518       break;
8519     }
8520     bp++;
8521   }
8522
8523   return bp;
8524 }
8525 \f
8526 /* Discard comments and duplicate newlines
8527    in the string of length LENGTH at START,
8528    except inside of string constants.
8529    The string is copied into itself with its beginning staying fixed.
8530
8531    NEWLINES is the number of newlines that must be duplicated.
8532    We assume that that much extra space is available past the end
8533    of the string.  */
8534
8535 static int
8536 discard_comments (start, length, newlines)
8537      U_CHAR *start;
8538      int length;
8539      int newlines;
8540 {
8541   register U_CHAR *ibp;
8542   register U_CHAR *obp;
8543   register U_CHAR *limit;
8544   register int c;
8545
8546   /* If we have newlines to duplicate, copy everything
8547      that many characters up.  Then, in the second part,
8548      we will have room to insert the newlines
8549      while copying down.
8550      NEWLINES may actually be too large, because it counts
8551      newlines in string constants, and we don't duplicate those.
8552      But that does no harm.  */
8553   if (newlines > 0) {
8554     ibp = start + length;
8555     obp = ibp + newlines;
8556     limit = start;
8557     while (limit != ibp)
8558       *--obp = *--ibp;
8559   }
8560
8561   ibp = start + newlines;
8562   limit = start + length + newlines;
8563   obp = start;
8564
8565   while (ibp < limit) {
8566     *obp++ = c = *ibp++;
8567     switch (c) {
8568     case '\n':
8569       /* Duplicate the newline.  */
8570       *obp++ = '\n';
8571       break;
8572
8573     case '\\':
8574       if (*ibp == '\n') {
8575         obp--;
8576         ibp++;
8577       }
8578       break;
8579
8580     case '/':
8581       if (*ibp == '\\' && ibp[1] == '\n')
8582         newline_fix (ibp);
8583       /* Delete any comment.  */
8584       if (cplusplus_comments && ibp[0] == '/') {
8585         /* Comments are equivalent to spaces.  */
8586         obp[-1] = ' ';
8587         ibp++;
8588         while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
8589           ibp++;
8590         break;
8591       }
8592       if (ibp[0] != '*' || ibp + 1 >= limit)
8593         break;
8594       /* Comments are equivalent to spaces.
8595          For -traditional, a comment is equivalent to nothing.  */
8596       if (traditional)
8597         obp--;
8598       else
8599         obp[-1] = ' ';
8600       ibp++;
8601       while (ibp + 1 < limit) {
8602         if (ibp[0] == '*'
8603             && ibp[1] == '\\' && ibp[2] == '\n')
8604           newline_fix (ibp + 1);
8605         if (ibp[0] == '*' && ibp[1] == '/')
8606           break;
8607         ibp++;
8608       }
8609       ibp += 2;
8610       break;
8611
8612     case '\'':
8613     case '\"':
8614       /* Notice and skip strings, so that we don't
8615          think that comments start inside them,
8616          and so we don't duplicate newlines in them.  */
8617       {
8618         int quotec = c;
8619         while (ibp < limit) {
8620           *obp++ = c = *ibp++;
8621           if (c == quotec)
8622             break;
8623           if (c == '\n' && quotec == '\'')
8624             break;
8625           if (c == '\\' && ibp < limit) {
8626             while (*ibp == '\\' && ibp[1] == '\n')
8627               ibp += 2;
8628             *obp++ = *ibp++;
8629           }
8630         }
8631       }
8632       break;
8633     }
8634   }
8635
8636   return obp - start;
8637 }
8638 \f
8639 /* Turn newlines to spaces in the string of length LENGTH at START,
8640    except inside of string constants.
8641    The string is copied into itself with its beginning staying fixed.  */
8642
8643 static int
8644 change_newlines (start, length)
8645      U_CHAR *start;
8646      int length;
8647 {
8648   register U_CHAR *ibp;
8649   register U_CHAR *obp;
8650   register U_CHAR *limit;
8651   register int c;
8652
8653   ibp = start;
8654   limit = start + length;
8655   obp = start;
8656
8657   while (ibp < limit) {
8658     *obp++ = c = *ibp++;
8659     switch (c) {
8660     case '\n':
8661       /* If this is a NEWLINE NEWLINE, then this is a real newline in the
8662          string.  Skip past the newline and its duplicate.
8663          Put a space in the output.  */
8664       if (*ibp == '\n')
8665         {
8666           ibp++;
8667           obp--;
8668           *obp++ = ' ';
8669         }
8670       break;
8671
8672     case '\'':
8673     case '\"':
8674       /* Notice and skip strings, so that we don't delete newlines in them.  */
8675       {
8676         int quotec = c;
8677         while (ibp < limit) {
8678           *obp++ = c = *ibp++;
8679           if (c == quotec)
8680             break;
8681           if (c == '\n' && quotec == '\'')
8682             break;
8683         }
8684       }
8685       break;
8686     }
8687   }
8688
8689   return obp - start;
8690 }
8691 \f
8692 /* my_strerror - return the descriptive text associated with an
8693    `errno' code.  */
8694
8695 char *
8696 my_strerror (errnum)
8697      int errnum;
8698 {
8699   char *result;
8700
8701 #ifndef VMS
8702 #ifndef HAVE_STRERROR
8703   result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
8704 #else
8705   result = strerror (errnum);
8706 #endif
8707 #else   /* VMS */
8708   /* VAXCRTL's strerror() takes an optional second argument, which only
8709      matters when the first argument is EVMSERR.  However, it's simplest
8710      just to pass it unconditionally.  `vaxc$errno' is declared in
8711      <errno.h>, and maintained by the library in parallel with `errno'.
8712      We assume that caller's `errnum' either matches the last setting of
8713      `errno' by the library or else does not have the value `EVMSERR'.  */
8714
8715   result = strerror (errnum, vaxc$errno);
8716 #endif
8717
8718   if (!result)
8719     result = "undocumented I/O error";
8720
8721   return result;
8722 }
8723
8724 /* error - print error message and increment count of errors.  */
8725
8726 void
8727 error (PRINTF_ALIST (msg))
8728      PRINTF_DCL (msg)
8729 {
8730   va_list args;
8731
8732   VA_START (args, msg);
8733   verror (msg, args);
8734   va_end (args);
8735 }
8736
8737 static void
8738 verror (msg, args)
8739      char *msg;
8740      va_list args;
8741 {
8742   int i;
8743   FILE_BUF *ip = NULL;
8744
8745   print_containing_files ();
8746
8747   for (i = indepth; i >= 0; i--)
8748     if (instack[i].fname != NULL) {
8749       ip = &instack[i];
8750       break;
8751     }
8752
8753   if (ip != NULL)
8754     fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8755   vfprintf (stderr, msg, args);
8756   fprintf (stderr, "\n");
8757   errors++;
8758 }
8759
8760 /* Error including a message from `errno'.  */
8761
8762 static void
8763 error_from_errno (name)
8764      char *name;
8765 {
8766   int i;
8767   FILE_BUF *ip = NULL;
8768
8769   print_containing_files ();
8770
8771   for (i = indepth; i >= 0; i--)
8772     if (instack[i].fname != NULL) {
8773       ip = &instack[i];
8774       break;
8775     }
8776
8777   if (ip != NULL)
8778     fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8779
8780   fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
8781
8782   errors++;
8783 }
8784
8785 /* Print error message but don't count it.  */
8786
8787 void
8788 warning (PRINTF_ALIST (msg))
8789      PRINTF_DCL (msg)
8790 {
8791   va_list args;
8792
8793   VA_START (args, msg);
8794   vwarning (msg, args);
8795   va_end (args);
8796 }
8797
8798 static void
8799 vwarning (msg, args)
8800      char *msg;
8801      va_list args;
8802 {
8803   int i;
8804   FILE_BUF *ip = NULL;
8805
8806   if (inhibit_warnings)
8807     return;
8808
8809   if (warnings_are_errors)
8810     errors++;
8811
8812   print_containing_files ();
8813
8814   for (i = indepth; i >= 0; i--)
8815     if (instack[i].fname != NULL) {
8816       ip = &instack[i];
8817       break;
8818     }
8819
8820   if (ip != NULL)
8821     fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
8822   fprintf (stderr, "warning: ");
8823   vfprintf (stderr, msg, args);
8824   fprintf (stderr, "\n");
8825 }
8826
8827 static void
8828 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8829 error_with_line (int line, PRINTF_ALIST (msg))
8830 #else
8831 error_with_line (line, PRINTF_ALIST (msg))
8832      int line;
8833      PRINTF_DCL (msg)
8834 #endif
8835 {
8836   va_list args;
8837
8838   VA_START (args, msg);
8839   verror_with_line (line, msg, args);
8840   va_end (args);
8841 }
8842
8843 static void
8844 verror_with_line (line, msg, args)
8845      int line;
8846      char *msg;
8847      va_list args;
8848 {
8849   int i;
8850   FILE_BUF *ip = NULL;
8851
8852   print_containing_files ();
8853
8854   for (i = indepth; i >= 0; i--)
8855     if (instack[i].fname != NULL) {
8856       ip = &instack[i];
8857       break;
8858     }
8859
8860   if (ip != NULL)
8861     fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
8862   vfprintf (stderr, msg, args);
8863   fprintf (stderr, "\n");
8864   errors++;
8865 }
8866
8867 static void
8868 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8869 warning_with_line (int line, PRINTF_ALIST (msg))
8870 #else
8871 warning_with_line (line, PRINTF_ALIST (msg))
8872      int line;
8873      PRINTF_DCL (msg)
8874 #endif
8875 {
8876   va_list args;
8877
8878   VA_START (args, msg);
8879   vwarning_with_line (line, msg, args);
8880   va_end (args);
8881 }
8882
8883 static void
8884 vwarning_with_line (line, msg, args)
8885      int line;
8886      char *msg;
8887      va_list args;
8888 {
8889   int i;
8890   FILE_BUF *ip = NULL;
8891
8892   if (inhibit_warnings)
8893     return;
8894
8895   if (warnings_are_errors)
8896     errors++;
8897
8898   print_containing_files ();
8899
8900   for (i = indepth; i >= 0; i--)
8901     if (instack[i].fname != NULL) {
8902       ip = &instack[i];
8903       break;
8904     }
8905
8906   if (ip != NULL)
8907     fprintf (stderr, line ? "%s:%d: " : "%s: ", ip->nominal_fname, line);
8908   fprintf (stderr, "warning: ");
8909   vfprintf (stderr, msg, args);
8910   fprintf (stderr, "\n");
8911 }
8912
8913 /* Print an error message and maybe count it.  */
8914
8915 void
8916 pedwarn (PRINTF_ALIST (msg))
8917      PRINTF_DCL (msg)
8918 {
8919   va_list args;
8920
8921   VA_START (args, msg);
8922   if (pedantic_errors)
8923     verror (msg, args);
8924   else
8925     vwarning (msg, args);
8926   va_end (args);
8927 }
8928
8929 void
8930 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8931 pedwarn_with_line (int line, PRINTF_ALIST (msg))
8932 #else
8933 pedwarn_with_line (line, PRINTF_ALIST (msg))
8934      int line;
8935      PRINTF_DCL (msg)
8936 #endif
8937 {
8938   va_list args;
8939
8940   VA_START (args, msg);
8941   if (pedantic_errors)
8942     verror_with_line (line, msg, args);
8943   else
8944     vwarning_with_line (line, msg, args);
8945   va_end (args);
8946 }
8947
8948 /* Report a warning (or an error if pedantic_errors)
8949    giving specified file name and line number, not current.  */
8950
8951 static void
8952 #if defined (__STDC__) && defined (HAVE_VPRINTF)
8953 pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
8954 #else
8955 pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
8956      char *file;
8957      int line;
8958      PRINTF_DCL (msg)
8959 #endif
8960 {
8961   va_list args;
8962
8963   if (!pedantic_errors && inhibit_warnings)
8964     return;
8965   if (file != NULL)
8966     fprintf (stderr, "%s:%d: ", file, line);
8967   if (pedantic_errors)
8968     errors++;
8969   if (!pedantic_errors)
8970     fprintf (stderr, "warning: ");
8971   VA_START (args, msg);
8972   vfprintf (stderr, msg, args);
8973   va_end (args);
8974   fprintf (stderr, "\n");
8975 }
8976 \f
8977 /* Print the file names and line numbers of the #include
8978    directives which led to the current file.  */
8979
8980 static void
8981 print_containing_files ()
8982 {
8983   FILE_BUF *ip = NULL;
8984   int i;
8985   int first = 1;
8986
8987   /* If stack of files hasn't changed since we last printed
8988      this info, don't repeat it.  */
8989   if (last_error_tick == input_file_stack_tick)
8990     return;
8991
8992   for (i = indepth; i >= 0; i--)
8993     if (instack[i].fname != NULL) {
8994       ip = &instack[i];
8995       break;
8996     }
8997
8998   /* Give up if we don't find a source file.  */
8999   if (ip == NULL)
9000     return;
9001
9002   /* Find the other, outer source files.  */
9003   for (i--; i >= 0; i--)
9004     if (instack[i].fname != NULL) {
9005       ip = &instack[i];
9006       if (first) {
9007         first = 0;
9008         fprintf (stderr, "In file included");
9009       } else {
9010         fprintf (stderr, ",\n                ");
9011       }
9012
9013       fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
9014     }
9015   if (! first)
9016     fprintf (stderr, ":\n");
9017
9018   /* Record we have printed the status as of this time.  */
9019   last_error_tick = input_file_stack_tick;
9020 }
9021 \f
9022 /* Return the line at which an error occurred.
9023    The error is not necessarily associated with the current spot
9024    in the input stack, so LINE says where.  LINE will have been
9025    copied from ip->lineno for the current input level.
9026    If the current level is for a file, we return LINE.
9027    But if the current level is not for a file, LINE is meaningless.
9028    In that case, we return the lineno of the innermost file.  */
9029
9030 static int
9031 line_for_error (line)
9032      int line;
9033 {
9034   int i;
9035   int line1 = line;
9036
9037   for (i = indepth; i >= 0; ) {
9038     if (instack[i].fname != 0)
9039       return line1;
9040     i--;
9041     if (i < 0)
9042       return 0;
9043     line1 = instack[i].lineno;
9044   }
9045   abort ();
9046   /*NOTREACHED*/
9047   return 0;
9048 }
9049
9050 /*
9051  * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
9052  *
9053  * As things stand, nothing is ever placed in the output buffer to be
9054  * removed again except when it's KNOWN to be part of an identifier,
9055  * so flushing and moving down everything left, instead of expanding,
9056  * should work ok.
9057  */
9058
9059 /* You might think void was cleaner for the return type,
9060    but that would get type mismatch in check_expand in strict ANSI.  */
9061
9062 static int
9063 grow_outbuf (obuf, needed)
9064      register FILE_BUF *obuf;
9065      register int needed;
9066 {
9067   register U_CHAR *p;
9068   int minsize;
9069
9070   if (obuf->length - (obuf->bufp - obuf->buf) > needed)
9071     return 0;
9072
9073   /* Make it at least twice as big as it is now.  */
9074   obuf->length *= 2;
9075   /* Make it have at least 150% of the free space we will need.  */
9076   minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
9077   if (minsize > obuf->length)
9078     obuf->length = minsize;
9079
9080   if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
9081     memory_full ();
9082
9083   obuf->bufp = p + (obuf->bufp - obuf->buf);
9084   obuf->buf = p;
9085
9086   return 0;
9087 }
9088 \f
9089 /* Symbol table for macro names and special symbols */
9090
9091 /*
9092  * install a name in the main hash table, even if it is already there.
9093  *   name stops with first non alphanumeric, except leading '#'.
9094  * caller must check against redefinition if that is desired.
9095  * delete_macro () removes things installed by install () in fifo order.
9096  * this is important because of the `defined' special symbol used
9097  * in #if, and also if pushdef/popdef directives are ever implemented.
9098  *
9099  * If LEN is >= 0, it is the length of the name.
9100  * Otherwise, compute the length by scanning the entire name.
9101  *
9102  * If HASH is >= 0, it is the precomputed hash code.
9103  * Otherwise, compute the hash code.
9104  */
9105
9106 static HASHNODE *
9107 install (name, len, type, value, hash)
9108      U_CHAR *name;
9109      int len;
9110      enum node_type type;
9111      char *value;
9112      int hash;
9113 {
9114   register HASHNODE *hp;
9115   register int i, bucket;
9116   register U_CHAR *p, *q;
9117
9118   if (len < 0) {
9119     p = name;
9120     while (is_idchar[*p])
9121       p++;
9122     len = p - name;
9123   }
9124
9125   if (hash < 0)
9126     hash = hashf (name, len, HASHSIZE);
9127
9128   i = sizeof (HASHNODE) + len + 1;
9129   hp = (HASHNODE *) xmalloc (i);
9130   bucket = hash;
9131   hp->bucket_hdr = &hashtab[bucket];
9132   hp->next = hashtab[bucket];
9133   hashtab[bucket] = hp;
9134   hp->prev = NULL;
9135   if (hp->next != NULL)
9136     hp->next->prev = hp;
9137   hp->type = type;
9138   hp->length = len;
9139   hp->value.cpval = value;
9140   hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
9141   p = hp->name;
9142   q = name;
9143   for (i = 0; i < len; i++)
9144     *p++ = *q++;
9145   hp->name[len] = 0;
9146   return hp;
9147 }
9148
9149 /*
9150  * find the most recent hash node for name name (ending with first
9151  * non-identifier char) installed by install
9152  *
9153  * If LEN is >= 0, it is the length of the name.
9154  * Otherwise, compute the length by scanning the entire name.
9155  *
9156  * If HASH is >= 0, it is the precomputed hash code.
9157  * Otherwise, compute the hash code.
9158  */
9159
9160 HASHNODE *
9161 lookup (name, len, hash)
9162      U_CHAR *name;
9163      int len;
9164      int hash;
9165 {
9166   register U_CHAR *bp;
9167   register HASHNODE *bucket;
9168
9169   if (len < 0) {
9170     for (bp = name; is_idchar[*bp]; bp++) ;
9171     len = bp - name;
9172   }
9173
9174   if (hash < 0)
9175     hash = hashf (name, len, HASHSIZE);
9176
9177   bucket = hashtab[hash];
9178   while (bucket) {
9179     if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
9180       return bucket;
9181     bucket = bucket->next;
9182   }
9183   return NULL;
9184 }
9185
9186 /*
9187  * Delete a hash node.  Some weirdness to free junk from macros.
9188  * More such weirdness will have to be added if you define more hash
9189  * types that need it.
9190  */
9191
9192 /* Note that the DEFINITION of a macro is removed from the hash table
9193    but its storage is not freed.  This would be a storage leak
9194    except that it is not reasonable to keep undefining and redefining
9195    large numbers of macros many times.
9196    In any case, this is necessary, because a macro can be #undef'd
9197    in the middle of reading the arguments to a call to it.
9198    If #undef freed the DEFINITION, that would crash.  */
9199
9200 static void
9201 delete_macro (hp)
9202      HASHNODE *hp;
9203 {
9204
9205   if (hp->prev != NULL)
9206     hp->prev->next = hp->next;
9207   if (hp->next != NULL)
9208     hp->next->prev = hp->prev;
9209
9210   /* Make sure that the bucket chain header that the deleted guy was
9211      on points to the right thing afterwards.  */
9212   if (hp == *hp->bucket_hdr)
9213     *hp->bucket_hdr = hp->next;
9214
9215 #if 0
9216   if (hp->type == T_MACRO) {
9217     DEFINITION *d = hp->value.defn;
9218     struct reflist *ap, *nextap;
9219
9220     for (ap = d->pattern; ap != NULL; ap = nextap) {
9221       nextap = ap->next;
9222       free (ap);
9223     }
9224     free (d);
9225   }
9226 #endif
9227   free (hp);
9228 }
9229
9230 /*
9231  * return hash function on name.  must be compatible with the one
9232  * computed a step at a time, elsewhere
9233  */
9234
9235 static int
9236 hashf (name, len, hashsize)
9237      register U_CHAR *name;
9238      register int len;
9239      int hashsize;
9240 {
9241   register int r = 0;
9242
9243   while (len--)
9244     r = HASHSTEP (r, *name++);
9245
9246   return MAKE_POS (r) % hashsize;
9247 }
9248 \f
9249
9250 /* Dump the definition of a single macro HP to OF.  */
9251
9252 static void
9253 dump_single_macro (hp, of)
9254      register HASHNODE *hp;
9255      FILE *of;
9256 {
9257   register DEFINITION *defn = hp->value.defn;
9258   struct reflist *ap;
9259   int offset;
9260   int concat;
9261
9262
9263   /* Print the definition of the macro HP.  */
9264
9265   fprintf (of, "#define %s", hp->name);
9266
9267   if (defn->nargs >= 0) {
9268     int i;
9269
9270     fprintf (of, "(");
9271     for (i = 0; i < defn->nargs; i++) {
9272       dump_arg_n (defn, i, of);
9273       if (i + 1 < defn->nargs)
9274         fprintf (of, ", ");
9275     }
9276     fprintf (of, ")");
9277   }
9278
9279   fprintf (of, " ");
9280
9281   offset = 0;
9282   concat = 0;
9283   for (ap = defn->pattern; ap != NULL; ap = ap->next) {
9284     dump_defn_1 (defn->expansion, offset, ap->nchars, of);
9285     offset += ap->nchars;
9286     if (!traditional) {
9287       if (ap->nchars != 0)
9288         concat = 0;
9289       if (ap->stringify) {
9290         switch (ap->stringify) {
9291          case SHARP_TOKEN: fprintf (of, "#"); break;
9292          case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
9293          case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
9294          case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
9295          default: abort ();
9296         }
9297       }
9298       if (ap->raw_before != 0) {
9299         if (concat) {
9300           switch (ap->raw_before) {
9301            case WHITE_SHARP_TOKEN:
9302            case WHITE_PERCENT_COLON_TOKEN:
9303             fprintf (of, " ");
9304             break;
9305            default:
9306             break;
9307           }
9308         } else {
9309           switch (ap->raw_before) {
9310            case SHARP_TOKEN: fprintf (of, "##"); break;
9311            case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
9312            case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9313            case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
9314            default: abort ();
9315           }
9316         }
9317       }
9318       concat = 0;
9319     }
9320     dump_arg_n (defn, ap->argno, of);
9321     if (!traditional && ap->raw_after != 0) {
9322       switch (ap->raw_after) {
9323        case SHARP_TOKEN: fprintf (of, "##"); break;
9324        case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
9325        case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
9326        case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
9327        default: abort ();
9328       }
9329       concat = 1;
9330     }
9331   }
9332   dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
9333   fprintf (of, "\n");
9334 }
9335
9336 /* Dump all macro definitions as #defines to stdout.  */
9337
9338 static void
9339 dump_all_macros ()
9340 {
9341   int bucket;
9342
9343   for (bucket = 0; bucket < HASHSIZE; bucket++) {
9344     register HASHNODE *hp;
9345
9346     for (hp = hashtab[bucket]; hp; hp= hp->next) {
9347       if (hp->type == T_MACRO)
9348         dump_single_macro (hp, stdout);
9349     }
9350   }
9351 }
9352
9353 /* Output to OF a substring of a macro definition.
9354    BASE is the beginning of the definition.
9355    Output characters START thru LENGTH.
9356    Unless traditional, discard newlines outside of strings, thus
9357    converting funny-space markers to ordinary spaces.  */
9358
9359 static void
9360 dump_defn_1 (base, start, length, of)
9361      U_CHAR *base;
9362      int start;
9363      int length;
9364      FILE *of;
9365 {
9366   U_CHAR *p = base + start;
9367   U_CHAR *limit = base + start + length;
9368
9369   if (traditional)
9370     fwrite (p, sizeof (*p), length, of);
9371   else {
9372     while (p < limit) {
9373       if (*p == '\"' || *p =='\'') {
9374         U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
9375                                          NULL_PTR, NULL_PTR);
9376         fwrite (p, sizeof (*p), p1 - p, of);
9377         p = p1;
9378       } else {
9379         if (*p != '\n')
9380           putc (*p, of);
9381         p++;
9382       }
9383     }
9384   }
9385 }
9386
9387 /* Print the name of argument number ARGNUM of macro definition DEFN
9388    to OF.
9389    Recall that DEFN->args.argnames contains all the arg names
9390    concatenated in reverse order with comma-space in between.  */
9391
9392 static void
9393 dump_arg_n (defn, argnum, of)
9394      DEFINITION *defn;
9395      int argnum;
9396      FILE *of;
9397 {
9398   register U_CHAR *p = defn->args.argnames;
9399   while (argnum + 1 < defn->nargs) {
9400     p = (U_CHAR *) index ((char *) p, ' ') + 1;
9401     argnum++;
9402   }
9403
9404   while (*p && *p != ',') {
9405     putc (*p, of);
9406     p++;
9407   }
9408 }
9409 \f
9410 /* Initialize syntactic classifications of characters.  */
9411
9412 static void
9413 initialize_char_syntax ()
9414 {
9415   register int i;
9416
9417   /*
9418    * Set up is_idchar and is_idstart tables.  These should be
9419    * faster than saying (is_alpha (c) || c == '_'), etc.
9420    * Set up these things before calling any routines tthat
9421    * refer to them.
9422    */
9423   for (i = 'a'; i <= 'z'; i++) {
9424     is_idchar[i - 'a' + 'A'] = 1;
9425     is_idchar[i] = 1;
9426     is_idstart[i - 'a' + 'A'] = 1;
9427     is_idstart[i] = 1;
9428   }
9429   for (i = '0'; i <= '9'; i++)
9430     is_idchar[i] = 1;
9431   is_idchar['_'] = 1;
9432   is_idstart['_'] = 1;
9433   is_idchar['$'] = 1;
9434   is_idstart['$'] = 1;
9435
9436   /* horizontal space table */
9437   is_hor_space[' '] = 1;
9438   is_hor_space['\t'] = 1;
9439   is_hor_space['\v'] = 1;
9440   is_hor_space['\f'] = 1;
9441   is_hor_space['\r'] = 1;
9442
9443   is_space[' '] = 1;
9444   is_space['\t'] = 1;
9445   is_space['\v'] = 1;
9446   is_space['\f'] = 1;
9447   is_space['\n'] = 1;
9448   is_space['\r'] = 1;
9449
9450   char_name['\v'] = "vertical tab";
9451   char_name['\f'] = "formfeed";
9452   char_name['\r'] = "carriage return";
9453 }
9454
9455 /* Initialize the built-in macros.  */
9456
9457 static void
9458 initialize_builtins (inp, outp)
9459      FILE_BUF *inp;
9460      FILE_BUF *outp;
9461 {
9462   install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
9463   install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
9464   install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
9465   install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
9466   install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
9467   install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
9468 #ifndef NO_BUILTIN_SIZE_TYPE
9469   install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
9470 #endif
9471 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9472   install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
9473 #endif
9474   install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
9475   install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
9476            NULL_PTR, -1);
9477   install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
9478            NULL_PTR, -1);
9479   install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
9480            NULL_PTR, -1);
9481   install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
9482   if (!traditional) {
9483     install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
9484     install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
9485   }
9486   if (objc)
9487     install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
9488 /*  This is supplied using a -D by the compiler driver
9489     so that it is present only when truly compiling with GNU C.  */
9490 /*  install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1);  */
9491   install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
9492
9493   if (debug_output)
9494     {
9495       char directive[2048];
9496       U_CHAR *udirective = (U_CHAR *) directive;
9497       register struct directive *dp = &directive_table[0];
9498       struct tm *timebuf = timestamp ();
9499
9500       sprintf (directive, " __BASE_FILE__ \"%s\"\n",
9501                instack[0].nominal_fname);
9502       output_line_directive (inp, outp, 0, same_file);
9503       pass_thru_directive (udirective, &udirective[strlen (directive)],
9504                            outp, dp);
9505
9506       sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
9507       output_line_directive (inp, outp, 0, same_file);
9508       pass_thru_directive (udirective, &udirective[strlen (directive)],
9509                            outp, dp);
9510
9511 #ifndef NO_BUILTIN_SIZE_TYPE
9512       sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
9513       output_line_directive (inp, outp, 0, same_file);
9514       pass_thru_directive (udirective, &udirective[strlen (directive)],
9515                            outp, dp);
9516 #endif
9517
9518 #ifndef NO_BUILTIN_PTRDIFF_TYPE
9519       sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
9520       output_line_directive (inp, outp, 0, same_file);
9521       pass_thru_directive (udirective, &udirective[strlen (directive)],
9522                            outp, dp);
9523 #endif
9524
9525       sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
9526       output_line_directive (inp, outp, 0, same_file);
9527       pass_thru_directive (udirective, &udirective[strlen (directive)],
9528                            outp, dp);
9529
9530       sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
9531                monthnames[timebuf->tm_mon],
9532                timebuf->tm_mday, timebuf->tm_year + 1900);
9533       output_line_directive (inp, outp, 0, same_file);
9534       pass_thru_directive (udirective, &udirective[strlen (directive)],
9535                            outp, dp);
9536
9537       sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
9538                timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
9539       output_line_directive (inp, outp, 0, same_file);
9540       pass_thru_directive (udirective, &udirective[strlen (directive)],
9541                            outp, dp);
9542
9543       if (!traditional)
9544         {
9545           sprintf (directive, " __STDC__ 1");
9546           output_line_directive (inp, outp, 0, same_file);
9547           pass_thru_directive (udirective, &udirective[strlen (directive)],
9548                                outp, dp);
9549         }
9550       if (objc)
9551         {
9552           sprintf (directive, " __OBJC__ 1");
9553           output_line_directive (inp, outp, 0, same_file);
9554           pass_thru_directive (udirective, &udirective[strlen (directive)],
9555                                outp, dp);
9556         }
9557     }
9558 }
9559 \f
9560 /*
9561  * process a given definition string, for initialization
9562  * If STR is just an identifier, define it with value 1.
9563  * If STR has anything after the identifier, then it should
9564  * be identifier=definition.
9565  */
9566
9567 static void
9568 make_definition (str, op)
9569      char *str;
9570      FILE_BUF *op;
9571 {
9572   FILE_BUF *ip;
9573   struct directive *kt;
9574   U_CHAR *buf, *p;
9575
9576   p = buf = (U_CHAR *) str;
9577   if (!is_idstart[*p]) {
9578     error ("malformed option `-D %s'", str);
9579     return;
9580   }
9581   while (is_idchar[*++p])
9582     ;
9583   if (*p == '(') {
9584     while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
9585       ;
9586     if (*p++ != ')')
9587       p = (U_CHAR *) str;                       /* Error */
9588   }
9589   if (*p == 0) {
9590     buf = (U_CHAR *) alloca (p - buf + 4);
9591     strcpy ((char *)buf, str);
9592     strcat ((char *)buf, " 1");
9593   } else if (*p != '=') {
9594     error ("malformed option `-D %s'", str);
9595     return;
9596   } else {
9597     U_CHAR *q;
9598     /* Copy the entire option so we can modify it.  */
9599     buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
9600     strncpy ((char *) buf, str, p - (U_CHAR *) str);
9601     /* Change the = to a space.  */
9602     buf[p - (U_CHAR *) str] = ' ';
9603     /* Scan for any backslash-newline and remove it.  */
9604     p++;
9605     q = &buf[p - (U_CHAR *) str];
9606     while (*p) {
9607       if (*p == '\"' || *p == '\'') {
9608         int unterminated = 0;
9609         U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
9610                                          NULL_PTR, NULL_PTR, &unterminated);
9611         if (unterminated)
9612           return;
9613         while (p != p1)
9614           if (*p == '\\' && p[1] == '\n')
9615             p += 2;
9616           else
9617             *q++ = *p++;
9618       } else if (*p == '\\' && p[1] == '\n')
9619         p += 2;
9620       /* Change newline chars into newline-markers.  */
9621       else if (*p == '\n')
9622         {
9623           *q++ = '\n';
9624           *q++ = '\n';
9625           p++;
9626         }
9627       else
9628         *q++ = *p++;
9629     }
9630     *q = 0;
9631   }
9632
9633   ip = &instack[++indepth];
9634   ip->nominal_fname = ip->fname = "*Initialization*";
9635
9636   ip->buf = ip->bufp = buf;
9637   ip->length = strlen ((char *) buf);
9638   ip->lineno = 1;
9639   ip->macro = 0;
9640   ip->free_ptr = 0;
9641   ip->if_stack = if_stack;
9642   ip->system_header_p = 0;
9643
9644   for (kt = directive_table; kt->type != T_DEFINE; kt++)
9645     ;
9646
9647   /* Pass NULL instead of OP, since this is a "predefined" macro.  */
9648   do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
9649   --indepth;
9650 }
9651
9652 /* JF, this does the work for the -U option */
9653
9654 static void
9655 make_undef (str, op)
9656      char *str;
9657      FILE_BUF *op;
9658 {
9659   FILE_BUF *ip;
9660   struct directive *kt;
9661
9662   ip = &instack[++indepth];
9663   ip->nominal_fname = ip->fname = "*undef*";
9664
9665   ip->buf = ip->bufp = (U_CHAR *) str;
9666   ip->length = strlen (str);
9667   ip->lineno = 1;
9668   ip->macro = 0;
9669   ip->free_ptr = 0;
9670   ip->if_stack = if_stack;
9671   ip->system_header_p = 0;
9672
9673   for (kt = directive_table; kt->type != T_UNDEF; kt++)
9674     ;
9675
9676   do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
9677   --indepth;
9678 }
9679 \f
9680 /* Process the string STR as if it appeared as the body of a #assert.
9681    OPTION is the option name for which STR was the argument.  */
9682
9683 static void
9684 make_assertion (option, str)
9685      char *option;
9686      char *str;
9687 {
9688   FILE_BUF *ip;
9689   struct directive *kt;
9690   U_CHAR *buf, *p, *q;
9691
9692   /* Copy the entire option so we can modify it.  */
9693   buf = (U_CHAR *) alloca (strlen (str) + 1);
9694   strcpy ((char *) buf, str);
9695   /* Scan for any backslash-newline and remove it.  */
9696   p = q = buf;
9697   while (*p) {
9698     if (*p == '\\' && p[1] == '\n')
9699       p += 2;
9700     else
9701       *q++ = *p++;
9702   }
9703   *q = 0;
9704
9705   p = buf;
9706   if (!is_idstart[*p]) {
9707     error ("malformed option `%s %s'", option, str);
9708     return;
9709   }
9710   while (is_idchar[*++p])
9711     ;
9712   SKIP_WHITE_SPACE (p);
9713   if (! (*p == 0 || *p == '(')) {
9714     error ("malformed option `%s %s'", option, str);
9715     return;
9716   }
9717
9718   ip = &instack[++indepth];
9719   ip->nominal_fname = ip->fname = "*Initialization*";
9720
9721   ip->buf = ip->bufp = buf;
9722   ip->length = strlen ((char *) buf);
9723   ip->lineno = 1;
9724   ip->macro = 0;
9725   ip->free_ptr = 0;
9726   ip->if_stack = if_stack;
9727   ip->system_header_p = 0;
9728
9729   for (kt = directive_table; kt->type != T_ASSERT; kt++)
9730     ;
9731
9732   /* Pass NULL as output ptr to do_define since we KNOW it never does
9733      any output....  */
9734   do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
9735   --indepth;
9736 }
9737 \f
9738 /* The previous include prefix, if any, is PREV_FILE_NAME.
9739    Allocate a new include prefix whose name is the
9740    simplified concatenation of PREFIX and NAME,
9741    with a trailing / added if needed.
9742    But return 0 if the include prefix should be ignored,
9743    e.g. because it is a duplicate of PREV_FILE_NAME.  */
9744
9745 static struct file_name_list *
9746 new_include_prefix (prev_file_name, prefix, name)
9747      struct file_name_list *prev_file_name;
9748      char *prefix;
9749      char *name;
9750 {
9751   if (!name)
9752     fatal ("Directory name missing after command line option");
9753
9754   if (!*name)
9755     /* Ignore the empty string.  */
9756     return 0;
9757   else {
9758     struct file_name_list *dir
9759       = ((struct file_name_list *)
9760          xmalloc (sizeof (struct file_name_list)
9761                   + strlen (prefix) + strlen (name) + 1 /* for trailing / */));
9762     size_t len;
9763     strcpy (dir->fname, prefix);
9764     strcat (dir->fname, name);
9765     len = simplify_filename (dir->fname);
9766
9767     /* Convert directory name to a prefix.  */
9768     if (dir->fname[len - 1] != '/') {
9769       if (len == 1 && dir->fname[len - 1] == '.')
9770         len = 0;
9771       else
9772         dir->fname[len++] = '/';
9773       dir->fname[len] = 0;
9774     }
9775
9776     /* Ignore a directory whose name matches the previous one.  */
9777     if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
9778       /* But treat `-Idir -I- -Idir' as `-I- -Idir'.  */
9779       if (!first_bracket_include)
9780         first_bracket_include = prev_file_name;
9781       free (dir);
9782       return 0;
9783     }
9784
9785 #ifndef VMS
9786     /* VMS can't stat dir prefixes, so skip these optimizations in VMS.  */
9787
9788     /* Ignore a nonexistent directory.  */
9789     if (stat (len ? dir->fname : ".", &dir->st) != 0) {
9790       if (errno != ENOENT && errno != ENOTDIR)
9791         error_from_errno (dir->fname);
9792       free (dir);
9793       return 0;
9794     }
9795
9796     /* Ignore a directory whose identity matches the previous one.  */
9797     if (prev_file_name
9798         && INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
9799         && prev_file_name->st.st_dev == dir->st.st_dev) {
9800       /* But treat `-Idir -I- -Idir' as `-I- -Idir'.  */
9801       if (!first_bracket_include)
9802         first_bracket_include = prev_file_name;
9803       free (dir);
9804       return 0;
9805     }
9806 #endif /* ! VMS */
9807
9808     dir->next = 0;
9809     dir->c_system_include_path = 0;
9810     dir->got_name_map = 0;
9811
9812     return dir;
9813   }
9814 }
9815
9816 /* Append a chain of `struct file_name_list's
9817    to the end of the main include chain.
9818    FIRST is the beginning of the chain to append, and LAST is the end.  */
9819
9820 static void
9821 append_include_chain (first, last)
9822      struct file_name_list *first, *last;
9823 {
9824   struct file_name_list *dir;
9825
9826   if (!first || !last)
9827     return;
9828
9829   if (include == 0)
9830     include = first;
9831   else
9832     last_include->next = first;
9833
9834   if (first_bracket_include == 0)
9835     first_bracket_include = first;
9836
9837   for (dir = first; ; dir = dir->next) {
9838     int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
9839     if (len > max_include_len)
9840       max_include_len = len;
9841     if (dir == last)
9842       break;
9843   }
9844
9845   last->next = NULL;
9846   last_include = last;
9847 }
9848 \f
9849 /* Add output to `deps_buffer' for the -M switch.
9850    STRING points to the text to be output.
9851    SPACER is ':' for targets, ' ' for dependencies.  */
9852
9853 static void
9854 deps_output (string, spacer)
9855      char *string;
9856      int spacer;
9857 {
9858   int size = strlen (string);
9859
9860   if (size == 0)
9861     return;
9862
9863 #ifndef MAX_OUTPUT_COLUMNS
9864 #define MAX_OUTPUT_COLUMNS 72
9865 #endif
9866   if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
9867       && 1 < deps_column) {
9868     bcopy (" \\\n ", &deps_buffer[deps_size], 4);
9869     deps_size += 4;
9870     deps_column = 1;
9871     if (spacer == ' ')
9872       spacer = 0;
9873   }
9874
9875   if (deps_size + size + 8 > deps_allocated_size) {
9876     deps_allocated_size = (deps_size + size + 50) * 2;
9877     deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
9878   }
9879   if (spacer == ' ') {
9880     deps_buffer[deps_size++] = ' ';
9881     deps_column++;
9882   }
9883   bcopy (string, &deps_buffer[deps_size], size);
9884   deps_size += size;
9885   deps_column += size;
9886   if (spacer == ':') {
9887     deps_buffer[deps_size++] = ':';
9888     deps_column++;
9889   }
9890   deps_buffer[deps_size] = 0;
9891 }
9892 \f
9893 static void
9894 fatal (PRINTF_ALIST (msg))
9895      PRINTF_DCL (msg)
9896 {
9897   va_list args;
9898
9899   fprintf (stderr, "%s: ", progname);
9900   VA_START (args, msg);
9901   vfprintf (stderr, msg, args);
9902   va_end (args);
9903   fprintf (stderr, "\n");
9904   exit (FATAL_EXIT_CODE);
9905 }
9906
9907 /* More 'friendly' abort that prints the line and file.
9908    config.h can #define abort fancy_abort if you like that sort of thing.  */
9909
9910 void
9911 fancy_abort ()
9912 {
9913   fatal ("Internal gcc abort.");
9914 }
9915
9916 static void
9917 perror_with_name (name)
9918      char *name;
9919 {
9920   fprintf (stderr, "%s: ", progname);
9921   fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
9922   errors++;
9923 }
9924
9925 static void
9926 pfatal_with_name (name)
9927      char *name;
9928 {
9929   perror_with_name (name);
9930 #ifdef VMS
9931   exit (vaxc$errno);
9932 #else
9933   exit (FATAL_EXIT_CODE);
9934 #endif
9935 }
9936
9937 /* Handler for SIGPIPE.  */
9938
9939 static void
9940 pipe_closed (signo)
9941      /* If this is missing, some compilers complain.  */
9942      int signo;
9943 {
9944   fatal ("output pipe has been closed");
9945 }
9946 \f
9947 static void
9948 memory_full ()
9949 {
9950   fatal ("Memory exhausted.");
9951 }
9952
9953
9954 GENERIC_PTR
9955 xmalloc (size)
9956      size_t size;
9957 {
9958   register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
9959   if (!ptr)
9960     memory_full ();
9961   return ptr;
9962 }
9963
9964 static GENERIC_PTR
9965 xrealloc (old, size)
9966      GENERIC_PTR old;
9967      size_t size;
9968 {
9969   register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
9970   if (!ptr)
9971     memory_full ();
9972   return ptr;
9973 }
9974
9975 static GENERIC_PTR
9976 xcalloc (number, size)
9977      size_t number, size;
9978 {
9979   register size_t total = number * size;
9980   register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
9981   if (!ptr)
9982     memory_full ();
9983   bzero (ptr, total);
9984   return ptr;
9985 }
9986
9987 static char *
9988 savestring (input)
9989      char *input;
9990 {
9991   size_t size = strlen (input);
9992   char *output = xmalloc (size + 1);
9993   strcpy (output, input);
9994   return output;
9995 }
9996 \f
9997 #ifdef VMS
9998
9999 /* Under VMS we need to fix up the "include" specification filename so
10000    that everything following the 1st slash is changed into its correct
10001    VMS file specification.  */
10002
10003 static void
10004 hack_vms_include_specification (fname)
10005      char *fname;
10006 {
10007   register char *cp, *cp1, *cp2;
10008   int f, check_filename_before_returning;
10009   char Local[512];
10010
10011   check_filename_before_returning = 0;
10012
10013   cp = base_name (fname);
10014
10015   /*
10016    * Check if we have a vax-c style '#include filename'
10017    * and add the missing .h
10018    */
10019   if (!index (cp,'.'))
10020     strcat (cp, ".h");
10021
10022   cp2 = Local;                  /* initialize */
10023
10024   /* We are trying to do a number of things here.  First of all, we are
10025      trying to hammer the filenames into a standard format, such that later
10026      processing can handle them.
10027
10028      If the file name contains something like [dir.], then it recognizes this
10029      as a root, and strips the ".]".  Later processing will add whatever is
10030      needed to get things working properly.
10031
10032      If no device is specified, then the first directory name is taken to be
10033      a device name (or a rooted logical).  */
10034
10035   /* See if we found that 1st slash */
10036   if (cp == 0) return;          /* Nothing to do!!! */
10037   if (*cp != '/') return;       /* Nothing to do!!! */
10038   /* Point to the UNIX filename part (which needs to be fixed!) */
10039   cp1 = cp+1;
10040   /* If the directory spec is not rooted, we can just copy
10041      the UNIX filename part and we are done */
10042   if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
10043     if (cp[-2] != '.') {
10044       /*
10045        * The VMS part ends in a `]', and the preceding character is not a `.'.
10046        * We strip the `]', and then splice the two parts of the name in the
10047        * usual way.  Given the default locations for include files in cccp.c,
10048        * we will only use this code if the user specifies alternate locations
10049        * with the /include (-I) switch on the command line.  */
10050       cp -= 1;                  /* Strip "]" */
10051       cp1--;                    /* backspace */
10052     } else {
10053       /*
10054        * The VMS part has a ".]" at the end, and this will not do.  Later
10055        * processing will add a second directory spec, and this would be a syntax
10056        * error.  Thus we strip the ".]", and thus merge the directory specs.
10057        * We also backspace cp1, so that it points to a '/'.  This inhibits the
10058        * generation of the 000000 root directory spec (which does not belong here
10059        * in this case).
10060        */
10061       cp -= 2;                  /* Strip ".]" */
10062       cp1--; };                 /* backspace */
10063   } else {
10064
10065     /* We drop in here if there is no VMS style directory specification yet.
10066      * If there is no device specification either, we make the first dir a
10067      * device and try that.  If we do not do this, then we will be essentially
10068      * searching the users default directory (as if they did a #include "asdf.h").
10069      *
10070      * Then all we need to do is to push a '[' into the output string. Later
10071      * processing will fill this in, and close the bracket.
10072      */
10073     if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec.  take first dir */
10074     *cp2++ = '[';               /* Open the directory specification */
10075   }
10076
10077   /* at this point we assume that we have the device spec, and (at least
10078      the opening "[" for a directory specification.  We may have directories
10079      specified already */
10080
10081   /* If there are no other slashes then the filename will be
10082      in the "root" directory.  Otherwise, we need to add
10083      directory specifications.  */
10084   if (index (cp1, '/') == 0) {
10085     /* Just add "000000]" as the directory string */
10086     strcpy (cp2, "000000]");
10087     cp2 += strlen (cp2);
10088     check_filename_before_returning = 1; /* we might need to fool with this later */
10089   } else {
10090     /* As long as there are still subdirectories to add, do them.  */
10091     while (index (cp1, '/') != 0) {
10092       /* If this token is "." we can ignore it */
10093       if ((cp1[0] == '.') && (cp1[1] == '/')) {
10094         cp1 += 2;
10095         continue;
10096       }
10097       /* Add a subdirectory spec. Do not duplicate "." */
10098       if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
10099         *cp2++ = '.';
10100       /* If this is ".." then the spec becomes "-" */
10101       if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
10102         /* Add "-" and skip the ".." */
10103         *cp2++ = '-';
10104         cp1 += 3;
10105         continue;
10106       }
10107       /* Copy the subdirectory */
10108       while (*cp1 != '/') *cp2++= *cp1++;
10109       cp1++;                    /* Skip the "/" */
10110     }
10111     /* Close the directory specification */
10112     if (cp2[-1] == '.')         /* no trailing periods */
10113       cp2--;
10114     *cp2++ = ']';
10115   }
10116   /* Now add the filename */
10117   while (*cp1) *cp2++ = *cp1++;
10118   *cp2 = 0;
10119   /* Now append it to the original VMS spec.  */
10120   strcpy (cp, Local);
10121
10122   /* If we put a [000000] in the filename, try to open it first. If this fails,
10123      remove the [000000], and return that name.  This provides flexibility
10124      to the user in that they can use both rooted and non-rooted logical names
10125      to point to the location of the file.  */
10126
10127   if (check_filename_before_returning) {
10128     f = open (fname, O_RDONLY, 0666);
10129     if (f >= 0) {
10130       /* The file name is OK as it is, so return it as is.  */
10131       close (f);
10132       return;
10133     }
10134     /* The filename did not work.  Try to remove the [000000] from the name,
10135        and return it.  */
10136     cp = index (fname, '[');
10137     cp2 = index (fname, ']') + 1;
10138     strcpy (cp, cp2);           /* this gets rid of it */
10139   }
10140   return;
10141 }
10142 #endif  /* VMS */
10143 \f
10144 #ifdef  VMS
10145
10146 /* These are the read/write replacement routines for
10147    VAX-11 "C".  They make read/write behave enough
10148    like their UNIX counterparts that CCCP will work */
10149
10150 static int
10151 read (fd, buf, size)
10152      int fd;
10153      char *buf;
10154      int size;
10155 {
10156 #undef  read    /* Get back the REAL read routine */
10157   register int i;
10158   register int total = 0;
10159
10160   /* Read until the buffer is exhausted */
10161   while (size > 0) {
10162     /* Limit each read to 32KB */
10163     i = (size > (32*1024)) ? (32*1024) : size;
10164     i = read (fd, buf, i);
10165     if (i <= 0) {
10166       if (i == 0) return (total);
10167       return (i);
10168     }
10169     /* Account for this read */
10170     total += i;
10171     buf += i;
10172     size -= i;
10173   }
10174   return (total);
10175 }
10176
10177 static int
10178 write (fd, buf, size)
10179      int fd;
10180      char *buf;
10181      int size;
10182 {
10183 #undef  write   /* Get back the REAL write routine */
10184   int i;
10185   int j;
10186
10187   /* Limit individual writes to 32Kb */
10188   i = size;
10189   while (i > 0) {
10190     j = (i > (32*1024)) ? (32*1024) : i;
10191     if (write (fd, buf, j) < 0) return (-1);
10192     /* Account for the data written */
10193     buf += j;
10194     i -= j;
10195   }
10196   return (size);
10197 }
10198
10199 /* The following wrapper functions supply additional arguments to the VMS
10200    I/O routines to optimize performance with file handling.  The arguments
10201    are:
10202      "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
10203      "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
10204      "fop=tef"- Truncate unused portions of file when closing file.
10205      "shr=nil"- Disallow file sharing while file is open.  */
10206
10207 static FILE *
10208 freopen (fname, type, oldfile)
10209      char *fname;
10210      char *type;
10211      FILE *oldfile;
10212 {
10213 #undef  freopen /* Get back the REAL fopen routine */
10214   if (strcmp (type, "w") == 0)
10215     return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil");
10216   return freopen (fname, type, oldfile, "mbc=16");
10217 }
10218
10219 static FILE *
10220 fopen (fname, type)
10221      char *fname;
10222      char *type;
10223 {
10224 #undef fopen    /* Get back the REAL fopen routine */
10225   /* The gcc-vms-1.42 distribution's header files prototype fopen with two
10226      fixed arguments, which matches ANSI's specification but not VAXCRTL's
10227      pre-ANSI implementation.  This hack circumvents the mismatch problem.  */
10228   FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
10229
10230   if (*type == 'w')
10231     return (*vmslib_fopen) (fname, type, "mbc=32",
10232                             "deq=64", "fop=tef", "shr=nil");
10233   else
10234     return (*vmslib_fopen) (fname, type, "mbc=32");
10235 }
10236
10237 static int
10238 open (fname, flags, prot)
10239      char *fname;
10240      int flags;
10241      int prot;
10242 {
10243 #undef open     /* Get back the REAL open routine */
10244   return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
10245 }
10246 \f
10247 /* more VMS hackery */
10248 #include <fab.h>
10249 #include <nam.h>
10250
10251 extern unsigned long sys$parse(), sys$search();
10252
10253 /* Work around another library bug.  If a file is located via a searchlist,
10254    and if the device it's on is not the same device as the one specified
10255    in the first element of that searchlist, then both stat() and fstat()
10256    will fail to return info about it.  `errno' will be set to EVMSERR, and
10257    `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
10258    We can get around this by fully parsing the filename and then passing
10259    that absolute name to stat().
10260
10261    Without this fix, we can end up failing to find header files, which is
10262    bad enough, but then compounding the problem by reporting the reason for
10263    failure as "normal successful completion."  */
10264
10265 #undef fstat    /* get back to library version */
10266
10267 static int
10268 VMS_fstat (fd, statbuf)
10269      int fd;
10270      struct stat *statbuf;
10271 {
10272   int result = fstat (fd, statbuf);
10273
10274   if (result < 0)
10275     {
10276       FILE *fp;
10277       char nambuf[NAM$C_MAXRSS+1];
10278
10279       if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
10280         result = VMS_stat (nambuf, statbuf);
10281       /* No fclose(fp) here; that would close(fd) as well.  */
10282     }
10283
10284   return result;
10285 }
10286
10287 static int
10288 VMS_stat (name, statbuf)
10289      const char *name;
10290      struct stat *statbuf;
10291 {
10292   int result = stat (name, statbuf);
10293
10294   if (result < 0)
10295     {
10296       struct FAB fab;
10297       struct NAM nam;
10298       char exp_nam[NAM$C_MAXRSS+1],  /* expanded name buffer for sys$parse */
10299            res_nam[NAM$C_MAXRSS+1];  /* resultant name buffer for sys$search */
10300
10301       fab = cc$rms_fab;
10302       fab.fab$l_fna = (char *) name;
10303       fab.fab$b_fns = (unsigned char) strlen (name);
10304       fab.fab$l_nam = (void *) &nam;
10305       nam = cc$rms_nam;
10306       nam.nam$l_esa = exp_nam,  nam.nam$b_ess = sizeof exp_nam - 1;
10307       nam.nam$l_rsa = res_nam,  nam.nam$b_rss = sizeof res_nam - 1;
10308       nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
10309       if (sys$parse (&fab) & 1)
10310         {
10311           if (sys$search (&fab) & 1)
10312             {
10313               res_nam[nam.nam$b_rsl] = '\0';
10314               result = stat (res_nam, statbuf);
10315             }
10316           /* Clean up searchlist context cached by the system.  */
10317           nam.nam$b_nop = NAM$M_SYNCHK;
10318           fab.fab$l_fna = 0,  fab.fab$b_fns = 0;
10319           (void) sys$parse (&fab);
10320         }
10321     }
10322
10323   return result;
10324 }
10325 #endif /* VMS */