gcc/cccp.c

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