gcc/cccp.c

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