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