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