This commit was generated by cvs2svn to compensate for changes in r124151,

which included commits to RCS files with non-trunk default branches.

1 files changed, 0 insertions, 5276 deletions

diff --git a/contrib/gcc/tradcpp.c b/contrib/gcc/tradcpp.c
deleted file mode 100644
index f277eba..0000000
--- a/contrib/gcc/tradcpp.c
+++ /dev/null
@@ -1,5276 +0,0 @@
-/* C Compatible Compiler Preprocessor (CCCP)
-Copyright (C) 1986, 1987, 1989, 2000, 2001, 2003 Free Software Foundation, Inc.
-                    Written by Paul Rubin, June 1986
-		    Adapted to ANSI C, Richard Stallman, Jan 1987
-		    Dusted off, polished, and adapted for use as traditional
-		    preprocessor only, Zack Weinberg, Jul 2000
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-#include "config.h"
-#include "system.h"
-#include "version.h"
-#include "cppdefault.h"
-#include "tradcpp.h"
-#include "mkdeps.h"
-#include "intl.h"
-
-typedef unsigned char U_CHAR;
-
-/* Name under which this program was invoked.  */
-
-static const char *progname;
-
-/* Current maximum length of directory names in the search path
-   for include files.  (Altered as we get more of them.)  */
-
-size_t max_include_len;
-
-/* Nonzero means copy comments into the output file.  */
-
-int put_out_comments = 0;
-
-/* mkdeps.h opaque structure that encapsulates dependency information.  */
-struct deps *deps;
-
-/* Nonzero means print the names of included files rather than
-   the preprocessed output.  1 means just the #include "...",
-   2 means #include <...> as well.  */
-
-int print_deps = 0;
-
-/* Nonzero means print dummy targets for each header file.  */
-
-int print_deps_phony_targets = 0;
-
-/* If true, fopen (deps_file, "a") else fopen (deps_file, "w").  */
-
-int deps_append = 0;
-
-/* File name which deps are being written to.  This is 0 if deps are
-   being written to stdout.  */
-
-const char *deps_file = 0;
-
-/* Nonzero if missing .h files in -M output are assumed to be
-   generated files and not errors.  */
-
-int deps_missing_files = 0;
-       
-/* Nonzero means don't output line number information.  */
-
-int no_line_commands;
-
-/* Nonzero means inhibit output of the preprocessed text
-   and instead output the definitions of all user-defined macros
-   in a form suitable for use as input to cccp.  */
-
-int dump_macros;
-
-/* Nonzero means don't print warning messages.  -w.  */
-
-int inhibit_warnings = 0;
-
-/* Non-0 means don't output the preprocessed program.  */
-int inhibit_output = 0;
-
-/* Nonzero means chars are signed.  */
-#if DEFAULT_SIGNED_CHAR
-int flag_signed_char = 1;
-#else
-int flag_signed_char = 0;
-#endif
-
-/* Nonzero means warn if slash-star appears in a comment.  */
-
-int warn_comments;
-
-/* Nonzero causes output not to be done,
-   but directives such as #define that have side effects
-   are still obeyed.  */
-
-int no_output;
-
-/* Value of __USER_LABEL_PREFIX__.  Target-dependent, also controlled
-   by -f(no-)leading-underscore.  */
-static const char *user_label_prefix;
-
-/* I/O buffer structure.
-   The `fname' field is nonzero for source files and #include files
-   and for the dummy text used for -D and -U.
-   It is zero for rescanning results of macro expansion
-   and for expanding macro arguments.  */
-#define INPUT_STACK_MAX 200
-struct file_name_list;
-struct file_buf {
-  const char *fname;
-  int lineno;
-  int length;
-  U_CHAR *buf;
-  U_CHAR *bufp;
-  /* Macro that this level is the expansion of.
-     Included so that we can reenable the macro
-     at the end of this level.  */
-  struct hashnode *macro;
-  /* Value of if_stack at start of this file.
-     Used to prohibit unmatched #endif (etc) in an include file.  */
-  struct if_stack *if_stack;
-  /* Object to be freed at end of input at this level.  */
-  U_CHAR *free_ptr;
-  /* Position to start scanning for #include_next in this file.  */
-  struct file_name_list *next_header_dir;
-} instack[INPUT_STACK_MAX];
-
-typedef struct file_buf FILE_BUF;
-
-/* Current nesting level of input sources.
-   `instack[indepth]' is the level currently being read.  */
-int indepth = -1;
-#define CHECK_DEPTH(code) \
-  if (indepth >= (INPUT_STACK_MAX - 1))					\
-    {									\
-      error_with_line (line_for_error (instack[indepth].lineno),	\
-		       "macro or #include recursion too deep");		\
-      code;								\
-    }
-
-/* Current depth in #include directives that use <...>.  */
-int system_include_depth = 0;
-
-/* The output buffer.  Its LENGTH field is the amount of room allocated
-   for the buffer, not the number of chars actually present.  To get
-   that, subtract outbuf.buf from outbuf.bufp. */
-
-#define OUTBUF_SIZE 10	/* initial size of output buffer */
-FILE_BUF outbuf;
-
-/* Grow output buffer OBUF points at
-   so it can hold at least NEEDED more chars.  */
-
-#define check_expand(OBUF, NEEDED) do { \
-  if ((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
-    grow_outbuf ((OBUF), (NEEDED)); \
- } while (0)
-
-struct file_name_list
-  {
-    struct file_name_list *next;
-    const char *fname;
-  };
-
-struct file_name_list *include = 0;	/* First dir to search */
-	/* First dir to search for <file> */
-struct file_name_list *first_bracket_include = 0;
-struct file_name_list *last_include = 0;	/* Last in chain */
-
-/* List of included files that contained #once.  */
-struct file_name_list *dont_repeat_files = 0;
-
-/* List of other included files.  */
-struct file_name_list *all_include_files = 0;
-
-/* Structure allocated for every #define.  For a simple replacement
-   such as
-   	#define foo bar ,
-   nargs = -1, the `pattern' list is null, and the expansion is just
-   the replacement text.  Nargs = 0 means a functionlike macro with no args,
-   e.g.,
-       #define getchar() getc (stdin) .
-   When there are args, the expansion is the replacement text with the
-   args squashed out, and the reflist is a list describing how to
-   build the output from the input: e.g., "3 chars, then the 1st arg,
-   then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
-   The chars here come from the expansion.  Whatever is left of the
-   expansion after the last arg-occurrence is copied after that arg.
-   Note that the reflist can be arbitrarily long---
-   its length depends on the number of times the arguments appear in
-   the replacement text, not how many args there are.  Example:
-   #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
-   pattern list
-     { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
-   where (x, y) means (nchars, argno). */
-
-typedef struct definition DEFINITION;
-struct definition {
-  int nargs;
-  int length;			/* length of expansion string */
-  U_CHAR *expansion;
-  struct reflist {
-    struct reflist *next;
-    char stringify;		/* nonzero if this arg was preceded by a
-				   # operator. */
-    char raw_before;		/* Nonzero if a ## operator before arg. */
-    char raw_after;		/* Nonzero if a ## operator after arg. */
-    int nchars;			/* Number of literal chars to copy before
-				   this arg occurrence.  */
-    int argno;			/* Number of arg to substitute (origin-0) */
-  } *pattern;
-  /* Names of macro args, concatenated in reverse order
-     with comma-space between them.
-     The only use of this is that we warn on redefinition
-     if this differs between the old and new definitions.  */
-  const U_CHAR *argnames;
-};
-
-/* Chained list of answers to an assertion.  */
-struct answer
-{
-  struct answer *next;
-  const unsigned char *answer;
-  size_t len;
-};
-
-/* different kinds of things that can appear in the value field
-   of a hash node.  Actually, this may be useless now. */
-union hashval {
-  const char *cpval;
-  DEFINITION *defn;
-  struct answer *answers;
-};
-
-/* The structure of a node in the hash table.  The hash table
-   has entries for all tokens defined by #define commands (type T_MACRO),
-   plus some special tokens like __LINE__ (these each have their own
-   type, and the appropriate code is run when that type of node is seen.
-   It does not contain control words like "#define", which are recognized
-   by a separate piece of code. */
-
-/* different flavors of hash nodes --- also used in keyword table */
-enum node_type {
- T_DEFINE = 1,	/* `#define' */
- T_INCLUDE,	/* `#include' */
- T_INCLUDE_NEXT,/* `#include_next' */
- T_IFDEF,	/* `#ifdef' */
- T_IFNDEF,	/* `#ifndef' */
- T_IF,		/* `#if' */
- T_ELSE,	/* `#else' */
- T_ELIF,	/* `#elif' */
- T_UNDEF,	/* `#undef' */
- T_LINE,	/* `#line' */
- T_ENDIF,	/* `#endif' */
- T_ERROR,	/* `#error' */
- T_WARNING,	/* `#warning' */
- T_ASSERT,	/* `#assert' */
- T_UNASSERT,	/* `#unassert' */
- T_SPECLINE,	/* special symbol `__LINE__' */
- T_DATE,	/* `__DATE__' */
- T_FILE,	/* `__FILE__' */
- T_BASE_FILE,	/* `__BASE_FILE__' */
- T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
- T_VERSION,	/* `__VERSION__' */
- T_TIME,	/* `__TIME__' */
- T_CONST,	/* Constant value, used by `__STDC__' */
- T_MACRO,	/* macro defined by `#define' */
- T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
- T_UNUSED	/* Used for something not defined.  */
-};
-
-struct hashnode {
-  struct hashnode *next;	/* double links for easy deletion */
-  struct hashnode *prev;
-  struct hashnode **bucket_hdr;	/* also, a back pointer to this node's hash
-				   chain is kept, in case the node is the head
-				   of the chain and gets deleted. */
-  enum node_type type;		/* type of special token */
-  int length;			/* length of token, for quick comparison */
-  U_CHAR *name;			/* the actual name */
-  union hashval value;		/* pointer to expansion, or whatever */
-};
-
-typedef struct hashnode HASHNODE;
-
-static HASHNODE *parse_assertion PARAMS ((const unsigned char *,
-					  const unsigned char *,
-					  struct answer **, int));
-static struct answer **find_answer PARAMS ((HASHNODE *,
-					    const struct answer *));
-static int parse_answer PARAMS ((const unsigned char *, const unsigned char *,
-				 struct answer **, int));
-static unsigned char *canonicalize_text PARAMS ((const unsigned char *,
-						 const unsigned char *,
-						 const unsigned char **));
-
-/* Some definitions for the hash table.  The hash function MUST be
-   computed as shown in hashf () below.  That is because the rescan
-   loop computes the hash value `on the fly' for most tokens,
-   in order to avoid the overhead of a lot of procedure calls to
-   the hashf () function.  Hashf () only exists for the sake of
-   politeness, for use when speed isn't so important. */
-
-#define HASHSIZE 1403
-HASHNODE *hashtab[HASHSIZE];
-#define HASHSTEP(old, c) ((old << 2) + c)
-#define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
-
-/* `struct directive' defines one #-directive, including how to handle it.  */
-
-struct directive {
-  const int length;		/* Length of name */
-  void (*const func) PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-  				/* Function to handle directive */
-  const char *const name;	/* Name of directive */
-  const enum node_type type;	/* Code which describes which directive. */
-};
-
-/* Last arg to output_line_command.  */
-enum file_change_code {same_file, enter_file, leave_file};
-
-/* This structure represents one parsed argument in a macro call.
-   `raw' points to the argument text as written (`raw_length' is its length).
-   `expanded' points to the argument's macro-expansion
-   (its length is `expand_length').
-   `stringified_length' is the length the argument would have
-   if stringified.
-   `free1' and `free2', if nonzero, point to blocks to be freed
-   when the macro argument data is no longer needed.  */
-
-struct argdata {
-  U_CHAR *raw, *expanded;
-  int raw_length, expand_length;
-  int stringified_length;
-  U_CHAR *free1, *free2;
-  char newlines;
-  char comments;
-};
-
-/* The arglist structure is built by do_define to tell
-   collect_definition where the argument names begin.  That
-   is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
-   would contain pointers to the strings x, y, and z.
-   Collect_definition would then build a DEFINITION node,
-   with reflist nodes pointing to the places x, y, and z had
-   appeared.  So the arglist is just convenience data passed
-   between these two routines.  It is not kept around after
-   the current #define has been processed and entered into the
-   hash table. */
-
-struct arglist {
-  struct arglist *next;
-  U_CHAR *name;
-  int length;
-  int argno;
-};
-
-/* Function prototypes.  */
-
-static void do_define	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_error	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_warning	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_line	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_include	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_include_next	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_undef	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_if	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_ifdef	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_ifndef	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_else	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_elif	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_endif	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_assert	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_unassert	PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
-static void do_xifdef	PARAMS ((U_CHAR *, U_CHAR *, enum node_type));
-
-static struct hashnode *install PARAMS ((const U_CHAR *, int, enum node_type, int));
-static int hashf		 PARAMS ((const U_CHAR *, int, int));
-static int compare_defs	 PARAMS ((DEFINITION *, DEFINITION *));
-static int comp_def_part	 PARAMS ((int, const U_CHAR *, int,
-					  const U_CHAR *, int, int));
-static void delete_macro	 PARAMS ((HASHNODE *));
-
-/* First arg to v_message.  */
-enum msgtype { MT_WARNING = 0, MT_ERROR, MT_FATAL };
-static void v_message		 PARAMS ((enum msgtype mtype, int line,
-					  const char *msgid, va_list ap))
-     ATTRIBUTE_PRINTF (3, 0);
-
-static int line_for_error	 PARAMS ((int));
-
-/* We know perfectly well which file this is, so we don't need to
-   use __FILE__.  */
-#undef abort
-#if (GCC_VERSION >= 2007)
-#define abort()	fancy_abort(__LINE__, __FUNCTION__)
-#else
-#define abort() fancy_abort(__LINE__, 0);
-#endif
-
-static void macroexpand 	PARAMS ((HASHNODE *, FILE_BUF *));
-static void special_symbol	PARAMS ((HASHNODE *, FILE_BUF *));
-static void dump_all_macros 	PARAMS ((void));
-static void dump_defn_1		PARAMS ((const U_CHAR *, int, int));
-static void dump_arg_n		PARAMS ((DEFINITION *, int));
-static void conditional_skip 	PARAMS ((FILE_BUF *, int, enum node_type));
-static void skip_if_group 	PARAMS ((FILE_BUF *, int));
-static void output_line_command PARAMS ((FILE_BUF *, FILE_BUF *,
-					 int, enum file_change_code));
-
-static int eval_if_expression	PARAMS ((const U_CHAR *, int));
-
-static void output_deps		PARAMS ((void));
-static void initialize_builtins	PARAMS ((void));
-static void run_directive	PARAMS ((const char *, size_t,
-					 enum node_type));
-static void make_definition	PARAMS ((const char *));
-static void make_undef		PARAMS ((const char *));
-static void make_assertion	PARAMS ((const char *));
-
-static void grow_outbuf 	PARAMS ((FILE_BUF *, int));
-static int handle_directive 	PARAMS ((FILE_BUF *, FILE_BUF *));
-static void process_include	PARAMS ((struct file_name_list *,
-					 const U_CHAR *, int, int, FILE_BUF *));
-static void fixup_newlines	PARAMS ((FILE_BUF *));
-static void finclude		PARAMS ((int, const char *,
-					 struct file_name_list *, FILE_BUF *));
-static void init_dependency_output PARAMS ((void));
-static void rescan		PARAMS ((FILE_BUF *, int));
-static void newline_fix		PARAMS ((U_CHAR *));
-static void name_newline_fix	PARAMS ((U_CHAR *));
-static U_CHAR *macarg1		PARAMS ((U_CHAR *, const U_CHAR *, int *,
-					 int *, int *));
-static const char *macarg	PARAMS ((struct argdata *));
-static int discard_comments	PARAMS ((U_CHAR *, int, int));
-static int file_size_and_mode	PARAMS ((int, int *, long *));
-
-static U_CHAR *skip_to_end_of_comment PARAMS ((FILE_BUF *, int *));
-static U_CHAR *skip_quoted_string     PARAMS ((const U_CHAR *, const U_CHAR *,
-					       int, int *, int *, int *));
-
-int main		PARAMS ((int, char **));
-
-/* Convenience.  Write U"string" to get an unsigned string constant.  */
-#define U (const unsigned char *)
-
-/* Here is the actual list of #-directives, most-often-used first.  */
-
-static const struct directive directive_table[] = {
-  {  6, do_define,  "define",  T_DEFINE  },
-  {  7, do_include, "include", T_INCLUDE },
-  {  5, do_endif,   "endif",   T_ENDIF   },
-  {  5, do_ifdef,   "ifdef",   T_IFDEF   },
-  {  2, do_if,      "if",      T_IF,     },
-  {  4, do_else,    "else",    T_ELSE    },
-  {  6, do_ifndef,  "ifndef",  T_IFNDEF  },
-  {  5, do_undef,   "undef",   T_UNDEF   },
-  {  4, do_line,    "line",    T_LINE    },
-  {  4, do_elif,    "elif",    T_ELIF    },
-  {  5, do_error,   "error",   T_ERROR   },
-  {  7, do_warning, "warning", T_WARNING },
-  { 12, do_include_next, "include_next", T_INCLUDE_NEXT },
-  {  6, do_assert,  "assert",  T_ASSERT  },
-  {  8, do_unassert,"unassert",T_UNASSERT},
-  {  -1, 0, "", T_UNUSED},
-};
-
-#define SKIP_WHITE_SPACE(p) do { while (is_nvspace(*p)) p++; } while (0)
-#define SKIP_ALL_WHITE_SPACE(p) do { while (is_space(*p)) p++; } while (0)
-  
-int errors = 0;			/* Error counter for exit code */
-
-static FILE_BUF expand_to_temp_buffer PARAMS ((const U_CHAR *, const U_CHAR *, int));
-static DEFINITION *collect_expansion  PARAMS ((U_CHAR *, U_CHAR *, int,
-					       struct arglist *));
-
-/* Stack of conditionals currently in progress
-   (including both successful and failing conditionals).  */
-
-struct if_stack {
-  struct if_stack *next;	/* for chaining to the next stack frame */
-  const char *fname;		/* copied from input when frame is made */
-  int lineno;			/* similarly */
-  int if_succeeded;		/* true if a leg of this if-group
-				    has been passed through rescan */
-  enum node_type type;		/* type of last directive seen in this group */
-};
-typedef struct if_stack IF_STACK_FRAME;
-IF_STACK_FRAME *if_stack = NULL;
-
-/* Nonzero means -I- has been seen,
-   so don't look for #include "foo" the source-file directory.  */
-int ignore_srcdir;
-
-/* Pending directives.  */
-enum pending_dir_t {PD_NONE = 0, PD_DEFINE, PD_UNDEF, PD_ASSERTION, PD_FILE};
-
-typedef struct pending_dir pending_dir;
-struct pending_dir
-{
-  const char *arg;
-  enum pending_dir_t type;
-};
-
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  int st_mode;
-  long st_size;
-  const char *in_fname, *out_fname;
-  int f, i;
-  FILE_BUF *fp;
-  pending_dir *pend = (pending_dir *) xcalloc (argc, sizeof (pending_dir));
-  int no_standard_includes = 0;
-
-  hex_init ();
-
-#ifdef RLIMIT_STACK
-  /* Get rid of any avoidable limit on stack size.  */
-  {
-    struct rlimit rlim;
-
-    /* Set the stack limit huge so that alloca (particularly stringtab
-     * in dbxread.c) does not fail. */
-    getrlimit (RLIMIT_STACK, &rlim);
-    rlim.rlim_cur = rlim.rlim_max;
-    setrlimit (RLIMIT_STACK, &rlim);
-  }
-#endif /* RLIMIT_STACK defined */
-
-  progname = argv[0];
-
-  in_fname = NULL;
-  out_fname = NULL;
-
-  no_line_commands = 0;
-  dump_macros = 0;
-  no_output = 0;
-
-  max_include_len = cpp_GCC_INCLUDE_DIR_len + 7;  /* ??? */
-
-  gcc_init_libintl ();
-
-  /* It's simplest to just create this struct whether or not it will
-     be needed.  */
-  deps = deps_init ();
-
-  /* Process switches and find input file name.  */
-
-  for (i = 1; i < argc; i++) {
-    if (argv[i][0] != '-') {
-      if (out_fname != NULL)
-	fatal ("usage: %s [switches] input output", argv[0]);
-      else if (in_fname != NULL)
-	out_fname = argv[i];
-      else
-	in_fname = argv[i];
-    } else {
-      int c = argv[i][1];
-
-      switch (c) {
-      case 'E':
-      case '$':
-	break;  /* Ignore for compatibility with ISO/extended cpp.  */
-
-      case 'l':
-	if (!strcmp (argv[i], "-lang-c++")
-	    || !strcmp (argv[i], "-lang-objc++"))
-	  fatal ("-traditional is not supported in C++");
-	else if (!strcmp (argv[i], "-lang-c89"))
-	  fatal ("-traditional and -ansi are mutually exclusive");
-	else if (!strcmp (argv[i], "-lang-objc"))
-	  pend[i].type = PD_DEFINE, pend[i].arg = "__OBJC__";
-	else if (!strcmp (argv[i], "-lang-asm"))
-	  pend[i].type = PD_DEFINE, pend[i].arg = "__ASSEMBLER__";
-	else if (!strcmp (argv[i], "-lang-fortran"))
-	  pend[i].type = PD_DEFINE, pend[i].arg = "_LANGUAGE_FORTRAN";
-	/* All other possibilities ignored.  */
-	break;
-
-      case 'i':
-	if (!strcmp (argv[i], "-include"))
-	  {
-	    if (i + 1 == argc)
-	      fatal ("filename missing after -i option");
-	    else
-	      pend[i].type = PD_FILE, pend[i].arg = argv[i + 1], i++;
-	  }
-	else if (!strcmp (argv[i], "-iprefix"))
-	  i++; /* Ignore for compatibility */
-	else if (!strcmp (argv[i], "-isystem")
-		 || !strcmp (argv[i], "-iwithprefix")
-		 || !strcmp (argv[i], "-iwithprefixbefore")
-		 || !strcmp (argv[i], "-idirafter"))
-	  goto add_include;  /* best we can do */
-	  
-	break;
-
-      case 'o':
-	if (out_fname != NULL)
-	  fatal ("output filename specified twice");
-	if (i + 1 == argc)
-	  fatal ("filename missing after -o option");
-	out_fname = argv[++i];
-	if (!strcmp (out_fname, "-"))
-	  out_fname = "";
-	break;
-
-      case 'w':
-	inhibit_warnings = 1;
-	break;
-
-      case 'W':
-	if (!strcmp (argv[i], "-Wcomments"))
-	  warn_comments = 1;
-	else if (!strcmp (argv[i], "-Wcomment"))
-	  warn_comments = 1;
-	else if (!strcmp (argv[i], "-Wall")) {
-	  warn_comments = 1;
-	}
-	break;
-
-      case 'f':
-	if (!strcmp (argv[i], "-fleading-underscore"))
-	  user_label_prefix = "_";
-	else if (!strcmp (argv[i], "-fno-leading-underscore"))
-	  user_label_prefix = "";
-	else if (!strcmp (argv[i], "-fsigned-char"))
-	  flag_signed_char = 1;
-	else if (!strcmp (argv[i], "-funsigned-char"))
-	  flag_signed_char = 0;
-	break;
-
-      case 'M':
-	{
-	  char *p = NULL;
-
-	  /* -MD and -MMD for tradcpp are deprecated and undocumented
-	     (use -M or -MM with -MF instead), and probably should be
-	     removed with the next major GCC version.  For the moment
-	     we allow these for the benefit of Automake 1.4, which
-	     uses these when dependency tracking is enabled.  Automake
-	     1.5 will fix this.  */
-	  if (!strncmp (argv[i], "-MD", 3)) {
-	    p = argv[i] + 3;
-	    print_deps = 2;
-	  } else if (!strncmp (argv[i], "-MMD", 4)) {
-	    p = argv[i] + 4;
-	    print_deps = 1;
-	  } else if (!strcmp (argv[i], "-M")) {
-	    print_deps = 2;
-	  } else if (!strcmp (argv[i], "-MM")) {
-	    print_deps = 1;
-	  } else if (!strcmp (argv[i], "-MG")) {
-	    deps_missing_files = 1;
-	  } else if (!strcmp (argv[i], "-MF")) {
-	    p = argv[i] + 3;
-	  } else if (!strcmp (argv[i], "-MP")) {
-	    print_deps_phony_targets = 1;
-	  } else if (!strcmp (argv[i], "-MQ") || !strcmp (argv[i], "-MT")) {
-	    /* Add a target.  -MQ quotes for Make.  */
-	    const char *tgt = argv[i] + 3;
-	    int quoted = argv[i][2] == 'Q';
-
-	    if (*tgt == '\0' && i + 1 == argc)
-	      fatal ("target missing after %s option", argv[i]);
-	    else
-	      {
-		if (*tgt == '\0')
-		  tgt = argv[++i];
-	      
-		deps_add_target (deps, tgt, quoted);
-	      }
-	  }
-
-	  if (p) {
-	    if (*p)
-	      deps_file = p;
-	    else if (i + 1 == argc)
-	      fatal ("filename missing after %s option", argv[i]);
-	    else
-	      deps_file = argv[++i];
-	  }
-	}
-	break;
-
-      case 'd':
-	dump_macros = 1;
-	no_output = 1;
-	break;
-
-      case 'v':
-	fprintf (stderr, "GNU traditional CPP version %s\n", version_string);
-	break;
-
-      case 'D':
-      case 'U':
-      case 'A':
-	{
-	  char *p;
-
-	  if (argv[i][2] != 0)
-	    p = argv[i] + 2;
-	  else if (i + 1 == argc)
-	    fatal ("macro name missing after -%c option", c);
-	  else
-	    p = argv[++i];
-
-	  if (c == 'D')
-	    pend[i].type = PD_DEFINE;
-	  else if (c == 'U')
-	    pend[i].type = PD_UNDEF;
-	  else
-	    pend[i].type = PD_ASSERTION;
-	  pend[i].arg = p;
-	}
-	break;
-
-      case 'C':
-	put_out_comments = 1;
-	break;
-
-      case 'p':
-	if (!strcmp (argv[i], "-pedantic"))
-	  fatal ("-pedantic and -traditional are mutually exclusive");
-	break;
-
-      case 't':
-	if (!strcmp (argv[i], "-trigraphs"))
-	  fatal ("-trigraphs and -traditional are mutually exclusive");
-	break;
-
-      case 'P':
-	no_line_commands = 1;
-	break;
-
-      case 'I':			/* Add directory to path for includes.  */
-      add_include:
-	{
-	  struct file_name_list *dirtmp;
-
-	  if (! ignore_srcdir && !strcmp (argv[i] + 2, "-"))
-	    ignore_srcdir = 1;
-	  else {
-	    dirtmp = (struct file_name_list *)
-	      xmalloc (sizeof (struct file_name_list));
-	    dirtmp->next = 0;		/* New one goes on the end */
-	    if (include == 0)
-	      include = dirtmp;
-	    else
-	      last_include->next = dirtmp;
-	    last_include = dirtmp;	/* Tail follows the last one */
-	    if (argv[i][1] == 'I' && argv[i][2] != 0)
-	      dirtmp->fname = argv[i] + 2;
-	    else if (i + 1 == argc)
-	      fatal ("directory name missing after -I option");
-	    else
-	      dirtmp->fname = argv[++i];
-	    if (strlen (dirtmp->fname) > max_include_len)
-	      max_include_len = strlen (dirtmp->fname);
-	    if (ignore_srcdir && first_bracket_include == 0)
-	      first_bracket_include = dirtmp;
-	    }
-	}
-	break;
-
-      case 'n':
-	/* -nostdinc causes no default include directories.
-	   You must specify all include-file directories with -I.  */
-	no_standard_includes = 1;
-	break;
-
-      case '\0': /* JF handle '-' as file name meaning stdin or stdout */
-	if (in_fname == NULL) {
-	  in_fname = "";
-	  break;
-	} else if (out_fname == NULL) {
-	  out_fname = "";
-	  break;
-	}	/* else fall through into error */
-
-      default:
-	fatal ("invalid option `%s'", argv[i]);
-      }
-    }
-  }
-
-  init_dependency_output ();
-
-  /* After checking the environment variables, check if -M or -MM has
-     not been specified, but other -M options have.  */
-  if (print_deps == 0
-      && (deps_missing_files || deps_file || print_deps_phony_targets))
-    fatal ("you must additionally specify either -M or -MM");
-
-  if (user_label_prefix == 0)
-    user_label_prefix = USER_LABEL_PREFIX;
-
-  if (print_deps)
-    {
-      /* Set the default target (if there is none already), and
-	 the dependency on the main file.  */
-      deps_add_default_target (deps, in_fname);
-
-      deps_add_dep (deps, in_fname);
-    }
-
-  /* Install __LINE__, etc.  Must follow option processing.  */
-  initialize_builtins ();
-
-  /* Do defines specified with -D and undefines specified with -U.  */
-  for (i = 1; i < argc; i++)
-    if (pend[i].type == PD_DEFINE)
-      make_definition (pend[i].arg);
-    else if (pend[i].type == PD_UNDEF)
-      make_undef (pend[i].arg);
-    else if (pend[i].type == PD_ASSERTION)
-      make_assertion (pend[i].arg);
-
-  /* Unless -fnostdinc,
-     tack on the standard include file dirs to the specified list */
-  if (!no_standard_includes) {
-    const struct default_include *di;
-    struct file_name_list *old_last_include = last_include;
-    struct file_name_list *dirtmp;
-    for (di = cpp_include_defaults; di->fname; di++) {
-      if (di->cplusplus)
-	continue;
-      dirtmp = (struct file_name_list *)
-	xmalloc (sizeof (struct file_name_list));
-      dirtmp->next = 0;		/* New one goes on the end */
-      if (include == 0)
-	include = dirtmp;
-      else
-	last_include->next = dirtmp;
-      last_include = dirtmp;	/* Tail follows the last one */
-      dirtmp->fname = di->fname;
-      if (strlen (dirtmp->fname) > max_include_len)
-	max_include_len = strlen (dirtmp->fname);
-    }
-
-    if (ignore_srcdir && first_bracket_include == 0)
-      first_bracket_include = old_last_include->next;
-  }
-
-  /* Initialize output buffer */
-
-  outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
-  outbuf.bufp = outbuf.buf;
-  outbuf.length = OUTBUF_SIZE;
-
-  /* Scan the -i files before the main input.
-     Much like #including them, but with no_output set
-     so that only their macro definitions matter.  */
-
-  no_output++;
-  indepth++;
-  for (i = 1; i < argc; i++)
-    if (pend[i].type == PD_FILE)
-      {
-	int fd = open (pend[i].arg, O_RDONLY, 0666);
-	if (fd < 0)
-	  {
-	    perror_with_name (pend[i].arg);
-	    return FATAL_EXIT_CODE;
-	  }
-
-	/* For -M, add this file to the dependencies.  */
-	if (print_deps)
-	  deps_add_dep (deps, pend[i].arg);
-
-	finclude (fd, pend[i].arg, 0, &outbuf);
-      }
-  indepth--;
-  no_output--;
-
-  /* Pending directives no longer needed.  */
-  free ((PTR) pend);
-
-  /* Create an input stack level for the main input file
-     and copy the entire contents of the file into it.  */
-
-  fp = &instack[++indepth];
-
-  /* JF check for stdin */
-  if (in_fname == NULL || *in_fname == 0) {
-    in_fname = "";
-    f = 0;
-  } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
-    goto sys_error;
-
-  if (file_size_and_mode (f, &st_mode, &st_size))
-    goto sys_error;
-  fp->fname = in_fname;
-  fp->lineno = 1;
-  /* JF all this is mine about reading pipes and ttys */
-  if (!S_ISREG (st_mode)) {
-    /* Read input from a file that is not a normal disk file.
-       We cannot preallocate a buffer with the correct size,
-       so we must read in the file a piece at the time and make it bigger.  */
-    int size;
-    int bsize;
-    int cnt;
-    U_CHAR *bufp;
-
-    bsize = 2000;
-    size = 0;
-    fp->buf = (U_CHAR *) xmalloc (bsize + 2);
-    bufp = fp->buf;
-    for (;;) {
-      cnt = read (f, bufp, bsize - size);
-      if (cnt < 0) goto sys_error;	/* error! */
-      if (cnt == 0) break;		/* End of file */
-      size += cnt;
-      bufp += cnt;
-      if (bsize == size) {		/* Buffer is full! */
-        bsize *= 2;
-        fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
-	bufp = fp->buf + size;	/* May have moved */
-      }
-    }
-    fp->length = size;
-  } else {
-    /* Read a file whose size we can determine in advance.
-       For the sake of VMS, st_size is just an upper bound.  */
-    long i;
-    fp->length = 0;
-    fp->buf = (U_CHAR *) xmalloc (st_size + 2);
-
-    while (st_size > 0) {
-      i = read (f, fp->buf + fp->length, st_size);
-      if (i <= 0) {
-        if (i == 0) break;
-	goto sys_error;
-      }
-      fp->length += i;
-      st_size -= i;
-    }
-  }
-  fp->bufp = fp->buf;
-  fp->if_stack = if_stack;
-  fixup_newlines (fp);
-
-  /* Make sure data ends with a newline.  And put a null after it.  */
-
-  if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
-    fp->buf[fp->length++] = '\n';
-  fp->buf[fp->length] = '\0';
-  
-  /* Now that we know the input file is valid, open the output.  */
-
-  if (!out_fname || !strcmp (out_fname, ""))
-    out_fname = "stdout";
-  else if (! freopen (out_fname, "w", stdout))
-    pfatal_with_name (out_fname);
-
-  output_line_command (fp, &outbuf, 0, same_file);
-
-  /* Scan the input, processing macros and directives.  */
-
-  rescan (&outbuf, 0);
-
-  /* Now we have processed the entire input
-     Write whichever kind of output has been requested.  */
-
-
-  if (dump_macros)
-    dump_all_macros ();
-  else if (! inhibit_output)
-    if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
-      fatal ("I/O error on output");
-
-  /* Don't write the deps file if preprocessing has failed.  */
-  if (print_deps && errors == 0)
-    output_deps ();
-
-  /* Destruct the deps object.  */
-  deps_free (deps);
-
-  if (ferror (stdout))
-    fatal ("I/O error on output");
-
-  if (errors)
-    exit (FATAL_EXIT_CODE);
-  exit (SUCCESS_EXIT_CODE);
-
- sys_error:
-  pfatal_with_name (in_fname);
-}
-
-/* Set up dependency-file output.  */
-static void
-init_dependency_output ()
-{
-  char *spec, *s, *output_file;
-
-  /* Either of two environment variables can specify output of deps.
-     Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
-     where OUTPUT_FILE is the file to write deps info to
-     and DEPS_TARGET is the target to mention in the deps.  */
-
-  if (print_deps == 0)
-    {
-      spec = getenv ("DEPENDENCIES_OUTPUT");
-      if (spec)
-	print_deps = 1;
-      else
-	{
-	  spec = getenv ("SUNPRO_DEPENDENCIES");
-	  if (spec)
-	    print_deps = 2;
-	  else
-	    return;
-	}
-
-      /* Find the space before the DEPS_TARGET, if there is one.  */
-      s = strchr (spec, ' ');
-      if (s)
-	{
-	  /* Let the caller perform MAKE quoting.  */
-	  deps_add_target (deps, s + 1, 0);
-	  output_file = (char *) xmalloc (s - spec + 1);
-	  memcpy (output_file, spec, s - spec);
-	  output_file[s - spec] = 0;
-	}
-      else
-	output_file = spec;
-
-      /* Command line overrides environment variables.  */
-      if (deps_file == 0)
-	deps_file = output_file;
-      deps_append = 1;
-    }
-
-  /* If dependencies go to standard output, or -MG is used, we should
-     suppress output.  The user may be requesting other stuff to
-     stdout, with -dM, -v etc.  We let them shoot themselves in the
-     foot.  */
-  if (deps_file == 0 || deps_missing_files)
-    inhibit_output = 1;
-}
-
-/* Use mkdeps.c to output dependency information.  */
-static void
-output_deps ()
-{
-  /* Stream on which to print the dependency information.  */
-  FILE *deps_stream = 0;
-  const char *const deps_mode = deps_append ? "a" : "w";
-
-  if (deps_file == 0)
-    deps_stream = stdout;
-  else
-    {
-      deps_stream = fopen (deps_file, deps_mode);
-      if (deps_stream == 0)
-	{
-	  error_from_errno (deps_file);
-	  return;
-	}
-    }
-
-  deps_write (deps, deps_stream, 72);
-
-  if (print_deps_phony_targets)
-    deps_phony_targets (deps, deps_stream);
-
-  /* Don't close stdout.  */
-  if (deps_file)
-    {
-      if (ferror (deps_stream) || fclose (deps_stream) != 0)
-	fatal ("I/O error on output");
-    }
-}
-
-/* Move all backslash-newline pairs out of embarrassing places.
-   Exchange all such pairs following BP
-   with any potentially-embarrasing characters that follow them.
-   Potentially-embarrassing characters are / and *
-   (because a backslash-newline inside a comment delimiter
-   would cause it not to be recognized).  */
-static void
-newline_fix (bp)
-     U_CHAR *bp;
-{
-  U_CHAR *p = bp;
-  int count = 0;
-
-  /* First count the backslash-newline pairs here.  */
-
-  while (*p++ == '\\' && *p++ == '\n')
-    count++;
-
-  p = bp + count * 2;
-
-  /* Exit if what follows the backslash-newlines is not embarrassing.  */
-
-  if (count == 0 || (*p != '/' && *p != '*'))
-    return;
-
-  /* Copy all potentially embarrassing characters
-     that follow the backslash-newline pairs
-     down to where the pairs originally started.  */
-
-  while (*p == '*' || *p == '/')
-    *bp++ = *p++;
-
-  /* Now write the same number of pairs after the embarrassing chars.  */
-  while (count-- > 0) {
-    *bp++ = '\\';
-    *bp++ = '\n';
-  }
-}
-
-/* Like newline_fix but for use within a directive-name.
-   Move any backslash-newlines up past any following symbol constituents.  */
-static void
-name_newline_fix (bp)
-     U_CHAR *bp;
-{
-  U_CHAR *p = bp;
-  int count = 0;
-
-  /* First count the backslash-newline pairs here.  */
-
-  while (*p++ == '\\' && *p++ == '\n')
-    count++;
-
-  p = bp + count * 2;
-
-  /* What follows the backslash-newlines is not embarrassing.  */
-
-  if (count == 0 || !is_idchar (*p))
-    return;
-
-  /* Copy all potentially embarrassing characters
-     that follow the backslash-newline pairs
-     down to where the pairs originally started.  */
-
-  while (is_idchar (*p))
-    *bp++ = *p++;
-
-  /* Now write the same number of pairs after the embarrassing chars.  */
-  while (count-- > 0) {
-    *bp++ = '\\';
-    *bp++ = '\n';
-  }
-}
-
-/*
- * The main loop of the program.
- *
- * Read characters from the input stack, transferring them to the
- * output buffer OP.
- *
- * Macros are expanded and push levels on the input stack.
- * At the end of such a level it is popped off and we keep reading.
- * At the end of any other kind of level, we return.
- * #-directives are handled, except within macros.
- *
- * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
- * and insert them when appropriate.  This is set while scanning macro
- * arguments before substitution.  It is zero when scanning for final output.
- *   There are three types of Newline markers:
- *   * Newline -  follows a macro name that was not expanded
- *     because it appeared inside an expansion of the same macro.
- *     This marker prevents future expansion of that identifier.
- *     When the input is rescanned into the final output, these are deleted.
- *     These are also deleted by ## concatenation.
- *   * Newline Space (or Newline and any other whitespace character)
- *     stands for a place that tokens must be separated or whitespace
- *     is otherwise desirable, but where the ANSI standard specifies there
- *     is no whitespace.  This marker turns into a Space (or whichever other
- *     whitespace char appears in the marker) in the final output,
- *     but it turns into nothing in an argument that is stringified with #.
- *     Such stringified arguments are the only place where the ANSI standard
- *     specifies with precision that whitespace may not appear.
- *
- * During this function, IP->bufp is kept cached in IBP for speed of access.
- * Likewise, OP->bufp is kept in OBP.  Before calling a subroutine
- * IBP, IP and OBP must be copied back to memory.  IP and IBP are
- * copied back with the RECACHE macro.  OBP must be copied back from OP->bufp
- * explicitly, and before RECACHE, since RECACHE uses OBP.
- */
-
-static void
-rescan (op, output_marks)
-     FILE_BUF *op;
-     int output_marks;
-{
-  /* Character being scanned in main loop.  */
-  U_CHAR c;
-
-  /* Length of pending accumulated identifier.  */
-  int ident_length = 0;
-
-  /* Hash code of pending accumulated identifier.  */
-  int hash = 0;
-
-  /* Current input level (&instack[indepth]).  */
-  FILE_BUF *ip;
-
-  /* Pointer for scanning input.  */
-  U_CHAR *ibp;
-
-  /* Pointer to end of input.  End of scan is controlled by LIMIT.  */
-  U_CHAR *limit;
-
-  /* Pointer for storing output.  */
-  U_CHAR *obp;
-
-  /* REDO_CHAR is nonzero if we are processing an identifier
-     after backing up over the terminating character.
-     Sometimes we process an identifier without backing up over
-     the terminating character, if the terminating character
-     is not special.  Backing up is done so that the terminating character
-     will be dispatched on again once the identifier is dealt with.  */
-  int redo_char = 0;
-
-  /* 1 if within an identifier inside of which a concatenation
-     marker (Newline -) has been seen.  */
-  int concatenated = 0;
-
-  /* While scanning a comment or a string constant,
-     this records the line it started on, for error messages.  */
-  int start_line;
-
-  /* Record position of last `real' newline.  */
-  U_CHAR *beg_of_line;
-
-  /* This has to be a global bacause of RECACHE.  */
-  U_CHAR *obufp_before_macroname = NULL;
-
-/* Pop the innermost input stack level, assuming it is a macro expansion.  */
-
-#define POPMACRO \
-do { ip->macro->type = T_MACRO;		\
-     if (ip->free_ptr) free (ip->free_ptr);	\
-     --indepth; } while (0)
-
-/* Reload `rescan's local variables that describe the current
-   level of the input stack.  */
-
-#define RECACHE  \
-do { ip = &instack[indepth];		\
-     ibp = ip->bufp;			\
-     limit = ip->buf + ip->length;	\
-     op->bufp = obp;			\
-     check_expand (op, limit - ibp);	\
-     beg_of_line = 0;			\
-     obufp_before_macroname += op->bufp - obp;  \
-     obp = op->bufp; } while (0)
-
-  if (no_output && instack[indepth].fname != 0)
-    skip_if_group (&instack[indepth], 1);
-
-  obp = op->bufp;
-  RECACHE;
-  beg_of_line = ibp;
-
-  /* Our caller must always put a null after the end of
-     the input at each input stack level.  */
-  if (*limit != 0)
-    abort ();
-
-  while (1) {
-    c = *ibp++;
-    *obp++ = c;
-
-    switch (c) {
-    case '\\':
-      if (ibp >= limit)
-	break;
-      if (*ibp == '\n') {
-	/* Always merge lines ending with backslash-newline,
-	   even in middle of identifier.  */
-	++ibp;
-	++ip->lineno;
-	--obp;		/* remove backslash from obuf */
-	break;
-      }
-      /* Otherwise, backslash suppresses specialness of following char,
-	 so copy it here to prevent the switch from seeing it.
-	 But first get any pending identifier processed.  */
-      if (ident_length > 0)
-	goto specialchar;
-      *obp++ = *ibp++;
-      break;
-
-    case '#':
-      /* If this is expanding a macro definition, don't recognize
-	 preprocessor directives.  */
-      if (ip->macro != 0)
-	goto randomchar;
-      if (ident_length)
-	goto specialchar;
-
-      /* # keyword: a # must be the first char on the line */
-      if (beg_of_line == 0)
-	goto randomchar;
-      if (beg_of_line + 1 != ibp)
-	goto randomchar;
-
-      /* This # can start a directive.  */
-
-      --obp;		/* Don't copy the '#' */
-
-      ip->bufp = ibp;
-      op->bufp = obp;
-      if (! handle_directive (ip, op)) {
-#ifdef USE_C_ALLOCA
-	alloca (0);
-#endif
-	/* Not a known directive: treat it as ordinary text.
-	   IP, OP, IBP, etc. have not been changed.  */
-	if (no_output && instack[indepth].fname) {
-	  /* If not generating expanded output,
-	     what we do with ordinary text is skip it.
-	     Discard everything until next # directive.  */
-	  skip_if_group (&instack[indepth], 1);
-	  RECACHE;
-	  beg_of_line = ibp;
-	  break;
-	}
-	++obp;		/* Copy the '#' after all */
-	goto randomchar;
-      }
-#ifdef USE_C_ALLOCA
-      alloca (0);
-#endif
-      /* A # directive has been successfully processed.  */
-      /* If not generating expanded output, ignore everything until
-	 next # directive.  */
-      if (no_output && instack[indepth].fname)
-	skip_if_group (&instack[indepth], 1);
-      obp = op->bufp;
-      RECACHE;
-      beg_of_line = ibp;
-      break;
-
-    case '\"':			/* skip quoted string */
-    case '\'':
-      /* A single quoted string is treated like a double -- some
-	 programs (e.g., troff) are perverse this way */
-
-      if (ident_length)
-	goto specialchar;
-
-      start_line = ip->lineno;
-
-      /* Skip ahead to a matching quote.  */
-
-      while (1) {
-	if (ibp >= limit) {
-	  if (ip->macro != 0) {
-	    /* try harder: this string crosses a macro expansion boundary */
-	    POPMACRO;
-	    RECACHE;
-	    continue;
-	  }
-	  break;
-	}
-	*obp++ = *ibp;
-	switch (*ibp++) {
-	case '\n':
-	  ++ip->lineno;
-	  ++op->lineno;
-	  /* Traditionally, end of line ends a string constant with no error.
-	     So exit the loop and record the new line.  */
-	  beg_of_line = ibp;
-	  goto while2end;
-
-	case '\\':
-	  if (ibp >= limit)
-	    break;
-	  if (*ibp == '\n') {
-	    /* Backslash newline is replaced by nothing at all,
-	       but keep the line counts correct.  */
-	    --obp;
-	    ++ibp;
-	    ++ip->lineno;
-	  } else {
-	    /* ANSI stupidly requires that in \\ the second \
-	       is *not* prevented from combining with a newline.  */
-	    while (*ibp == '\\' && ibp[1] == '\n') {
-	      ibp += 2;
-	      ++ip->lineno;
-	    }
-	    *obp++ = *ibp++;
-	  }
-	  break;
-
-	case '\"':
-	case '\'':
-	  if (ibp[-1] == c)
-	    goto while2end;
-	  break;
-	}
-      }
-    while2end:
-      break;
-
-    case '/':
-      if (*ibp == '\\' && ibp[1] == '\n')
-	newline_fix (ibp);
-      /* Don't look for comments inside a macro definition.  */
-      if (ip->macro != 0)
-	goto randomchar;
-      /* A comment constitutes white space, so it can terminate an identifier.
-	 Process the identifier, if any.  */
-      if (ident_length)
-	goto specialchar;
-
-      if (*ibp != '*')
-	goto randomchar;
-
-      /* We have a comment.  Skip it, optionally copying it to output.  */
-
-      start_line = ip->lineno;
-
-      ++ibp;			/* Skip the star. */
-
-      /* In K+R C, a comment is equivalent to nothing.  Note that we
-	  already output the slash; we might not want it.  */
-      if (! put_out_comments)
-	obp--;
-      else
-	*obp++ = '*';
-
-      {
-	U_CHAR *before_bp = ibp;
-
-	while (ibp < limit) {
-	  switch (*ibp++) {
-	  case '/':
-	    if (warn_comments && ibp < limit && *ibp == '*')
-	      warning("`/*' within comment");
-	    break;
-	  case '*':
-	    if (*ibp == '\\' && ibp[1] == '\n')
-	      newline_fix (ibp);
-	    if (ibp >= limit || *ibp == '/')
-	      goto comment_end;
-	    break;
-	  case '\n':
-	    ++ip->lineno;
-	    /* Copy the newline into the output buffer, in order to
-	       avoid the pain of a #line every time a multiline comment
-	       is seen.  */
-	    if (!put_out_comments)
-	      *obp++ = '\n';
-	    ++op->lineno;
-	  }
-	}
-      comment_end:
-
-	if (ibp >= limit)
-	  error_with_line (line_for_error (start_line),
-			   "unterminated comment");
-	else {
-	  ibp++;
-	  if (put_out_comments) {
-	    memcpy (obp, before_bp, ibp - before_bp);
-	    obp += ibp - before_bp;
-	  }
-	}
-      }
-      break;
-
-    case '0': case '1': case '2': case '3': case '4':
-    case '5': case '6': case '7': case '8': case '9':
-      /* If digit is not part of identifier, it starts a number,
-	 which means that following letters are not an identifier.
-	 "0x5" does not refer to an identifier "x5".
-	 So copy all alphanumerics that follow without accumulating
-	 as an identifier.  Periods also, for sake of "3.e7".  */
-
-      if (ident_length == 0) {
-	while (ibp < limit) {
-	  while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
-	    ++ip->lineno;
-	    ibp += 2;
-	  }
-	  c = *ibp++;
-	  if (! ISIDNUM (c) && c != '.') {
-	    --ibp;
-	    break;
-	  }
-	  *obp++ = c;
-	  /* A sign can be part of a preprocessing number
-	     if it follows an e.  */
-	  if (c == 'e' || c == 'E') {
-	    while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
-	      ++ip->lineno;
-	      ibp += 2;
-	    }
-	    if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
-	      *obp++ = *ibp++;
-	      /* Traditional C does not let the token go past the sign.  */
-	      break;
-	    }
-	  }
-	}
-	break;
-      }
-      /* fall through */
-
-    case '_':
-    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-    case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
-    case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
-    case 's': case 't': case 'u': case 'v': case 'w': case 'x':
-    case 'y': case 'z':
-    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-    case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
-    case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
-    case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
-    case 'Y': case 'Z':
-      ident_length++;
-      /* Compute step of hash function, to avoid a proc call on every token */
-      hash = HASHSTEP (hash, c);
-      break;
-
-    case '\n':
-      /* If reprocessing a macro expansion, newline is a special marker.  */
-      if (ip->macro != 0) {
-	/* Newline White is a "funny space" to separate tokens that are
-	   supposed to be separate but without space between.
-	   Here White means any horizontal whitespace character.
-	   Newline - marks a recursive macro use that is not
-	   supposed to be expandable.  */
-
-	if (*ibp == '-') {
-	  /* Newline - inhibits expansion of preceding token.
-	     If expanding a macro arg, we keep the newline -.
-	     In final output, it is deleted.  */
-	  if (! concatenated) {
-	    ident_length = 0;
-	    hash = 0;
-	  }
-	  ibp++;
-	  if (!output_marks) {
-	    obp--;
-	  } else {
-	    /* If expanding a macro arg, keep the newline -.  */
-	    *obp++ = '-';
-	  }
-	} else if (is_space (*ibp)) {
-	  /* Newline Space does not prevent expansion of preceding token
-	     so expand the preceding token and then come back.  */
-	  if (ident_length > 0)
-	    goto specialchar;
-
-	  /* If generating final output, newline space makes a space.  */
-	  if (!output_marks) {
-	    obp[-1] = *ibp++;
-	    /* And Newline Newline makes a newline, so count it.  */
-	    if (obp[-1] == '\n')
-	      op->lineno++;
-	  } else {
-	    /* If expanding a macro arg, keep the newline space.
-	       If the arg gets stringified, newline space makes nothing.  */
-	    *obp++ = *ibp++;
-	  }
-	} else abort ();	/* Newline followed by something random?  */
-	break;
-      }
-
-      /* If there is a pending identifier, handle it and come back here.  */
-      if (ident_length > 0)
-	goto specialchar;
-
-      beg_of_line = ibp;
-
-      /* Update the line counts and output a #line if necessary.  */
-      ++ip->lineno;
-      ++op->lineno;
-      if (ip->lineno != op->lineno) {
-	op->bufp = obp;
-	output_line_command (ip, op, 1, same_file);
-	check_expand (op, ip->length - (ip->bufp - ip->buf));
-	obp = op->bufp;
-      }
-      break;
-
-      /* Come here either after (1) a null character that is part of the input
-	 or (2) at the end of the input, because there is a null there.  */
-    case 0:
-      if (ibp <= limit)
-	/* Our input really contains a null character.  */
-	goto randomchar;
-
-      /* At end of a macro-expansion level, pop it and read next level.  */
-      if (ip->macro != 0) {
-	obp--;
-	ibp--;
-	/* If we have an identifier that ends here, process it now, so
-	   we get the right error for recursion.  */
-	if (ident_length && ! is_idchar (*instack[indepth - 1].bufp)) {
-	  redo_char = 1;
-	  goto randomchar;
-	}
-	POPMACRO;
-	RECACHE;
-	break;
-      }
-
-      /* If we don't have a pending identifier,
-	 return at end of input.  */
-      if (ident_length == 0) {
-	obp--;
-	ibp--;
-	op->bufp = obp;
-	ip->bufp = ibp;
-	goto ending;
-      }
-
-      /* If we do have a pending identifier, just consider this null
-	 a special character and arrange to dispatch on it again.
-	 The second time, IDENT_LENGTH will be zero so we will return.  */
-
-      /* Fall through */
-
-specialchar:
-
-      /* Handle the case of a character such as /, ', " or null
-	 seen following an identifier.  Back over it so that
-	 after the identifier is processed the special char
-	 will be dispatched on again.  */
-
-      ibp--;
-      obp--;
-      redo_char = 1;
-
-    default:
-
-randomchar:
-
-      if (ident_length > 0) {
-	HASHNODE *hp;
-
-	/* We have just seen an identifier end.  If it's a macro, expand it.
-
-	   IDENT_LENGTH is the length of the identifier
-	   and HASH is its hash code.
-
-	   The identifier has already been copied to the output,
-	   so if it is a macro we must remove it.
-
-	   If REDO_CHAR is 0, the char that terminated the identifier
-	   has been skipped in the output and the input.
-	   OBP-IDENT_LENGTH-1 points to the identifier.
-	   If the identifier is a macro, we must back over the terminator.
-
-	   If REDO_CHAR is 1, the terminating char has already been
-	   backed over.  OBP-IDENT_LENGTH points to the identifier.  */
-
-	for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
-	     hp = hp->next) {
-
-	  if (hp->length == ident_length) {
-	    /* obufp_before_macroname is used only in this block,
-               but it has to be global because of RECACHE.  */
-	    int op_lineno_before_macroname;
-	    int i = ident_length;
-	    U_CHAR *p = hp->name;
-	    U_CHAR *q = obp - i;
-
-	    if (! redo_char)
-	      q--;
-
-	    do {		/* All this to avoid a strncmp () */
-	      if (*p++ != *q++)
-		goto hashcollision;
-	    } while (--i);
-
-	    /* We found a use of a macro name.
-	       see if the context shows it is a macro call.  */
-
-	    /* Back up over terminating character if not already done.  */
-	    if (! redo_char) {
-	      ibp--;
-	      obp--;
-	    }
-
-	    obufp_before_macroname = obp - ident_length;
-	    op_lineno_before_macroname = op->lineno;
-
-	    /* If macro wants an arglist, verify that a '(' follows.
-	       first skip all whitespace, copying it to the output
-	       after the macro name.  Then, if there is no '(',
-	       decide this is not a macro call and leave things that way.  */
-	    if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
-	      {
-		while (1) {
-		  /* Scan forward over whitespace, copying it to the output.  */
-		  if (ibp == limit && ip->macro != 0) {
-		    POPMACRO;
-		    RECACHE;
-		  }
-		  /* A comment: copy it unchanged or discard it.  */
-		  else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
-		    if (put_out_comments) {
-		      *obp++ = '/';
-		      *obp++ = '*';
-		    }
-		    ibp += 2;
-		    while (ibp + 1 != limit
-			   && !(ibp[0] == '*' && ibp[1] == '/')) {
-		      /* We need not worry about newline-marks,
-			 since they are never found in comments.  */
-		      if (*ibp == '\n') {
-			/* Newline in a file.  Count it.  */
-			++ip->lineno;
-			++op->lineno;
-		      }
-		      if (put_out_comments)
-			*obp++ = *ibp++;
-		      else
-			ibp++;
-		    }
-		    ibp += 2;
-		    if (put_out_comments) {
-		      *obp++ = '*';
-		      *obp++ = '/';
-		    }
-		  }
-		  else if (is_space (*ibp)) {
-		    *obp++ = *ibp++;
-		    if (ibp[-1] == '\n') {
-		      if (ip->macro == 0) {
-			/* Newline in a file.  Count it.  */
-			++ip->lineno;
-			++op->lineno;
-		      } else if (!output_marks) {
-			/* A newline mark, and we don't want marks
-			   in the output.  If it is newline-hyphen,
-			   discard it entirely.  Otherwise, it is
-			   newline-whitechar, so keep the whitechar.  */
-			obp--;
-			if (*ibp == '-')
-			  ibp++;
-			else {
-			  if (*ibp == '\n')
-			    ++op->lineno;
-			  *obp++ = *ibp++;
-			}
-		      } else {
-			/* A newline mark; copy both chars to the output.  */
-			*obp++ = *ibp++;
-		      }
-		    }
-		  }
-		  else break;
-		}
-		if (*ibp != '(')
-		  break;
-	      }
-
-	    /* This is now known to be a macro call.
-	       Discard the macro name from the output,
-	       along with any following whitespace just copied.  */
-	    obp = obufp_before_macroname;
-	    op->lineno = op_lineno_before_macroname;
-
-	    /* Expand the macro, reading arguments as needed,
-	       and push the expansion on the input stack.  */
-	    ip->bufp = ibp;
-	    op->bufp = obp;
-	    macroexpand (hp, op);
-
-	    /* Reexamine input stack, since macroexpand has pushed
-	       a new level on it.  */
-	    obp = op->bufp;
-	    RECACHE;
-	    break;
-	  }
-hashcollision:
-	       ;
-	}			/* End hash-table-search loop */
-	ident_length = hash = 0; /* Stop collecting identifier */
-	redo_char = 0;
-	concatenated = 0;
-      }				/* End if (ident_length > 0) */
-    }				/* End switch */
-  }				/* End per-char loop */
-
-  /* Come here to return -- but first give an error message
-     if there was an unterminated successful conditional.  */
- ending:
-  if (if_stack != ip->if_stack) {
-    const char *str;
-    switch (if_stack->type) {
-    case T_IF:
-      str = "if";
-      break;
-    case T_IFDEF:
-      str = "ifdef";
-      break;
-    case T_IFNDEF:
-      str = "ifndef";
-      break;
-    case T_ELSE:
-      str = "else";
-      break;
-    case T_ELIF:
-      str = "elif";
-      break;
-    default:
-      abort ();
-    }
-    error_with_line (line_for_error (if_stack->lineno),
-		     "unterminated #%s conditional", str);
-  }
-  if_stack = ip->if_stack;
-}
-
-/*
- * Rescan a string into a temporary buffer and return the result
- * as a FILE_BUF.  Note this function returns a struct, not a pointer.
- *
- * OUTPUT_MARKS nonzero means keep Newline markers found in the input
- * and insert such markers when appropriate.  See `rescan' for details.
- * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
- * before substitution; it is 0 for other uses.
- */
-static FILE_BUF
-expand_to_temp_buffer (buf, limit, output_marks)
-     const U_CHAR *buf, *limit;
-     int output_marks;
-{
-  FILE_BUF *ip;
-  FILE_BUF obuf;
-  int length = limit - buf;
-  U_CHAR *buf1;
-  int odepth = indepth;
-
-  if (length < 0)
-    abort ();
-
-  /* Set up the input on the input stack.  */
-
-  buf1 = (U_CHAR *) alloca (length + 1);
-  {
-    const U_CHAR *p1 = buf;
-    U_CHAR *p2 = buf1;
-
-    while (p1 != limit)
-      *p2++ = *p1++;
-  }
-  buf1[length] = 0;
-
-  /* Set up to receive the output.  */
-
-  obuf.length = length * 2 + 100; /* Usually enough.  Why be stingy?  */
-  obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
-  obuf.fname = 0;
-  obuf.macro = 0;
-  obuf.free_ptr = 0;
-
-  CHECK_DEPTH ({return obuf;});
-
-  ++indepth;
-
-  ip = &instack[indepth];
-  ip->fname = 0;
-  ip->macro = 0;
-  ip->free_ptr = 0;
-  ip->length = length;
-  ip->buf = ip->bufp = buf1;
-  ip->if_stack = if_stack;
-
-  ip->lineno = obuf.lineno = 1;
-
-  /* Scan the input, create the output.  */
-
-  rescan (&obuf, output_marks);
-
-  /* Pop input stack to original state.  */
-  --indepth;
-
-  if (indepth != odepth)
-    abort ();
-
-  /* Record the output.  */
-  obuf.length = obuf.bufp - obuf.buf;
-
-  return obuf;
-}
-
-/*
- * Process a # directive.  Expects IP->bufp to point to the '#', as in
- * `#define foo bar'.  Passes to the command handler
- * (do_define, do_include, etc.): the addresses of the 1st and
- * last chars of the command (starting immediately after the #
- * keyword), plus op and the keyword table pointer.  If the command
- * contains comments it is copied into a temporary buffer sans comments
- * and the temporary buffer is passed to the command handler instead.
- * Likewise for backslash-newlines.
- *
- * Returns nonzero if this was a known # directive.
- * Otherwise, returns zero, without advancing the input pointer.
- */
-
-static int
-handle_directive (ip, op)
-     FILE_BUF *ip, *op;
-{
-  U_CHAR *bp, *cp;
-  const struct directive *kt;
-  int ident_length;
-  U_CHAR *resume_p;
-
-  /* Nonzero means we must copy the entire command
-     to get rid of comments or backslash-newlines.  */
-  int copy_command = 0;
-
-  U_CHAR *ident, *after_ident;
-
-  bp = ip->bufp;
-  /* Skip whitespace and \-newline.  */
-  while (1) {
-    if (is_nvspace (*bp))
-      bp++;
-    else if (*bp == '/' && (newline_fix (bp + 1), bp[1]) == '*') {
-      ip->bufp = bp;
-      skip_to_end_of_comment (ip, &ip->lineno);
-      bp = ip->bufp;
-    } else if (*bp == '\\' && bp[1] == '\n') {
-      bp += 2; ip->lineno++;
-    } else break;
-  }
-
-  /* Now find end of directive name.
-     If we encounter a backslash-newline, exchange it with any following
-     symbol-constituents so that we end up with a contiguous name.  */
-
-  cp = bp;
-  while (1) {
-    if (is_idchar (*cp))
-      cp++;
-    else {
-      if (*cp == '\\' && cp[1] == '\n')
-	name_newline_fix (cp);
-      if (is_idchar (*cp))
-	cp++;
-      else break;
-    }
-  }
-  ident_length = cp - bp;
-  ident = bp;
-  after_ident = cp;
-
-  /* A line of just `#' becomes blank.  */
-
-  if (ident_length == 0 && *after_ident == '\n') {
-    ip->bufp = after_ident;
-    return 1;
-  }
-
-  /*
-   * Decode the keyword and call the appropriate expansion
-   * routine, after moving the input pointer up to the next line.
-   */
-  for (kt = directive_table; kt->length > 0; kt++) {
-    if (kt->length == ident_length
-	&& !strncmp (kt->name, (const char *)ident, ident_length)) {
-      U_CHAR *buf;
-      U_CHAR *limit = ip->buf + ip->length;
-      int unterminated = 0;
-
-      /* Nonzero means do not delete comments within the directive.
-	 #define needs this to detect traditional token paste.  */
-      int keep_comments = kt->type == T_DEFINE;
-
-      /* Find the end of this command (first newline not backslashed
-	 and not in a string or comment).
-	 Set COPY_COMMAND if the command must be copied
-	 (it contains a backslash-newline or a comment).  */
-
-      buf = bp = after_ident;
-      while (bp < limit) {
-	U_CHAR c = *bp++;
-	switch (c) {
-	case '\\':
-	  if (bp < limit) {
-	    if (*bp == '\n') {
-	      ip->lineno++;
-	      copy_command = 1;
-	    }
-	    bp++;
-	  }
-	  break;
-
-	case '\'':
-	case '\"':
-	  bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, &copy_command, &unterminated);
-	  if (unterminated) {
-	    /* Traditional preprocessing permits unterminated strings.  */
-	    ip->bufp = bp;
-	    goto endloop1;
-	  }
-	  break;
-
-	  /* <...> is special for #include.  */
-	case '<':
-	  if (kt->type != T_INCLUDE)
-	    break;
-	  while (*bp && *bp != '>') bp++;
-	  break;
-
-	case '/':
-	  if (*bp == '\\' && bp[1] == '\n')
-	    newline_fix (bp);
-	  if (*bp == '*') {
-	    U_CHAR *obp = bp - 1;
-	    ip->bufp = bp + 1;
-	    skip_to_end_of_comment (ip, &ip->lineno);
-	    bp = ip->bufp;
-	    /* No need to copy the command because of a comment at the end;
-	       just don't include the comment in the directive.  */
-	    if (bp == limit || *bp == '\n') {
-	      bp = obp;
-	      goto endloop1;
-	    }
-	    /* Don't remove the comments if this is #define.  */
-	    if (! keep_comments)
-	      copy_command++;
-	  }
-	  break;
-
-	case '\n':
-	  --bp;		/* Point to the newline */
-	  ip->bufp = bp;
-	  goto endloop1;
-	}
-      }
-      ip->bufp = bp;
-
-    endloop1:
-      resume_p = ip->bufp;
-      /* BP is the end of the directive.
-	 RESUME_P is the next interesting data after the directive.
-	 A comment may come between.  */
-
-      if (copy_command) {
-	U_CHAR *xp = buf;
-	/* Need to copy entire command into temp buffer before dispatching */
-
-	cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
-						  some slop */
-	buf = cp;
-
-	/* Copy to the new buffer, deleting comments
-	   and backslash-newlines (and whitespace surrounding the latter).  */
-
-	while (xp < bp) {
-	  U_CHAR c = *xp++;
-	  *cp++ = c;
-
-	  switch (c) {
-	  case '\n':
-	    break;
-
-	    /* <...> is special for #include.  */
-	  case '<':
-	    if (kt->type != T_INCLUDE)
-	      break;
-	    while (xp < bp && c != '>') {
-	      c = *xp++;
-	      if (c == '\\' && xp < bp && *xp == '\n')
-		xp++, ip->lineno++;
-	      else
-		*cp++ = c;
-	    }
-	    break;
-
-	  case '\\':
-	    if (*xp == '\n') {
-	      xp++;
-	      cp--;
-	      if (cp != buf && is_space (cp[-1])) {
-		while (cp != buf && is_space(cp[-1])) cp--;
-		cp++;
-		SKIP_WHITE_SPACE (xp);
-	      } else if (is_nvspace (*xp)) {
-		*cp++ = *xp++;
-		SKIP_WHITE_SPACE (xp);
-	      }
-	    } else {
-	      *cp++ = *xp++;
-	    }
-	    break;
-
-	  case '\'':
-	  case '\"':
-	    {
-	      const U_CHAR *bp1
-		= skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
-	      while (xp != bp1)
-		*cp++ = *xp++;
-	    }
-	    break;
-
-	  case '/':
-	    if (*xp == '*') {
-	      ip->bufp = xp + 1;
-	      skip_to_end_of_comment (ip, 0);
-	      if (keep_comments)
-		while (xp != ip->bufp)
-		  *cp++ = *xp++;
-	      /* Delete the slash.  */
-	      else
-		cp--;
-	      xp = ip->bufp;
-	    }
-	  }
-	}
-
-	/* Null-terminate the copy.  */
-
-	*cp = 0;
-      }
-      else
-	cp = bp;
-
-      ip->bufp = resume_p;
-
-      /* Call the appropriate command handler.  buf now points to
-	 either the appropriate place in the input buffer, or to
-	 the temp buffer if it was necessary to make one.  cp
-	 points to the first char after the contents of the (possibly
-	 copied) command, in either case. */
-      (*kt->func) (buf, cp, op);
-      check_expand (op, ip->length - (ip->bufp - ip->buf));
-
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-static const char *const
-monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-
-/*
- * expand things like __FILE__.  Place the expansion into the output
- * buffer *without* rescanning.
- */
-static void
-special_symbol (hp, op)
-     HASHNODE *hp;
-     FILE_BUF *op;
-{
-  const char *buf;
-  time_t t;
-  int i, len;
-  int true_indepth;
-  FILE_BUF *ip = NULL;
-  static struct tm *timebuf = NULL;
-
-  int paren = 0;		/* For special `defined' keyword */
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-  if (ip == NULL)
-    fatal ("not in any file?!");
-
-  switch (hp->type) {
-  case T_FILE:
-  case T_BASE_FILE:
-    {
-      const char *string;
-      if (hp->type == T_FILE)
-	string = ip->fname;
-      else
-	string = instack[0].fname;
-
-      if (string)
-	{
-	  char *tmp = (char *) alloca (3 + strlen (string));
-	  sprintf (tmp, "\"%s\"", string);
-	  buf = tmp;
-	}
-      else
-	buf = "";
-
-      break;
-    }
-
-  case T_INCLUDE_LEVEL:
-    {
-      char *tmp = (char *) alloca (8);	/* Eigth bytes ought to be more than enough */
-      true_indepth = 0;
-      for (i = indepth; i >= 0; i--)
-	if (instack[i].fname != NULL)
-	  true_indepth++;
-
-    sprintf (tmp, "%d", true_indepth - 1);
-    buf = tmp;
-    break;
-    }
-
-  case T_VERSION:
-    {
-      char *tmp = (char *) alloca (3 + strlen (version_string));
-      sprintf (tmp, "\"%s\"", version_string);
-      buf = tmp;
-      break;
-    }
-
-  case T_CONST:
-    buf = hp->value.cpval;
-    break;
-
-  case T_SPECLINE:
-    {
-      char *tmp = (char *) alloca (10);
-      sprintf (tmp, "%d", ip->lineno);
-      buf = tmp;
-      break;
-    }
-
-  case T_DATE:
-  case T_TIME:
-    {
-      char *tmp = (char *) alloca (20);
-
-      if (timebuf == NULL) {
-	t = time (0);
-	timebuf = localtime (&t);
-      }
-      if (hp->type == T_DATE)
-	sprintf (tmp, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
-		 timebuf->tm_mday, timebuf->tm_year + 1900);
-      else
-	sprintf (tmp, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
-		 timebuf->tm_sec);
-      buf = tmp;
-      break;
-    }
-
-  case T_SPEC_DEFINED:
-    buf = " 0 ";			/* Assume symbol is not defined */
-    ip = &instack[indepth];
-    SKIP_WHITE_SPACE (ip->bufp);
-    if (*ip->bufp == '(') {
-      paren++;
-      ip->bufp++;			/* Skip over the paren */
-      SKIP_WHITE_SPACE (ip->bufp);
-    }
-
-    if (!is_idstart (*ip->bufp))
-      goto oops;
-    {
-      HASHNODE *hp = lookup (ip->bufp, -1, -1);
-
-      if (hp && hp->type != T_UNUSED && hp->type != T_SPEC_DEFINED)
-	buf = " 1 ";
-    }
-    while (is_idchar (*ip->bufp))
-      ++ip->bufp;
-    SKIP_WHITE_SPACE (ip->bufp);
-    if (paren) {
-      if (*ip->bufp != ')')
-	goto oops;
-      ++ip->bufp;
-    }
-    break;
-
-oops:
-
-    error ("`defined' must be followed by ident or (ident)");
-    break;
-
-  default:
-    error ("cccp error: invalid special hash type"); /* time for gdb */
-    abort ();
-  }
-  len = strlen (buf);
-  check_expand (op, len);
-  memcpy (op->bufp, buf, len);
-  op->bufp += len;
-}
-
-
-/* Routines to handle #directives */
-
-/*
- * Process include file by reading it in and calling rescan.
- * Expects to see "fname" or <fname> on the input.
- */
-static void
-do_include (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-{
-  U_CHAR *fbeg, *fend;		/* Beginning and end of fname */
-
-  struct file_name_list *stackp = include; /* Chain of dirs to search */
-  struct file_name_list dsp[1];	/* First in chain, if #include "..." */
-  int flen;
-
-  int retried = 0;		/* Have already tried macro
-				   expanding the include line*/
-  FILE_BUF trybuf;		/* It got expanded into here */
-  int system_header_p = 0;	/* 0 for "...", 1 for <...> */
-
-get_filename:
-
-  fbeg = buf;
-  SKIP_WHITE_SPACE (fbeg);
-  /* Discard trailing whitespace so we can easily see
-     if we have parsed all the significant chars we were given.  */
-  while (limit != fbeg && is_nvspace (limit[-1])) limit--;
-
-  switch (*fbeg++) {
-  case '\"':
-    fend = fbeg;
-    while (fend != limit && *fend != '\"')
-      fend++;
-    if (*fend == '\"' && fend + 1 == limit) {
-      FILE_BUF *fp;
-
-      /* We have "filename".  Figure out directory this source
-	 file is coming from and put it on the front of the list. */
-
-      /* If -I- was specified, don't search current dir, only spec'd ones. */
-      if (ignore_srcdir) break;
-
-      for (fp = &instack[indepth]; fp >= instack; fp--)
-	{
-	  size_t n;
-	  const char *ep, *nam;
-
-	  if ((nam = fp->fname) != NULL) {
-	    /* Found a named file.  Figure out dir of the file,
-	       and put it in front of the search list.  */
-	    dsp[0].next = stackp;
-	    stackp = dsp;
-	    ep = strrchr (nam, '/');
-	    if (ep != NULL) {
-	      char *f; 
-	      n = ep - nam;
-	      f = (char *) alloca (n + 1);
-	      strncpy (f, nam, n);
-	      f[n] = '\0';
-	      dsp[0].fname = f;
-	      if (n > max_include_len) max_include_len = n;
-	    } else {
-	      dsp[0].fname = 0; /* Current directory */
-	    }
-	    break;
-	  }
-	}
-      break;
-    }
-    goto fail;
-
-  case '<':
-    fend = fbeg;
-    while (fend != limit && *fend != '>') fend++;
-    if (*fend == '>' && fend + 1 == limit) {
-      system_header_p = 1;
-      /* If -I-, start with the first -I dir after the -I-.  */
-      if (first_bracket_include)
-	stackp = first_bracket_include;
-      break;
-    }
-    goto fail;
-
-  default:
-  fail:
-    if (retried) {
-      error ("#include expects \"fname\" or <fname>");
-      return;
-    } else {
-      trybuf = expand_to_temp_buffer (buf, limit, 0);
-      buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
-      memcpy (buf, trybuf.buf, trybuf.bufp - trybuf.buf);
-      limit = buf + (trybuf.bufp - trybuf.buf);
-      free (trybuf.buf);
-      retried++;
-      goto get_filename;
-    }
-  }
-
-  flen = fend - fbeg;
-  process_include (stackp, fbeg, flen, system_header_p, op);
-}
-
-static void
-do_include_next (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-{
-  U_CHAR *fbeg, *fend;		/* Beginning and end of fname */
-
-  struct file_name_list *stackp; /* Chain of dirs to search */
-  int flen;
-
-  int retried = 0;		/* Have already tried macro
-				   expanding the include line*/
-  FILE_BUF trybuf;		/* It got expanded into here */
-  int system_header_p = 0;	/* 0 for "...", 1 for <...> */
-
-  /* Treat as plain #include if we don't know where to start
-     looking.  */
-  stackp = instack[indepth].next_header_dir;
-  if (stackp == 0)
-    {
-      do_include (buf, limit, op);
-      return;
-    }
-
-get_filename:
-
-  fbeg = buf;
-  SKIP_WHITE_SPACE (fbeg);
-  /* Discard trailing whitespace so we can easily see
-     if we have parsed all the significant chars we were given.  */
-  while (limit != fbeg && is_nvspace (limit[-1])) limit--;
-
-  switch (*fbeg++) {
-  case '\"':
-    fend = fbeg;
-    while (fend != limit && *fend != '\"')
-      fend++;
-    if (*fend == '\"' && fend + 1 == limit)
-      break;
-    goto fail;
-
-  case '<':
-    fend = fbeg;
-    while (fend != limit && *fend != '>') fend++;
-    if (*fend == '>' && fend + 1 == limit) {
-      system_header_p = 1;
-      break;
-    }
-    goto fail;
-
-  default:
-  fail:
-    if (retried) {
-      error ("#include expects \"fname\" or <fname>");
-      return;
-    } else {
-      trybuf = expand_to_temp_buffer (buf, limit, 0);
-      buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
-      memcpy (buf, trybuf.buf, trybuf.bufp - trybuf.buf);
-      limit = buf + (trybuf.bufp - trybuf.buf);
-      free (trybuf.buf);
-      retried++;
-      goto get_filename;
-    }
-  }
-
-  flen = fend - fbeg;
-  process_include (stackp, fbeg, flen, system_header_p, op);
-}
-
-static void
-process_include (stackp, fbeg, flen, system_header_p, op)
-     struct file_name_list *stackp;
-     const U_CHAR *fbeg;
-     int flen;
-     int system_header_p;
-     FILE_BUF *op;
-{
-  char *fname;
-  int f = -1;			/* file number */
-
-  fname = (char *) alloca (max_include_len + flen + 2);
-  /* + 2 above for slash and terminating null.  */
-
-  /* If specified file name is absolute, just open it.  */
-
-  if (IS_ABSOLUTE_PATHNAME (fbeg)) {
-    strncpy (fname, (const char *)fbeg, flen);
-    fname[flen] = 0;
-    f = open (fname, O_RDONLY, 0666);
-  } else {
-    /* Search directory path, trying to open the file.
-       Copy each filename tried into FNAME.  */
-
-    for (; stackp; stackp = stackp->next) {
-      if (stackp->fname) {
-	strcpy (fname, stackp->fname);
-	strcat (fname, "/");
-	fname[strlen (fname) + flen] = 0;
-      } else {
-	fname[0] = 0;
-      }
-      strncat (fname, (const char *)fbeg, flen);
-      if ((f = open (fname, O_RDONLY, 0666)) >= 0)
-	break;
-    }
-  }
-
-  if (f < 0) {
-    strncpy (fname, (const char *)fbeg, flen);
-    fname[flen] = 0;
-    if (deps_missing_files
-	&& print_deps > (system_header_p || (system_include_depth > 0))) {
-
-      /* If requested as a system header, assume it belongs in
-	 the first system header directory. */
-      if (first_bracket_include)
-	stackp = first_bracket_include;
-      else
-	stackp = include;
-
-      if (!system_header_p || IS_ABSOLUTE_PATHNAME (fbeg) || !stackp->fname)
-	deps_add_dep (deps, fname);
-      else {
-	char *p;
-	int len = strlen(stackp->fname);
-
-	p = (char *) alloca (len + flen + 2);
-	memcpy (p, stackp->fname, len);
-	p[len++] = '/';
-	memcpy (p + len, fbeg, flen);
-	len += flen;
-	p[len] = '\0';
-	deps_add_dep (deps, p);
-      }
-    } else if (print_deps
-	       && print_deps <= (system_header_p
-				 || (system_include_depth > 0)))
-      warning ("no include path in which to find %.*s", flen, fbeg);
-    else
-      error_from_errno (fname);
-
-  } else {
-
-    /* Check to see if this include file is a once-only include file.
-       If so, give up.  */
-
-    struct file_name_list* ptr;
-
-    for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
-      if (!strcmp (ptr->fname, fname)) {
-	close (f);
-        return;				/* This file was once'd. */
-      }
-    }
-
-    for (ptr = all_include_files; ptr; ptr = ptr->next) {
-      if (!strcmp (ptr->fname, fname))
-        break;				/* This file was included before. */
-    }
-
-    if (ptr == 0) {
-      /* This is the first time for this file.  */
-      /* Add it to list of files included.  */
-
-      ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
-      ptr->next = all_include_files;
-      all_include_files = ptr;
-      ptr->fname = xstrdup (fname);
-
-      /* For -M, add this file to the dependencies.  */
-      if (print_deps > (system_header_p || (system_include_depth > 0)))
-	deps_add_dep (deps, fname);
-    }   
-
-    if (system_header_p)
-      system_include_depth++;
-
-    /* Actually process the file.  */
-    finclude (f, fname, stackp->next, op);
-
-    if (system_header_p)
-      system_include_depth--;
-
-    close (f);
-  }
-}
-
-/* Replace all CR NL, NL CR and CR sequences with NL.  */
-
-static void
-fixup_newlines (fp)
-     FILE_BUF *fp;
-{
-  U_CHAR *p, *q, *end;
-
-  if (fp->length <= 0)
-    return;
-
-  end = fp->buf + fp->length;
-  p = (U_CHAR *) memchr ((const char *) fp->buf, '\r', fp->length);
-  if (p == NULL)
-    return;
-
-  if (p > fp->buf && p[-1] == '\n')
-    p--;
-  q = p;
-  while (p < end)
-    switch (*p)
-      {
-      default:
-	*q++ = *p++;
-	break;
-      case '\n':
-      case '\r':
-	p += 1 + (p[0] + p[1] == '\n' + '\r');
-	*q++ = '\n';
-	break;
-      }
-
-  fp->length = q - fp->buf;
-}
-
-/* Process the contents of include file FNAME, already open on descriptor F,
-   with output to OP.  */
-
-static void
-finclude (f, fname, nhd, op)
-     int f;
-     const char *fname;
-     struct file_name_list *nhd;
-     FILE_BUF *op;
-{
-  int st_mode;
-  long st_size;
-  long i;
-  FILE_BUF *fp;			/* For input stack frame */
-
-  CHECK_DEPTH (return;);
-
-  if (file_size_and_mode (f, &st_mode, &st_size))
-    goto nope;
-
-  fp = &instack[indepth + 1];
-  memset (fp, 0, sizeof (FILE_BUF));
-  fp->fname = fname;
-  fp->length = 0;
-  fp->lineno = 1;
-  fp->if_stack = if_stack;
-  fp->next_header_dir = nhd;
-
-  if (S_ISREG (st_mode)) {
-    fp->buf = (U_CHAR *) xmalloc (st_size + 2);
-    fp->bufp = fp->buf;
-
-    /* Read the file contents, knowing that st_size is an upper bound
-       on the number of bytes we can read.  */
-    while (st_size > 0) {
-      i = read (f, fp->buf + fp->length, st_size);
-      if (i <= 0) {
-	if (i == 0) break;
-	goto nope;
-      }
-      fp->length += i;
-      st_size -= i;
-    }
-  }
-  else {
-    /* Cannot count its file size before reading.  */
-
-    U_CHAR *bufp;
-    U_CHAR *basep;
-    int bsize = 2000;
-
-    st_size = 0;
-    basep = (U_CHAR *) xmalloc (bsize + 2);
-    bufp = basep;
-
-    for (;;) {
-      i = read (f, bufp, bsize - st_size);
-      if (i < 0)
-	goto nope;      /* error! */
-      if (i == 0)
-	break;	/* End of file */
-      st_size += i;
-      bufp += i;
-      if (bsize == st_size) {	/* Buffer is full! */
-	  bsize *= 2;
-	  basep = (U_CHAR *) xrealloc (basep, bsize + 2);
-	  bufp = basep + st_size;	/* May have moved */
-	}
-    }
-    fp->buf = basep;
-    fp->bufp = fp->buf;
-    fp->length = st_size;
-  }
-  close (f);
-  fixup_newlines (fp);
-
-  /* Make sure data ends with a newline.  And put a null after it.  */
-
-  if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
-    fp->buf[fp->length++] = '\n';
-  fp->buf[fp->length] = '\0';
-
-  indepth++;
-  output_line_command (fp, op, 0, enter_file);
-  rescan (op, 0);
-  indepth--;
-  instack[indepth].lineno++;
-  instack[indepth].bufp++;	/* Skip the new line.  */
-  output_line_command (&instack[indepth], op, 0, leave_file);
-  free (fp->buf);
-  return;
-
-nope:
-  perror_with_name (fname);
-  close (f);
-}
-
-
-/* Process a #define command.
-BUF points to the contents of the #define command, as a continguous string.
-LIMIT points to the first character past the end of the definition.
-KEYWORD is the keyword-table entry for #define.  */
-
-static void
-do_define (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  U_CHAR *bp;			/* temp ptr into input buffer */
-  U_CHAR *symname;		/* remember where symbol name starts */
-  int sym_length;		/* and how long it is */
-
-  DEFINITION *defn;
-  int arglengths = 0;		/* Accumulate lengths of arg names
-				   plus number of args.  */
-  int hashcode;
-
-  bp = buf;
-
-  while (is_nvspace (*bp))
-    bp++;
-
-  symname = bp;			/* remember where it starts */
-  while (is_idchar (*bp) && bp < limit) {
-    bp++;
-  }
-  sym_length = bp - symname;
-  if (sym_length == 0)
-    {
-      error ("invalid macro name");
-      return;
-    }
-  else if (!is_idstart (*symname)) {
-    U_CHAR *msg;			/* what pain... */
-    msg = (U_CHAR *) alloca (sym_length + 1);
-    memcpy (msg, symname, sym_length);
-    msg[sym_length] = 0;
-    error ("invalid macro name `%s'", msg);
-    return;
-  } else {
-    if (! strncmp ((const char *)symname, "defined", 7) && sym_length == 7)
-      {
-	error ("\"defined\" cannot be used as a macro name");
-	return;
-      }
-  }
-
-  /* lossage will occur if identifiers or control keywords are broken
-     across lines using backslash.  This is not the right place to take
-     care of that. */
-
-  if (*bp == '(') {
-    struct arglist *arg_ptrs = NULL;
-    int argno = 0;
-
-    bp++;			/* skip '(' */
-    SKIP_WHITE_SPACE (bp);
-
-    /* Loop over macro argument names.  */
-    while (*bp != ')') {
-      struct arglist *temp;
-
-      temp = (struct arglist *) alloca (sizeof (struct arglist));
-      temp->name = bp;
-      temp->next = arg_ptrs;
-      temp->argno = argno++;
-      arg_ptrs = temp;
-
-      if (!is_idstart (*bp))
-	warning ("parameter name starts with a digit in #define");
-
-      /* Find the end of the arg name.  */
-      while (is_idchar (*bp)) {
-	bp++;
-      }
-      temp->length = bp - temp->name;
-      arglengths += temp->length + 2;
-      SKIP_WHITE_SPACE (bp);
-      if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
-	error ("badly punctuated parameter list in #define");
-	return;
-      }
-      if (*bp == ',') {
-	bp++;
-	SKIP_WHITE_SPACE (bp);
-      }
-      if (bp >= limit) {
-	error ("unterminated parameter list in #define");
-	return;
-      }
-    }
-
-    ++bp;					/* skip paren */
-    while (is_nvspace (*bp) && bp < limit)	/* and leading whitespace */
-      ++bp;
-    /* now everything from bp before limit is the definition. */
-    defn = collect_expansion (bp, limit, argno, arg_ptrs);
-
-    /* Now set defn->argnames to the result of concatenating
-       the argument names in reverse order
-       with comma-space between them.  */
-    {
-      struct arglist *temp;
-      int i = 0;
-      U_CHAR *tmp = (U_CHAR *) xmalloc (arglengths + 1);
-
-      for (temp = arg_ptrs; temp; temp = temp->next) {
-	memcpy (&tmp[i], temp->name, temp->length);
-	i += temp->length;
-	if (temp->next != 0) {
-	  tmp[i++] = ',';
-	  tmp[i++] = ' ';
-	}
-      }
-      tmp[i] = 0;
-      defn->argnames = tmp;
-      
-    }
-  } else {
-    /* simple expansion or empty definition; skip leading whitespace */
-    while (is_nvspace (*bp) && bp < limit)
-      ++bp;
-    /* now everything from bp before limit is the definition. */
-    defn = collect_expansion (bp, limit, -1, 0);
-    defn->argnames = (const U_CHAR *) "";
-  }
-
-  hashcode = hashf (symname, sym_length, HASHSIZE);
-
-  {
-    HASHNODE *hp;
-    if ((hp = lookup (symname, sym_length, hashcode)) == NULL)
-      hp = install (symname, sym_length, T_MACRO, hashcode);
-    else {
-      if (hp->type != T_MACRO || compare_defs (defn, hp->value.defn))
-	warning ("\"%.*s\" redefined", sym_length, symname);
-
-      /* Replace the old definition.  */
-      hp->type = T_MACRO;
-    }
-
-    hp->value.defn = defn;
-  }
-}
-
-/*
- * return zero if two DEFINITIONs are isomorphic
- */
-static int
-compare_defs (d1, d2)
-     DEFINITION *d1, *d2;
-{
-  struct reflist *a1, *a2;
-  U_CHAR *p1 = d1->expansion;
-  U_CHAR *p2 = d2->expansion;
-  int first = 1;
-
-  if (d1->nargs != d2->nargs)
-    return 1;
-  if (strcmp ((const char *)d1->argnames, (const char *)d2->argnames))
-    return 1;
-  for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
-       a1 = a1->next, a2 = a2->next) {
-    if (!((a1->nchars == a2->nchars
-	   && ! strncmp ((const char *)p1, (const char *)p2, a1->nchars))
-	  || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
-	|| a1->argno != a2->argno
-	|| a1->stringify != a2->stringify
-	|| a1->raw_before != a2->raw_before
-	|| a1->raw_after != a2->raw_after)
-      return 1;
-    first = 0;
-    p1 += a1->nchars;
-    p2 += a2->nchars;
-  }
-  if (a1 != a2)
-    return 1;
-  if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
-		     p2, d2->length - (p2 - d2->expansion), 1))
-    return 1;
-  return 0;
-}
-
-/* Return 1 if two parts of two macro definitions are effectively different.
-   One of the parts starts at BEG1 and has LEN1 chars;
-   the other has LEN2 chars at BEG2.
-   Any sequence of whitespace matches any other sequence of whitespace.
-   FIRST means these parts are the first of a macro definition;
-    so ignore leading whitespace entirely.
-   LAST means these parts are the last of a macro definition;
-    so ignore trailing whitespace entirely.  */
-static int
-comp_def_part (first, beg1, len1, beg2, len2, last)
-     int first;
-     const U_CHAR *beg1, *beg2;
-     int len1, len2;
-     int last;
-{
-  const U_CHAR *end1 = beg1 + len1;
-  const U_CHAR *end2 = beg2 + len2;
-  if (first) {
-    while (beg1 != end1 && is_space (*beg1)) beg1++;
-    while (beg2 != end2 && is_space (*beg2)) beg2++;
-  }
-  if (last) {
-    while (beg1 != end1 && is_space (end1[-1])) end1--;
-    while (beg2 != end2 && is_space (end2[-1])) end2--;
-  }
-  while (beg1 != end1 && beg2 != end2) {
-    if (is_space (*beg1) && is_space (*beg2)) {
-      while (beg1 != end1 && is_space (*beg1)) beg1++;
-      while (beg2 != end2 && is_space (*beg2)) beg2++;
-    } else if (*beg1 == *beg2) {
-      beg1++; beg2++;
-    } else break;
-  }
-  return (beg1 != end1) || (beg2 != end2);
-}
-
-/* Read a replacement list for a macro with parameters.
-   Build the DEFINITION structure.
-   Reads characters of text starting at BUF until LIMIT.
-   ARGLIST specifies the formal parameters to look for
-   in the text of the definition; NARGS is the number of args
-   in that list, or -1 for a macro name that wants no argument list.
-   MACRONAME is the macro name itself (so we can avoid recursive expansion)
-   and NAMELEN is its length in characters.
-   
-Note that comments and backslash-newlines have already been deleted
-from the argument.  */
-
-/* Leading and trailing Space, Tab, etc. are converted to markers
-   Newline Space, Newline Tab, etc.
-   Newline Space makes a space in the final output
-   but is discarded if stringified.  (Newline Tab is similar but
-   makes a Tab instead.)
-
-   If there is no trailing whitespace, a Newline Space is added at the end
-   to prevent concatenation that would be contrary to the standard.  */
-
-static DEFINITION *
-collect_expansion (buf, end, nargs, arglist)
-     U_CHAR *buf, *end;
-     int nargs;
-     struct arglist *arglist;
-{
-  DEFINITION *defn;
-  U_CHAR *p, *limit, *lastp, *exp_p;
-  struct reflist *endpat = NULL;
-  /* Pointer to first nonspace after last ## seen.  */
-  U_CHAR *concat = 0;
-  /* Pointer to first nonspace after last single-# seen.  */
-  U_CHAR *stringify = 0;
-  int maxsize;
-  int expected_delimiter = '\0';
-
-  /* Scan thru the replacement list, ignoring comments and quoted
-     strings, picking up on the macro calls.  It does a linear search
-     thru the arg list on every potential symbol.  Profiling might say
-     that something smarter should happen. */
-
-  if (end < buf)
-    abort ();
-
-  /* Find the beginning of the trailing whitespace.  */
-  /* Find end of leading whitespace.  */
-  limit = end;
-  p = buf;
-  while (p < limit && is_space (limit[-1])) limit--;
-  while (p < limit && is_space (*p)) p++;
-
-  /* Allocate space for the text in the macro definition.
-     Leading and trailing whitespace chars need 2 bytes each.
-     Each other input char may or may not need 1 byte,
-     so this is an upper bound.
-     The extra 2 are for invented trailing newline-marker and final null.  */
-  maxsize = (sizeof (DEFINITION)
-	     + 2 * (end - limit) + 2 * (p - buf)
-	     + (limit - p) + 3);
-  defn = (DEFINITION *) xcalloc (1, maxsize);
-
-  defn->nargs = nargs;
-  exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
-  lastp = exp_p;
-
-  p = buf;
-
-  /* Convert leading whitespace to Newline-markers.  */
-  while (p < limit && is_space (*p)) {
-    *exp_p++ = '\n';
-    *exp_p++ = *p++;
-  }
-
-  /* Process the main body of the definition.  */
-  while (p < limit) {
-    int skipped_arg = 0;
-    U_CHAR c = *p++;
-
-    *exp_p++ = c;
-
-    /* In -traditional mode, recognize arguments inside strings and
-       and character constants, and ignore special properties of #.
-       Arguments inside strings are considered "stringified", but no
-       extra quote marks are supplied.  */
-    switch (c) {
-    case '\'':
-    case '\"':
-      if (expected_delimiter != '\0') {
-	if (c == expected_delimiter)
-	  expected_delimiter = '\0';
-      } else
-	expected_delimiter = c;
-      break;
-
-    case '\\':
-      /* Backslash quotes delimiters and itself, but not macro args.  */
-      if (expected_delimiter != 0 && p < limit
-	  && (*p == expected_delimiter || *p == '\\')) {
-	*exp_p++ = *p++;
-	continue;
-      }
-      break;
-
-    case '/':
-      if (expected_delimiter != '\0') /* No comments inside strings.  */
-	break;
-      if (*p == '*') {
-	/* If we find a comment that wasn't removed by handle_directive,
-	   this must be -traditional.  So replace the comment with
-	   nothing at all.  */
-	exp_p--;
-	p += 1;
-	while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
-	  p++;
-      }
-      break;
-    }
-
-    if (is_idchar (c) && nargs > 0) {
-      U_CHAR *id_beg = p - 1;
-      int id_len;
-
-      --exp_p;
-      while (p != limit && is_idchar (*p)) p++;
-      id_len = p - id_beg;
-
-      if (is_idstart (c)) {
-	struct arglist *arg;
-
-	for (arg = arglist; arg != NULL; arg = arg->next) {
-	  struct reflist *tpat;
-
-	  if (arg->name[0] == c
-	      && arg->length == id_len
-	      && strncmp ((const char *)arg->name,
-			  (const char *)id_beg, id_len) == 0) {
-	    /* make a pat node for this arg and append it to the end of
-	       the pat list */
-	    tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
-	    tpat->next = NULL;
-	    tpat->raw_before = concat == id_beg;
-	    tpat->raw_after = 0;
-	    tpat->stringify = expected_delimiter != '\0';
-
-	    if (endpat == NULL)
-	      defn->pattern = tpat;
-	    else
-	      endpat->next = tpat;
-	    endpat = tpat;
-
-	    tpat->argno = arg->argno;
-	    tpat->nchars = exp_p - lastp;
-	    {
-	      U_CHAR *p1 = p;
-	      SKIP_WHITE_SPACE (p1);
-	      if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
-		tpat->raw_after = 1;
-	    }
-	    lastp = exp_p;	/* place to start copying from next time */
-	    skipped_arg = 1;
-	    break;
-	  }
-	}
-      }
-
-      /* If this was not a macro arg, copy it into the expansion.  */
-      if (! skipped_arg) {
-	U_CHAR *lim1 = p;
-	p = id_beg;
-	while (p != lim1)
-	  *exp_p++ = *p++;
-	if (stringify == id_beg)
-	  error ("# operator should be followed by a macro argument name");
-      }
-    }
-  }
-
-  if (limit < end) {
-    /* Convert trailing whitespace to Newline-markers.  */
-    while (limit < end && is_space (*limit)) {
-      *exp_p++ = '\n';
-      *exp_p++ = *limit++;
-    }
-  }
-  *exp_p = '\0';
-
-  defn->length = exp_p - defn->expansion;
-
-  /* Crash now if we overrun the allocated size.  */
-  if (defn->length + 1 > maxsize)
-    abort ();
-
-  return defn;
-}
-
-/*
- * interpret #line command.  Remembers previously seen fnames
- * in its very own hash table.
- */
-#define FNAME_HASHSIZE 37
-static void
-do_line (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-{
-  U_CHAR *bp;
-  FILE_BUF *ip = &instack[indepth];
-  FILE_BUF tem;
-  int new_lineno;
-  enum file_change_code file_change = same_file;
-
-  /* Expand any macros.  */
-  tem = expand_to_temp_buffer (buf, limit, 0);
-
-  /* Point to macroexpanded line, which is null-terminated now.  */
-  bp = tem.buf;
-  SKIP_WHITE_SPACE (bp);
-
-  if (!ISDIGIT (*bp)) {
-    error ("invalid format #line command");
-    return;
-  }
-
-  /* The Newline at the end of this line remains to be processed.
-     To put the next line at the specified line number,
-     we must store a line number now that is one less.  */
-  new_lineno = atoi ((const char *)bp);
-
-  /* skip over the line number.  */
-  while (ISDIGIT (*bp))
-    bp++;
-
-  SKIP_WHITE_SPACE (bp);
-
-  if (*bp == '\"') {
-    static HASHNODE *fname_table[FNAME_HASHSIZE];
-    HASHNODE *hp, **hash_bucket;
-    U_CHAR *fname;
-    int fname_length;
-
-    fname = ++bp;
-
-    while (*bp && *bp != '\"')
-      bp++;
-    if (*bp != '\"') {
-      error ("invalid format #line command");
-      return;
-    }
-
-    fname_length = bp - fname;
-
-    bp++;
-    SKIP_WHITE_SPACE (bp);
-    if (*bp) {
-      if (*bp == '1')
-	file_change = enter_file;
-      else if (*bp == '2')
-	file_change = leave_file;
-      else {
-	error ("invalid format #line command");
-	return;
-      }
-
-      bp++;
-      SKIP_WHITE_SPACE (bp);
-      if (*bp) {
-	error ("invalid format #line command");
-	return;
-      }
-    }
-
-    hash_bucket =
-      &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
-    for (hp = *hash_bucket; hp != NULL; hp = hp->next)
-      if (hp->length == fname_length &&
-	  strncmp (hp->value.cpval, (const char *)fname, fname_length) == 0) {
-	ip->fname = hp->value.cpval;
-	break;
-      }
-    if (hp == 0) {
-      char *q;
-      /* Didn't find it; cons up a new one.  */
-      hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
-      hp->next = *hash_bucket;
-      *hash_bucket = hp;
-
-      hp->length = fname_length;
-      ip->fname = hp->value.cpval = q = ((char *) hp) + sizeof (HASHNODE);
-      memcpy (q, fname, fname_length);
-    }
-  } else if (*bp) {
-    error ("invalid format #line command");
-    return;
-  }
-
-  ip->lineno = new_lineno;
-  output_line_command (ip, op, 0, file_change);
-  ip->bufp++;			/* Skip the new line.  */
-  check_expand (op, ip->length - (ip->bufp - ip->buf));
-}
-
-/*
- * remove all definitions of symbol from symbol table.
- * according to un*x /lib/cpp, it is not an error to undef
- * something that has no definitions, so it isn't one here either.
- */
-static void
-do_undef (buf, limit, op)
-     U_CHAR *buf;
-     U_CHAR *limit ATTRIBUTE_UNUSED;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  HASHNODE *hp;
-
-  SKIP_WHITE_SPACE (buf);
-
-  if (! strncmp ((const char *)buf, "defined", 7) && ! is_idchar (buf[7]))
-    warning ("undefining `defined'");
-
-  while ((hp = lookup (buf, -1, -1)) != NULL) {
-    if (hp->type != T_MACRO)
-      warning ("undefining `%s'", hp->name);
-    delete_macro (hp);
-  }
-}
-
-/* Read the tokens of the answer into the macro pool.  Only commit the
-   memory if we intend it as permanent storage, i.e. the #assert case.
-   Returns 0 on success.  */
-
-static int
-parse_answer (buf, limit, answerp, type)
-     const unsigned char *buf, *limit;
-     struct answer **answerp;
-     int type;
-{
-  const unsigned char *start;
-
-  /* Skip leading whitespace.  */
-  if (buf < limit && *buf == ' ')
-    buf++;
-
-  /* Parentheses are optional here.  */
-  if (buf == limit && type == T_UNASSERT)
-    return 0;
-
-  if (buf == limit || *buf++ != '(')
-    {
-      if (type == T_IF)
-	return 0;
-
-      error ("missing '(' after predicate");
-      return 1;
-    }
-
-  /* Drop whitespace at start.  */
-  while (buf < limit && *buf == ' ')
-    buf++;
-
-  start = buf;
-  while (buf < limit && *buf != ')')
-    buf++;
-
-  if (buf == limit)
-    {
-      error ("missing ')' to complete answer");
-      return 1;
-    }
-
-  if (buf == start)
-    {
-      error ("predicate's answer is empty");
-      return 1;
-    }
-
-  if ((type == T_ASSERT || type == T_UNASSERT) && buf + 1 != limit)
-    {
-      error ("extra text at end of directive");
-      return 1;
-    }
-
-  /* Lose trailing whitespace.  */
-  if (buf[-1] == ' ')
-    buf--;
-
-  *answerp = (struct answer *) xmalloc (sizeof (struct answer));
-  (*answerp)->answer = start;
-  (*answerp)->len = buf - start;
-
-  return 0;
-}
-
-/* Parses an assertion, returning a pointer to the hash node of the
-   predicate, or 0 on error.  If an answer was supplied, it is placed
-   in ANSWERP, otherwise it is set to 0.  */
-static HASHNODE *
-parse_assertion (buf, limit, answerp, type)
-     const unsigned char *buf, *limit;
-     struct answer **answerp;
-     int type;
-{
-  HASHNODE *result = 0;
-  const unsigned char *climit;
-  unsigned char *bp, *symname = canonicalize_text (buf, limit, &climit);
-  unsigned int len;
-
-  bp = symname;
-  if (bp < climit && is_idstart (*bp))
-    {
-      do
-	bp++;
-      while (bp < climit && is_idchar (*bp));
-    }
-  len = bp - symname;
-
-  *answerp = 0;
-  if (len == 0)
-    {
-      if (symname == climit)
-	error ("assertion without predicate");
-      else
-	error ("predicate must be an identifier");
-    }
-  /* Unfortunately, because of the way we handle #if, we don't avoid
-     macro expansion in answers.  This is not easy to fix.  */
-  else if (parse_answer (bp, climit, answerp, type) == 0)
-    {
-      unsigned char *sym = alloca (len + 1);
-      int hashcode;
-      
-      /* Prefix '#' to get it out of macro namespace.  */
-      sym[0] = '#';
-      memcpy (sym + 1, symname, len);
-
-      hashcode = hashf (sym, len + 1, HASHSIZE);
-      result = lookup (sym, len + 1, hashcode);
-      if (result == 0)
-	result = install (sym, len + 1, T_UNUSED, hashcode);
-    }
-
-  return result;
-}
-
-/* Test an assertion within a preprocessor conditional.  Returns zero
-   on error or failure, one on success.  */
-int
-test_assertion (pbuf)
-     unsigned char **pbuf;	/* NUL-terminated.  */
-{
-  unsigned char *buf = *pbuf;
-  unsigned char *limit = buf + strlen ((char *) buf);
-  struct answer *answer;
-  HASHNODE *node;
-  int result = 0;
-
-  node = parse_assertion (buf, limit, &answer, T_IF);
-  if (node)
-    {
-      result = (node->type == T_ASSERT &&
-		(answer == 0 || *find_answer (node, answer) != 0));
-
-      /* Yuk.  We update pbuf to point after the assertion test.
-	 First, move past the identifier.  */
-      if (is_space (*buf))
-	buf++;
-      while (is_idchar (*buf))
-	buf++;
-      /* If we have an answer, we need to move past the parentheses.  */
-      if (answer)
-	while (*buf++ != ')')
-	  ;
-      *pbuf = buf;
-    }
-
-  return result;
-}
-
-/* Handle a #error directive.  */
-static void
-do_error (buf, limit, op)
-     U_CHAR *buf;
-     U_CHAR *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  error ("#error%.*s", (int) (limit - buf), buf);
-}
-
-/* Handle a #warning directive.  */
-static void
-do_warning (buf, limit, op)
-     U_CHAR *buf;
-     U_CHAR *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  warning ("#warning%.*s", (int) (limit - buf), buf);
-}
-
-/* Handle a #assert directive.  */
-static void
-do_assert (buf, limit, op)
-     U_CHAR *buf;
-     U_CHAR *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  struct answer *new_answer;
-  HASHNODE *node;
-  
-  node = parse_assertion (buf, limit, &new_answer, T_ASSERT);
-  if (node)
-    {
-      /* Place the new answer in the answer list.  First check there
-         is not a duplicate.  */
-      new_answer->next = 0;
-      if (node->type == T_ASSERT)
-	{
-	  if (*find_answer (node, new_answer))
-	    {
-	      free (new_answer);
-	      warning ("\"%s\" re-asserted", node->name + 1);
-	      return;
-	    }
-	  new_answer->next = node->value.answers;
-	}
-      node->type = T_ASSERT;
-      node->value.answers = new_answer;
-    }
-}
-
-/* Function body to be provided later.  */
-static void
-do_unassert (buf, limit, op)
-     U_CHAR *buf;
-     U_CHAR *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  HASHNODE *node;
-  struct answer *answer;
-  
-  node = parse_assertion (buf, limit, &answer, T_UNASSERT);
-  /* It isn't an error to #unassert something that isn't asserted.  */
-  if (node)
-    {
-      if (node->type == T_ASSERT)
-	{
-	  if (answer)
-	    {
-	      struct answer **p = find_answer (node, answer), *temp;
-
-	      /* Remove the answer from the list.  */
-	      temp = *p;
-	      if (temp)
-		*p = temp->next;
-
-	      /* Did we free the last answer?  */
-	      if (node->value.answers == 0)
-		delete_macro (node);
-	    }
-	  else
-	    delete_macro (node);
-	}
-
-      free (answer);
-    }
-}
-
-/* Returns a pointer to the pointer to the answer in the answer chain,
-   or a pointer to NULL if the answer is not in the chain.  */
-static struct answer **
-find_answer (node, candidate)
-     HASHNODE *node;
-     const struct answer *candidate;
-{
-  struct answer **result;
-
-  for (result = &node->value.answers; *result; result = &(*result)->next)
-    {
-      struct answer *answer = *result;
-
-      if (answer->len == candidate->len
-	  && !memcmp (answer->answer, candidate->answer, answer->len))
-	break;
-    }
-
-  return result;
-}
-
-/* Return a malloced buffer with leading and trailing whitespace
-   removed, and all instances of internal whitespace reduced to a
-   single space.  */
-static unsigned char *
-canonicalize_text (buf, limit, climit)
-     const unsigned char *buf, *limit, **climit;
-{
-  unsigned int len = limit - buf;
-  unsigned char *result = (unsigned char *) xmalloc (len), *dest;
-
-  for (dest = result; buf < limit;)
-    {
-      if (! is_space (*buf))
-	*dest++ = *buf++;
-      else
-	{
-	  while (++buf < limit && is_space (*buf))
-	    ;
-	  if (dest != result && buf != limit)
-	    *dest++ = ' ';
-	}
-    }
-
-  *climit = dest;
-  return result;
-}
-
-/*
- * handle #if command by
- *   1) inserting special `defined' keyword into the hash table
- *	that gets turned into 0 or 1 by special_symbol (thus,
- *	if the luser has a symbol called `defined' already, it won't
- *      work inside the #if command)
- *   2) rescan the input into a temporary output buffer
- *   3) pass the output buffer to the yacc parser and collect a value
- *   4) clean up the mess left from steps 1 and 2.
- *   5) call conditional_skip to skip til the next #endif (etc.),
- *      or not, depending on the value from step 3.
- */
-static void
-do_if (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  int value;
-  FILE_BUF *ip = &instack[indepth];
-
-  value = eval_if_expression (buf, limit - buf);
-  conditional_skip (ip, value == 0, T_IF);
-}
-
-/*
- * handle a #elif directive by not changing  if_stack  either.
- * see the comment above do_else.
- */
-static void
-do_elif (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-{
-  int value;
-  FILE_BUF *ip = &instack[indepth];
-
-  if (if_stack == instack[indepth].if_stack) {
-    error ("#elif not within a conditional");
-    return;
-  } else {
-    if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
-      error ("#elif after #else");
-      fprintf (stderr, " (matches line %d", if_stack->lineno);
-      if (if_stack->fname != NULL && ip->fname != NULL &&
-	  strcmp (if_stack->fname, ip->fname) != 0)
-	fprintf (stderr, ", file %s", if_stack->fname);
-      fprintf (stderr, ")\n");
-    }
-    if_stack->type = T_ELIF;
-  }
-
-  if (if_stack->if_succeeded)
-    skip_if_group (ip, 0);
-  else {
-    value = eval_if_expression (buf, limit - buf);
-    if (value == 0)
-      skip_if_group (ip, 0);
-    else {
-      ++if_stack->if_succeeded;	/* continue processing input */
-      output_line_command (ip, op, 1, same_file);
-    }
-  }
-}
-
-/*
- * evaluate a #if expression in BUF, of length LENGTH,
- * then parse the result as a C expression and return the value as an int.
- */
-static int
-eval_if_expression (buf, length)
-     const U_CHAR *buf;
-     int length;
-{
-  FILE_BUF temp_obuf;
-  HASHNODE *save_defined;
-  int value;
-
-  save_defined = install (U"defined", -1, T_SPEC_DEFINED, -1);
-  temp_obuf = expand_to_temp_buffer (buf, buf + length, 0);
-  delete_macro (save_defined);	/* clean up special symbol */
-
-  value = parse_c_expression ((const char *)temp_obuf.buf);
-
-  free (temp_obuf.buf);
-
-  return value;
-}
-
-/*
- * routine to handle ifdef/ifndef.  Try to look up the symbol,
- * then do or don't skip to the #endif/#else/#elif depending
- * on what directive is actually being processed.
- */
-static void
-do_xifdef (buf, limit, type)
-     U_CHAR *buf, *limit;
-     enum node_type type;     
-{
-  int skip;
-  FILE_BUF *ip = &instack[indepth];
-  U_CHAR *end; 
-
-  /* Discard leading and trailing whitespace.  */
-  SKIP_WHITE_SPACE (buf);
-  while (limit != buf && is_nvspace (limit[-1])) limit--;
-
-  /* Find the end of the identifier at the beginning.  */
-  for (end = buf; is_idchar (*end); end++);
-
-  if (end == buf)
-    skip = (type == T_IFDEF);
-  else
-    skip = (lookup (buf, end-buf, -1) == NULL) ^ (type == T_IFNDEF);
-
-  conditional_skip (ip, skip, T_IF);
-}
-
-static void
-do_ifdef (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  do_xifdef (buf, limit, T_IFDEF);
-}
-
-static void
-do_ifndef (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op ATTRIBUTE_UNUSED;
-{
-  do_xifdef (buf, limit, T_IFNDEF);
-}
-
-/*
- * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
- */
-static void
-conditional_skip (ip, skip, type)
-     FILE_BUF *ip;
-     int skip;
-     enum node_type type;
-{
-  IF_STACK_FRAME *temp;
-
-  temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
-  temp->fname = ip->fname;
-  temp->lineno = ip->lineno;
-  temp->next = if_stack;
-  if_stack = temp;
-
-  if_stack->type = type;
-
-  if (skip != 0) {
-    skip_if_group (ip, 0);
-    return;
-  } else {
-    ++if_stack->if_succeeded;
-    output_line_command (ip, &outbuf, 1, same_file);
-  }
-}
-
-/*
- * skip to #endif, #else, or #elif.  adjust line numbers, etc.
- * leaves input ptr at the sharp sign found.
- * If ANY is nonzero, return at next directive of any sort.
- */
-static void
-skip_if_group (ip, any)
-     FILE_BUF *ip;
-     int any;
-{
-  U_CHAR *bp = ip->bufp, *cp;
-  U_CHAR *endb = ip->buf + ip->length;
-  const struct directive *kt;
-  IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
-  U_CHAR *beg_of_line = bp;
-
-  while (bp < endb) {
-    switch (*bp++) {
-    case '/':			/* possible comment */
-      if (*bp == '\\' && bp[1] == '\n')
-	newline_fix (bp);
-      if (*bp == '*') {
-	ip->bufp = ++bp;
-	bp = skip_to_end_of_comment (ip, &ip->lineno);
-      }
-      break;
-    case '\"':
-    case '\'':
-      bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, 0, 0);
-      break;
-    case '\\':
-      /* Char after backslash loses its special meaning.  */
-      if (bp < endb) {
-	if (*bp == '\n')
-	  ++ip->lineno;		/* But do update the line-count.  */
-	bp++;
-      }
-      break;
-    case '\n':
-      ++ip->lineno;
-      beg_of_line = bp;
-      break;
-    case '#':
-      ip->bufp = bp - 1;
-
-      /* # keyword: a # must be first nonblank char on the line */
-      if (beg_of_line == 0)
-	break;
-      /* Scan from start of line, skipping whitespace, comments
-	 and backslash-newlines, and see if we reach this #.
-	 If not, this # is not special.  */
-      bp = beg_of_line;
-      while (1) {
-	if (is_nvspace (*bp))
-	  bp++;
-	else if (*bp == '\\' && bp[1] == '\n')
-	  bp += 2;
-	else if (*bp == '/' && bp[1] == '*') {
-	  bp += 2;
-	  while (!(*bp == '*' && bp[1] == '/')) {
-	    if (*bp == '\n')
-	      ip->lineno++;
-	    bp++;
-	  }
-	  bp += 2;
-	}
-	else break;
-      }
-      if (bp != ip->bufp) {
-	bp = ip->bufp + 1;	/* Reset bp to after the #.  */
-	break;
-      }
-
-      bp = ip->bufp + 1;	/* Point after '#'.  */
-
-      /* Skip whitespace and \-newline.  */
-      while (1) {
-	if (is_nvspace (*bp))
-	  bp++;
-	else if (*bp == '\\' && bp[1] == '\n')
-	  bp += 2;
-	else if (*bp == '/' && bp[1] == '*') {
-	  bp += 2;
-	  while (!(*bp == '*' && bp[1] == '/'))
-	    bp++;
-	  bp += 2;
-	}
-	else break;
-      }
-
-      cp = bp;
-
-      /* Now find end of directive name.
-	 If we encounter a backslash-newline, exchange it with any following
-	 symbol-constituents so that we end up with a contiguous name.  */
-
-      while (1) {
-	if (is_idchar (*bp))
-	  bp++;
-	else {
-	  if (*bp == '\\' && bp[1] == '\n')
-	    name_newline_fix (bp);
-	  if (is_idchar (*bp))
-	    bp++;
-	  else break;
-	}
-      }
-
-      for (kt = directive_table; kt->length >= 0; kt++) {
-	IF_STACK_FRAME *temp;
-	if (strncmp ((const char *)cp, kt->name, kt->length) == 0
-	    && !is_idchar (cp[kt->length])) {
-
-	  /* If we are asked to return on next directive,
-	     do so now.  */
-	  if (any)
-	    return;
-
-	  switch (kt->type) {
-	  case T_IF:
-	  case T_IFDEF:
-	  case T_IFNDEF:
-	    temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
-	    temp->next = if_stack;
-	    if_stack = temp;
-	    temp->lineno = ip->lineno;
-	    temp->fname = ip->fname;
-	    temp->type = kt->type;
-	    break;
-	  case T_ELSE:
-	  case T_ENDIF:
-	  case T_ELIF:
-	    if (if_stack == instack[indepth].if_stack) {
-	      error ("#%s not within a conditional", kt->name);
-	      break;
-	    }
-	    else if (if_stack == save_if_stack)
-	      return;		/* found what we came for */
-
-	    if (kt->type != T_ENDIF) {
-	      if (if_stack->type == T_ELSE)
-		error ("#else or #elif after #else");
-	      if_stack->type = kt->type;
-	      break;
-	    }
-
-	    temp = if_stack;
-	    if_stack = if_stack->next;
-	    free (temp);
-	    break;
-
-	  default:
-	    /* Anything else is ignored.  */
-	    break;
-	  }
-	  break;
-	}
-      }
-    }
-  }
-  ip->bufp = bp;
-  /* after this returns, rescan will exit because ip->bufp
-     now points to the end of the buffer.
-     rescan is responsible for the error message also.  */
-}
-
-/*
- * handle a #else directive.  Do this by just continuing processing
- * without changing  if_stack ;  this is so that the error message
- * for missing #endif's etc. will point to the original #if.  It
- * is possible that something different would be better.
- */
-static void
-do_else (buf, limit, op)
-     U_CHAR *buf ATTRIBUTE_UNUSED;
-     U_CHAR *limit ATTRIBUTE_UNUSED;
-     FILE_BUF *op;
-{
-  FILE_BUF *ip = &instack[indepth];
-
-  if (if_stack == instack[indepth].if_stack) {
-    error ("#else not within a conditional");
-    return;
-  } else {
-    if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
-      error ("#else after #else");
-      fprintf (stderr, " (matches line %d", if_stack->lineno);
-      if (strcmp (if_stack->fname, ip->fname) != 0)
-	fprintf (stderr, ", file %s", if_stack->fname);
-      fprintf (stderr, ")\n");
-    }
-    if_stack->type = T_ELSE;
-  }
-
-  if (if_stack->if_succeeded)
-    skip_if_group (ip, 0);
-  else {
-    ++if_stack->if_succeeded;	/* continue processing input */
-    output_line_command (ip, op, 1, same_file);
-  }
-}
-
-/*
- * unstack after #endif command
- */
-static void
-do_endif (buf, limit, op)
-     U_CHAR *buf ATTRIBUTE_UNUSED;
-     U_CHAR *limit ATTRIBUTE_UNUSED;
-     FILE_BUF *op;
-{
-  if (if_stack == instack[indepth].if_stack)
-    error ("unbalanced #endif");
-  else {
-    IF_STACK_FRAME *temp = if_stack;
-    if_stack = if_stack->next;
-    free (temp);
-    output_line_command (&instack[indepth], op, 1, same_file);
-  }
-}
-
-/*
- * Skip a comment, assuming the input ptr immediately follows the
- * initial slash-star.  Bump line counter as necessary.
- * (The canonical line counter is &ip->lineno).
- * Don't use this routine (or the next one) if bumping the line
- * counter is not sufficient to deal with newlines in the string.
- */
-static U_CHAR *
-skip_to_end_of_comment (ip, line_counter)
-     FILE_BUF *ip;
-     int *line_counter;		/* place to remember newlines, or NULL */
-{
-  U_CHAR *limit = ip->buf + ip->length;
-  U_CHAR *bp = ip->bufp;
-  FILE_BUF *op = &outbuf;	/* JF */
-  int output = put_out_comments && !line_counter;
-
-	/* JF this line_counter stuff is a crock to make sure the
-	   comment is only put out once, no matter how many times
-	   the comment is skipped.  It almost works */
-  if (output) {
-    *op->bufp++ = '/';
-    *op->bufp++ = '*';
-  }
-  while (bp < limit) {
-    if (output)
-      *op->bufp++ = *bp;
-    switch (*bp++) {
-    case '/':
-      if (warn_comments && bp < limit && *bp == '*')
-	warning("`/*' within comment");
-      break;
-    case '\n':
-      if (line_counter != NULL)
-	++*line_counter;
-      if (output)
-	++op->lineno;
-      break;
-    case '*':
-      if (*bp == '\\' && bp[1] == '\n')
-	newline_fix (bp);
-      if (*bp == '/') {
-        if (output)
-	  *op->bufp++ = '/';
-	ip->bufp = ++bp;
-	return bp;
-      }
-      break;
-    }
-  }
-  ip->bufp = bp;
-  return bp;
-}
-
-/*
- * Skip over a quoted string.  BP points to the opening quote.
- * Returns a pointer after the closing quote.  Don't go past LIMIT.
- * START_LINE is the line number of the starting point (but it need
- * not be valid if the starting point is inside a macro expansion).
- *
- * The input stack state is not changed.
- *
- * If COUNT_NEWLINES is nonzero, it points to an int to increment
- * for each newline passed.
- *
- * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
- * if we pass a backslash-newline.
- *
- * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
- */
-static U_CHAR *
-skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
-     const U_CHAR *bp;
-     const U_CHAR *limit;
-     int start_line;
-     int *count_newlines;
-     int *backslash_newlines_p;
-     int *eofp;
-{
-  U_CHAR c, match;
-
-  match = *bp++;
-  while (1) {
-    if (bp >= limit) {
-      error_with_line (line_for_error (start_line),
-		       "unterminated string or character constant");
-      if (eofp)
-	*eofp = 1;
-      break;
-    }
-    c = *bp++;
-    if (c == '\\') {
-      while (*bp == '\\' && bp[1] == '\n') {
-	if (backslash_newlines_p)
-	  *backslash_newlines_p = 1;
-	if (count_newlines)
-	  ++*count_newlines;
-	bp += 2;
-      }
-      if (*bp == '\n' && count_newlines) {
-	if (backslash_newlines_p)
-	  *backslash_newlines_p = 1;
-	++*count_newlines;
-      }
-      bp++;
-    } else if (c == '\n') {
-      /* Unterminated strings and character constants are 'legal'.  */
-      bp--;	/* Don't consume the newline. */
-      if (eofp)
-	*eofp = 1;
-      break;
-    } else if (c == match)
-      break;
-  }
-  return (U_CHAR *) bp;
-}
-
-/*
- * write out a #line command, for instance, after an #include file.
- * If CONDITIONAL is nonzero, we can omit the #line if it would
- * appear to be a no-op, and we can output a few newlines instead
- * if we want to increase the line number by a small amount.
- * FILE_CHANGE says whether we are entering a file, leaving, or neither.
- */
-
-static void
-output_line_command (ip, op, conditional, file_change)
-     FILE_BUF *ip, *op;
-     int conditional;
-     enum file_change_code file_change;
-{
-  int len;
-  char line_cmd_buf[500];
-
-  if (no_line_commands
-      || ip->fname == NULL
-      || no_output) {
-    op->lineno = ip->lineno;
-    return;
-  }
-
-  if (conditional) {
-    if (ip->lineno == op->lineno)
-      return;
-
-    /* If the inherited line number is a little too small,
-       output some newlines instead of a #line command.  */
-    if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
-      check_expand (op, 10);
-      while (ip->lineno > op->lineno) {
-	*op->bufp++ = '\n';
-	op->lineno++;
-      }
-      return;
-    }
-  }
-
-  sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, ip->fname);
-  if (file_change != same_file)
-    strcat (line_cmd_buf, file_change == enter_file ? " 1" : " 2");
-  if (system_include_depth > (file_change == leave_file))
-    strcat (line_cmd_buf, " 3");
-  len = strlen (line_cmd_buf);
-  line_cmd_buf[len++] = '\n';
-  check_expand (op, len + 1);
-  if (op->bufp > op->buf && op->bufp[-1] != '\n')
-    *op->bufp++ = '\n';
-  memcpy (op->bufp, line_cmd_buf, len);
-  op->bufp += len;
-  op->lineno = ip->lineno;
-}
-
-
-/* Expand a macro call.
-   HP points to the symbol that is the macro being called.
-   Put the result of expansion onto the input stack
-   so that subsequent input by our caller will use it.
-
-   If macro wants arguments, caller has already verified that
-   an argument list follows; arguments come from the input stack.  */
-
-static void
-macroexpand (hp, op)
-     HASHNODE *hp;
-     FILE_BUF *op;
-{
-  int nargs;
-  DEFINITION *defn = hp->value.defn;
-  U_CHAR *xbuf;
-  int xbuf_len;
-  int start_line = instack[indepth].lineno;
-
-  CHECK_DEPTH (return;);
-
-  /* it might not actually be a macro.  */
-  if (hp->type != T_MACRO) {
-    special_symbol (hp, op);
-    return;
-  }
-
-  nargs = defn->nargs;
-
-  if (nargs >= 0) {
-    int i;
-    struct argdata *args;
-    const char *parse_error = 0;
-
-    args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
-
-    for (i = 0; i < nargs; i++) {
-      args[i].raw = args[i].expanded = (U_CHAR *) "";
-      args[i].raw_length = args[i].expand_length
-	= args[i].stringified_length = 0;
-      args[i].free1 = args[i].free2 = 0;
-    }
-
-    /* Parse all the macro args that are supplied.  I counts them.
-       The first NARGS args are stored in ARGS.
-       The rest are discarded.  */
-    i = 0;
-    do {
-      /* Discard the open-parenthesis or comma before the next arg.  */
-      ++instack[indepth].bufp;
-      parse_error
-	= macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0);
-      if (parse_error)
-	{
-	  error_with_line (line_for_error (start_line), "%s", parse_error);
-	  break;
-	}
-      i++;
-    } while (*instack[indepth].bufp != ')');
-
-    /* If we got one arg but it was just whitespace, call that 0 args.  */
-    if (i == 1) {
-      const U_CHAR *bp = args[0].raw;
-      const U_CHAR *lim = bp + args[0].raw_length;
-      while (bp != lim && is_space (*bp)) bp++;
-      if (bp == lim)
-	i = 0;
-    }
-
-    if (nargs == 0 && i > 0)
-      error ("arguments given to macro `%s'", hp->name);
-    else if (i < nargs) {
-      /* traditional C allows foo() if foo wants one argument.  */
-      if (nargs == 1 && i == 0)
-	;
-      else if (i == 0)
-	error ("no args to macro `%s'", hp->name);
-      else if (i == 1)
-	error ("only 1 arg to macro `%s'", hp->name);
-      else
-	error ("only %d args to macro `%s'", i, hp->name);
-    } else if (i > nargs)
-      error ("too many (%d) args to macro `%s'", i, hp->name);
-
-    /* Swallow the closeparen.  */
-    ++instack[indepth].bufp;
-
-    /* If macro wants zero args, we parsed the arglist for checking only.
-       Read directly from the macro definition.  */
-    if (nargs == 0) {
-      xbuf = defn->expansion;
-      xbuf_len = defn->length;
-    } else {
-      U_CHAR *exp = defn->expansion;
-      int offset;	/* offset in expansion,
-				   copied a piece at a time */
-      int totlen;	/* total amount of exp buffer filled so far */
-
-      struct reflist *ap;
-
-      /* Macro really takes args.  Compute the expansion of this call.  */
-
-      /* Compute length in characters of the macro's expansion.  */
-      xbuf_len = defn->length;
-      for (ap = defn->pattern; ap != NULL; ap = ap->next) {
-	if (ap->stringify)
-	  xbuf_len += args[ap->argno].stringified_length;
-	else 
-	  xbuf_len += args[ap->argno].raw_length;
-      }
-
-      xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
-
-      /* Generate in XBUF the complete expansion
-	 with arguments substituted in.
-	 TOTLEN is the total size generated so far.
-	 OFFSET is the index in the definition
-	 of where we are copying from.  */
-      offset = totlen = 0;
-      for (ap = defn->pattern; ap != NULL; ap = ap->next) {
-	struct argdata *arg = &args[ap->argno];
-
-	for (i = 0; i < ap->nchars; i++)
-	  xbuf[totlen++] = exp[offset++];
-
-	if (ap->stringify != 0) {
-	  int arglen = arg->raw_length;
-	  int escaped = 0;
-	  int in_string = 0;
-	  int c;
-	  i = 0;
-	  while (i < arglen
-		 && (c = arg->raw[i], is_space (c)))
-	    i++;
-	  while (i < arglen
-		 && (c = arg->raw[arglen - 1], is_space (c)))
-	    arglen--;
-	  for (; i < arglen; i++) {
-	    c = arg->raw[i];
-
-	    /* Special markers Newline Space
-	       generate nothing for a stringified argument.  */
-	    if (c == '\n' && arg->raw[i+1] != '\n') {
-	      i++;
-	      continue;
-	    }
-
-	    /* Internal sequences of whitespace are replaced by one space
-	       except within an string or char token.  */
-	    if (! in_string
-		&& (c == '\n' ? arg->raw[i+1] == '\n' : is_space (c))) {
-	      while (1) {
-		/* Note that Newline Space does occur within whitespace
-		   sequences; consider it part of the sequence.  */
-		if (c == '\n' && is_space (arg->raw[i+1]))
-		  i += 2;
-		else if (c != '\n' && is_space (c))
-		  i++;
-		else break;
-		c = arg->raw[i];
-	      }
-	      i--;
-	      c = ' ';
-	    }
-
-	    if (escaped)
-	      escaped = 0;
-	    else {
-	      if (c == '\\')
-		escaped = 1;
-	      if (in_string) {
-		if (c == in_string)
-		  in_string = 0;
-	      } else if (c == '\"' || c == '\'')
-		in_string = c;
-	    }
-
-	    /* Escape these chars */
-	    if (c == '\"' || (in_string && c == '\\'))
-	      xbuf[totlen++] = '\\';
-	    if (ISPRINT (c))
-	      xbuf[totlen++] = c;
-	    else {
-	      sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
-	      totlen += 4;
-	    }
-	  }
-	} else {
-	  const U_CHAR *p1 = arg->raw;
-	  const U_CHAR *l1 = p1 + arg->raw_length;
-
-	  if (ap->raw_before) {
-	    while (p1 != l1 && is_space (*p1)) p1++;
-	    while (p1 != l1 && is_idchar (*p1))
-	      xbuf[totlen++] = *p1++;
-	    /* Delete any no-reexpansion marker that follows
-	       an identifier at the beginning of the argument
-	       if the argument is concatenated with what precedes it.  */
-	    if (p1[0] == '\n' && p1[1] == '-')
-	      p1 += 2;
-	  }
-	  if (ap->raw_after) {
-	    /* Arg is concatenated after: delete trailing whitespace,
-	       whitespace markers, and no-reexpansion markers.  */
-	    while (p1 != l1) {
-	      if (is_space (l1[-1])) l1--;
-	      else if (l1[-1] == '-') {
-		const U_CHAR *p2 = l1 - 1;
-		/* If a `-' is preceded by an odd number of newlines then it
-		   and the last newline are a no-reexpansion marker.  */
-		while (p2 != p1 && p2[-1] == '\n') p2--;
-		if ((l1 - 1 - p2) & 1) {
-		  l1 -= 2;
-		}
-		else break;
-	      }
-	      else break;
-	    }
-	  }
-	  memmove (xbuf + totlen, p1, l1 - p1);
-	  totlen += l1 - p1;
-	}
-
-	if (totlen > xbuf_len)
-	  abort ();
-      }
-
-      /* if there is anything left of the definition
-	 after handling the arg list, copy that in too. */
-
-      for (i = offset; i < defn->length; i++)
-	xbuf[totlen++] = exp[i];
-
-      xbuf[totlen] = 0;
-      xbuf_len = totlen;
-
-      for (i = 0; i < nargs; i++) {
-	if (args[i].free1 != 0)
-	  free (args[i].free1);
-	if (args[i].free2 != 0)
-	  free (args[i].free2);
-      }
-    }
-  } else {
-    xbuf = defn->expansion;
-    xbuf_len = defn->length;
-  }
-
-  /* Now put the expansion on the input stack
-     so our caller will commence reading from it.  */
-  {
-    FILE_BUF *ip2;
-
-    ip2 = &instack[++indepth];
-
-    ip2->fname = 0;
-    ip2->lineno = 0;
-    ip2->buf = xbuf;
-    ip2->length = xbuf_len;
-    ip2->bufp = xbuf;
-    ip2->free_ptr = (nargs > 0) ? xbuf : 0;
-    ip2->macro = hp;
-    ip2->if_stack = if_stack;
-  }
-}
-
-/*
- * Parse a macro argument and store the info on it into *ARGPTR.
- * Return nonzero to indicate a syntax error.
- */
-
-static const char *
-macarg (argptr)
-     struct argdata *argptr;
-{
-  FILE_BUF *ip = &instack[indepth];
-  int paren = 0;
-  int newlines = 0;
-  int comments = 0;
-
-  /* Try to parse as much of the argument as exists at this
-     input stack level.  */
-  U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
-			&paren, &newlines, &comments);
-
-  /* If we find the end of the argument at this level,
-     set up *ARGPTR to point at it in the input stack.  */
-  if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
-      && bp != ip->buf + ip->length) {
-    if (argptr != 0) {
-      argptr->raw = ip->bufp;
-      argptr->raw_length = bp - ip->bufp;
-    }
-    ip->bufp = bp;
-  } else {
-    /* This input stack level ends before the macro argument does.
-       We must pop levels and keep parsing.
-       Therefore, we must allocate a temporary buffer and copy
-       the macro argument into it.  */
-    int bufsize = bp - ip->bufp;
-    int extra = newlines;
-    U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
-    int final_start = 0;
-
-    memcpy (buffer, ip->bufp, bufsize);
-    ip->bufp = bp;
-    ip->lineno += newlines;
-
-    while (bp == ip->buf + ip->length) {
-      if (instack[indepth].macro == 0) {
-	free (buffer);
-	return "unterminated macro call";
-      }
-      ip->macro->type = T_MACRO;
-      if (ip->free_ptr)
-	free (ip->free_ptr);
-      ip = &instack[--indepth];
-      newlines = 0;
-      comments = 0;
-      bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
-		    &newlines, &comments);
-      final_start = bufsize;
-      bufsize += bp - ip->bufp;
-      extra += newlines;
-      buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
-      memcpy (buffer + bufsize - (bp - ip->bufp), ip->bufp, bp - ip->bufp);
-      ip->bufp = bp;
-      ip->lineno += newlines;
-    }
-
-    /* Now, if arg is actually wanted, record its raw form,
-       discarding comments and duplicating newlines in whatever
-       part of it did not come from a macro expansion.
-       EXTRA space has been preallocated for duplicating the newlines.
-       FINAL_START is the index of the start of that part.  */
-    if (argptr != 0) {
-      argptr->raw = buffer;
-      argptr->raw_length = bufsize;
-      argptr->free1 = buffer;
-      argptr->newlines = newlines;
-      argptr->comments = comments;
-      if ((newlines || comments) && ip->fname != 0)
-	argptr->raw_length
-	  = final_start +
-	    discard_comments (argptr->raw + final_start,
-			      argptr->raw_length - final_start,
-			      newlines);
-      argptr->raw[argptr->raw_length] = 0;
-      if (argptr->raw_length > bufsize + extra)
-	abort ();
-    }
-  }
-
-  /* If we are not discarding this argument,
-     macroexpand it and compute its length as stringified.
-     All this info goes into *ARGPTR.  */
-
-  if (argptr != 0) {
-    FILE_BUF obuf;
-    const U_CHAR *buf, *lim;
-    int totlen;
-
-    obuf = expand_to_temp_buffer (argptr->raw,
-				  argptr->raw + argptr->raw_length,
-				  1);
-
-    argptr->expanded = obuf.buf;
-    argptr->expand_length = obuf.length;
-    argptr->free2 = obuf.buf;
-
-    buf = argptr->raw;
-    lim = buf + argptr->raw_length;
-
-    totlen = 0;
-    while (buf != lim) {
-      U_CHAR c = *buf++;
-      totlen++;
-      /* Internal sequences of whitespace are replaced by one space
-	 in most cases, but not always.  So count all the whitespace
-	 in case we need to keep it all.  */
-      if (c == '\"' || c == '\\') /* escape these chars */
-	totlen++;
-      else if (!ISPRINT (c))
-	totlen += 3;
-    }
-    argptr->stringified_length = totlen;
-  }
-  return 0;
-}
-
-/* Scan text from START (inclusive) up to LIMIT (exclusive),
-   counting parens in *DEPTHPTR,
-   and return if reach LIMIT
-   or before a `)' that would make *DEPTHPTR negative
-   or before a comma when *DEPTHPTR is zero.
-   Single and double quotes are matched and termination
-   is inhibited within them.  Comments also inhibit it.
-   Value returned is pointer to stopping place.
-
-   Increment *NEWLINES each time a newline is passed.
-   Set *COMMENTS to 1 if a comment is seen.  */
-
-static U_CHAR *
-macarg1 (start, limit, depthptr, newlines, comments)
-     U_CHAR *start;
-     const U_CHAR *limit;
-     int *depthptr, *newlines, *comments;
-{
-  U_CHAR *bp = start;
-
-  while (bp < limit) {
-    switch (*bp) {
-    case '(':
-      (*depthptr)++;
-      break;
-    case ')':
-      if (--(*depthptr) < 0)
-	return bp;
-      break;
-    case '\\':
-      /* Traditionally, backslash makes following char not special.  */
-      if (bp + 1 < limit)
-	{
-	  bp++;
-	  /* But count source lines anyway.  */
-	  if (*bp == '\n')
-	    ++*newlines;
-	}
-      break;
-    case '\n':
-      ++*newlines;
-      break;
-    case '/':
-      if (bp[1] == '\\' && bp[2] == '\n')
-	newline_fix (bp + 1);
-      if (bp[1] != '*' || bp + 1 >= limit)
-	break;
-      *comments = 1;
-      bp += 2;
-      while (bp + 1 < limit) {
-	if (bp[0] == '*'
-	    && bp[1] == '\\' && bp[2] == '\n')
-	  newline_fix (bp + 1);
-	if (bp[0] == '*' && bp[1] == '/')
-	  break;
-	if (*bp == '\n') ++*newlines;
-	bp++;
-      }
-      bp += 1;
-      break;
-    case '\'':
-    case '\"':
-      {
-	int quotec;
-	for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
-	  if (*bp == '\\') {
-	    bp++;
-	    if (*bp == '\n')
-	      ++*newlines;
-	    while (*bp == '\\' && bp[1] == '\n') {
-	      bp += 2;
-	    }
-	  } else if (*bp == '\n') {
-	    ++*newlines;
-	    if (quotec == '\'')
-	      break;
-	  }
-	}
-      }
-      break;
-    case ',':
-      if ((*depthptr) == 0)
-	return bp;
-      break;
-    }
-    bp++;
-  }
-
-  return bp;
-}
-
-/* Discard comments and duplicate newlines
-   in the string of length LENGTH at START,
-   except inside of string constants.
-   The string is copied into itself with its beginning staying fixed.  
-
-   NEWLINES is the number of newlines that must be duplicated.
-   We assume that that much extra space is available past the end
-   of the string.  */
-
-static int
-discard_comments (start, length, newlines)
-     U_CHAR *start;
-     int length;
-     int newlines;
-{
-  U_CHAR *ibp;
-  U_CHAR *obp;
-  const U_CHAR *limit;
-  int c;
-
-  /* If we have newlines to duplicate, copy everything
-     that many characters up.  Then, in the second part,
-     we will have room to insert the newlines
-     while copying down.
-     NEWLINES may actually be too large, because it counts
-     newlines in string constants, and we don't duplicate those.
-     But that does no harm.  */
-  if (newlines > 0) {
-    ibp = start + length;
-    obp = ibp + newlines;
-    limit = start;
-    while (limit != ibp)
-      *--obp = *--ibp;
-  }
-
-  ibp = start + newlines;
-  limit = start + length + newlines;
-  obp = start;
-
-  while (ibp < limit) {
-    *obp++ = c = *ibp++;
-    switch (c) {
-    case '\n':
-      /* Duplicate the newline.  */
-      *obp++ = '\n';
-      break;
-
-    case '\\':
-      if (*ibp == '\n') {
-	obp--;
-	ibp++;
-      }
-      break;
-
-    case '/':
-      if (*ibp == '\\' && ibp[1] == '\n')
-	newline_fix (ibp);
-      /* Delete any comment.  */
-      if (ibp[0] != '*' || ibp + 1 >= limit)
-	break;
-      obp--;
-      ibp++;
-      while (ibp + 1 < limit) {
-	if (ibp[0] == '*'
-	    && ibp[1] == '\\' && ibp[2] == '\n')
-	  newline_fix (ibp + 1);
-	if (ibp[0] == '*' && ibp[1] == '/')
-	  break;
-	ibp++;
-      }
-      ibp += 2;
-      break;
-
-    case '\'':
-    case '\"':
-      /* Notice and skip strings, so that we don't
-	 think that comments start inside them,
-	 and so we don't duplicate newlines in them.  */
-      {
-	int quotec = c;
-	while (ibp < limit) {
-	  *obp++ = c = *ibp++;
-	  if (c == quotec)
-	    break;
-	  if (c == '\n' && quotec == '\'')
-	    break;
-	  if (c == '\\' && ibp < limit) {
-	    while (*ibp == '\\' && ibp[1] == '\n')
-	      ibp += 2;
-	    *obp++ = *ibp++;
-	  }
-	}
-      }
-      break;
-    }
-  }
-
-  return obp - start;
-}
-
-
-/* Core error handling routine.  */
-static void
-v_message (mtype, line, msgid, ap)
-     enum msgtype mtype;
-     int line;
-     const char *msgid;
-     va_list ap;
-{
-  const char *fname = 0;
-  int i;
-
-  if (mtype == MT_WARNING && inhibit_warnings)
-    return;
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      if (line == 0)
-	line = instack[i].lineno;
-      fname = instack[i].fname;
-      break;
-    }
-
-  if (fname)
-    fprintf (stderr, "%s:%d: ", fname, line);
-  else
-    fprintf (stderr, "%s: ", progname);
-
-  if (mtype == MT_WARNING)
-    fputs (_("warning: "), stderr);
-
-  vfprintf (stderr, _(msgid), ap);
-  putc ('\n', stderr);
-
-  if (mtype == MT_ERROR)
-    errors++;
-}
-
-/*
- * error - print error message and increment count of errors.
- */
-void
-error VPARAMS ((const char *msgid, ...))
-{
-  VA_OPEN(ap, msgid);
-  VA_FIXEDARG (ap, const char *, msgid);
-
-  v_message (MT_ERROR, 0, msgid, ap);
-  VA_CLOSE (ap);
-}
-
-void
-error_with_line VPARAMS ((int line, const char *msgid, ...))
-{
-  VA_OPEN(ap, msgid);
-  VA_FIXEDARG (ap, int, line);
-  VA_FIXEDARG (ap, const char *, msgid);
-
-  v_message (MT_ERROR, line, msgid, ap);
-  VA_CLOSE (ap);
-}
-
-/* Error including a message from `errno'.  */
-void
-error_from_errno (name)
-     const char *name;
-{
-  error ("%s: %s", name, strerror (errno));
-}
-
-/* Print error message but don't count it.  */
-void
-warning VPARAMS ((const char *msgid, ...))
-{
-  VA_OPEN(ap, msgid);
-  VA_FIXEDARG (ap, const char *, msgid);
-
-  v_message (MT_WARNING, 0, msgid, ap);
-  VA_CLOSE (ap);
-}
-
-void
-fatal VPARAMS ((const char *msgid, ...))
-{
-  VA_OPEN(ap, msgid);
-  VA_FIXEDARG (ap, const char *, msgid);
-
-  v_message (MT_FATAL, 0, msgid, ap);
-  VA_CLOSE (ap);
-  exit (FATAL_EXIT_CODE);
-}
-
-/* More 'friendly' abort that prints the location at which we died.  */
-void
-fancy_abort (line, func)
-     int line;
-     const char *func;
-{
-  fatal ("internal error in %s, at tradcpp.c:%d\n\
-Please submit a full bug report.\n\
-See %s for instructions.", func, line, GCCBUGURL);
-}
-
-void
-perror_with_name (name)
-     const char *name;
-{
-  fprintf (stderr, "%s: %s: %s\n", progname, name, strerror (errno));
-  errors++;
-}
-
-void
-pfatal_with_name (name)
-     const char *name;
-{
-  perror_with_name (name);
-  exit (FATAL_EXIT_CODE);
-}
-
-/* Return the line at which an error occurred.
-   The error is not necessarily associated with the current spot
-   in the input stack, so LINE says where.  LINE will have been
-   copied from ip->lineno for the current input level.
-   If the current level is for a file, we return LINE.
-   But if the current level is not for a file, LINE is meaningless.
-   In that case, we return the lineno of the innermost file.  */
-static int
-line_for_error (line)
-     int line;
-{
-  int i;
-  int line1 = line;
-
-  for (i = indepth; i >= 0; ) {
-    if (instack[i].fname != 0)
-      return line1;
-    i--;
-    if (i < 0)
-      return 0;
-    line1 = instack[i].lineno;
-  }
-  return 0;
-}
-
-/*
- * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
- *
- * As things stand, nothing is ever placed in the output buffer to be
- * removed again except when it's KNOWN to be part of an identifier,
- * so flushing and moving down everything left, instead of expanding,
- * should work ok.
- */
-
-static void
-grow_outbuf (obuf, needed)
-     FILE_BUF *obuf;
-     int needed;
-{
-  U_CHAR *p;
-  int minsize;
-
-  if (obuf->length - (obuf->bufp - obuf->buf) > needed)
-    return;
-
-  /* Make it at least twice as big as it is now.  */
-  obuf->length *= 2;
-  /* Make it have at least 150% of the free space we will need.  */
-  minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
-  if (minsize > obuf->length)
-    obuf->length = minsize;
-
-  p = (U_CHAR *) xrealloc (obuf->buf, obuf->length);
-  obuf->bufp = p + (obuf->bufp - obuf->buf);
-  obuf->buf = p;
-}
-
-/* Symbol table for macro names and special symbols */
-
-/*
- * install a name in the main hash table, even if it is already there.
- *   name stops with first non alphanumeric, except leading '#'.
- * caller must check against redefinition if that is desired.
- * delete_macro () removes things installed by install () in fifo order.
- * this is important because of the `defined' special symbol used
- * in #if, and also if pushdef/popdef directives are ever implemented.
- *
- * If LEN is >= 0, it is the length of the name.
- * Otherwise, compute the length by scanning the entire name.
- *
- * If HASH is >= 0, it is the precomputed hash code.
- * Otherwise, compute the hash code.
- *
- * caller must set the value, if any is desired.
- */
-static HASHNODE *
-install (name, len, type, hash)
-     const U_CHAR *name;
-     int len;
-     enum node_type type;
-     int hash;
-        /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
-{
-  HASHNODE *hp;
-  int bucket;
-  const U_CHAR *p;
-  U_CHAR *q;
-
-  if (len < 0) {
-    p = name;
-    while (is_idchar (*p))
-      p++;
-    len = p - name;
-  }
-
-  if (hash < 0)
-    hash = hashf (name, len, HASHSIZE);
-
-  hp = (HASHNODE *) xmalloc (sizeof (HASHNODE) + len + 1);
-  bucket = hash;
-  hp->bucket_hdr = &hashtab[bucket];
-  hp->next = hashtab[bucket];
-  hashtab[bucket] = hp;
-  hp->prev = NULL;
-  if (hp->next != NULL)
-    hp->next->prev = hp;
-  hp->type = type;
-  hp->length = len;
-  hp->name = q = ((U_CHAR *) hp) + sizeof (HASHNODE);
-  memcpy (q, name, len);
-  q[len] = 0;
-  return hp;
-}
-
-/*
- * find the most recent hash node for name name (ending with first
- * non-identifier char) installed by install
- *
- * If LEN is >= 0, it is the length of the name.
- * Otherwise, compute the length by scanning the entire name.
- *
- * If HASH is >= 0, it is the precomputed hash code.
- * Otherwise, compute the hash code.
- */
-HASHNODE *
-lookup (name, len, hash)
-     const U_CHAR *name;
-     int len;
-     int hash;
-{
-  const U_CHAR *bp;
-  HASHNODE *bucket;
-
-  if (len < 0) {
-    for (bp = name; is_idchar (*bp); bp++) ;
-    len = bp - name;
-  }
-
-  if (hash < 0)
-    hash = hashf (name, len, HASHSIZE);
-
-  bucket = hashtab[hash];
-  while (bucket) {
-    if (bucket->length == len
-	&& strncmp ((const char *)bucket->name, (const char *)name, len) == 0)
-      return bucket;
-    bucket = bucket->next;
-  }
-  return NULL;
-}
-
-/*
- * Delete a hash node.  Some weirdness to free junk from macros.
- * More such weirdness will have to be added if you define more hash
- * types that need it.
- */
-
-/* Note that the DEFINITION of a macro is removed from the hash table
-   but its storage is not freed.  This would be a storage leak
-   except that it is not reasonable to keep undefining and redefining
-   large numbers of macros many times.
-   In any case, this is necessary, because a macro can be #undef'd
-   in the middle of reading the arguments to a call to it.
-   If #undef freed the DEFINITION, that would crash.  */
-static void
-delete_macro (hp)
-     HASHNODE *hp;
-{
-
-  if (hp->prev != NULL)
-    hp->prev->next = hp->next;
-  if (hp->next != NULL)
-    hp->next->prev = hp->prev;
-
-  /* make sure that the bucket chain header that
-     the deleted guy was on points to the right thing afterwards. */
-  if (hp == *hp->bucket_hdr)
-    *hp->bucket_hdr = hp->next;
-
-  free (hp);
-}
-
-/*
- * return hash function on name.  must be compatible with the one
- * computed a step at a time, elsewhere
- */
-static int
-hashf (name, len, hashsize)
-     const U_CHAR *name;
-     int len;
-     int hashsize;
-{
-  int r = 0;
-
-  while (len--)
-    r = HASHSTEP (r, *name++);
-
-  return MAKE_POS (r) % hashsize;
-}
-
-/* Dump all macro definitions as #defines to stdout.  */
-
-static void
-dump_all_macros ()
-{
-  int bucket;
-
-  for (bucket = 0; bucket < HASHSIZE; bucket++) {
-    HASHNODE *hp;
-
-    for (hp = hashtab[bucket]; hp; hp= hp->next) {
-      if (hp->type == T_MACRO) {
-	DEFINITION *defn = hp->value.defn;
-	struct reflist *ap;
-	int offset;
-	int concat;
-
-
-	/* Print the definition of the macro HP.  */
-
-	printf ("#define %s", hp->name);
-	if (defn->nargs >= 0) {
-	  int i;
-
-	  printf ("(");
-	  for (i = 0; i < defn->nargs; i++) {
-	    dump_arg_n (defn, i);
-	    if (i + 1 < defn->nargs)
-	      printf (", ");
-	  }
-	  printf (")");
-	}
-
-	printf (" ");
-
-	offset = 0;
-	concat = 0;
-	for (ap = defn->pattern; ap != NULL; ap = ap->next) {
-	  dump_defn_1 (defn->expansion, offset, ap->nchars);
-	  if (ap->nchars != 0)
-	    concat = 0;
-	  offset += ap->nchars;
-	  if (ap->stringify)
-	    printf (" #");
-	  if (ap->raw_before && !concat)
-	    printf (" ## ");
-	  concat = 0;
-	  dump_arg_n (defn, ap->argno);
-	  if (ap->raw_after) {
-	    printf (" ## ");
-	    concat = 1;
-	  }
-	}
-	dump_defn_1 (defn->expansion, offset, defn->length - offset);
-	printf ("\n");
-      }
-    }
-  }
-}
-
-/* Output to stdout a substring of a macro definition.
-   BASE is the beginning of the definition.
-   Output characters START thru LENGTH.
-   Discard newlines outside of strings, thus
-   converting funny-space markers to ordinary spaces.  */
-static void
-dump_defn_1 (base, start, length)
-     const U_CHAR *base;
-     int start;
-     int length;
-{
-  const U_CHAR *p = base + start;
-  const U_CHAR *limit = base + start + length;
-
-  while (p < limit) {
-    if (*p != '\n')
-      putchar (*p);
-    else if (*p == '\"' || *p =='\'') {
-      const U_CHAR *p1 = skip_quoted_string (p, limit, 0, 0, 0, 0);
-      fwrite (p, p1 - p, 1, stdout);
-      p = p1 - 1;
-    }
-    p++;
-  }
-}
-
-/* Print the name of argument number ARGNUM of macro definition DEFN.
-   Recall that DEFN->argnames contains all the arg names
-   concatenated in reverse order with comma-space in between.  */
-static void
-dump_arg_n (defn, argnum)
-     DEFINITION *defn;
-     int argnum;
-{
-  const U_CHAR *p = defn->argnames;
-  while (argnum + 1 < defn->nargs) {
-    p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
-    argnum++;
-  }
-
-  while (*p && *p != ',') {
-    putchar (*p);
-    p++;
-  }
-}
-
-/* Initialize the built-in macros.  */
-#define DSC(x) U x, sizeof x - 1
-#define install_spec(name, type) \
- install(DSC(name), type, -1);
-#define install_value(name, val) \
- hp = install(DSC(name), T_CONST, -1); hp->value.cpval = val;
-static void
-initialize_builtins ()
-{
-  HASHNODE *hp;
-
-  install_spec ("__BASE_FILE__",     T_BASE_FILE);
-  install_spec ("__DATE__",          T_DATE);
-  install_spec ("__FILE__",          T_FILE);
-  install_spec ("__TIME__",          T_TIME);
-  install_spec ("__VERSION__",       T_VERSION);
-  install_spec ("__INCLUDE_LEVEL__", T_INCLUDE_LEVEL);
-  install_spec ("__LINE__",          T_SPECLINE);
-
-#ifndef NO_BUILTIN_SIZE_TYPE
-  install_value ("__SIZE_TYPE__",         SIZE_TYPE);
-#endif
-#ifndef NO_BUILTIN_PTRDIFF_TYPE
-  install_value ("__PTRDIFF_TYPE__",      PTRDIFF_TYPE);
-#endif
-#ifndef NO_BUILTIN_WCHAR_TYPE
-  install_value ("__WCHAR_TYPE__",        WCHAR_TYPE);
-#endif
-#ifndef NO_BUILTIN_WINT_TYPE
-  install_value ("__WINT_TYPE__",         WINT_TYPE);
-#endif
-  install_value ("__REGISTER_PREFIX__",   REGISTER_PREFIX);
-  install_value ("__USER_LABEL_PREFIX__", user_label_prefix);
-
-  if (flag_signed_char == 0)
-    install_value ("__CHAR_UNSIGNED__", "1");
-}
-#undef DSC
-#undef install_spec
-#undef install_value
-
-/* Common handler of command line directives -U, -D and -A.  */
-static void
-run_directive (str, len, type)
-     const char *str;
-     size_t len;
-     enum node_type type;
-{
-  const struct directive *kt;
-  FILE_BUF *ip = &instack[++indepth];
-  ip->fname = "*command line*";
-
-  ip->buf = ip->bufp = (U_CHAR *) str;
-  ip->length = len;
-  ip->lineno = 1;
-  ip->macro = 0;
-  ip->free_ptr = 0;
-  ip->if_stack = if_stack;
-
-  for (kt = directive_table; kt->type != type; kt++)
-    ;
-
-  (*kt->func) ((U_CHAR *) str, (U_CHAR *) str + len, NULL);
-  --indepth;
-}
-
-/* Handle the -D option.  If STR is just an identifier, define it with
- * value 1.  If STR has anything after the identifier, then it should
- * be identifier-space-definition.  */
-static void
-make_definition (str)
-     const char *str;
-{
-  char *buf, *p;
-  size_t count;
-
-  /* Copy the entire option so we can modify it. 
-     Change the first "=" in the string to a space.  If there is none,
-     tack " 1" on the end.  */
-
-  /* Length including the null.  */  
-  count = strlen (str);
-  buf = (char *) alloca (count + 2);
-  memcpy (buf, str, count);
-
-  p = strchr (str, '=');
-  if (p)
-    buf[p - str] = ' ';
-  else
-    {
-      buf[count++] = ' ';
-      buf[count++] = '1';
-    }
-
-  run_directive (buf, count, T_DEFINE);
-}
-
-/* Handle the -U option.  */
-static void
-make_undef (str)
-     const char *str;
-{
-  run_directive (str, strlen (str), T_UNDEF);
-}
-
-/* Handles the #assert (-A) and #unassert (-A-) command line options.  */
-static void
-make_assertion (str)
-     const char *str;
-{
-  enum node_type type = T_ASSERT;
-  size_t count;
-  const char *p;
-
-  if (*str == '-')
-    {
-      str++;
-      type = T_UNASSERT;
-    }
-  
-  count = strlen (str);
-  p = strchr (str, '=');
-  if (p)
-    {
-      /* Copy the entire option so we can modify it.  Change the first
-	 "=" in the string to a '(', and tack a ')' on the end.  */
-      char *buf = (char *) alloca (count + 1);
-
-      memcpy (buf, str, count);
-      buf[p - str] = '(';
-      buf[count++] = ')';
-      str = buf;
-    }
-
-  run_directive (str, count, type);
-}
-
-/* Get the file-mode and data size of the file open on FD
-   and store them in *MODE_POINTER and *SIZE_POINTER.  */
-
-static int
-file_size_and_mode (fd, mode_pointer, size_pointer)
-     int fd;
-     int *mode_pointer;
-     long *size_pointer;
-{
-  struct stat sbuf;
-
-  if (fstat (fd, &sbuf) < 0) return -1;
-  if (mode_pointer) *mode_pointer = sbuf.st_mode;
-  if (size_pointer) *size_pointer = sbuf.st_size;
-  return 0;
-}