gcc/tradcpp.c

   1 /* C Compatible Compiler Preprocessor (CCCP)
   2 Copyright (C) 1986, 1987, 1989, 2000 Free Software Foundation, Inc.
   3                     Written by Paul Rubin, June 1986
   4                     Adapted to ANSI C, Richard Stallman, Jan 1987
   5                     Dusted off, polished, and adapted for use as traditional
   6                     preprocessor only, Zack Weinberg, Jul 2000
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 1, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22  In other words, you are welcome to use, share and improve this program.
  23  You are forbidden to forbid anyone else to use, share and improve
  24  what you give them.   Help stamp out software-hoarding!  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "version.h"
  29 #include "cppdefault.h"
  30
  31 typedef unsigned char U_CHAR;
  32
  33 /* Name under which this program was invoked.  */
  34
  35 char *progname;
  36
  37 /* Current maximum length of directory names in the search path
  38    for include files.  (Altered as we get more of them.)  */
  39
  40 size_t max_include_len;
  41
  42 /* Nonzero means copy comments into the output file.  */
  43
  44 int put_out_comments = 0;
  45
  46 /* Nonzero means print the names of included files rather than
  47    the preprocessed output.  1 means just the #include "...",
  48    2 means #include <...> as well.  */
  49
  50 int print_deps = 0;
  51
  52 /* Nonzero means don't output line number information.  */
  53
  54 int no_line_commands;
  55
  56 /* Nonzero means inhibit output of the preprocessed text
  57    and instead output the definitions of all user-defined macros
  58    in a form suitable for use as input to cccp.  */
  59
  60 int dump_macros;
  61
  62 /* Nonzero means don't print warning messages.  -w.  */
  63
  64 int inhibit_warnings = 0;
  65
  66 /* Nonzero means warn if slash-star appears in a comment.  */
  67
  68 int warn_comments;
  69
  70 /* Nonzero causes output not to be done,
  71    but directives such as #define that have side effects
  72    are still obeyed.  */
  73
  74 int no_output;
  75
  76 /* Value of __USER_LABEL_PREFIX__.  Target-dependent, also controlled
  77    by -f(no-)leading-underscore.  */
  78 const char *user_label_prefix;
  79
  80 /* I/O buffer structure.
  81    The `fname' field is nonzero for source files and #include files
  82    and for the dummy text used for -D and -U.
  83    It is zero for rescanning results of macro expansion
  84    and for expanding macro arguments.  */
  85 #define INPUT_STACK_MAX 200
  86 struct file_buf {
  87   const char *fname;
  88   int lineno;
  89   int length;
  90   U_CHAR *buf;
  91   U_CHAR *bufp;
  92   /* Macro that this level is the expansion of.
  93      Included so that we can reenable the macro
  94      at the end of this level.  */
  95   struct hashnode *macro;
  96   /* Value of if_stack at start of this file.
  97      Used to prohibit unmatched #endif (etc) in an include file.  */
  98   struct if_stack *if_stack;
  99   /* Object to be freed at end of input at this level.  */
 100   U_CHAR *free_ptr;
 101 } instack[INPUT_STACK_MAX];
 102
 103 typedef struct file_buf FILE_BUF;
 104
 105 /* Current nesting level of input sources.
 106    `instack[indepth]' is the level currently being read.  */
 107 int indepth = -1;
 108 #define CHECK_DEPTH(code) \
 109   if (indepth >= (INPUT_STACK_MAX - 1))                                 \
 110     {                                                                   \
 111       error_with_line (line_for_error (instack[indepth].lineno),        \
 112                        "macro or #include recursion too deep");         \
 113       code;                                                             \
 114     }
 115
 116 /* Current depth in #include directives that use <...>.  */
 117 int system_include_depth = 0;
 118
 119 /* The output buffer.  Its LENGTH field is the amount of room allocated
 120    for the buffer, not the number of chars actually present.  To get
 121    that, subtract outbuf.buf from outbuf.bufp. */
 122
 123 #define OUTBUF_SIZE 10  /* initial size of output buffer */
 124 FILE_BUF outbuf;
 125
 126 /* Grow output buffer OBUF points at
 127    so it can hold at least NEEDED more chars.  */
 128
 129 #define check_expand(OBUF, NEEDED) do { \
 130   if ((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
 131     grow_outbuf ((OBUF), (NEEDED)); \
 132  } while (0)
 133
 134 struct file_name_list
 135   {
 136     struct file_name_list *next;
 137     const char *fname;
 138   };
 139
 140 struct file_name_list *include = 0;     /* First dir to search */
 141         /* First dir to search for <file> */
 142 struct file_name_list *first_bracket_include = 0;
 143 struct file_name_list *last_include = 0;        /* Last in chain */
 144
 145 /* List of included files that contained #once.  */
 146 struct file_name_list *dont_repeat_files = 0;
 147
 148 /* List of other included files.  */
 149 struct file_name_list *all_include_files = 0;
 150 \f
 151 /* Structure allocated for every #define.  For a simple replacement
 152    such as
 153         #define foo bar ,
 154    nargs = -1, the `pattern' list is null, and the expansion is just
 155    the replacement text.  Nargs = 0 means a functionlike macro with no args,
 156    e.g.,
 157        #define getchar() getc (stdin) .
 158    When there are args, the expansion is the replacement text with the
 159    args squashed out, and the reflist is a list describing how to
 160    build the output from the input: e.g., "3 chars, then the 1st arg,
 161    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
 162    The chars here come from the expansion.  Whatever is left of the
 163    expansion after the last arg-occurrence is copied after that arg.
 164    Note that the reflist can be arbitrarily long---
 165    its length depends on the number of times the arguments appear in
 166    the replacement text, not how many args there are.  Example:
 167    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
 168    pattern list
 169      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
 170    where (x, y) means (nchars, argno). */
 171
 172 typedef struct definition DEFINITION;
 173 struct definition {
 174   int nargs;
 175   int length;                   /* length of expansion string */
 176   U_CHAR *expansion;
 177   struct reflist {
 178     struct reflist *next;
 179     char stringify;             /* nonzero if this arg was preceded by a
 180                                    # operator. */
 181     char raw_before;            /* Nonzero if a ## operator before arg. */
 182     char raw_after;             /* Nonzero if a ## operator after arg. */
 183     int nchars;                 /* Number of literal chars to copy before
 184                                    this arg occurrence.  */
 185     int argno;                  /* Number of arg to substitute (origin-0) */
 186   } *pattern;
 187   /* Names of macro args, concatenated in reverse order
 188      with comma-space between them.
 189      The only use of this is that we warn on redefinition
 190      if this differs between the old and new definitions.  */
 191   U_CHAR *argnames;
 192 };
 193
 194 /* different kinds of things that can appear in the value field
 195    of a hash node.  Actually, this may be useless now. */
 196 union hashval {
 197   const char *cpval;
 198   DEFINITION *defn;
 199 };
 200
 201
 202 /* The structure of a node in the hash table.  The hash table
 203    has entries for all tokens defined by #define commands (type T_MACRO),
 204    plus some special tokens like __LINE__ (these each have their own
 205    type, and the appropriate code is run when that type of node is seen.
 206    It does not contain control words like "#define", which are recognized
 207    by a separate piece of code. */
 208
 209 /* different flavors of hash nodes --- also used in keyword table */
 210 enum node_type {
 211  T_DEFINE = 1,  /* `#define' */
 212  T_INCLUDE,     /* `#include' */
 213  T_IFDEF,       /* `#ifdef' */
 214  T_IFNDEF,      /* `#ifndef' */
 215  T_IF,          /* `#if' */
 216  T_ELSE,        /* `#else' */
 217  T_ELIF,        /* `#elif' */
 218  T_UNDEF,       /* `#undef' */
 219  T_LINE,        /* `#line' */
 220  T_ENDIF,       /* `#endif' */
 221  T_SPECLINE,    /* special symbol `__LINE__' */
 222  T_DATE,        /* `__DATE__' */
 223  T_FILE,        /* `__FILE__' */
 224  T_BASE_FILE,   /* `__BASE_FILE__' */
 225  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 226  T_VERSION,     /* `__VERSION__' */
 227  T_TIME,        /* `__TIME__' */
 228  T_CONST,       /* Constant value, used by `__STDC__' */
 229  T_MACRO,       /* macro defined by `#define' */
 230  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
 231  T_UNUSED       /* Used for something not defined.  */
 232 };
 233
 234 struct hashnode {
 235   struct hashnode *next;        /* double links for easy deletion */
 236   struct hashnode *prev;
 237   struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
 238                                    chain is kept, in case the node is the head
 239                                    of the chain and gets deleted. */
 240   enum node_type type;          /* type of special token */
 241   int length;                   /* length of token, for quick comparison */
 242   U_CHAR *name;                 /* the actual name */
 243   union hashval value;          /* pointer to expansion, or whatever */
 244 };
 245
 246 typedef struct hashnode HASHNODE;
 247
 248 /* Some definitions for the hash table.  The hash function MUST be
 249    computed as shown in hashf () below.  That is because the rescan
 250    loop computes the hash value `on the fly' for most tokens,
 251    in order to avoid the overhead of a lot of procedure calls to
 252    the hashf () function.  Hashf () only exists for the sake of
 253    politeness, for use when speed isn't so important. */
 254
 255 #define HASHSIZE 1403
 256 HASHNODE *hashtab[HASHSIZE];
 257 #define HASHSTEP(old, c) ((old << 2) + c)
 258 #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
 259
 260 /* `struct directive' defines one #-directive, including how to handle it.  */
 261
 262 struct directive {
 263   int length;                   /* Length of name */
 264   void (*func) PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 265                                 /* Function to handle directive */
 266   const char *name;             /* Name of directive */
 267   enum node_type type;          /* Code which describes which directive. */
 268 };
 269
 270 /* Last arg to output_line_command.  */
 271 enum file_change_code {same_file, enter_file, leave_file};
 272
 273 /* This structure represents one parsed argument in a macro call.
 274    `raw' points to the argument text as written (`raw_length' is its length).
 275    `expanded' points to the argument's macro-expansion
 276    (its length is `expand_length').
 277    `stringified_length' is the length the argument would have
 278    if stringified.
 279    `free1' and `free2', if nonzero, point to blocks to be freed
 280    when the macro argument data is no longer needed.  */
 281
 282 struct argdata {
 283   U_CHAR *raw, *expanded;
 284   int raw_length, expand_length;
 285   int stringified_length;
 286   U_CHAR *free1, *free2;
 287   char newlines;
 288   char comments;
 289 };
 290
 291 /* The arglist structure is built by do_define to tell
 292    collect_definition where the argument names begin.  That
 293    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
 294    would contain pointers to the strings x, y, and z.
 295    Collect_definition would then build a DEFINITION node,
 296    with reflist nodes pointing to the places x, y, and z had
 297    appeared.  So the arglist is just convenience data passed
 298    between these two routines.  It is not kept around after
 299    the current #define has been processed and entered into the
 300    hash table. */
 301
 302 struct arglist {
 303   struct arglist *next;
 304   U_CHAR *name;
 305   int length;
 306   int argno;
 307 };
 308
 309 /* Function prototypes.  */
 310
 311 void do_define  PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 312 void do_line    PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 313 void do_include PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 314 void do_undef   PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 315 void do_if      PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 316 void do_xifdef  PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 317 void do_else    PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 318 void do_elif    PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 319 void do_endif   PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
 320
 321 struct hashnode *install PARAMS ((const U_CHAR *, int, enum node_type, int));
 322 struct hashnode *lookup  PARAMS ((const U_CHAR *, int, int));
 323 int hashf                PARAMS ((const U_CHAR *, int, int));
 324 int compare_defs         PARAMS ((DEFINITION *, DEFINITION *));
 325 int comp_def_part        PARAMS ((int, U_CHAR *, int, U_CHAR *, int, int));
 326 void delete_macro        PARAMS ((HASHNODE *));
 327
 328 /* First arg to v_message.  */
 329 enum msgtype { WARNING = 0, ERROR, FATAL };
 330 void v_message           PARAMS ((enum msgtype mtype, int line,
 331                                   const char *msgid, va_list ap));
 332
 333 void warning             PARAMS ((const char *msgid, ...));
 334 void error               PARAMS ((const char *msgid, ...));
 335 void fatal               PARAMS ((const char *msgid, ...)) ATTRIBUTE_NORETURN;
 336 void error_with_line     PARAMS ((int, const char *msgid, ...));
 337 void error_from_errno    PARAMS ((const char *msgid));
 338
 339 void perror_with_name    PARAMS ((const char *msgid));
 340 void pfatal_with_name    PARAMS ((const char *msgid)) ATTRIBUTE_NORETURN;
 341 void fancy_abort         PARAMS ((int, const char *)) ATTRIBUTE_NORETURN;
 342
 343 int line_for_error       PARAMS ((int));
 344
 345 /* We know perfectly well which file this is, so we don't need to
 346    use __FILE__.  */
 347 #undef abort
 348 #if (GCC_VERSION >= 2007)
 349 #define abort() fancy_abort(__LINE__, __FUNCTION__)
 350 #else
 351 #define abort() fancy_abort(__LINE__, 0);
 352 #endif
 353
 354 void macroexpand                PARAMS ((HASHNODE *, FILE_BUF *));
 355 void special_symbol             PARAMS ((HASHNODE *, FILE_BUF *));
 356 void dump_all_macros            PARAMS ((void));
 357 void dump_defn_1                PARAMS ((U_CHAR *, int, int));
 358 void dump_arg_n                 PARAMS ((DEFINITION *, int));
 359 void conditional_skip           PARAMS ((FILE_BUF *, int, enum node_type));
 360 void skip_if_group              PARAMS ((FILE_BUF *, int));
 361 void output_line_command        PARAMS ((FILE_BUF *, FILE_BUF *,
 362                                          int, enum file_change_code));
 363
 364 int eval_if_expression          PARAMS ((U_CHAR *, int));
 365 int parse_c_expression          PARAMS ((char *));  /* in tradcif.y */
 366
 367 void initialize_char_syntax     PARAMS ((void));
 368 void initialize_builtins        PARAMS ((void));
 369 void make_definition            PARAMS ((U_CHAR *));
 370 void make_undef                 PARAMS ((U_CHAR *));
 371
 372 void grow_outbuf        PARAMS ((FILE_BUF *, int));
 373 int handle_directive    PARAMS ((FILE_BUF *, FILE_BUF *));
 374 void finclude           PARAMS ((int, const char *, FILE_BUF *));
 375 void deps_output        PARAMS ((const char *, int));
 376 void rescan             PARAMS ((FILE_BUF *, int));
 377 void newline_fix        PARAMS ((U_CHAR *));
 378 void name_newline_fix   PARAMS ((U_CHAR *));
 379 U_CHAR *macarg1         PARAMS ((U_CHAR *, U_CHAR *, int *, int *, int *));
 380 const char *macarg      PARAMS ((struct argdata *));
 381 int discard_comments    PARAMS ((U_CHAR *, int, int));
 382 int file_size_and_mode  PARAMS ((int, int *, long *));
 383
 384 U_CHAR *skip_to_end_of_comment PARAMS ((FILE_BUF *, int *));
 385 U_CHAR *skip_quoted_string     PARAMS ((U_CHAR *, U_CHAR *, int,
 386                                         int *, int *, int *));
 387
 388 int main                PARAMS ((int, char **));
 389
 390 /* Convenience.  Write U"string" to get an unsigned string constant.  */
 391 #define U (const unsigned char *)
 392
 393 /* Here is the actual list of #-directives, most-often-used first.  */
 394
 395 struct directive directive_table[] = {
 396   {  6, do_define,  "define",  T_DEFINE  },
 397   {  7, do_include, "include", T_INCLUDE },
 398   {  5, do_endif,   "endif",   T_ENDIF   },
 399   {  5, do_xifdef,  "ifdef",   T_IFDEF   },
 400   {  2, do_if,      "if",      T_IF,     },
 401   {  4, do_else,    "else",    T_ELSE    },
 402   {  6, do_xifdef,  "ifndef",  T_IFNDEF  },
 403   {  5, do_undef,   "undef",   T_UNDEF   },
 404   {  4, do_line,    "line",    T_LINE    },
 405   {  4, do_elif,    "elif",    T_ELIF    },
 406   {  -1, 0, "", T_UNUSED},
 407 };
 408
 409 /* table to tell if char can be part of a C identifier. */
 410 U_CHAR is_idchar[256];
 411 /* table to tell if char can be first char of a c identifier. */
 412 U_CHAR is_idstart[256];
 413 /* table to tell if c is horizontal space.  */
 414 U_CHAR is_hor_space[256];
 415 /* table to tell if c is horizontal or vertical space.  */
 416 U_CHAR is_space[256];
 417
 418 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
 419 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
 420
 421 int errors = 0;                 /* Error counter for exit code */
 422
 423 FILE_BUF expand_to_temp_buffer PARAMS ((U_CHAR *, U_CHAR *, int));
 424 DEFINITION *collect_expansion  PARAMS ((U_CHAR *, U_CHAR *, int,
 425                                         struct arglist *));
 426
 427 /* Stack of conditionals currently in progress
 428    (including both successful and failing conditionals).  */
 429
 430 struct if_stack {
 431   struct if_stack *next;        /* for chaining to the next stack frame */
 432   const char *fname;            /* copied from input when frame is made */
 433   int lineno;                   /* similarly */
 434   int if_succeeded;             /* true if a leg of this if-group
 435                                     has been passed through rescan */
 436   enum node_type type;          /* type of last directive seen in this group */
 437 };
 438 typedef struct if_stack IF_STACK_FRAME;
 439 IF_STACK_FRAME *if_stack = NULL;
 440
 441 /* Buffer of -M output.  */
 442
 443 char *deps_buffer;
 444
 445 /* Number of bytes allocated in above.  */
 446 int deps_allocated_size;
 447
 448 /* Number of bytes used.  */
 449 int deps_size;
 450
 451 /* Number of bytes since the last newline.  */
 452 int deps_column;
 453
 454 /* Nonzero means -I- has been seen,
 455    so don't look for #include "foo" the source-file directory.  */
 456 int ignore_srcdir;
 457
 458 int
 459 main (argc, argv)
 460      int argc;
 461      char **argv;
 462 {
 463   int st_mode;
 464   long st_size;
 465   const char *in_fname, *out_fname;
 466   int f, i;
 467   FILE_BUF *fp;
 468   const char **pend_files = (const char **) xmalloc (argc * sizeof (char *));
 469   const char **pend_defs = (const char **) xmalloc (argc * sizeof (char *));
 470   const char **pend_undefs = (const char **) xmalloc (argc * sizeof (char *));
 471   int no_standard_includes = 0;
 472
 473   /* Non-0 means don't output the preprocessed program.  */
 474   int inhibit_output = 0;
 475
 476   /* Stream on which to print the dependency information.  */
 477   FILE *deps_stream = 0;
 478   /* Target-name to write with the dependency information.  */
 479   char *deps_target = 0;
 480
 481 #ifdef RLIMIT_STACK
 482   /* Get rid of any avoidable limit on stack size.  */
 483   {
 484     struct rlimit rlim;
 485
 486     /* Set the stack limit huge so that alloca (particularly stringtab
 487      * in dbxread.c) does not fail. */
 488     getrlimit (RLIMIT_STACK, &rlim);
 489     rlim.rlim_cur = rlim.rlim_max;
 490     setrlimit (RLIMIT_STACK, &rlim);
 491   }
 492 #endif /* RLIMIT_STACK defined */
 493
 494   progname = argv[0];
 495
 496   in_fname = NULL;
 497   out_fname = NULL;
 498
 499   /* Initialize is_idchar to allow $.  */
 500   initialize_char_syntax ();
 501
 502   no_line_commands = 0;
 503   dump_macros = 0;
 504   no_output = 0;
 505
 506   max_include_len = cpp_GCC_INCLUDE_DIR_len + 7;  /* ??? */
 507
 508   memset (pend_files, 0, argc * sizeof (char *));
 509   memset (pend_defs, 0, argc * sizeof (char *));
 510   memset (pend_undefs, 0, argc * sizeof (char *));
 511
 512   /* Process switches and find input file name.  */
 513
 514   for (i = 1; i < argc; i++) {
 515     if (argv[i][0] != '-') {
 516       if (out_fname != NULL)
 517         fatal ("Usage: %s [switches] input output", argv[0]);
 518       else if (in_fname != NULL)
 519         out_fname = argv[i];
 520       else
 521         in_fname = argv[i];
 522     } else {
 523       switch (argv[i][1]) {
 524       case 'A':
 525       case 'E':
 526       case '$':
 527       case 'g':
 528         break;  /* Ignore for compatibility with ISO/extended cpp.  */
 529
 530       case 'l':
 531         if (!strcmp (argv[i], "-lang-c++")
 532             || !strcmp (argv[i], "-lang-objc++"))
 533           fatal ("-traditional is not supported in C++");
 534         else if (!strcmp (argv[i], "-lang-c89"))
 535           fatal ("-traditional and -ansi are mutually exclusive");
 536         else if (!strcmp (argv[i], "-lang-objc"))
 537           pend_defs[i] = "__OBJC__";
 538         else if (!strcmp (argv[i], "-lang-asm"))
 539           pend_defs[i] = "__ASSEMBLER__";
 540         else if (!strcmp (argv[i], "-lang-fortran"))
 541           pend_defs[i] = "_LANGUAGE_FORTRAN";
 542         /* All other possibilities ignored.  */
 543         break;
 544
 545       case 'i':
 546         if (!strcmp (argv[i], "-include"))
 547           {
 548             if (i + 1 == argc)
 549               fatal ("Filename missing after -i option");
 550             else
 551               pend_files[i] = argv[i+1], i++;
 552           }
 553         else if (!strcmp (argv[i], "-iprefix"))
 554           i++; /* Ignore for compatibility */
 555         else if (!strcmp (argv[i], "-isystem")
 556                  || !strcmp (argv[i], "-iwithprefix")
 557                  || !strcmp (argv[i], "-iwithprefixbefore")
 558                  || !strcmp (argv[i], "-idirafter"))
 559           goto add_include;  /* best we can do */
 560
 561         break;
 562
 563       case 'o':
 564         if (out_fname != NULL)
 565           fatal ("Output filename specified twice");
 566         if (i + 1 == argc)
 567           fatal ("Filename missing after -o option");
 568         out_fname = argv[++i];
 569         if (!strcmp (out_fname, "-"))
 570           out_fname = "";
 571         break;
 572
 573       case 'w':
 574         inhibit_warnings = 1;
 575         break;
 576
 577       case 'W':
 578         if (!strcmp (argv[i], "-Wcomments"))
 579           warn_comments = 1;
 580         else if (!strcmp (argv[i], "-Wcomment"))
 581           warn_comments = 1;
 582         else if (!strcmp (argv[i], "-Wall")) {
 583           warn_comments = 1;
 584         }
 585         break;
 586
 587       case 'f':
 588         if (!strcmp (argv[i], "-fleading-underscore"))
 589           user_label_prefix = "_";
 590         else if (!strcmp (argv[i], "-fno-leading-underscore"))
 591           user_label_prefix = "";
 592         break;
 593
 594       case 'M':
 595         if (!strcmp (argv[i], "-M"))
 596           print_deps = 2;
 597         else if (!strcmp (argv[i], "-MM"))
 598           print_deps = 1;
 599         inhibit_output = 1;
 600         break;
 601
 602       case 'd':
 603         dump_macros = 1;
 604         no_output = 1;
 605         break;
 606
 607       case 'v':
 608         fprintf (stderr, "GNU traditional CPP version %s\n", version_string);
 609         break;
 610
 611       case 'D':
 612         {
 613           char *p;
 614
 615           if (argv[i][2] != 0)
 616             p = argv[i] + 2;
 617           else if (i + 1 == argc)
 618             fatal ("Macro name missing after -D option");
 619           else
 620             p = argv[++i];
 621
 622           pend_defs[i] = p;
 623         }
 624         break;
 625
 626       case 'U':         /* JF #undef something */
 627         if (argv[i][2] != 0)
 628           pend_undefs[i] = argv[i] + 2;
 629         else if (i + 1 == argc)
 630           fatal ("Macro name missing after -U option");
 631         else
 632           pend_undefs[i] = argv[i+1], i++;
 633         break;
 634
 635       case 'C':
 636         put_out_comments = 1;
 637         break;
 638
 639       case 'p':
 640         if (!strcmp (argv[i], "-pedantic"))
 641           fatal ("-pedantic and -traditional are mutually exclusive");
 642         break;
 643
 644       case 't':
 645         if (!strcmp (argv[i], "-trigraphs"))
 646           fatal ("-trigraphs and -traditional are mutually exclusive");
 647         break;
 648
 649       case 'P':
 650         no_line_commands = 1;
 651         break;
 652
 653       case 'I':                 /* Add directory to path for includes.  */
 654       add_include:
 655         {
 656           struct file_name_list *dirtmp;
 657
 658           if (! ignore_srcdir && !strcmp (argv[i] + 2, "-"))
 659             ignore_srcdir = 1;
 660           else {
 661             dirtmp = (struct file_name_list *)
 662               xmalloc (sizeof (struct file_name_list));
 663             dirtmp->next = 0;           /* New one goes on the end */
 664             if (include == 0)
 665               include = dirtmp;
 666             else
 667               last_include->next = dirtmp;
 668             last_include = dirtmp;      /* Tail follows the last one */
 669             if (argv[i][1] == 'I' && argv[i][2] != 0)
 670               dirtmp->fname = argv[i] + 2;
 671             else if (i + 1 == argc)
 672               fatal ("Directory name missing after -I option");
 673             else
 674               dirtmp->fname = argv[++i];
 675             if (strlen (dirtmp->fname) > max_include_len)
 676               max_include_len = strlen (dirtmp->fname);
 677             if (ignore_srcdir && first_bracket_include == 0)
 678               first_bracket_include = dirtmp;
 679             }
 680         }
 681         break;
 682
 683       case 'n':
 684         /* -nostdinc causes no default include directories.
 685            You must specify all include-file directories with -I.  */
 686         no_standard_includes = 1;
 687         break;
 688
 689       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
 690         if (in_fname == NULL) {
 691           in_fname = "";
 692           break;
 693         } else if (out_fname == NULL) {
 694           out_fname = "";
 695           break;
 696         }       /* else fall through into error */
 697
 698       default:
 699         fatal ("Invalid option `%s'", argv[i]);
 700       }
 701     }
 702   }
 703
 704   if (user_label_prefix == 0)
 705     user_label_prefix = USER_LABEL_PREFIX;
 706
 707   /* Initialize is_idchar.  */
 708   initialize_char_syntax ();
 709
 710   /* Install __LINE__, etc.  Must follow initialize_char_syntax
 711      and option processing.  */
 712   initialize_builtins ();
 713
 714   /* Do defines specified with -D and undefines specified with -U.  */
 715   for (i = 1; i < argc; i++)
 716     if (pend_defs[i])
 717       make_definition ((U_CHAR *)pend_defs[i]);
 718     else if (pend_undefs[i])
 719       make_undef ((U_CHAR *)pend_undefs[i]);
 720
 721   /* Unless -fnostdinc,
 722      tack on the standard include file dirs to the specified list */
 723   if (!no_standard_includes) {
 724     const struct default_include *di;
 725     struct file_name_list *old_last_include = last_include;
 726     struct file_name_list *dirtmp;
 727     for (di = cpp_include_defaults; di->fname; di++) {
 728       if (di->cplusplus)
 729         continue;
 730       dirtmp = (struct file_name_list *)
 731         xmalloc (sizeof (struct file_name_list));
 732       dirtmp->next = 0;         /* New one goes on the end */
 733       if (include == 0)
 734         include = dirtmp;
 735       else
 736         last_include->next = dirtmp;
 737       last_include = dirtmp;    /* Tail follows the last one */
 738       dirtmp->fname = di->fname;
 739       if (strlen (dirtmp->fname) > max_include_len)
 740         max_include_len = strlen (dirtmp->fname);
 741     }
 742
 743     if (ignore_srcdir && first_bracket_include == 0)
 744       first_bracket_include = old_last_include->next;
 745   }
 746
 747   /* Initialize output buffer */
 748
 749   outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
 750   outbuf.bufp = outbuf.buf;
 751   outbuf.length = OUTBUF_SIZE;
 752
 753   /* Scan the -i files before the main input.
 754      Much like #including them, but with no_output set
 755      so that only their macro definitions matter.  */
 756
 757   no_output++;
 758   for (i = 1; i < argc; i++)
 759     if (pend_files[i]) {
 760       int fd = open (pend_files[i], O_RDONLY, 0666);
 761       if (fd < 0) {
 762         perror_with_name (pend_files[i]);
 763         return FATAL_EXIT_CODE;
 764       }
 765       finclude (fd, pend_files[i], &outbuf);
 766     }
 767   no_output--;
 768
 769   /* Create an input stack level for the main input file
 770      and copy the entire contents of the file into it.  */
 771
 772   fp = &instack[++indepth];
 773
 774   /* JF check for stdin */
 775   if (in_fname == NULL || *in_fname == 0) {
 776     in_fname = "";
 777     f = 0;
 778   } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
 779     goto sys_error;
 780
 781   /* Either of two environment variables can specify output of deps.
 782      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
 783      where OUTPUT_FILE is the file to write deps info to
 784      and DEPS_TARGET is the target to mention in the deps.  */
 785
 786   if (print_deps == 0
 787       && (getenv ("SUNPRO_DEPENDENCIES") != 0
 788           || getenv ("DEPENDENCIES_OUTPUT") != 0))
 789     {
 790       char *spec = getenv ("DEPENDENCIES_OUTPUT");
 791       char *s;
 792       char *output_file;
 793
 794       if (spec == 0)
 795         {
 796           spec = getenv ("SUNPRO_DEPENDENCIES");
 797           print_deps = 2;
 798         }
 799       else
 800         print_deps = 1;
 801
 802       /* Find the space before the DEPS_TARGET, if there is one.  */
 803       s = strchr (spec, ' ');
 804       if (s)
 805         {
 806           deps_target = s + 1;
 807           output_file = (char *) xmalloc (s - spec + 1);
 808           memcpy (output_file, spec, s - spec);
 809           output_file[s - spec] = 0;
 810         }
 811       else
 812         {
 813           deps_target = 0;
 814           output_file = spec;
 815         }
 816
 817       deps_stream = fopen (output_file, "a");
 818       if (deps_stream == 0)
 819         pfatal_with_name (output_file);
 820     }
 821   /* If the -M option was used, output the deps to standard output.  */
 822   else if (print_deps)
 823     deps_stream = stdout;
 824
 825   /* For -M, print the expected object file name
 826      as the target of this Make-rule.  */
 827   if (print_deps) {
 828     deps_allocated_size = 200;
 829     deps_buffer = (char *) xmalloc (deps_allocated_size);
 830     deps_buffer[0] = 0;
 831     deps_size = 0;
 832     deps_column = 0;
 833
 834     if (deps_target) {
 835       deps_output (deps_target, 0);
 836       deps_output (":", 0);
 837     } else if (*in_fname == 0)
 838       deps_output ("-: ", 0);
 839     else {
 840       int len;
 841       const char *p = in_fname;
 842       const char *p1 = p;
 843       /* Discard all directory prefixes from P.  */
 844       while (*p1) {
 845         if (*p1 == '/')
 846           p = p1 + 1;
 847         p1++;
 848       }
 849       /* Output P, but remove known suffixes.  */
 850       len = strlen (p);
 851       if (p[len - 2] == '.'
 852           && (p[len - 1] == 'c' || p[len - 1] == 'C' || p[len - 1] == 'S'))
 853         deps_output (p, len - 2);
 854       else if (p[len - 3] == '.'
 855                && p[len - 2] == 'c'
 856                && p[len - 1] == 'c')
 857         deps_output (p, len - 3);
 858       else
 859         deps_output (p, 0);
 860       /* Supply our own suffix.  */
 861       deps_output (".o : ", 0);
 862       deps_output (in_fname, 0);
 863       deps_output (" ", 0);
 864     }
 865   }
 866
 867   if (file_size_and_mode (f, &st_mode, &st_size))
 868     goto sys_error;
 869   fp->fname = in_fname;
 870   fp->lineno = 1;
 871   /* JF all this is mine about reading pipes and ttys */
 872   if (!S_ISREG (st_mode)) {
 873     /* Read input from a file that is not a normal disk file.
 874        We cannot preallocate a buffer with the correct size,
 875        so we must read in the file a piece at the time and make it bigger.  */
 876     int size;
 877     int bsize;
 878     int cnt;
 879     U_CHAR *bufp;
 880
 881     bsize = 2000;
 882     size = 0;
 883     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
 884     bufp = fp->buf;
 885     for (;;) {
 886       cnt = read (f, bufp, bsize - size);
 887       if (cnt < 0) goto sys_error;      /* error! */
 888       if (cnt == 0) break;              /* End of file */
 889       size += cnt;
 890       bufp += cnt;
 891       if (bsize == size) {              /* Buffer is full! */
 892         bsize *= 2;
 893         fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
 894         bufp = fp->buf + size;  /* May have moved */
 895       }
 896     }
 897     fp->length = size;
 898   } else {
 899     /* Read a file whose size we can determine in advance.
 900        For the sake of VMS, st_size is just an upper bound.  */
 901     long i;
 902     fp->length = 0;
 903     fp->buf = (U_CHAR *) xmalloc (st_size + 2);
 904
 905     while (st_size > 0) {
 906       i = read (f, fp->buf + fp->length, st_size);
 907       if (i <= 0) {
 908         if (i == 0) break;
 909         goto sys_error;
 910       }
 911       fp->length += i;
 912       st_size -= i;
 913     }
 914   }
 915   fp->bufp = fp->buf;
 916   fp->if_stack = if_stack;
 917
 918   /* Make sure data ends with a newline.  And put a null after it.  */
 919
 920   if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
 921     fp->buf[fp->length++] = '\n';
 922   fp->buf[fp->length] = '\0';
 923
 924   /* Now that we know the input file is valid, open the output.  */
 925
 926   if (!out_fname || !strcmp (out_fname, ""))
 927     out_fname = "stdout";
 928   else if (! freopen (out_fname, "w", stdout))
 929     pfatal_with_name (out_fname);
 930
 931   output_line_command (fp, &outbuf, 0, same_file);
 932
 933   /* Scan the input, processing macros and directives.  */
 934
 935   rescan (&outbuf, 0);
 936
 937   /* Now we have processed the entire input
 938      Write whichever kind of output has been requested.  */
 939
 940
 941   if (dump_macros)
 942     dump_all_macros ();
 943   else if (! inhibit_output && deps_stream != stdout) {
 944     if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
 945       fatal ("I/O error on output");
 946   }
 947
 948   if (print_deps) {
 949     fputs (deps_buffer, deps_stream);
 950     putc ('\n', deps_stream);
 951     if (deps_stream != stdout) {
 952       fclose (deps_stream);
 953       if (ferror (deps_stream))
 954         fatal ("I/O error on output");
 955     }
 956   }
 957
 958   if (ferror (stdout))
 959     fatal ("I/O error on output");
 960
 961   if (errors)
 962     exit (FATAL_EXIT_CODE);
 963   exit (SUCCESS_EXIT_CODE);
 964
 965  sys_error:
 966   pfatal_with_name (in_fname);
 967 }
 968
 969 /* Move all backslash-newline pairs out of embarrassing places.
 970    Exchange all such pairs following BP
 971    with any potentially-embarrasing characters that follow them.
 972    Potentially-embarrassing characters are / and *
 973    (because a backslash-newline inside a comment delimiter
 974    would cause it not to be recognized).  */
 975 void
 976 newline_fix (bp)
 977      U_CHAR *bp;
 978 {
 979   register U_CHAR *p = bp;
 980   register int count = 0;
 981
 982   /* First count the backslash-newline pairs here.  */
 983
 984   while (*p++ == '\\' && *p++ == '\n')
 985     count++;
 986
 987   p = bp + count * 2;
 988
 989   /* Exit if what follows the backslash-newlines is not embarrassing.  */
 990
 991   if (count == 0 || (*p != '/' && *p != '*'))
 992     return;
 993
 994   /* Copy all potentially embarrassing characters
 995      that follow the backslash-newline pairs
 996      down to where the pairs originally started.  */
 997
 998   while (*p == '*' || *p == '/')
 999     *bp++ = *p++;
1000
1001   /* Now write the same number of pairs after the embarrassing chars.  */
1002   while (count-- > 0) {
1003     *bp++ = '\\';
1004     *bp++ = '\n';
1005   }
1006 }
1007
1008 /* Like newline_fix but for use within a directive-name.
1009    Move any backslash-newlines up past any following symbol constituents.  */
1010 void
1011 name_newline_fix (bp)
1012      U_CHAR *bp;
1013 {
1014   register U_CHAR *p = bp;
1015   register int count = 0;
1016
1017   /* First count the backslash-newline pairs here.  */
1018
1019   while (*p++ == '\\' && *p++ == '\n')
1020     count++;
1021
1022   p = bp + count * 2;
1023
1024   /* What follows the backslash-newlines is not embarrassing.  */
1025
1026   if (count == 0 || !is_idchar[*p])
1027     return;
1028
1029   /* Copy all potentially embarrassing characters
1030      that follow the backslash-newline pairs
1031      down to where the pairs originally started.  */
1032
1033   while (is_idchar[*p])
1034     *bp++ = *p++;
1035
1036   /* Now write the same number of pairs after the embarrassing chars.  */
1037   while (count-- > 0) {
1038     *bp++ = '\\';
1039     *bp++ = '\n';
1040   }
1041 }
1042 \f
1043 /*
1044  * The main loop of the program.
1045  *
1046  * Read characters from the input stack, transferring them to the
1047  * output buffer OP.
1048  *
1049  * Macros are expanded and push levels on the input stack.
1050  * At the end of such a level it is popped off and we keep reading.
1051  * At the end of any other kind of level, we return.
1052  * #-directives are handled, except within macros.
1053  *
1054  * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1055  * and insert them when appropriate.  This is set while scanning macro
1056  * arguments before substitution.  It is zero when scanning for final output.
1057  *   There are three types of Newline markers:
1058  *   * Newline -  follows a macro name that was not expanded
1059  *     because it appeared inside an expansion of the same macro.
1060  *     This marker prevents future expansion of that identifier.
1061  *     When the input is rescanned into the final output, these are deleted.
1062  *     These are also deleted by ## concatenation.
1063  *   * Newline Space (or Newline and any other whitespace character)
1064  *     stands for a place that tokens must be separated or whitespace
1065  *     is otherwise desirable, but where the ANSI standard specifies there
1066  *     is no whitespace.  This marker turns into a Space (or whichever other
1067  *     whitespace char appears in the marker) in the final output,
1068  *     but it turns into nothing in an argument that is stringified with #.
1069  *     Such stringified arguments are the only place where the ANSI standard
1070  *     specifies with precision that whitespace may not appear.
1071  *
1072  * During this function, IP->bufp is kept cached in IBP for speed of access.
1073  * Likewise, OP->bufp is kept in OBP.  Before calling a subroutine
1074  * IBP, IP and OBP must be copied back to memory.  IP and IBP are
1075  * copied back with the RECACHE macro.  OBP must be copied back from OP->bufp
1076  * explicitly, and before RECACHE, since RECACHE uses OBP.
1077  */
1078
1079 void
1080 rescan (op, output_marks)
1081      FILE_BUF *op;
1082      int output_marks;
1083 {
1084   /* Character being scanned in main loop.  */
1085   register U_CHAR c;
1086
1087   /* Length of pending accumulated identifier.  */
1088   register int ident_length = 0;
1089
1090   /* Hash code of pending accumulated identifier.  */
1091   register int hash = 0;
1092
1093   /* Current input level (&instack[indepth]).  */
1094   FILE_BUF *ip;
1095
1096   /* Pointer for scanning input.  */
1097   register U_CHAR *ibp;
1098
1099   /* Pointer to end of input.  End of scan is controlled by LIMIT.  */
1100   register U_CHAR *limit;
1101
1102   /* Pointer for storing output.  */
1103   register U_CHAR *obp;
1104
1105   /* REDO_CHAR is nonzero if we are processing an identifier
1106      after backing up over the terminating character.
1107      Sometimes we process an identifier without backing up over
1108      the terminating character, if the terminating character
1109      is not special.  Backing up is done so that the terminating character
1110      will be dispatched on again once the identifier is dealt with.  */
1111   int redo_char = 0;
1112
1113   /* 1 if within an identifier inside of which a concatenation
1114      marker (Newline -) has been seen.  */
1115   int concatenated = 0;
1116
1117   /* While scanning a comment or a string constant,
1118      this records the line it started on, for error messages.  */
1119   int start_line;
1120
1121   /* Record position of last `real' newline.  */
1122   U_CHAR *beg_of_line;
1123
1124 /* Pop the innermost input stack level, assuming it is a macro expansion.  */
1125
1126 #define POPMACRO \
1127 do { ip->macro->type = T_MACRO;         \
1128      if (ip->free_ptr) free (ip->free_ptr);     \
1129      --indepth; } while (0)
1130
1131 /* Reload `rescan's local variables that describe the current
1132    level of the input stack.  */
1133
1134 #define RECACHE  \
1135 do { ip = &instack[indepth];            \
1136      ibp = ip->bufp;                    \
1137      limit = ip->buf + ip->length;      \
1138      op->bufp = obp;                    \
1139      check_expand (op, limit - ibp);    \
1140      beg_of_line = 0;                   \
1141      obp = op->bufp; } while (0)
1142
1143   if (no_output && instack[indepth].fname != 0)
1144     skip_if_group (&instack[indepth], 1);
1145
1146   obp = op->bufp;
1147   RECACHE;
1148   beg_of_line = ibp;
1149
1150   /* Our caller must always put a null after the end of
1151      the input at each input stack level.  */
1152   if (*limit != 0)
1153     abort ();
1154
1155   while (1) {
1156     c = *ibp++;
1157     *obp++ = c;
1158
1159     switch (c) {
1160     case '\\':
1161       if (ibp >= limit)
1162         break;
1163       if (*ibp == '\n') {
1164         /* Always merge lines ending with backslash-newline,
1165            even in middle of identifier.  */
1166         ++ibp;
1167         ++ip->lineno;
1168         --obp;          /* remove backslash from obuf */
1169         break;
1170       }
1171       /* Otherwise, backslash suppresses specialness of following char,
1172          so copy it here to prevent the switch from seeing it.
1173          But first get any pending identifier processed.  */
1174       if (ident_length > 0)
1175         goto specialchar;
1176       *obp++ = *ibp++;
1177       break;
1178
1179     case '#':
1180       /* If this is expanding a macro definition, don't recognize
1181          preprocessor directives.  */
1182       if (ip->macro != 0)
1183         goto randomchar;
1184       if (ident_length)
1185         goto specialchar;
1186
1187       /* # keyword: a # must be the first char on the line */
1188       if (beg_of_line == 0)
1189         goto randomchar;
1190       if (beg_of_line + 1 != ibp)
1191         goto randomchar;
1192
1193       /* This # can start a directive.  */
1194
1195       --obp;            /* Don't copy the '#' */
1196
1197       ip->bufp = ibp;
1198       op->bufp = obp;
1199       if (! handle_directive (ip, op)) {
1200 #ifdef USE_C_ALLOCA
1201         alloca (0);
1202 #endif
1203         /* Not a known directive: treat it as ordinary text.
1204            IP, OP, IBP, etc. have not been changed.  */
1205         if (no_output && instack[indepth].fname) {
1206           /* If not generating expanded output,
1207              what we do with ordinary text is skip it.
1208              Discard everything until next # directive.  */
1209           skip_if_group (&instack[indepth], 1);
1210           RECACHE;
1211           beg_of_line = ibp;
1212           break;
1213         }
1214         ++obp;          /* Copy the '#' after all */
1215         goto randomchar;
1216       }
1217 #ifdef USE_C_ALLOCA
1218       alloca (0);
1219 #endif
1220       /* A # directive has been successfully processed.  */
1221       /* If not generating expanded output, ignore everything until
1222          next # directive.  */
1223       if (no_output && instack[indepth].fname)
1224         skip_if_group (&instack[indepth], 1);
1225       obp = op->bufp;
1226       RECACHE;
1227       beg_of_line = ibp;
1228       break;
1229
1230     case '\"':                  /* skip quoted string */
1231     case '\'':
1232       /* A single quoted string is treated like a double -- some
1233          programs (e.g., troff) are perverse this way */
1234
1235       if (ident_length)
1236         goto specialchar;
1237
1238       start_line = ip->lineno;
1239
1240       /* Skip ahead to a matching quote.  */
1241
1242       while (1) {
1243         if (ibp >= limit) {
1244           if (ip->macro != 0) {
1245             /* try harder: this string crosses a macro expansion boundary */
1246             POPMACRO;
1247             RECACHE;
1248             continue;
1249           }
1250           break;
1251         }
1252         *obp++ = *ibp;
1253         switch (*ibp++) {
1254         case '\n':
1255           ++ip->lineno;
1256           ++op->lineno;
1257           /* Traditionally, end of line ends a string constant with no error.
1258              So exit the loop and record the new line.  */
1259           beg_of_line = ibp;
1260           goto while2end;
1261
1262         case '\\':
1263           if (ibp >= limit)
1264             break;
1265           if (*ibp == '\n') {
1266             /* Backslash newline is replaced by nothing at all,
1267                but keep the line counts correct.  */
1268             --obp;
1269             ++ibp;
1270             ++ip->lineno;
1271           } else {
1272             /* ANSI stupidly requires that in \\ the second \
1273                is *not* prevented from combining with a newline.  */
1274             while (*ibp == '\\' && ibp[1] == '\n') {
1275               ibp += 2;
1276               ++ip->lineno;
1277             }
1278             *obp++ = *ibp++;
1279           }
1280           break;
1281
1282         case '\"':
1283         case '\'':
1284           if (ibp[-1] == c)
1285             goto while2end;
1286           break;
1287         }
1288       }
1289     while2end:
1290       break;
1291
1292     case '/':
1293       if (*ibp == '\\' && ibp[1] == '\n')
1294         newline_fix (ibp);
1295       /* Don't look for comments inside a macro definition.  */
1296       if (ip->macro != 0)
1297         goto randomchar;
1298       /* A comment constitutes white space, so it can terminate an identifier.
1299          Process the identifier, if any.  */
1300       if (ident_length)
1301         goto specialchar;
1302
1303       if (*ibp != '*')
1304         goto randomchar;
1305
1306       /* We have a comment.  Skip it, optionally copying it to output.  */
1307
1308       start_line = ip->lineno;
1309
1310       ++ibp;                    /* Skip the star. */
1311
1312       /* In K+R C, a comment is equivalent to nothing.  Note that we
1313           already output the slash; we might not want it.  */
1314       if (! put_out_comments)
1315         obp--;
1316       else
1317         *obp++ = '*';
1318
1319       {
1320         U_CHAR *before_bp = ibp;
1321
1322         while (ibp < limit) {
1323           switch (*ibp++) {
1324           case '/':
1325             if (warn_comments && ibp < limit && *ibp == '*')
1326               warning("`/*' within comment");
1327             break;
1328           case '*':
1329             if (*ibp == '\\' && ibp[1] == '\n')
1330               newline_fix (ibp);
1331             if (ibp >= limit || *ibp == '/')
1332               goto comment_end;
1333             break;
1334           case '\n':
1335             ++ip->lineno;
1336             /* Copy the newline into the output buffer, in order to
1337                avoid the pain of a #line every time a multiline comment
1338                is seen.  */
1339             if (!put_out_comments)
1340               *obp++ = '\n';
1341             ++op->lineno;
1342           }
1343         }
1344       comment_end:
1345
1346         if (ibp >= limit)
1347           error_with_line (line_for_error (start_line),
1348                            "unterminated comment");
1349         else {
1350           ibp++;
1351           if (put_out_comments) {
1352             memcpy (obp, before_bp, ibp - before_bp);
1353             obp += ibp - before_bp;
1354           }
1355         }
1356       }
1357       break;
1358
1359     case '0': case '1': case '2': case '3': case '4':
1360     case '5': case '6': case '7': case '8': case '9':
1361       /* If digit is not part of identifier, it starts a number,
1362          which means that following letters are not an identifier.
1363          "0x5" does not refer to an identifier "x5".
1364          So copy all alphanumerics that follow without accumulating
1365          as an identifier.  Periods also, for sake of "3.e7".  */
1366
1367       if (ident_length == 0) {
1368         while (ibp < limit) {
1369           while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
1370             ++ip->lineno;
1371             ibp += 2;
1372           }
1373           c = *ibp++;
1374           if (!isalnum (c) && c != '.' && c != '_') {
1375             --ibp;
1376             break;
1377           }
1378           *obp++ = c;
1379           /* A sign can be part of a preprocessing number
1380              if it follows an e.  */
1381           if (c == 'e' || c == 'E') {
1382             while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
1383               ++ip->lineno;
1384               ibp += 2;
1385             }
1386             if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
1387               *obp++ = *ibp++;
1388               /* Traditional C does not let the token go past the sign.  */
1389               break;
1390             }
1391           }
1392         }
1393         break;
1394       }
1395       /* fall through */
1396
1397     case '_':
1398     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1399     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1400     case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1401     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1402     case 'y': case 'z':
1403     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1404     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1405     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1406     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1407     case 'Y': case 'Z':
1408       ident_length++;
1409       /* Compute step of hash function, to avoid a proc call on every token */
1410       hash = HASHSTEP (hash, c);
1411       break;
1412
1413     case '\n':
1414       /* If reprocessing a macro expansion, newline is a special marker.  */
1415       if (ip->macro != 0) {
1416         /* Newline White is a "funny space" to separate tokens that are
1417            supposed to be separate but without space between.
1418            Here White means any horizontal whitespace character.
1419            Newline - marks a recursive macro use that is not
1420            supposed to be expandable.  */
1421
1422         if (*ibp == '-') {
1423           /* Newline - inhibits expansion of preceding token.
1424              If expanding a macro arg, we keep the newline -.
1425              In final output, it is deleted.  */
1426           if (! concatenated) {
1427             ident_length = 0;
1428             hash = 0;
1429           }
1430           ibp++;
1431           if (!output_marks) {
1432             obp--;
1433           } else {
1434             /* If expanding a macro arg, keep the newline -.  */
1435             *obp++ = '-';
1436           }
1437         } else if (is_space[*ibp]) {
1438           /* Newline Space does not prevent expansion of preceding token
1439              so expand the preceding token and then come back.  */
1440           if (ident_length > 0)
1441             goto specialchar;
1442
1443           /* If generating final output, newline space makes a space.  */
1444           if (!output_marks) {
1445             obp[-1] = *ibp++;
1446             /* And Newline Newline makes a newline, so count it.  */
1447             if (obp[-1] == '\n')
1448               op->lineno++;
1449           } else {
1450             /* If expanding a macro arg, keep the newline space.
1451                If the arg gets stringified, newline space makes nothing.  */
1452             *obp++ = *ibp++;
1453           }
1454         } else abort ();        /* Newline followed by something random?  */
1455         break;
1456       }
1457
1458       /* If there is a pending identifier, handle it and come back here.  */
1459       if (ident_length > 0)
1460         goto specialchar;
1461
1462       beg_of_line = ibp;
1463
1464       /* Update the line counts and output a #line if necessary.  */
1465       ++ip->lineno;
1466       ++op->lineno;
1467       if (ip->lineno != op->lineno) {
1468         op->bufp = obp;
1469         output_line_command (ip, op, 1, same_file);
1470         check_expand (op, ip->length - (ip->bufp - ip->buf));
1471         obp = op->bufp;
1472       }
1473       break;
1474
1475       /* Come here either after (1) a null character that is part of the input
1476          or (2) at the end of the input, because there is a null there.  */
1477     case 0:
1478       if (ibp <= limit)
1479         /* Our input really contains a null character.  */
1480         goto randomchar;
1481
1482       /* At end of a macro-expansion level, pop it and read next level.  */
1483       if (ip->macro != 0) {
1484         obp--;
1485         ibp--;
1486         /* If we have an identifier that ends here, process it now, so
1487            we get the right error for recursion.  */
1488         if (ident_length && ! is_idchar[*instack[indepth - 1].bufp]) {
1489           redo_char = 1;
1490           goto randomchar;
1491         }
1492         POPMACRO;
1493         RECACHE;
1494         break;
1495       }
1496
1497       /* If we don't have a pending identifier,
1498          return at end of input.  */
1499       if (ident_length == 0) {
1500         obp--;
1501         ibp--;
1502         op->bufp = obp;
1503         ip->bufp = ibp;
1504         goto ending;
1505       }
1506
1507       /* If we do have a pending identifier, just consider this null
1508          a special character and arrange to dispatch on it again.
1509          The second time, IDENT_LENGTH will be zero so we will return.  */
1510
1511       /* Fall through */
1512
1513 specialchar:
1514
1515       /* Handle the case of a character such as /, ', " or null
1516          seen following an identifier.  Back over it so that
1517          after the identifier is processed the special char
1518          will be dispatched on again.  */
1519
1520       ibp--;
1521       obp--;
1522       redo_char = 1;
1523
1524     default:
1525
1526 randomchar:
1527
1528       if (ident_length > 0) {
1529         register HASHNODE *hp;
1530
1531         /* We have just seen an identifier end.  If it's a macro, expand it.
1532
1533            IDENT_LENGTH is the length of the identifier
1534            and HASH is its hash code.
1535
1536            The identifier has already been copied to the output,
1537            so if it is a macro we must remove it.
1538
1539            If REDO_CHAR is 0, the char that terminated the identifier
1540            has been skipped in the output and the input.
1541            OBP-IDENT_LENGTH-1 points to the identifier.
1542            If the identifier is a macro, we must back over the terminator.
1543
1544            If REDO_CHAR is 1, the terminating char has already been
1545            backed over.  OBP-IDENT_LENGTH points to the identifier.  */
1546
1547         for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
1548              hp = hp->next) {
1549
1550           if (hp->length == ident_length) {
1551             U_CHAR *obufp_before_macroname;
1552             int op_lineno_before_macroname;
1553             register int i = ident_length;
1554             register U_CHAR *p = hp->name;
1555             register U_CHAR *q = obp - i;
1556
1557             if (! redo_char)
1558               q--;
1559
1560             do {                /* All this to avoid a strncmp () */
1561               if (*p++ != *q++)
1562                 goto hashcollision;
1563             } while (--i);
1564
1565             /* We found a use of a macro name.
1566                see if the context shows it is a macro call.  */
1567
1568             /* Back up over terminating character if not already done.  */
1569             if (! redo_char) {
1570               ibp--;
1571               obp--;
1572             }
1573
1574             obufp_before_macroname = obp - ident_length;
1575             op_lineno_before_macroname = op->lineno;
1576
1577             /* If macro wants an arglist, verify that a '(' follows.
1578                first skip all whitespace, copying it to the output
1579                after the macro name.  Then, if there is no '(',
1580                decide this is not a macro call and leave things that way.  */
1581             if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
1582               {
1583                 while (1) {
1584                   /* Scan forward over whitespace, copying it to the output.  */
1585                   if (ibp == limit && ip->macro != 0) {
1586                     POPMACRO;
1587                     RECACHE;
1588                   }
1589                   /* A comment: copy it unchanged or discard it.  */
1590                   else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
1591                     if (put_out_comments) {
1592                       *obp++ = '/';
1593                       *obp++ = '*';
1594                     }
1595                     ibp += 2;
1596                     while (ibp + 1 != limit
1597                            && !(ibp[0] == '*' && ibp[1] == '/')) {
1598                       /* We need not worry about newline-marks,
1599                          since they are never found in comments.  */
1600                       if (*ibp == '\n') {
1601                         /* Newline in a file.  Count it.  */
1602                         ++ip->lineno;
1603                         ++op->lineno;
1604                       }
1605                       if (put_out_comments)
1606                         *obp++ = *ibp++;
1607                       else
1608                         ibp++;
1609                     }
1610                     ibp += 2;
1611                     if (put_out_comments) {
1612                       *obp++ = '*';
1613                       *obp++ = '/';
1614                     }
1615                   }
1616                   else if (is_space[*ibp]) {
1617                     *obp++ = *ibp++;
1618                     if (ibp[-1] == '\n') {
1619                       if (ip->macro == 0) {
1620                         /* Newline in a file.  Count it.  */
1621                         ++ip->lineno;
1622                         ++op->lineno;
1623                       } else if (!output_marks) {
1624                         /* A newline mark, and we don't want marks
1625                            in the output.  If it is newline-hyphen,
1626                            discard it entirely.  Otherwise, it is
1627                            newline-whitechar, so keep the whitechar.  */
1628                         obp--;
1629                         if (*ibp == '-')
1630                           ibp++;
1631                         else {
1632                           if (*ibp == '\n')
1633                             ++op->lineno;
1634                           *obp++ = *ibp++;
1635                         }
1636                       } else {
1637                         /* A newline mark; copy both chars to the output.  */
1638                         *obp++ = *ibp++;
1639                       }
1640                     }
1641                   }
1642                   else break;
1643                 }
1644                 if (*ibp != '(')
1645                   break;
1646               }
1647
1648             /* This is now known to be a macro call.
1649                Discard the macro name from the output,
1650                along with any following whitespace just copied.  */
1651             obp = obufp_before_macroname;
1652             op->lineno = op_lineno_before_macroname;
1653
1654             /* Expand the macro, reading arguments as needed,
1655                and push the expansion on the input stack.  */
1656             ip->bufp = ibp;
1657             op->bufp = obp;
1658             macroexpand (hp, op);
1659
1660             /* Reexamine input stack, since macroexpand has pushed
1661                a new level on it.  */
1662             obp = op->bufp;
1663             RECACHE;
1664             break;
1665           }
1666 hashcollision:
1667                ;
1668         }                       /* End hash-table-search loop */
1669         ident_length = hash = 0; /* Stop collecting identifier */
1670         redo_char = 0;
1671         concatenated = 0;
1672       }                         /* End if (ident_length > 0) */
1673     }                           /* End switch */
1674   }                             /* End per-char loop */
1675
1676   /* Come here to return -- but first give an error message
1677      if there was an unterminated successful conditional.  */
1678  ending:
1679   if (if_stack != ip->if_stack) {
1680     const char *str;
1681     switch (if_stack->type) {
1682     case T_IF:
1683       str = "if";
1684       break;
1685     case T_IFDEF:
1686       str = "ifdef";
1687       break;
1688     case T_IFNDEF:
1689       str = "ifndef";
1690       break;
1691     case T_ELSE:
1692       str = "else";
1693       break;
1694     case T_ELIF:
1695       str = "elif";
1696       break;
1697     default:
1698       abort ();
1699     }
1700     error_with_line (line_for_error (if_stack->lineno),
1701                      "unterminated #%s conditional", str);
1702   }
1703   if_stack = ip->if_stack;
1704 }
1705 \f
1706 /*
1707  * Rescan a string into a temporary buffer and return the result
1708  * as a FILE_BUF.  Note this function returns a struct, not a pointer.
1709  *
1710  * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1711  * and insert such markers when appropriate.  See `rescan' for details.
1712  * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1713  * before substitution; it is 0 for other uses.
1714  */
1715 FILE_BUF
1716 expand_to_temp_buffer (buf, limit, output_marks)
1717      U_CHAR *buf, *limit;
1718      int output_marks;
1719 {
1720   register FILE_BUF *ip;
1721   FILE_BUF obuf;
1722   int length = limit - buf;
1723   U_CHAR *buf1;
1724   int odepth = indepth;
1725
1726   if (length < 0)
1727     abort ();
1728
1729   /* Set up the input on the input stack.  */
1730
1731   buf1 = (U_CHAR *) alloca (length + 1);
1732   {
1733     register U_CHAR *p1 = buf;
1734     register U_CHAR *p2 = buf1;
1735
1736     while (p1 != limit)
1737       *p2++ = *p1++;
1738   }
1739   buf1[length] = 0;
1740
1741   /* Set up to receive the output.  */
1742
1743   obuf.length = length * 2 + 100; /* Usually enough.  Why be stingy?  */
1744   obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
1745   obuf.fname = 0;
1746   obuf.macro = 0;
1747   obuf.free_ptr = 0;
1748
1749   CHECK_DEPTH ({return obuf;});
1750
1751   ++indepth;
1752
1753   ip = &instack[indepth];
1754   ip->fname = 0;
1755   ip->macro = 0;
1756   ip->free_ptr = 0;
1757   ip->length = length;
1758   ip->buf = ip->bufp = buf1;
1759   ip->if_stack = if_stack;
1760
1761   ip->lineno = obuf.lineno = 1;
1762
1763   /* Scan the input, create the output.  */
1764
1765   rescan (&obuf, output_marks);
1766
1767   /* Pop input stack to original state.  */
1768   --indepth;
1769
1770   if (indepth != odepth)
1771     abort ();
1772
1773   /* Record the output.  */
1774   obuf.length = obuf.bufp - obuf.buf;
1775
1776   return obuf;
1777 }
1778 \f
1779 /*
1780  * Process a # directive.  Expects IP->bufp to point to the '#', as in
1781  * `#define foo bar'.  Passes to the command handler
1782  * (do_define, do_include, etc.): the addresses of the 1st and
1783  * last chars of the command (starting immediately after the #
1784  * keyword), plus op and the keyword table pointer.  If the command
1785  * contains comments it is copied into a temporary buffer sans comments
1786  * and the temporary buffer is passed to the command handler instead.
1787  * Likewise for backslash-newlines.
1788  *
1789  * Returns nonzero if this was a known # directive.
1790  * Otherwise, returns zero, without advancing the input pointer.
1791  */
1792
1793 int
1794 handle_directive (ip, op)
1795      FILE_BUF *ip, *op;
1796 {
1797   register U_CHAR *bp, *cp;
1798   register struct directive *kt;
1799   register int ident_length;
1800   U_CHAR *resume_p;
1801
1802   /* Nonzero means we must copy the entire command
1803      to get rid of comments or backslash-newlines.  */
1804   int copy_command = 0;
1805
1806   U_CHAR *ident, *after_ident;
1807
1808   bp = ip->bufp;
1809   /* Skip whitespace and \-newline.  */
1810   while (1) {
1811     if (is_hor_space[*bp])
1812       bp++;
1813     else if (*bp == '/' && (newline_fix (bp + 1), bp[1]) == '*') {
1814       ip->bufp = bp;
1815       skip_to_end_of_comment (ip, &ip->lineno);
1816       bp = ip->bufp;
1817     } else if (*bp == '\\' && bp[1] == '\n') {
1818       bp += 2; ip->lineno++;
1819     } else break;
1820   }
1821
1822   /* Now find end of directive name.
1823      If we encounter a backslash-newline, exchange it with any following
1824      symbol-constituents so that we end up with a contiguous name.  */
1825
1826   cp = bp;
1827   while (1) {
1828     if (is_idchar[*cp])
1829       cp++;
1830     else {
1831       if (*cp == '\\' && cp[1] == '\n')
1832         name_newline_fix (cp);
1833       if (is_idchar[*cp])
1834         cp++;
1835       else break;
1836     }
1837   }
1838   ident_length = cp - bp;
1839   ident = bp;
1840   after_ident = cp;
1841
1842   /* A line of just `#' becomes blank.  */
1843
1844   if (ident_length == 0 && *after_ident == '\n') {
1845     ip->bufp = after_ident;
1846     return 1;
1847   }
1848
1849   /*
1850    * Decode the keyword and call the appropriate expansion
1851    * routine, after moving the input pointer up to the next line.
1852    */
1853   for (kt = directive_table; kt->length > 0; kt++) {
1854     if (kt->length == ident_length
1855         && !strncmp (kt->name, (char *)ident, ident_length)) {
1856       register U_CHAR *buf;
1857       register U_CHAR *limit = ip->buf + ip->length;
1858       int unterminated = 0;
1859
1860       /* Nonzero means do not delete comments within the directive.
1861          #define needs this to detect traditional token paste.  */
1862       int keep_comments = kt->type == T_DEFINE;
1863
1864       /* Find the end of this command (first newline not backslashed
1865          and not in a string or comment).
1866          Set COPY_COMMAND if the command must be copied
1867          (it contains a backslash-newline or a comment).  */
1868
1869       buf = bp = after_ident;
1870       while (bp < limit) {
1871         register U_CHAR c = *bp++;
1872         switch (c) {
1873         case '\\':
1874           if (bp < limit) {
1875             if (*bp == '\n') {
1876               ip->lineno++;
1877               copy_command = 1;
1878             }
1879             bp++;
1880           }
1881           break;
1882
1883         case '\'':
1884         case '\"':
1885           bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, &copy_command, &unterminated);
1886           if (unterminated) {
1887             /* Traditional preprocessing permits unterminated strings.  */
1888             ip->bufp = bp;
1889             goto endloop1;
1890           }
1891           break;
1892
1893           /* <...> is special for #include.  */
1894         case '<':
1895           if (kt->type != T_INCLUDE)
1896             break;
1897           while (*bp && *bp != '>') bp++;
1898           break;
1899
1900         case '/':
1901           if (*bp == '\\' && bp[1] == '\n')
1902             newline_fix (bp);
1903           if (*bp == '*') {
1904             U_CHAR *obp = bp - 1;
1905             ip->bufp = bp + 1;
1906             skip_to_end_of_comment (ip, &ip->lineno);
1907             bp = ip->bufp;
1908             /* No need to copy the command because of a comment at the end;
1909                just don't include the comment in the directive.  */
1910             if (bp == limit || *bp == '\n') {
1911               bp = obp;
1912               goto endloop1;
1913             }
1914             /* Don't remove the comments if this is #define.  */
1915             if (! keep_comments)
1916               copy_command++;
1917           }
1918           break;
1919
1920         case '\n':
1921           --bp;         /* Point to the newline */
1922           ip->bufp = bp;
1923           goto endloop1;
1924         }
1925       }
1926       ip->bufp = bp;
1927
1928     endloop1:
1929       resume_p = ip->bufp;
1930       /* BP is the end of the directive.
1931          RESUME_P is the next interesting data after the directive.
1932          A comment may come between.  */
1933
1934       if (copy_command) {
1935         register U_CHAR *xp = buf;
1936         /* Need to copy entire command into temp buffer before dispatching */
1937
1938         cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
1939                                                   some slop */
1940         buf = cp;
1941
1942         /* Copy to the new buffer, deleting comments
1943            and backslash-newlines (and whitespace surrounding the latter).  */
1944
1945         while (xp < bp) {
1946           register U_CHAR c = *xp++;
1947           *cp++ = c;
1948
1949           switch (c) {
1950           case '\n':
1951             break;
1952
1953             /* <...> is special for #include.  */
1954           case '<':
1955             if (kt->type != T_INCLUDE)
1956               break;
1957             while (xp < bp && c != '>') {
1958               c = *xp++;
1959               if (c == '\\' && xp < bp && *xp == '\n')
1960                 xp++, ip->lineno++;
1961               else
1962                 *cp++ = c;
1963             }
1964             break;
1965
1966           case '\\':
1967             if (*xp == '\n') {
1968               xp++;
1969               cp--;
1970               if (cp != buf && is_space[cp[-1]]) {
1971                 while (cp != buf && is_space[cp[-1]]) cp--;
1972                 cp++;
1973                 SKIP_WHITE_SPACE (xp);
1974               } else if (is_space[*xp]) {
1975                 *cp++ = *xp++;
1976                 SKIP_WHITE_SPACE (xp);
1977               }
1978             } else {
1979               *cp++ = *xp++;
1980             }
1981             break;
1982
1983           case '\'':
1984           case '\"':
1985             {
1986               register U_CHAR *bp1
1987                 = skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
1988               while (xp != bp1)
1989                 *cp++ = *xp++;
1990             }
1991             break;
1992
1993           case '/':
1994             if (*xp == '*') {
1995               ip->bufp = xp + 1;
1996               skip_to_end_of_comment (ip, 0);
1997               if (keep_comments)
1998                 while (xp != ip->bufp)
1999                   *cp++ = *xp++;
2000               /* Delete the slash.  */
2001               else
2002                 cp--;
2003               xp = ip->bufp;
2004             }
2005           }
2006         }
2007
2008         /* Null-terminate the copy.  */
2009
2010         *cp = 0;
2011       }
2012       else
2013         cp = bp;
2014
2015       ip->bufp = resume_p;
2016
2017       /* Call the appropriate command handler.  buf now points to
2018          either the appropriate place in the input buffer, or to
2019          the temp buffer if it was necessary to make one.  cp
2020          points to the first char after the contents of the (possibly
2021          copied) command, in either case. */
2022       (*kt->func) (buf, cp, op, kt);
2023       check_expand (op, ip->length - (ip->bufp - ip->buf));
2024
2025       return 1;
2026     }
2027   }
2028
2029   return 0;
2030 }
2031 \f
2032 static const char *const
2033 monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2034                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2035
2036 /*
2037  * expand things like __FILE__.  Place the expansion into the output
2038  * buffer *without* rescanning.
2039  */
2040 void
2041 special_symbol (hp, op)
2042      HASHNODE *hp;
2043      FILE_BUF *op;
2044 {
2045   char *buf = 0;
2046   time_t t;
2047   int i, len;
2048   int true_indepth;
2049   FILE_BUF *ip = NULL;
2050   static struct tm *timebuf = NULL;
2051
2052   int paren = 0;                /* For special `defined' keyword */
2053
2054   for (i = indepth; i >= 0; i--)
2055     if (instack[i].fname != NULL) {
2056       ip = &instack[i];
2057       break;
2058     }
2059   if (ip == NULL)
2060     fatal ("not in any file?!");
2061
2062   switch (hp->type) {
2063   case T_FILE:
2064   case T_BASE_FILE:
2065     {
2066       const char *string;
2067       if (hp->type == T_FILE)
2068         string = ip->fname;
2069       else
2070         string = instack[0].fname;
2071
2072       if (string)
2073         {
2074           buf = (char *) alloca (3 + strlen (string));
2075           sprintf (buf, "\"%s\"", string);
2076         }
2077       else
2078         strcpy (buf, "\"\"");
2079
2080       break;
2081     }
2082
2083   case T_INCLUDE_LEVEL:
2084     true_indepth = 0;
2085     for (i = indepth; i >= 0; i--)
2086       if (instack[i].fname != NULL)
2087         true_indepth++;
2088
2089     buf = (char *) alloca (8);  /* Eigth bytes ought to be more than enough */
2090     sprintf (buf, "%d", true_indepth - 1);
2091     break;
2092
2093   case T_VERSION:
2094     buf = (char *) alloca (3 + strlen (version_string));
2095     sprintf (buf, "\"%s\"", version_string);
2096     break;
2097
2098   case T_CONST:
2099     buf = (char *) hp->value.cpval;
2100     break;
2101
2102   case T_SPECLINE:
2103     buf = (char *) alloca (10);
2104     sprintf (buf, "%d", ip->lineno);
2105     break;
2106
2107   case T_DATE:
2108   case T_TIME:
2109     if (timebuf == NULL) {
2110       t = time (0);
2111       timebuf = localtime (&t);
2112     }
2113     buf = (char *) alloca (20);
2114     if (hp->type == T_DATE)
2115       sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2116               timebuf->tm_mday, timebuf->tm_year + 1900);
2117     else
2118       sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2119               timebuf->tm_sec);
2120     break;
2121
2122   case T_SPEC_DEFINED:
2123     buf = (char *) " 0 ";               /* Assume symbol is not defined */
2124     ip = &instack[indepth];
2125     SKIP_WHITE_SPACE (ip->bufp);
2126     if (*ip->bufp == '(') {
2127       paren++;
2128       ip->bufp++;                       /* Skip over the paren */
2129       SKIP_WHITE_SPACE (ip->bufp);
2130     }
2131
2132     if (!is_idstart[*ip->bufp])
2133       goto oops;
2134     if (lookup (ip->bufp, -1, -1))
2135       buf = (char *) " 1 ";
2136     while (is_idchar[*ip->bufp])
2137       ++ip->bufp;
2138     SKIP_WHITE_SPACE (ip->bufp);
2139     if (paren) {
2140       if (*ip->bufp != ')')
2141         goto oops;
2142       ++ip->bufp;
2143     }
2144     break;
2145
2146 oops:
2147
2148     error ("`defined' must be followed by ident or (ident)");
2149     break;
2150
2151   default:
2152     error ("cccp error: invalid special hash type"); /* time for gdb */
2153     abort ();
2154   }
2155   len = strlen (buf);
2156   check_expand (op, len);
2157   memcpy (op->bufp, buf, len);
2158   op->bufp += len;
2159 }
2160
2161 \f
2162 /* Routines to handle #directives */
2163
2164 /*
2165  * Process include file by reading it in and calling rescan.
2166  * Expects to see "fname" or <fname> on the input.
2167  */
2168 void
2169 do_include (buf, limit, op, keyword)
2170      U_CHAR *buf, *limit;
2171      FILE_BUF *op;
2172      struct directive *keyword ATTRIBUTE_UNUSED;
2173 {
2174   char *fname;          /* Dynamically allocated fname buffer */
2175   U_CHAR *fbeg, *fend;          /* Beginning and end of fname */
2176
2177   struct file_name_list *stackp = include; /* Chain of dirs to search */
2178   struct file_name_list dsp[1]; /* First in chain, if #include "..." */
2179   int flen;
2180
2181   int f;                        /* file number */
2182
2183   int retried = 0;              /* Have already tried macro
2184                                    expanding the include line*/
2185   FILE_BUF trybuf;              /* It got expanded into here */
2186   int system_header_p = 0;      /* 0 for "...", 1 for <...> */
2187
2188   f= -1;                        /* JF we iz paranoid! */
2189
2190 get_filename:
2191
2192   fbeg = buf;
2193   SKIP_WHITE_SPACE (fbeg);
2194   /* Discard trailing whitespace so we can easily see
2195      if we have parsed all the significant chars we were given.  */
2196   while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
2197
2198   switch (*fbeg++) {
2199   case '\"':
2200     fend = fbeg;
2201     while (fend != limit && *fend != '\"')
2202       fend++;
2203     if (*fend == '\"' && fend + 1 == limit) {
2204       FILE_BUF *fp;
2205
2206       /* We have "filename".  Figure out directory this source
2207          file is coming from and put it on the front of the list. */
2208
2209       /* If -I- was specified, don't search current dir, only spec'd ones. */
2210       if (ignore_srcdir) break;
2211
2212       for (fp = &instack[indepth]; fp >= instack; fp--)
2213         {
2214           size_t n;
2215           const char *ep, *nam;
2216
2217           if ((nam = fp->fname) != NULL) {
2218             /* Found a named file.  Figure out dir of the file,
2219                and put it in front of the search list.  */
2220             dsp[0].next = stackp;
2221             stackp = dsp;
2222             ep = strrchr (nam, '/');
2223             if (ep != NULL) {
2224               char *f;
2225               n = ep - nam;
2226               f = (char *) alloca (n + 1);
2227               strncpy (f, nam, n);
2228               f[n] = '\0';
2229               dsp[0].fname = f;
2230               if (n > max_include_len) max_include_len = n;
2231             } else {
2232               dsp[0].fname = 0; /* Current directory */
2233             }
2234             break;
2235           }
2236         }
2237       break;
2238     }
2239     goto fail;
2240
2241   case '<':
2242     fend = fbeg;
2243     while (fend != limit && *fend != '>') fend++;
2244     if (*fend == '>' && fend + 1 == limit) {
2245       system_header_p = 1;
2246       /* If -I-, start with the first -I dir after the -I-.  */
2247       if (first_bracket_include)
2248         stackp = first_bracket_include;
2249       break;
2250     }
2251     goto fail;
2252
2253   default:
2254   fail:
2255     if (retried) {
2256       error ("#include expects \"fname\" or <fname>");
2257       return;
2258     } else {
2259       trybuf = expand_to_temp_buffer (buf, limit, 0);
2260       buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
2261       memcpy (buf, trybuf.buf, trybuf.bufp - trybuf.buf);
2262       limit = buf + (trybuf.bufp - trybuf.buf);
2263       free (trybuf.buf);
2264       retried++;
2265       goto get_filename;
2266     }
2267   }
2268
2269   flen = fend - fbeg;
2270   fname = (char *) alloca (max_include_len + flen + 2);
2271   /* + 2 above for slash and terminating null.  */
2272
2273   /* If specified file name is absolute, just open it.  */
2274
2275   if (*fbeg == '/') {
2276     strncpy (fname, (char *)fbeg, flen);
2277     fname[flen] = 0;
2278     f = open (fname, O_RDONLY, 0666);
2279   } else {
2280     /* Search directory path, trying to open the file.
2281        Copy each filename tried into FNAME.  */
2282
2283     for (; stackp; stackp = stackp->next) {
2284       if (stackp->fname) {
2285         strcpy (fname, stackp->fname);
2286         strcat (fname, "/");
2287         fname[strlen (fname) + flen] = 0;
2288       } else {
2289         fname[0] = 0;
2290       }
2291       strncat (fname, (char *)fbeg, flen);
2292       if ((f = open (fname, O_RDONLY, 0666)) >= 0)
2293         break;
2294     }
2295   }
2296
2297   if (f < 0) {
2298     strncpy (fname, (char *)fbeg, flen);
2299     fname[flen] = 0;
2300     error_from_errno (fname);
2301
2302     /* For -M, add this file to the dependencies.  */
2303     if (print_deps > (system_header_p || (system_include_depth > 0))) {
2304       if (system_header_p)
2305         warning ("nonexistent file <%.*s> omitted from dependency output",
2306                  fend - fbeg, fbeg);
2307       else
2308         {
2309           deps_output ((const char *)fbeg, fend - fbeg);
2310           deps_output (" ", 0);
2311         }
2312     }
2313   } else {
2314
2315     /* Check to see if this include file is a once-only include file.
2316        If so, give up.  */
2317
2318     struct file_name_list* ptr;
2319
2320     for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
2321       if (!strcmp (ptr->fname, fname)) {
2322         close (f);
2323         return;                         /* This file was once'd. */
2324       }
2325     }
2326
2327     for (ptr = all_include_files; ptr; ptr = ptr->next) {
2328       if (!strcmp (ptr->fname, fname))
2329         break;                          /* This file was included before. */
2330     }
2331
2332     if (ptr == 0) {
2333       /* This is the first time for this file.  */
2334       /* Add it to list of files included.  */
2335
2336       ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
2337       ptr->next = all_include_files;
2338       all_include_files = ptr;
2339       ptr->fname = xstrdup (fname);
2340
2341       /* For -M, add this file to the dependencies.  */
2342       if (print_deps > (system_header_p || (system_include_depth > 0))) {
2343         deps_output (fname, strlen (fname));
2344         deps_output (" ", 0);
2345       }
2346     }
2347
2348     if (system_header_p)
2349       system_include_depth++;
2350
2351     /* Actually process the file.  */
2352     finclude (f, fname, op);
2353
2354     if (system_header_p)
2355       system_include_depth--;
2356
2357     close (f);
2358   }
2359 }
2360
2361 /* Process the contents of include file FNAME, already open on descriptor F,
2362    with output to OP.  */
2363
2364 void
2365 finclude (f, fname, op)
2366      int f;
2367      const char *fname;
2368      FILE_BUF *op;
2369 {
2370   int st_mode;
2371   long st_size;
2372   long i;
2373   FILE_BUF *fp;                 /* For input stack frame */
2374
2375   CHECK_DEPTH (return;);
2376
2377   if (file_size_and_mode (f, &st_mode, &st_size))
2378     goto nope;
2379
2380   fp = &instack[indepth + 1];
2381   memset (fp, 0, sizeof (FILE_BUF));
2382   fp->fname = fname;
2383   fp->length = 0;
2384   fp->lineno = 1;
2385   fp->if_stack = if_stack;
2386
2387   if (S_ISREG (st_mode)) {
2388     fp->buf = (U_CHAR *) xmalloc (st_size + 2);
2389     fp->bufp = fp->buf;
2390
2391     /* Read the file contents, knowing that st_size is an upper bound
2392        on the number of bytes we can read.  */
2393     while (st_size > 0) {
2394       i = read (f, fp->buf + fp->length, st_size);
2395       if (i <= 0) {
2396         if (i == 0) break;
2397         goto nope;
2398       }
2399       fp->length += i;
2400       st_size -= i;
2401     }
2402   }
2403   else {
2404     /* Cannot count its file size before reading.  */
2405
2406     U_CHAR *bufp;
2407     U_CHAR *basep;
2408     int bsize = 2000;
2409
2410     st_size = 0;
2411     basep = (U_CHAR *) xmalloc (bsize + 2);
2412     bufp = basep;
2413
2414     for (;;) {
2415       i = read (f, bufp, bsize - st_size);
2416       if (i < 0)
2417         goto nope;      /* error! */
2418       if (i == 0)
2419         break;  /* End of file */
2420       st_size += i;
2421       bufp += i;
2422       if (bsize == st_size) {   /* Buffer is full! */
2423           bsize *= 2;
2424           basep = (U_CHAR *) xrealloc (basep, bsize + 2);
2425           bufp = basep + st_size;       /* May have moved */
2426         }
2427     }
2428     fp->buf = basep;
2429     fp->bufp = fp->buf;
2430     fp->length = st_size;
2431   }
2432   close (f);
2433
2434   /* Make sure data ends with a newline.  And put a null after it.  */
2435
2436   if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
2437     fp->buf[fp->length++] = '\n';
2438   fp->buf[fp->length] = '\0';
2439
2440   indepth++;
2441   output_line_command (fp, op, 0, enter_file);
2442   rescan (op, 0);
2443   indepth--;
2444   output_line_command (&instack[indepth], op, 0, leave_file);
2445   free (fp->buf);
2446   return;
2447
2448 nope:
2449   perror_with_name (fname);
2450   close (f);
2451 }
2452 \f
2453
2454 /* Process a #define command.
2455 BUF points to the contents of the #define command, as a continguous string.
2456 LIMIT points to the first character past the end of the definition.
2457 KEYWORD is the keyword-table entry for #define.  */
2458
2459 void
2460 do_define (buf, limit, op, keyword)
2461      U_CHAR *buf, *limit;
2462      FILE_BUF *op ATTRIBUTE_UNUSED;
2463      struct directive *keyword ATTRIBUTE_UNUSED;
2464 {
2465   U_CHAR *bp;                   /* temp ptr into input buffer */
2466   U_CHAR *symname;              /* remember where symbol name starts */
2467   int sym_length;               /* and how long it is */
2468
2469   DEFINITION *defn;
2470   int arglengths = 0;           /* Accumulate lengths of arg names
2471                                    plus number of args.  */
2472   int hashcode;
2473
2474   bp = buf;
2475
2476   while (is_hor_space[*bp])
2477     bp++;
2478
2479   symname = bp;                 /* remember where it starts */
2480   while (is_idchar[*bp] && bp < limit) {
2481     bp++;
2482   }
2483   sym_length = bp - symname;
2484   if (sym_length == 0)
2485     error ("invalid macro name");
2486   else if (!is_idstart[*symname]) {
2487     U_CHAR *msg;                        /* what pain... */
2488     msg = (U_CHAR *) alloca (sym_length + 1);
2489     memcpy (msg, symname, sym_length);
2490     msg[sym_length] = 0;
2491     error ("invalid macro name `%s'", msg);
2492   } else {
2493     if (! strncmp ((char *)symname, "defined", 7) && sym_length == 7)
2494       error ("defining `defined' as a macro");
2495   }
2496
2497   /* lossage will occur if identifiers or control keywords are broken
2498      across lines using backslash.  This is not the right place to take
2499      care of that. */
2500
2501   if (*bp == '(') {
2502     struct arglist *arg_ptrs = NULL;
2503     int argno = 0;
2504
2505     bp++;                       /* skip '(' */
2506     SKIP_WHITE_SPACE (bp);
2507
2508     /* Loop over macro argument names.  */
2509     while (*bp != ')') {
2510       struct arglist *temp;
2511
2512       temp = (struct arglist *) alloca (sizeof (struct arglist));
2513       temp->name = bp;
2514       temp->next = arg_ptrs;
2515       temp->argno = argno++;
2516       arg_ptrs = temp;
2517
2518       if (!is_idstart[*bp])
2519         warning ("parameter name starts with a digit in #define");
2520
2521       /* Find the end of the arg name.  */
2522       while (is_idchar[*bp]) {
2523         bp++;
2524       }
2525       temp->length = bp - temp->name;
2526       arglengths += temp->length + 2;
2527       SKIP_WHITE_SPACE (bp);
2528       if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
2529         error ("badly punctuated parameter list in #define");
2530         return;
2531       }
2532       if (*bp == ',') {
2533         bp++;
2534         SKIP_WHITE_SPACE (bp);
2535       }
2536       if (bp >= limit) {
2537         error ("unterminated parameter list in #define");
2538         return;
2539       }
2540     }
2541
2542     ++bp;                       /* skip paren */
2543     while (is_hor_space[*bp])   /* and leading whitespace */
2544       ++bp;
2545     /* now everything from bp before limit is the definition. */
2546     defn = collect_expansion (bp, limit, argno, arg_ptrs);
2547
2548     /* Now set defn->argnames to the result of concatenating
2549        the argument names in reverse order
2550        with comma-space between them.  */
2551     defn->argnames = (U_CHAR *) xmalloc (arglengths + 1);
2552     {
2553       struct arglist *temp;
2554       int i = 0;
2555       for (temp = arg_ptrs; temp; temp = temp->next) {
2556         memcpy (&defn->argnames[i], temp->name, temp->length);
2557         i += temp->length;
2558         if (temp->next != 0) {
2559           defn->argnames[i++] = ',';
2560           defn->argnames[i++] = ' ';
2561         }
2562       }
2563       defn->argnames[i] = 0;
2564     }
2565   } else {
2566     /* simple expansion or empty definition; skip leading whitespace */
2567     while (is_hor_space[*bp])
2568       ++bp;
2569     /* now everything from bp before limit is the definition. */
2570     defn = collect_expansion (bp, limit, -1, 0);
2571     defn->argnames = (U_CHAR *) "";
2572   }
2573
2574   hashcode = hashf (symname, sym_length, HASHSIZE);
2575
2576   {
2577     HASHNODE *hp;
2578     if ((hp = lookup (symname, sym_length, hashcode)) == NULL)
2579       hp = install (symname, sym_length, T_MACRO, hashcode);
2580     else {
2581       if (hp->type != T_MACRO || compare_defs (defn, hp->value.defn))
2582         warning ("\"%.*s\" redefined", sym_length, symname);
2583
2584       /* Replace the old definition.  */
2585       hp->type = T_MACRO;
2586     }
2587
2588     hp->value.defn = defn;
2589   }
2590 }
2591
2592 /*
2593  * return zero if two DEFINITIONs are isomorphic
2594  */
2595 int
2596 compare_defs (d1, d2)
2597      DEFINITION *d1, *d2;
2598 {
2599   register struct reflist *a1, *a2;
2600   register U_CHAR *p1 = d1->expansion;
2601   register U_CHAR *p2 = d2->expansion;
2602   int first = 1;
2603
2604   if (d1->nargs != d2->nargs)
2605     return 1;
2606   if (strcmp ((char *)d1->argnames, (char *)d2->argnames))
2607     return 1;
2608   for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
2609        a1 = a1->next, a2 = a2->next) {
2610     if (!((a1->nchars == a2->nchars
2611            && ! strncmp ((char *)p1, (char *)p2, a1->nchars))
2612           || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
2613         || a1->argno != a2->argno
2614         || a1->stringify != a2->stringify
2615         || a1->raw_before != a2->raw_before
2616         || a1->raw_after != a2->raw_after)
2617       return 1;
2618     first = 0;
2619     p1 += a1->nchars;
2620     p2 += a2->nchars;
2621   }
2622   if (a1 != a2)
2623     return 1;
2624   if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
2625                      p2, d2->length - (p2 - d2->expansion), 1))
2626     return 1;
2627   return 0;
2628 }
2629
2630 /* Return 1 if two parts of two macro definitions are effectively different.
2631    One of the parts starts at BEG1 and has LEN1 chars;
2632    the other has LEN2 chars at BEG2.
2633    Any sequence of whitespace matches any other sequence of whitespace.
2634    FIRST means these parts are the first of a macro definition;
2635     so ignore leading whitespace entirely.
2636    LAST means these parts are the last of a macro definition;
2637     so ignore trailing whitespace entirely.  */
2638 int
2639 comp_def_part (first, beg1, len1, beg2, len2, last)
2640      int first;
2641      U_CHAR *beg1, *beg2;
2642      int len1, len2;
2643      int last;
2644 {
2645   register U_CHAR *end1 = beg1 + len1;
2646   register U_CHAR *end2 = beg2 + len2;
2647   if (first) {
2648     while (beg1 != end1 && is_space[*beg1]) beg1++;
2649     while (beg2 != end2 && is_space[*beg2]) beg2++;
2650   }
2651   if (last) {
2652     while (beg1 != end1 && is_space[end1[-1]]) end1--;
2653     while (beg2 != end2 && is_space[end2[-1]]) end2--;
2654   }
2655   while (beg1 != end1 && beg2 != end2) {
2656     if (is_space[*beg1] && is_space[*beg2]) {
2657       while (beg1 != end1 && is_space[*beg1]) beg1++;
2658       while (beg2 != end2 && is_space[*beg2]) beg2++;
2659     } else if (*beg1 == *beg2) {
2660       beg1++; beg2++;
2661     } else break;
2662   }
2663   return (beg1 != end1) || (beg2 != end2);
2664 }
2665
2666 /* Read a replacement list for a macro with parameters.
2667    Build the DEFINITION structure.
2668    Reads characters of text starting at BUF until LIMIT.
2669    ARGLIST specifies the formal parameters to look for
2670    in the text of the definition; NARGS is the number of args
2671    in that list, or -1 for a macro name that wants no argument list.
2672    MACRONAME is the macro name itself (so we can avoid recursive expansion)
2673    and NAMELEN is its length in characters.
2674
2675 Note that comments and backslash-newlines have already been deleted
2676 from the argument.  */
2677
2678 /* Leading and trailing Space, Tab, etc. are converted to markers
2679    Newline Space, Newline Tab, etc.
2680    Newline Space makes a space in the final output
2681    but is discarded if stringified.  (Newline Tab is similar but
2682    makes a Tab instead.)
2683
2684    If there is no trailing whitespace, a Newline Space is added at the end
2685    to prevent concatenation that would be contrary to the standard.  */
2686
2687 DEFINITION *
2688 collect_expansion (buf, end, nargs, arglist)
2689      U_CHAR *buf, *end;
2690      int nargs;
2691      struct arglist *arglist;
2692 {
2693   DEFINITION *defn;
2694   register U_CHAR *p, *limit, *lastp, *exp_p;
2695   struct reflist *endpat = NULL;
2696   /* Pointer to first nonspace after last ## seen.  */
2697   U_CHAR *concat = 0;
2698   /* Pointer to first nonspace after last single-# seen.  */
2699   U_CHAR *stringify = 0;
2700   int maxsize;
2701   int expected_delimiter = '\0';
2702
2703   /* Scan thru the replacement list, ignoring comments and quoted
2704      strings, picking up on the macro calls.  It does a linear search
2705      thru the arg list on every potential symbol.  Profiling might say
2706      that something smarter should happen. */
2707
2708   if (end < buf)
2709     abort ();
2710
2711   /* Find the beginning of the trailing whitespace.  */
2712   /* Find end of leading whitespace.  */
2713   limit = end;
2714   p = buf;
2715   while (p < limit && is_space[limit[-1]]) limit--;
2716   while (p < limit && is_space[*p]) p++;
2717
2718   /* Allocate space for the text in the macro definition.
2719      Leading and trailing whitespace chars need 2 bytes each.
2720      Each other input char may or may not need 1 byte,
2721      so this is an upper bound.
2722      The extra 2 are for invented trailing newline-marker and final null.  */
2723   maxsize = (sizeof (DEFINITION)
2724              + 2 * (end - limit) + 2 * (p - buf)
2725              + (limit - p) + 3);
2726   defn = (DEFINITION *) xcalloc (1, maxsize);
2727
2728   defn->nargs = nargs;
2729   exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
2730   lastp = exp_p;
2731
2732   p = buf;
2733
2734   /* Convert leading whitespace to Newline-markers.  */
2735   while (p < limit && is_space[*p]) {
2736     *exp_p++ = '\n';
2737     *exp_p++ = *p++;
2738   }
2739
2740   /* Process the main body of the definition.  */
2741   while (p < limit) {
2742     int skipped_arg = 0;
2743     register U_CHAR c = *p++;
2744
2745     *exp_p++ = c;
2746
2747     /* In -traditional mode, recognize arguments inside strings and
2748        and character constants, and ignore special properties of #.
2749        Arguments inside strings are considered "stringified", but no
2750        extra quote marks are supplied.  */
2751     switch (c) {
2752     case '\'':
2753     case '\"':
2754       if (expected_delimiter != '\0') {
2755         if (c == expected_delimiter)
2756           expected_delimiter = '\0';
2757       } else
2758         expected_delimiter = c;
2759       break;
2760
2761     case '\\':
2762       /* Backslash quotes delimiters and itself, but not macro args.  */
2763       if (expected_delimiter != 0 && p < limit
2764           && (*p == expected_delimiter || *p == '\\')) {
2765         *exp_p++ = *p++;
2766         continue;
2767       }
2768       break;
2769
2770     case '/':
2771       if (expected_delimiter != '\0') /* No comments inside strings.  */
2772         break;
2773       if (*p == '*') {
2774         /* If we find a comment that wasn't removed by handle_directive,
2775            this must be -traditional.  So replace the comment with
2776            nothing at all.  */
2777         exp_p--;
2778         p += 1;
2779         while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
2780           p++;
2781       }
2782       break;
2783     }
2784
2785     if (is_idchar[c] && nargs > 0) {
2786       U_CHAR *id_beg = p - 1;
2787       int id_len;
2788
2789       --exp_p;
2790       while (p != limit && is_idchar[*p]) p++;
2791       id_len = p - id_beg;
2792
2793       if (is_idstart[c]) {
2794         register struct arglist *arg;
2795
2796         for (arg = arglist; arg != NULL; arg = arg->next) {
2797           struct reflist *tpat;
2798
2799           if (arg->name[0] == c
2800               && arg->length == id_len
2801               && strncmp ((char *)arg->name, (char *)id_beg, id_len) == 0) {
2802             /* make a pat node for this arg and append it to the end of
2803                the pat list */
2804             tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
2805             tpat->next = NULL;
2806             tpat->raw_before = concat == id_beg;
2807             tpat->raw_after = 0;
2808             tpat->stringify = expected_delimiter != '\0';
2809
2810             if (endpat == NULL)
2811               defn->pattern = tpat;
2812             else
2813               endpat->next = tpat;
2814             endpat = tpat;
2815
2816             tpat->argno = arg->argno;
2817             tpat->nchars = exp_p - lastp;
2818             {
2819               register U_CHAR *p1 = p;
2820               SKIP_WHITE_SPACE (p1);
2821               if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
2822                 tpat->raw_after = 1;
2823             }
2824             lastp = exp_p;      /* place to start copying from next time */
2825             skipped_arg = 1;
2826             break;
2827           }
2828         }
2829       }
2830
2831       /* If this was not a macro arg, copy it into the expansion.  */
2832       if (! skipped_arg) {
2833         register U_CHAR *lim1 = p;
2834         p = id_beg;
2835         while (p != lim1)
2836           *exp_p++ = *p++;
2837         if (stringify == id_beg)
2838           error ("# operator should be followed by a macro argument name");
2839       }
2840     }
2841   }
2842
2843   if (limit < end) {
2844     /* Convert trailing whitespace to Newline-markers.  */
2845     while (limit < end && is_space[*limit]) {
2846       *exp_p++ = '\n';
2847       *exp_p++ = *limit++;
2848     }
2849   }
2850   *exp_p = '\0';
2851
2852   defn->length = exp_p - defn->expansion;
2853
2854   /* Crash now if we overrun the allocated size.  */
2855   if (defn->length + 1 > maxsize)
2856     abort ();
2857
2858   return defn;
2859 }
2860 \f
2861 /*
2862  * interpret #line command.  Remembers previously seen fnames
2863  * in its very own hash table.
2864  */
2865 #define FNAME_HASHSIZE 37
2866 void
2867 do_line (buf, limit, op, keyword)
2868      U_CHAR *buf, *limit;
2869      FILE_BUF *op;
2870      struct directive *keyword ATTRIBUTE_UNUSED;
2871 {
2872   register U_CHAR *bp;
2873   FILE_BUF *ip = &instack[indepth];
2874   FILE_BUF tem;
2875   int new_lineno;
2876   enum file_change_code file_change = same_file;
2877
2878   /* Expand any macros.  */
2879   tem = expand_to_temp_buffer (buf, limit, 0);
2880
2881   /* Point to macroexpanded line, which is null-terminated now.  */
2882   bp = tem.buf;
2883   SKIP_WHITE_SPACE (bp);
2884
2885   if (!isdigit (*bp)) {
2886     error ("invalid format #line command");
2887     return;
2888   }
2889
2890   /* The Newline at the end of this line remains to be processed.
2891      To put the next line at the specified line number,
2892      we must store a line number now that is one less.  */
2893   new_lineno = atoi ((char *)bp) - 1;
2894
2895   /* skip over the line number.  */
2896   while (isdigit (*bp))
2897     bp++;
2898
2899 #if 0 /* #line 10"foo.c" is supposed to be allowed.  */
2900   if (*bp && !is_space[*bp]) {
2901     error ("invalid format #line command");
2902     return;
2903   }
2904 #endif
2905
2906   SKIP_WHITE_SPACE (bp);
2907
2908   if (*bp == '\"') {
2909     static HASHNODE *fname_table[FNAME_HASHSIZE];
2910     HASHNODE *hp, **hash_bucket;
2911     U_CHAR *fname;
2912     int fname_length;
2913
2914     fname = ++bp;
2915
2916     while (*bp && *bp != '\"')
2917       bp++;
2918     if (*bp != '\"') {
2919       error ("invalid format #line command");
2920       return;
2921     }
2922
2923     fname_length = bp - fname;
2924
2925     bp++;
2926     SKIP_WHITE_SPACE (bp);
2927     if (*bp) {
2928       if (*bp == '1')
2929         file_change = enter_file;
2930       else if (*bp == '2')
2931         file_change = leave_file;
2932       else {
2933         error ("invalid format #line command");
2934         return;
2935       }
2936
2937       bp++;
2938       SKIP_WHITE_SPACE (bp);
2939       if (*bp) {
2940         error ("invalid format #line command");
2941         return;
2942       }
2943     }
2944
2945     hash_bucket =
2946       &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
2947     for (hp = *hash_bucket; hp != NULL; hp = hp->next)
2948       if (hp->length == fname_length &&
2949           strncmp (hp->value.cpval, (char *)fname, fname_length) == 0) {
2950         ip->fname = hp->value.cpval;
2951         break;
2952       }
2953     if (hp == 0) {
2954       char *q;
2955       /* Didn't find it; cons up a new one.  */
2956       hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
2957       hp->next = *hash_bucket;
2958       *hash_bucket = hp;
2959
2960       hp->length = fname_length;
2961       ip->fname = hp->value.cpval = q = ((char *) hp) + sizeof (HASHNODE);
2962       memcpy (q, fname, fname_length);
2963     }
2964   } else if (*bp) {
2965     error ("invalid format #line command");
2966     return;
2967   }
2968
2969   ip->lineno = new_lineno;
2970   output_line_command (ip, op, 0, file_change);
2971   check_expand (op, ip->length - (ip->bufp - ip->buf));
2972 }
2973
2974 /*
2975  * remove all definitions of symbol from symbol table.
2976  * according to un*x /lib/cpp, it is not an error to undef
2977  * something that has no definitions, so it isn't one here either.
2978  */
2979 void
2980 do_undef (buf, limit, op, keyword)
2981      U_CHAR *buf;
2982      U_CHAR *limit ATTRIBUTE_UNUSED;
2983      FILE_BUF *op ATTRIBUTE_UNUSED;
2984      struct directive *keyword ATTRIBUTE_UNUSED;
2985 {
2986   HASHNODE *hp;
2987
2988   SKIP_WHITE_SPACE (buf);
2989
2990   if (! strncmp ((char *)buf, "defined", 7) && ! is_idchar[buf[7]])
2991     warning ("undefining `defined'");
2992
2993   while ((hp = lookup (buf, -1, -1)) != NULL) {
2994     if (hp->type != T_MACRO)
2995       warning ("undefining `%s'", hp->name);
2996     delete_macro (hp);
2997   }
2998 }
2999
3000 /*
3001  * handle #if command by
3002  *   1) inserting special `defined' keyword into the hash table
3003  *      that gets turned into 0 or 1 by special_symbol (thus,
3004  *      if the luser has a symbol called `defined' already, it won't
3005  *      work inside the #if command)
3006  *   2) rescan the input into a temporary output buffer
3007  *   3) pass the output buffer to the yacc parser and collect a value
3008  *   4) clean up the mess left from steps 1 and 2.
3009  *   5) call conditional_skip to skip til the next #endif (etc.),
3010  *      or not, depending on the value from step 3.
3011  */
3012 void
3013 do_if (buf, limit, op, keyword)
3014      U_CHAR *buf, *limit;
3015      FILE_BUF *op ATTRIBUTE_UNUSED;
3016      struct directive *keyword ATTRIBUTE_UNUSED;
3017 {
3018   int value;
3019   FILE_BUF *ip = &instack[indepth];
3020
3021   value = eval_if_expression (buf, limit - buf);
3022   conditional_skip (ip, value == 0, T_IF);
3023 }
3024
3025 /*
3026  * handle a #elif directive by not changing  if_stack  either.
3027  * see the comment above do_else.
3028  */
3029 void
3030 do_elif (buf, limit, op, keyword)
3031      U_CHAR *buf, *limit;
3032      FILE_BUF *op;
3033      struct directive *keyword ATTRIBUTE_UNUSED;
3034 {
3035   int value;
3036   FILE_BUF *ip = &instack[indepth];
3037
3038   if (if_stack == instack[indepth].if_stack) {
3039     error ("#elif not within a conditional");
3040     return;
3041   } else {
3042     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3043       error ("#elif after #else");
3044       fprintf (stderr, " (matches line %d", if_stack->lineno);
3045       if (if_stack->fname != NULL && ip->fname != NULL &&
3046           strcmp (if_stack->fname, ip->fname) != 0)
3047         fprintf (stderr, ", file %s", if_stack->fname);
3048       fprintf (stderr, ")\n");
3049     }
3050     if_stack->type = T_ELIF;
3051   }
3052
3053   if (if_stack->if_succeeded)
3054     skip_if_group (ip, 0);
3055   else {
3056     value = eval_if_expression (buf, limit - buf);
3057     if (value == 0)
3058       skip_if_group (ip, 0);
3059     else {
3060       ++if_stack->if_succeeded; /* continue processing input */
3061       output_line_command (ip, op, 1, same_file);
3062     }
3063   }
3064 }
3065
3066 /*
3067  * evaluate a #if expression in BUF, of length LENGTH,
3068  * then parse the result as a C expression and return the value as an int.
3069  */
3070 int
3071 eval_if_expression (buf, length)
3072      U_CHAR *buf;
3073      int length;
3074 {
3075   FILE_BUF temp_obuf;
3076   HASHNODE *save_defined;
3077   int value;
3078
3079   save_defined = install (U"defined", -1, T_SPEC_DEFINED, -1);
3080   temp_obuf = expand_to_temp_buffer (buf, buf + length, 0);
3081   delete_macro (save_defined);  /* clean up special symbol */
3082
3083   value = parse_c_expression ((char *)temp_obuf.buf);
3084
3085   free (temp_obuf.buf);
3086
3087   return value;
3088 }
3089
3090 /*
3091  * routine to handle ifdef/ifndef.  Try to look up the symbol,
3092  * then do or don't skip to the #endif/#else/#elif depending
3093  * on what directive is actually being processed.
3094  */
3095 void
3096 do_xifdef (buf, limit, op, keyword)
3097      U_CHAR *buf, *limit;
3098      FILE_BUF *op ATTRIBUTE_UNUSED;
3099      struct directive *keyword;
3100 {
3101   int skip;
3102   FILE_BUF *ip = &instack[indepth];
3103   U_CHAR *end;
3104
3105   /* Discard leading and trailing whitespace.  */
3106   SKIP_WHITE_SPACE (buf);
3107   while (limit != buf && is_hor_space[limit[-1]]) limit--;
3108
3109   /* Find the end of the identifier at the beginning.  */
3110   for (end = buf; is_idchar[*end]; end++);
3111
3112   if (end == buf) {
3113     skip = (keyword->type == T_IFDEF);
3114   } else {
3115     skip = (lookup (buf, end-buf, -1) == NULL) ^ (keyword->type == T_IFNDEF);
3116   }
3117
3118   conditional_skip (ip, skip, T_IF);
3119 }
3120
3121 /*
3122  * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3123  */
3124 void
3125 conditional_skip (ip, skip, type)
3126      FILE_BUF *ip;
3127      int skip;
3128      enum node_type type;
3129 {
3130   IF_STACK_FRAME *temp;
3131
3132   temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3133   temp->fname = ip->fname;
3134   temp->lineno = ip->lineno;
3135   temp->next = if_stack;
3136   if_stack = temp;
3137
3138   if_stack->type = type;
3139
3140   if (skip != 0) {
3141     skip_if_group (ip, 0);
3142     return;
3143   } else {
3144     ++if_stack->if_succeeded;
3145     output_line_command (ip, &outbuf, 1, same_file);
3146   }
3147 }
3148
3149 /*
3150  * skip to #endif, #else, or #elif.  adjust line numbers, etc.
3151  * leaves input ptr at the sharp sign found.
3152  * If ANY is nonzero, return at next directive of any sort.
3153  */
3154 void
3155 skip_if_group (ip, any)
3156      FILE_BUF *ip;
3157      int any;
3158 {
3159   register U_CHAR *bp = ip->bufp, *cp;
3160   register U_CHAR *endb = ip->buf + ip->length;
3161   struct directive *kt;
3162   IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
3163   U_CHAR *beg_of_line = bp;
3164
3165   while (bp < endb) {
3166     switch (*bp++) {
3167     case '/':                   /* possible comment */
3168       if (*bp == '\\' && bp[1] == '\n')
3169         newline_fix (bp);
3170       if (*bp == '*') {
3171         ip->bufp = ++bp;
3172         bp = skip_to_end_of_comment (ip, &ip->lineno);
3173       }
3174       break;
3175     case '\"':
3176     case '\'':
3177       bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, 0, 0);
3178       break;
3179     case '\\':
3180       /* Char after backslash loses its special meaning.  */
3181       if (bp < endb) {
3182         if (*bp == '\n')
3183           ++ip->lineno;         /* But do update the line-count.  */
3184         bp++;
3185       }
3186       break;
3187     case '\n':
3188       ++ip->lineno;
3189       beg_of_line = bp;
3190       break;
3191     case '#':
3192       ip->bufp = bp - 1;
3193
3194       /* # keyword: a # must be first nonblank char on the line */
3195       if (beg_of_line == 0)
3196         break;
3197       /* Scan from start of line, skipping whitespace, comments
3198          and backslash-newlines, and see if we reach this #.
3199          If not, this # is not special.  */
3200       bp = beg_of_line;
3201       while (1) {
3202         if (is_hor_space[*bp])
3203           bp++;
3204         else if (*bp == '\\' && bp[1] == '\n')
3205           bp += 2;
3206         else if (*bp == '/' && bp[1] == '*') {
3207           bp += 2;
3208           while (!(*bp == '*' && bp[1] == '/')) {
3209             if (*bp == '\n')
3210               ip->lineno++;
3211             bp++;
3212           }
3213           bp += 2;
3214         }
3215         else break;
3216       }
3217       if (bp != ip->bufp) {
3218         bp = ip->bufp + 1;      /* Reset bp to after the #.  */
3219         break;
3220       }
3221
3222       bp = ip->bufp + 1;        /* Point after '#'.  */
3223
3224       /* Skip whitespace and \-newline.  */
3225       while (1) {
3226         if (is_hor_space[*bp])
3227           bp++;
3228         else if (*bp == '\\' && bp[1] == '\n')
3229           bp += 2;
3230         else if (*bp == '/' && bp[1] == '*') {
3231           bp += 2;
3232           while (!(*bp == '*' && bp[1] == '/'))
3233             bp++;
3234           bp += 2;
3235         }
3236         else break;
3237       }
3238
3239       cp = bp;
3240
3241       /* Now find end of directive name.
3242          If we encounter a backslash-newline, exchange it with any following
3243          symbol-constituents so that we end up with a contiguous name.  */
3244
3245       while (1) {
3246         if (is_idchar[*bp])
3247           bp++;
3248         else {
3249           if (*bp == '\\' && bp[1] == '\n')
3250             name_newline_fix (bp);
3251           if (is_idchar[*bp])
3252             bp++;
3253           else break;
3254         }
3255       }
3256
3257       for (kt = directive_table; kt->length >= 0; kt++) {
3258         IF_STACK_FRAME *temp;
3259         if (strncmp ((char *)cp, kt->name, kt->length) == 0
3260             && !is_idchar[cp[kt->length]]) {
3261
3262           /* If we are asked to return on next directive,
3263              do so now.  */
3264           if (any)
3265             return;
3266
3267           switch (kt->type) {
3268           case T_IF:
3269           case T_IFDEF:
3270           case T_IFNDEF:
3271             temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3272             temp->next = if_stack;
3273             if_stack = temp;
3274             temp->lineno = ip->lineno;
3275             temp->fname = ip->fname;
3276             temp->type = kt->type;
3277             break;
3278           case T_ELSE:
3279           case T_ENDIF:
3280           case T_ELIF:
3281             if (if_stack == instack[indepth].if_stack) {
3282               error ("#%s not within a conditional", kt->name);
3283               break;
3284             }
3285             else if (if_stack == save_if_stack)
3286               return;           /* found what we came for */
3287
3288             if (kt->type != T_ENDIF) {
3289               if (if_stack->type == T_ELSE)
3290                 error ("#else or #elif after #else");
3291               if_stack->type = kt->type;
3292               break;
3293             }
3294
3295             temp = if_stack;
3296             if_stack = if_stack->next;
3297             free (temp);
3298             break;
3299
3300           default:
3301             /* Anything else is ignored.  */
3302             break;
3303           }
3304           break;
3305         }
3306       }
3307     }
3308   }
3309   ip->bufp = bp;
3310   /* after this returns, rescan will exit because ip->bufp
3311      now points to the end of the buffer.
3312      rescan is responsible for the error message also.  */
3313 }
3314
3315 /*
3316  * handle a #else directive.  Do this by just continuing processing
3317  * without changing  if_stack ;  this is so that the error message
3318  * for missing #endif's etc. will point to the original #if.  It
3319  * is possible that something different would be better.
3320  */
3321 void
3322 do_else (buf, limit, op, keyword)
3323      U_CHAR *buf ATTRIBUTE_UNUSED;
3324      U_CHAR *limit ATTRIBUTE_UNUSED;
3325      FILE_BUF *op;
3326      struct directive *keyword ATTRIBUTE_UNUSED;
3327 {
3328   FILE_BUF *ip = &instack[indepth];
3329
3330   if (if_stack == instack[indepth].if_stack) {
3331     error ("#else not within a conditional");
3332     return;
3333   } else {
3334     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3335       error ("#else after #else");
3336       fprintf (stderr, " (matches line %d", if_stack->lineno);
3337       if (strcmp (if_stack->fname, ip->fname) != 0)
3338         fprintf (stderr, ", file %s", if_stack->fname);
3339       fprintf (stderr, ")\n");
3340     }
3341     if_stack->type = T_ELSE;
3342   }
3343
3344   if (if_stack->if_succeeded)
3345     skip_if_group (ip, 0);
3346   else {
3347     ++if_stack->if_succeeded;   /* continue processing input */
3348     output_line_command (ip, op, 1, same_file);
3349   }
3350 }
3351
3352 /*
3353  * unstack after #endif command
3354  */
3355 void
3356 do_endif (buf, limit, op, keyword)
3357      U_CHAR *buf ATTRIBUTE_UNUSED;
3358      U_CHAR *limit ATTRIBUTE_UNUSED;
3359      FILE_BUF *op;
3360      struct directive *keyword ATTRIBUTE_UNUSED;
3361 {
3362   if (if_stack == instack[indepth].if_stack)
3363     error ("unbalanced #endif");
3364   else {
3365     IF_STACK_FRAME *temp = if_stack;
3366     if_stack = if_stack->next;
3367     free (temp);
3368     output_line_command (&instack[indepth], op, 1, same_file);
3369   }
3370 }
3371
3372 /*
3373  * Skip a comment, assuming the input ptr immediately follows the
3374  * initial slash-star.  Bump line counter as necessary.
3375  * (The canonical line counter is &ip->lineno).
3376  * Don't use this routine (or the next one) if bumping the line
3377  * counter is not sufficient to deal with newlines in the string.
3378  */
3379 U_CHAR *
3380 skip_to_end_of_comment (ip, line_counter)
3381      register FILE_BUF *ip;
3382      int *line_counter;         /* place to remember newlines, or NULL */
3383 {
3384   register U_CHAR *limit = ip->buf + ip->length;
3385   register U_CHAR *bp = ip->bufp;
3386   FILE_BUF *op = &outbuf;       /* JF */
3387   int output = put_out_comments && !line_counter;
3388
3389         /* JF this line_counter stuff is a crock to make sure the
3390            comment is only put out once, no matter how many times
3391            the comment is skipped.  It almost works */
3392   if (output) {
3393     *op->bufp++ = '/';
3394     *op->bufp++ = '*';
3395   }
3396   while (bp < limit) {
3397     if (output)
3398       *op->bufp++ = *bp;
3399     switch (*bp++) {
3400     case '/':
3401       if (warn_comments && bp < limit && *bp == '*')
3402         warning("`/*' within comment");
3403       break;
3404     case '\n':
3405       if (line_counter != NULL)
3406         ++*line_counter;
3407       if (output)
3408         ++op->lineno;
3409       break;
3410     case '*':
3411       if (*bp == '\\' && bp[1] == '\n')
3412         newline_fix (bp);
3413       if (*bp == '/') {
3414         if (output)
3415           *op->bufp++ = '/';
3416         ip->bufp = ++bp;
3417         return bp;
3418       }
3419       break;
3420     }
3421   }
3422   ip->bufp = bp;
3423   return bp;
3424 }
3425
3426 /*
3427  * Skip over a quoted string.  BP points to the opening quote.
3428  * Returns a pointer after the closing quote.  Don't go past LIMIT.
3429  * START_LINE is the line number of the starting point (but it need
3430  * not be valid if the starting point is inside a macro expansion).
3431  *
3432  * The input stack state is not changed.
3433  *
3434  * If COUNT_NEWLINES is nonzero, it points to an int to increment
3435  * for each newline passed.
3436  *
3437  * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
3438  * if we pass a backslash-newline.
3439  *
3440  * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
3441  */
3442 U_CHAR *
3443 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
3444      register U_CHAR *bp;
3445      register U_CHAR *limit;
3446      int start_line;
3447      int *count_newlines;
3448      int *backslash_newlines_p;
3449      int *eofp;
3450 {
3451   register U_CHAR c, match;
3452
3453   match = *bp++;
3454   while (1) {
3455     if (bp >= limit) {
3456       error_with_line (line_for_error (start_line),
3457                        "unterminated string or character constant");
3458       if (eofp)
3459         *eofp = 1;
3460       break;
3461     }
3462     c = *bp++;
3463     if (c == '\\') {
3464       while (*bp == '\\' && bp[1] == '\n') {
3465         if (backslash_newlines_p)
3466           *backslash_newlines_p = 1;
3467         if (count_newlines)
3468           ++*count_newlines;
3469         bp += 2;
3470       }
3471       if (*bp == '\n' && count_newlines) {
3472         if (backslash_newlines_p)
3473           *backslash_newlines_p = 1;
3474         ++*count_newlines;
3475       }
3476       bp++;
3477     } else if (c == '\n') {
3478       /* Unterminated strings and character constants are 'legal'.  */
3479       bp--;     /* Don't consume the newline. */
3480       if (eofp)
3481         *eofp = 1;
3482       break;
3483     } else if (c == match)
3484       break;
3485   }
3486   return bp;
3487 }
3488 \f
3489 /*
3490  * write out a #line command, for instance, after an #include file.
3491  * If CONDITIONAL is nonzero, we can omit the #line if it would
3492  * appear to be a no-op, and we can output a few newlines instead
3493  * if we want to increase the line number by a small amount.
3494  * FILE_CHANGE says whether we are entering a file, leaving, or neither.
3495  */
3496
3497 void
3498 output_line_command (ip, op, conditional, file_change)
3499      FILE_BUF *ip, *op;
3500      int conditional;
3501      enum file_change_code file_change;
3502 {
3503   int len;
3504   char line_cmd_buf[500];
3505
3506   if (no_line_commands
3507       || ip->fname == NULL
3508       || no_output) {
3509     op->lineno = ip->lineno;
3510     return;
3511   }
3512
3513   if (conditional) {
3514     if (ip->lineno == op->lineno)
3515       return;
3516
3517     /* If the inherited line number is a little too small,
3518        output some newlines instead of a #line command.  */
3519     if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
3520       check_expand (op, 10);
3521       while (ip->lineno > op->lineno) {
3522         *op->bufp++ = '\n';
3523         op->lineno++;
3524       }
3525       return;
3526     }
3527   }
3528
3529   sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, ip->fname);
3530   if (file_change != same_file)
3531     strcat (line_cmd_buf, file_change == enter_file ? " 1" : " 2");
3532   len = strlen (line_cmd_buf);
3533   line_cmd_buf[len++] = '\n';
3534   check_expand (op, len + 1);
3535   if (op->bufp > op->buf && op->bufp[-1] != '\n')
3536     *op->bufp++ = '\n';
3537   memcpy (op->bufp, line_cmd_buf, len);
3538   op->bufp += len;
3539   op->lineno = ip->lineno;
3540 }
3541 \f
3542
3543 /* Expand a macro call.
3544    HP points to the symbol that is the macro being called.
3545    Put the result of expansion onto the input stack
3546    so that subsequent input by our caller will use it.
3547
3548    If macro wants arguments, caller has already verified that
3549    an argument list follows; arguments come from the input stack.  */
3550
3551 void
3552 macroexpand (hp, op)
3553      HASHNODE *hp;
3554      FILE_BUF *op;
3555 {
3556   int nargs;
3557   DEFINITION *defn = hp->value.defn;
3558   register U_CHAR *xbuf;
3559   int xbuf_len;
3560   int start_line = instack[indepth].lineno;
3561
3562   CHECK_DEPTH (return;);
3563
3564   /* it might not actually be a macro.  */
3565   if (hp->type != T_MACRO) {
3566     special_symbol (hp, op);
3567     return;
3568   }
3569
3570   nargs = defn->nargs;
3571
3572   if (nargs >= 0) {
3573     register int i;
3574     struct argdata *args;
3575     const char *parse_error = 0;
3576
3577     args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
3578
3579     for (i = 0; i < nargs; i++) {
3580       args[i].raw = args[i].expanded = (U_CHAR *) "";
3581       args[i].raw_length = args[i].expand_length
3582         = args[i].stringified_length = 0;
3583       args[i].free1 = args[i].free2 = 0;
3584     }
3585
3586     /* Parse all the macro args that are supplied.  I counts them.
3587        The first NARGS args are stored in ARGS.
3588        The rest are discarded.  */
3589     i = 0;
3590     do {
3591       /* Discard the open-parenthesis or comma before the next arg.  */
3592       ++instack[indepth].bufp;
3593       parse_error
3594         = macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0);
3595       if (parse_error)
3596         {
3597           error_with_line (line_for_error (start_line), parse_error);
3598           break;
3599         }
3600       i++;
3601     } while (*instack[indepth].bufp != ')');
3602
3603     /* If we got one arg but it was just whitespace, call that 0 args.  */
3604     if (i == 1) {
3605       register U_CHAR *bp = args[0].raw;
3606       register U_CHAR *lim = bp + args[0].raw_length;
3607       while (bp != lim && is_space[*bp]) bp++;
3608       if (bp == lim)
3609         i = 0;
3610     }
3611
3612     if (nargs == 0 && i > 0)
3613       error ("arguments given to macro `%s'", hp->name);
3614     else if (i < nargs) {
3615       /* traditional C allows foo() if foo wants one argument.  */
3616       if (nargs == 1 && i == 0)
3617         ;
3618       else if (i == 0)
3619         error ("no args to macro `%s'", hp->name);
3620       else if (i == 1)
3621         error ("only 1 arg to macro `%s'", hp->name);
3622       else
3623         error ("only %d args to macro `%s'", i, hp->name);
3624     } else if (i > nargs)
3625       error ("too many (%d) args to macro `%s'", i, hp->name);
3626
3627     /* Swallow the closeparen.  */
3628     ++instack[indepth].bufp;
3629
3630     /* If macro wants zero args, we parsed the arglist for checking only.
3631        Read directly from the macro definition.  */
3632     if (nargs == 0) {
3633       xbuf = defn->expansion;
3634       xbuf_len = defn->length;
3635     } else {
3636       register U_CHAR *exp = defn->expansion;
3637       register int offset;      /* offset in expansion,
3638                                    copied a piece at a time */
3639       register int totlen;      /* total amount of exp buffer filled so far */
3640
3641       register struct reflist *ap;
3642
3643       /* Macro really takes args.  Compute the expansion of this call.  */
3644
3645       /* Compute length in characters of the macro's expansion.  */
3646       xbuf_len = defn->length;
3647       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3648         if (ap->stringify)
3649           xbuf_len += args[ap->argno].stringified_length;
3650         else
3651           xbuf_len += args[ap->argno].raw_length;
3652       }
3653
3654       xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
3655
3656       /* Generate in XBUF the complete expansion
3657          with arguments substituted in.
3658          TOTLEN is the total size generated so far.
3659          OFFSET is the index in the definition
3660          of where we are copying from.  */
3661       offset = totlen = 0;
3662       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3663         register struct argdata *arg = &args[ap->argno];
3664
3665         for (i = 0; i < ap->nchars; i++)
3666           xbuf[totlen++] = exp[offset++];
3667
3668         if (ap->stringify != 0) {
3669           int arglen = arg->raw_length;
3670           int escaped = 0;
3671           int in_string = 0;
3672           int c;
3673           i = 0;
3674           while (i < arglen
3675                  && (c = arg->raw[i], is_space[c]))
3676             i++;
3677           while (i < arglen
3678                  && (c = arg->raw[arglen - 1], is_space[c]))
3679             arglen--;
3680           for (; i < arglen; i++) {
3681             c = arg->raw[i];
3682
3683             /* Special markers Newline Space
3684                generate nothing for a stringified argument.  */
3685             if (c == '\n' && arg->raw[i+1] != '\n') {
3686               i++;
3687               continue;
3688             }
3689
3690             /* Internal sequences of whitespace are replaced by one space
3691                except within an string or char token.  */
3692             if (! in_string
3693                 && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) {
3694               while (1) {
3695                 /* Note that Newline Space does occur within whitespace
3696                    sequences; consider it part of the sequence.  */
3697                 if (c == '\n' && is_space[arg->raw[i+1]])
3698                   i += 2;
3699                 else if (c != '\n' && is_space[c])
3700                   i++;
3701                 else break;
3702                 c = arg->raw[i];
3703               }
3704               i--;
3705               c = ' ';
3706             }
3707
3708             if (escaped)
3709               escaped = 0;
3710             else {
3711               if (c == '\\')
3712                 escaped = 1;
3713               if (in_string) {
3714                 if (c == in_string)
3715                   in_string = 0;
3716               } else if (c == '\"' || c == '\'')
3717                 in_string = c;
3718             }
3719
3720             /* Escape these chars */
3721             if (c == '\"' || (in_string && c == '\\'))
3722               xbuf[totlen++] = '\\';
3723             if (isprint (c))
3724               xbuf[totlen++] = c;
3725             else {
3726               sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
3727               totlen += 4;
3728             }
3729           }
3730         } else {
3731           U_CHAR *p1 = arg->raw;
3732           U_CHAR *l1 = p1 + arg->raw_length;
3733
3734           if (ap->raw_before) {
3735             while (p1 != l1 && is_space[*p1]) p1++;
3736             while (p1 != l1 && is_idchar[*p1])
3737               xbuf[totlen++] = *p1++;
3738             /* Delete any no-reexpansion marker that follows
3739                an identifier at the beginning of the argument
3740                if the argument is concatenated with what precedes it.  */
3741             if (p1[0] == '\n' && p1[1] == '-')
3742               p1 += 2;
3743           }
3744           if (ap->raw_after) {
3745             /* Arg is concatenated after: delete trailing whitespace,
3746                whitespace markers, and no-reexpansion markers.  */
3747             while (p1 != l1) {
3748               if (is_space[l1[-1]]) l1--;
3749               else if (l1[-1] == '-') {
3750                 U_CHAR *p2 = l1 - 1;
3751                 /* If a `-' is preceded by an odd number of newlines then it
3752                    and the last newline are a no-reexpansion marker.  */
3753                 while (p2 != p1 && p2[-1] == '\n') p2--;
3754                 if ((l1 - 1 - p2) & 1) {
3755                   l1 -= 2;
3756                 }
3757                 else break;
3758               }
3759               else break;
3760             }
3761           }
3762           memmove (xbuf + totlen, p1, l1 - p1);
3763           totlen += l1 - p1;
3764         }
3765
3766         if (totlen > xbuf_len)
3767           abort ();
3768       }
3769
3770       /* if there is anything left of the definition
3771          after handling the arg list, copy that in too. */
3772
3773       for (i = offset; i < defn->length; i++)
3774         xbuf[totlen++] = exp[i];
3775
3776       xbuf[totlen] = 0;
3777       xbuf_len = totlen;
3778
3779       for (i = 0; i < nargs; i++) {
3780         if (args[i].free1 != 0)
3781           free (args[i].free1);
3782         if (args[i].free2 != 0)
3783           free (args[i].free2);
3784       }
3785     }
3786   } else {
3787     xbuf = defn->expansion;
3788     xbuf_len = defn->length;
3789   }
3790
3791   /* Now put the expansion on the input stack
3792      so our caller will commence reading from it.  */
3793   {
3794     register FILE_BUF *ip2;
3795
3796     ip2 = &instack[++indepth];
3797
3798     ip2->fname = 0;
3799     ip2->lineno = 0;
3800     ip2->buf = xbuf;
3801     ip2->length = xbuf_len;
3802     ip2->bufp = xbuf;
3803     ip2->free_ptr = (nargs > 0) ? xbuf : 0;
3804     ip2->macro = hp;
3805     ip2->if_stack = if_stack;
3806   }
3807 }
3808 \f
3809 /*
3810  * Parse a macro argument and store the info on it into *ARGPTR.
3811  * Return nonzero to indicate a syntax error.
3812  */
3813
3814 const char *
3815 macarg (argptr)
3816      register struct argdata *argptr;
3817 {
3818   FILE_BUF *ip = &instack[indepth];
3819   int paren = 0;
3820   int newlines = 0;
3821   int comments = 0;
3822
3823   /* Try to parse as much of the argument as exists at this
3824      input stack level.  */
3825   U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
3826                         &paren, &newlines, &comments);
3827
3828   /* If we find the end of the argument at this level,
3829      set up *ARGPTR to point at it in the input stack.  */
3830   if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
3831       && bp != ip->buf + ip->length) {
3832     if (argptr != 0) {
3833       argptr->raw = ip->bufp;
3834       argptr->raw_length = bp - ip->bufp;
3835     }
3836     ip->bufp = bp;
3837   } else {
3838     /* This input stack level ends before the macro argument does.
3839        We must pop levels and keep parsing.
3840        Therefore, we must allocate a temporary buffer and copy
3841        the macro argument into it.  */
3842     int bufsize = bp - ip->bufp;
3843     int extra = newlines;
3844     U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
3845     int final_start = 0;
3846
3847     memcpy (buffer, ip->bufp, bufsize);
3848     ip->bufp = bp;
3849     ip->lineno += newlines;
3850
3851     while (bp == ip->buf + ip->length) {
3852       if (instack[indepth].macro == 0) {
3853         free (buffer);
3854         return "unterminated macro call";
3855       }
3856       ip->macro->type = T_MACRO;
3857       if (ip->free_ptr)
3858         free (ip->free_ptr);
3859       ip = &instack[--indepth];
3860       newlines = 0;
3861       comments = 0;
3862       bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
3863                     &newlines, &comments);
3864       final_start = bufsize;
3865       bufsize += bp - ip->bufp;
3866       extra += newlines;
3867       buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
3868       memcpy (buffer + bufsize - (bp - ip->bufp), ip->bufp, bp - ip->bufp);
3869       ip->bufp = bp;
3870       ip->lineno += newlines;
3871     }
3872
3873     /* Now, if arg is actually wanted, record its raw form,
3874        discarding comments and duplicating newlines in whatever
3875        part of it did not come from a macro expansion.
3876        EXTRA space has been preallocated for duplicating the newlines.
3877        FINAL_START is the index of the start of that part.  */
3878     if (argptr != 0) {
3879       argptr->raw = buffer;
3880       argptr->raw_length = bufsize;
3881       argptr->free1 = buffer;
3882       argptr->newlines = newlines;
3883       argptr->comments = comments;
3884       if ((newlines || comments) && ip->fname != 0)
3885         argptr->raw_length
3886           = final_start +
3887             discard_comments (argptr->raw + final_start,
3888                               argptr->raw_length - final_start,
3889                               newlines);
3890       argptr->raw[argptr->raw_length] = 0;
3891       if (argptr->raw_length > bufsize + extra)
3892         abort ();
3893     }
3894   }
3895
3896   /* If we are not discarding this argument,
3897      macroexpand it and compute its length as stringified.
3898      All this info goes into *ARGPTR.  */
3899
3900   if (argptr != 0) {
3901     FILE_BUF obuf;
3902     register U_CHAR *buf, *lim;
3903     register int totlen;
3904
3905     obuf = expand_to_temp_buffer (argptr->raw,
3906                                   argptr->raw + argptr->raw_length,
3907                                   1);
3908
3909     argptr->expanded = obuf.buf;
3910     argptr->expand_length = obuf.length;
3911     argptr->free2 = obuf.buf;
3912
3913     buf = argptr->raw;
3914     lim = buf + argptr->raw_length;
3915
3916     totlen = 0;
3917     while (buf != lim) {
3918       register U_CHAR c = *buf++;
3919       totlen++;
3920       /* Internal sequences of whitespace are replaced by one space
3921          in most cases, but not always.  So count all the whitespace
3922          in case we need to keep it all.  */
3923       if (c == '\"' || c == '\\') /* escape these chars */
3924         totlen++;
3925       else if (!isprint (c))
3926         totlen += 3;
3927     }
3928     argptr->stringified_length = totlen;
3929   }
3930   return 0;
3931 }
3932
3933 /* Scan text from START (inclusive) up to LIMIT (exclusive),
3934    counting parens in *DEPTHPTR,
3935    and return if reach LIMIT
3936    or before a `)' that would make *DEPTHPTR negative
3937    or before a comma when *DEPTHPTR is zero.
3938    Single and double quotes are matched and termination
3939    is inhibited within them.  Comments also inhibit it.
3940    Value returned is pointer to stopping place.
3941
3942    Increment *NEWLINES each time a newline is passed.
3943    Set *COMMENTS to 1 if a comment is seen.  */
3944
3945 U_CHAR *
3946 macarg1 (start, limit, depthptr, newlines, comments)
3947      U_CHAR *start;
3948      register U_CHAR *limit;
3949      int *depthptr, *newlines, *comments;
3950 {
3951   register U_CHAR *bp = start;
3952
3953   while (bp < limit) {
3954     switch (*bp) {
3955     case '(':
3956       (*depthptr)++;
3957       break;
3958     case ')':
3959       if (--(*depthptr) < 0)
3960         return bp;
3961       break;
3962     case '\\':
3963       /* Traditionally, backslash makes following char not special.  */
3964       if (bp + 1 < limit)
3965         {
3966           bp++;
3967           /* But count source lines anyway.  */
3968           if (*bp == '\n')
3969             ++*newlines;
3970         }
3971       break;
3972     case '\n':
3973       ++*newlines;
3974       break;
3975     case '/':
3976       if (bp[1] == '\\' && bp[2] == '\n')
3977         newline_fix (bp + 1);
3978       if (bp[1] != '*' || bp + 1 >= limit)
3979         break;
3980       *comments = 1;
3981       bp += 2;
3982       while (bp + 1 < limit) {
3983         if (bp[0] == '*'
3984             && bp[1] == '\\' && bp[2] == '\n')
3985           newline_fix (bp + 1);
3986         if (bp[0] == '*' && bp[1] == '/')
3987           break;
3988         if (*bp == '\n') ++*newlines;
3989         bp++;
3990       }
3991       bp += 1;
3992       break;
3993     case '\'':
3994     case '\"':
3995       {
3996         int quotec;
3997         for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
3998           if (*bp == '\\') {
3999             bp++;
4000             if (*bp == '\n')
4001               ++*newlines;
4002             while (*bp == '\\' && bp[1] == '\n') {
4003               bp += 2;
4004             }
4005           } else if (*bp == '\n') {
4006             ++*newlines;
4007             if (quotec == '\'')
4008               break;
4009           }
4010         }
4011       }
4012       break;
4013     case ',':
4014       if ((*depthptr) == 0)
4015         return bp;
4016       break;
4017     }
4018     bp++;
4019   }
4020
4021   return bp;
4022 }
4023
4024 /* Discard comments and duplicate newlines
4025    in the string of length LENGTH at START,
4026    except inside of string constants.
4027    The string is copied into itself with its beginning staying fixed.
4028
4029    NEWLINES is the number of newlines that must be duplicated.
4030    We assume that that much extra space is available past the end
4031    of the string.  */
4032
4033 int
4034 discard_comments (start, length, newlines)
4035      U_CHAR *start;
4036      int length;
4037      int newlines;
4038 {
4039   register U_CHAR *ibp;
4040   register U_CHAR *obp;
4041   register U_CHAR *limit;
4042   register int c;
4043
4044   /* If we have newlines to duplicate, copy everything
4045      that many characters up.  Then, in the second part,
4046      we will have room to insert the newlines
4047      while copying down.
4048      NEWLINES may actually be too large, because it counts
4049      newlines in string constants, and we don't duplicate those.
4050      But that does no harm.  */
4051   if (newlines > 0) {
4052     ibp = start + length;
4053     obp = ibp + newlines;
4054     limit = start;
4055     while (limit != ibp)
4056       *--obp = *--ibp;
4057   }
4058
4059   ibp = start + newlines;
4060   limit = start + length + newlines;
4061   obp = start;
4062
4063   while (ibp < limit) {
4064     *obp++ = c = *ibp++;
4065     switch (c) {
4066     case '\n':
4067       /* Duplicate the newline.  */
4068       *obp++ = '\n';
4069       break;
4070
4071     case '\\':
4072       if (*ibp == '\n') {
4073         obp--;
4074         ibp++;
4075       }
4076       break;
4077
4078     case '/':
4079       if (*ibp == '\\' && ibp[1] == '\n')
4080         newline_fix (ibp);
4081       /* Delete any comment.  */
4082       if (ibp[0] != '*' || ibp + 1 >= limit)
4083         break;
4084       obp--;
4085       ibp++;
4086       while (ibp + 1 < limit) {
4087         if (ibp[0] == '*'
4088             && ibp[1] == '\\' && ibp[2] == '\n')
4089           newline_fix (ibp + 1);
4090         if (ibp[0] == '*' && ibp[1] == '/')
4091           break;
4092         ibp++;
4093       }
4094       ibp += 2;
4095       break;
4096
4097     case '\'':
4098     case '\"':
4099       /* Notice and skip strings, so that we don't
4100          think that comments start inside them,
4101          and so we don't duplicate newlines in them.  */
4102       {
4103         int quotec = c;
4104         while (ibp < limit) {
4105           *obp++ = c = *ibp++;
4106           if (c == quotec)
4107             break;
4108           if (c == '\n' && quotec == '\'')
4109             break;
4110           if (c == '\\' && ibp < limit) {
4111             while (*ibp == '\\' && ibp[1] == '\n')
4112               ibp += 2;
4113             *obp++ = *ibp++;
4114           }
4115         }
4116       }
4117       break;
4118     }
4119   }
4120
4121   return obp - start;
4122 }
4123 \f
4124
4125 /* Core error handling routine.  */
4126 void
4127 v_message (mtype, line, msgid, ap)
4128      enum msgtype mtype;
4129      int line;
4130      const char *msgid;
4131      va_list ap;
4132 {
4133   const char *fname = 0;
4134   int i;
4135
4136   if (mtype == WARNING && inhibit_warnings)
4137     return;
4138
4139   for (i = indepth; i >= 0; i--)
4140     if (instack[i].fname != NULL) {
4141       if (line == 0)
4142         line = instack[i].lineno;
4143       fname = instack[i].fname;
4144       break;
4145     }
4146
4147   if (fname)
4148     fprintf (stderr, "%s:%d: ", fname, line);
4149   else
4150     fprintf (stderr, "%s: ", progname);
4151
4152   if (mtype == WARNING)
4153     fputs ("warning: ", stderr);
4154
4155   vfprintf (stderr, msgid, ap);
4156   putc ('\n', stderr);
4157
4158   if (mtype == ERROR)
4159     errors++;
4160 }
4161
4162 /*
4163  * error - print error message and increment count of errors.
4164  */
4165 void
4166 error VPARAMS ((const char *msgid, ...))
4167 {
4168 #ifndef ANSI_PROTOTYPES
4169   const char *msgid;
4170 #endif
4171   va_list ap;
4172
4173   VA_START(ap, msgid);
4174
4175 #ifndef ANSI_PROTOTYPES
4176   msgid = va_arg (ap, const char *);
4177 #endif
4178
4179   v_message (ERROR, 0, msgid, ap);
4180 }
4181
4182 void
4183 error_with_line VPARAMS ((int line, const char *msgid, ...))
4184 {
4185 #ifndef ANSI_PROTOTYPES
4186   int line;
4187   const char *msgid;
4188 #endif
4189   va_list ap;
4190
4191   VA_START(ap, msgid);
4192
4193 #ifndef ANSI_PROTOTYPES
4194   line = va_arg (ap, int);
4195   msgid = va_arg (ap, const char *);
4196 #endif
4197
4198   v_message (ERROR, line, msgid, ap);
4199 }
4200
4201 /* Error including a message from `errno'.  */
4202 void
4203 error_from_errno (name)
4204      const char *name;
4205 {
4206   error ("%s: %s", name, strerror (errno));
4207 }
4208
4209 /* Print error message but don't count it.  */
4210 void
4211 warning VPARAMS ((const char *msgid, ...))
4212 {
4213 #ifndef ANSI_PROTOTYPES
4214   const char *msgid;
4215 #endif
4216   va_list ap;
4217
4218   VA_START(ap, msgid);
4219
4220 #ifndef ANSI_PROTOTYPES
4221   msgid = va_arg (ap, const char *);
4222 #endif
4223
4224   v_message (WARNING, 0, msgid, ap);
4225 }
4226
4227 void
4228 fatal VPARAMS ((const char *msgid, ...))
4229 {
4230 #ifndef ANSI_PROTOTYPES
4231   const char *msgid;
4232 #endif
4233   va_list ap;
4234
4235   VA_START(ap, msgid);
4236
4237 #ifndef ANSI_PROTOTYPES
4238   msgid = va_arg (ap, const char *);
4239 #endif
4240
4241   v_message (FATAL, 0, msgid, ap);
4242   exit (FATAL_EXIT_CODE);
4243 }
4244
4245 /* More 'friendly' abort that prints the location at which we died.  */
4246 void
4247 fancy_abort (line, func)
4248      int line;
4249      const char *func;
4250 {
4251   fatal ("Internal error in %s, at tradcpp.c:%d\n\
4252 Please submit a full bug report.\n\
4253 See %s for instructions.", func, line, GCCBUGURL);
4254 }
4255
4256 void
4257 perror_with_name (name)
4258      const char *name;
4259 {
4260   fprintf (stderr, "%s: %s: %s\n", progname, name, strerror (errno));
4261   errors++;
4262 }
4263
4264 void
4265 pfatal_with_name (name)
4266      const char *name;
4267 {
4268   perror_with_name (name);
4269   exit (FATAL_EXIT_CODE);
4270 }
4271
4272 /* Return the line at which an error occurred.
4273    The error is not necessarily associated with the current spot
4274    in the input stack, so LINE says where.  LINE will have been
4275    copied from ip->lineno for the current input level.
4276    If the current level is for a file, we return LINE.
4277    But if the current level is not for a file, LINE is meaningless.
4278    In that case, we return the lineno of the innermost file.  */
4279 int
4280 line_for_error (line)
4281      int line;
4282 {
4283   int i;
4284   int line1 = line;
4285
4286   for (i = indepth; i >= 0; ) {
4287     if (instack[i].fname != 0)
4288       return line1;
4289     i--;
4290     if (i < 0)
4291       return 0;
4292     line1 = instack[i].lineno;
4293   }
4294   return 0;
4295 }
4296
4297 /*
4298  * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4299  *
4300  * As things stand, nothing is ever placed in the output buffer to be
4301  * removed again except when it's KNOWN to be part of an identifier,
4302  * so flushing and moving down everything left, instead of expanding,
4303  * should work ok.
4304  */
4305
4306 void
4307 grow_outbuf (obuf, needed)
4308      register FILE_BUF *obuf;
4309      register int needed;
4310 {
4311   register U_CHAR *p;
4312   int minsize;
4313
4314   if (obuf->length - (obuf->bufp - obuf->buf) > needed)
4315     return;
4316
4317   /* Make it at least twice as big as it is now.  */
4318   obuf->length *= 2;
4319   /* Make it have at least 150% of the free space we will need.  */
4320   minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
4321   if (minsize > obuf->length)
4322     obuf->length = minsize;
4323
4324   p = (U_CHAR *) xrealloc (obuf->buf, obuf->length);
4325   obuf->bufp = p + (obuf->bufp - obuf->buf);
4326   obuf->buf = p;
4327 }
4328 \f
4329 /* Symbol table for macro names and special symbols */
4330
4331 /*
4332  * install a name in the main hash table, even if it is already there.
4333  *   name stops with first non alphanumeric, except leading '#'.
4334  * caller must check against redefinition if that is desired.
4335  * delete_macro () removes things installed by install () in fifo order.
4336  * this is important because of the `defined' special symbol used
4337  * in #if, and also if pushdef/popdef directives are ever implemented.
4338  *
4339  * If LEN is >= 0, it is the length of the name.
4340  * Otherwise, compute the length by scanning the entire name.
4341  *
4342  * If HASH is >= 0, it is the precomputed hash code.
4343  * Otherwise, compute the hash code.
4344  *
4345  * caller must set the value, if any is desired.
4346  */
4347 HASHNODE *
4348 install (name, len, type, hash)
4349      const U_CHAR *name;
4350      int len;
4351      enum node_type type;
4352      int hash;
4353         /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4354 {
4355   register HASHNODE *hp;
4356   register int bucket;
4357   register const U_CHAR *p;
4358   U_CHAR *q;
4359
4360   if (len < 0) {
4361     p = name;
4362     while (is_idchar[*p])
4363       p++;
4364     len = p - name;
4365   }
4366
4367   if (hash < 0)
4368     hash = hashf (name, len, HASHSIZE);
4369
4370   hp = (HASHNODE *) xmalloc (sizeof (HASHNODE) + len + 1);
4371   bucket = hash;
4372   hp->bucket_hdr = &hashtab[bucket];
4373   hp->next = hashtab[bucket];
4374   hashtab[bucket] = hp;
4375   hp->prev = NULL;
4376   if (hp->next != NULL)
4377     hp->next->prev = hp;
4378   hp->type = type;
4379   hp->length = len;
4380   hp->name = q = ((U_CHAR *) hp) + sizeof (HASHNODE);
4381   memcpy (q, name, len);
4382   q[len] = 0;
4383   return hp;
4384 }
4385
4386 /*
4387  * find the most recent hash node for name name (ending with first
4388  * non-identifier char) installed by install
4389  *
4390  * If LEN is >= 0, it is the length of the name.
4391  * Otherwise, compute the length by scanning the entire name.
4392  *
4393  * If HASH is >= 0, it is the precomputed hash code.
4394  * Otherwise, compute the hash code.
4395  */
4396 HASHNODE *
4397 lookup (name, len, hash)
4398      const U_CHAR *name;
4399      int len;
4400      int hash;
4401 {
4402   register const U_CHAR *bp;
4403   register HASHNODE *bucket;
4404
4405   if (len < 0) {
4406     for (bp = name; is_idchar[*bp]; bp++) ;
4407     len = bp - name;
4408   }
4409
4410   if (hash < 0)
4411     hash = hashf (name, len, HASHSIZE);
4412
4413   bucket = hashtab[hash];
4414   while (bucket) {
4415     if (bucket->length == len
4416         && strncmp ((char *)bucket->name, (char *)name, len) == 0)
4417       return bucket;
4418     bucket = bucket->next;
4419   }
4420   return NULL;
4421 }
4422
4423 /*
4424  * Delete a hash node.  Some weirdness to free junk from macros.
4425  * More such weirdness will have to be added if you define more hash
4426  * types that need it.
4427  */
4428
4429 /* Note that the DEFINITION of a macro is removed from the hash table
4430    but its storage is not freed.  This would be a storage leak
4431    except that it is not reasonable to keep undefining and redefining
4432    large numbers of macros many times.
4433    In any case, this is necessary, because a macro can be #undef'd
4434    in the middle of reading the arguments to a call to it.
4435    If #undef freed the DEFINITION, that would crash.  */
4436 void
4437 delete_macro (hp)
4438      HASHNODE *hp;
4439 {
4440
4441   if (hp->prev != NULL)
4442     hp->prev->next = hp->next;
4443   if (hp->next != NULL)
4444     hp->next->prev = hp->prev;
4445
4446   /* make sure that the bucket chain header that
4447      the deleted guy was on points to the right thing afterwards. */
4448   if (hp == *hp->bucket_hdr)
4449     *hp->bucket_hdr = hp->next;
4450
4451   free (hp);
4452 }
4453
4454 /*
4455  * return hash function on name.  must be compatible with the one
4456  * computed a step at a time, elsewhere
4457  */
4458 int
4459 hashf (name, len, hashsize)
4460      register const U_CHAR *name;
4461      register int len;
4462      int hashsize;
4463 {
4464   register int r = 0;
4465
4466   while (len--)
4467     r = HASHSTEP (r, *name++);
4468
4469   return MAKE_POS (r) % hashsize;
4470 }
4471 \f
4472 /* Dump all macro definitions as #defines to stdout.  */
4473
4474 void
4475 dump_all_macros ()
4476 {
4477   int bucket;
4478
4479   for (bucket = 0; bucket < HASHSIZE; bucket++) {
4480     register HASHNODE *hp;
4481
4482     for (hp = hashtab[bucket]; hp; hp= hp->next) {
4483       if (hp->type == T_MACRO) {
4484         register DEFINITION *defn = hp->value.defn;
4485         struct reflist *ap;
4486         int offset;
4487         int concat;
4488
4489
4490         /* Print the definition of the macro HP.  */
4491
4492         printf ("#define %s", hp->name);
4493         if (defn->nargs >= 0) {
4494           int i;
4495
4496           printf ("(");
4497           for (i = 0; i < defn->nargs; i++) {
4498             dump_arg_n (defn, i);
4499             if (i + 1 < defn->nargs)
4500               printf (", ");
4501           }
4502           printf (")");
4503         }
4504
4505         printf (" ");
4506
4507         offset = 0;
4508         concat = 0;
4509         for (ap = defn->pattern; ap != NULL; ap = ap->next) {
4510           dump_defn_1 (defn->expansion, offset, ap->nchars);
4511           if (ap->nchars != 0)
4512             concat = 0;
4513           offset += ap->nchars;
4514           if (ap->stringify)
4515             printf (" #");
4516           if (ap->raw_before && !concat)
4517             printf (" ## ");
4518           concat = 0;
4519           dump_arg_n (defn, ap->argno);
4520           if (ap->raw_after) {
4521             printf (" ## ");
4522             concat = 1;
4523           }
4524         }
4525         dump_defn_1 (defn->expansion, offset, defn->length - offset);
4526         printf ("\n");
4527       }
4528     }
4529   }
4530 }
4531
4532 /* Output to stdout a substring of a macro definition.
4533    BASE is the beginning of the definition.
4534    Output characters START thru LENGTH.
4535    Discard newlines outside of strings, thus
4536    converting funny-space markers to ordinary spaces.  */
4537 void
4538 dump_defn_1 (base, start, length)
4539      U_CHAR *base;
4540      int start;
4541      int length;
4542 {
4543   U_CHAR *p = base + start;
4544   U_CHAR *limit = base + start + length;
4545
4546   while (p < limit) {
4547     if (*p != '\n')
4548       putchar (*p);
4549     else if (*p == '\"' || *p =='\'') {
4550       U_CHAR *p1 = skip_quoted_string (p, limit, 0, 0, 0, 0);
4551       fwrite (p, p1 - p, 1, stdout);
4552       p = p1 - 1;
4553     }
4554     p++;
4555   }
4556 }
4557
4558 /* Print the name of argument number ARGNUM of macro definition DEFN.
4559    Recall that DEFN->argnames contains all the arg names
4560    concatenated in reverse order with comma-space in between.  */
4561 void
4562 dump_arg_n (defn, argnum)
4563      DEFINITION *defn;
4564      int argnum;
4565 {
4566   register U_CHAR *p = defn->argnames;
4567   while (argnum + 1 < defn->nargs) {
4568     p = (U_CHAR *) strchr ((char *)p, ' ') + 1;
4569     argnum++;
4570   }
4571
4572   while (*p && *p != ',') {
4573     putchar (*p);
4574     p++;
4575   }
4576 }
4577 \f
4578 /* Initialize syntactic classifications of characters.  */
4579 void
4580 initialize_char_syntax ()
4581 {
4582   register int i;
4583
4584   /*
4585    * Set up is_idchar and is_idstart tables.  These should be
4586    * faster than saying (is_alpha (c) || c == '_'), etc.
4587    * Must do set up these things before calling any routines tthat
4588    * refer to them.
4589    */
4590   for (i = 'a'; i <= 'z'; i++) {
4591     is_idchar[i - 'a' + 'A'] = 1;
4592     is_idchar[i] = 1;
4593     is_idstart[i - 'a' + 'A'] = 1;
4594     is_idstart[i] = 1;
4595   }
4596   for (i = '0'; i <= '9'; i++)
4597     is_idchar[i] = 1;
4598   is_idchar['_'] = 1;
4599   is_idstart['_'] = 1;
4600
4601   /* horizontal space table */
4602   is_hor_space[' '] = 1;
4603   is_hor_space['\t'] = 1;
4604   is_hor_space['\v'] = 1;
4605   is_hor_space['\f'] = 1;
4606   is_hor_space['\r'] = 1;
4607
4608   is_space[' '] = 1;
4609   is_space['\t'] = 1;
4610   is_space['\v'] = 1;
4611   is_space['\f'] = 1;
4612   is_space['\n'] = 1;
4613   is_space['\r'] = 1;
4614 }
4615
4616 /* Initialize the built-in macros.  */
4617 #define DSC(x) U x, sizeof x - 1
4618 #define install_spec(name, type) \
4619  install(DSC(name), type, -1);
4620 #define install_value(name, val) \
4621  hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
4622 void
4623 initialize_builtins ()
4624 {
4625   HASHNODE *hp;
4626
4627   install_spec ("__BASE_FILE__",     T_BASE_FILE);
4628   install_spec ("__DATE__",          T_DATE);
4629   install_spec ("__FILE__",          T_FILE);
4630   install_spec ("__TIME__",          T_TIME);
4631   install_spec ("__VERSION__",       T_VERSION);
4632   install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL);
4633   install_spec ("__LINE__",          T_SPECLINE);
4634
4635 #ifndef NO_BUILTIN_SIZE_TYPE
4636   install_value ("__SIZE_TYPE__",         SIZE_TYPE);
4637 #endif
4638 #ifndef NO_BUILTIN_PTRDIFF_TYPE
4639   install_value ("__PTRDIFF_TYPE__",      PTRDIFF_TYPE);
4640 #endif
4641 #ifndef NO_BUILTIN_WCHAR_TYPE
4642   install_value ("__WCHAR_TYPE__",        WCHAR_TYPE);
4643 #endif
4644 #ifndef NO_BUILTIN_WINT_TYPE
4645   install_value ("__WINT_TYPE__",         WINT_TYPE);
4646 #endif
4647   install_value ("__REGISTER_PREFIX__",   REGISTER_PREFIX);
4648   install_value ("__USER_LABEL_PREFIX__", user_label_prefix);
4649 }
4650 #undef DSC
4651 #undef install_spec
4652 #undef install_value
4653 \f
4654 /*
4655  * process a given definition string, for initialization
4656  * If STR is just an identifier, define it with value 1.
4657  * If STR has anything after the identifier, then it should
4658  * be identifier-space-definition.
4659  */
4660 void
4661 make_definition (str)
4662      U_CHAR *str;
4663 {
4664   FILE_BUF *ip;
4665   struct directive *kt;
4666   U_CHAR *buf, *p;
4667   size_t len = strlen ((char *)str);
4668
4669   p = (U_CHAR *) strchr ((char *)str, '=');
4670   if (p == NULL) {
4671     /* Change -DFOO into #define FOO 1 */
4672     buf = (U_CHAR *) alloca (len + 3);
4673     memcpy (buf, str, len);
4674     memcpy (buf + len, " 1", 3);
4675     len += 2;
4676   } else {
4677     buf = (U_CHAR *) alloca (len + 1);
4678     memcpy (buf, str, len + 1);
4679     buf[p - str] = ' ';
4680   }
4681
4682   ip = &instack[++indepth];
4683   ip->fname = "*Initialization*";
4684
4685   ip->buf = ip->bufp = buf;
4686   ip->length = len;
4687   ip->lineno = 1;
4688   ip->macro = 0;
4689   ip->free_ptr = 0;
4690   ip->if_stack = if_stack;
4691
4692   for (kt = directive_table; kt->type != T_DEFINE; kt++)
4693     ;
4694
4695   /* pass NULL as output ptr to do_define since we KNOW it never
4696      does any output.... */
4697   do_define (buf, buf + ip->length, NULL, kt);
4698   --indepth;
4699 }
4700
4701 /* JF, this does the work for the -U option */
4702 void
4703 make_undef (str)
4704      U_CHAR *str;
4705 {
4706   FILE_BUF *ip;
4707   struct directive *kt;
4708
4709   ip = &instack[++indepth];
4710   ip->fname = "*undef*";
4711
4712   ip->buf = ip->bufp = str;
4713   ip->length = strlen ((char *)str);
4714   ip->lineno = 1;
4715   ip->macro = 0;
4716   ip->free_ptr = 0;
4717   ip->if_stack = if_stack;
4718
4719   for (kt = directive_table; kt->type != T_UNDEF; kt++)
4720     ;
4721
4722   do_undef (str, str + ip->length, NULL, kt);
4723   --indepth;
4724 }
4725 \f
4726 /* Add output to `deps_buffer' for the -M switch.
4727    STRING points to the text to be output.
4728    SIZE is the number of bytes, or 0 meaning output until a null.
4729    If SIZE is nonzero, we break the line first, if it is long enough.  */
4730 void
4731 deps_output (string, size)
4732      const char *string;
4733      int size;
4734 {
4735 #ifndef MAX_OUTPUT_COLUMNS
4736 #define MAX_OUTPUT_COLUMNS 75
4737 #endif
4738   if (size != 0 && deps_column != 0
4739       && size + deps_column > MAX_OUTPUT_COLUMNS) {
4740     deps_output ("\\\n  ", 0);
4741     deps_column = 0;
4742   }
4743
4744   if (size == 0)
4745     size = strlen (string);
4746
4747   if (deps_size + size + 1 > deps_allocated_size) {
4748     deps_allocated_size = deps_size + size + 50;
4749     deps_allocated_size *= 2;
4750     deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
4751   }
4752   memcpy (&deps_buffer[deps_size], string, size);
4753   deps_size += size;
4754   deps_column += size;
4755   deps_buffer[deps_size] = 0;
4756 }
4757
4758 /* Get the file-mode and data size of the file open on FD
4759    and store them in *MODE_POINTER and *SIZE_POINTER.  */
4760
4761 int
4762 file_size_and_mode (fd, mode_pointer, size_pointer)
4763      int fd;
4764      int *mode_pointer;
4765      long *size_pointer;
4766 {
4767   struct stat sbuf;
4768
4769   if (fstat (fd, &sbuf) < 0) return -1;
4770   if (mode_pointer) *mode_pointer = sbuf.st_mode;
4771   if (size_pointer) *size_pointer = sbuf.st_size;
4772   return 0;
4773 }