gcc/cccp.c

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