cleanup

6 files changed, 8242 insertions, 9091 deletions

diff --git a/gcc/config/arm/telf.h b/gcc/config/arm/telf.h
index ca415ac..a956f48 100755
--- a/gcc/config/arm/telf.h
+++ b/gcc/config/arm/telf.h
@@ -22,8 +22,6 @@ Boston, MA 02111-1307, USA.  */
 
 #define OBJECT_FORMAT_ELF
 
-#define CPP_PREDEFINES "-Dthumb -Dthumbelf -D__thumb -Acpu(arm) -Amachine(arm)"
-
 #include "arm/thumb.h"
 #include "tree.h"
 
diff --git a/gcc/config/arm/thumb.h b/gcc/config/arm/thumb.h
index 600520f..db196b5 100755
--- a/gcc/config/arm/thumb.h
+++ b/gcc/config/arm/thumb.h
@@ -36,16 +36,6 @@ Boston, MA 02111-1307, USA.  */
 /* ??? There is no pattern for the TST instuction.  Check for other unsupported
    instructions.  */
 
-/* Run Time Target Specifications */
-#ifndef CPP_PREDEFINES
-#define CPP_PREDEFINES "-Dthumb -D__thumb -Acpu(arm) -Amachine(arm)"
-#endif
-
-#ifndef ASM_SPEC
-#define ASM_SPEC "-marm7tdmi %{mthumb-interwork:-mthumb-interwork}"
-#endif
-#define LINK_SPEC "-X"
-
 #define TARGET_VERSION  fputs (" (ARM/THUMB:generic)", stderr);
 
 #define ARM_FLAG_THUMB				0x1000	/* same as in arm.h */
@@ -104,12 +94,25 @@ extern int target_flags;
 /* This is how to output an assembler line
    that says to advance the location counter
    to a multiple of 2**LOG bytes.  */
-#define ASM_OUTPUT_ALIGN(STREAM,LOG)		\
-{						\
-  if ((LOG) > 0)				\
-    fprintf (STREAM, "\t.align\t%d\n", (LOG));	\
+
+#ifdef OLD_ASM
+
+#define ASM_OUTPUT_ALIGN(STREAM,LOG)               \
+{                                                  \
+    if ((LOG) > 0)                                 \
+        fprintf (STREAM, "\t.align\t%d\n", (LOG)); \
+}
+
+#else
+
+#define ASM_OUTPUT_ALIGN(STREAM,LOG)                  \
+{                                                     \
+    if ((LOG) > 0)                                    \
+        fprintf (STREAM, "\t.align\t%d, 0\n", (LOG)); \
 }
 
+#endif
+
 /* Output a common block */
 #define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED)  		\
   (fprintf ((STREAM), "\t.comm\t"), 		     			\
diff --git a/gcc/cppexp.c b/gcc/cppexp.c
index 8589e65..6efd90b 100755
--- a/gcc/cppexp.c
+++ b/gcc/cppexp.c
@@ -259,12 +259,6 @@ cpp_lex (pfile, skip_evaluation)
   old_written = CPP_WRITTEN (pfile);
   cpp_skip_hspace (pfile);
   c = CPP_BUF_PEEK (CPP_BUFFER (pfile));
-  if (c == '#')
-    {
-      op.op = INT;
-      op.value = cpp_read_check_assertion (pfile);
-      return op;
-    }
 
   if (c == '\n')
     {
diff --git a/gcc/cpphash.h b/gcc/cpphash.h
index 3b97f1c..b773951 100755
--- a/gcc/cpphash.h
+++ b/gcc/cpphash.h
@@ -21,7 +21,6 @@ union hashval {
   int ival;
   char *cpval;
   DEFINITION *defn;
-  struct hashnode *aschain; /* for #assert */
 };
 
 struct hashnode {
diff --git a/gcc/cpplib.c b/gcc/cpplib.c
index 77e4ddb..bc51639 100755
--- a/gcc/cpplib.c
+++ b/gcc/cpplib.c
@@ -4,19 +4,19 @@
    Based on CCCP program by Paul Rubin, June 1986
    Adapted to ANSI C, Richard Stallman, Jan 1987
 
-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 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.
+   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.  */
+   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"
@@ -41,7 +41,7 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "prefix.h"
 
 #ifndef GET_ENV_PATH_LIST
-#define GET_ENV_PATH_LIST(VAR,NAME)	do { (VAR) = getenv (NAME); } while (0)
+#define GET_ENV_PATH_LIST(VAR,NAME)     do { (VAR) = getenv(NAME); } while (0)
 #endif
 
 /* By default, colon separates directories in a path.  */
@@ -60,7 +60,7 @@ static char *predefs = CPP_PREDEFINES;
 #else
 static char *predefs = "";
 #endif
-
+
 /* We let tm.h override the types used here, to handle trivial differences
    such as the choice of unsigned int or long unsigned int for size_t.
    When machines start needing nontrivial differences in the size type,
@@ -88,7 +88,7 @@ static char *predefs = "";
 #define WCHAR_TYPE "int"
 #endif
 #define CPP_WCHAR_TYPE(PFILE) \
-	(CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
+    (CPP_OPTIONS(PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
 /* CYGNUS LOCAL vmakarov */
 #endif
 /* END CYGNUS LOCAL */
@@ -98,14 +98,14 @@ static char *predefs = "";
 #ifndef REGISTER_PREFIX
 #define REGISTER_PREFIX ""
 #endif
-
+
 #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
 #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
 
-#define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
-#define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
-#define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
-#define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
+#define PEEKN(N) (CPP_BUFFER(pfile)->rlimit - CPP_BUFFER(pfile)->cur >= (N) ? CPP_BUFFER(pfile)->cur[N] : EOF)
+#define FORWARD(N) CPP_FORWARD(CPP_BUFFER(pfile), (N))
+#define GETC() CPP_BUF_GET(CPP_BUFFER(pfile))
+#define PEEKC() CPP_BUF_PEEK(CPP_BUFFER(pfile))
 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
    (Note that it is false while we're expanding marco *arguments*.) */
 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->cleanup == macro_cleanup)
@@ -118,52 +118,51 @@ static char *predefs = "";
    would cause it not to be recognized).  */
 
 #define NEWLINE_FIX \
-  do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
+    do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
 
 /* Same, but assume we've already read the potential '\\' into C.  */
 #define NEWLINE_FIX1(C) do { \
-    while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
-  } while(0)
+        while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); } \
+} while(0)
 
 struct cpp_pending {
-  struct cpp_pending *next;
-  char *cmd;
-  char *arg;
+    struct cpp_pending *next;
+    char *cmd;
+    char *arg;
 };
 
 /* Forward declarations.  */
 
 extern void cpp_hash_cleanup (cpp_reader *);
 
-static char *my_strerror		(int);
-static void make_assertion		(cpp_reader *, char *, U_CHAR *);
-static void path_include		(cpp_reader *, char *);
-static void initialize_builtins		(cpp_reader *);
-static void initialize_char_syntax	(void);
+static char *my_strerror                (int);
+static void path_include                (cpp_reader *, char *);
+static void initialize_builtins         (cpp_reader *);
+static void initialize_char_syntax      (void);
 #if 0
 static void trigraph_pcp ();
 #endif
-static void validate_else		(cpp_reader *, char *);
-static int comp_def_part		(int, U_CHAR *, int, U_CHAR *,
-						int, int);
+static void validate_else               (cpp_reader *, char *);
+static int comp_def_part                (int, U_CHAR *, int, U_CHAR *,
+                                         int, int);
 #ifdef abort
 extern void fancy_abort ();
 #endif
 /* CYGNUS LOCAL - obscured headers */
 static int open_include_file_name (cpp_reader*, char *);
 /* END CYGNUS LOCAL - obscured headers */
-static int check_macro_name		(cpp_reader *, U_CHAR *, char *);
-static int compare_defs			(cpp_reader *,
-						DEFINITION *, DEFINITION *);
-static HOST_WIDE_INT eval_if_expression	(cpp_reader *);
-static int change_newlines		(U_CHAR *, int);
+static int check_macro_name             (cpp_reader *, U_CHAR *, char *);
+static int compare_defs                 (cpp_reader *,
+                                         DEFINITION *, DEFINITION *);
+static HOST_WIDE_INT eval_if_expression (cpp_reader *);
+static int change_newlines              (U_CHAR *, int);
 static void push_macro_expansion (cpp_reader *,
-					  U_CHAR *, int, HASHNODE *);
+                                  U_CHAR *, int, HASHNODE *);
 static struct cpp_pending *nreverse_pending (struct cpp_pending *);
 
-static void conditional_skip		(cpp_reader *, int,
-						enum node_type, U_CHAR *);
-static void skip_if_group		(cpp_reader *);
+static void conditional_skip            (cpp_reader *, int,
+                                         enum node_type, U_CHAR *);
+static void skip_if_group               (cpp_reader *);
 static int parse_name                   (cpp_reader *, int);
 static void print_help                  (void);
 
@@ -176,24 +175,24 @@ extern HOST_WIDE_INT cpp_parse_expr (cpp_reader *);
 
 extern char *version_string;
 extern struct tm *localtime ();
-
+
 
 /* #include "file" looks in source file dir, then stack.  */
 /* #include <file> just looks in the stack.  */
 /* -I directories are added to the end, then the defaults are added.  */
 /* The */
 static struct default_include {
-  char *fname;			/* The name of the directory.  */
-  char *component;		/* The component containing the directory */
-  int cplusplus;		/* Only look here if we're compiling C++.  */
-  int cxx_aware;		/* Includes in this directory don't need to
-				   be wrapped in extern "C" when compiling
-				   C++.  */
+    char *fname;                /* The name of the directory.  */
+    char *component;            /* The component containing the directory */
+    int cplusplus;              /* Only look here if we're compiling C++.  */
+    int cxx_aware;              /* Includes in this directory don't need to
+                                   be wrapped in extern "C" when compiling
+                                   C++.  */
 } include_defaults_array[]
 #ifdef INCLUDE_DEFAULTS
-  = INCLUDE_DEFAULTS;
+    = INCLUDE_DEFAULTS;
 #else
-  = {
+    = {
     /* Pick up GNU C++ specific include files.  */
     { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1 },
 #ifdef CROSS_COMPILE
@@ -237,11 +236,11 @@ static struct default_include {
 /* `struct directive' defines one #-directive, including how to handle it.  */
 
 struct directive {
-  int length;			/* Length of name */
-  int (*func)			/* Function to handle directive */
+    int length;                 /* Length of name */
+    int (*func)                 /* Function to handle directive */
     (cpp_reader *, struct directive *);
-  char *name;			/* Name of directive */
-  enum node_type type;		/* Code which describes which directive.  */
+    char *name;                 /* Name of directive */
+    enum node_type type;        /* Code which describes which directive.  */
 };
 
 /* These functions are declared to return int instead of void since they
@@ -260,44 +259,34 @@ static int do_xifdef (cpp_reader *, struct directive *);
 static int do_else (cpp_reader *, struct directive *);
 static int do_elif (cpp_reader *, struct directive *);
 static int do_endif (cpp_reader *, struct directive *);
-#ifdef SCCS_DIRECTIVE
-static int do_sccs (cpp_reader *, struct directive *);
-#endif
-static int do_assert (cpp_reader *, struct directive *);
-static int do_unassert (cpp_reader *, struct directive *);
 static int do_warning (cpp_reader *, struct directive *);
 
 #define IS_INCLUDE_DIRECTIVE_TYPE(t) \
-((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT)
+    ((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT)
 
 /* Here is the actual list of #-directives, most-often-used first.
    The initialize_builtins function assumes #define is the very first.  */
 
 static struct directive directive_table[] = {
-  {  6, do_define,   "define",       T_DEFINE },
-  {  5, do_xifdef,   "ifdef",        T_IFDEF },
-  {  6, do_xifdef,   "ifndef",       T_IFNDEF },
-  {  7, do_include,  "include",      T_INCLUDE },
-  { 12, do_include,  "include_next", T_INCLUDE_NEXT },
-  {  6, do_include,  "import",       T_IMPORT },
-  {  5, do_endif,    "endif",        T_ENDIF },
-  {  4, do_else,     "else",         T_ELSE },
-  {  2, do_if,       "if",           T_IF },
-  {  4, do_elif,     "elif",         T_ELIF },
-  {  5, do_undef,    "undef",        T_UNDEF },
-  {  5, do_error,    "error",        T_ERROR },
-  {  7, do_warning,  "warning",      T_WARNING },
-  {  6, do_pragma,   "pragma",       T_PRAGMA },
-  {  4, do_line,     "line",         T_LINE },
-  {  5, do_ident,    "ident",        T_IDENT },
-#ifdef SCCS_DIRECTIVE
-  {  4, do_sccs,     "sccs",         T_SCCS },
-#endif
-  {  6, do_assert,   "assert",       T_ASSERT },
-  {  8, do_unassert, "unassert",     T_UNASSERT },
-  {  -1, 0, "", T_UNUSED }
+    {  6, do_define,   "define",       T_DEFINE },
+    {  5, do_xifdef,   "ifdef",        T_IFDEF },
+    {  6, do_xifdef,   "ifndef",       T_IFNDEF },
+    {  7, do_include,  "include",      T_INCLUDE },
+    { 12, do_include,  "include_next", T_INCLUDE_NEXT },
+    {  6, do_include,  "import",       T_IMPORT },
+    {  5, do_endif,    "endif",        T_ENDIF },
+    {  4, do_else,     "else",         T_ELSE },
+    {  2, do_if,       "if",           T_IF },
+    {  4, do_elif,     "elif",         T_ELIF },
+    {  5, do_undef,    "undef",        T_UNDEF },
+    {  5, do_error,    "error",        T_ERROR },
+    {  7, do_warning,  "warning",      T_WARNING },
+    {  6, do_pragma,   "pragma",       T_PRAGMA },
+    {  4, do_line,     "line",         T_LINE },
+    {  5, do_ident,    "ident",        T_IDENT },
+    {  -1, 0, "", T_UNUSED }
 };
-
+
 /* table to tell if char can be part of a C identifier.  */
 U_CHAR is_idchar[256] = { 0 };
 /* table to tell if char can be first char of a c identifier.  */
@@ -309,43 +298,43 @@ U_CHAR is_space[256] = { 0 };
 
 /* Initialize syntactic classifications of characters. */
 static void
-initialize_char_syntax ()
+initialize_char_syntax()
 {
-  register int i;
-
-  /*
-   * Set up is_idchar and is_idstart tables.  These should be
-   * faster than saying (is_alpha (c) || c == '_'), etc.
-   * Set up these things before calling any routines tthat
-   * refer to them.
-   * XXX We should setlocale(LC_CTYPE, "C") here for safety.
-   */
-  for (i = 0; i < 256; i++)
+    register int i;
+
+    /*
+     * Set up is_idchar and is_idstart tables.  These should be
+     * faster than saying (is_alpha (c) || c == '_'), etc.
+     * Set up these things before calling any routines tthat
+     * refer to them.
+     * XXX We should setlocale(LC_CTYPE, "C") here for safety.
+     */
+    for (i = 0; i < 256; i++)
     {
-      is_idchar[i]  = ISALNUM (i);
-      is_idstart[i] = ISALPHA (i);
+        is_idchar[i]  = ISALNUM(i);
+        is_idstart[i] = ISALPHA(i);
     }
 
-  is_idchar['_']  = 1;
-  is_idstart['_'] = 1;
-
-  /* These will be reset later if -$ is in effect. */
-  is_idchar['$']  = 1;
-  is_idstart['$'] = 1;
-
-  /* horizontal space table */
-  is_hor_space[' '] = 1;
-  is_hor_space['\t'] = 1;
-  is_hor_space['\v'] = 1;
-  is_hor_space['\f'] = 1;
-  is_hor_space['\r'] = 1;
-
-  is_space[' '] = 1;
-  is_space['\t'] = 1;
-  is_space['\v'] = 1;
-  is_space['\f'] = 1;
-  is_space['\n'] = 1;
-  is_space['\r'] = 1;
+    is_idchar['_']  = 1;
+    is_idstart['_'] = 1;
+
+    /* These will be reset later if -$ is in effect. */
+    is_idchar['$']  = 1;
+    is_idstart['$'] = 1;
+
+    /* horizontal space table */
+    is_hor_space[' '] = 1;
+    is_hor_space['\t'] = 1;
+    is_hor_space['\v'] = 1;
+    is_hor_space['\f'] = 1;
+    is_hor_space['\r'] = 1;
+
+    is_space[' '] = 1;
+    is_space['\t'] = 1;
+    is_space['\v'] = 1;
+    is_space['\f'] = 1;
+    is_space['\n'] = 1;
+    is_space['\r'] = 1;
 }
 
 
@@ -353,54 +342,50 @@ initialize_char_syntax ()
    Caller must reserve enough space in pfile->token_buffer.  */
 
 static void
-quote_string (pfile, src)
-     cpp_reader *pfile;
-     char *src;
+quote_string(cpp_reader *pfile, char *src)
 {
-  U_CHAR c;
+    U_CHAR c;
 
-  CPP_PUTC_Q (pfile, '\"');
-  for (;;)
-    switch ((c = *src++))
-      {
-      default:
-        if (ISPRINT (c))
-	  CPP_PUTC_Q (pfile, c);
-	else
-	  {
-	    sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
-	    CPP_ADJUST_WRITTEN (pfile, 4);
-	  }
-	break;
-
-      case '\"':
-      case '\\':
-	CPP_PUTC_Q (pfile, '\\');
-	CPP_PUTC_Q (pfile, c);
-	break;
-      
-      case '\0':
-	CPP_PUTC_Q (pfile, '\"');
-	CPP_NUL_TERMINATE_Q (pfile);
-	return;
-      }
+    CPP_PUTC_Q(pfile, '\"');
+    for (;; )
+        switch ((c = *src++))
+        {
+        default:
+            if (ISPRINT(c))
+                CPP_PUTC_Q(pfile, c);
+            else
+            {
+                sprintf((char *)CPP_PWRITTEN(pfile), "\\%03o", c);
+                CPP_ADJUST_WRITTEN(pfile, 4);
+            }
+            break;
+
+        case '\"':
+        case '\\':
+            CPP_PUTC_Q(pfile, '\\');
+            CPP_PUTC_Q(pfile, c);
+            break;
+
+        case '\0':
+            CPP_PUTC_Q(pfile, '\"');
+            CPP_NUL_TERMINATE_Q(pfile);
+            return;
+        }
 }
 
 /* Re-allocates PFILE->token_buffer so it will hold at least N more chars.  */
 
 void
-cpp_grow_buffer (pfile, n)
-     cpp_reader *pfile;
-     long n;
+cpp_grow_buffer(cpp_reader *pfile, long n)
 {
-  long old_written = CPP_WRITTEN (pfile);
-  pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
-  pfile->token_buffer = (U_CHAR *)
-    xrealloc(pfile->token_buffer, pfile->token_buffer_size);
-  CPP_SET_WRITTEN (pfile, old_written);
+    long old_written = CPP_WRITTEN(pfile);
+    pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
+    pfile->token_buffer = (U_CHAR *)
+                          xrealloc(pfile->token_buffer, pfile->token_buffer_size);
+    CPP_SET_WRITTEN(pfile, old_written);
 }
 
-
+
 /*
  * process a given definition string, for initialization
  * If STR is just an identifier, define it with value 1.
@@ -409,109 +394,61 @@ cpp_grow_buffer (pfile, n)
  */
 
 void
-cpp_define (pfile, str)
-     cpp_reader *pfile;
-     U_CHAR *str;
+cpp_define(cpp_reader *pfile, U_CHAR *str)
 {
-  U_CHAR *buf, *p;
+    U_CHAR *buf, *p;
 
-  buf = str;
-  p = str;
-  if (!is_idstart[*p])
+    buf = str;
+    p = str;
+    if (!is_idstart[*p])
     {
-      cpp_error (pfile, "malformed option `-D %s'", str);
-      return;
+        cpp_error(pfile, "malformed option `-D %s'", str);
+        return;
     }
-  while (is_idchar[*++p])
-    ;
-  if (*p == '(') {
-    while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
-      ;
-    if (*p++ != ')')
-      p = (U_CHAR *) str;			/* Error */
-  }
-  if (*p == 0)
-    {
-      buf = (U_CHAR *) alloca (p - buf + 4);
-      strcpy ((char *)buf, str);
-      strcat ((char *)buf, " 1");
+    while (is_idchar[*++p])
+        ;
+    if (*p == '(') {
+        while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
+            ;
+        if (*p++ != ')')
+            p = (U_CHAR *) str;                 /* Error */
     }
-  else if (*p != '=')
+    if (*p == 0)
     {
-      cpp_error (pfile, "malformed option `-D %s'", str);
-      return;
+        buf = (U_CHAR *) alloca(p - buf + 4);
+        strcpy((char *)buf, str);
+        strcat((char *)buf, " 1");
     }
-  else
+    else if (*p != '=')
     {
-      U_CHAR *q;
-      /* Copy the entire option so we can modify it.  */
-      buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
-      strncpy (buf, str, p - str);
-      /* Change the = to a space.  */
-      buf[p - str] = ' ';
-      /* Scan for any backslash-newline and remove it.  */
-      p++;
-      q = &buf[p - str];
-      while (*p)
-	{
-      if (*p == '\\' && p[1] == '\n')
-	p += 2;
-      else
-	*q++ = *p++;
+        cpp_error(pfile, "malformed option `-D %s'", str);
+        return;
     }
-    *q = 0;
-  }
-  
-  if (cpp_push_buffer (pfile, buf, strlen (buf)) != NULL)
+    else
     {
-      do_define (pfile, NULL);
-      cpp_pop_buffer (pfile);
+        U_CHAR *q;
+        /* Copy the entire option so we can modify it.  */
+        buf = (U_CHAR *) alloca(2 * strlen(str) + 1);
+        strncpy(buf, str, p - str);
+        /* Change the = to a space.  */
+        buf[p - str] = ' ';
+        /* Scan for any backslash-newline and remove it.  */
+        p++;
+        q = &buf[p - str];
+        while (*p)
+        {
+            if (*p == '\\' && p[1] == '\n')
+                p += 2;
+            else
+                *q++ = *p++;
+        }
+        *q = 0;
     }
-}
-
-/* Process the string STR as if it appeared as the body of a #assert.
-   OPTION is the option name for which STR was the argument.  */
 
-static void
-make_assertion (pfile, option, str)
-     cpp_reader *pfile;
-     char *option;
-     U_CHAR *str;
-{
-  U_CHAR *buf, *p, *q;
-
-  /* Copy the entire option so we can modify it.  */
-  buf = (U_CHAR *) alloca (strlen (str) + 1);
-  strcpy ((char *) buf, str);
-  /* Scan for any backslash-newline and remove it.  */
-  p = q = buf;
-  while (*p) {
-#if 0
-    if (*p == '\\' && p[1] == '\n')
-      p += 2;
-    else
-#endif
-      *q++ = *p++;
-  }
-  *q = 0;
-
-  p = buf;
-  if (!is_idstart[*p]) {
-    cpp_error (pfile, "malformed option `%s %s'", option, str);
-    return;
-  }
-  while (is_idchar[*++p])
-    ;
-  while (*p == ' ' || *p == '\t') p++;
-  if (! (*p == 0 || *p == '(')) {
-    cpp_error (pfile, "malformed option `%s %s'", option, str);
-    return;
-  }
-
-  if (cpp_push_buffer (pfile, buf, strlen (buf)) != NULL)
+    if (cpp_push_buffer(pfile, buf, strlen(buf)) != NULL)
     {
-      do_assert (pfile, NULL);
-      cpp_pop_buffer (pfile);
+        do_define(pfile, NULL);
+        cpp_pop_buffer(pfile);
     }
 }
 
@@ -519,104 +456,96 @@ make_assertion (pfile, option, str)
    add all the names to the search path for include files.  */
 
 static void
-path_include (pfile, path)
-     cpp_reader *pfile;
-     char *path;
+path_include(cpp_reader *pfile, char *path)
 {
-  char *p;
-
-  p = path;
-
-  if (*p)
-    while (1) {
-      char *q = p;
-      char *name;
-
-      /* Find the end of this name.  */
-      while (*q != 0 && *q != PATH_SEPARATOR) q++;
-      if (p == q) {
-	/* An empty name in the path stands for the current directory.  */
-	name = (char *) xmalloc (2);
-	name[0] = '.';
-	name[1] = 0;
-      } else {
-	/* Otherwise use the directory that is named.  */
-	name = (char *) xmalloc (q - p + 1);
-	copy_memory (p, name, q - p);
-	name[q - p] = 0;
-      }
-
-      append_include_chain (pfile,
-			    &(CPP_OPTIONS (pfile)->bracket_include), name, 0);
-
-      /* Advance past this name.  */
-      p = q;
-      if (*p == 0)
-	break;
-      /* Skip the colon.  */
-      p++;
-    }
+    char *p;
+
+    p = path;
+
+    if (*p)
+        while (1) {
+            char *q = p;
+            char *name;
+
+            /* Find the end of this name.  */
+            while (*q != 0 && *q != PATH_SEPARATOR) q++;
+            if (p == q) {
+                /* An empty name in the path stands for the current directory.  */
+                name = (char *) xmalloc(2);
+                name[0] = '.';
+                name[1] = 0;
+            } else {
+                /* Otherwise use the directory that is named.  */
+                name = (char *) xmalloc(q - p + 1);
+                copy_memory(p, name, q - p);
+                name[q - p] = 0;
+            }
+
+            append_include_chain(pfile,
+                                 &(CPP_OPTIONS(pfile)->bracket_include), name, 0);
+
+            /* Advance past this name.  */
+            p = q;
+            if (*p == 0)
+                break;
+            /* Skip the colon.  */
+            p++;
+        }
 }
-
+
 void
-cpp_options_init (opts)
-     cpp_options *opts;
+cpp_options_init(cpp_options *opts)
 {
-  zero_memory ((char *) opts, sizeof *opts);
-  opts->in_fname = NULL;
-  opts->out_fname = NULL;
-
-  opts->dollars_in_ident = 1;
-  initialize_char_syntax ();
-
-  opts->no_line_commands = 0;
-  opts->no_trigraphs = 1;
-  opts->put_out_comments = 0;
-  opts->print_include_names = 0;
-  opts->dump_macros = dump_none;
-  opts->no_output = 0;
-  opts->remap = 0;
-  opts->cplusplus = 0;
-  opts->cplusplus_comments = 1;
-
-  opts->verbose = 0;
-  opts->objc = 0;
-  opts->lang_asm = 0;
-  opts->for_lint = 0;
-  opts->chill = 0;
-  opts->pedantic_errors = 0;
-  opts->inhibit_warnings = 0;
-  opts->warn_comments = 0;
-  opts->warn_import = 1;
-  opts->warnings_are_errors = 0;
+    zero_memory((char *) opts, sizeof *opts);
+    opts->in_fname = NULL;
+    opts->out_fname = NULL;
+
+    opts->dollars_in_ident = 1;
+    initialize_char_syntax();
+
+    opts->no_line_commands = 0;
+    opts->no_trigraphs = 1;
+    opts->put_out_comments = 0;
+    opts->print_include_names = 0;
+    opts->dump_macros = dump_none;
+    opts->no_output = 0;
+    opts->remap = 0;
+    opts->cplusplus = 0;
+    opts->cplusplus_comments = 1;
+
+    opts->verbose = 0;
+    opts->objc = 0;
+    opts->lang_asm = 0;
+    opts->for_lint = 0;
+    opts->chill = 0;
+    opts->pedantic_errors = 0;
+    opts->inhibit_warnings = 0;
+    opts->warn_comments = 0;
+    opts->warn_import = 1;
+    opts->warnings_are_errors = 0;
 }
 
 enum cpp_token
-null_underflow (pfile)
-     cpp_reader *pfile ATTRIBUTE_UNUSED;
+null_underflow(cpp_reader *pfile ATTRIBUTE_UNUSED)
 {
-  return CPP_EOF;
+    return CPP_EOF;
 }
 
 int
-null_cleanup (pbuf, pfile)
-     cpp_buffer *pbuf ATTRIBUTE_UNUSED;
-     cpp_reader *pfile ATTRIBUTE_UNUSED;
+null_cleanup(cpp_buffer *pbuf ATTRIBUTE_UNUSED, cpp_reader *pfile ATTRIBUTE_UNUSED)
 {
-  return 0;
+    return 0;
 }
 
 int
-macro_cleanup (pbuf, pfile)
-     cpp_buffer *pbuf;
-     cpp_reader *pfile ATTRIBUTE_UNUSED;
+macro_cleanup(cpp_buffer *pbuf, cpp_reader *pfile ATTRIBUTE_UNUSED)
 {
-  HASHNODE *macro = (HASHNODE *) pbuf->data;
-  if (macro->type == T_DISABLED)
-    macro->type = T_MACRO;
-  if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
-    free (pbuf->buf);
-  return 0;
+    HASHNODE *macro = (HASHNODE *) pbuf->data;
+    if (macro->type == T_DISABLED)
+        macro->type = T_MACRO;
+    if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
+        free(pbuf->buf);
+    return 0;
 }
 
 /* Assuming we have read '/'.
@@ -626,99 +555,96 @@ macro_cleanup (pbuf, pfile)
    If not the start of a comment, return '/'.  */
 
 static int
-skip_comment (pfile, linep)
-     cpp_reader *pfile;
-     long *linep;
+skip_comment(cpp_reader *pfile, long *linep)
 {
-  int c = 0;
-  while (PEEKC() == '\\' && PEEKN(1) == '\n')
+    int c = 0;
+    while (PEEKC() == '\\' && PEEKN(1) == '\n')
     {
-      if (linep)
-	(*linep)++;
-      FORWARD(2);
+        if (linep)
+            (*linep)++;
+        FORWARD(2);
     }
-  if (PEEKC() == '*')
+    if (PEEKC() == '*')
     {
-      FORWARD(1);
-      for (;;)
-	{
-	  int prev_c = c;
-	  c = GETC ();
-	  if (c == EOF)
-	    return EOF;
-	  while (c == '\\' && PEEKC() == '\n')
-	    {
-	      if (linep)
-		(*linep)++;
-	      FORWARD(1), c = GETC();
-	    }
-	  if (prev_c == '*' && c == '/')
-	    return ' ';
-	  if (c == '\n' && linep)
-	    (*linep)++;
-	}
+        FORWARD(1);
+        for (;; )
+        {
+            int prev_c = c;
+            c = GETC();
+            if (c == EOF)
+                return EOF;
+            while (c == '\\' && PEEKC() == '\n')
+            {
+                if (linep)
+                    (*linep)++;
+                FORWARD(1), c = GETC();
+            }
+            if (prev_c == '*' && c == '/')
+                return ' ';
+            if (c == '\n' && linep)
+                (*linep)++;
+        }
     }
-  else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
+    else if (PEEKC() == '/' && CPP_OPTIONS(pfile)->cplusplus_comments)
     {
-      FORWARD(1);
-      for (;;)
-	{
-	  c = GETC ();
-	  if (c == EOF)
-	    return ' '; /* Allow // to be terminated by EOF.  */
-	  while (c == '\\' && PEEKC() == '\n')
-	    {
-	      FORWARD(1);
-	      c = GETC();
-	      if (linep)
-		(*linep)++;
-	    }
-	  if (c == '\n')
-	    {
-	      /* Don't consider final '\n' to be part of comment.  */
-	      FORWARD(-1);
-	      return ' ';
-	    }
-	}
+        FORWARD(1);
+        for (;; )
+        {
+            c = GETC();
+            if (c == EOF)
+                return ' '; /* Allow // to be terminated by EOF.  */
+            while (c == '\\' && PEEKC() == '\n')
+            {
+                FORWARD(1);
+                c = GETC();
+                if (linep)
+                    (*linep)++;
+            }
+            if (c == '\n')
+            {
+                /* Don't consider final '\n' to be part of comment.  */
+                FORWARD(-1);
+                return ' ';
+            }
+        }
     }
-  else
-    return '/';
-}     
+    else
+        return '/';
+}
 
 /* Skip whitespace \-newline and comments.  Does not macro-expand.  */
 
 void
-cpp_skip_hspace (pfile)
-     cpp_reader *pfile;
+cpp_skip_hspace(cpp_reader *pfile)
 {
-  while (1)
+    while (1)
     {
-      int c = PEEKC();
-      if (c == EOF)
-	return; /* FIXME */
-      if (is_hor_space[c])
-	{
-	  if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
-	    cpp_pedwarn (pfile, "%s in preprocessing directive",
-			 c == '\f' ? "formfeed" : "vertical tab");
-	  FORWARD(1);
-	}
-      else if (c == '/')
-	{
-	  FORWARD (1);
-	  c = skip_comment (pfile, NULL);
-	  if (c == '/')
-	    FORWARD(-1);
-	  if (c == EOF || c == '/')
-	    return;
-	}
-      else if (c == '\\' && PEEKN(1) == '\n') {
-	FORWARD(2);
-      }
-      else if (c == '@' && CPP_BUFFER (pfile)->has_escapes
-	       && is_hor_space[PEEKN(1)])
-	FORWARD(2);
-      else return;
+        int c = PEEKC();
+        if (c == EOF)
+            return; /* FIXME */
+        if (is_hor_space[c])
+        {
+            if ((c == '\f' || c == '\v') && CPP_PEDANTIC(pfile))
+                cpp_pedwarn(pfile, "%s in preprocessing directive",
+                            c == '\f' ? "formfeed" : "vertical tab");
+            FORWARD(1);
+        }
+        else if (c == '/')
+        {
+            FORWARD(1);
+            c = skip_comment(pfile, NULL);
+            if (c == '/')
+                FORWARD(-1);
+            if (c == EOF || c == '/')
+                return;
+        }
+        else if (c == '\\' && PEEKN(1) == '\n') {
+            FORWARD(2);
+        }
+        else if (c == '@' && CPP_BUFFER(pfile)->has_escapes
+                 && is_hor_space[PEEKN(1)])
+            FORWARD(2);
+        else return;
     }
 }
 
@@ -726,197 +652,190 @@ cpp_skip_hspace (pfile)
    The line is appended to PFILE's output buffer.  */
 
 static void
-copy_rest_of_line (pfile)
-     cpp_reader *pfile;
+copy_rest_of_line(cpp_reader *pfile)
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
-  for (;;)
+    struct cpp_options *opts = CPP_OPTIONS(pfile);
+    for (;; )
     {
-      int c = GETC();
-      int nextc;
-      switch (c)
-	{
-	case EOF:
-	  goto end_directive;
-	case '\\':
-	  if (PEEKC() == '\n')
-	    {
-	      FORWARD (1);
-	      continue;
-	    }
-	case '\'':
-	case '\"':
-	  goto scan_directive_token;
-	  break;
-	case '/':
-	  nextc = PEEKC();
-	  if (nextc == '*' || (opts->cplusplus_comments && nextc == '/'))
-	    goto scan_directive_token;
-	  break;
-	case '\f':
-	case '\v':
-	  if (CPP_PEDANTIC (pfile))
-	    cpp_pedwarn (pfile, "%s in preprocessing directive",
-			 c == '\f' ? "formfeed" : "vertical tab");
-	  break;
-
-	case '\n':
-	  FORWARD(-1);
-	  goto end_directive;
-	scan_directive_token:
-	  FORWARD(-1);
-	  cpp_get_token (pfile);
-	  continue;
-	}
-      CPP_PUTC (pfile, c);
+        int c = GETC();
+        int nextc;
+        switch (c)
+        {
+        case EOF:
+            goto end_directive;
+        case '\\':
+            if (PEEKC() == '\n')
+            {
+                FORWARD(1);
+                continue;
+            }
+        case '\'':
+        case '\"':
+            goto scan_directive_token;
+            break;
+        case '/':
+            nextc = PEEKC();
+            if (nextc == '*' || (opts->cplusplus_comments && nextc == '/'))
+                goto scan_directive_token;
+            break;
+        case '\f':
+        case '\v':
+            if (CPP_PEDANTIC(pfile))
+                cpp_pedwarn(pfile, "%s in preprocessing directive",
+                            c == '\f' ? "formfeed" : "vertical tab");
+            break;
+
+        case '\n':
+            FORWARD(-1);
+            goto end_directive;
+scan_directive_token:
+            FORWARD(-1);
+            cpp_get_token(pfile);
+            continue;
+        }
+        CPP_PUTC(pfile, c);
     }
- end_directive: ;
-  CPP_NUL_TERMINATE (pfile);
+end_directive:;
+    CPP_NUL_TERMINATE(pfile);
 }
 
 void
-skip_rest_of_line (pfile)
-     cpp_reader *pfile;
+skip_rest_of_line(cpp_reader *pfile)
 {
-  long old = CPP_WRITTEN (pfile);
-  copy_rest_of_line (pfile);
-  CPP_SET_WRITTEN (pfile, old);
+    long old = CPP_WRITTEN(pfile);
+    copy_rest_of_line(pfile);
+    CPP_SET_WRITTEN(pfile, old);
 }
 
 /* Handle a possible # directive.
    '#' has already been read.  */
 
 int
-handle_directive (pfile)
-     cpp_reader *pfile;
+handle_directive(cpp_reader *pfile)
 { int c;
   register struct directive *kt;
   int ident_length;
   U_CHAR *ident;
-  long old_written = CPP_WRITTEN (pfile);
+  long old_written = CPP_WRITTEN(pfile);
 
-  cpp_skip_hspace (pfile);
+  cpp_skip_hspace(pfile);
 
-  c = PEEKC ();
+  c = PEEKC();
   if (c >= '0' && c <= '9')
-    {
+  {
       /* Handle # followed by a line number.  */
-      if (CPP_PEDANTIC (pfile))
-	cpp_pedwarn (pfile, "`#' followed by integer");
-      do_line (pfile, NULL);
+      if (CPP_PEDANTIC(pfile))
+          cpp_pedwarn(pfile, "`#' followed by integer");
+      do_line(pfile, NULL);
       goto done_a_directive;
-    }
+  }
 
   /* Now find the directive name.  */
-  CPP_PUTC (pfile, '#');
-  parse_name (pfile, GETC());
+  CPP_PUTC(pfile, '#');
+  parse_name(pfile, GETC());
   ident = pfile->token_buffer + old_written + 1;
-  ident_length = CPP_PWRITTEN (pfile) - ident;
+  ident_length = CPP_PWRITTEN(pfile) - ident;
   if (ident_length == 0 && PEEKC() == '\n')
-    {
+  {
       /* A line of just `#' becomes blank.  */
       goto done_a_directive;
-    }
+  }
 
 #if 0
   if (ident_length == 0 || !is_idstart[*ident]) {
-    U_CHAR *p = ident;
-    while (is_idchar[*p]) {
-      if (*p < '0' || *p > '9')
-	break;
-      p++;
-    }
-    /* Avoid error for `###' and similar cases unless -pedantic.  */
-    if (p == ident) {
-      while (*p == '#' || is_hor_space[*p]) p++;
-      if (*p == '\n') {
-	if (pedantic && !lang_asm)
-	  cpp_warning (pfile, "invalid preprocessor directive");
-	return 0;
+      U_CHAR *p = ident;
+      while (is_idchar[*p]) {
+          if (*p < '0' || *p > '9')
+              break;
+          p++;
+      }
+      /* Avoid error for `###' and similar cases unless -pedantic.  */
+      if (p == ident) {
+          while (*p == '#' || is_hor_space[*p]) p++;
+          if (*p == '\n') {
+              if (pedantic && !lang_asm)
+                  cpp_warning(pfile, "invalid preprocessor directive");
+              return 0;
+          }
       }
-    }
 
-    if (!lang_asm)
-      cpp_error (pfile, "invalid preprocessor directive name");
+      if (!lang_asm)
+          cpp_error(pfile, "invalid preprocessor directive name");
 
-    return 0;
+      return 0;
   }
 #endif
   /*
    * Decode the keyword and call the appropriate expansion
    * routine, after moving the input pointer up to the next line.
    */
-  for (kt = directive_table; ; kt++) {
-    if (kt->length <= 0)
-      goto not_a_directive;
-    if (kt->length == ident_length
-	&& !strncmp (kt->name, ident, ident_length)) 
-      break;
+  for (kt = directive_table;; kt++) {
+      if (kt->length <= 0)
+          goto not_a_directive;
+      if (kt->length == ident_length
+          && !strncmp(kt->name, ident, ident_length))
+          break;
   }
 
   /* We may want to pass through #define, #pragma, and #include.
      Other directives may create output, but we don't want the directive
      itself out, so we pop it now.  For example conditionals may emit
-     #failed ... #endfailed stuff.  */
+   #failed ... #endfailed stuff.  */
 
-  if (! (kt->type == T_DEFINE
-	 || kt->type == T_PRAGMA
-	 || (IS_INCLUDE_DIRECTIVE_TYPE (kt->type)
-	     && CPP_OPTIONS (pfile)->dump_includes)))
-    CPP_SET_WRITTEN (pfile, old_written);
+  if (!(kt->type == T_DEFINE
+        || kt->type == T_PRAGMA
+        || (IS_INCLUDE_DIRECTIVE_TYPE(kt->type)
+            && CPP_OPTIONS(pfile)->dump_includes)))
+      CPP_SET_WRITTEN(pfile, old_written);
 
-  (*kt->func) (pfile, kt);
+  (*kt->func)(pfile, kt);
 
   if (kt->type == T_DEFINE)
-    {
-      if (CPP_OPTIONS (pfile)->dump_macros == dump_names)
-	{
-	  /* Skip "#define". */
-	  U_CHAR *p = pfile->token_buffer + old_written + 7;
-
-	  SKIP_WHITE_SPACE (p);
-	  while (is_idchar[*p]) p++;
-	  pfile->limit = p;
-	  CPP_PUTC (pfile, '\n');
-	}
-      else if (CPP_OPTIONS (pfile)->dump_macros != dump_definitions)
-	CPP_SET_WRITTEN (pfile, old_written);
-    }
+  {
+      if (CPP_OPTIONS(pfile)->dump_macros == dump_names)
+      {
+          /* Skip "#define". */
+          U_CHAR *p = pfile->token_buffer + old_written + 7;
+
+          SKIP_WHITE_SPACE(p);
+          while (is_idchar[*p]) p++;
+          pfile->limit = p;
+          CPP_PUTC(pfile, '\n');
+      }
+      else if (CPP_OPTIONS(pfile)->dump_macros != dump_definitions)
+          CPP_SET_WRITTEN(pfile, old_written);
+  }
 
- done_a_directive:
+done_a_directive:
   return 1;
 
- not_a_directive:
-  return 0;
-}
+not_a_directive:
+  return 0; }
 
 /* Pass a directive through to the output file.
    BUF points to the contents of the directive, as a contiguous string.
-m   LIMIT points to the first character past the end of the directive.
+   m   LIMIT points to the first character past the end of the directive.
    KEYWORD is the keyword-table entry for the directive.  */
 
 static void
-pass_thru_directive (buf, limit, pfile, keyword)
-     U_CHAR *buf, *limit;
-     cpp_reader *pfile;
-     struct directive *keyword;
+pass_thru_directive(U_CHAR *buf, U_CHAR *limit, cpp_reader *pfile, struct directive *keyword)
 {
-  register unsigned keyword_length = keyword->length;
-
-  CPP_RESERVE (pfile, 1 + keyword_length + (limit - buf));
-  CPP_PUTC_Q (pfile, '#');
-  CPP_PUTS_Q (pfile, keyword->name, keyword_length);
-  if (limit != buf && buf[0] != ' ')
-    CPP_PUTC_Q (pfile, ' ');
-  CPP_PUTS_Q (pfile, buf, limit - buf);
+    register unsigned keyword_length = keyword->length;
+
+    CPP_RESERVE(pfile, 1 + keyword_length + (limit - buf));
+    CPP_PUTC_Q(pfile, '#');
+    CPP_PUTS_Q(pfile, keyword->name, keyword_length);
+    if (limit != buf && buf[0] != ' ')
+        CPP_PUTC_Q(pfile, ' ');
+    CPP_PUTS_Q(pfile, buf, limit - buf);
 #if 0
-  CPP_PUTS_Q (pfile, '\n');
-  /* Count the line we have just made in the output,
-     to get in sync properly.  */
-  pfile->lineno++;
+    CPP_PUTS_Q(pfile, '\n');
+    /* Count the line we have just made in the output,
+       to get in sync properly.  */
+    pfile->lineno++;
 #endif
 }
-
+
 /* 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
@@ -929,11 +848,11 @@ pass_thru_directive (buf, limit, pfile, keyword)
    hash table.  */
 
 struct arglist {
-  struct arglist *next;
-  U_CHAR *name;
-  int length;
-  int argno;
-  char rest_args;
+    struct arglist *next;
+    U_CHAR *name;
+    int length;
+    int argno;
+    char rest_args;
 };
 
 /* Read a replacement list for a macro with parameters.
@@ -944,536 +863,524 @@ struct arglist {
    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, backslash-newlines, and leading white space
    have already been deleted from the argument.  */
 
 static DEFINITION *
-collect_expansion (pfile, buf, limit, nargs, arglist)
-     cpp_reader *pfile;
-     U_CHAR *buf, *limit;
-     int nargs;
-     struct arglist *arglist;
+collect_expansion(cpp_reader *pfile, U_CHAR *buf, U_CHAR *limit, int nargs, struct arglist *arglist)
 {
-  DEFINITION *defn;
-  register U_CHAR *p, *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 (limit < buf)
-    abort ();
-
-  /* Find the beginning of the trailing whitespace.  */
-  p = buf;
-  while (p < limit && is_space[limit[-1]]) limit--;
-
-  /* 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 5 are for invented
-     leading and trailing newline-marker and final null.  */
-  maxsize = (sizeof (DEFINITION)
-	     + (limit - p) + 5);
-  /* Occurrences of '@' get doubled, so allocate extra space for them.  */
-  while (p < limit)
-    if (*p++ == '@')
-      maxsize++;
-  defn = (DEFINITION *) xcalloc (1, maxsize);
-
-  defn->nargs = nargs;
-  exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
-  lastp = exp_p;
-
-  p = buf;
-
-  /* Add one initial space escape-marker to prevent accidental
-     token-pasting (often removed by macroexpand).  */
-  *exp_p++ = '@';
-  *exp_p++ = ' ';
-
-  if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
-    cpp_error (pfile, "`##' at start of macro definition");
-    p += 2;
-  }
+    DEFINITION *defn;
+    register U_CHAR *p, *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 (limit < buf)
+        abort();
+
+    /* Find the beginning of the trailing whitespace.  */
+    p = buf;
+    while (p < limit && is_space[limit[-1]]) limit--;
+
+    /* 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 5 are for invented
+       leading and trailing newline-marker and final null.  */
+    maxsize = (sizeof (DEFINITION)
+               + (limit - p) + 5);
+    /* Occurrences of '@' get doubled, so allocate extra space for them.  */
+    while (p < limit)
+        if (*p++ == '@')
+            maxsize++;
+    defn = (DEFINITION *) xcalloc(1, maxsize);
+
+    defn->nargs = nargs;
+    exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
+    lastp = exp_p;
+
+    p = buf;
+
+    /* Add one initial space escape-marker to prevent accidental
+       token-pasting (often removed by macroexpand).  */
+    *exp_p++ = '@';
+    *exp_p++ = ' ';
+
+    if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
+        cpp_error(pfile, "`##' at start of macro definition");
+        p += 2;
+    }
 
-  /* Process the main body of the definition.  */
-  while (p < limit) {
-    int skipped_arg = 0;
-    register U_CHAR c = *p++;
-
-    *exp_p++ = c;
-
-    if (!CPP_TRADITIONAL (pfile)) {
-      switch (c) {
-      case '\'':
-      case '\"':
-        if (expected_delimiter != '\0') {
-          if (c == expected_delimiter)
-            expected_delimiter = '\0';
-        } else
-          expected_delimiter = c;
-	break;
-
-      case '\\':
-	if (p < limit && expected_delimiter) {
-	  /* In a string, backslash goes through
-	     and makes next char ordinary.  */
-	  *exp_p++ = *p++;
-	}
-	break;
-
-      case '@':
-	/* An '@' in a string or character constant stands for itself,
-	   and does not need to be escaped.  */
-	if (!expected_delimiter)
-	  *exp_p++ = c;
-	break;
-
-      case '#':
-	/* # is ordinary inside a string.  */
-	if (expected_delimiter)
-	  break;
-	if (p < limit && *p == '#') {
-	  /* ##: concatenate preceding and following tokens.  */
-	  /* Take out the first #, discard preceding whitespace.  */
-	  exp_p--;
-	  while (exp_p > lastp && is_hor_space[exp_p[-1]])
-	    --exp_p;
-	  /* Skip the second #.  */
-	  p++;
-	  /* Discard following whitespace.  */
-	  SKIP_WHITE_SPACE (p);
-	  concat = p;
-	  if (p == limit)
-	    cpp_error (pfile, "`##' at end of macro definition");
-	} else if (nargs >= 0) {
-	  /* Single #: stringify following argument ref.
-	     Don't leave the # in the expansion.  */
-	  exp_p--;
-	  SKIP_WHITE_SPACE (p);
-	  if (p == limit || ! is_idstart[*p]
-	      || (*p == 'L' && p + 1 < limit && (p[1] == '\'' || p[1] == '"')))
-	    cpp_error (pfile,
-		     "`#' operator is not followed by a macro argument name");
-	  else
-	    stringify = p;
-	}
-	break;
-      }
-    } else {
-      /* In -traditional mode, recognize arguments inside strings 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++;
+    /* Process the main body of the definition.  */
+    while (p < limit) {
+        int skipped_arg = 0;
+        register U_CHAR c = *p++;
+
+        *exp_p++ = c;
+
+        if (!CPP_TRADITIONAL(pfile)) {
+            switch (c) {
+            case '\'':
+            case '\"':
+                if (expected_delimiter != '\0') {
+                    if (c == expected_delimiter)
+                        expected_delimiter = '\0';
+                } else
+                    expected_delimiter = c;
+                break;
+
+            case '\\':
+                if (p < limit && expected_delimiter) {
+                    /* In a string, backslash goes through
+                       and makes next char ordinary.  */
+                    *exp_p++ = *p++;
+                }
+                break;
+
+            case '@':
+                /* An '@' in a string or character constant stands for itself,
+                   and does not need to be escaped.  */
+                if (!expected_delimiter)
+                    *exp_p++ = c;
+                break;
+
+            case '#':
+                /* # is ordinary inside a string.  */
+                if (expected_delimiter)
+                    break;
+                if (p < limit && *p == '#') {
+                    /* ##: concatenate preceding and following tokens.  */
+                    /* Take out the first #, discard preceding whitespace.  */
+                    exp_p--;
+                    while (exp_p > lastp && is_hor_space[exp_p[-1]])
+                        --exp_p;
+                    /* Skip the second #.  */
+                    p++;
+                    /* Discard following whitespace.  */
+                    SKIP_WHITE_SPACE(p);
+                    concat = p;
+                    if (p == limit)
+                        cpp_error(pfile, "`##' at end of macro definition");
+                } else if (nargs >= 0) {
+                    /* Single #: stringify following argument ref.
+                       Don't leave the # in the expansion.  */
+                    exp_p--;
+                    SKIP_WHITE_SPACE(p);
+                    if (p == limit || !is_idstart[*p]
+                        || (*p == 'L' && p + 1 < limit && (p[1] == '\'' || p[1] == '"')))
+                        cpp_error(pfile,
+                                  "`#' operator is not followed by a macro argument name");
+                    else
+                        stringify = p;
+                }
+                break;
+            }
+        } else {
+            /* In -traditional mode, recognize arguments inside strings 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++;
 #if 0
-	  /* Mark this as a concatenation-point, as if it had been ##.  */
-	  concat = p;
+                    /* Mark this as a concatenation-point, as if it had been ##.  */
+                    concat = p;
 #endif
-	}
-	break;
-      }
-    }
-
-    /* Handle the start of a symbol.  */
-    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]
-	  && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
-	register struct arglist *arg;
-
-	for (arg = arglist; arg != NULL; arg = arg->next) {
-	  struct reflist *tpat;
-
-	  if (arg->name[0] == c
-	      && arg->length == id_len
-	      && strncmp (arg->name, id_beg, id_len) == 0) {
-	    if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
-	      if (CPP_TRADITIONAL (pfile)) {
-		cpp_warning (pfile, "macro argument `%.*s' is stringified.",
-			     id_len, arg->name);
-	      } else {
-		cpp_warning (pfile,
-		    "macro arg `%.*s' would be stringified with -traditional.",
-			     id_len, arg->name);
-	      }
-	    }
-	    /* If ANSI, don't actually substitute inside a string.  */
-	    if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
-	      break;
-	    /* 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->rest_args = arg->rest_args;
-	    tpat->stringify = (CPP_TRADITIONAL (pfile)
-			       ? expected_delimiter != '\0'
-			       : stringify == id_beg);
-
-	    if (endpat == NULL)
-	      defn->pattern = tpat;
-	    else
-	      endpat->next = tpat;
-	    endpat = tpat;
-
-	    tpat->argno = arg->argno;
-	    tpat->nchars = exp_p - lastp;
-	    {
-	      register 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;
-	  }
-	}
-      }
+                }
+                break;
+            }
+        }
 
-      /* If this was not a macro arg, copy it into the expansion.  */
-      if (! skipped_arg) {
-	register U_CHAR *lim1 = p;
-	p = id_beg;
-	while (p != lim1)
-	  *exp_p++ = *p++;
-	if (stringify == id_beg)
-	  cpp_error (pfile,
-		   "`#' operator should be followed by a macro argument name");
-      }
+        /* Handle the start of a symbol.  */
+        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]
+                && !(id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
+                register struct arglist *arg;
+
+                for (arg = arglist; arg != NULL; arg = arg->next) {
+                    struct reflist *tpat;
+
+                    if (arg->name[0] == c
+                        && arg->length == id_len
+                        && strncmp(arg->name, id_beg, id_len) == 0) {
+                        if (expected_delimiter && CPP_OPTIONS(pfile)->warn_stringify) {
+                            if (CPP_TRADITIONAL(pfile)) {
+                                cpp_warning(pfile, "macro argument `%.*s' is stringified.",
+                                            id_len, arg->name);
+                            } else {
+                                cpp_warning(pfile,
+                                            "macro arg `%.*s' would be stringified with -traditional.",
+                                            id_len, arg->name);
+                            }
+                        }
+                        /* If ANSI, don't actually substitute inside a string.  */
+                        if (!CPP_TRADITIONAL(pfile) && expected_delimiter)
+                            break;
+                        /* 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->rest_args = arg->rest_args;
+                        tpat->stringify = (CPP_TRADITIONAL(pfile)
+                                           ? expected_delimiter != '\0'
+                                           : stringify == id_beg);
+
+                        if (endpat == NULL)
+                            defn->pattern = tpat;
+                        else
+                            endpat->next = tpat;
+                        endpat = tpat;
+
+                        tpat->argno = arg->argno;
+                        tpat->nchars = exp_p - lastp;
+                        {
+                            register 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) {
+                register U_CHAR *lim1 = p;
+                p = id_beg;
+                while (p != lim1)
+                    *exp_p++ = *p++;
+                if (stringify == id_beg)
+                    cpp_error(pfile,
+                              "`#' operator should be followed by a macro argument name");
+            }
+        }
     }
-  }
 
-  if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
+    if (!CPP_TRADITIONAL(pfile) && expected_delimiter == 0)
     {
-      /* If ANSI, put in a "@ " marker to prevent token pasting.
-         But not if "inside a string" (which in ANSI mode
-         happens only for -D option).  */
-      *exp_p++ = '@';
-      *exp_p++ = ' ';
+        /* If ANSI, put in a "@ " marker to prevent token pasting.
+           But not if "inside a string" (which in ANSI mode
+           happens only for -D option).  */
+        *exp_p++ = '@';
+        *exp_p++ = ' ';
     }
 
-  *exp_p = '\0';
+    *exp_p = '\0';
 
-  defn->length = exp_p - defn->expansion;
+    defn->length = exp_p - defn->expansion;
 
-  /* Crash now if we overrun the allocated size.  */
-  if (defn->length + 1 > maxsize)
-    abort ();
+    /* Crash now if we overrun the allocated size.  */
+    if (defn->length + 1 > maxsize)
+        abort();
 
 #if 0
 /* This isn't worth the time it takes.  */
-  /* give back excess storage */
-  defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
+/* give back excess storage */
+    defn->expansion = (U_CHAR *) xrealloc(defn->expansion, defn->length + 1);
 #endif
 
-  return defn;
+    return defn;
 }
 
 /*
- * special extension string that can be added to the last macro argument to 
+ * special extension string that can be added to the last macro argument to
  * allow it to absorb the "rest" of the arguments when expanded.  Ex:
- * 		#define wow(a, b...)		process (b, a, b)
+ *              #define wow(a, b...)		process (b, a, b)
  *		{ wow (1, 2, 3); }	->	{ process (2, 3, 1, 2, 3); }
  *		{ wow (one, two); }	->	{ process (two, one, two); }
  * if this "rest_arg" is used with the concat token '##' and if it is not
  * supplied then the token attached to with ## will not be outputted.  Ex:
- * 		#define wow (a, b...)		process (b ## , a, ## b)
+ *              #define wow (a, b...)		process (b ## , a, ## b)
  *		{ wow (1, 2); }		->	{ process (2, 1, 2); }
  *		{ wow (one); }		->	{ process (one); {
  */
 static char rest_extension[] = "...";
-#define REST_EXTENSION_LENGTH	(sizeof (rest_extension) - 1)
+#define REST_EXTENSION_LENGTH   (sizeof (rest_extension) - 1)
 
-/* Create a DEFINITION node from a #define directive.  Arguments are 
+/* Create a DEFINITION node from a #define directive.  Arguments are
    as for do_define.  */
 
 static MACRODEF
-create_definition (buf, limit, pfile, predefinition)
-     U_CHAR *buf, *limit;
-     cpp_reader *pfile;
-     int predefinition;
+create_definition(U_CHAR *buf, U_CHAR *limit, cpp_reader *pfile, int predefinition)
 {
-  U_CHAR *bp;			/* temp ptr into input buffer */
-  U_CHAR *symname;		/* remember where symbol name starts */
-  int sym_length;		/* and how long it is */
-  int rest_args = 0;
-  long line, col;
-  char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
-  DEFINITION *defn;
-  int arglengths = 0;		/* Accumulate lengths of arg names
-				   plus number of args.  */
-  MACRODEF mdef;
-  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
-
-  bp = buf;
-
-  while (is_hor_space[*bp])
-    bp++;
-
-  symname = bp;			/* remember where it starts */
-
-  sym_length = check_macro_name (pfile, bp, "macro");
-  bp += sym_length;
-
-  /* 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++;
-      temp->rest_args = 0;
-      arg_ptrs = temp;
-
-      if (rest_args)
-	cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
-
-      if (!is_idstart[*bp])
-	cpp_pedwarn (pfile, "invalid character in macro parameter name");
-      
-      /* Find the end of the arg name.  */
-      while (is_idchar[*bp]) {
-	bp++;
-	/* do we have a "special" rest-args extension here? */
-	if ((size_t)(limit - bp) > REST_EXTENSION_LENGTH
-	    && strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
-	  rest_args = 1;
-	  temp->rest_args = 1;
-	  break;
-	}
-      }
-      temp->length = bp - temp->name;
-      if (rest_args == 1)
-	bp += REST_EXTENSION_LENGTH;
-      arglengths += temp->length + 2;
-      SKIP_WHITE_SPACE (bp);
-      if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
-	cpp_error (pfile, "badly punctuated parameter list in `#define'");
-	goto nope;
-      }
-      if (*bp == ',') {
-	bp++;
-	SKIP_WHITE_SPACE (bp);
-      }
-      if (bp >= limit) {
-	cpp_error (pfile, "unterminated parameter list in `#define'");
-	goto nope;
-      }
-      {
-	struct arglist *otemp;
-
-	for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
-	  if (temp->length == otemp->length
-	      && strncmp (temp->name, otemp->name, temp->length) == 0) {
-	      U_CHAR *name;
-
-	      name = (U_CHAR *) alloca (temp->length + 1);
-	      (void) strncpy (name, temp->name, temp->length);
-	      name[temp->length] = '\0';
-	      cpp_error (pfile,
-			 "duplicate argument name `%s' in `#define'", name);
-	      goto nope;
-	  }
-      }
-    }
+    U_CHAR *bp;                 /* temp ptr into input buffer */
+    U_CHAR *symname;            /* remember where symbol name starts */
+    int sym_length;             /* and how long it is */
+    int rest_args = 0;
+    long line, col;
+    char *file = CPP_BUFFER(pfile) ? CPP_BUFFER(pfile)->nominal_fname : "";
+    DEFINITION *defn;
+    int arglengths = 0;         /* Accumulate lengths of arg names
+                                   plus number of args.  */
+    MACRODEF mdef;
+    cpp_buf_line_and_col(CPP_BUFFER(pfile), &line, &col);
+
+    bp = buf;
+
+    while (is_hor_space[*bp])
+        bp++;
+
+    symname = bp;               /* remember where it starts */
+
+    sym_length = check_macro_name(pfile, bp, "macro");
+    bp += sym_length;
+
+    /* 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++;
+            temp->rest_args = 0;
+            arg_ptrs = temp;
+
+            if (rest_args)
+                cpp_pedwarn(pfile, "another parameter follows `%s'", rest_extension);
+
+            if (!is_idstart[*bp])
+                cpp_pedwarn(pfile, "invalid character in macro parameter name");
+
+            /* Find the end of the arg name.  */
+            while (is_idchar[*bp]) {
+                bp++;
+                /* do we have a "special" rest-args extension here? */
+                if ((size_t)(limit - bp) > REST_EXTENSION_LENGTH
+                    && strncmp(rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
+                    rest_args = 1;
+                    temp->rest_args = 1;
+                    break;
+                }
+            }
+            temp->length = bp - temp->name;
+            if (rest_args == 1)
+                bp += REST_EXTENSION_LENGTH;
+            arglengths += temp->length + 2;
+            SKIP_WHITE_SPACE(bp);
+            if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
+                cpp_error(pfile, "badly punctuated parameter list in `#define'");
+                goto nope;
+            }
+            if (*bp == ',') {
+                bp++;
+                SKIP_WHITE_SPACE(bp);
+            }
+            if (bp >= limit) {
+                cpp_error(pfile, "unterminated parameter list in `#define'");
+                goto nope;
+            }
+            {
+                struct arglist *otemp;
+
+                for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
+                    if (temp->length == otemp->length
+                        && strncmp(temp->name, otemp->name, temp->length) == 0) {
+                        U_CHAR *name;
+
+                        name = (U_CHAR *) alloca(temp->length + 1);
+                        (void) strncpy(name, temp->name, temp->length);
+                        name[temp->length] = '\0';
+                        cpp_error(pfile,
+                                  "duplicate argument name `%s' in `#define'", name);
+                        goto nope;
+                    }
+            }
+        }
 
-    ++bp;			/* skip paren */
-    SKIP_WHITE_SPACE (bp);
-    /* now everything from bp before limit is the definition.  */
-    defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
-    defn->rest_args = rest_args;
+        ++bp;                   /* skip paren */
+        SKIP_WHITE_SPACE(bp);
+        /* now everything from bp before limit is the definition.  */
+        defn = collect_expansion(pfile, bp, limit, argno, arg_ptrs);
+        defn->rest_args = rest_args;
 
-    /* Now set defn->args.argnames to the result of concatenating
-       the argument names in reverse order
-       with comma-space between them.  */
-    defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
-    {
-      struct arglist *temp;
-      int i = 0;
-      for (temp = arg_ptrs; temp; temp = temp->next) {
-	copy_memory (temp->name, &defn->args.argnames[i], temp->length);
-	i += temp->length;
-	if (temp->next != 0) {
-	  defn->args.argnames[i++] = ',';
-	  defn->args.argnames[i++] = ' ';
-	}
-      }
-      defn->args.argnames[i] = 0;
-    }
-  } else {
-    /* Simple expansion or empty definition.  */
+        /* Now set defn->args.argnames to the result of concatenating
+           the argument names in reverse order
+           with comma-space between them.  */
+        defn->args.argnames = (U_CHAR *) xmalloc(arglengths + 1);
+        {
+            struct arglist *temp;
+            int i = 0;
+            for (temp = arg_ptrs; temp; temp = temp->next) {
+                copy_memory(temp->name, &defn->args.argnames[i], temp->length);
+                i += temp->length;
+                if (temp->next != 0) {
+                    defn->args.argnames[i++] = ',';
+                    defn->args.argnames[i++] = ' ';
+                }
+            }
+            defn->args.argnames[i] = 0;
+        }
+    } else {
+        /* Simple expansion or empty definition.  */
 
-    if (bp < limit)
-      {
-	if (is_hor_space[*bp]) {
-	  bp++;
-	  SKIP_WHITE_SPACE (bp);
-	} else {
-	  switch (*bp) {
-	    case '!':  case '"':  case '#':  case '%':  case '&':  case '\'':
-	    case ')':  case '*':  case '+':  case ',':  case '-':  case '.':
-	    case '/':  case ':':  case ';':  case '<':  case '=':  case '>':
-	    case '?':  case '[':  case '\\': case ']':  case '^':  case '{':
-	    case '|':  case '}':  case '~':
-	      cpp_warning (pfile, "missing white space after `#define %.*s'",
-			   sym_length, symname);
-	      break;
-
-	    default:
-	      cpp_pedwarn (pfile, "missing white space after `#define %.*s'",
-			   sym_length, symname);
-	      break;
-	  }
-	}
-      }
-    /* now everything from bp before limit is the definition.  */
-    defn = collect_expansion (pfile, bp, limit, -1, NULL);
-    defn->args.argnames = (U_CHAR *) "";
-  }
+        if (bp < limit)
+        {
+            if (is_hor_space[*bp]) {
+                bp++;
+                SKIP_WHITE_SPACE(bp);
+            } else {
+                switch (*bp) {
+                case '!':  case '"':  case '#':  case '%':  case '&':  case '\'':
+                case ')':  case '*':  case '+':  case ',':  case '-':  case '.':
+                case '/':  case ':':  case ';':  case '<':  case '=':  case '>':
+                case '?':  case '[':  case '\\': case ']':  case '^':  case '{':
+                case '|':  case '}':  case '~':
+                    cpp_warning(pfile, "missing white space after `#define %.*s'",
+                                sym_length, symname);
+                    break;
+
+                default:
+                    cpp_pedwarn(pfile, "missing white space after `#define %.*s'",
+                                sym_length, symname);
+                    break;
+                }
+            }
+        }
+        /* now everything from bp before limit is the definition.  */
+        defn = collect_expansion(pfile, bp, limit, -1, NULL);
+        defn->args.argnames = (U_CHAR *) "";
+    }
 
-  defn->line = line;
-  defn->file = file;
+    defn->line = line;
+    defn->file = file;
 
-  /* OP is null if this is a predefinition */
-  defn->predefined = predefinition;
-  mdef.defn = defn;
-  mdef.symnam = symname;
-  mdef.symlen = sym_length;
+    /* OP is null if this is a predefinition */
+    defn->predefined = predefinition;
+    mdef.defn = defn;
+    mdef.symnam = symname;
+    mdef.symlen = sym_length;
 
-  return mdef;
+    return mdef;
 
- nope:
-  mdef.defn = 0;
-  return mdef;
+nope:
+    mdef.defn = 0;
+    return mdef;
 }
 
 /* Check a purported macro name SYMNAME, and yield its length.
    USAGE is the kind of name this is intended for.  */
 
 static int
-check_macro_name (pfile, symname, usage)
-     cpp_reader *pfile;
-     U_CHAR *symname;
-     char *usage;
+check_macro_name(cpp_reader *pfile, U_CHAR *symname, char *usage)
 {
-  U_CHAR *p;
-  int sym_length;
-
-  for (p = symname; is_idchar[*p]; p++)
-    ;
-  sym_length = p - symname;
-  if (sym_length == 0
-      || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
-    cpp_error (pfile, "invalid %s name", usage);
-  else if (!is_idstart[*symname]) {
-    U_CHAR *msg;			/* what pain...  */
-    msg = (U_CHAR *) alloca (sym_length + 1);
-    copy_memory (symname, msg, sym_length);
-    msg[sym_length] = 0;
-    cpp_error (pfile, "invalid %s name `%s'", usage, msg);
-  } else {
-    if (! strncmp (symname, "defined", 7) && sym_length == 7)
-      cpp_error (pfile, "invalid %s name `defined'", usage);
-  }
-  return sym_length;
+    U_CHAR *p;
+    int sym_length;
+
+    for (p = symname; is_idchar[*p]; p++)
+        ;
+    sym_length = p - symname;
+    if (sym_length == 0
+        || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
+        cpp_error(pfile, "invalid %s name", usage);
+    else if (!is_idstart[*symname]) {
+        U_CHAR *msg;                    /* what pain...  */
+        msg = (U_CHAR *) alloca(sym_length + 1);
+        copy_memory(symname, msg, sym_length);
+        msg[sym_length] = 0;
+        cpp_error(pfile, "invalid %s name `%s'", usage, msg);
+    } else {
+        if (!strncmp(symname, "defined", 7) && sym_length == 7)
+            cpp_error(pfile, "invalid %s name `defined'", usage);
+    }
+    return sym_length;
 }
 
 /* Return zero if two DEFINITIONs are isomorphic.  */
 
 static int
-compare_defs (pfile, d1, d2)
-     cpp_reader *pfile;
-     DEFINITION *d1, *d2;
+compare_defs(cpp_reader *pfile, DEFINITION *d1, DEFINITION *d2)
 {
-  register struct reflist *a1, *a2;
-  register U_CHAR *p1 = d1->expansion;
-  register U_CHAR *p2 = d2->expansion;
-  int first = 1;
-
-  if (d1->nargs != d2->nargs)
-    return 1;
-  if (CPP_PEDANTIC (pfile)
-      && strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
-    return 1;
-  for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
-       a1 = a1->next, a2 = a2->next) {
-    if (!((a1->nchars == a2->nchars && ! strncmp (p1, 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;
+    register struct reflist *a1, *a2;
+    register U_CHAR *p1 = d1->expansion;
+    register U_CHAR *p2 = d2->expansion;
+    int first = 1;
+
+    if (d1->nargs != d2->nargs)
+        return 1;
+    if (CPP_PEDANTIC(pfile)
+        && strcmp((char *)d1->args.argnames, (char *)d2->args.argnames))
+        return 1;
+    for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
+         a1 = a1->next, a2 = a2->next) {
+        if (!((a1->nchars == a2->nchars && !strncmp(p1, 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.
@@ -1486,127 +1393,121 @@ compare_defs (pfile, d1, d2)
     so ignore trailing whitespace entirely.  */
 
 static int
-comp_def_part (first, beg1, len1, beg2, len2, last)
-     int first;
-     U_CHAR *beg1, *beg2;
-     int len1, len2;
-     int last;
+comp_def_part(int first, U_CHAR *beg1, int len1, U_CHAR *beg2, int len2, int last)
 {
-  register U_CHAR *end1 = beg1 + len1;
-  register 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);
+    register U_CHAR *end1 = beg1 + len1;
+    register 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);
 }
 
 /* Process a #define command.
-KEYWORD is the keyword-table entry for #define,
-or NULL for a "predefined" macro.  */
+   KEYWORD is the keyword-table entry for #define,
+   or NULL for a "predefined" macro.  */
 
 static int
-do_define (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword;
+do_define(cpp_reader *pfile, struct directive *keyword)
 {
-  int hashcode;
-  MACRODEF mdef;
-  HASHNODE *hp;
-  int save_put_out_comments;
-  long here;
-  U_CHAR *macro, *buf, *end;
-
-  here = CPP_WRITTEN (pfile);
-  
-  save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
-  CPP_OPTIONS (pfile)->put_out_comments = CPP_TRADITIONAL (pfile);
-  copy_rest_of_line (pfile);
-  CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
-
-  /* Copy out the line so we can pop the token buffer. */
-  buf = pfile->token_buffer + here;
-  end = CPP_PWRITTEN (pfile);
-  macro = alloca (end - buf + 1);
-  copy_memory (buf, macro, end - buf + 1);
-  end = macro + (end - buf);
-
-  CPP_SET_WRITTEN (pfile, here);
+    int hashcode;
+    MACRODEF mdef;
+    HASHNODE *hp;
+    int save_put_out_comments;
+    long here;
+    U_CHAR *macro, *buf, *end;
+
+    here = CPP_WRITTEN(pfile);
+
+    save_put_out_comments = CPP_OPTIONS(pfile)->put_out_comments;
+    CPP_OPTIONS(pfile)->put_out_comments = CPP_TRADITIONAL(pfile);
+    copy_rest_of_line(pfile);
+    CPP_OPTIONS(pfile)->put_out_comments = save_put_out_comments;
+
+    /* Copy out the line so we can pop the token buffer. */
+    buf = pfile->token_buffer + here;
+    end = CPP_PWRITTEN(pfile);
+    macro = alloca(end - buf + 1);
+    copy_memory(buf, macro, end - buf + 1);
+    end = macro + (end - buf);
+
+    CPP_SET_WRITTEN(pfile, here);
 
 #if 0
-  /* If this is a precompiler run (with -pcp) pass thru #define commands.  */
-  if (pcp_outfile && keyword)
-    pass_thru_directive (macro, end, pfile, keyword);
+    /* If this is a precompiler run (with -pcp) pass thru #define commands.  */
+    if (pcp_outfile && keyword)
+        pass_thru_directive(macro, end, pfile, keyword);
 #endif
 
-  mdef = create_definition (macro, end, pfile, keyword == NULL);
-  if (mdef.defn == 0)
-    goto nope;
+    mdef = create_definition(macro, end, pfile, keyword == NULL);
+    if (mdef.defn == 0)
+        goto nope;
 
-  hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
+    hashcode = hashf(mdef.symnam, mdef.symlen, HASHSIZE);
 
-  if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
+    if ((hp = cpp_lookup(pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
     {
-      int ok = 0;
-      /* Redefining a precompiled key is ok.  */
-      if (hp->type == T_PCSTRING)
-	ok = 1;
-      /* Redefining a macro is ok if the definitions are the same.  */
-      else if (hp->type == T_MACRO)
-	ok = ! compare_defs (pfile, mdef.defn, hp->value.defn);
-      /* Redefining a constant is ok with -D.  */
-      else if (hp->type == T_CONST)
-        ok = ! CPP_OPTIONS (pfile)->done_initializing;
-      /* Print the warning if it's not ok.  */
-      if (!ok)
-	{
-	  U_CHAR *msg;		/* what pain...  */
-
-	  /* If we are passing through #define and #undef directives, do
-	     that for this re-definition now.  */
-	  if (CPP_OPTIONS (pfile)->debug_output && keyword)
-	    pass_thru_directive (macro, end, pfile, keyword);
-
-	  msg = (U_CHAR *) alloca (mdef.symlen + 22);
-	  *msg = '`';
-	  copy_memory (mdef.symnam, msg + 1, mdef.symlen);
-	  strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
-	  cpp_pedwarn (pfile, msg);
-	  if (hp->type == T_MACRO)
-	    cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, hp->value.defn->line,
-				      "this is the location of the previous definition");
-	}
-      /* Replace the old definition.  */
-      hp->type = T_MACRO;
-      hp->value.defn = mdef.defn;
+        int ok = 0;
+        /* Redefining a precompiled key is ok.  */
+        if (hp->type == T_PCSTRING)
+            ok = 1;
+        /* Redefining a macro is ok if the definitions are the same.  */
+        else if (hp->type == T_MACRO)
+            ok = !compare_defs(pfile, mdef.defn, hp->value.defn);
+        /* Redefining a constant is ok with -D.  */
+        else if (hp->type == T_CONST)
+            ok = !CPP_OPTIONS(pfile)->done_initializing;
+        /* Print the warning if it's not ok.  */
+        if (!ok)
+        {
+            U_CHAR *msg;        /* what pain...  */
+
+            /* If we are passing through #define and #undef directives, do
+               that for this re-definition now.  */
+            if (CPP_OPTIONS(pfile)->debug_output && keyword)
+                pass_thru_directive(macro, end, pfile, keyword);
+
+            msg = (U_CHAR *) alloca(mdef.symlen + 22);
+            *msg = '`';
+            copy_memory(mdef.symnam, msg + 1, mdef.symlen);
+            strcpy((char *) (msg + mdef.symlen + 1), "' redefined");
+            cpp_pedwarn(pfile, msg);
+            if (hp->type == T_MACRO)
+                cpp_pedwarn_with_file_and_line(pfile, hp->value.defn->file, hp->value.defn->line,
+                                               "this is the location of the previous definition");
+        }
+        /* Replace the old definition.  */
+        hp->type = T_MACRO;
+        hp->value.defn = mdef.defn;
     }
-  else
+    else
     {
-      /* If we are passing through #define and #undef directives, do
-	 that for this new definition now.  */
-      if (CPP_OPTIONS (pfile)->debug_output && keyword)
-	pass_thru_directive (macro, end, pfile, keyword);
-      install (mdef.symnam, mdef.symlen, T_MACRO, 0,
-	       (char *) mdef.defn, hashcode);
+        /* If we are passing through #define and #undef directives, do
+           that for this new definition now.  */
+        if (CPP_OPTIONS(pfile)->debug_output && keyword)
+            pass_thru_directive(macro, end, pfile, keyword);
+        install(mdef.symnam, mdef.symlen, T_MACRO, 0,
+                (char *) mdef.defn, hashcode);
     }
 
-  return 0;
+    return 0;
 
 nope:
 
-  return 1;
+    return 1;
 }
 
 /* This structure represents one parsed argument in a macro call.
@@ -1616,19 +1517,19 @@ nope:
    `stringified_length' is the length the argument would have
    if stringified.
    `use_count' is the number of times this macro arg is substituted
-   into the macro.  If the actual use count exceeds 10, 
+   into the macro.  If the actual use count exceeds 10,
    the value stored is 10.  */
 
 /* raw and expanded are relative to ARG_BASE */
 #define ARG_BASE ((pfile)->token_buffer)
 
 struct argdata {
-  /* Strings relative to pfile->token_buffer */
-  long raw, expanded, stringified;
-  int raw_length, expand_length;
-  int stringified_length;
-  char newlines;
-  char use_count;
+    /* Strings relative to pfile->token_buffer */
+    long raw, expanded, stringified;
+    int raw_length, expand_length;
+    int stringified_length;
+    char newlines;
+    char use_count;
 };
 
 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
@@ -1637,57 +1538,52 @@ struct argdata {
    Return the new buffer, or NULL on failure.  */
 
 cpp_buffer *
-cpp_push_buffer (pfile, buffer, length)
-     cpp_reader *pfile;
-     U_CHAR *buffer;
-     long length;
+cpp_push_buffer(cpp_reader *pfile, U_CHAR *buffer, long length)
 {
-  register cpp_buffer *buf = CPP_BUFFER (pfile);
-  if (buf == pfile->buffer_stack)
+    register cpp_buffer *buf = CPP_BUFFER(pfile);
+    if (buf == pfile->buffer_stack)
     {
-      cpp_fatal (pfile, "%s: macro or `#include' recursion too deep",
-		 buf->fname);
-      return NULL;
+        cpp_fatal(pfile, "%s: macro or `#include' recursion too deep",
+                  buf->fname);
+        return NULL;
     }
-  buf--;
-  zero_memory ((char *) buf, sizeof (cpp_buffer));
-  CPP_BUFFER (pfile) = buf;
-  buf->if_stack = pfile->if_stack;
-  buf->cleanup = null_cleanup;
-  buf->underflow = null_underflow;
-  buf->buf = buf->cur = buffer;
-  buf->alimit = buf->rlimit = buffer + length;
-  
-  return buf;
+    buf--;
+    zero_memory((char *) buf, sizeof (cpp_buffer));
+    CPP_BUFFER(pfile) = buf;
+    buf->if_stack = pfile->if_stack;
+    buf->cleanup = null_cleanup;
+    buf->underflow = null_underflow;
+    buf->buf = buf->cur = buffer;
+    buf->alimit = buf->rlimit = buffer + length;
+
+    return buf;
 }
 
 cpp_buffer *
-cpp_pop_buffer (pfile)
-     cpp_reader *pfile;
+cpp_pop_buffer(cpp_reader *pfile)
 {
-  cpp_buffer *buf = CPP_BUFFER (pfile);
-  (*buf->cleanup) (buf, pfile);
-  return ++CPP_BUFFER (pfile);
+    cpp_buffer *buf = CPP_BUFFER(pfile);
+    (*buf->cleanup)(buf, pfile);
+    return ++CPP_BUFFER(pfile);
 }
 
 /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
    Pop the buffer when done.  */
 
 void
-cpp_scan_buffer (pfile)
-     cpp_reader *pfile;
+cpp_scan_buffer(cpp_reader *pfile)
 {
-  cpp_buffer *buffer = CPP_BUFFER (pfile);
-  for (;;)
+    cpp_buffer *buffer = CPP_BUFFER(pfile);
+    for (;; )
     {
-      enum cpp_token token = cpp_get_token (pfile);
-      if (token == CPP_EOF) /* Should not happen ...  */
-	break;
-      if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
-	{
-	  cpp_pop_buffer (pfile);
-	  break;
-	}
+        enum cpp_token token = cpp_get_token(pfile);
+        if (token == CPP_EOF) /* Should not happen ...  */
+            break;
+        if (token == CPP_POP && CPP_BUFFER(pfile) == buffer)
+        {
+            cpp_pop_buffer(pfile);
+            break;
+        }
     }
 }
 
@@ -1701,139 +1597,126 @@ cpp_scan_buffer (pfile)
  */
 
 static void
-cpp_expand_to_buffer (pfile, buf, length)
-     cpp_reader *pfile;
-     U_CHAR *buf;
-     int length;
+cpp_expand_to_buffer(cpp_reader *pfile, U_CHAR *buf, int length)
 {
-  register cpp_buffer *ip;
+    register cpp_buffer *ip;
 #if 0
-  cpp_buffer obuf;
+    cpp_buffer obuf;
 #endif
-  U_CHAR *limit = buf + length;
-  U_CHAR *buf1;
+    U_CHAR *limit = buf + length;
+    U_CHAR *buf1;
 #if 0
-  int odepth = indepth;
+    int odepth = indepth;
 #endif
 
-  if (length < 0)
-    abort ();
+    if (length < 0)
+        abort();
 
-  /* Set up the input on the input stack.  */
+    /* Set up the input on the input stack.  */
 
-  buf1 = (U_CHAR *) alloca (length + 1);
-  {
-    register U_CHAR *p1 = buf;
-    register U_CHAR *p2 = buf1;
+    buf1 = (U_CHAR *) alloca(length + 1);
+    {
+        register U_CHAR *p1 = buf;
+        register U_CHAR *p2 = buf1;
 
-    while (p1 != limit)
-      *p2++ = *p1++;
-  }
-  buf1[length] = 0;
+        while (p1 != limit)
+            *p2++ = *p1++;
+    }
+    buf1[length] = 0;
 
-  ip = cpp_push_buffer (pfile, buf1, length);
-  if (ip == NULL)
-    return;
-  ip->has_escapes = 1;
+    ip = cpp_push_buffer(pfile, buf1, length);
+    if (ip == NULL)
+        return;
+    ip->has_escapes = 1;
 #if 0
-  ip->lineno = obuf.lineno = 1;
+    ip->lineno = obuf.lineno = 1;
 #endif
 
-  /* Scan the input, create the output.  */
-  cpp_scan_buffer (pfile);
+    /* Scan the input, create the output.  */
+    cpp_scan_buffer(pfile);
 
 #if 0
-  if (indepth != odepth)
-    abort ();
+    if (indepth != odepth)
+        abort();
 #endif
 
-  CPP_NUL_TERMINATE (pfile);
+    CPP_NUL_TERMINATE(pfile);
 }
 
-
+
 static void
-adjust_position (buf, limit, linep, colp)
-     U_CHAR *buf;
-     U_CHAR *limit;
-     long *linep;
-     long *colp;
+adjust_position(U_CHAR *buf, U_CHAR *limit, long *linep, long *colp)
 {
-  while (buf < limit)
+    while (buf < limit)
     {
-      U_CHAR ch = *buf++;
-      if (ch == '\n')
-	(*linep)++, (*colp) = 1;
-      else
-	(*colp)++;
+        U_CHAR ch = *buf++;
+        if (ch == '\n')
+            (*linep)++, (*colp) = 1;
+        else
+            (*colp)++;
     }
 }
 
 /* Move line_base forward, updating lineno and colno.  */
 
 static void
-update_position (pbuf)
-     register cpp_buffer *pbuf;
+update_position(register cpp_buffer *pbuf)
 {
-  unsigned char *old_pos = pbuf->buf + pbuf->line_base;
-  unsigned char *new_pos = pbuf->cur;
-  register struct parse_marker *mark;
-  for (mark = pbuf->marks;  mark != NULL; mark = mark->next)
+    unsigned char *old_pos = pbuf->buf + pbuf->line_base;
+    unsigned char *new_pos = pbuf->cur;
+    register struct parse_marker *mark;
+    for (mark = pbuf->marks; mark != NULL; mark = mark->next)
     {
-      if (pbuf->buf + mark->position < new_pos)
-	new_pos = pbuf->buf + mark->position;
+        if (pbuf->buf + mark->position < new_pos)
+            new_pos = pbuf->buf + mark->position;
     }
-  pbuf->line_base += new_pos - old_pos;
-  adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
+    pbuf->line_base += new_pos - old_pos;
+    adjust_position(old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
 }
 
 void
-cpp_buf_line_and_col (pbuf, linep, colp)
-     register cpp_buffer *pbuf;
-     long *linep, *colp;
+cpp_buf_line_and_col(register cpp_buffer *pbuf, long *linep, long *colp)
 {
-  long dummy;
-  if (colp == NULL)
-    colp = &dummy;
-  if (pbuf)
+    long dummy;
+    if (colp == NULL)
+        colp = &dummy;
+    if (pbuf)
     {
-      *linep = pbuf->lineno;
-      *colp = pbuf->colno;
-      adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
+        *linep = pbuf->lineno;
+        *colp = pbuf->colno;
+        adjust_position(pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
     }
-  else
+    else
     {
-      *linep = 0;
-      *colp = 0;
+        *linep = 0;
+        *colp = 0;
     }
 }
 
 /* Return the cpp_buffer that corresponds to a file (not a macro).  */
 
 cpp_buffer *
-cpp_file_buffer (pfile)
-     cpp_reader *pfile;
+cpp_file_buffer(cpp_reader *pfile)
 {
-  cpp_buffer *ip = CPP_BUFFER (pfile);
+    cpp_buffer *ip = CPP_BUFFER(pfile);
 
-  for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
-    if (ip->fname != NULL)
-      return ip;
-  return NULL;
+    for (; ip != CPP_NULL_BUFFER(pfile); ip = CPP_PREV_BUFFER(ip))
+        if (ip->fname != NULL)
+            return ip;
+    return NULL;
 }
 
 static long
-count_newlines (buf, limit)
-     register U_CHAR *buf;
-     register U_CHAR *limit;
+count_newlines(register U_CHAR *buf, register U_CHAR *limit)
 {
-  register long count = 0;
-  while (buf < limit)
+    register long count = 0;
+    while (buf < limit)
     {
-      U_CHAR ch = *buf++;
-      if (ch == '\n')
-	count++;
+        U_CHAR ch = *buf++;
+        if (ch == '\n')
+            count++;
     }
-  return count;
+    return count;
 }
 
 /*
@@ -1845,89 +1728,86 @@ count_newlines (buf, limit)
  */
 
 static void
-output_line_command (pfile, conditional, file_change)
-     cpp_reader *pfile;
-     int conditional;
-     enum file_change_code file_change;
+output_line_command(cpp_reader *pfile, int conditional, enum file_change_code file_change)
 {
-  long line, col;
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-
-  if (ip->fname == NULL)
-    return;
-
-  update_position (ip);
-
-  if (CPP_OPTIONS (pfile)->no_line_commands
-      || CPP_OPTIONS (pfile)->no_output)
-    return;
-
-  line = CPP_BUFFER (pfile)->lineno;
-  col = CPP_BUFFER (pfile)->colno;
-  adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
-
-  if (CPP_OPTIONS (pfile)->no_line_commands)
-    return;
-
-  if (conditional) {
-    if (line == pfile->lineno)
-      return;
-
-    /* If the inherited line number is a little too small,
-       output some newlines instead of a #line command.  */
-    if (line > pfile->lineno && line < pfile->lineno + 8) {
-      CPP_RESERVE (pfile, 20);
-      while (line > pfile->lineno) {
-	CPP_PUTC_Q (pfile, '\n');
-	pfile->lineno++;
-      }
-      return;
+    long line, col;
+    cpp_buffer *ip = CPP_BUFFER(pfile);
+
+    if (ip->fname == NULL)
+        return;
+
+    update_position(ip);
+
+    if (CPP_OPTIONS(pfile)->no_line_commands
+        || CPP_OPTIONS(pfile)->no_output)
+        return;
+
+    line = CPP_BUFFER(pfile)->lineno;
+    col = CPP_BUFFER(pfile)->colno;
+    adjust_position(CPP_LINE_BASE(ip), ip->cur, &line, &col);
+
+    if (CPP_OPTIONS(pfile)->no_line_commands)
+        return;
+
+    if (conditional) {
+        if (line == pfile->lineno)
+            return;
+
+        /* If the inherited line number is a little too small,
+           output some newlines instead of a #line command.  */
+        if (line > pfile->lineno && line < pfile->lineno + 8) {
+            CPP_RESERVE(pfile, 20);
+            while (line > pfile->lineno) {
+                CPP_PUTC_Q(pfile, '\n');
+                pfile->lineno++;
+            }
+            return;
+        }
     }
-  }
 
 #if 0
-  /* Don't output a line number of 0 if we can help it.  */
-  if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
-      && *ip->bufp == '\n') {
-    ip->lineno++;
-    ip->bufp++;
-  }
+    /* Don't output a line number of 0 if we can help it.  */
+    if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
+        && *ip->bufp == '\n') {
+        ip->lineno++;
+        ip->bufp++;
+    }
 #endif
 
-  CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
-  {
+    CPP_RESERVE(pfile, 4 * strlen(ip->nominal_fname) + 50);
+    {
 #ifdef OUTPUT_LINE_COMMANDS
-    static char sharp_line[] = "#line ";
+        static char sharp_line[] = "#line ";
 #else
-    static char sharp_line[] = "# ";
+        static char sharp_line[] = "# ";
 #endif
-    CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
-  }
+        CPP_PUTS_Q(pfile, sharp_line, sizeof(sharp_line)-1);
+    }
 
-  sprintf ((char *) CPP_PWRITTEN (pfile), "%ld ", line);
-  CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
+    sprintf((char *) CPP_PWRITTEN(pfile), "%ld ", line);
+    CPP_ADJUST_WRITTEN(pfile, strlen(CPP_PWRITTEN(pfile)));
 
-  quote_string (pfile, ip->nominal_fname); 
-  if (file_change != same_file) {
-    CPP_PUTC_Q (pfile, ' ');
-    CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
-  }
-  /* Tell cc1 if following text comes from a system header file.  */
-  if (ip->system_header_p) {
-    CPP_PUTC_Q (pfile, ' ');
-    CPP_PUTC_Q (pfile, '3');
-  }
+    quote_string(pfile, ip->nominal_fname);
+    if (file_change != same_file) {
+        CPP_PUTC_Q(pfile, ' ');
+        CPP_PUTC_Q(pfile, file_change == enter_file ? '1' : '2');
+    }
+    /* Tell cc1 if following text comes from a system header file.  */
+    if (ip->system_header_p) {
+        CPP_PUTC_Q(pfile, ' ');
+        CPP_PUTC_Q(pfile, '3');
+    }
 #ifndef NO_IMPLICIT_EXTERN_C
-  /* Tell cc1plus if following text should be treated as C.  */
-  if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) {
-    CPP_PUTC_Q (pfile, ' ');
-    CPP_PUTC_Q (pfile, '4');
-  }
+    /* Tell cc1plus if following text should be treated as C.  */
+    if (ip->system_header_p == 2 && CPP_OPTIONS(pfile)->cplusplus) {
+        CPP_PUTC_Q(pfile, ' ');
+        CPP_PUTC_Q(pfile, '4');
+    }
 #endif
-  CPP_PUTC_Q (pfile, '\n');
-  pfile->lineno = line;
+    CPP_PUTC_Q(pfile, '\n');
+    pfile->lineno = line;
 }
-
+
 /*
  * Parse a macro argument and append the info on PFILE's token_buffer.
  * REST_ARGS means to absorb the rest of the args.
@@ -1935,117 +1815,111 @@ output_line_command (pfile, conditional, file_change)
  */
 
 static enum cpp_token
-macarg (pfile, rest_args)
-     cpp_reader *pfile;
-     int rest_args;
+macarg(cpp_reader *pfile, int rest_args)
 {
-  int paren = 0;
-  enum cpp_token token;
-  char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
-  CPP_OPTIONS (pfile)->put_out_comments = 0;
-
-  /* Try to parse as much of the argument as exists at this
-     input stack level.  */
-  pfile->no_macro_expand++;
-  for (;;)
+    int paren = 0;
+    enum cpp_token token;
+    char save_put_out_comments = CPP_OPTIONS(pfile)->put_out_comments;
+    CPP_OPTIONS(pfile)->put_out_comments = 0;
+
+    /* Try to parse as much of the argument as exists at this
+       input stack level.  */
+    pfile->no_macro_expand++;
+    for (;; )
     {
-      token = cpp_get_token (pfile);
-      switch (token)
-	{
-	case CPP_EOF:
-	  goto done;
-	case CPP_POP:
-	  /* If we've hit end of file, it's an error (reported by caller).
-	     Ditto if it's the end of cpp_expand_to_buffer text.
-	     If we've hit end of macro, just continue.  */
-	  if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
-	    goto done;
-	  break;
-	case CPP_LPAREN:
-	  paren++;
-	  break;
-	case CPP_RPAREN:
-	  if (--paren < 0)
-	    goto found;
-	  break;
-	case CPP_COMMA:
-	  /* if we've returned to lowest level and
-	     we aren't absorbing all args */
-	  if (paren == 0 && rest_args == 0)
-	    goto found;
-	  break;
-	found:
-	  /* Remove ',' or ')' from argument buffer.  */
-	  CPP_ADJUST_WRITTEN (pfile, -1);
-	  goto done;
-      default: ;
-	}
+        token = cpp_get_token(pfile);
+        switch (token)
+        {
+        case CPP_EOF:
+            goto done;
+        case CPP_POP:
+            /* If we've hit end of file, it's an error (reported by caller).
+               Ditto if it's the end of cpp_expand_to_buffer text.
+               If we've hit end of macro, just continue.  */
+            if (!CPP_IS_MACRO_BUFFER(CPP_BUFFER(pfile)))
+                goto done;
+            break;
+        case CPP_LPAREN:
+            paren++;
+            break;
+        case CPP_RPAREN:
+            if (--paren < 0)
+                goto found;
+            break;
+        case CPP_COMMA:
+            /* if we've returned to lowest level and
+               we aren't absorbing all args */
+            if (paren == 0 && rest_args == 0)
+                goto found;
+            break;
+found:
+            /* Remove ',' or ')' from argument buffer.  */
+            CPP_ADJUST_WRITTEN(pfile, -1);
+            goto done;
+        default:;
+        }
     }
 
- done:
-  CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
-  pfile->no_macro_expand--;
+done:
+    CPP_OPTIONS(pfile)->put_out_comments = save_put_out_comments;
+    pfile->no_macro_expand--;
 
-  return token;
+    return token;
 }
-
+
 /* Turn newlines to spaces in the string of length LENGTH at START,
    except inside of string constants.
    The string is copied into itself with its beginning staying fixed.  */
 
 static int
-change_newlines (start, length)
-     U_CHAR *start;
-     int length;
+change_newlines(U_CHAR *start, int length)
 {
-  register U_CHAR *ibp;
-  register U_CHAR *obp;
-  register U_CHAR *limit;
-  register int c;
-
-  ibp = start;
-  limit = start + length;
-  obp = start;
-
-  while (ibp < limit) {
-    *obp++ = c = *ibp++;
-    switch (c) {
-
-    case '\'':
-    case '\"':
-      /* Notice and skip strings, so that we don't delete newlines in them.  */
-      {
-	int quotec = c;
-	while (ibp < limit) {
-	  *obp++ = c = *ibp++;
-	  if (c == quotec)
-	    break;
-	  if (c == '\n' && quotec == '\'')
-	    break;
-	}
-      }
-      break;
+    register U_CHAR *ibp;
+    register U_CHAR *obp;
+    register U_CHAR *limit;
+    register int c;
+
+    ibp = start;
+    limit = start + length;
+    obp = start;
+
+    while (ibp < limit) {
+        *obp++ = c = *ibp++;
+        switch (c) {
+
+        case '\'':
+        case '\"':
+            /* Notice and skip strings, so that we don't delete newlines in them.  */
+        {
+            int quotec = c;
+            while (ibp < limit) {
+                *obp++ = c = *ibp++;
+                if (c == quotec)
+                    break;
+                if (c == '\n' && quotec == '\'')
+                    break;
+            }
+        }
+        break;
+        }
     }
-  }
 
-  return obp - start;
+    return obp - start;
 }
 
-
+
 static struct tm *
-timestamp (pfile)
-     cpp_reader *pfile;
+timestamp(cpp_reader *pfile)
 {
-  if (!pfile->timebuf) {
-    time_t t = time ((time_t *) 0);
-    pfile->timebuf = localtime (&t);
-  }
-  return pfile->timebuf;
+    if (!pfile->timebuf) {
+        time_t t = time((time_t *) 0);
+        pfile->timebuf = localtime(&t);
+    }
+    return pfile->timebuf;
 }
 
 static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-			     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
-			    };
+                             "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",};
 
 /*
  * expand things like __FILE__.  Place the expansion into the output
@@ -2053,309 +1927,303 @@ static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  */
 
 static void
-special_symbol (hp, pfile)
-     HASHNODE *hp;
-     cpp_reader *pfile;
+special_symbol(HASHNODE *hp, cpp_reader *pfile)
 {
-  char *buf;
-  int len;
-  int true_indepth;
-  cpp_buffer *ip = NULL;
-  struct tm *timebuf;
+    char *buf;
+    int len;
+    int true_indepth;
+    cpp_buffer *ip = NULL;
+    struct tm *timebuf;
 
-  int paren = 0;		/* For special `defined' keyword */
+    int paren = 0;              /* For special `defined' keyword */
 
 #if 0
-  if (pcp_outfile && pcp_inside_if
-      && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
-    cpp_error (pfile,
-	       "Predefined macro `%s' used inside `#if' during precompilation",
-	       hp->name);
+    if (pcp_outfile && pcp_inside_if
+        && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
+        cpp_error(pfile,
+                  "Predefined macro `%s' used inside `#if' during precompilation",
+                  hp->name);
 #endif
-    
-  for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
+
+    for (ip = CPP_BUFFER(pfile);; ip = CPP_PREV_BUFFER(ip))
     {
-      if (ip == CPP_NULL_BUFFER (pfile))
-	{
-	  cpp_error (pfile, "cccp error: not in any file?!");
-	  return;			/* the show must go on */
-	}
-      if (ip->fname != NULL)
-	break;
+        if (ip == CPP_NULL_BUFFER(pfile))
+        {
+            cpp_error(pfile, "cccp error: not in any file?!");
+            return;                     /* the show must go on */
+        }
+        if (ip->fname != NULL)
+            break;
     }
 
-  switch (hp->type)
+    switch (hp->type)
     {
     case T_FILE:
     case T_BASE_FILE:
-      {
-	char *string;
-	if (hp->type == T_BASE_FILE)
-	  {
-	    while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
-	      ip = CPP_PREV_BUFFER (ip);
-	  }
-	string = ip->nominal_fname;
-
-	if (!string)
-	  string = "";
-	CPP_RESERVE (pfile, 3 + 4 * strlen (string));
-	quote_string (pfile, string);
-	return;
-      }
+    {
+        char *string;
+        if (hp->type == T_BASE_FILE)
+        {
+            while (CPP_PREV_BUFFER(ip) != CPP_NULL_BUFFER(pfile))
+                ip = CPP_PREV_BUFFER(ip);
+        }
+        string = ip->nominal_fname;
+
+        if (!string)
+            string = "";
+        CPP_RESERVE(pfile, 3 + 4 * strlen(string));
+        quote_string(pfile, string);
+        return;
+    }
 
     case T_INCLUDE_LEVEL:
-      true_indepth = 0;
-      ip = CPP_BUFFER (pfile);
-      for (;  ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
-	if (ip->fname != NULL)
-	  true_indepth++;
+        true_indepth = 0;
+        ip = CPP_BUFFER(pfile);
+        for (; ip != CPP_NULL_BUFFER(pfile); ip = CPP_PREV_BUFFER(ip))
+            if (ip->fname != NULL)
+                true_indepth++;
 
-      buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
-      sprintf (buf, "%d", true_indepth - 1);
-      break;
+        buf = (char *) alloca(8); /* Eight bytes ought to be more than enough */
+        sprintf(buf, "%d", true_indepth - 1);
+        break;
 
-  case T_VERSION:
-      buf = (char *) alloca (3 + strlen (version_string));
-      sprintf (buf, "\"%s\"", version_string);
-      break;
+    case T_VERSION:
+        buf = (char *) alloca(3 + strlen(version_string));
+        sprintf(buf, "\"%s\"", version_string);
+        break;
 
 #ifndef NO_BUILTIN_SIZE_TYPE
     case T_SIZE_TYPE:
-      buf = SIZE_TYPE;
-      break;
+        buf = SIZE_TYPE;
+        break;
 #endif
 
 #ifndef NO_BUILTIN_PTRDIFF_TYPE
     case T_PTRDIFF_TYPE:
-      buf = PTRDIFF_TYPE;
-      break;
+        buf = PTRDIFF_TYPE;
+        break;
 #endif
 
 /* CYGNUS LOCAL vmakarov */
 #ifndef NO_BUILTIN_WCHAR_TYPE
 /* END CYGNUS LOCAL */
     case T_WCHAR_TYPE:
-      buf = CPP_WCHAR_TYPE (pfile);
-    break;
+        buf = CPP_WCHAR_TYPE(pfile);
+        break;
 /* CYGNUS LOCAL vmakarov */
 #endif
 /* END CYGNUS LOCAL */
 
     case T_REGISTER_PREFIX_TYPE:
-      buf = REGISTER_PREFIX;
-      break;
+        buf = REGISTER_PREFIX;
+        break;
 
-  case T_CONST:
-      buf = (char *) alloca (4 * sizeof (int));
-      sprintf (buf, "%d", hp->value.ival);
+    case T_CONST:
+        buf = (char *) alloca(4 * sizeof (int));
+        sprintf(buf, "%d", hp->value.ival);
 #ifdef STDC_0_IN_SYSTEM_HEADERS
-      if (ip->system_header_p
-	  && hp->length == 8 && memcmp (hp->name, "__STDC__", 8) == 0
-	  && ! cpp_lookup (pfile, (U_CHAR *) "__STRICT_ANSI__", -1, -1))
-	strcpy (buf, "0");
+        if (ip->system_header_p
+            && hp->length == 8 && memcmp(hp->name, "__STDC__", 8) == 0
+            && !cpp_lookup(pfile, (U_CHAR *) "__STRICT_ANSI__", -1, -1))
+            strcpy(buf, "0");
 #endif
 #if 0
-      if (pcp_inside_if && pcp_outfile)
-	/* Output a precondition for this macro use */
-	fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
+        if (pcp_inside_if && pcp_outfile)
+            /* Output a precondition for this macro use */
+            fprintf(pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
 #endif
-      break;
+        break;
 
     case T_SPECLINE:
-      {
-	long line = ip->lineno;
-	long col = ip->colno;
-	adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
+    {
+        long line = ip->lineno;
+        long col = ip->colno;
+        adjust_position(CPP_LINE_BASE(ip), ip->cur, &line, &col);
 
-	buf = (char *) alloca (10);
-	sprintf (buf, "%ld", line);
-      }
-      break;
+        buf = (char *) alloca(10);
+        sprintf(buf, "%ld", line);
+    }
+    break;
 
     case T_DATE:
     case T_TIME:
-      buf = (char *) alloca (20);
-      timebuf = timestamp (pfile);
-      if (hp->type == T_DATE)
-	sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
-		 timebuf->tm_mday, timebuf->tm_year + 1900);
-      else
-	sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
-		 timebuf->tm_sec);
-      break;
+        buf = (char *) alloca(20);
+        timebuf = timestamp(pfile);
+        if (hp->type == T_DATE)
+            sprintf(buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
+                    timebuf->tm_mday, timebuf->tm_year + 1900);
+        else
+            sprintf(buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
+                    timebuf->tm_sec);
+        break;
 
     case T_SPEC_DEFINED:
-      buf = " 0 ";		/* Assume symbol is not defined */
-      ip = CPP_BUFFER (pfile);
-      SKIP_WHITE_SPACE (ip->cur);
-      if (*ip->cur == '(')
-	{
-	  paren++;
-	  ip->cur++;			/* Skip over the paren */
-	  SKIP_WHITE_SPACE (ip->cur);
-	}
-
-      if (!is_idstart[*ip->cur])
-	goto oops;
-      if (ip->cur[0] == 'L' && (ip->cur[1] == '\'' || ip->cur[1] == '"'))
-	goto oops;
-      if ((hp = cpp_lookup (pfile, ip->cur, -1, -1)))
-	{
+        buf = " 0 ";            /* Assume symbol is not defined */
+        ip = CPP_BUFFER(pfile);
+        SKIP_WHITE_SPACE(ip->cur);
+        if (*ip->cur == '(')
+        {
+            paren++;
+            ip->cur++;                  /* Skip over the paren */
+            SKIP_WHITE_SPACE(ip->cur);
+        }
+
+        if (!is_idstart[*ip->cur])
+            goto oops;
+        if (ip->cur[0] == 'L' && (ip->cur[1] == '\'' || ip->cur[1] == '"'))
+            goto oops;
+        if ((hp = cpp_lookup(pfile, ip->cur, -1, -1)))
+        {
 #if 0
-	  if (pcp_outfile && pcp_inside_if
-	      && (hp->type == T_CONST
-		  || (hp->type == T_MACRO && hp->value.defn->predefined)))
-	    /* Output a precondition for this macro use.  */
-	    fprintf (pcp_outfile, "#define %s\n", hp->name);
+            if (pcp_outfile && pcp_inside_if
+                && (hp->type == T_CONST
+                    || (hp->type == T_MACRO && hp->value.defn->predefined)))
+                /* Output a precondition for this macro use.  */
+                fprintf(pcp_outfile, "#define %s\n", hp->name);
 #endif
-	  buf = " 1 ";
-	}
+            buf = " 1 ";
+        }
 #if 0
-      else
-	if (pcp_outfile && pcp_inside_if)
-	  {
-	    /* Output a precondition for this macro use */
-	    U_CHAR *cp = ip->bufp;
-	    fprintf (pcp_outfile, "#undef ");
-	    while (is_idchar[*cp]) /* Ick! */
-	      fputc (*cp++, pcp_outfile);
-	    putc ('\n', pcp_outfile);
-	  }
+        else
+        if (pcp_outfile && pcp_inside_if)
+        {
+            /* Output a precondition for this macro use */
+            U_CHAR *cp = ip->bufp;
+            fprintf(pcp_outfile, "#undef ");
+            while (is_idchar[*cp]) /* Ick! */
+                fputc(*cp++, pcp_outfile);
+            putc('\n', pcp_outfile);
+        }
 #endif
-      while (is_idchar[*ip->cur])
-	++ip->cur;
-      SKIP_WHITE_SPACE (ip->cur);
-      if (paren)
-	{
-	  if (*ip->cur != ')')
-	    goto oops;
-	  ++ip->cur;
-	}
-      break;
-
-    oops:
-
-      cpp_error (pfile, "`defined' without an identifier");
-      break;
+        while (is_idchar[*ip->cur])
+            ++ip->cur;
+        SKIP_WHITE_SPACE(ip->cur);
+        if (paren)
+        {
+            if (*ip->cur != ')')
+                goto oops;
+            ++ip->cur;
+        }
+        break;
+
+oops:
+
+        cpp_error(pfile, "`defined' without an identifier");
+        break;
 
     default:
-      cpp_error (pfile, "cccp error: invalid special hash type"); /* time for gdb */
-      abort ();
+        cpp_error(pfile, "cccp error: invalid special hash type"); /* time for gdb */
+        abort();
     }
-  len = strlen (buf);
-  CPP_RESERVE (pfile, len + 1);
-  CPP_PUTS_Q (pfile, buf, len);
-  CPP_NUL_TERMINATE_Q (pfile);
+    len = strlen(buf);
+    CPP_RESERVE(pfile, len + 1);
+    CPP_PUTS_Q(pfile, buf, len);
+    CPP_NUL_TERMINATE_Q(pfile);
 
-  return;
+    return;
 }
 
 /* Write out a #define command for the special named MACRO_NAME
    to PFILE's token_buffer.  */
 
 static void
-dump_special_to_buffer (pfile, macro_name)
-     cpp_reader *pfile;
-     char *macro_name;
+dump_special_to_buffer(cpp_reader *pfile, char *macro_name)
 {
-  static char define_directive[] = "#define ";
-  int macro_name_length = strlen (macro_name);
-  output_line_command (pfile, 0, same_file);
-  CPP_RESERVE (pfile, sizeof(define_directive) + macro_name_length);
-  CPP_PUTS_Q (pfile, define_directive, sizeof(define_directive)-1);
-  CPP_PUTS_Q (pfile, macro_name, macro_name_length);
-  CPP_PUTC_Q (pfile, ' ');
-  cpp_expand_to_buffer (pfile, macro_name, macro_name_length);
-  CPP_PUTC (pfile, '\n');
+    static char define_directive[] = "#define ";
+    int macro_name_length = strlen(macro_name);
+    output_line_command(pfile, 0, same_file);
+    CPP_RESERVE(pfile, sizeof(define_directive) + macro_name_length);
+    CPP_PUTS_Q(pfile, define_directive, sizeof(define_directive)-1);
+    CPP_PUTS_Q(pfile, macro_name, macro_name_length);
+    CPP_PUTC_Q(pfile, ' ');
+    cpp_expand_to_buffer(pfile, macro_name, macro_name_length);
+    CPP_PUTC(pfile, '\n');
 }
 
 /* Initialize the built-in macros.  */
 
 static void
-initialize_builtins (pfile)
-     cpp_reader *pfile;
+initialize_builtins(cpp_reader *pfile)
 {
-  install ((U_CHAR *)"__LINE__", -1, T_SPECLINE, 0, 0, -1);
-  install ((U_CHAR *)"__DATE__", -1, T_DATE, 0, 0, -1);
-  install ((U_CHAR *)"__FILE__", -1, T_FILE, 0, 0, -1);
-  install ((U_CHAR *)"__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
-  install ((U_CHAR *)"__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
-  install ((U_CHAR *)"__VERSION__", -1, T_VERSION, 0, 0, -1);
+    install((U_CHAR *)"__LINE__", -1, T_SPECLINE, 0, 0, -1);
+    install((U_CHAR *)"__DATE__", -1, T_DATE, 0, 0, -1);
+    install((U_CHAR *)"__FILE__", -1, T_FILE, 0, 0, -1);
+    install((U_CHAR *)"__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
+    install((U_CHAR *)"__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
+    install((U_CHAR *)"__VERSION__", -1, T_VERSION, 0, 0, -1);
 #ifndef NO_BUILTIN_SIZE_TYPE
-  install ((U_CHAR *)"__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
+    install((U_CHAR *)"__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
 #endif
 #ifndef NO_BUILTIN_PTRDIFF_TYPE
-  install ((U_CHAR *)"__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
+    install((U_CHAR *)"__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
 #endif
 /* CYGNUS LOCAL vmakarov */
 #ifndef NO_BUILTIN_WCHAR_TYPE
 /* END CYGNUS LOCAL */
-  install ((U_CHAR *)"__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
+    install((U_CHAR *)"__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
 /* CYGNUS LOCAL vmakarov */
 #endif
 /* END CYGNUS LOCAL */
-  install ((U_CHAR *)"__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
-  install ((U_CHAR *)"__TIME__", -1, T_TIME, 0, 0, -1);
-  if (!CPP_TRADITIONAL (pfile))
-    install ((U_CHAR *)"__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
-  if (CPP_OPTIONS (pfile)->objc)
-    install ((U_CHAR *)"__OBJC__", -1, T_CONST, 1, 0, -1);
+    install((U_CHAR *)"__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
+    install((U_CHAR *)"__TIME__", -1, T_TIME, 0, 0, -1);
+    if (!CPP_TRADITIONAL(pfile))
+        install((U_CHAR *)"__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
+    if (CPP_OPTIONS(pfile)->objc)
+        install((U_CHAR *)"__OBJC__", -1, T_CONST, 1, 0, -1);
 /*  This is supplied using a -D by the compiler driver
     so that it is present only when truly compiling with GNU C.  */
 /*  install ("__GNUC__", -1, T_CONST, 2, 0, -1);  */
 
-  if (CPP_OPTIONS (pfile)->debug_output)
+    if (CPP_OPTIONS(pfile)->debug_output)
     {
-      dump_special_to_buffer (pfile, "__BASE_FILE__");
-      dump_special_to_buffer (pfile, "__VERSION__");
+        dump_special_to_buffer(pfile, "__BASE_FILE__");
+        dump_special_to_buffer(pfile, "__VERSION__");
 #ifndef NO_BUILTIN_SIZE_TYPE
-      dump_special_to_buffer (pfile, "__SIZE_TYPE__");
+        dump_special_to_buffer(pfile, "__SIZE_TYPE__");
 #endif
 #ifndef NO_BUILTIN_PTRDIFF_TYPE
-      dump_special_to_buffer (pfile, "__PTRDIFF_TYPE__");
+        dump_special_to_buffer(pfile, "__PTRDIFF_TYPE__");
 #endif
 /* CYGNUS LOCAL vmakarov */
 #ifndef NO_BUILTIN_WCHAR_TYPE
 /* END CYGNUS LOCAL */
-      dump_special_to_buffer (pfile, "__WCHAR_TYPE__");
+        dump_special_to_buffer(pfile, "__WCHAR_TYPE__");
 /* CYGNUS LOCAL vmakarov */
 #endif
 /* END CYGNUS LOCAL */
-      dump_special_to_buffer (pfile, "__DATE__");
-      dump_special_to_buffer (pfile, "__TIME__");
-      if (!CPP_TRADITIONAL (pfile))
-	dump_special_to_buffer (pfile, "__STDC__");
-      if (CPP_OPTIONS (pfile)->objc)
-	dump_special_to_buffer (pfile, "__OBJC__");
+        dump_special_to_buffer(pfile, "__DATE__");
+        dump_special_to_buffer(pfile, "__TIME__");
+        if (!CPP_TRADITIONAL(pfile))
+            dump_special_to_buffer(pfile, "__STDC__");
+        if (CPP_OPTIONS(pfile)->objc)
+            dump_special_to_buffer(pfile, "__OBJC__");
     }
 }
-
+
 /* Return 1 iff a token ending in C1 followed directly by a token C2
    could cause mis-tokenization.  */
 
 static int
-unsafe_chars (c1, c2)
-     int c1, c2;
+unsafe_chars(int c1, int c2)
 {
-  switch (c1)
+    switch (c1)
     {
     case '+': case '-':
-      if (c2 == c1 || c2 == '=')
-	return 1;
-      goto letter;
+        if (c2 == c1 || c2 == '=')
+            return 1;
+        goto letter;
     case '.':
     case '0': case '1': case '2': case '3': case '4':
     case '5': case '6': case '7': case '8': case '9':
     case 'e': case 'E': case 'p': case 'P':
-      if (c2 == '-' || c2 == '+')
-	return 1; /* could extend a pre-processing number */
-      goto letter;
+        if (c2 == '-' || c2 == '+')
+            return 1; /* could extend a pre-processing number */
+        goto letter;
     case 'L':
-      if (c2 == '\'' || c2 == '\"')
-	return 1;   /* Could turn into L"xxx" or L'xxx'.  */
-      goto letter;
-    letter:
+        if (c2 == '\'' || c2 == '\"')
+            return 1; /* Could turn into L"xxx" or L'xxx'.  */
+        goto letter;
+letter:
     case '_':
     case 'a': case 'b': case 'c': case 'd':           case 'f':
     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
@@ -2367,13 +2235,13 @@ unsafe_chars (c1, c2)
     case 'M': case 'N': case 'O':           case 'Q': case 'R':
     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
     case 'Y': case 'Z':
-      /* We're in the middle of either a name or a pre-processing number.  */
-      return (is_idchar[c2] || c2 == '.');
+        /* We're in the middle of either a name or a pre-processing number.  */
+        return (is_idchar[c2] || c2 == '.');
     case '<': case '>': case '!': case '%': case '#': case ':':
     case '^': case '&': case '|': case '*': case '/': case '=':
-      return (c2 == c1 || c2 == '=');
+        return (c2 == c1 || c2 == '=');
     }
-  return 0;
+    return 0;
 }
 
 /* Expand a macro call.
@@ -2385,493 +2253,486 @@ unsafe_chars (c1, c2)
    an argument list follows; arguments come from the input stack.  */
 
 static void
-macroexpand (pfile, hp)
-     cpp_reader *pfile;
-     HASHNODE *hp;
+macroexpand(cpp_reader *pfile, HASHNODE *hp)
 {
-  int nargs;
-  DEFINITION *defn = hp->value.defn;
-  register U_CHAR *xbuf;
-  long start_line, start_column;
-  int xbuf_len;
-  struct argdata *args;
-  long old_written = CPP_WRITTEN (pfile);
+    int nargs;
+    DEFINITION *defn = hp->value.defn;
+    register U_CHAR *xbuf;
+    long start_line, start_column;
+    int xbuf_len;
+    struct argdata *args;
+    long old_written = CPP_WRITTEN(pfile);
 #if 0
-  int start_line = instack[indepth].lineno;
+    int start_line = instack[indepth].lineno;
 #endif
-  int rest_args, rest_zero;
-      register int i;
+    int rest_args, rest_zero;
+    register int i;
 
 #if 0
-  CHECK_DEPTH (return;);
+    CHECK_DEPTH(return; );
 #endif
 
 #if 0
-  /* This macro is being used inside a #if, which means it must be */
-  /* recorded as a precondition.  */
-  if (pcp_inside_if && pcp_outfile && defn->predefined)
-    dump_single_macro (hp, pcp_outfile);
+    /* This macro is being used inside a #if, which means it must be */
+    /* recorded as a precondition.  */
+    if (pcp_inside_if && pcp_outfile && defn->predefined)
+        dump_single_macro(hp, pcp_outfile);
 #endif
 
-  pfile->output_escapes++;
-  cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
+    pfile->output_escapes++;
+    cpp_buf_line_and_col(cpp_file_buffer(pfile), &start_line, &start_column);
 
-  nargs = defn->nargs;
+    nargs = defn->nargs;
 
-  if (nargs >= 0)
+    if (nargs >= 0)
     {
-      enum cpp_token token;
-
-      args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
-
-      for (i = 0; i < nargs; i++)
-	{
-	  args[i].raw = args[i].expanded = 0;
-	  args[i].raw_length = 0; 
-	  args[i].expand_length = args[i].stringified_length = -1;
-	  args[i].use_count = 0;
-	}
-
-      /* Parse all the macro args that are supplied.  I counts them.
-	 The first NARGS args are stored in ARGS.
-	 The rest are discarded.  If rest_args is set then we assume
-	 macarg absorbed the rest of the args.  */
-      i = 0;
-      rest_args = 0;
-      rest_args = 0;
-      FORWARD(1); /* Discard the open-parenthesis before the first arg.  */
-      do
-	{
-	  if (rest_args)
-	    continue;
-	  if (i < nargs || (nargs == 0 && i == 0))
-	    {
-	      /* if we are working on last arg which absorbs rest of args... */
-	      if (i == nargs - 1 && defn->rest_args)
-		rest_args = 1;
-	      args[i].raw = CPP_WRITTEN (pfile);
-	      token = macarg (pfile, rest_args);
-	      args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
-	      args[i].newlines = 0; /* FIXME */
-	    }
-	  else
-	    token = macarg (pfile, 0);
-	  if (token == CPP_EOF || token == CPP_POP)
-	    {
-	      cpp_error_with_line (pfile, start_line, start_column,
-				   "unterminated macro call");
-	      return;
-	    }
-	  i++;
-	} while (token == CPP_COMMA);
-
-      /* If we got one arg but it was just whitespace, call that 0 args.  */
-      if (i == 1)
-	{
-	  register U_CHAR *bp = ARG_BASE + args[0].raw;
-	  register U_CHAR *lim = bp + args[0].raw_length;
-	  /* cpp.texi says for foo ( ) we provide one argument.
-	     However, if foo wants just 0 arguments, treat this as 0.  */
-	  if (nargs == 0)
-	    while (bp != lim && is_space[*bp]) bp++;
-	  if (bp == lim)
-	    i = 0;
-	}
-
-      /* Don't output an error message if we have already output one for
-	 a parse error above.  */
-      rest_zero = 0;
-      if (nargs == 0 && i > 0)
-	{
-	  cpp_error (pfile, "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 && CPP_TRADITIONAL (pfile))
-	    ;
-	  /* the rest args token is allowed to absorb 0 tokens */
-	  else if (i == nargs - 1 && defn->rest_args)
-	    rest_zero = 1;
-	  else if (i == 0)
-	    cpp_error (pfile, "macro `%s' used without args", hp->name);
-	  else if (i == 1)
-	    cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
-	  else
-	    cpp_error (pfile, "macro `%s' used with only %d args",
-		       hp->name, i);
-      }
-      else if (i > nargs)
-	{
-	  cpp_error (pfile,
-		     "macro `%s' used with too many (%d) args", hp->name, i);
-	}
+        enum cpp_token token;
+
+        args = (struct argdata *) alloca((nargs + 1) * sizeof (struct argdata));
+
+        for (i = 0; i < nargs; i++)
+        {
+            args[i].raw = args[i].expanded = 0;
+            args[i].raw_length = 0;
+            args[i].expand_length = args[i].stringified_length = -1;
+            args[i].use_count = 0;
+        }
+
+        /* Parse all the macro args that are supplied.  I counts them.
+           The first NARGS args are stored in ARGS.
+           The rest are discarded.  If rest_args is set then we assume
+           macarg absorbed the rest of the args.  */
+        i = 0;
+        rest_args = 0;
+        rest_args = 0;
+        FORWARD(1); /* Discard the open-parenthesis before the first arg.  */
+        do
+        {
+            if (rest_args)
+                continue;
+            if (i < nargs || (nargs == 0 && i == 0))
+            {
+                /* if we are working on last arg which absorbs rest of args... */
+                if (i == nargs - 1 && defn->rest_args)
+                    rest_args = 1;
+                args[i].raw = CPP_WRITTEN(pfile);
+                token = macarg(pfile, rest_args);
+                args[i].raw_length = CPP_WRITTEN(pfile) - args[i].raw;
+                args[i].newlines = 0; /* FIXME */
+            }
+            else
+                token = macarg(pfile, 0);
+            if (token == CPP_EOF || token == CPP_POP)
+            {
+                cpp_error_with_line(pfile, start_line, start_column,
+                                    "unterminated macro call");
+                return;
+            }
+            i++;
+        } while (token == CPP_COMMA);
+
+        /* If we got one arg but it was just whitespace, call that 0 args.  */
+        if (i == 1)
+        {
+            register U_CHAR *bp = ARG_BASE + args[0].raw;
+            register U_CHAR *lim = bp + args[0].raw_length;
+            /* cpp.texi says for foo ( ) we provide one argument.
+               However, if foo wants just 0 arguments, treat this as 0.  */
+            if (nargs == 0)
+                while (bp != lim && is_space[*bp]) bp++;
+            if (bp == lim)
+                i = 0;
+        }
+
+        /* Don't output an error message if we have already output one for
+           a parse error above.  */
+        rest_zero = 0;
+        if (nargs == 0 && i > 0)
+        {
+            cpp_error(pfile, "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 && CPP_TRADITIONAL(pfile))
+                ;
+            /* the rest args token is allowed to absorb 0 tokens */
+            else if (i == nargs - 1 && defn->rest_args)
+                rest_zero = 1;
+            else if (i == 0)
+                cpp_error(pfile, "macro `%s' used without args", hp->name);
+            else if (i == 1)
+                cpp_error(pfile, "macro `%s' used with just one arg", hp->name);
+            else
+                cpp_error(pfile, "macro `%s' used with only %d args",
+                          hp->name, i);
+        }
+        else if (i > nargs)
+        {
+            cpp_error(pfile,
+                      "macro `%s' used with too many (%d) args", hp->name, i);
+        }
     }
 
-  /* If macro wants zero args, we parsed the arglist for checking only.
-     Read directly from the macro definition.  */
-  if (nargs <= 0)
+    /* 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;
+        xbuf = defn->expansion;
+        xbuf_len = defn->length;
     }
-  else
+    else
     {
-      register U_CHAR *exp = defn->expansion;
-      register int offset;	/* offset in expansion,
-				   copied a piece at a time */
-      register int totlen;	/* total amount of exp buffer filled so far */
-
-      register struct reflist *ap, *last_ap;
-
-      /* Macro really takes args.  Compute the expansion of this call.  */
-
-      /* Compute length in characters of the macro's expansion.
-	 Also count number of times each arg is used.  */
-      xbuf_len = defn->length;
-      for (ap = defn->pattern; ap != NULL; ap = ap->next)
-	{
-	  if (ap->stringify)
-	    {
-	      register struct argdata *arg = &args[ap->argno];
-	      /* Stringify if it hasn't already been */
-	      if (arg->stringified_length < 0)
-		{
-		  int arglen = arg->raw_length;
-		  int escaped = 0;
-		  int in_string = 0;
-		  int c;
-		  /* Initially need_space is -1.  Otherwise, 1 means the
-		     previous character was a space, but we suppressed it;
-		     0 means the previous character was a non-space.  */
-		  int need_space = -1;
-		  i = 0;
-		  arg->stringified = CPP_WRITTEN (pfile);
-		  if (!CPP_TRADITIONAL (pfile))
-		    CPP_PUTC (pfile, '\"'); /* insert beginning quote */
-		  for (; i < arglen; i++)
-		    {
-		      c = (ARG_BASE + arg->raw)[i];
-
-		      if (! in_string)
-			{
-			  /* Internal sequences of whitespace are replaced by
-			     one space except within an string or char token.*/
-			  if (is_space[c])
-			    {
-			      if (CPP_WRITTEN (pfile) > (unsigned)arg->stringified
-				  && (CPP_PWRITTEN (pfile))[-1] == '@')
-				{
-				  /* "@ " escape markers are removed */
-				  CPP_ADJUST_WRITTEN (pfile, -1);
-				  continue;
-				}
-			      if (need_space == 0)
-				need_space = 1;
-			      continue;
-			    }
-			  else if (need_space > 0)
-			    CPP_PUTC (pfile, ' ');
-			  need_space = 0;
-			}
-
-		      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 == '\\'))
-			CPP_PUTC (pfile, '\\');
-		      if (ISPRINT (c))
-			CPP_PUTC (pfile, c);
-		      else
-			{
-			  CPP_RESERVE (pfile, 4);
-			  sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o",
-				   (unsigned int) c);
-			  CPP_ADJUST_WRITTEN (pfile, 4);
-			}
-		    }
-		  if (!CPP_TRADITIONAL (pfile))
-		    CPP_PUTC (pfile, '\"'); /* insert ending quote */
-		  arg->stringified_length
-		    = CPP_WRITTEN (pfile) - arg->stringified;
-		}
-	      xbuf_len += args[ap->argno].stringified_length;
-	    }
-	  else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
-	    /* Add 4 for two newline-space markers to prevent
-	       token concatenation.  */
-	    xbuf_len += args[ap->argno].raw_length + 4;
-	  else
-	    {
-	      /* We have an ordinary (expanded) occurrence of the arg.
-		 So compute its expansion, if we have not already.  */
-	      if (args[ap->argno].expand_length < 0)
-		{
-		  args[ap->argno].expanded = CPP_WRITTEN (pfile);
-		  cpp_expand_to_buffer (pfile,
-					ARG_BASE + args[ap->argno].raw,
-					args[ap->argno].raw_length);
-
-		  args[ap->argno].expand_length
-		    = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
-		}
-
-	      /* Add 4 for two newline-space markers to prevent
-		 token concatenation.  */
-	      xbuf_len += args[ap->argno].expand_length + 4;
-	    }
-	  if (args[ap->argno].use_count < 10)
-	    args[ap->argno].use_count++;
-	}
-
-      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 (last_ap = NULL, ap = defn->pattern; ap != NULL;
-	   last_ap = ap, ap = ap->next)
-	{
-	  register struct argdata *arg = &args[ap->argno];
-	  int count_before = totlen;
-
-	  /* Add chars to XBUF.  */
-	  for (i = 0; i < ap->nchars; i++, offset++)
-	    xbuf[totlen++] = exp[offset];
-
-	  /* If followed by an empty rest arg with concatenation,
-	     delete the last run of nonwhite chars.  */
-	  if (rest_zero && totlen > count_before
-	      && ((ap->rest_args && ap->raw_before)
-		  || (last_ap != NULL && last_ap->rest_args
-		      && last_ap->raw_after)))
-	    {
-	      /* Delete final whitespace.  */
-	      while (totlen > count_before && is_space[xbuf[totlen - 1]])
-		totlen--;
-
-	      /* Delete the nonwhites before them.  */
-	      while (totlen > count_before && ! is_space[xbuf[totlen - 1]])
-		totlen--;
-	    }
-
-	  if (ap->stringify != 0)
-	    {
-	      copy_memory (ARG_BASE + arg->stringified,
-		     xbuf + totlen, arg->stringified_length);
-	      totlen += arg->stringified_length;
-	    }
-	  else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
-	    {
-	      U_CHAR *p1 = ARG_BASE + arg->raw;
-	      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++;
-		}
-	      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] == '@')
-		        {
-			  U_CHAR *p2 = l1 - 1;
-			  /* If whitespace is preceded by an odd number
-			     of `@' signs, the last `@' was a whitespace
-			     marker; drop it too. */
-			  while (p2 != p1 && p2[0] == '@') p2--;
-			  if ((l1 - p2) & 1)
-			    l1--;
-			  break;
-			}
-		      else if (l1[-1] == '-')
-			{
-			  U_CHAR *p2 = l1 - 1;
-			  /* If a `-' is preceded by an odd number of
-			     `@' signs then it and the last `@' are
-			     a no-reexpansion marker.  */
-			  while (p2 != p1 && p2[0] == '@') p2--;
-			  if ((l1 - p2) & 1)
-			    l1 -= 2;
-			  else
-			    break;
-			}
-		      else break;
-		    }
-		}
-
-	      /* Delete any no-reexpansion marker that precedes
-		 an identifier at the beginning of the argument. */
-	      if (p1[0] == '@' && p1[1] == '-')
-		p1 += 2;
-
-	      copy_memory (p1, xbuf + totlen, l1 - p1);
-	      totlen += l1 - p1;
-	    }
-	  else
-	    {
-	      U_CHAR *expanded = ARG_BASE + arg->expanded;
-	      if (!ap->raw_before && totlen > 0 && arg->expand_length
-		  && !CPP_TRADITIONAL(pfile)
-		  && unsafe_chars (xbuf[totlen-1], expanded[0]))
-		{
-		  xbuf[totlen++] = '@';
-		  xbuf[totlen++] = ' ';
-		}
-
-	      copy_memory (expanded, xbuf + totlen, arg->expand_length);
-	      totlen += arg->expand_length;
-
-	      if (!ap->raw_after && totlen > 0 && offset < defn->length
-		  && !CPP_TRADITIONAL(pfile)
-		  && unsafe_chars (xbuf[totlen-1], exp[offset]))
-		{
-		  xbuf[totlen++] = '@';
-		  xbuf[totlen++] = ' ';
-		}
-
-	      /* If a macro argument with newlines is used multiple times,
-		 then only expand the newlines once.  This avoids creating
-		 output lines which don't correspond to any input line,
-		 which confuses gdb and gcov.  */
-	      if (arg->use_count > 1 && arg->newlines > 0)
-		{
-		  /* Don't bother doing change_newlines for subsequent
-		     uses of arg.  */
-		  arg->use_count = 1;
-		  arg->expand_length
-		    = change_newlines (expanded, arg->expand_length);
-		}
-	    }
-
-	  if (totlen > xbuf_len)
-	    abort ();
-      }
+        register U_CHAR *exp = defn->expansion;
+        register int offset;    /* offset in expansion,
+                                   copied a piece at a time */
+        register int totlen;    /* total amount of exp buffer filled so far */
+
+        register struct reflist *ap, *last_ap;
 
-      /* if there is anything left of the definition
-	 after handling the arg list, copy that in too.  */
+        /* Macro really takes args.  Compute the expansion of this call.  */
 
-      for (i = offset; i < defn->length; i++)
-	{
-	  /* if we've reached the end of the macro */
-	  if (exp[i] == ')')
-	    rest_zero = 0;
-	  if (! (rest_zero && last_ap != NULL && last_ap->rest_args
-		 && last_ap->raw_after))
-	    xbuf[totlen++] = exp[i];
-	}
+        /* Compute length in characters of the macro's expansion.
+           Also count number of times each arg is used.  */
+        xbuf_len = defn->length;
+        for (ap = defn->pattern; ap != NULL; ap = ap->next)
+        {
+            if (ap->stringify)
+            {
+                register struct argdata *arg = &args[ap->argno];
+                /* Stringify if it hasn't already been */
+                if (arg->stringified_length < 0)
+                {
+                    int arglen = arg->raw_length;
+                    int escaped = 0;
+                    int in_string = 0;
+                    int c;
+                    /* Initially need_space is -1.  Otherwise, 1 means the
+                       previous character was a space, but we suppressed it;
+                       0 means the previous character was a non-space.  */
+                    int need_space = -1;
+                    i = 0;
+                    arg->stringified = CPP_WRITTEN(pfile);
+                    if (!CPP_TRADITIONAL(pfile))
+                        CPP_PUTC(pfile, '\"'); /* insert beginning quote */
+                    for (; i < arglen; i++)
+                    {
+                        c = (ARG_BASE + arg->raw)[i];
 
-      xbuf[totlen] = 0;
-      xbuf_len = totlen;
+                        if (!in_string)
+                        {
+                            /* Internal sequences of whitespace are replaced by
+                               one space except within an string or char token.*/
+                            if (is_space[c])
+                            {
+                                if (CPP_WRITTEN(pfile) > (unsigned)arg->stringified
+                                    && (CPP_PWRITTEN(pfile))[-1] == '@')
+                                {
+                                    /* "@ " escape markers are removed */
+                                    CPP_ADJUST_WRITTEN(pfile, -1);
+                                    continue;
+                                }
+                                if (need_space == 0)
+                                    need_space = 1;
+                                continue;
+                            }
+                            else if (need_space > 0)
+                                CPP_PUTC(pfile, ' ');
+                            need_space = 0;
+                        }
+
+                        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 == '\\'))
+                            CPP_PUTC(pfile, '\\');
+                        if (ISPRINT(c))
+                            CPP_PUTC(pfile, c);
+                        else
+                        {
+                            CPP_RESERVE(pfile, 4);
+                            sprintf((char *)CPP_PWRITTEN(pfile), "\\%03o",
+                                    (unsigned int) c);
+                            CPP_ADJUST_WRITTEN(pfile, 4);
+                        }
+                    }
+                    if (!CPP_TRADITIONAL(pfile))
+                        CPP_PUTC(pfile, '\"'); /* insert ending quote */
+                    arg->stringified_length
+                        = CPP_WRITTEN(pfile) - arg->stringified;
+                }
+                xbuf_len += args[ap->argno].stringified_length;
+            }
+            else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL(pfile))
+                /* Add 4 for two newline-space markers to prevent
+                   token concatenation.  */
+                xbuf_len += args[ap->argno].raw_length + 4;
+            else
+            {
+                /* We have an ordinary (expanded) occurrence of the arg.
+                   So compute its expansion, if we have not already.  */
+                if (args[ap->argno].expand_length < 0)
+                {
+                    args[ap->argno].expanded = CPP_WRITTEN(pfile);
+                    cpp_expand_to_buffer(pfile,
+                                         ARG_BASE + args[ap->argno].raw,
+                                         args[ap->argno].raw_length);
+
+                    args[ap->argno].expand_length
+                        = CPP_WRITTEN(pfile) - args[ap->argno].expanded;
+                }
+
+                /* Add 4 for two newline-space markers to prevent
+                   token concatenation.  */
+                xbuf_len += args[ap->argno].expand_length + 4;
+            }
+            if (args[ap->argno].use_count < 10)
+                args[ap->argno].use_count++;
+        }
+
+        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 (last_ap = NULL, ap = defn->pattern; ap != NULL;
+             last_ap = ap, ap = ap->next)
+        {
+            register struct argdata *arg = &args[ap->argno];
+            int count_before = totlen;
+
+            /* Add chars to XBUF.  */
+            for (i = 0; i < ap->nchars; i++, offset++)
+                xbuf[totlen++] = exp[offset];
+
+            /* If followed by an empty rest arg with concatenation,
+               delete the last run of nonwhite chars.  */
+            if (rest_zero && totlen > count_before
+                && ((ap->rest_args && ap->raw_before)
+                    || (last_ap != NULL && last_ap->rest_args
+                        && last_ap->raw_after)))
+            {
+                /* Delete final whitespace.  */
+                while (totlen > count_before && is_space[xbuf[totlen - 1]])
+                    totlen--;
+
+                /* Delete the nonwhites before them.  */
+                while (totlen > count_before && !is_space[xbuf[totlen - 1]])
+                    totlen--;
+            }
+
+            if (ap->stringify != 0)
+            {
+                copy_memory(ARG_BASE + arg->stringified,
+                            xbuf + totlen, arg->stringified_length);
+                totlen += arg->stringified_length;
+            }
+            else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL(pfile))
+            {
+                U_CHAR *p1 = ARG_BASE + arg->raw;
+                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++;
+                }
+                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] == '@')
+                        {
+                            U_CHAR *p2 = l1 - 1;
+                            /* If whitespace is preceded by an odd number
+                               of `@' signs, the last `@' was a whitespace
+                               marker; drop it too. */
+                            while (p2 != p1 && p2[0] == '@') p2--;
+                            if ((l1 - p2) & 1)
+                                l1--;
+                            break;
+                        }
+                        else if (l1[-1] == '-')
+                        {
+                            U_CHAR *p2 = l1 - 1;
+                            /* If a `-' is preceded by an odd number of
+                               `@' signs then it and the last `@' are
+                               a no-reexpansion marker.  */
+                            while (p2 != p1 && p2[0] == '@') p2--;
+                            if ((l1 - p2) & 1)
+                                l1 -= 2;
+                            else
+                                break;
+                        }
+                        else break;
+                    }
+                }
+
+                /* Delete any no-reexpansion marker that precedes
+                   an identifier at the beginning of the argument. */
+                if (p1[0] == '@' && p1[1] == '-')
+                    p1 += 2;
+
+                copy_memory(p1, xbuf + totlen, l1 - p1);
+                totlen += l1 - p1;
+            }
+            else
+            {
+                U_CHAR *expanded = ARG_BASE + arg->expanded;
+                if (!ap->raw_before && totlen > 0 && arg->expand_length
+                    && !CPP_TRADITIONAL(pfile)
+                    && unsafe_chars(xbuf[totlen-1], expanded[0]))
+                {
+                    xbuf[totlen++] = '@';
+                    xbuf[totlen++] = ' ';
+                }
+
+                copy_memory(expanded, xbuf + totlen, arg->expand_length);
+                totlen += arg->expand_length;
+
+                if (!ap->raw_after && totlen > 0 && offset < defn->length
+                    && !CPP_TRADITIONAL(pfile)
+                    && unsafe_chars(xbuf[totlen-1], exp[offset]))
+                {
+                    xbuf[totlen++] = '@';
+                    xbuf[totlen++] = ' ';
+                }
+
+                /* If a macro argument with newlines is used multiple times,
+                   then only expand the newlines once.  This avoids creating
+                   output lines which don't correspond to any input line,
+                   which confuses gdb and gcov.  */
+                if (arg->use_count > 1 && arg->newlines > 0)
+                {
+                    /* Don't bother doing change_newlines for subsequent
+                       uses of arg.  */
+                    arg->use_count = 1;
+                    arg->expand_length
+                        = change_newlines(expanded, arg->expand_length);
+                }
+            }
+
+            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++)
+        {
+            /* if we've reached the end of the macro */
+            if (exp[i] == ')')
+                rest_zero = 0;
+            if (!(rest_zero && last_ap != NULL && last_ap->rest_args
+                  && last_ap->raw_after))
+                xbuf[totlen++] = exp[i];
+        }
+
+        xbuf[totlen] = 0;
+        xbuf_len = totlen;
 
     }
 
-  pfile->output_escapes--;
-
-  /* Now put the expansion on the input stack
-     so our caller will commence reading from it.  */
-  push_macro_expansion (pfile, xbuf, xbuf_len, hp);
-  CPP_BUFFER (pfile)->has_escapes = 1;
-
-  /* Pop the space we've used in the token_buffer for argument expansion.  */
-  CPP_SET_WRITTEN (pfile, old_written);
-    
-  /* Recursive macro use sometimes works traditionally.
-     #define foo(x,y) bar (x (y,0), y)
-     foo (foo, baz)  */
-  
-  if (!CPP_TRADITIONAL (pfile))
-    hp->type = T_DISABLED;
+    pfile->output_escapes--;
+
+    /* Now put the expansion on the input stack
+       so our caller will commence reading from it.  */
+    push_macro_expansion(pfile, xbuf, xbuf_len, hp);
+    CPP_BUFFER(pfile)->has_escapes = 1;
+
+    /* Pop the space we've used in the token_buffer for argument expansion.  */
+    CPP_SET_WRITTEN(pfile, old_written);
+
+    /* Recursive macro use sometimes works traditionally.
+       #define foo(x,y) bar (x (y,0), y)
+       foo (foo, baz)  */
+
+    if (!CPP_TRADITIONAL(pfile))
+        hp->type = T_DISABLED;
 }
 
 static void
-push_macro_expansion (pfile, xbuf, xbuf_len, hp)
-     cpp_reader *pfile;
-     register U_CHAR *xbuf;
-     int xbuf_len;
-     HASHNODE *hp;
+push_macro_expansion(cpp_reader *pfile, register U_CHAR *xbuf, int xbuf_len, HASHNODE *hp)
 {
-  register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
-  if (mbuf == NULL)
-    return;
-  mbuf->cleanup = macro_cleanup;
-  mbuf->data = hp;
-
-  /* The first chars of the expansion should be a "@ " added by
-     collect_expansion.  This is to prevent accidental token-pasting
-     between the text preceding the macro invocation, and the macro
-     expansion text.
-
-     We would like to avoid adding unneeded spaces (for the sake of
-     tools that use cpp, such as imake).  In some common cases we can
-     tell that it is safe to omit the space.
-
-     The character before the macro invocation cannot have been an
-     idchar (or else it would have been pasted with the idchars of
-     the macro name).  Therefore, if the first non-space character
-     of the expansion is an idchar, we do not need the extra space
-     to prevent token pasting.
-
-     Also, we don't need the extra space if the first char is '(',
-     or some other (less common) characters.  */
-
-  if (xbuf[0] == '@' && xbuf[1] == ' '
-      && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
-	  || xbuf[2] == '\"'))
-    mbuf->cur += 2;
+    register cpp_buffer *mbuf = cpp_push_buffer(pfile, xbuf, xbuf_len);
+    if (mbuf == NULL)
+        return;
+    mbuf->cleanup = macro_cleanup;
+    mbuf->data = hp;
+
+    /* The first chars of the expansion should be a "@ " added by
+       collect_expansion.  This is to prevent accidental token-pasting
+       between the text preceding the macro invocation, and the macro
+       expansion text.
+
+       We would like to avoid adding unneeded spaces (for the sake of
+       tools that use cpp, such as imake).  In some common cases we can
+       tell that it is safe to omit the space.
+
+       The character before the macro invocation cannot have been an
+       idchar (or else it would have been pasted with the idchars of
+       the macro name).  Therefore, if the first non-space character
+       of the expansion is an idchar, we do not need the extra space
+       to prevent token pasting.
+
+       Also, we don't need the extra space if the first char is '(',
+       or some other (less common) characters.  */
+
+    if (xbuf[0] == '@' && xbuf[1] == ' '
+        && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
+            || xbuf[2] == '\"'))
+        mbuf->cur += 2;
 }
-
+
 /* Like cpp_get_token, except that it does not read past end-of-line.
    Also, horizontal space is skipped, and macros are popped.  */
 
 static enum cpp_token
-get_directive_token (pfile)
-     cpp_reader *pfile;
+get_directive_token(cpp_reader *pfile)
 {
-  for (;;)
+    for (;; )
     {
-      long old_written = CPP_WRITTEN (pfile);
-      enum cpp_token token;
-      cpp_skip_hspace (pfile);
-      if (PEEKC () == '\n')
-	  return CPP_VSPACE;
-      token = cpp_get_token (pfile);
-      switch (token)
-      {
-      case CPP_POP:
-	  if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
-	      return token;
-	  /* ... else fall though ...  */
-      case CPP_HSPACE:  case CPP_COMMENT:
-	  CPP_SET_WRITTEN (pfile, old_written);
-	  break;
-      default:
-	  return token;
-      }
+        long old_written = CPP_WRITTEN(pfile);
+        enum cpp_token token;
+        cpp_skip_hspace(pfile);
+        if (PEEKC() == '\n')
+            return CPP_VSPACE;
+        token = cpp_get_token(pfile);
+        switch (token)
+        {
+        case CPP_POP:
+            if (!CPP_IS_MACRO_BUFFER(CPP_BUFFER(pfile)))
+                return token;
+        /* ... else fall though ...  */
+        case CPP_HSPACE:  case CPP_COMMENT:
+            CPP_SET_WRITTEN(pfile, old_written);
+            break;
+        default:
+            return token;
+        }
     }
 }
-
+
 /* Handle #include and #import.
    This function expects to see "fname" or <fname> on the input.
 
@@ -2881,219 +2742,217 @@ get_directive_token (pfile)
    This is safe.  */
 
 static int
-do_include (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword;
+do_include(cpp_reader *pfile, struct directive *keyword)
 {
-  int importing = (keyword->type == T_IMPORT);
-  int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
-  int angle_brackets = 0;	/* 0 for "...", 1 for <...> */
-  int before;  /* included before? */
-  long flen;
-  char *fbeg, *fend;
-  cpp_buffer *fp;
+    int importing = (keyword->type == T_IMPORT);
+    int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
+    int angle_brackets = 0;     /* 0 for "...", 1 for <...> */
+    int before; /* included before? */
+    long flen;
+    char *fbeg, *fend;
+    cpp_buffer *fp;
 
-  enum cpp_token token;
+    enum cpp_token token;
 
-  /* Chain of dirs to search */
-  struct include_hash *ihash;
-  struct file_name_list *search_start;
-  
-  long old_written = CPP_WRITTEN (pfile);
+    /* Chain of dirs to search */
+    struct include_hash *ihash;
+    struct file_name_list *search_start;
 
-  int fd;
+    long old_written = CPP_WRITTEN(pfile);
 
-  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
+    int fd;
+
+    if (CPP_PEDANTIC(pfile) && !CPP_BUFFER(pfile)->system_header_p)
     {
-      if (importing)
-	cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
-      if (skip_dirs)
-	cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'");
+        if (importing)
+            cpp_pedwarn(pfile, "ANSI C does not allow `#import'");
+        if (skip_dirs)
+            cpp_pedwarn(pfile, "ANSI C does not allow `#include_next'");
     }
 
-  if (importing && CPP_OPTIONS (pfile)->warn_import
-      && !CPP_OPTIONS (pfile)->inhibit_warnings
-      && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
+    if (importing && CPP_OPTIONS(pfile)->warn_import
+        && !CPP_OPTIONS(pfile)->inhibit_warnings
+        && !CPP_BUFFER(pfile)->system_header_p && !pfile->import_warning)
     {
-      pfile->import_warning = 1;
-      cpp_warning (pfile, "`#import' is obsolete, use an #ifdef wrapper in the header file");
+        pfile->import_warning = 1;
+        cpp_warning(pfile, "`#import' is obsolete, use an #ifdef wrapper in the header file");
     }
 
-  pfile->parsing_include_directive++;
-  token = get_directive_token (pfile);
-  pfile->parsing_include_directive--;
+    pfile->parsing_include_directive++;
+    token = get_directive_token(pfile);
+    pfile->parsing_include_directive--;
 
-  if (token == CPP_STRING)
+    if (token == CPP_STRING)
     {
-      fbeg = pfile->token_buffer + old_written + 1;
-      fend = CPP_PWRITTEN (pfile) - 1;
-      *fend = '\0';
-      if (fbeg[-1] == '<')
-	  angle_brackets = 1;
+        fbeg = pfile->token_buffer + old_written + 1;
+        fend = CPP_PWRITTEN(pfile) - 1;
+        *fend = '\0';
+        if (fbeg[-1] == '<')
+            angle_brackets = 1;
     }
-  else
+    else
     {
-      cpp_error (pfile,
-		 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
-      CPP_SET_WRITTEN (pfile, old_written);
-      skip_rest_of_line (pfile);
-      return 0;
+        cpp_error(pfile,
+                  "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
+        CPP_SET_WRITTEN(pfile, old_written);
+        skip_rest_of_line(pfile);
+        return 0;
     }
 
-  token = get_directive_token (pfile);
-  if (token != CPP_VSPACE)
+    token = get_directive_token(pfile);
+    if (token != CPP_VSPACE)
     {
-      cpp_error (pfile, "junk at end of `#include'");
-      skip_rest_of_line (pfile);
+        cpp_error(pfile, "junk at end of `#include'");
+        skip_rest_of_line(pfile);
     }
 
-  CPP_SET_WRITTEN (pfile, old_written);
+    CPP_SET_WRITTEN(pfile, old_written);
 
-  flen = fend - fbeg;
+    flen = fend - fbeg;
 
-  if (flen == 0)
+    if (flen == 0)
     {
-      cpp_error (pfile, "empty file name in `#%s'", keyword->name);
-      return 0;
+        cpp_error(pfile, "empty file name in `#%s'", keyword->name);
+        return 0;
     }
 
-  search_start = 0;
+    search_start = 0;
 
-  for (fp = CPP_BUFFER (pfile);
-       fp != CPP_NULL_BUFFER (pfile);
-       fp = CPP_PREV_BUFFER (fp))
-    if (fp->fname != NULL)
-      break;
+    for (fp = CPP_BUFFER(pfile);
+         fp != CPP_NULL_BUFFER(pfile);
+         fp = CPP_PREV_BUFFER(fp))
+        if (fp->fname != NULL)
+            break;
 
-  if (fp == CPP_NULL_BUFFER (pfile))
+    if (fp == CPP_NULL_BUFFER(pfile))
     {
-      cpp_fatal (pfile, "cpp internal error: fp == NULL_BUFFER in do_include");
-      return 1;
+        cpp_fatal(pfile, "cpp internal error: fp == NULL_BUFFER in do_include");
+        return 1;
     }
-  
-  /* For #include_next, skip in the search path past the dir in which the
-     containing file was found.  Treat files specified using an absolute path
-     as if there are no more directories to search.  Treat the primary source
-     file like any other included source, but generate a warning.  */
-  if (skip_dirs && CPP_PREV_BUFFER(fp) != CPP_NULL_BUFFER (pfile))
+
+    /* For #include_next, skip in the search path past the dir in which the
+       containing file was found.  Treat files specified using an absolute path
+       as if there are no more directories to search.  Treat the primary source
+       file like any other included source, but generate a warning.  */
+    if (skip_dirs && CPP_PREV_BUFFER(fp) != CPP_NULL_BUFFER(pfile))
     {
-      if (fp->ihash->foundhere != ABSOLUTE_PATH)
-	search_start = fp->ihash->foundhere->next;
+        if (fp->ihash->foundhere != ABSOLUTE_PATH)
+            search_start = fp->ihash->foundhere->next;
     }
-  else
+    else
     {
-      if (skip_dirs)
-	cpp_warning (pfile, "#include_next in primary source file");
-      
-      if (angle_brackets)
-	search_start = CPP_OPTIONS (pfile)->bracket_include;
-      else
+        if (skip_dirs)
+            cpp_warning(pfile, "#include_next in primary source file");
+
+        if (angle_brackets)
+            search_start = CPP_OPTIONS(pfile)->bracket_include;
+        else
         {
-	  if (!CPP_OPTIONS (pfile)->ignore_srcdir)
-	    {
-	      if (fp)
-		search_start = fp->actual_dir;
-	    }
-	  else
-	    search_start = CPP_OPTIONS (pfile)->quote_include;
-	}
+            if (!CPP_OPTIONS(pfile)->ignore_srcdir)
+            {
+                if (fp)
+                    search_start = fp->actual_dir;
+            }
+            else
+                search_start = CPP_OPTIONS(pfile)->quote_include;
+        }
     }
 
-  if (!search_start)
+    if (!search_start)
     {
-      cpp_error (pfile, "No include path in which to find %s", fbeg);
-      return 0;
+        cpp_error(pfile, "No include path in which to find %s", fbeg);
+        return 0;
     }
 
-  fd = find_include_file (pfile, fbeg, search_start, &ihash, &before);
+    fd = find_include_file(pfile, fbeg, search_start, &ihash, &before);
 
-  if (fd == -2)
-    return 0;
-  
-  if (fd == -1)
+    if (fd == -2)
+        return 0;
+
+    if (fd == -1)
     {
-      if (CPP_OPTIONS (pfile)->print_deps_missing_files
-	  && CPP_PRINT_DEPS (pfile) > (angle_brackets ||
-				       (pfile->system_include_depth > 0)))
+        if (CPP_OPTIONS(pfile)->print_deps_missing_files
+            && CPP_PRINT_DEPS(pfile) > (angle_brackets ||
+                                        (pfile->system_include_depth > 0)))
         {
-	  if (!angle_brackets)
-	    deps_output (pfile, fbeg, ' ');
-	  else
-	    {
-	      char *p;
-	      struct file_name_list *ptr;
-	      /* If requested as a system header, assume it belongs in
-		 the first system header directory. */
-	      if (CPP_OPTIONS (pfile)->bracket_include)
-	        ptr = CPP_OPTIONS (pfile)->bracket_include;
-	      else
-	        ptr = CPP_OPTIONS (pfile)->quote_include;
-
-	      p = (char *) alloca (strlen (ptr->name)
-				   + strlen (fbeg) + 2);
-	      if (*ptr->name != '\0')
-	        {
-		  strcpy (p, ptr->name);
-		  strcat (p, "/");
-	        }
-	      strcat (p, fbeg);
-	      deps_output (pfile, p, ' ');
-	    }
-	}
-      /* If -M was specified, and this header file won't be added to
-	 the dependency list, then don't count this as an error,
-	 because we can still produce correct output.  Otherwise, we
-	 can't produce correct output, because there may be
-	 dependencies we need inside the missing file, and we don't
-	 know what directory this missing file exists in. */
-      else if (CPP_PRINT_DEPS (pfile)
-	       && (CPP_PRINT_DEPS (pfile)
-		   <= (angle_brackets || (pfile->system_include_depth > 0))))
-	cpp_warning (pfile, "No include path in which to find %s", fbeg);
-      else
-	cpp_error_from_errno (pfile, fbeg);
+            if (!angle_brackets)
+                deps_output(pfile, fbeg, ' ');
+            else
+            {
+                char *p;
+                struct file_name_list *ptr;
+                /* If requested as a system header, assume it belongs in
+                   the first system header directory. */
+                if (CPP_OPTIONS(pfile)->bracket_include)
+                    ptr = CPP_OPTIONS(pfile)->bracket_include;
+                else
+                    ptr = CPP_OPTIONS(pfile)->quote_include;
+
+                p = (char *) alloca(strlen(ptr->name)
+                                    + strlen(fbeg) + 2);
+                if (*ptr->name != '\0')
+                {
+                    strcpy(p, ptr->name);
+                    strcat(p, "/");
+                }
+                strcat(p, fbeg);
+                deps_output(pfile, p, ' ');
+            }
+        }
+        /* If -M was specified, and this header file won't be added to
+           the dependency list, then don't count this as an error,
+           because we can still produce correct output.  Otherwise, we
+           can't produce correct output, because there may be
+           dependencies we need inside the missing file, and we don't
+           know what directory this missing file exists in. */
+        else if (CPP_PRINT_DEPS(pfile)
+                 && (CPP_PRINT_DEPS(pfile)
+                     <= (angle_brackets || (pfile->system_include_depth > 0))))
+            cpp_warning(pfile, "No include path in which to find %s", fbeg);
+        else
+            cpp_error_from_errno(pfile, fbeg);
 
-      return 0;
+        return 0;
     }
 
-  /* For -M, add the file to the dependencies on its first inclusion. */
-  if (!before && (CPP_PRINT_DEPS (pfile)
-		  > (angle_brackets || (pfile->system_include_depth > 0))))
-    deps_output (pfile, ihash->name, ' ');
+    /* For -M, add the file to the dependencies on its first inclusion. */
+    if (!before && (CPP_PRINT_DEPS(pfile)
+                    > (angle_brackets || (pfile->system_include_depth > 0))))
+        deps_output(pfile, ihash->name, ' ');
 
-  /* Handle -H option.  */
-  if (CPP_OPTIONS(pfile)->print_include_names)
+    /* Handle -H option.  */
+    if (CPP_OPTIONS(pfile)->print_include_names)
     {
-      fp = CPP_BUFFER (pfile);
-      while ((fp = CPP_PREV_BUFFER (fp)) != CPP_NULL_BUFFER (pfile))
-	putc ('.', stderr);
-      fprintf (stderr, " %s\n", ihash->name);
+        fp = CPP_BUFFER(pfile);
+        while ((fp = CPP_PREV_BUFFER(fp)) != CPP_NULL_BUFFER(pfile))
+            putc('.', stderr);
+        fprintf(stderr, " %s\n", ihash->name);
     }
 
-  /* Actually process the file */
+    /* Actually process the file */
 
-  if (importing)
-    ihash->control_macro = "";
-  
-  if (cpp_push_buffer (pfile, NULL, 0) == NULL)
+    if (importing)
+        ihash->control_macro = "";
+
+    if (cpp_push_buffer(pfile, NULL, 0) == NULL)
     {
-      close (fd);
-      return 0;
+        close(fd);
+        return 0;
     }
-  
-  if (angle_brackets)
-    pfile->system_include_depth++;   /* Decremented in file_cleanup. */
 
-  if (finclude (pfile, fd, ihash))
+    if (angle_brackets)
+        pfile->system_include_depth++; /* Decremented in file_cleanup. */
+
+    if (finclude(pfile, fd, ihash))
     {
-      output_line_command (pfile, 0, enter_file);
-      pfile->only_seen_white = 2;
+        output_line_command(pfile, 0, enter_file);
+        pfile->only_seen_white = 2;
     }
 
-  return 0;
+    return 0;
 }
 
-
+
 /* Convert a character string literal into a nul-terminated string.
    The input string is [IN ... LIMIT).
    The result is placed in RESULT.  RESULT can be the same as IN.
@@ -3101,42 +2960,39 @@ do_include (pfile, keyword)
    or NULL on error.  */
 
 static U_CHAR *
-convert_string (pfile, result, in, limit, handle_escapes)
-     cpp_reader *pfile;
-     register U_CHAR *result, *in, *limit;
-     int handle_escapes;
+convert_string(cpp_reader *pfile, register U_CHAR *result, register U_CHAR *in, register U_CHAR *limit, int handle_escapes)
 {
-  U_CHAR c;
-  c = *in++;
-  if (c != '\"')
-    return NULL;
-  while (in < limit)
+    U_CHAR c;
+    c = *in++;
+    if (c != '\"')
+        return NULL;
+    while (in < limit)
     {
-      U_CHAR c = *in++;
-      switch (c)
-	{
-	case '\0':
-	  return NULL;
-	case '\"':
-	  limit = in;
-	  break;
-	case '\\':
-	  if (handle_escapes)
-	    {
-	      char *bpc = (char *) in;
-	      int i = (U_CHAR) cpp_parse_escape (pfile, &bpc, 0x00ff);
-	      in = (U_CHAR *) bpc;
-	      if (i >= 0)
-		*result++ = (U_CHAR)c;
-	      break;
-	    }
-	  /* else fall through */
-	default:
-	  *result++ = c;
-	}
+        U_CHAR c = *in++;
+        switch (c)
+        {
+        case '\0':
+            return NULL;
+        case '\"':
+            limit = in;
+            break;
+        case '\\':
+            if (handle_escapes)
+            {
+                char *bpc = (char *) in;
+                int i = (U_CHAR) cpp_parse_escape(pfile, &bpc, 0x00ff);
+                in = (U_CHAR *) bpc;
+                if (i >= 0)
+                    *result++ = (U_CHAR)c;
+                break;
+            }
+        /* else fall through */
+        default:
+            *result++ = c;
+        }
     }
-  *result = 0;
-  return result;
+    *result = 0;
+    return result;
 }
 
 /*
@@ -3146,127 +3002,125 @@ convert_string (pfile, result, in, limit, handle_escapes)
 #define FNAME_HASHSIZE 37
 
 static int
-do_line (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_line(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-  int new_lineno;
-  long old_written = CPP_WRITTEN (pfile);
-  enum file_change_code file_change = same_file;
-  enum cpp_token token;
+    cpp_buffer *ip = CPP_BUFFER(pfile);
+    int new_lineno;
+    long old_written = CPP_WRITTEN(pfile);
+    enum file_change_code file_change = same_file;
+    enum cpp_token token;
 
-  token = get_directive_token (pfile);
+    token = get_directive_token(pfile);
 
-  if (token != CPP_NUMBER
-      || !ISDIGIT(pfile->token_buffer[old_written]))
+    if (token != CPP_NUMBER
+        || !ISDIGIT(pfile->token_buffer[old_written]))
     {
-      cpp_error (pfile, "invalid format `#line' command");
-      goto bad_line_directive;
+        cpp_error(pfile, "invalid format `#line' command");
+        goto bad_line_directive;
     }
 
-  /* 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 ((char *)(pfile->token_buffer + old_written)) - 1;
-  CPP_SET_WRITTEN (pfile, old_written);
+    /* 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((char *)(pfile->token_buffer + old_written)) - 1;
+    CPP_SET_WRITTEN(pfile, old_written);
 
-  /* NEW_LINENO is one less than the actual line number here.  */
-  if (CPP_PEDANTIC (pfile) && new_lineno < 0)
-    cpp_pedwarn (pfile, "line number out of range in `#line' command");
+    /* NEW_LINENO is one less than the actual line number here.  */
+    if (CPP_PEDANTIC(pfile) && new_lineno < 0)
+        cpp_pedwarn(pfile, "line number out of range in `#line' command");
 
 #if 0 /* #line 10"foo.c" is supposed to be allowed.  */
-  if (PEEKC() && !is_space[PEEKC()]) {
-    cpp_error (pfile, "invalid format `#line' command");
-    goto bad_line_directive;
-  }
-#endif
-
-  token = get_directive_token (pfile);
-
-  if (token == CPP_STRING) {
-    U_CHAR *fname = pfile->token_buffer + old_written;
-    U_CHAR *end_name;
-    static HASHNODE *fname_table[FNAME_HASHSIZE];
-    HASHNODE *hp, **hash_bucket;
-    U_CHAR *p;
-    long num_start;
-    int fname_length;
-
-    /* Turn the file name, which is a character string literal,
-       into a null-terminated string.  Do this in place.  */
-    end_name = convert_string (pfile, fname, fname, CPP_PWRITTEN (pfile), 1);
-    if (end_name == NULL)
-    {
-	cpp_error (pfile, "invalid format `#line' command");
-	goto bad_line_directive;
+    if (PEEKC() && !is_space[PEEKC()]) {
+        cpp_error(pfile, "invalid format `#line' command");
+        goto bad_line_directive;
     }
+#endif
 
-    fname_length = end_name - fname;
+    token = get_directive_token(pfile);
+
+    if (token == CPP_STRING) {
+        U_CHAR *fname = pfile->token_buffer + old_written;
+        U_CHAR *end_name;
+        static HASHNODE *fname_table[FNAME_HASHSIZE];
+        HASHNODE *hp, **hash_bucket;
+        U_CHAR *p;
+        long num_start;
+        int fname_length;
+
+        /* Turn the file name, which is a character string literal,
+           into a null-terminated string.  Do this in place.  */
+        end_name = convert_string(pfile, fname, fname, CPP_PWRITTEN(pfile), 1);
+        if (end_name == NULL)
+        {
+            cpp_error(pfile, "invalid format `#line' command");
+            goto bad_line_directive;
+        }
 
-    num_start = CPP_WRITTEN (pfile);
-    token = get_directive_token (pfile);
-    if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
-      p = pfile->token_buffer + num_start;
-      if (CPP_PEDANTIC (pfile))
-	cpp_pedwarn (pfile, "garbage at end of `#line' command");
+        fname_length = end_name - fname;
+
+        num_start = CPP_WRITTEN(pfile);
+        token = get_directive_token(pfile);
+        if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
+            p = pfile->token_buffer + num_start;
+            if (CPP_PEDANTIC(pfile))
+                cpp_pedwarn(pfile, "garbage at end of `#line' command");
+
+            if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
+            {
+                cpp_error(pfile, "invalid format `#line' command");
+                goto bad_line_directive;
+            }
+            if (*p == '1')
+                file_change = enter_file;
+            else if (*p == '2')
+                file_change = leave_file;
+            else if (*p == '3')
+                ip->system_header_p = 1;
+            else /* if (*p == '4') */
+                ip->system_header_p = 2;
+
+            CPP_SET_WRITTEN(pfile, num_start);
+            token = get_directive_token(pfile);
+            p = pfile->token_buffer + num_start;
+            if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
+                ip->system_header_p = *p == '3' ? 1 : 2;
+                token = get_directive_token(pfile);
+            }
+            if (token != CPP_VSPACE) {
+                cpp_error(pfile, "invalid format `#line' command");
+                goto bad_line_directive;
+            }
+        }
 
-      if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
-      {
-	cpp_error (pfile, "invalid format `#line' command");
-	goto bad_line_directive;
-      }
-      if (*p == '1')
-	file_change = enter_file;
-      else if (*p == '2')
-	file_change = leave_file;
-      else if (*p == '3')
-	ip->system_header_p = 1;
-      else /* if (*p == '4') */
-	ip->system_header_p = 2;
-
-      CPP_SET_WRITTEN (pfile, num_start);
-      token = get_directive_token (pfile);
-      p = pfile->token_buffer + num_start;
-      if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
-	ip->system_header_p = *p == '3' ? 1 : 2;
-	token = get_directive_token (pfile);
-      }
-      if (token != CPP_VSPACE) {
-	cpp_error (pfile, "invalid format `#line' command");
-	goto bad_line_directive;
-      }
+        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, fname, fname_length) == 0) {
+                ip->nominal_fname = hp->value.cpval;
+                break;
+            }
+        if (hp == 0) {
+            /* 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->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
+            copy_memory(fname, hp->value.cpval, fname_length);
+        }
     }
-
-    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, fname, fname_length) == 0) {
-	ip->nominal_fname = hp->value.cpval;
-	break;
-      }
-    if (hp == 0) {
-      /* 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->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
-      copy_memory (fname, hp->value.cpval, fname_length);
+    else if (token != CPP_VSPACE && token != CPP_EOF) {
+        cpp_error(pfile, "invalid format `#line' command");
+        goto bad_line_directive;
     }
-  }
-  else if (token != CPP_VSPACE && token != CPP_EOF) {
-    cpp_error (pfile, "invalid format `#line' command");
-    goto bad_line_directive;
-  }
 
-  ip->lineno = new_lineno;
- bad_line_directive:
-  skip_rest_of_line (pfile);
-  CPP_SET_WRITTEN (pfile, old_written);
-  output_line_command (pfile, 0, file_change);
-  return 0;
+    ip->lineno = new_lineno;
+bad_line_directive:
+    skip_rest_of_line(pfile);
+    CPP_SET_WRITTEN(pfile, old_written);
+    output_line_command(pfile, 0, file_change);
+    return 0;
 }
 
 /*
@@ -3276,80 +3130,76 @@ do_line (pfile, keyword)
  */
 
 static int
-do_undef (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword;
+do_undef(cpp_reader *pfile, struct directive *keyword)
 {
-  int sym_length;
-  HASHNODE *hp;
-  U_CHAR *buf, *name, *limit;
-  int c;
-  long here = CPP_WRITTEN (pfile);
-  enum cpp_token token;
-
-  cpp_skip_hspace (pfile);
-  c = GETC();
-  if (! is_idstart[c])
-  {
-      cpp_error (pfile, "token after #undef is not an identifier");
-      skip_rest_of_line (pfile);
-      return 1;
-  }
+    int sym_length;
+    HASHNODE *hp;
+    U_CHAR *buf, *name, *limit;
+    int c;
+    long here = CPP_WRITTEN(pfile);
+    enum cpp_token token;
+
+    cpp_skip_hspace(pfile);
+    c = GETC();
+    if (!is_idstart[c])
+    {
+        cpp_error(pfile, "token after #undef is not an identifier");
+        skip_rest_of_line(pfile);
+        return 1;
+    }
 
-  parse_name (pfile, c);
-  buf = pfile->token_buffer + here;
-  limit = CPP_PWRITTEN(pfile);
+    parse_name(pfile, c);
+    buf = pfile->token_buffer + here;
+    limit = CPP_PWRITTEN(pfile);
 
-  /* Copy out the token so we can pop the token buffer. */
-  name = alloca (limit - buf + 1);
-  copy_memory(buf, name, limit - buf);
-  name[limit - buf] = '\0';
+    /* Copy out the token so we can pop the token buffer. */
+    name = alloca(limit - buf + 1);
+    copy_memory(buf, name, limit - buf);
+    name[limit - buf] = '\0';
 
-  token = get_directive_token (pfile);
-  if (token != CPP_VSPACE && token != CPP_POP)
-  {
-      cpp_pedwarn (pfile, "junk on line after #undef");
-      skip_rest_of_line (pfile);
-  }
+    token = get_directive_token(pfile);
+    if (token != CPP_VSPACE && token != CPP_POP)
+    {
+        cpp_pedwarn(pfile, "junk on line after #undef");
+        skip_rest_of_line(pfile);
+    }
 
-  CPP_SET_WRITTEN (pfile, here);
+    CPP_SET_WRITTEN(pfile, here);
 
 #if 0
-  /* If this is a precompiler run (with -pcp) pass thru #undef commands.  */
-  if (pcp_outfile && keyword)
-    pass_thru_directive (buf, limit, pfile, keyword);
+    /* If this is a precompiler run (with -pcp) pass thru #undef commands.  */
+    if (pcp_outfile && keyword)
+        pass_thru_directive(buf, limit, pfile, keyword);
 #endif
 
-  sym_length = check_macro_name (pfile, name, "macro");
+    sym_length = check_macro_name(pfile, name, "macro");
 
-  while ((hp = cpp_lookup (pfile, name, sym_length, -1)) != NULL)
+    while ((hp = cpp_lookup(pfile, name, sym_length, -1)) != NULL)
     {
-      /* If we are generating additional info for debugging (with -g) we
-	 need to pass through all effective #undef commands.  */
-      if (CPP_OPTIONS (pfile)->debug_output && keyword)
-	pass_thru_directive (name, name+sym_length, pfile, keyword);
-      if (hp->type != T_MACRO)
-	cpp_warning (pfile, "undefining `%s'", hp->name);
-      delete_macro (hp);
+        /* If we are generating additional info for debugging (with -g) we
+           need to pass through all effective #undef commands.  */
+        if (CPP_OPTIONS(pfile)->debug_output && keyword)
+            pass_thru_directive(name, name+sym_length, pfile, keyword);
+        if (hp->type != T_MACRO)
+            cpp_warning(pfile, "undefining `%s'", hp->name);
+        delete_macro(hp);
     }
 
-  return 0;
+    return 0;
 }
 
 /* Wrap do_undef for -U processing. */
 static void
-cpp_undef (pfile, macro)
-     cpp_reader *pfile;
-     U_CHAR *macro;
+cpp_undef(cpp_reader *pfile, U_CHAR *macro)
 {
-    if (cpp_push_buffer (pfile, macro, strlen(macro)))
+    if (cpp_push_buffer(pfile, macro, strlen(macro)))
     {
-	do_undef (pfile, NULL);
-	cpp_pop_buffer (pfile);
+        do_undef(pfile, NULL);
+        cpp_pop_buffer(pfile);
     }
 }
 
-
+
 /*
  * Report an error detected by the program we are processing.
  * Use the text of the line in the error message.
@@ -3357,19 +3207,17 @@ cpp_undef (pfile, macro)
  */
 
 static int
-do_error (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_error(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  long here = CPP_WRITTEN (pfile);
-  U_CHAR *text;
-  copy_rest_of_line (pfile);
-  text = pfile->token_buffer + here;
-  SKIP_WHITE_SPACE(text);
-
-  cpp_error (pfile, "#error %s", text);
-  CPP_SET_WRITTEN (pfile, here);
-  return 0;
+    long here = CPP_WRITTEN(pfile);
+    U_CHAR *text;
+    copy_rest_of_line(pfile);
+    text = pfile->token_buffer + here;
+    SKIP_WHITE_SPACE(text);
+
+    cpp_error(pfile, "#error %s", text);
+    CPP_SET_WRITTEN(pfile, here);
+    return 0;
 }
 
 /*
@@ -3378,122 +3226,102 @@ do_error (pfile, keyword)
  */
 
 static int
-do_warning (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_warning(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  U_CHAR *text;
-  long here = CPP_WRITTEN(pfile);
-  copy_rest_of_line (pfile);
-  text = pfile->token_buffer + here;
-  SKIP_WHITE_SPACE(text);
-
-  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
-    cpp_pedwarn (pfile, "ANSI C does not allow `#warning'");
-
-  /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
-     if -pedantic-errors is given, #warning should cause an error.  */
-  cpp_pedwarn (pfile, "#warning %s", text);
-  CPP_SET_WRITTEN (pfile, here);
-  return 0;
+    U_CHAR *text;
+    long here = CPP_WRITTEN(pfile);
+    copy_rest_of_line(pfile);
+    text = pfile->token_buffer + here;
+    SKIP_WHITE_SPACE(text);
+
+    if (CPP_PEDANTIC(pfile) && !CPP_BUFFER(pfile)->system_header_p)
+        cpp_pedwarn(pfile, "ANSI C does not allow `#warning'");
+
+    /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
+       if -pedantic-errors is given, #warning should cause an error.  */
+    cpp_pedwarn(pfile, "#warning %s", text);
+    CPP_SET_WRITTEN(pfile, here);
+    return 0;
 }
 
 /* Report program identification.  */
 
 static int
-do_ident (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_ident(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  /* Allow #ident in system headers, since that's not user's fault.  */
-  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
-    cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");
+    /* Allow #ident in system headers, since that's not user's fault.  */
+    if (CPP_PEDANTIC(pfile) && !CPP_BUFFER(pfile)->system_header_p)
+        cpp_pedwarn(pfile, "ANSI C does not allow `#ident'");
 
-  skip_rest_of_line (pfile);  /* Correct?  Appears to match cccp.  */
+    skip_rest_of_line(pfile); /* Correct?  Appears to match cccp.  */
 
-  return 0;
+    return 0;
 }
 
 /* Just check for some recognized pragmas that need validation here,
    and leave the text in the token buffer to be output. */
 
 static int
-do_pragma (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_pragma(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  long here = CPP_WRITTEN (pfile);
-  U_CHAR *buf;
-  
-  copy_rest_of_line (pfile);
-  buf = pfile->token_buffer + here;
-  SKIP_WHITE_SPACE (buf);
-  
-  if (!strncmp (buf, "once", 4))
-    {
-      cpp_buffer *ip = NULL;
-
-      /* Allow #pragma once in system headers, since that's not the user's
-	 fault.  */
-      if (!CPP_BUFFER (pfile)->system_header_p)
-	cpp_warning (pfile, "`#pragma once' is obsolete");
-      
-      for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
-        {
-	  if (ip == CPP_NULL_BUFFER (pfile))
-	    return 0;
-	  if (ip->fname != NULL)
-	    break;
-	}
-
-      if (CPP_PREV_BUFFER (ip) == CPP_NULL_BUFFER (pfile))
-	cpp_warning (pfile, "`#pragma once' outside include file");
-      else
-	ip->ihash->control_macro = "";  /* never repeat */
-    }
+    long here = CPP_WRITTEN(pfile);
+    U_CHAR *buf;
+
+    copy_rest_of_line(pfile);
+    buf = pfile->token_buffer + here;
+    SKIP_WHITE_SPACE(buf);
 
-  if (!strncmp (buf, "implementation", 14))
+    if (!strncmp(buf, "once", 4))
     {
-      /* Be quiet about `#pragma implementation' for a file only if it hasn't
-	 been included yet.  */
-      struct include_hash *ptr;
-      U_CHAR *p = buf + 14, *fname, *fcopy;
-      SKIP_WHITE_SPACE (p);
-      if (*p == '\n' || *p != '\"')
-        return 0;
+        cpp_buffer *ip = NULL;
 
-      fname = p + 1;
-      p = (U_CHAR *) strchr (fname, '\"');
+        /* Allow #pragma once in system headers, since that's not the user's
+           fault.  */
+        if (!CPP_BUFFER(pfile)->system_header_p)
+            cpp_warning(pfile, "`#pragma once' is obsolete");
 
-      fcopy = alloca (p - fname + 1);
-      copy_memory (fname, fcopy, p - fname);
-      fcopy[p-fname] = '\0';
+        for (ip = CPP_BUFFER(pfile);; ip = CPP_PREV_BUFFER(ip))
+        {
+            if (ip == CPP_NULL_BUFFER(pfile))
+                return 0;
+            if (ip->fname != NULL)
+                break;
+        }
+
+        if (CPP_PREV_BUFFER(ip) == CPP_NULL_BUFFER(pfile))
+            cpp_warning(pfile, "`#pragma once' outside include file");
+        else
+            ip->ihash->control_macro = ""; /* never repeat */
+    }
 
-      ptr = include_hash (pfile, fcopy, 0);
-      if (ptr)
-        cpp_warning (pfile,
-	  "`#pragma implementation' for `%s' appears after file is included",
-		     fcopy);
+    if (!strncmp(buf, "implementation", 14))
+    {
+        /* Be quiet about `#pragma implementation' for a file only if it hasn't
+           been included yet.  */
+        struct include_hash *ptr;
+        U_CHAR *p = buf + 14, *fname, *fcopy;
+        SKIP_WHITE_SPACE(p);
+        if (*p == '\n' || *p != '\"')
+            return 0;
+
+        fname = p + 1;
+        p = (U_CHAR *) strchr(fname, '\"');
+
+        fcopy = alloca(p - fname + 1);
+        copy_memory(fname, fcopy, p - fname);
+        fcopy[p-fname] = '\0';
+
+        ptr = include_hash(pfile, fcopy, 0);
+        if (ptr)
+            cpp_warning(pfile,
+                        "`#pragma implementation' for `%s' appears after file is included",
+                        fcopy);
     }
 
-  return 0;
+    return 0;
 }
 
-#ifdef SCCS_DIRECTIVE
-/* Just ignore #sccs, on systems where we define it at all.  */
 
-static int
-do_sccs (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
-{
-  if (CPP_PEDANTIC (pfile))
-    cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
-  skip_rest_of_line (pfile);
-  return 0;
-}
-#endif
-
 /*
  * handle #if command by
  *   1) inserting special `defined' keyword into the hash table
@@ -3508,13 +3336,11 @@ do_sccs (pfile, keyword)
  */
 
 static int
-do_if (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_if(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  HOST_WIDE_INT value = eval_if_expression (pfile);
-  conditional_skip (pfile, value == 0, T_IF, NULL);
-  return 0;
+    HOST_WIDE_INT value = eval_if_expression(pfile);
+    conditional_skip(pfile, value == 0, T_IF, NULL);
+    return 0;
 }
 
 /*
@@ -3523,40 +3349,38 @@ do_if (pfile, keyword)
  */
 
 static int
-do_elif (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_elif(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
-    cpp_error (pfile, "`#elif' not within a conditional");
-    return 0;
-  } else {
-    if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
-      cpp_error (pfile, "`#elif' after `#else'");
+    if (pfile->if_stack == CPP_BUFFER(pfile)->if_stack) {
+        cpp_error(pfile, "`#elif' not within a conditional");
+        return 0;
+    } else {
+        if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
+            cpp_error(pfile, "`#elif' after `#else'");
 #if 0
-      fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
+            fprintf(stderr, " (matches line %d", pfile->if_stack->lineno);
 #endif
-      if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
-	  && strcmp (pfile->if_stack->fname,
-		     CPP_BUFFER (pfile)->nominal_fname) != 0)
-	fprintf (stderr, ", file %s", pfile->if_stack->fname);
-      fprintf (stderr, ")\n");
+            if (pfile->if_stack->fname != NULL && CPP_BUFFER(pfile)->fname != NULL
+                && strcmp(pfile->if_stack->fname,
+                          CPP_BUFFER(pfile)->nominal_fname) != 0)
+                fprintf(stderr, ", file %s", pfile->if_stack->fname);
+            fprintf(stderr, ")\n");
+        }
+        pfile->if_stack->type = T_ELIF;
     }
-    pfile->if_stack->type = T_ELIF;
-  }
 
-  if (pfile->if_stack->if_succeeded)
-    skip_if_group (pfile);
-  else {
-    HOST_WIDE_INT value = eval_if_expression (pfile);
-    if (value == 0)
-      skip_if_group (pfile);
+    if (pfile->if_stack->if_succeeded)
+        skip_if_group(pfile);
     else {
-      ++pfile->if_stack->if_succeeded;	/* continue processing input */
-      output_line_command (pfile, 1, same_file);
+        HOST_WIDE_INT value = eval_if_expression(pfile);
+        if (value == 0)
+            skip_if_group(pfile);
+        else {
+            ++pfile->if_stack->if_succeeded; /* continue processing input */
+            output_line_command(pfile, 1, same_file);
+        }
     }
-  }
-  return 0;
+    return 0;
 }
 
 /*
@@ -3565,23 +3389,22 @@ do_elif (pfile, keyword)
  */
 
 static HOST_WIDE_INT
-eval_if_expression (pfile)
-     cpp_reader *pfile;
+eval_if_expression(cpp_reader *pfile)
 {
-  HASHNODE *save_defined;
-  HOST_WIDE_INT value;
-  long old_written = CPP_WRITTEN (pfile);
+    HASHNODE *save_defined;
+    HOST_WIDE_INT value;
+    long old_written = CPP_WRITTEN(pfile);
 
-  save_defined = install ((U_CHAR *)"defined", -1, T_SPEC_DEFINED, 0, 0, -1);
-  pfile->pcp_inside_if = 1;
+    save_defined = install((U_CHAR *)"defined", -1, T_SPEC_DEFINED, 0, 0, -1);
+    pfile->pcp_inside_if = 1;
 
-  value = cpp_parse_expr (pfile);
-  pfile->pcp_inside_if = 0;
-  delete_macro (save_defined);	/* clean up special symbol */
+    value = cpp_parse_expr(pfile);
+    pfile->pcp_inside_if = 0;
+    delete_macro(save_defined); /* clean up special symbol */
 
-  CPP_SET_WRITTEN (pfile, old_written); /* Pop */
+    CPP_SET_WRITTEN(pfile, old_written); /* Pop */
 
-  return value;
+    return value;
 }
 
 /*
@@ -3591,79 +3414,76 @@ eval_if_expression (pfile)
  */
 
 static int
-do_xifdef (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword;
+do_xifdef(cpp_reader *pfile, struct directive *keyword)
 {
-  int skip;
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-  U_CHAR *ident;
-  int ident_length;
-  enum cpp_token token;
-  int start_of_file = 0;
-  U_CHAR *control_macro = 0;
-  int old_written = CPP_WRITTEN (pfile);
-
-  /* Detect a #ifndef at start of file (not counting comments).  */
-  if (ip->fname != 0 && keyword->type == T_IFNDEF)
-    start_of_file = pfile->only_seen_white == 2;
-
-  pfile->no_macro_expand++;
-  token = get_directive_token (pfile);
-  pfile->no_macro_expand--;
-
-  ident = pfile->token_buffer + old_written;
-  ident_length = CPP_WRITTEN (pfile) - old_written;
-  CPP_SET_WRITTEN (pfile, old_written); /* Pop */
-
-  if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
+    int skip;
+    cpp_buffer *ip = CPP_BUFFER(pfile);
+    U_CHAR *ident;
+    int ident_length;
+    enum cpp_token token;
+    int start_of_file = 0;
+    U_CHAR *control_macro = 0;
+    int old_written = CPP_WRITTEN(pfile);
+
+    /* Detect a #ifndef at start of file (not counting comments).  */
+    if (ip->fname != 0 && keyword->type == T_IFNDEF)
+        start_of_file = pfile->only_seen_white == 2;
+
+    pfile->no_macro_expand++;
+    token = get_directive_token(pfile);
+    pfile->no_macro_expand--;
+
+    ident = pfile->token_buffer + old_written;
+    ident_length = CPP_WRITTEN(pfile) - old_written;
+    CPP_SET_WRITTEN(pfile, old_written); /* Pop */
+
+    if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
     {
-      skip = (keyword->type == T_IFDEF);
-      if (! CPP_TRADITIONAL (pfile))
-	cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
+        skip = (keyword->type == T_IFDEF);
+        if (!CPP_TRADITIONAL(pfile))
+            cpp_pedwarn(pfile, "`#%s' with no argument", keyword->name);
     }
-  else if (token == CPP_NAME)
+    else if (token == CPP_NAME)
     {
-      HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
-      skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
-      if (start_of_file && !skip)
-	{
-	  control_macro = (U_CHAR *) xmalloc (ident_length + 1);
-	  copy_memory (ident, control_macro, ident_length + 1);
-	}
+        HASHNODE *hp = cpp_lookup(pfile, ident, ident_length, -1);
+        skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
+        if (start_of_file && !skip)
+        {
+            control_macro = (U_CHAR *) xmalloc(ident_length + 1);
+            copy_memory(ident, control_macro, ident_length + 1);
+        }
     }
-  else
+    else
     {
-      skip = (keyword->type == T_IFDEF);
-      if (! CPP_TRADITIONAL (pfile))
-	cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
+        skip = (keyword->type == T_IFDEF);
+        if (!CPP_TRADITIONAL(pfile))
+            cpp_error(pfile, "`#%s' with invalid argument", keyword->name);
     }
 
-  if (!CPP_TRADITIONAL (pfile))
+    if (!CPP_TRADITIONAL(pfile))
     { int c;
-      cpp_skip_hspace (pfile);
-      c = PEEKC ();
+      cpp_skip_hspace(pfile);
+      c = PEEKC();
       if (c != EOF && c != '\n')
-	cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
-    }
-  skip_rest_of_line (pfile);
+          cpp_pedwarn(pfile, "garbage at end of `#%s' argument", keyword->name); }
+    skip_rest_of_line(pfile);
 
 #if 0
     if (pcp_outfile) {
-      /* Output a precondition for this macro.  */
-      if (hp && hp->value.defn->predefined)
-	fprintf (pcp_outfile, "#define %s\n", hp->name);
-      else {
-	U_CHAR *cp = buf;
-	fprintf (pcp_outfile, "#undef ");
-	while (is_idchar[*cp]) /* Ick! */
-	  fputc (*cp++, pcp_outfile);
-	putc ('\n', pcp_outfile);
-      }
+        /* Output a precondition for this macro.  */
+        if (hp && hp->value.defn->predefined)
+            fprintf(pcp_outfile, "#define %s\n", hp->name);
+        else {
+            U_CHAR *cp = buf;
+            fprintf(pcp_outfile, "#undef ");
+            while (is_idchar[*cp]) /* Ick! */
+                fputc(*cp++, pcp_outfile);
+            putc('\n', pcp_outfile);
+        }
 #endif
 
-  conditional_skip (pfile, skip, T_IF, control_macro);
-  return 0;
+    conditional_skip(pfile, skip, T_IF, control_macro);
+    return 0;
 }
 
 /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
@@ -3672,32 +3492,28 @@ do_xifdef (pfile, keyword)
    Otherwise, CONTROL_MACRO is 0.  */
 
 static void
-conditional_skip (pfile, skip, type, control_macro)
-     cpp_reader *pfile;
-     int skip;
-     enum node_type type;
-     U_CHAR *control_macro;
+conditional_skip(cpp_reader *pfile, int skip, enum node_type type, U_CHAR *control_macro)
 {
-  IF_STACK_FRAME *temp;
+    IF_STACK_FRAME *temp;
 
-  temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
-  temp->fname = CPP_BUFFER (pfile)->nominal_fname;
+    temp = (IF_STACK_FRAME *) xcalloc(1, sizeof (IF_STACK_FRAME));
+    temp->fname = CPP_BUFFER(pfile)->nominal_fname;
 #if 0
-  temp->lineno = CPP_BUFFER (pfile)->lineno;
+    temp->lineno = CPP_BUFFER(pfile)->lineno;
 #endif
-  temp->next = pfile->if_stack;
-  temp->control_macro = control_macro;
-  pfile->if_stack = temp;
+    temp->next = pfile->if_stack;
+    temp->control_macro = control_macro;
+    pfile->if_stack = temp;
 
-  pfile->if_stack->type = type;
+    pfile->if_stack->type = type;
 
-  if (skip != 0) {
-    skip_if_group (pfile);
-    return;
-  } else {
-    ++pfile->if_stack->if_succeeded;
-    output_line_command (pfile, 1, same_file);
-  }
+    if (skip != 0) {
+        skip_if_group(pfile);
+        return;
+    } else {
+        ++pfile->if_stack->if_succeeded;
+        output_line_command(pfile, 1, same_file);
+    }
 }
 
 /* Subroutine of skip_if_group.	 Examine one preprocessing directive and
@@ -3706,72 +3522,70 @@ conditional_skip (pfile, skip, type, control_macro)
    The `#' has been read, but not the identifier. */
 
 static int
-consider_directive_while_skipping (pfile, stack)
-    cpp_reader *pfile;
-    IF_STACK_FRAME *stack; 
+consider_directive_while_skipping(cpp_reader *pfile, IF_STACK_FRAME *stack)
 {
-  long ident_len, ident;
-  struct directive *kt;
-  IF_STACK_FRAME *temp;
-    
-  cpp_skip_hspace (pfile);
-
-  ident = CPP_WRITTEN (pfile);
-  parse_name (pfile, GETC());
-  ident_len = CPP_WRITTEN (pfile) - ident;
-
-  CPP_SET_WRITTEN (pfile, ident);
-
-  for (kt = directive_table; kt->length >= 0; kt++)
-    if (kt->length == ident_len
-	&& strncmp (pfile->token_buffer + ident, kt->name, kt->length) == 0)
-      switch (kt->type)
-	{
-	case T_IF:
-	case T_IFDEF:
-	case T_IFNDEF:
-	    temp = (IF_STACK_FRAME *) xmalloc (sizeof (IF_STACK_FRAME));
-	    temp->next = pfile->if_stack;
-	    pfile->if_stack = temp;
-	    temp->fname = CPP_BUFFER(pfile)->nominal_fname;
-	    temp->type = kt->type;
-	    return 0;
-
-	case T_ELSE:
-	    if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
-	      validate_else (pfile, "#else");
-	    /* fall through */
-	case T_ELIF:
-	    if (pfile->if_stack->type == T_ELSE)
-	      cpp_error (pfile, "`%s' after `#else'", kt->name);
-	    
-	    if (pfile->if_stack == stack)
-	      return 1;
-	    else
-	      {
-		pfile->if_stack->type = kt->type;
-		return 0;
-	      }
-
-	    case T_ENDIF:
-		if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
-		  validate_else (pfile, "#endif");
-
-		if (pfile->if_stack == stack)
-		  return 1;
-		    
-		temp = pfile->if_stack;
-		pfile->if_stack = temp->next;
-		free (temp);
-		return 0;
-
-	    default:
-		return 0;
-	    }
+    long ident_len, ident;
+    struct directive *kt;
+    IF_STACK_FRAME *temp;
+
+    cpp_skip_hspace(pfile);
+
+    ident = CPP_WRITTEN(pfile);
+    parse_name(pfile, GETC());
+    ident_len = CPP_WRITTEN(pfile) - ident;
+
+    CPP_SET_WRITTEN(pfile, ident);
+
+    for (kt = directive_table; kt->length >= 0; kt++)
+        if (kt->length == ident_len
+            && strncmp(pfile->token_buffer + ident, kt->name, kt->length) == 0)
+            switch (kt->type)
+            {
+            case T_IF:
+            case T_IFDEF:
+            case T_IFNDEF:
+                temp = (IF_STACK_FRAME *) xmalloc(sizeof (IF_STACK_FRAME));
+                temp->next = pfile->if_stack;
+                pfile->if_stack = temp;
+                temp->fname = CPP_BUFFER(pfile)->nominal_fname;
+                temp->type = kt->type;
+                return 0;
+
+            case T_ELSE:
+                if (CPP_PEDANTIC(pfile) && pfile->if_stack != stack)
+                    validate_else(pfile, "#else");
+            /* fall through */
+            case T_ELIF:
+                if (pfile->if_stack->type == T_ELSE)
+                    cpp_error(pfile, "`%s' after `#else'", kt->name);
+
+                if (pfile->if_stack == stack)
+                    return 1;
+                else
+                {
+                    pfile->if_stack->type = kt->type;
+                    return 0;
+                }
+
+            case T_ENDIF:
+                if (CPP_PEDANTIC(pfile) && pfile->if_stack != stack)
+                    validate_else(pfile, "#endif");
+
+                if (pfile->if_stack == stack)
+                    return 1;
+
+                temp = pfile->if_stack;
+                pfile->if_stack = temp->next;
+                free(temp);
+                return 0;
+
+            default:
+                return 0;
+            }
 
     /* Don't let erroneous code go by.	*/
-    if (!CPP_OPTIONS (pfile)->lang_asm && CPP_PEDANTIC (pfile))
-	cpp_pedwarn (pfile, "invalid preprocessor directive name");
+    if (!CPP_OPTIONS(pfile)->lang_asm && CPP_PEDANTIC(pfile))
+        cpp_pedwarn(pfile, "invalid preprocessor directive name");
     return 0;
 }
 
@@ -3779,75 +3593,74 @@ consider_directive_while_skipping (pfile, stack)
  * leaves input ptr at the sharp sign found.
  */
 static void
-skip_if_group (pfile)
-    cpp_reader *pfile;
+skip_if_group(cpp_reader *pfile)
 {
-  int c;
-  IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
-  U_CHAR *beg_of_line;
-  long old_written;
+    int c;
+    IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
+    U_CHAR *beg_of_line;
+    long old_written;
 
-  if (CPP_OPTIONS (pfile)->output_conditionals)
+    if (CPP_OPTIONS(pfile)->output_conditionals)
     {
-      CPP_PUTS (pfile, "#failed\n", 8);
-      pfile->lineno++;
-      output_line_command (pfile, 1, same_file);
+        CPP_PUTS(pfile, "#failed\n", 8);
+        pfile->lineno++;
+        output_line_command(pfile, 1, same_file);
     }
 
-  old_written = CPP_WRITTEN (pfile);
-  
-  for (;;)
+    old_written = CPP_WRITTEN(pfile);
+
+    for (;; )
     {
-      beg_of_line = CPP_BUFFER (pfile)->cur;
-
-      if (! CPP_TRADITIONAL (pfile))
-	cpp_skip_hspace (pfile);
-      c = GETC();
-      if (c == '\n')
-	{
-	  if (CPP_OPTIONS (pfile)->output_conditionals)
-	    CPP_PUTC (pfile, c);
-	  continue;
-	}
-      else if (c == '#')
-	{
-	  if (consider_directive_while_skipping (pfile, save_if_stack))
-	    break;
-	}
-      else if (c == EOF)
-	return;	 /* Caller will issue error. */
-
-      FORWARD(-1);
-      if (CPP_OPTIONS (pfile)->output_conditionals)
-	{
-	  CPP_PUTS (pfile, beg_of_line, CPP_BUFFER (pfile)->cur - beg_of_line);
-	  copy_rest_of_line (pfile);
-	}
-      else
-	{
-	  copy_rest_of_line (pfile);
-	  CPP_SET_WRITTEN (pfile, old_written);	 /* discard it */
-	}
-
-      c = GETC();
-      if (c == EOF)
-	return;	 /* Caller will issue error. */
-      else
-	{
-	  /* \n */
-	  if (CPP_OPTIONS (pfile)->output_conditionals)
-	    CPP_PUTC (pfile, c);
-	}
-    }	  
-
-  /* Back up to the beginning of this line.  Caller will process the
-     directive. */
-  CPP_BUFFER (pfile)->cur = beg_of_line;
-  pfile->only_seen_white = 1;
-  if (CPP_OPTIONS (pfile)->output_conditionals)
+        beg_of_line = CPP_BUFFER(pfile)->cur;
+
+        if (!CPP_TRADITIONAL(pfile))
+            cpp_skip_hspace(pfile);
+        c = GETC();
+        if (c == '\n')
+        {
+            if (CPP_OPTIONS(pfile)->output_conditionals)
+                CPP_PUTC(pfile, c);
+            continue;
+        }
+        else if (c == '#')
+        {
+            if (consider_directive_while_skipping(pfile, save_if_stack))
+                break;
+        }
+        else if (c == EOF)
+            return; /* Caller will issue error. */
+
+        FORWARD(-1);
+        if (CPP_OPTIONS(pfile)->output_conditionals)
+        {
+            CPP_PUTS(pfile, beg_of_line, CPP_BUFFER(pfile)->cur - beg_of_line);
+            copy_rest_of_line(pfile);
+        }
+        else
+        {
+            copy_rest_of_line(pfile);
+            CPP_SET_WRITTEN(pfile, old_written); /* discard it */
+        }
+
+        c = GETC();
+        if (c == EOF)
+            return; /* Caller will issue error. */
+        else
+        {
+            /* \n */
+            if (CPP_OPTIONS(pfile)->output_conditionals)
+                CPP_PUTC(pfile, c);
+        }
+    }
+
+    /* Back up to the beginning of this line.  Caller will process the
+       directive. */
+    CPP_BUFFER(pfile)->cur = beg_of_line;
+    pfile->only_seen_white = 1;
+    if (CPP_OPTIONS(pfile)->output_conditionals)
     {
-      CPP_PUTS (pfile, "#endfailed\n", 11);
-      pfile->lineno++;
+        CPP_PUTS(pfile, "#endfailed\n", 11);
+        pfile->lineno++;
     }
 }
 
@@ -3859,41 +3672,39 @@ skip_if_group (pfile)
  */
 
 static int
-do_else (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_else(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  cpp_buffer *ip = CPP_BUFFER (pfile);
+    cpp_buffer *ip = CPP_BUFFER(pfile);
 
-  if (CPP_PEDANTIC (pfile))
-    validate_else (pfile, "#else");
-  skip_rest_of_line (pfile);
+    if (CPP_PEDANTIC(pfile))
+        validate_else(pfile, "#else");
+    skip_rest_of_line(pfile);
 
-  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
-    cpp_error (pfile, "`#else' not within a conditional");
-    return 0;
-  } else {
-    /* #ifndef can't have its special treatment for containing the whole file
-       if it has a #else clause.  */
-    pfile->if_stack->control_macro = 0;
-
-    if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
-      cpp_error (pfile, "`#else' after `#else'");
-      fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
-      if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
-	fprintf (stderr, ", file %s", pfile->if_stack->fname);
-      fprintf (stderr, ")\n");
+    if (pfile->if_stack == CPP_BUFFER(pfile)->if_stack) {
+        cpp_error(pfile, "`#else' not within a conditional");
+        return 0;
+    } else {
+        /* #ifndef can't have its special treatment for containing the whole file
+           if it has a #else clause.  */
+        pfile->if_stack->control_macro = 0;
+
+        if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
+            cpp_error(pfile, "`#else' after `#else'");
+            fprintf(stderr, " (matches line %d", pfile->if_stack->lineno);
+            if (strcmp(pfile->if_stack->fname, ip->nominal_fname) != 0)
+                fprintf(stderr, ", file %s", pfile->if_stack->fname);
+            fprintf(stderr, ")\n");
+        }
+        pfile->if_stack->type = T_ELSE;
     }
-    pfile->if_stack->type = T_ELSE;
-  }
 
-  if (pfile->if_stack->if_succeeded)
-    skip_if_group (pfile);
-  else {
-    ++pfile->if_stack->if_succeeded;	/* continue processing input */
-    output_line_command (pfile, 1, same_file);
-  }
-  return 0;
+    if (pfile->if_stack->if_succeeded)
+        skip_if_group(pfile);
+    else {
+        ++pfile->if_stack->if_succeeded; /* continue processing input */
+        output_line_command(pfile, 1, same_file);
+    }
+    return 0;
 }
 
 /*
@@ -3901,56 +3712,54 @@ do_else (pfile, keyword)
  */
 
 static int
-do_endif (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+do_endif(cpp_reader *pfile, struct directive *keyword ATTRIBUTE_UNUSED)
 {
-  if (CPP_PEDANTIC (pfile))
-    validate_else (pfile, "#endif");
-  skip_rest_of_line (pfile);
+    if (CPP_PEDANTIC(pfile))
+        validate_else(pfile, "#endif");
+    skip_rest_of_line(pfile);
 
-  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
-    cpp_error (pfile, "unbalanced `#endif'");
-  else
+    if (pfile->if_stack == CPP_BUFFER(pfile)->if_stack)
+        cpp_error(pfile, "unbalanced `#endif'");
+    else
     {
-      IF_STACK_FRAME *temp = pfile->if_stack;
-      pfile->if_stack = temp->next;
-      if (temp->control_macro != 0)
-	{
-	  /* This #endif matched a #ifndef at the start of the file.
-	     See if it is at the end of the file.  */
-	  struct parse_marker start_mark;
-	  int c;
-
-	  parse_set_mark (&start_mark, pfile);
-
-	  for (;;)
-	    {
-	      cpp_skip_hspace (pfile);
-	      c = GETC ();
-	      if (c != '\n')
-		break;
-	    }
-	  parse_goto_mark (&start_mark, pfile);
-	  parse_clear_mark (&start_mark);
-
-	  if (c == EOF)
-	    {
-	      /* This #endif ends a #ifndef
-		 that contains all of the file (aside from whitespace).
-		 Arrange not to include the file again
-		 if the macro that was tested is defined. */
-	      struct cpp_buffer *ip;
-	      for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
-		if (ip->fname != NULL)
-		  break;
-	      ip->ihash->control_macro = temp->control_macro;
-	    }
+        IF_STACK_FRAME *temp = pfile->if_stack;
+        pfile->if_stack = temp->next;
+        if (temp->control_macro != 0)
+        {
+            /* This #endif matched a #ifndef at the start of the file.
+               See if it is at the end of the file.  */
+            struct parse_marker start_mark;
+            int c;
+
+            parse_set_mark(&start_mark, pfile);
+
+            for (;; )
+            {
+                cpp_skip_hspace(pfile);
+                c = GETC();
+                if (c != '\n')
+                    break;
+            }
+            parse_goto_mark(&start_mark, pfile);
+            parse_clear_mark(&start_mark);
+
+            if (c == EOF)
+            {
+                /* This #endif ends a #ifndef
+                   that contains all of the file (aside from whitespace).
+                   Arrange not to include the file again
+                   if the macro that was tested is defined. */
+                struct cpp_buffer *ip;
+                for (ip = CPP_BUFFER(pfile);; ip = CPP_PREV_BUFFER(ip))
+                    if (ip->fname != NULL)
+                        break;
+                ip->ihash->control_macro = temp->control_macro;
+            }
         }
-      free (temp);
-      output_line_command (pfile, 1, same_file);
+        free(temp);
+        output_line_command(pfile, 1, same_file);
     }
-  return 0;
+    return 0;
 }
 
 /* When an #else or #endif is found while skipping failed conditional,
@@ -3958,726 +3767,721 @@ do_endif (pfile, keyword)
    the command name.  P points to the first char after the command name.  */
 
 static void
-validate_else (pfile, directive)
-     cpp_reader *pfile;
-     char *directive;
+validate_else(cpp_reader *pfile, char *directive)
 {
-  int c;
-  cpp_skip_hspace (pfile);
-  c = PEEKC ();
-  if (c != EOF && c != '\n')
-    cpp_pedwarn (pfile,
-		 "text following `%s' violates ANSI standard", directive);
+    int c;
+    cpp_skip_hspace(pfile);
+    c = PEEKC();
+    if (c != EOF && c != '\n')
+        cpp_pedwarn(pfile,
+                    "text following `%s' violates ANSI standard", directive);
 }
 
 /* Get the next token, and add it to the text in pfile->token_buffer.
    Return the kind of token we got.  */
-  
+
 enum cpp_token
-cpp_get_token (pfile)
-     cpp_reader *pfile;
+cpp_get_token(cpp_reader *pfile)
 {
-  register int c, c2, c3;
-  long old_written;
-  long start_line, start_column;
-  enum cpp_token token;
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
-  CPP_BUFFER (pfile)->prev = CPP_BUFFER (pfile)->cur;
- get_next:
-  c = GETC();
-  if (c == EOF)
+    register int c, c2, c3;
+    long old_written;
+    long start_line, start_column;
+    enum cpp_token token;
+    struct cpp_options *opts = CPP_OPTIONS(pfile);
+    CPP_BUFFER(pfile)->prev = CPP_BUFFER(pfile)->cur;
+get_next:
+    c = GETC();
+    if (c == EOF)
     {
-    handle_eof:
-      if (CPP_BUFFER (pfile)->seen_eof)
-	{
-	  if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
-	    goto get_next;
-	  else
-	    return CPP_EOF;
-	}
-      else
-	{
-	  cpp_buffer *next_buf
-	    = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
-	  CPP_BUFFER (pfile)->seen_eof = 1;
-	  if (CPP_BUFFER (pfile)->nominal_fname
-	      && next_buf != CPP_NULL_BUFFER (pfile))
-	    {
-	      /* We're about to return from an #include file.
-		 Emit #line information now (as part of the CPP_POP) result.
-		 But the #line refers to the file we will pop to.  */
-	      cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
-	      CPP_BUFFER (pfile) = next_buf;
-	      pfile->input_stack_listing_current = 0;
-	      output_line_command (pfile, 0, leave_file);
-	      CPP_BUFFER (pfile) = cur_buffer;
-	    }
-	  return CPP_POP;
-	}
+handle_eof:
+        if (CPP_BUFFER(pfile)->seen_eof)
+        {
+            if (cpp_pop_buffer(pfile) != CPP_NULL_BUFFER(pfile))
+                goto get_next;
+            else
+                return CPP_EOF;
+        }
+        else
+        {
+            cpp_buffer *next_buf
+                = CPP_PREV_BUFFER(CPP_BUFFER(pfile));
+            CPP_BUFFER(pfile)->seen_eof = 1;
+            if (CPP_BUFFER(pfile)->nominal_fname
+                && next_buf != CPP_NULL_BUFFER(pfile))
+            {
+                /* We're about to return from an #include file.
+                   Emit #line information now (as part of the CPP_POP) result.
+                   But the #line refers to the file we will pop to.  */
+                cpp_buffer *cur_buffer = CPP_BUFFER(pfile);
+                CPP_BUFFER(pfile) = next_buf;
+                pfile->input_stack_listing_current = 0;
+                output_line_command(pfile, 0, leave_file);
+                CPP_BUFFER(pfile) = cur_buffer;
+            }
+            return CPP_POP;
+        }
     }
-  else
+    else
     {
-      switch (c)
-	{
-	  long newlines;
-	  struct parse_marker start_mark;
-	case '/':
-	  if (PEEKC () == '=')
-	    goto op2;
-	  if (opts->put_out_comments)
-	    parse_set_mark (&start_mark, pfile);
-	  newlines = 0;
-	  cpp_buf_line_and_col (cpp_file_buffer (pfile),
-				&start_line, &start_column);
-	  c = skip_comment (pfile, &newlines);
-	  if (opts->put_out_comments && (c == '/' || c == EOF))
-	    parse_clear_mark (&start_mark);
-	  if (c == '/')
-	    goto randomchar;
-	  if (c == EOF)
-	    {
-	      cpp_error_with_line (pfile, start_line, start_column,
-				   "unterminated comment");
-	      goto handle_eof;
-	    }
-	  c = '/';  /* Initial letter of comment.  */
-	return_comment:
-	  /* Comments are equivalent to spaces.
-	     For -traditional, a comment is equivalent to nothing.  */
-	  if (opts->put_out_comments)
-	    {
-	      cpp_buffer *pbuf = CPP_BUFFER (pfile);
-	      U_CHAR *start = pbuf->buf + start_mark.position;
-	      int len = pbuf->cur - start;
-	      CPP_RESERVE(pfile, 1 + len);
-	      CPP_PUTC_Q (pfile, c);
-	      CPP_PUTS_Q (pfile, start, len);
-	      pfile->lineno += newlines;
-	      parse_clear_mark (&start_mark);
-	      return CPP_COMMENT;
-	    }
-	  else if (CPP_TRADITIONAL (pfile))
-	    {
-	      return CPP_COMMENT;
-	    }
-	  else
-	    {
+        switch (c)
+        {
+            long newlines;
+            struct parse_marker start_mark;
+        case '/':
+            if (PEEKC() == '=')
+                goto op2;
+            if (opts->put_out_comments)
+                parse_set_mark(&start_mark, pfile);
+            newlines = 0;
+            cpp_buf_line_and_col(cpp_file_buffer(pfile),
+                                 &start_line, &start_column);
+            c = skip_comment(pfile, &newlines);
+            if (opts->put_out_comments && (c == '/' || c == EOF))
+                parse_clear_mark(&start_mark);
+            if (c == '/')
+                goto randomchar;
+            if (c == EOF)
+            {
+                cpp_error_with_line(pfile, start_line, start_column,
+                                    "unterminated comment");
+                goto handle_eof;
+            }
+            c = '/'; /* Initial letter of comment.  */
+return_comment:
+            /* Comments are equivalent to spaces.
+               For -traditional, a comment is equivalent to nothing.  */
+            if (opts->put_out_comments)
+            {
+                cpp_buffer *pbuf = CPP_BUFFER(pfile);
+                U_CHAR *start = pbuf->buf + start_mark.position;
+                int len = pbuf->cur - start;
+                CPP_RESERVE(pfile, 1 + len);
+                CPP_PUTC_Q(pfile, c);
+                CPP_PUTS_Q(pfile, start, len);
+                pfile->lineno += newlines;
+                parse_clear_mark(&start_mark);
+                return CPP_COMMENT;
+            }
+            else if (CPP_TRADITIONAL(pfile))
+            {
+                return CPP_COMMENT;
+            }
+            else
+            {
 #if 0
-	      /* This may not work if cpp_get_token is called recursively,
-		 since many places look for horizontal space.  */
-	      if (newlines)
-		{
-		  /* Copy the newlines into the output buffer, in order to
-		     avoid the pain of a #line every time a multiline comment
-		     is seen.  */
-		  CPP_RESERVE(pfile, newlines);
-		  while (--newlines >= 0)
-		    {
-		      CPP_PUTC_Q (pfile, '\n');
-		      pfile->lineno++;
-		    }
-		  return CPP_VSPACE;
-		}
+                /* This may not work if cpp_get_token is called recursively,
+                   since many places look for horizontal space.  */
+                if (newlines)
+                {
+                    /* Copy the newlines into the output buffer, in order to
+                       avoid the pain of a #line every time a multiline comment
+                       is seen.  */
+                    CPP_RESERVE(pfile, newlines);
+                    while (--newlines >= 0)
+                    {
+                        CPP_PUTC_Q(pfile, '\n');
+                        pfile->lineno++;
+                    }
+                    return CPP_VSPACE;
+                }
 #endif
-	      CPP_RESERVE(pfile, 1);
-	      CPP_PUTC_Q (pfile, ' ');
-	      return CPP_HSPACE;
-	    }
+                CPP_RESERVE(pfile, 1);
+                CPP_PUTC_Q(pfile, ' ');
+                return CPP_HSPACE;
+            }
 #if 0
-	  if (opts->for_lint) {
-	    U_CHAR *argbp;
-	    int cmdlen, arglen;
-	    char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
-	    
-	    if (lintcmd != NULL) {
-	      /* I believe it is always safe to emit this newline: */
-	      obp[-1] = '\n';
-	      copy_memory ("#pragma lint ", (char *) obp, 13);
-	      obp += 13;
-	      copy_memory (lintcmd, (char *) obp, cmdlen);
-	      obp += cmdlen;
-
-	      if (arglen != 0) {
-		*(obp++) = ' ';
-		copy_memory (argbp, (char *) obp, arglen);
-		obp += arglen;
-	      }
-
-	      /* OK, now bring us back to the state we were in before we entered
-		 this branch.  We need #line because the newline for the pragma
-		 could mess things up.  */
-	      output_line_command (pfile, 0, same_file);
-	      *(obp++) = ' ';	/* just in case, if comments are copied thru */
-	      *(obp++) = '/';
-	    }
-	  }
+            if (opts->for_lint) {
+                U_CHAR *argbp;
+                int cmdlen, arglen;
+                char *lintcmd = get_lintcmd(ibp, limit, &argbp, &arglen, &cmdlen);
+
+                if (lintcmd != NULL) {
+                    /* I believe it is always safe to emit this newline: */
+                    obp[-1] = '\n';
+                    copy_memory("#pragma lint ", (char *) obp, 13);
+                    obp += 13;
+                    copy_memory(lintcmd, (char *) obp, cmdlen);
+                    obp += cmdlen;
+
+                    if (arglen != 0) {
+                        *(obp++) = ' ';
+                        copy_memory(argbp, (char *) obp, arglen);
+                        obp += arglen;
+                    }
+
+                    /* OK, now bring us back to the state we were in before we entered
+                       this branch.  We need #line because the newline for the pragma
+                       could mess things up.  */
+                    output_line_command(pfile, 0, same_file);
+                    *(obp++) = ' '; /* just in case, if comments are copied thru */
+                    *(obp++) = '/';
+                }
+            }
 #endif
 
-	case '#':
+        case '#':
 #if 0
-	  /* If this is expanding a macro definition, don't recognize
-	     preprocessor directives.  */
-	  if (ip->macro != 0)
-	    goto randomchar;
-	  /* If this is expand_into_temp_buffer, recognize them
-	     only after an actual newline at this level,
-	     not at the beginning of the input level.  */
-	  if (ip->fname == 0 && beg_of_line == ip->buf)
-	    goto randomchar;
-	  if (ident_length)
-	    goto specialchar;
+            /* If this is expanding a macro definition, don't recognize
+               preprocessor directives.  */
+            if (ip->macro != 0)
+                goto randomchar;
+            /* If this is expand_into_temp_buffer, recognize them
+               only after an actual newline at this level,
+               not at the beginning of the input level.  */
+            if (ip->fname == 0 && beg_of_line == ip->buf)
+                goto randomchar;
+            if (ident_length)
+                goto specialchar;
 #endif
 
-	  if (!pfile->only_seen_white)
-	    goto randomchar;
-	  if (handle_directive (pfile))
-	    return CPP_DIRECTIVE;
-	  pfile->only_seen_white = 0;
-	  return CPP_OTHER;
-
-	case '\"':
-	case '\'':
-	  /* A single quoted string is treated like a double -- some
-	     programs (e.g., troff) are perverse this way */
-	  cpp_buf_line_and_col (cpp_file_buffer (pfile),
-				&start_line, &start_column);
-	  old_written = CPP_WRITTEN (pfile);
-	string:
-	  CPP_PUTC (pfile, c);
-	  while (1)
-	    {
-	      int cc = GETC();
-	      if (cc == EOF)
-		{
-		  if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
-		    {
-		      /* try harder: this string crosses a macro expansion
-			 boundary.  This can happen naturally if -traditional.
-			 Otherwise, only -D can make a macro with an unmatched
-			 quote.  */
-			cpp_buffer *next_buf
-			    = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
-			(*CPP_BUFFER (pfile)->cleanup)
-			    (CPP_BUFFER (pfile), pfile);
-			CPP_BUFFER (pfile) = next_buf;
-			continue;
-		    }
-		  if (!CPP_TRADITIONAL (pfile))
-		    {
-		      cpp_error_with_line (pfile, start_line, start_column,
-			      "unterminated string or character constant");
-		      if (pfile->multiline_string_line != start_line
-			  && pfile->multiline_string_line != 0)
-			cpp_error_with_line (pfile,
-					     pfile->multiline_string_line, -1,
-			       "possible real start of unterminated constant");
-		      pfile->multiline_string_line = 0;
-		    }
-		  break;
-		}
-	      CPP_PUTC (pfile, cc);
-	      switch (cc)
-		{
-		case '\n':
-		  /* Traditionally, end of line ends a string constant with
-		 no error.  So exit the loop and record the new line.  */
-		  if (CPP_TRADITIONAL (pfile))
-		    goto while2end;
-		  if (c == '\'')
-		    {
-		      cpp_error_with_line (pfile, start_line, start_column,
-					   "unterminated character constant");
-		      goto while2end;
-		    }
-		  if (CPP_PEDANTIC (pfile)
-		      && pfile->multiline_string_line == 0)
-		    {
-		      cpp_pedwarn_with_line (pfile, start_line, start_column,
-			       "string constant runs past end of line");
-		    }
-		  if (pfile->multiline_string_line == 0)
-		    pfile->multiline_string_line = start_line;
-		  break;
-		
-		case '\\':
-		  cc = GETC();
-		  if (cc == '\n')
-		    {
-		      /* Backslash newline is replaced by nothing at all.  */
-		      CPP_ADJUST_WRITTEN (pfile, -1);
-		      pfile->lineno++;
-		    }
-		  else
-		    {
-		      /* ANSI stupidly requires that in \\ the second \
-			 is *not* prevented from combining with a newline.  */
-		      NEWLINE_FIX1(cc);
-		      if (cc != EOF)
-			CPP_PUTC (pfile, cc);
-		    }
-		  break;
-
-		case '\"':
-		case '\'':
-		  if (cc == c)
-		    goto while2end;
-		  break;
-		}
-	    }
-	while2end:
-	  pfile->lineno += count_newlines (pfile->token_buffer + old_written,
-					   CPP_PWRITTEN (pfile));
-	  pfile->only_seen_white = 0;
-	  return c == '\'' ? CPP_CHAR : CPP_STRING;
-
-	case '$':
-	  if (!opts->dollars_in_ident)
-	    goto randomchar;
-	  goto letter;
-
-	case ':':
-	  if (opts->cplusplus && PEEKC () == ':')
-	    goto op2;
-	  goto randomchar;
-
-	case '&':
-	case '+':
-	case '|':
-	  NEWLINE_FIX;
-	  c2 = PEEKC ();
-	  if (c2 == c || c2 == '=')
-	    goto op2;
-	  goto randomchar;
-
-	case '*':
-	case '!':
-	case '%':
-	case '=':
-	case '^':
-	  NEWLINE_FIX;
-	  if (PEEKC () == '=')
-	    goto op2;
-	  goto randomchar;
-
-	case '-':
-	  NEWLINE_FIX;
-	  c2 = PEEKC ();
-	  if (c2 == '-' && opts->chill)
-	    {
-	      /* Chill style comment */
-	      if (opts->put_out_comments)
-		parse_set_mark (&start_mark, pfile);
-	      FORWARD(1);  /* Skip second '-'.  */
-	      for (;;)
-		{
-		  c = GETC ();
-		  if (c == EOF)
-		    break;
-		  if (c == '\n')
-		    {
-		      /* Don't consider final '\n' to be part of comment.  */
-		      FORWARD(-1);
-		      break;
-		    }
-		}
-	      c = '-';
-	      goto return_comment;
-	    }
-	  if (c2 == '-' || c2 == '=' || c2 == '>')
-	    goto op2;
-	  goto randomchar;
-
-	case '<':
-	  if (pfile->parsing_include_directive)
-	    {
-	      for (;;)
-		{
-		  CPP_PUTC (pfile, c);
-		  if (c == '>')
-		    break;
-		  c = GETC ();
-		  NEWLINE_FIX1 (c);
-		  if (c == '\n' || c == EOF)
-		    {
-		      cpp_error (pfile,
-				 "missing '>' in `#include <FILENAME>'");
-		      break;
-		    }
-		}
-	      return CPP_STRING;
-	    }
-	  /* else fall through */
-	case '>':
-	  NEWLINE_FIX;
-	  c2 = PEEKC ();
-	  if (c2 == '=')
-	    goto op2;
-	  if (c2 != c)
-	    goto randomchar;
-	  FORWARD(1);
-	  CPP_RESERVE (pfile, 4);
-	  CPP_PUTC (pfile, c);
-	  CPP_PUTC (pfile, c2);
-	  NEWLINE_FIX;
-	  c3 = PEEKC ();
-	  if (c3 == '=')
-	    CPP_PUTC_Q (pfile, GETC ());
-	  CPP_NUL_TERMINATE_Q (pfile);
-	  pfile->only_seen_white = 0;
-	  return CPP_OTHER;
-
-	case '@':
-	  if (CPP_BUFFER (pfile)->has_escapes)
-	    {
-	      c = GETC ();
-	      if (c == '-')
-		{
-		  if (pfile->output_escapes)
-		    CPP_PUTS (pfile, "@-", 2);
-		  parse_name (pfile, GETC ());
-		  return CPP_NAME;
-		}
-	      else if (is_space [c])
-		{
-		  CPP_RESERVE (pfile, 2);
-		  if (pfile->output_escapes)
-		    CPP_PUTC_Q (pfile, '@');
-		  CPP_PUTC_Q (pfile, c);
-		  return CPP_HSPACE;
-		}
-	    }
-	  if (pfile->output_escapes)
-	    {
-	      CPP_PUTS (pfile, "@@", 2);
-	      return CPP_OTHER;
-	    }
-	  goto randomchar;
-
-	case '.':
-	  NEWLINE_FIX;
-	  c2 = PEEKC ();
-	  if (ISDIGIT(c2))
-	    {
-	      CPP_RESERVE(pfile, 2);
-	      CPP_PUTC_Q (pfile, '.');
-	      c = GETC ();
-	      goto number;
-	    }
-	  /* FIXME - misses the case "..\\\n." */
-	  if (c2 == '.' && PEEKN(1) == '.')
-	    {
-	      CPP_RESERVE(pfile, 4);
-	      CPP_PUTC_Q (pfile, '.');
-	      CPP_PUTC_Q (pfile, '.');
-	      CPP_PUTC_Q (pfile, '.');
-	      FORWARD (2);
-	      CPP_NUL_TERMINATE_Q (pfile);
-	      pfile->only_seen_white = 0;
-	      return CPP_3DOTS;
-	    }
-	  goto randomchar;
-
-	op2:
-	  token = CPP_OTHER;
-	  pfile->only_seen_white = 0;
-        op2any:
-	  CPP_RESERVE(pfile, 3);
-	  CPP_PUTC_Q (pfile, c);
-	  CPP_PUTC_Q (pfile, GETC ());
-	  CPP_NUL_TERMINATE_Q (pfile);
-	  return token;
-
-	case 'L':
-	  NEWLINE_FIX;
-	  c2 = PEEKC ();
-	  if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
-	    {
-	      CPP_PUTC (pfile, c);
-	      c = GETC ();
-	      goto string;
-	    }
-	  goto letter;
-
-	case '0': case '1': case '2': case '3': case '4':
-	case '5': case '6': case '7': case '8': case '9':
-	number:
-	  c2  = '.';
-	  for (;;)
-	    {
-	      CPP_RESERVE (pfile, 2);
-	      CPP_PUTC_Q (pfile, c);
-	      NEWLINE_FIX;
-	      c = PEEKC ();
-	      if (c == EOF)
-		break;
-	      if (!is_idchar[c] && c != '.'
-		  && ((c2 != 'e' && c2 != 'E'
-		       && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile)))
-		      || (c != '+' && c != '-')))
-		break;
-	      FORWARD(1);
-	      c2= c;
-	    }
-	  CPP_NUL_TERMINATE_Q (pfile);
-	  pfile->only_seen_white = 0;
-	  return CPP_NUMBER;
-	case 'b': case 'c': case 'd': case 'h': case 'o':
-	case 'B': case 'C': case 'D': case 'H': case 'O':
-	  if (opts->chill && PEEKC () == '\'')
-	    {
-	      pfile->only_seen_white = 0;
-	      CPP_RESERVE (pfile, 2);
-	      CPP_PUTC_Q (pfile, c);
-	      CPP_PUTC_Q (pfile, '\'');
-	      FORWARD(1);
-	      for (;;)
-		{
-		  c = GETC();
-		  if (c == EOF)
-		    goto chill_number_eof;
-		  if (!is_idchar[c])
-		    {
-		      if (c == '\\' && PEEKC() == '\n')
-			{
-			  FORWARD(2);
-			  continue;
-			}
-		      break;
-		    }
-		  CPP_PUTC (pfile, c);
-		}
-	      if (c == '\'')
-		{
-		  CPP_RESERVE (pfile, 2);
-		  CPP_PUTC_Q (pfile, c);
-		  CPP_NUL_TERMINATE_Q (pfile);
-		  return CPP_STRING;
-		}
-	      else
-		{
-		  FORWARD(-1);
-		chill_number_eof:
-		  CPP_NUL_TERMINATE (pfile);
-		  return CPP_NUMBER;
-		}
-	    }
-	  else
-	    goto letter;
-	case '_':
-	case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
-	case 'k': case 'l': case 'm': case 'n': 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 'E': case 'F': case 'G': case 'I': case 'J':
-	case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
-	case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
-	case 'Y': case 'Z':
-        letter:
-          {
-	    HASHNODE *hp;
-	    unsigned char *ident;
-	    int before_name_written = CPP_WRITTEN (pfile);
-	    int ident_len;
-	    parse_name (pfile, c);
-	    pfile->only_seen_white = 0;
-	    if (pfile->no_macro_expand)
-	      return CPP_NAME;
-	    ident = pfile->token_buffer + before_name_written;
-	    ident_len = CPP_PWRITTEN (pfile) - ident;
-	    hp = cpp_lookup (pfile, ident, ident_len, -1);
-	    if (!hp)
-	      return CPP_NAME;
-	    if (hp->type == T_DISABLED)
-	      {
-		if (pfile->output_escapes)
-		  { /* Return "@-IDENT", followed by '\0'.  */
-		    int i;
-		    CPP_RESERVE (pfile, 3);
-		    ident = pfile->token_buffer + before_name_written;
-		    CPP_ADJUST_WRITTEN (pfile, 2);
-		    for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
-		    ident[0] = '@';
-		    ident[1] = '-';
-		  }
-		return CPP_NAME;
-	      }
-
-	    /* 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)
-	    {
-	      struct parse_marker macro_mark;
-	      int is_macro_call, macbuf_whitespace = 0;
-
-	      parse_set_mark (&macro_mark, pfile);
-	      for (;;)
-		{
-		  cpp_skip_hspace (pfile);
-		  c = PEEKC ();
-		  is_macro_call = c == '(';
-		  if (c != EOF)
-		    {
-		      if (c != '\n')
-		        break;
-		      FORWARD (1);
-		    }
-                  else
+            if (!pfile->only_seen_white)
+                goto randomchar;
+            if (handle_directive(pfile))
+                return CPP_DIRECTIVE;
+            pfile->only_seen_white = 0;
+            return CPP_OTHER;
+
+        case '\"':
+        case '\'':
+            /* A single quoted string is treated like a double -- some
+               programs (e.g., troff) are perverse this way */
+            cpp_buf_line_and_col(cpp_file_buffer(pfile),
+                                 &start_line, &start_column);
+            old_written = CPP_WRITTEN(pfile);
+string:
+            CPP_PUTC(pfile, c);
+            while (1)
+            {
+                int cc = GETC();
+                if (cc == EOF)
+                {
+                    if (CPP_IS_MACRO_BUFFER(CPP_BUFFER(pfile)))
                     {
-                      if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+                        /* try harder: this string crosses a macro expansion
+                           boundary.  This can happen naturally if -traditional.
+                           Otherwise, only -D can make a macro with an unmatched
+                           quote.  */
+                        cpp_buffer *next_buf
+                            = CPP_PREV_BUFFER(CPP_BUFFER(pfile));
+                        (*CPP_BUFFER(pfile)->cleanup)
+                            (CPP_BUFFER(pfile), pfile);
+                        CPP_BUFFER(pfile) = next_buf;
+                        continue;
+                    }
+                    if (!CPP_TRADITIONAL(pfile))
+                    {
+                        cpp_error_with_line(pfile, start_line, start_column,
+                                            "unterminated string or character constant");
+                        if (pfile->multiline_string_line != start_line
+                            && pfile->multiline_string_line != 0)
+                            cpp_error_with_line(pfile,
+                                                pfile->multiline_string_line, -1,
+                                                "possible real start of unterminated constant");
+                        pfile->multiline_string_line = 0;
+                    }
+                    break;
+                }
+                CPP_PUTC(pfile, cc);
+                switch (cc)
+                {
+                case '\n':
+                    /* Traditionally, end of line ends a string constant with
+                       no error.  So exit the loop and record the new line.  */
+                    if (CPP_TRADITIONAL(pfile))
+                        goto while2end;
+                    if (c == '\'')
+                    {
+                        cpp_error_with_line(pfile, start_line, start_column,
+                                            "unterminated character constant");
+                        goto while2end;
+                    }
+                    if (CPP_PEDANTIC(pfile)
+                        && pfile->multiline_string_line == 0)
+                    {
+                        cpp_pedwarn_with_line(pfile, start_line, start_column,
+                                              "string constant runs past end of line");
+                    }
+                    if (pfile->multiline_string_line == 0)
+                        pfile->multiline_string_line = start_line;
+                    break;
+
+                case '\\':
+                    cc = GETC();
+                    if (cc == '\n')
+                    {
+                        /* Backslash newline is replaced by nothing at all.  */
+                        CPP_ADJUST_WRITTEN(pfile, -1);
+                        pfile->lineno++;
+                    }
+                    else
+                    {
+                        /* ANSI stupidly requires that in \\ the second \
+                           is *not* prevented from combining with a newline.  */
+                        NEWLINE_FIX1(cc);
+                        if (cc != EOF)
+                            CPP_PUTC(pfile, cc);
+                    }
+                    break;
+
+                case '\"':
+                case '\'':
+                    if (cc == c)
+                        goto while2end;
+                    break;
+                }
+            }
+while2end:
+            pfile->lineno += count_newlines(pfile->token_buffer + old_written,
+                                            CPP_PWRITTEN(pfile));
+            pfile->only_seen_white = 0;
+            return c == '\'' ? CPP_CHAR : CPP_STRING;
+
+        case '$':
+            if (!opts->dollars_in_ident)
+                goto randomchar;
+            goto letter;
+
+        case ':':
+            if (opts->cplusplus && PEEKC() == ':')
+                goto op2;
+            goto randomchar;
+
+        case '&':
+        case '+':
+        case '|':
+            NEWLINE_FIX;
+            c2 = PEEKC();
+            if (c2 == c || c2 == '=')
+                goto op2;
+            goto randomchar;
+
+        case '*':
+        case '!':
+        case '%':
+        case '=':
+        case '^':
+            NEWLINE_FIX;
+            if (PEEKC() == '=')
+                goto op2;
+            goto randomchar;
+
+        case '-':
+            NEWLINE_FIX;
+            c2 = PEEKC();
+            if (c2 == '-' && opts->chill)
+            {
+                /* Chill style comment */
+                if (opts->put_out_comments)
+                    parse_set_mark(&start_mark, pfile);
+                FORWARD(1); /* Skip second '-'.  */
+                for (;; )
+                {
+                    c = GETC();
+                    if (c == EOF)
+                        break;
+                    if (c == '\n')
+                    {
+                        /* Don't consider final '\n' to be part of comment.  */
+                        FORWARD(-1);
+                        break;
+                    }
+                }
+                c = '-';
+                goto return_comment;
+            }
+            if (c2 == '-' || c2 == '=' || c2 == '>')
+                goto op2;
+            goto randomchar;
+
+        case '<':
+            if (pfile->parsing_include_directive)
+            {
+                for (;; )
+                {
+                    CPP_PUTC(pfile, c);
+                    if (c == '>')
+                        break;
+                    c = GETC();
+                    NEWLINE_FIX1(c);
+                    if (c == '\n' || c == EOF)
+                    {
+                        cpp_error(pfile,
+                                  "missing '>' in `#include <FILENAME>'");
+                        break;
+                    }
+                }
+                return CPP_STRING;
+            }
+        /* else fall through */
+        case '>':
+            NEWLINE_FIX;
+            c2 = PEEKC();
+            if (c2 == '=')
+                goto op2;
+            if (c2 != c)
+                goto randomchar;
+            FORWARD(1);
+            CPP_RESERVE(pfile, 4);
+            CPP_PUTC(pfile, c);
+            CPP_PUTC(pfile, c2);
+            NEWLINE_FIX;
+            c3 = PEEKC();
+            if (c3 == '=')
+                CPP_PUTC_Q(pfile, GETC());
+            CPP_NUL_TERMINATE_Q(pfile);
+            pfile->only_seen_white = 0;
+            return CPP_OTHER;
+
+        case '@':
+            if (CPP_BUFFER(pfile)->has_escapes)
+            {
+                c = GETC();
+                if (c == '-')
+                {
+                    if (pfile->output_escapes)
+                        CPP_PUTS(pfile, "@-", 2);
+                    parse_name(pfile, GETC());
+                    return CPP_NAME;
+                }
+                else if (is_space [c])
+                {
+                    CPP_RESERVE(pfile, 2);
+                    if (pfile->output_escapes)
+                        CPP_PUTC_Q(pfile, '@');
+                    CPP_PUTC_Q(pfile, c);
+                    return CPP_HSPACE;
+                }
+            }
+            if (pfile->output_escapes)
+            {
+                CPP_PUTS(pfile, "@@", 2);
+                return CPP_OTHER;
+            }
+            goto randomchar;
+
+        case '.':
+            NEWLINE_FIX;
+            c2 = PEEKC();
+            if (ISDIGIT(c2))
+            {
+                CPP_RESERVE(pfile, 2);
+                CPP_PUTC_Q(pfile, '.');
+                c = GETC();
+                goto number;
+            }
+            /* FIXME - misses the case "..\\\n." */
+            if (c2 == '.' && PEEKN(1) == '.')
+            {
+                CPP_RESERVE(pfile, 4);
+                CPP_PUTC_Q(pfile, '.');
+                CPP_PUTC_Q(pfile, '.');
+                CPP_PUTC_Q(pfile, '.');
+                FORWARD(2);
+                CPP_NUL_TERMINATE_Q(pfile);
+                pfile->only_seen_white = 0;
+                return CPP_3DOTS;
+            }
+            goto randomchar;
+
+op2:
+            token = CPP_OTHER;
+            pfile->only_seen_white = 0;
+op2any:
+            CPP_RESERVE(pfile, 3);
+            CPP_PUTC_Q(pfile, c);
+            CPP_PUTC_Q(pfile, GETC());
+            CPP_NUL_TERMINATE_Q(pfile);
+            return token;
+
+        case 'L':
+            NEWLINE_FIX;
+            c2 = PEEKC();
+            if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL(pfile))
+            {
+                CPP_PUTC(pfile, c);
+                c = GETC();
+                goto string;
+            }
+            goto letter;
+
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+number:
+            c2  = '.';
+            for (;; )
+            {
+                CPP_RESERVE(pfile, 2);
+                CPP_PUTC_Q(pfile, c);
+                NEWLINE_FIX;
+                c = PEEKC();
+                if (c == EOF)
+                    break;
+                if (!is_idchar[c] && c != '.'
+                    && ((c2 != 'e' && c2 != 'E'
+                         && ((c2 != 'p' && c2 != 'P') || CPP_C89(pfile)))
+                        || (c != '+' && c != '-')))
+                    break;
+                FORWARD(1);
+                c2= c;
+            }
+            CPP_NUL_TERMINATE_Q(pfile);
+            pfile->only_seen_white = 0;
+            return CPP_NUMBER;
+        case 'b': case 'c': case 'd': case 'h': case 'o':
+        case 'B': case 'C': case 'D': case 'H': case 'O':
+            if (opts->chill && PEEKC() == '\'')
+            {
+                pfile->only_seen_white = 0;
+                CPP_RESERVE(pfile, 2);
+                CPP_PUTC_Q(pfile, c);
+                CPP_PUTC_Q(pfile, '\'');
+                FORWARD(1);
+                for (;; )
+                {
+                    c = GETC();
+                    if (c == EOF)
+                        goto chill_number_eof;
+                    if (!is_idchar[c])
+                    {
+                        if (c == '\\' && PEEKC() == '\n')
                         {
-                          if (macro_mark.position !=
-                              (CPP_BUFFER (pfile)->cur
-                               - CPP_BUFFER (pfile)->buf))
-                             macbuf_whitespace = 1;
-
-                          parse_clear_mark (&macro_mark);
-                          cpp_pop_buffer (pfile);
-                          parse_set_mark (&macro_mark, pfile);
+                            FORWARD(2);
+                            continue;
                         }
-                      else
                         break;
                     }
-		}
-	      if (!is_macro_call)
+                    CPP_PUTC(pfile, c);
+                }
+                if (c == '\'')
+                {
+                    CPP_RESERVE(pfile, 2);
+                    CPP_PUTC_Q(pfile, c);
+                    CPP_NUL_TERMINATE_Q(pfile);
+                    return CPP_STRING;
+                }
+                else
                 {
-                  parse_goto_mark (&macro_mark, pfile);
-                  if (macbuf_whitespace)
-                    CPP_PUTC (pfile, ' ');
+                    FORWARD(-1);
+chill_number_eof:
+                    CPP_NUL_TERMINATE(pfile);
+                    return CPP_NUMBER;
+                }
+            }
+            else
+                goto letter;
+        case '_':
+        case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
+        case 'k': case 'l': case 'm': case 'n': 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 'E': case 'F': case 'G': case 'I': case 'J':
+        case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
+        case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
+        case 'Y': case 'Z':
+letter:
+            {
+                HASHNODE *hp;
+                unsigned char *ident;
+                int before_name_written = CPP_WRITTEN(pfile);
+                int ident_len;
+                parse_name(pfile, c);
+                pfile->only_seen_white = 0;
+                if (pfile->no_macro_expand)
+                    return CPP_NAME;
+                ident = pfile->token_buffer + before_name_written;
+                ident_len = CPP_PWRITTEN(pfile) - ident;
+                hp = cpp_lookup(pfile, ident, ident_len, -1);
+                if (!hp)
+                    return CPP_NAME;
+                if (hp->type == T_DISABLED)
+                {
+                    if (pfile->output_escapes)
+                    { /* Return "@-IDENT", followed by '\0'.  */
+                        int i;
+                        CPP_RESERVE(pfile, 3);
+                        ident = pfile->token_buffer + before_name_written;
+                        CPP_ADJUST_WRITTEN(pfile, 2);
+                        for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
+                        ident[0] = '@';
+                        ident[1] = '-';
+                    }
+                    return CPP_NAME;
                 }
-	      parse_clear_mark (&macro_mark);
-	      if (!is_macro_call)
-		return CPP_NAME;
-	    }
-	    /* This is now known to be a macro call.  */
-
-	    /* it might not actually be a macro.  */
-	    if (hp->type != T_MACRO) {
-	      int xbuf_len;  U_CHAR *xbuf;
-	      CPP_SET_WRITTEN (pfile, before_name_written);
-	      special_symbol (hp, pfile);
-	      xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
-	      xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
-	      CPP_SET_WRITTEN (pfile, before_name_written);
-	      copy_memory (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
-	      push_macro_expansion (pfile, xbuf, xbuf_len, hp);
-	    }
-	    else
-	      {
-		/* Expand the macro, reading arguments as needed,
-		   and push the expansion on the input stack.  */
-		macroexpand (pfile, hp);
-		CPP_SET_WRITTEN (pfile, before_name_written);
-	      }
-
-	    /* An extra "@ " is added to the end of a macro expansion
-	       to prevent accidental token pasting.  We prefer to avoid
-	       unneeded extra spaces (for the sake of cpp-using tools like
-	       imake).  Here we remove the space if it is safe to do so.  */
-	    if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
-		&& pfile->buffer->rlimit[-2] == '@'
-		&& pfile->buffer->rlimit[-1] == ' ')
-	      {
-		int c1 = pfile->buffer->rlimit[-3];
-		int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
-		if (c2 == EOF || ! unsafe_chars (c1, c2))
-		  pfile->buffer->rlimit -= 2;
-	      }
-	  }
-	  goto get_next;
-
-	case ' ':  case '\t':  case '\v':  case '\r':
-	  for (;;)
-	    {
-	      CPP_PUTC (pfile, c);
-	      c = PEEKC ();
-	      if (c == EOF || !is_hor_space[c])
-		break;
-	      FORWARD(1);
-	    }
-	  return CPP_HSPACE;
+
+                /* 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)
+                {
+                    struct parse_marker macro_mark;
+                    int is_macro_call, macbuf_whitespace = 0;
+
+                    parse_set_mark(&macro_mark, pfile);
+                    for (;; )
+                    {
+                        cpp_skip_hspace(pfile);
+                        c = PEEKC();
+                        is_macro_call = c == '(';
+                        if (c != EOF)
+                        {
+                            if (c != '\n')
+                                break;
+                            FORWARD(1);
+                        }
+                        else
+                        {
+                            if (CPP_IS_MACRO_BUFFER(CPP_BUFFER(pfile)))
+                            {
+                                if (macro_mark.position !=
+                                    (CPP_BUFFER(pfile)->cur
+                                     - CPP_BUFFER(pfile)->buf))
+                                    macbuf_whitespace = 1;
+
+                                parse_clear_mark(&macro_mark);
+                                cpp_pop_buffer(pfile);
+                                parse_set_mark(&macro_mark, pfile);
+                            }
+                            else
+                                break;
+                        }
+                    }
+                    if (!is_macro_call)
+                    {
+                        parse_goto_mark(&macro_mark, pfile);
+                        if (macbuf_whitespace)
+                            CPP_PUTC(pfile, ' ');
+                    }
+                    parse_clear_mark(&macro_mark);
+                    if (!is_macro_call)
+                        return CPP_NAME;
+                }
+                /* This is now known to be a macro call.  */
+
+                /* it might not actually be a macro.  */
+                if (hp->type != T_MACRO) {
+                    int xbuf_len;  U_CHAR *xbuf;
+                    CPP_SET_WRITTEN(pfile, before_name_written);
+                    special_symbol(hp, pfile);
+                    xbuf_len = CPP_WRITTEN(pfile) - before_name_written;
+                    xbuf = (U_CHAR *) xmalloc(xbuf_len + 1);
+                    CPP_SET_WRITTEN(pfile, before_name_written);
+                    copy_memory(CPP_PWRITTEN(pfile), xbuf, xbuf_len + 1);
+                    push_macro_expansion(pfile, xbuf, xbuf_len, hp);
+                }
+                else
+                {
+                    /* Expand the macro, reading arguments as needed,
+                       and push the expansion on the input stack.  */
+                    macroexpand(pfile, hp);
+                    CPP_SET_WRITTEN(pfile, before_name_written);
+                }
+
+                /* An extra "@ " is added to the end of a macro expansion
+                   to prevent accidental token pasting.  We prefer to avoid
+                   unneeded extra spaces (for the sake of cpp-using tools like
+                   imake).  Here we remove the space if it is safe to do so.  */
+                if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
+                    && pfile->buffer->rlimit[-2] == '@'
+                    && pfile->buffer->rlimit[-1] == ' ')
+                {
+                    int c1 = pfile->buffer->rlimit[-3];
+                    int c2 = CPP_BUF_PEEK(CPP_PREV_BUFFER(CPP_BUFFER(pfile)));
+                    if (c2 == EOF || !unsafe_chars(c1, c2))
+                        pfile->buffer->rlimit -= 2;
+                }
+            }
+            goto get_next;
+
+        case ' ':  case '\t':  case '\v':  case '\r':
+            for (;; )
+            {
+                CPP_PUTC(pfile, c);
+                c = PEEKC();
+                if (c == EOF || !is_hor_space[c])
+                    break;
+                FORWARD(1);
+            }
+            return CPP_HSPACE;
 
         case '\\':
-	  c2 = PEEKC ();
-	  if (c2 != '\n')
-	    goto randomchar;
-	  token = CPP_HSPACE;
-	  goto op2any;
-
-	case '\n':
-	  CPP_PUTC (pfile, c);
-	  if (pfile->only_seen_white == 0)
-	    pfile->only_seen_white = 1;
-	  pfile->lineno++;
-	  output_line_command (pfile, 1, same_file);
-	  return CPP_VSPACE;
-
-	case '(': token = CPP_LPAREN;    goto char1;
-	case ')': token = CPP_RPAREN;    goto char1;
-	case '{': token = CPP_LBRACE;    goto char1;
-	case '}': token = CPP_RBRACE;    goto char1;
-	case ',': token = CPP_COMMA;     goto char1;
-	case ';': token = CPP_SEMICOLON; goto char1;
-
-	randomchar:
-	default:
-	  token = CPP_OTHER;
-	char1:
-	  pfile->only_seen_white = 0;
-	  CPP_PUTC (pfile, c);
-	  return token;
-	}
+            c2 = PEEKC();
+            if (c2 != '\n')
+                goto randomchar;
+            token = CPP_HSPACE;
+            goto op2any;
+
+        case '\n':
+            CPP_PUTC(pfile, c);
+            if (pfile->only_seen_white == 0)
+                pfile->only_seen_white = 1;
+            pfile->lineno++;
+            output_line_command(pfile, 1, same_file);
+            return CPP_VSPACE;
+
+        case '(': token = CPP_LPAREN;    goto char1;
+        case ')': token = CPP_RPAREN;    goto char1;
+        case '{': token = CPP_LBRACE;    goto char1;
+        case '}': token = CPP_RBRACE;    goto char1;
+        case ',': token = CPP_COMMA;     goto char1;
+        case ';': token = CPP_SEMICOLON; goto char1;
+
+randomchar:
+        default:
+            token = CPP_OTHER;
+char1:
+            pfile->only_seen_white = 0;
+            CPP_PUTC(pfile, c);
+            return token;
+        }
     }
 }
 
 /* Like cpp_get_token, but skip spaces and comments.  */
 
 enum cpp_token
-cpp_get_non_space_token (pfile)
-     cpp_reader *pfile;
+cpp_get_non_space_token(cpp_reader *pfile)
 {
-  int old_written = CPP_WRITTEN (pfile);
-  for (;;)
+    int old_written = CPP_WRITTEN(pfile);
+    for (;; )
     {
-      enum cpp_token token = cpp_get_token (pfile);
-      if (token != CPP_COMMENT && token != CPP_POP
-	  && token != CPP_HSPACE && token != CPP_VSPACE)
-	return token;
-      CPP_SET_WRITTEN (pfile, old_written);
+        enum cpp_token token = cpp_get_token(pfile);
+        if (token != CPP_COMMENT && token != CPP_POP
+            && token != CPP_HSPACE && token != CPP_VSPACE)
+            return token;
+        CPP_SET_WRITTEN(pfile, old_written);
     }
 }
 
 /* Parse an identifier starting with C.  */
 
 static int
-parse_name (pfile, c)
-     cpp_reader *pfile; int c;
+parse_name(cpp_reader *pfile, int c)
 {
-  for (;;)
-  {
-      if (! is_idchar[c])
-      {
-	  if (c == '\\' && PEEKC() == '\n')
-	  {
-	      FORWARD(2);
-	      continue;
-	  }
-	  FORWARD (-1);
-	  break;
-      }
+    for (;; )
+    {
+        if (!is_idchar[c])
+        {
+            if (c == '\\' && PEEKC() == '\n')
+            {
+                FORWARD(2);
+                continue;
+            }
+            FORWARD(-1);
+            break;
+        }
 
-      if (c == '$' && CPP_PEDANTIC (pfile))
-	cpp_pedwarn (pfile, "`$' in identifier");
+        if (c == '$' && CPP_PEDANTIC(pfile))
+            cpp_pedwarn(pfile, "`$' in identifier");
 
-      CPP_RESERVE(pfile, 2); /* One more for final NUL.  */
-      CPP_PUTC_Q (pfile, c);
-      c = GETC();
-      if (c == EOF)
-	break;
-  }
-  CPP_NUL_TERMINATE_Q (pfile);
-  return 1;
+        CPP_RESERVE(pfile, 2); /* One more for final NUL.  */
+        CPP_PUTC_Q(pfile, c);
+        c = GETC();
+        if (c == EOF)
+            break;
+    }
+    CPP_NUL_TERMINATE_Q(pfile);
+    return 1;
 }
 
 /* This is called after options have been processed.
@@ -4687,1105 +4491,1010 @@ parse_name (pfile, c)
  */
 
 int
-cpp_start_read (pfile, fname)
-     cpp_reader *pfile;
-     char *fname;
+cpp_start_read(cpp_reader *pfile, char *fname)
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
-  struct cpp_pending *pend;
-  char *p;
-  int f;
-  cpp_buffer *fp;
-  struct include_hash *ih_fake;
-
-  /* The code looks at the defaults through this pointer, rather than through
-     the constant structure above.  This pointer gets changed if an environment
-     variable specifies other defaults.  */
-  struct default_include *include_defaults = include_defaults_array;
-
-  /* Now that we know dollars_in_ident for real,
-     reset is_idchar/is_idstart. */
-  is_idchar['$'] = opts->dollars_in_ident;
-  is_idstart['$'] = opts->dollars_in_ident;
-  
-  /* Add dirs from CPATH after dirs from -I.  */
-  /* There seems to be confusion about what CPATH should do,
-     so for the moment it is not documented.  */
-  /* Some people say that CPATH should replace the standard include dirs,
-     but that seems pointless: it comes before them, so it overrides them
-     anyway.  */
-  GET_ENV_PATH_LIST (p, "CPATH");
-  if (p != 0 && ! opts->no_standard_includes)
-    path_include (pfile, p);
-
-  /* Do partial setup of input buffer for the sake of generating
-     early #line directives (when -g is in effect).  */
-  fp = cpp_push_buffer (pfile, NULL, 0);
-  if (!fp)
-    return 0;
-  if (opts->in_fname == NULL || *opts->in_fname == 0)
+    struct cpp_options *opts = CPP_OPTIONS(pfile);
+    struct cpp_pending *pend;
+    char *p;
+    int f;
+    cpp_buffer *fp;
+    struct include_hash *ih_fake;
+
+    /* The code looks at the defaults through this pointer, rather than through
+       the constant structure above.  This pointer gets changed if an environment
+       variable specifies other defaults.  */
+    struct default_include *include_defaults = include_defaults_array;
+
+    /* Now that we know dollars_in_ident for real,
+       reset is_idchar/is_idstart. */
+    is_idchar['$'] = opts->dollars_in_ident;
+    is_idstart['$'] = opts->dollars_in_ident;
+
+    /* Add dirs from CPATH after dirs from -I.  */
+    /* There seems to be confusion about what CPATH should do,
+       so for the moment it is not documented.  */
+    /* Some people say that CPATH should replace the standard include dirs,
+       but that seems pointless: it comes before them, so it overrides them
+       anyway.  */
+    GET_ENV_PATH_LIST(p, "CPATH");
+    if (p != 0 && !opts->no_standard_includes)
+        path_include(pfile, p);
+
+    /* Do partial setup of input buffer for the sake of generating
+       early #line directives (when -g is in effect).  */
+    fp = cpp_push_buffer(pfile, NULL, 0);
+    if (!fp)
+        return 0;
+    if (opts->in_fname == NULL || *opts->in_fname == 0)
     {
-      opts->in_fname = fname;
-      if (opts->in_fname == NULL)
-	opts->in_fname = "";
+        opts->in_fname = fname;
+        if (opts->in_fname == NULL)
+            opts->in_fname = "";
     }
-  fp->nominal_fname = fp->fname = opts->in_fname;
-  fp->lineno = 0;
-
-  /* Install __LINE__, etc.  Must follow initialize_char_syntax
-     and option processing.  */
-  initialize_builtins (pfile);
-
-  /* Do standard #defines and assertions
-     that identify system and machine type.  */
-
-  if (!opts->inhibit_predefs) {
-    char *p = (char *) alloca (strlen (predefs) + 1);
-    strcpy (p, predefs);
-    while (*p) {
-      char *q;
-      while (*p == ' ' || *p == '\t')
-	p++;
-      /* Handle -D options.  */ 
-      if (p[0] == '-' && p[1] == 'D') {
-	q = &p[2];
-	while (*p && *p != ' ' && *p != '\t')
-	  p++;
-	if (*p != 0)
-	  *p++= 0;
-	if (opts->debug_output)
-	  output_line_command (pfile, 0, same_file);
-	cpp_define (pfile, q);
-	while (*p == ' ' || *p == '\t')
-	  p++;
-      } else if (p[0] == '-' && p[1] == 'A') {
-	/* Handle -A options (assertions).  */ 
-	char *assertion;
-	char *past_name;
-	char *value;
-	char *past_value;
-	char *termination;
-	int save_char;
-
-	assertion = &p[2];
-	past_name = assertion;
-	/* Locate end of name.  */
-	while (*past_name && *past_name != ' '
-	       && *past_name != '\t' && *past_name != '(')
-	  past_name++;
-	/* Locate `(' at start of value.  */
-	value = past_name;
-	while (*value && (*value == ' ' || *value == '\t'))
-	  value++;
-	if (*value++ != '(')
-	  abort ();
-	while (*value && (*value == ' ' || *value == '\t'))
-	  value++;
-	past_value = value;
-	/* Locate end of value.  */
-	while (*past_value && *past_value != ' '
-	       && *past_value != '\t' && *past_value != ')')
-	  past_value++;
-	termination = past_value;
-	while (*termination && (*termination == ' ' || *termination == '\t'))
-	  termination++;
-	if (*termination++ != ')')
-	  abort ();
-	if (*termination && *termination != ' ' && *termination != '\t')
-	  abort ();
-	/* Temporarily null-terminate the value.  */
-	save_char = *termination;
-	*termination = '\0';
-	/* Install the assertion.  */
-	make_assertion (pfile, "-A", assertion);
-	*termination = (char) save_char;
-	p = termination;
-	while (*p == ' ' || *p == '\t')
-	  p++;
-      } else {
-	abort ();
-      }
-    }
-  }
+    fp->nominal_fname = fp->fname = opts->in_fname;
+    fp->lineno = 0;
 
-  /* Now handle the command line options.  */
+    /* Install __LINE__, etc.  Must follow initialize_char_syntax
+       and option processing.  */
+    initialize_builtins(pfile);
 
-  /* Do -U's, -D's and -A's in the order they were seen.  */
-  /* First reverse the list.  */
-  opts->pending = nreverse_pending (opts->pending);
+    /* Do standard #defines that identify system and machine type.  */
 
-  for (pend = opts->pending;  pend;  pend = pend->next)
+    if (!opts->inhibit_predefs)
     {
-      if (pend->cmd != NULL && pend->cmd[0] == '-')
-	{
-	  switch (pend->cmd[1])
-	    {
-	    case 'U':
-	      if (opts->debug_output)
-		output_line_command (pfile, 0, same_file);
-	      cpp_undef (pfile, pend->arg);
-	      break;
-	    case 'D':
-	      if (opts->debug_output)
-		output_line_command (pfile, 0, same_file);
-	      cpp_define (pfile, pend->arg);
-	      break;
-	    case 'A':
-	      make_assertion (pfile, "-A", pend->arg);
-	      break;
-	    }
-	}
+        char *p = (char *) alloca(strlen(predefs) + 1);
+        strcpy(p, predefs);
+        while (*p)
+        {
+            char *q;
+            while (*p == ' ' || *p == '\t')
+                p++;
+            /* Handle -D options.  */
+            if (p[0] == '-' && p[1] == 'D')
+            {
+                q = &p[2];
+                while (*p && *p != ' ' && *p != '\t')
+                    p++;
+                if (*p != 0)
+                    *p++= 0;
+                if (opts->debug_output)
+                    output_line_command(pfile, 0, same_file);
+                cpp_define(pfile, q);
+                while (*p == ' ' || *p == '\t')
+                    p++;
+            }
+            else
+            {
+                abort();
+            }
+        }
     }
 
-  opts->done_initializing = 1;
+    /* Now handle the command line options.  */
 
-  { /* Read the appropriate environment variable and if it exists
-       replace include_defaults with the listed path.  */
-    char *epath = 0;
-    switch ((opts->objc << 1) + opts->cplusplus)
-      {
-      case 0:
-	GET_ENV_PATH_LIST (epath, "C_INCLUDE_PATH");
-	break;
-      case 1:
-	GET_ENV_PATH_LIST (epath, "CPLUS_INCLUDE_PATH");
-	break;
-      case 2:
-	GET_ENV_PATH_LIST (epath, "OBJC_INCLUDE_PATH");
-	break;
-      case 3:
-	GET_ENV_PATH_LIST (epath, "OBJCPLUS_INCLUDE_PATH");
-	break;
-      }
-    /* If the environment var for this language is set,
-       add to the default list of include directories.  */
-    if (epath) {
-      char *nstore = (char *) alloca (strlen (epath) + 2);
-      int num_dirs;
-      char *startp, *endp;
-
-      for (num_dirs = 1, startp = epath; *startp; startp++)
-	if (*startp == PATH_SEPARATOR)
-	  num_dirs++;
-      include_defaults
-	= (struct default_include *) xmalloc ((num_dirs
-					       * sizeof (struct default_include))
-					      + sizeof (include_defaults_array));
-      startp = endp = epath;
-      num_dirs = 0;
-      while (1) {
-        /* Handle cases like c:/usr/lib:d:/gcc/lib */
-        if ((*endp == PATH_SEPARATOR)
-            || *endp == 0) {
-	  strncpy (nstore, startp, endp-startp);
-	  if (endp == startp)
-	    strcpy (nstore, ".");
-	  else
-	    nstore[endp-startp] = '\0';
-
-	  include_defaults[num_dirs].fname = xstrdup (nstore);
-	  include_defaults[num_dirs].component = 0;
-	  include_defaults[num_dirs].cplusplus = opts->cplusplus;
-	  include_defaults[num_dirs].cxx_aware = 1;
-	  num_dirs++;
-	  if (*endp == '\0')
-	    break;
-	  endp = startp = endp + 1;
-	} else
-	  endp++;
-      }
-      /* Put the usual defaults back in at the end.  */
-      copy_memory ((char *) include_defaults_array,
-	     (char *) &include_defaults[num_dirs],
-	     sizeof (include_defaults_array));
+    /* Do -U's, -D's and -A's in the order they were seen.  */
+    /* First reverse the list.  */
+    opts->pending = nreverse_pending(opts->pending);
+
+    for (pend = opts->pending; pend; pend = pend->next)
+    {
+        if (pend->cmd != NULL && pend->cmd[0] == '-')
+        {
+            switch (pend->cmd[1])
+            {
+            case 'U':
+                if (opts->debug_output)
+                    output_line_command(pfile, 0, same_file);
+                cpp_undef(pfile, pend->arg);
+                break;
+            case 'D':
+                if (opts->debug_output)
+                    output_line_command(pfile, 0, same_file);
+                cpp_define(pfile, pend->arg);
+                break;
+            }
+        }
     }
-  }
 
-  /* Unless -fnostdinc,
-     tack on the standard include file dirs to the specified list */
-  if (!opts->no_standard_includes) {
-    struct default_include *p = include_defaults;
-    char *specd_prefix = opts->include_prefix;
-    char *default_prefix = xstrdup (GCC_INCLUDE_DIR);
-    int default_len = 0;
-    /* Remove the `include' from /usr/local/lib/gcc.../include.  */
-    if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
-      default_len = strlen (default_prefix) - 7;
-      default_prefix[default_len] = 0;
+    opts->done_initializing = 1;
+
+    { /* Read the appropriate environment variable and if it exists
+         replace include_defaults with the listed path.  */
+        char *epath = 0;
+        switch ((opts->objc << 1) + opts->cplusplus)
+        {
+        case 0:
+            GET_ENV_PATH_LIST(epath, "C_INCLUDE_PATH");
+            break;
+        case 1:
+            GET_ENV_PATH_LIST(epath, "CPLUS_INCLUDE_PATH");
+            break;
+        case 2:
+            GET_ENV_PATH_LIST(epath, "OBJC_INCLUDE_PATH");
+            break;
+        case 3:
+            GET_ENV_PATH_LIST(epath, "OBJCPLUS_INCLUDE_PATH");
+            break;
+        }
+        /* If the environment var for this language is set,
+           add to the default list of include directories.  */
+        if (epath) {
+            char *nstore = (char *) alloca(strlen(epath) + 2);
+            int num_dirs;
+            char *startp, *endp;
+
+            for (num_dirs = 1, startp = epath; *startp; startp++)
+                if (*startp == PATH_SEPARATOR)
+                    num_dirs++;
+            include_defaults
+                = (struct default_include *) xmalloc((num_dirs
+                                                      * sizeof (struct default_include))
+                                                     + sizeof (include_defaults_array));
+            startp = endp = epath;
+            num_dirs = 0;
+            while (1) {
+                /* Handle cases like c:/usr/lib:d:/gcc/lib */
+                if ((*endp == PATH_SEPARATOR)
+                    || *endp == 0) {
+                    strncpy(nstore, startp, endp-startp);
+                    if (endp == startp)
+                        strcpy(nstore, ".");
+                    else
+                        nstore[endp-startp] = '\0';
+
+                    include_defaults[num_dirs].fname = xstrdup(nstore);
+                    include_defaults[num_dirs].component = 0;
+                    include_defaults[num_dirs].cplusplus = opts->cplusplus;
+                    include_defaults[num_dirs].cxx_aware = 1;
+                    num_dirs++;
+                    if (*endp == '\0')
+                        break;
+                    endp = startp = endp + 1;
+                } else
+                    endp++;
+            }
+            /* Put the usual defaults back in at the end.  */
+            copy_memory((char *) include_defaults_array,
+                        (char *) &include_defaults[num_dirs],
+                        sizeof (include_defaults_array));
+        }
     }
-    /* Search "translated" versions of GNU directories.
-       These have /usr/local/lib/gcc... replaced by specd_prefix.  */
-    if (specd_prefix != 0 && default_len != 0)
-      for (p = include_defaults; p->fname; p++) {
-	/* Some standard dirs are only for C++.  */
-	if (!p->cplusplus
-	    || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
-	  /* Does this dir start with the prefix?  */
-	  if (!strncmp (p->fname, default_prefix, default_len)) {
-	    /* Yes; change prefix and add to search list.  */
-	    int this_len = strlen (specd_prefix)
-			   + strlen (p->fname) - default_len;
-	    char *str = (char *) xmalloc (this_len + 1);
-	    strcpy (str, specd_prefix);
-	    strcat (str, p->fname + default_len);
-
-	    append_include_chain (pfile, &opts->system_include,
-				  str, !p->cxx_aware);
-	  }
-	}
-      }
-    /* Search ordinary names for GNU include directories.  */
-    for (p = include_defaults; p->fname; p++) {
-      /* Some standard dirs are only for C++.  */
-      if (!p->cplusplus
-	  || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
-	const char *str = update_path (p->fname, p->component);
-	append_include_chain (pfile, &opts->system_include,
-			      str, !p->cxx_aware);
-      }
+
+    /* Unless -fnostdinc,
+       tack on the standard include file dirs to the specified list */
+    if (!opts->no_standard_includes) {
+        struct default_include *p = include_defaults;
+        char *specd_prefix = opts->include_prefix;
+        char *default_prefix = xstrdup(GCC_INCLUDE_DIR);
+        int default_len = 0;
+        /* Remove the `include' from /usr/local/lib/gcc.../include.  */
+        if (!strcmp(default_prefix + strlen(default_prefix) - 8, "/include")) {
+            default_len = strlen(default_prefix) - 7;
+            default_prefix[default_len] = 0;
+        }
+        /* Search "translated" versions of GNU directories.
+           These have /usr/local/lib/gcc... replaced by specd_prefix.  */
+        if (specd_prefix != 0 && default_len != 0)
+            for (p = include_defaults; p->fname; p++) {
+                /* Some standard dirs are only for C++.  */
+                if (!p->cplusplus
+                    || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
+                    /* Does this dir start with the prefix?  */
+                    if (!strncmp(p->fname, default_prefix, default_len)) {
+                        /* Yes; change prefix and add to search list.  */
+                        int this_len = strlen(specd_prefix)
+                                       + strlen(p->fname) - default_len;
+                        char *str = (char *) xmalloc(this_len + 1);
+                        strcpy(str, specd_prefix);
+                        strcat(str, p->fname + default_len);
+
+                        append_include_chain(pfile, &opts->system_include,
+                                             str, !p->cxx_aware);
+                    }
+                }
+            }
+        /* Search ordinary names for GNU include directories.  */
+        for (p = include_defaults; p->fname; p++) {
+            /* Some standard dirs are only for C++.  */
+            if (!p->cplusplus
+                || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
+                const char *str = update_path(p->fname, p->component);
+                append_include_chain(pfile, &opts->system_include,
+                                     str, !p->cxx_aware);
+            }
+        }
     }
-  }
 
-  merge_include_chains (opts);
+    merge_include_chains(opts);
 
-  /* With -v, print the list of dirs to search.  */
-  if (opts->verbose) {
-    struct file_name_list *p;
-    fprintf (stderr, "#include \"...\" search starts here:\n");
-    for (p = opts->quote_include; p; p = p->next) {
-      if (p == opts->bracket_include)
-	fprintf (stderr, "#include <...> search starts here:\n");
-      fprintf (stderr, " %s\n", p->name);
+    /* With -v, print the list of dirs to search.  */
+    if (opts->verbose) {
+        struct file_name_list *p;
+        fprintf(stderr, "#include \"...\" search starts here:\n");
+        for (p = opts->quote_include; p; p = p->next) {
+            if (p == opts->bracket_include)
+                fprintf(stderr, "#include <...> search starts here:\n");
+            fprintf(stderr, " %s\n", p->name);
+        }
+        fprintf(stderr, "End of search list.\n");
     }
-    fprintf (stderr, "End of search list.\n");
-  }
 
-  /* Copy the entire contents of the main input file into
-     the stacked input buffer previously allocated for it.  */
-  if (fname == NULL || *fname == 0) {
-    fname = "";
-    f = 0;
-  } else if ((f = open (fname, O_RDONLY, 0666)) < 0)
-    cpp_pfatal_with_name (pfile, fname);
-
-  /* -MG doesn't select the form of output and must be specified with one of
-     -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
-     inhibit compilation.  */
-  if (opts->print_deps_missing_files
-      && (opts->print_deps == 0 || !opts->no_output))
+    /* Copy the entire contents of the main input file into
+       the stacked input buffer previously allocated for it.  */
+    if (fname == NULL || *fname == 0) {
+        fname = "";
+        f = 0;
+    } else if ((f = open(fname, O_RDONLY, 0666)) < 0)
+        cpp_pfatal_with_name(pfile, fname);
+
+    /* -MG doesn't select the form of output and must be specified with one of
+       -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
+       inhibit compilation.  */
+    if (opts->print_deps_missing_files
+        && (opts->print_deps == 0 || !opts->no_output))
     {
-      cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
-      return 0;
+        cpp_fatal(pfile, "-MG must be specified with one of -M or -MM");
+        return 0;
     }
 
-  /* 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 (opts->print_deps == 0
-      && (getenv ("SUNPRO_DEPENDENCIES") != 0
-	  || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
-    char *spec = getenv ("DEPENDENCIES_OUTPUT");
-    char *s;
-    char *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 (spec == 0)
-      {
-	spec = getenv ("SUNPRO_DEPENDENCIES");
-	opts->print_deps = 2;
-      }
-    else
-      opts->print_deps = 1;
+    if (opts->print_deps == 0
+        && (getenv("SUNPRO_DEPENDENCIES") != 0
+            || getenv("DEPENDENCIES_OUTPUT") != 0)) {
+        char *spec = getenv("DEPENDENCIES_OUTPUT");
+        char *s;
+        char *output_file;
 
-    s = spec;
-    /* Find the space before the DEPS_TARGET, if there is one.  */
-    /* This should use index.  (mrs) */
-    while (*s != 0 && *s != ' ') s++;
-    if (*s != 0)
-      {
-	opts->deps_target = s + 1;
-	output_file = (char *) xmalloc (s - spec + 1);
-	copy_memory (spec, output_file, s - spec);
-	output_file[s - spec] = 0;
-      }
-    else
-      {
-	opts->deps_target = 0;
-	output_file = spec;
-      }
+        if (spec == 0)
+        {
+            spec = getenv("SUNPRO_DEPENDENCIES");
+            opts->print_deps = 2;
+        }
+        else
+            opts->print_deps = 1;
+
+        s = spec;
+        /* Find the space before the DEPS_TARGET, if there is one.  */
+        /* This should use index.  (mrs) */
+        while (*s != 0 && *s != ' ') s++;
+        if (*s != 0)
+        {
+            opts->deps_target = s + 1;
+            output_file = (char *) xmalloc(s - spec + 1);
+            copy_memory(spec, output_file, s - spec);
+            output_file[s - spec] = 0;
+        }
+        else
+        {
+            opts->deps_target = 0;
+            output_file = spec;
+        }
 
-    opts->deps_file = output_file;
-    opts->print_deps_append = 1;
-  }
+        opts->deps_file = output_file;
+        opts->print_deps_append = 1;
+    }
 
-  /* For -M, print the expected object file name
-     as the target of this Make-rule.  */
-  if (opts->print_deps)
+    /* For -M, print the expected object file name
+       as the target of this Make-rule.  */
+    if (opts->print_deps)
     {
-      pfile->deps_allocated_size = 200;
-      pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
-      pfile->deps_buffer[0] = 0;
-      pfile->deps_size = 0;
-      pfile->deps_column = 0;
-
-      if (opts->deps_target)
-	deps_output (pfile, opts->deps_target, ':');
-      else if (*opts->in_fname == 0)
-	deps_output (pfile, "-", ':');
-      else
-	{
-	  char *p, *q, *r;
-	  int len, x;
-	  static char *known_suffixes[] = { ".c", ".C", ".s", ".S", ".m",
-				     ".cc", ".cxx", ".cpp", ".cp",
-				     ".c++", 0
-				   };
-
-	  /* Discard all directory prefixes from filename.  */
-	  if ((q = strrchr (opts->in_fname, '/')) != NULL
+        pfile->deps_allocated_size = 200;
+        pfile->deps_buffer = (char *) xmalloc(pfile->deps_allocated_size);
+        pfile->deps_buffer[0] = 0;
+        pfile->deps_size = 0;
+        pfile->deps_column = 0;
+
+        if (opts->deps_target)
+            deps_output(pfile, opts->deps_target, ':');
+        else if (*opts->in_fname == 0)
+            deps_output(pfile, "-", ':');
+        else
+        {
+            char *p, *q, *r;
+            int len, x;
+            static char *known_suffixes[] = { ".c", ".C", ".s", ".S", ".m",
+                                              ".cc", ".cxx", ".cpp", ".cp",
+                                              ".c++", 0};
+
+            /* Discard all directory prefixes from filename.  */
+            if ((q = strrchr(opts->in_fname, '/')) != NULL
 #ifdef DIR_SEPARATOR
-	      && (q = strrchr (opts->in_fname, DIR_SEPARATOR)) != NULL
+                && (q = strrchr(opts->in_fname, DIR_SEPARATOR)) != NULL
 #endif
-	      )
-	    ++q;
-	  else
-	    q = opts->in_fname;
-
-	  /* Copy remainder to mungable area.  */
-	  p = (char *) alloca (strlen(q) + 8);
-	  strcpy (p, q);
-
-	  /* Output P, but remove known suffixes.  */
-	  len = strlen (p);
-	  q = p + len;
-	  /* Point to the filename suffix.  */
-	  r = strrchr (p, '.');
-	  /* Compare against the known suffixes.  */
-	  x = 0;
-	  while (known_suffixes[x] != 0)
-	    {
-	      if (strncmp (known_suffixes[x], r, q - r) == 0)
-		{
-		  /* Make q point to the bit we're going to overwrite
-		     with an object suffix.  */
-		  q = r;
-		  break;
-		}
-	      x++;
-	    }
-
-	  /* Supply our own suffix.  */
-	  strcpy (q, ".o");
-
-	  deps_output (pfile, p, ':');
-	  deps_output (pfile, opts->in_fname, ' ');
-	}
+                )
+                ++q;
+            else
+                q = opts->in_fname;
+
+            /* Copy remainder to mungable area.  */
+            p = (char *) alloca(strlen(q) + 8);
+            strcpy(p, q);
+
+            /* Output P, but remove known suffixes.  */
+            len = strlen(p);
+            q = p + len;
+            /* Point to the filename suffix.  */
+            r = strrchr(p, '.');
+            /* Compare against the known suffixes.  */
+            x = 0;
+            while (known_suffixes[x] != 0)
+            {
+                if (strncmp(known_suffixes[x], r, q - r) == 0)
+                {
+                    /* Make q point to the bit we're going to overwrite
+                       with an object suffix.  */
+                    q = r;
+                    break;
+                }
+                x++;
+            }
+
+            /* Supply our own suffix.  */
+            strcpy(q, ".o");
+
+            deps_output(pfile, p, ':');
+            deps_output(pfile, opts->in_fname, ' ');
+        }
     }
 
 #if 0
-  /* Make sure data ends with a newline.  And put a null after it.  */
+    /* Make sure data ends with a newline.  And put a null after it.  */
 
-  if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
-      /* Backslash-newline at end is not good enough.  */
-      || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
-    fp->buf[fp->length++] = '\n';
-    missing_newline = 1;
-  }
-  fp->buf[fp->length] = '\0';
+    if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
+        /* Backslash-newline at end is not good enough.  */
+        || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
+        fp->buf[fp->length++] = '\n';
+        missing_newline = 1;
+    }
+    fp->buf[fp->length] = '\0';
 
-  /* Unless inhibited, convert trigraphs in the input.  */
+    /* Unless inhibited, convert trigraphs in the input.  */
 
-  if (!no_trigraphs)
-    trigraph_pcp (fp);
+    if (!no_trigraphs)
+        trigraph_pcp(fp);
 #endif
 
-  /* Must call finclude() on the main input before processing
-     -include switches; otherwise the -included text winds up
-     after the main input. */
-  ih_fake = (struct include_hash *) xmalloc (sizeof (struct include_hash));
-  ih_fake->next = 0;
-  ih_fake->next_this_file = 0;
-  ih_fake->foundhere = ABSOLUTE_PATH;  /* well sort of ... */
-  ih_fake->name = fname;
-  ih_fake->control_macro = 0;
-  ih_fake->buf = (char *)-1;
-  ih_fake->limit = 0;
-  if (!finclude (pfile, f, ih_fake))
-    return 0;
-  output_line_command (pfile, 0, same_file);
-  pfile->only_seen_white = 2;
-
-  /* The -imacros files can be scanned now, but the -include files
-     have to be pushed onto the include stack and processed later,
-     in the main loop calling cpp_get_token.  That means the -include
-     files have to be processed in reverse order of the pending list,
-     which means the pending list has to be reversed again, which
-     means the -imacros files have to be done separately and first. */
-  
-  pfile->no_record_file++;
-  opts->no_output++;
-  for (pend = opts->pending; pend; pend = pend->next)
+    /* Must call finclude() on the main input before processing
+       -include switches; otherwise the -included text winds up
+       after the main input. */
+    ih_fake = (struct include_hash *) xmalloc(sizeof (struct include_hash));
+    ih_fake->next = 0;
+    ih_fake->next_this_file = 0;
+    ih_fake->foundhere = ABSOLUTE_PATH; /* well sort of ... */
+    ih_fake->name = fname;
+    ih_fake->control_macro = 0;
+    ih_fake->buf = (char *)-1;
+    ih_fake->limit = 0;
+    if (!finclude(pfile, f, ih_fake))
+        return 0;
+    output_line_command(pfile, 0, same_file);
+    pfile->only_seen_white = 2;
+
+    /* The -imacros files can be scanned now, but the -include files
+       have to be pushed onto the include stack and processed later,
+       in the main loop calling cpp_get_token.  That means the -include
+       files have to be processed in reverse order of the pending list,
+       which means the pending list has to be reversed again, which
+       means the -imacros files have to be done separately and first. */
+
+    pfile->no_record_file++;
+    opts->no_output++;
+    for (pend = opts->pending; pend; pend = pend->next)
     {
-      if (pend->cmd != NULL)
+        if (pend->cmd != NULL)
         {
-	  if (strcmp (pend->cmd, "-imacros") == 0)
-	    {
-	      int fd = open (pend->arg, O_RDONLY, 0666);
-	      if (fd < 0)
-	        {
-	          cpp_perror_with_name (pfile, pend->arg);
-	          return 0;
-	        }
-	      if (!cpp_push_buffer (pfile, NULL, 0))
-	        return 0;
-
-	      ih_fake = (struct include_hash *)
-		  xmalloc (sizeof (struct include_hash));
-	      ih_fake->next = 0;
-	      ih_fake->next_this_file = 0;
-	      ih_fake->foundhere = ABSOLUTE_PATH;  /* well sort of ... */
-	      ih_fake->name = pend->arg;
-	      ih_fake->control_macro = 0;
-	      ih_fake->buf = (char *)-1;
-	      ih_fake->limit = 0;
-	      if (!finclude (pfile, fd, ih_fake))
-		cpp_scan_buffer (pfile);
-	      free (ih_fake);
-	    }
-	}
+            if (strcmp(pend->cmd, "-imacros") == 0)
+            {
+                int fd = open(pend->arg, O_RDONLY, 0666);
+                if (fd < 0)
+                {
+                    cpp_perror_with_name(pfile, pend->arg);
+                    return 0;
+                }
+                if (!cpp_push_buffer(pfile, NULL, 0))
+                    return 0;
+
+                ih_fake = (struct include_hash *)
+                          xmalloc(sizeof (struct include_hash));
+                ih_fake->next = 0;
+                ih_fake->next_this_file = 0;
+                ih_fake->foundhere = ABSOLUTE_PATH; /* well sort of ... */
+                ih_fake->name = pend->arg;
+                ih_fake->control_macro = 0;
+                ih_fake->buf = (char *)-1;
+                ih_fake->limit = 0;
+                if (!finclude(pfile, fd, ih_fake))
+                    cpp_scan_buffer(pfile);
+                free(ih_fake);
+            }
+        }
     }
-  opts->no_output--;
-  opts->pending = nreverse_pending (opts->pending);
-  for (pend = opts->pending; pend; pend = pend->next)
+    opts->no_output--;
+    opts->pending = nreverse_pending(opts->pending);
+    for (pend = opts->pending; pend; pend = pend->next)
     {
-      if (pend->cmd != NULL)
+        if (pend->cmd != NULL)
         {
-	  if (strcmp (pend->cmd, "-include") == 0)
-	    {
-	      int fd = open (pend->arg, O_RDONLY, 0666);
-	      if (fd < 0)
-	        {
-	          cpp_perror_with_name (pfile, pend->arg);
-	          return 0;
-	        }
-	      if (!cpp_push_buffer (pfile, NULL, 0))
-	        return 0;
-
-	      ih_fake = (struct include_hash *)
-		  xmalloc (sizeof (struct include_hash));
-	      ih_fake->next = 0;
-	      ih_fake->next_this_file = 0;
-	      ih_fake->foundhere = ABSOLUTE_PATH;  /* well sort of ... */
-	      ih_fake->name = pend->arg;
-	      ih_fake->control_macro = 0;
-	      ih_fake->buf = (char *)-1;
-	      ih_fake->limit = 0;
-	      if (finclude (pfile, fd, ih_fake))
-	        output_line_command (pfile, 0, enter_file);
-	    }
-	}
+            if (strcmp(pend->cmd, "-include") == 0)
+            {
+                int fd = open(pend->arg, O_RDONLY, 0666);
+                if (fd < 0)
+                {
+                    cpp_perror_with_name(pfile, pend->arg);
+                    return 0;
+                }
+                if (!cpp_push_buffer(pfile, NULL, 0))
+                    return 0;
+
+                ih_fake = (struct include_hash *)
+                          xmalloc(sizeof (struct include_hash));
+                ih_fake->next = 0;
+                ih_fake->next_this_file = 0;
+                ih_fake->foundhere = ABSOLUTE_PATH; /* well sort of ... */
+                ih_fake->name = pend->arg;
+                ih_fake->control_macro = 0;
+                ih_fake->buf = (char *)-1;
+                ih_fake->limit = 0;
+                if (finclude(pfile, fd, ih_fake))
+                    output_line_command(pfile, 0, enter_file);
+            }
+        }
     }
-  pfile->no_record_file--;
+    pfile->no_record_file--;
 
-  /* Free the pending list.  */
-  for (pend = opts->pending;  pend; )
+    /* Free the pending list.  */
+    for (pend = opts->pending; pend; )
     {
-      struct cpp_pending *next = pend->next;
-      free (pend);
-      pend = next;
+        struct cpp_pending *next = pend->next;
+        free(pend);
+        pend = next;
     }
-  opts->pending = NULL;
+    opts->pending = NULL;
 
 
-  return 1;
+    return 1;
 }
 
 void
-cpp_reader_init (pfile)
-     cpp_reader *pfile;
+cpp_reader_init(cpp_reader *pfile)
 {
-  zero_memory ((char *) pfile, sizeof (cpp_reader));
-  pfile->get_token = cpp_get_token;
+    zero_memory((char *) pfile, sizeof (cpp_reader));
+    pfile->get_token = cpp_get_token;
 
-  pfile->token_buffer_size = 200;
-  pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
-  CPP_SET_WRITTEN (pfile, 0);
+    pfile->token_buffer_size = 200;
+    pfile->token_buffer = (U_CHAR *) xmalloc(pfile->token_buffer_size);
+    CPP_SET_WRITTEN(pfile, 0);
 
-  pfile->timebuf = NULL;
-  pfile->only_seen_white = 1;
-  pfile->buffer = CPP_NULL_BUFFER(pfile);
-  pfile->actual_dirs = NULL;
+    pfile->timebuf = NULL;
+    pfile->only_seen_white = 1;
+    pfile->buffer = CPP_NULL_BUFFER(pfile);
+    pfile->actual_dirs = NULL;
 }
 
 static struct cpp_pending *
-nreverse_pending (list)
-     struct cpp_pending *list;
-     
+nreverse_pending(struct cpp_pending *list)
 {
-  register struct cpp_pending *prev = 0, *next, *pend;
-  for (pend = list;  pend;  pend = next)
+    register struct cpp_pending *prev = 0, *next, *pend;
+    for (pend = list; pend; pend = next)
     {
-      next = pend->next;
-      pend->next = prev;
-      prev = pend;
+        next = pend->next;
+        pend->next = prev;
+        prev = pend;
     }
-  return prev;
+    return prev;
 }
 
 static void
-push_pending (pfile, cmd, arg)
-     cpp_reader *pfile;
-     char *cmd;
-     char *arg;
+push_pending(cpp_reader *pfile, char *cmd, char *arg)
 {
-  struct cpp_pending *pend
-    = (struct cpp_pending *) xmalloc (sizeof (struct cpp_pending));
-  pend->cmd = cmd;
-  pend->arg = arg;
-  pend->next = CPP_OPTIONS (pfile)->pending;
-  CPP_OPTIONS (pfile)->pending = pend;
+    struct cpp_pending *pend
+        = (struct cpp_pending *) xmalloc(sizeof (struct cpp_pending));
+    pend->cmd = cmd;
+    pend->arg = arg;
+    pend->next = CPP_OPTIONS(pfile)->pending;
+    CPP_OPTIONS(pfile)->pending = pend;
 }
 
-
+
 static void
-print_help ()
+print_help()
 {
-  printf ("Usage: %s [switches] input output\n", progname);
-  printf ("Switches:\n");
-  printf ("  -include <file>           Include the contents of <file> before other files\n");
-  printf ("  -imacros <file>           Accept definition of marcos in <file>\n");
-  printf ("  -iprefix <path>           Specify <path> as a prefix for next two options\n");
-  printf ("  -iwithprefix <dir>        Add <dir> to the end of the system include paths\n");
-  printf ("  -iwithprefixbefore <dir>  Add <dir> to the end of the main include paths\n");
-  printf ("  -isystem <dir>            Add <dir> to the start of the system include paths\n");
-  printf ("  -idirafter <dir>          Add <dir> to the end of the system include paths\n");
-  printf ("  -I <dir>                  Add <dir> to the end of the main include paths\n");
-  printf ("  -nostdinc                 Do not search the system include directories\n");
-  printf ("  -nostdinc++               Do not search the system include directories for C++\n");
-  printf ("  -o <file>                 Put output into <file>\n");
-  printf ("  -pedantic                 Issue all warnings demanded by strict ANSI C\n");
-  printf ("  -traditional              Follow K&R pre-processor behaviour\n");
-  printf ("  -trigraphs                Support ANSI C trigraphs\n");
-  printf ("  -lang-c                   Assume that the input sources are in C\n");
-  printf ("  -lang-c89                 Assume that the input sources are in C89\n");
-  printf ("  -lang-c++                 Assume that the input sources are in C++\n");
-  printf ("  -lang-objc                Assume that the input sources are in ObjectiveC\n");
-  printf ("  -lang-objc++              Assume that the input sources are in ObjectiveC++\n");
-  printf ("  -lang-asm                 Assume that the input sources are in assembler\n");
-  printf ("  -lang-chill               Assume that the input sources are in Chill\n");
-  printf ("  -+                        Allow parsing of C++ style features\n");
-  printf ("  -w                        Inhibit warning messages\n");
-  printf ("  -Wtrigraphs               Warn if trigraphs are encountered\n");
-  printf ("  -Wno-trigraphs            Do not warn about trigraphs\n");
-  printf ("  -Wcomment{s}              Warn if one comment starts inside another\n");
-  printf ("  -Wno-comment{s}           Do not warn about comments\n");
-  printf ("  -Wtraditional             Warn if a macro argument is/would be turned into\n");
-  printf ("                             a string if -tradtional is specified\n");
-  printf ("  -Wno-traditional          Do not warn about stringification\n");
-  printf ("  -Wundef                   Warn if an undefined macro is used by #if\n");
-  printf ("  -Wno-undef                Do not warn about testing udefined macros\n");
-  printf ("  -Wimport                  Warn about the use of the #import directive\n");
-  printf ("  -Wno-import               Do not warn about the use of #import\n");
-  printf ("  -Werror                   Treat all warnings as errors\n");
-  printf ("  -Wno-error                Do not treat warnings as errors\n");
-  printf ("  -Wall                     Enable all preprocessor warnings\n");
-  printf ("  -M                        Generate make dependencies\n");
-  printf ("  -MM                       As -M, but ignore system header files\n");
-  printf ("  -MD                       As -M, but put output in a .d file\n");
-  printf ("  -MMD                      As -MD, but ignore system header files\n");
-  printf ("  -MG                       Treat missing header file as generated files\n");
-  printf ("  -g                        Include #define and #undef directives in the output\n");
-  printf ("  -D<macro>                 Define a <macro> with string '1' as its value\n");
-  printf ("  -D<macro>=<val>           Define a <macro> with <val> as its value\n");
-  printf ("  -A<question> (<answer>)   Assert the <answer> to <question>\n");
-  printf ("  -U<macro>                 Undefine <macro> \n");
-  printf ("  -u or -undef              Do not predefine any macros\n");
-  printf ("  -v                        Display the version number\n");
-  printf ("  -H                        Print the name of header files as they are used\n");
-  printf ("  -C                        Do not discard comments\n");
-  printf ("  -dM                       Display a list of macro definitions active at end\n");
-  printf ("  -dD                       Preserve macro definitions in output\n");
-  printf ("  -dN                       As -dD except that only the names are preserved\n");
-  printf ("  -dI                       Include #include directives in the output\n");
-  printf ("  -ifoutput                 Describe skipped code blocks in output \n");
-  printf ("  -P                        Do not generate #line directives\n");
-  printf ("  -$                        Do not include '$' in identifiers\n");
-  printf ("  -remap                    Remap file names when including files.\n");
-  printf ("  -h or --help              Display this information\n");
+    printf("Usage: %s [switches] input output\n", progname);
+    printf("Switches:\n");
+    printf("  -include <file>           Include the contents of <file> before other files\n");
+    printf("  -imacros <file>           Accept definition of marcos in <file>\n");
+    printf("  -iprefix <path>           Specify <path> as a prefix for next two options\n");
+    printf("  -iwithprefix <dir>        Add <dir> to the end of the system include paths\n");
+    printf("  -iwithprefixbefore <dir>  Add <dir> to the end of the main include paths\n");
+    printf("  -isystem <dir>            Add <dir> to the start of the system include paths\n");
+    printf("  -idirafter <dir>          Add <dir> to the end of the system include paths\n");
+    printf("  -I <dir>                  Add <dir> to the end of the main include paths\n");
+    printf("  -nostdinc                 Do not search the system include directories\n");
+    printf("  -nostdinc++               Do not search the system include directories for C++\n");
+    printf("  -o <file>                 Put output into <file>\n");
+    printf("  -pedantic                 Issue all warnings demanded by strict ANSI C\n");
+    printf("  -traditional              Follow K&R pre-processor behaviour\n");
+    printf("  -trigraphs                Support ANSI C trigraphs\n");
+    printf("  -lang-c                   Assume that the input sources are in C\n");
+    printf("  -lang-c89                 Assume that the input sources are in C89\n");
+    printf("  -lang-c++                 Assume that the input sources are in C++\n");
+    printf("  -lang-objc                Assume that the input sources are in ObjectiveC\n");
+    printf("  -lang-objc++              Assume that the input sources are in ObjectiveC++\n");
+    printf("  -lang-asm                 Assume that the input sources are in assembler\n");
+    printf("  -lang-chill               Assume that the input sources are in Chill\n");
+    printf("  -+                        Allow parsing of C++ style features\n");
+    printf("  -w                        Inhibit warning messages\n");
+    printf("  -Wtrigraphs               Warn if trigraphs are encountered\n");
+    printf("  -Wno-trigraphs            Do not warn about trigraphs\n");
+    printf("  -Wcomment{s}              Warn if one comment starts inside another\n");
+    printf("  -Wno-comment{s}           Do not warn about comments\n");
+    printf("  -Wtraditional             Warn if a macro argument is/would be turned into\n");
+    printf("                             a string if -tradtional is specified\n");
+    printf("  -Wno-traditional          Do not warn about stringification\n");
+    printf("  -Wundef                   Warn if an undefined macro is used by #if\n");
+    printf("  -Wno-undef                Do not warn about testing udefined macros\n");
+    printf("  -Wimport                  Warn about the use of the #import directive\n");
+    printf("  -Wno-import               Do not warn about the use of #import\n");
+    printf("  -Werror                   Treat all warnings as errors\n");
+    printf("  -Wno-error                Do not treat warnings as errors\n");
+    printf("  -Wall                     Enable all preprocessor warnings\n");
+    printf("  -M                        Generate make dependencies\n");
+    printf("  -MM                       As -M, but ignore system header files\n");
+    printf("  -MD                       As -M, but put output in a .d file\n");
+    printf("  -MMD                      As -MD, but ignore system header files\n");
+    printf("  -MG                       Treat missing header file as generated files\n");
+    printf("  -g                        Include #define and #undef directives in the output\n");
+    printf("  -D<macro>                 Define a <macro> with string '1' as its value\n");
+    printf("  -D<macro>=<val>           Define a <macro> with <val> as its value\n");
+    printf("  -U<macro>                 Undefine <macro> \n");
+    printf("  -u or -undef              Do not predefine any macros\n");
+    printf("  -v                        Display the version number\n");
+    printf("  -H                        Print the name of header files as they are used\n");
+    printf("  -C                        Do not discard comments\n");
+    printf("  -dM                       Display a list of macro definitions active at end\n");
+    printf("  -dD                       Preserve macro definitions in output\n");
+    printf("  -dN                       As -dD except that only the names are preserved\n");
+    printf("  -dI                       Include #include directives in the output\n");
+    printf("  -ifoutput                 Describe skipped code blocks in output \n");
+    printf("  -P                        Do not generate #line directives\n");
+    printf("  -$                        Do not include '$' in identifiers\n");
+    printf("  -remap                    Remap file names when including files.\n");
+    printf("  -h or --help              Display this information\n");
 }
-
+
 
 /* Handle one command-line option in (argc, argv).
    Can be called multiple times, to handle multiple sets of options.
    Returns number of strings consumed.  */
 int
-cpp_handle_option (pfile, argc, argv)
-     cpp_reader *pfile;
-     int argc;
-     char **argv;
+cpp_handle_option(cpp_reader *pfile, int argc, char **argv)
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
-  int i = 0;
+    struct cpp_options *opts = CPP_OPTIONS(pfile);
+    int i = 0;
 
-  if (argv[i][0] != '-') {
-    if (opts->out_fname != NULL)
-      {
-	print_help ();
-	cpp_fatal (pfile, "Too many arguments");
-      }
-    else if (opts->in_fname != NULL)
-      opts->out_fname = argv[i];
-    else
-      opts->in_fname = argv[i];
-  } else {
-    switch (argv[i][1]) {
-      
-    missing_filename:
-      cpp_fatal (pfile, "Filename missing after `%s' option", argv[i]);
-      return argc;
-    missing_dirname:
-      cpp_fatal (pfile, "Directory name missing after `%s' option", argv[i]);
-      return argc;
-
-    case 'I':			/* Add directory to path for includes.  */
-      if (!strcmp (argv[i] + 2, "-"))
+    if (argv[i][0] != '-') {
+        if (opts->out_fname != NULL)
         {
-	  if (! opts->ignore_srcdir)
-	    {
-	      opts->ignore_srcdir = 1;
-	      /* Don't use any preceding -I directories for #include <...>. */
-	      opts->quote_include = opts->bracket_include;
-	      opts->bracket_include = 0;
-	    }
-	}
-      else
-	{
-	  char *fname;
-	  if (argv[i][2] != 0)
-	    fname = argv[i] + 2;
-	  else if (i + 1 == argc)
-	    goto missing_dirname;
-	  else
-	    fname = argv[++i];
-	  append_include_chain (pfile, &opts->bracket_include, fname, 0);
-	}
-      break;
-
-    case 'i':
-      /* Add directory to beginning of system include path, as a system
-	 include directory. */
-      if (!strcmp (argv[i], "-isystem"))
-        {
-	  if (i + 1 == argc)
-	    goto missing_filename;
-	  append_include_chain (pfile, &opts->system_include, argv[++i], 1);
-	}
-      /* Add directory to end of path for includes,
-	 with the default prefix at the front of its name.  */
-      else if (!strcmp (argv[i], "-iwithprefix"))
-        {
-	  char *fname;
-	  if (i + 1 == argc)
-	    goto missing_dirname;
-	  ++i;
-
-	  if (opts->include_prefix != 0)
-	    {
-	      fname = xmalloc (strlen (opts->include_prefix)
-			       + strlen (argv[i]) + 1);
-	      strcpy (fname, opts->include_prefix);
-	      strcat (fname, argv[i]);
-	    }
-	  else
-	    {
-	      fname = xmalloc (strlen (GCC_INCLUDE_DIR)
-			       + strlen (argv[i]) + 1);
-	      strcpy (fname, GCC_INCLUDE_DIR);
-	      /* Remove the `include' from /usr/local/lib/gcc.../include.  */
-	      if (!strcmp (fname + strlen (fname) - 8, "/include"))
-		fname[strlen (fname) - 7] = 0;
-	      strcat (fname, argv[i]);
-	    }
-	  
-	  append_include_chain (pfile, &opts->system_include, fname, 0);
-      }
-      /* Add directory to main path for includes,
-	 with the default prefix at the front of its name.  */
-      else if (!strcmp (argv[i], "-iwithprefix"))
-        {
-	  char *fname;
-	  if (i + 1 == argc)
-	    goto missing_dirname;
-	  ++i;
-
-	  if (opts->include_prefix != 0)
-	    {
-	      fname = xmalloc (strlen (opts->include_prefix)
-			       + strlen (argv[i]) + 1);
-	      strcpy (fname, opts->include_prefix);
-	      strcat (fname, argv[i]);
-	    }
-	  else
-	    {
-	      fname = xmalloc (strlen (GCC_INCLUDE_DIR)
-			       + strlen (argv[i]) + 1);
-	      strcpy (fname, GCC_INCLUDE_DIR);
-	      /* Remove the `include' from /usr/local/lib/gcc.../include.  */
-	      if (!strcmp (fname + strlen (fname) - 8, "/include"))
-		fname[strlen (fname) - 7] = 0;
-	      strcat (fname, argv[i]);
-	    }
-	  
-	  append_include_chain (pfile, &opts->bracket_include, fname, 0);
-        }
-      /* Add directory to end of path for includes.  */
-      else if (!strcmp (argv[i], "-idirafter"))
-        {
-	  if (i + 1 == argc)
-	    goto missing_dirname;
-	  append_include_chain (pfile, &opts->after_include, argv[++i], 0);
-	}
-      else if (!strcmp (argv[i], "-include") || !strcmp (argv[i], "-imacros"))
-        {
-	  if (i + 1 == argc)
-	    goto missing_filename;
-	  else
-	    push_pending (pfile, argv[i], argv[i+1]), i++;
+            print_help();
+            cpp_fatal(pfile, "Too many arguments");
         }
-      else if (!strcmp (argv[i], "-iprefix"))
-        {
-	  if (i + 1 == argc)
-	    goto missing_filename;
-	  else
-	      opts->include_prefix = argv[++i];
-	}
-      else if (!strcmp (argv[i], "-ifoutput"))
-	opts->output_conditionals = 1;
-
-      break;
-      
-    case 'o':
-      if (opts->out_fname != NULL)
-	{
-	  cpp_fatal (pfile, "Output filename specified twice");
-	  return argc;
-	}
-      if (i + 1 == argc)
-	goto missing_filename;
-      opts->out_fname = argv[++i];
-      if (!strcmp (opts->out_fname, "-"))
-	opts->out_fname = "";
-      break;
-      
-    case 'p':
-      if (!strcmp (argv[i], "-pedantic"))
-	CPP_PEDANTIC (pfile) = 1;
-      else if (!strcmp (argv[i], "-pedantic-errors")) {
-	CPP_PEDANTIC (pfile) = 1;
-	opts->pedantic_errors = 1;
-      }
+        else if (opts->in_fname != NULL)
+            opts->out_fname = argv[i];
+        else
+            opts->in_fname = argv[i];
+    } else {
+        switch (argv[i][1]) {
+
+missing_filename:
+            cpp_fatal(pfile, "Filename missing after `%s' option", argv[i]);
+            return argc;
+missing_dirname:
+            cpp_fatal(pfile, "Directory name missing after `%s' option", argv[i]);
+            return argc;
+
+        case 'I':               /* Add directory to path for includes.  */
+            if (!strcmp(argv[i] + 2, "-"))
+            {
+                if (!opts->ignore_srcdir)
+                {
+                    opts->ignore_srcdir = 1;
+                    /* Don't use any preceding -I directories for #include <...>. */
+                    opts->quote_include = opts->bracket_include;
+                    opts->bracket_include = 0;
+                }
+            }
+            else
+            {
+                char *fname;
+                if (argv[i][2] != 0)
+                    fname = argv[i] + 2;
+                else if (i + 1 == argc)
+                    goto missing_dirname;
+                else
+                    fname = argv[++i];
+                append_include_chain(pfile, &opts->bracket_include, fname, 0);
+            }
+            break;
+
+        case 'i':
+            /* Add directory to beginning of system include path, as a system
+               include directory. */
+            if (!strcmp(argv[i], "-isystem"))
+            {
+                if (i + 1 == argc)
+                    goto missing_filename;
+                append_include_chain(pfile, &opts->system_include, argv[++i], 1);
+            }
+            /* Add directory to end of path for includes,
+               with the default prefix at the front of its name.  */
+            else if (!strcmp(argv[i], "-iwithprefix"))
+            {
+                char *fname;
+                if (i + 1 == argc)
+                    goto missing_dirname;
+                ++i;
+
+                if (opts->include_prefix != 0)
+                {
+                    fname = xmalloc(strlen(opts->include_prefix)
+                                    + strlen(argv[i]) + 1);
+                    strcpy(fname, opts->include_prefix);
+                    strcat(fname, argv[i]);
+                }
+                else
+                {
+                    fname = xmalloc(strlen(GCC_INCLUDE_DIR)
+                                    + strlen(argv[i]) + 1);
+                    strcpy(fname, GCC_INCLUDE_DIR);
+                    /* Remove the `include' from /usr/local/lib/gcc.../include.  */
+                    if (!strcmp(fname + strlen(fname) - 8, "/include"))
+                        fname[strlen(fname) - 7] = 0;
+                    strcat(fname, argv[i]);
+                }
+
+                append_include_chain(pfile, &opts->system_include, fname, 0);
+            }
+            /* Add directory to main path for includes,
+               with the default prefix at the front of its name.  */
+            else if (!strcmp(argv[i], "-iwithprefix"))
+            {
+                char *fname;
+                if (i + 1 == argc)
+                    goto missing_dirname;
+                ++i;
+
+                if (opts->include_prefix != 0)
+                {
+                    fname = xmalloc(strlen(opts->include_prefix)
+                                    + strlen(argv[i]) + 1);
+                    strcpy(fname, opts->include_prefix);
+                    strcat(fname, argv[i]);
+                }
+                else
+                {
+                    fname = xmalloc(strlen(GCC_INCLUDE_DIR)
+                                    + strlen(argv[i]) + 1);
+                    strcpy(fname, GCC_INCLUDE_DIR);
+                    /* Remove the `include' from /usr/local/lib/gcc.../include.  */
+                    if (!strcmp(fname + strlen(fname) - 8, "/include"))
+                        fname[strlen(fname) - 7] = 0;
+                    strcat(fname, argv[i]);
+                }
+
+                append_include_chain(pfile, &opts->bracket_include, fname, 0);
+            }
+            /* Add directory to end of path for includes.  */
+            else if (!strcmp(argv[i], "-idirafter"))
+            {
+                if (i + 1 == argc)
+                    goto missing_dirname;
+                append_include_chain(pfile, &opts->after_include, argv[++i], 0);
+            }
+            else if (!strcmp(argv[i], "-include") || !strcmp(argv[i], "-imacros"))
+            {
+                if (i + 1 == argc)
+                    goto missing_filename;
+                else
+                    push_pending(pfile, argv[i], argv[i+1]), i++;
+            }
+            else if (!strcmp(argv[i], "-iprefix"))
+            {
+                if (i + 1 == argc)
+                    goto missing_filename;
+                else
+                    opts->include_prefix = argv[++i];
+            }
+            else if (!strcmp(argv[i], "-ifoutput"))
+                opts->output_conditionals = 1;
+
+            break;
+
+        case 'o':
+            if (opts->out_fname != NULL)
+            {
+                cpp_fatal(pfile, "Output filename specified twice");
+                return argc;
+            }
+            if (i + 1 == argc)
+                goto missing_filename;
+            opts->out_fname = argv[++i];
+            if (!strcmp(opts->out_fname, "-"))
+                opts->out_fname = "";
+            break;
+
+        case 'p':
+            if (!strcmp(argv[i], "-pedantic"))
+                CPP_PEDANTIC(pfile) = 1;
+            else if (!strcmp(argv[i], "-pedantic-errors")) {
+                CPP_PEDANTIC(pfile) = 1;
+                opts->pedantic_errors = 1;
+            }
 #if 0
-      else if (!strcmp (argv[i], "-pcp")) {
-	char *pcp_fname = argv[++i];
-	pcp_outfile = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
-		       ? fopen (pcp_fname, "w")
-		       : fdopen (dup (fileno (stdout)), "w"));
-	if (pcp_outfile == 0)
-	  cpp_pfatal_with_name (pfile, pcp_fname);
-	no_precomp = 1;
-      }
+            else if (!strcmp(argv[i], "-pcp")) {
+                char *pcp_fname = argv[++i];
+                pcp_outfile = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
+                               ? fopen(pcp_fname, "w")
+                               : fdopen(dup(fileno(stdout)), "w"));
+                if (pcp_outfile == 0)
+                    cpp_pfatal_with_name(pfile, pcp_fname);
+                no_precomp = 1;
+            }
 #endif
-      break;
-      
-    case 't':
-      if (!strcmp (argv[i], "-traditional")) {
-	opts->traditional = 1;
-	opts->cplusplus_comments = 0;
-      } else if (!strcmp (argv[i], "-trigraphs")) {
-	if (!opts->chill)
-	  opts->no_trigraphs = 0;
-      }
-      break;
-      
-    case 'l':
-      if (! strcmp (argv[i], "-lang-c"))
-	opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
-	  opts->objc = 0;
-      if (! strcmp (argv[i], "-lang-c89"))
-	opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->c89 = 1,
-	  opts->objc = 0;
-      if (! strcmp (argv[i], "-lang-c++"))
-	opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
-	  opts->objc = 0;
-      if (! strcmp (argv[i], "-lang-objc"))
-	opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
-	  opts->objc = 1;
-      if (! strcmp (argv[i], "-lang-objc++"))
-	opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
-	  opts->objc = 1;
-      if (! strcmp (argv[i], "-lang-asm"))
-	opts->lang_asm = 1;
-      if (! strcmp (argv[i], "-lint"))
-	opts->for_lint = 1;
-      if (! strcmp (argv[i], "-lang-chill"))
-	opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
-	  opts->traditional = 1, opts->no_trigraphs = 1,
-	  opts->traditional = 1, opts->cplusplus_comments = 0;
-      break;
-      
-    case '+':
-      opts->cplusplus = 1, opts->cplusplus_comments = 1;
-      break;
-      
-    case 'w':
-      opts->inhibit_warnings = 1;
-      break;
-      
-    case 'W':
-      if (!strcmp (argv[i], "-Wtrigraphs"))
-	opts->warn_trigraphs = 1;
-      else if (!strcmp (argv[i], "-Wno-trigraphs"))
-	opts->warn_trigraphs = 0;
-      else if (!strcmp (argv[i], "-Wcomment"))
-	opts->warn_comments = 1;
-      else if (!strcmp (argv[i], "-Wno-comment"))
-	opts->warn_comments = 0;
-      else if (!strcmp (argv[i], "-Wcomments"))
-	opts->warn_comments = 1;
-      else if (!strcmp (argv[i], "-Wno-comments"))
-	opts->warn_comments = 0;
-      else if (!strcmp (argv[i], "-Wtraditional"))
-	opts->warn_stringify = 1;
-      else if (!strcmp (argv[i], "-Wno-traditional"))
-	opts->warn_stringify = 0;
-      else if (!strcmp (argv[i], "-Wundef"))
-	opts->warn_undef = 1;
-      else if (!strcmp (argv[i], "-Wno-undef"))
-	opts->warn_undef = 0;
-      else if (!strcmp (argv[i], "-Wimport"))
-	opts->warn_import = 1;
-      else if (!strcmp (argv[i], "-Wno-import"))
-	opts->warn_import = 0;
-      else if (!strcmp (argv[i], "-Werror"))
-	opts->warnings_are_errors = 1;
-      else if (!strcmp (argv[i], "-Wno-error"))
-	opts->warnings_are_errors = 0;
-      else if (!strcmp (argv[i], "-Wall"))
-	{
-	  opts->warn_trigraphs = 1;
-	  opts->warn_comments = 1;
-	}
-      break;
-      
-    case 'M':
-      /* The style of the choices here is a bit mixed.
-	 The chosen scheme is a hybrid of keeping all options in one string
-	 and specifying each option in a separate argument:
-	 -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
-	 -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
-	 -M[M][G][D file].  This is awkward to handle in specs, and is not
-	 as extensible.  */
-      /* ??? -MG must be specified in addition to one of -M or -MM.
-	 This can be relaxed in the future without breaking anything.
-	 The converse isn't true.  */
-      
-      /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
-      if (!strcmp (argv[i], "-MG"))
-	{
-	  opts->print_deps_missing_files = 1;
-	  break;
-	}
-      if (!strcmp (argv[i], "-M"))
-	opts->print_deps = 2;
-      else if (!strcmp (argv[i], "-MM"))
-	opts->print_deps = 1;
-      else if (!strcmp (argv[i], "-MD"))
-	opts->print_deps = 2;
-      else if (!strcmp (argv[i], "-MMD"))
-	opts->print_deps = 1;
-      /* For -MD and -MMD options, write deps on file named by next arg.  */
-      if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
-	{
-	  if (i+1 == argc)
-	    goto missing_filename;
-	  opts->deps_file = argv[++i];
-	}
-      else
-	{
-	  /* For -M and -MM, write deps on standard output
-	     and suppress the usual output.  */
-	  opts->no_output = 1;
-	}	  
-      break;
-      
-    case 'd':
-      {
-	char *p = argv[i] + 2;
-	char c;
-	while ((c = *p++) != 0) {
-	  /* Arg to -d specifies what parts of macros to dump */
-	  switch (c) {
-	  case 'M':
-	    opts->dump_macros = dump_only;
-	    opts->no_output = 1;
-	    break;
-	  case 'N':
-	    opts->dump_macros = dump_names;
-	    break;
-	  case 'D':
-	    opts->dump_macros = dump_definitions;
-	    break;
-	  case 'I':
-	    opts->dump_includes = 1;
-	    break;
-	  }
-	}
-      }
-    break;
-    
-    case 'g':
-      if (argv[i][2] == '3')
-	opts->debug_output = 1;
-      break;
-      
-    case '-':
-      if (strcmp (argv[i], "--help") != 0)
-	return i;
-      print_help ();
-      break;
-	
-    case 'v':
-      fprintf (stderr, "GNU CPP version %s", version_string);
+            break;
+
+        case 't':
+            if (!strcmp(argv[i], "-traditional")) {
+                opts->traditional = 1;
+                opts->cplusplus_comments = 0;
+            } else if (!strcmp(argv[i], "-trigraphs")) {
+                if (!opts->chill)
+                    opts->no_trigraphs = 0;
+            }
+            break;
+
+        case 'l':
+            if (!strcmp(argv[i], "-lang-c"))
+                opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
+                opts->objc = 0;
+            if (!strcmp(argv[i], "-lang-c89"))
+                opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->c89 = 1,
+                opts->objc = 0;
+            if (!strcmp(argv[i], "-lang-c++"))
+                opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
+                opts->objc = 0;
+            if (!strcmp(argv[i], "-lang-objc"))
+                opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->c89 = 0,
+                opts->objc = 1;
+            if (!strcmp(argv[i], "-lang-objc++"))
+                opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->c89 = 0,
+                opts->objc = 1;
+            if (!strcmp(argv[i], "-lang-asm"))
+                opts->lang_asm = 1;
+            if (!strcmp(argv[i], "-lint"))
+                opts->for_lint = 1;
+            if (!strcmp(argv[i], "-lang-chill"))
+                opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
+                opts->traditional = 1, opts->no_trigraphs = 1,
+                opts->traditional = 1, opts->cplusplus_comments = 0;
+            break;
+
+        case '+':
+            opts->cplusplus = 1, opts->cplusplus_comments = 1;
+            break;
+
+        case 'w':
+            opts->inhibit_warnings = 1;
+            break;
+
+        case 'W':
+            if (!strcmp(argv[i], "-Wtrigraphs"))
+                opts->warn_trigraphs = 1;
+            else if (!strcmp(argv[i], "-Wno-trigraphs"))
+                opts->warn_trigraphs = 0;
+            else if (!strcmp(argv[i], "-Wcomment"))
+                opts->warn_comments = 1;
+            else if (!strcmp(argv[i], "-Wno-comment"))
+                opts->warn_comments = 0;
+            else if (!strcmp(argv[i], "-Wcomments"))
+                opts->warn_comments = 1;
+            else if (!strcmp(argv[i], "-Wno-comments"))
+                opts->warn_comments = 0;
+            else if (!strcmp(argv[i], "-Wtraditional"))
+                opts->warn_stringify = 1;
+            else if (!strcmp(argv[i], "-Wno-traditional"))
+                opts->warn_stringify = 0;
+            else if (!strcmp(argv[i], "-Wundef"))
+                opts->warn_undef = 1;
+            else if (!strcmp(argv[i], "-Wno-undef"))
+                opts->warn_undef = 0;
+            else if (!strcmp(argv[i], "-Wimport"))
+                opts->warn_import = 1;
+            else if (!strcmp(argv[i], "-Wno-import"))
+                opts->warn_import = 0;
+            else if (!strcmp(argv[i], "-Werror"))
+                opts->warnings_are_errors = 1;
+            else if (!strcmp(argv[i], "-Wno-error"))
+                opts->warnings_are_errors = 0;
+            else if (!strcmp(argv[i], "-Wall"))
+            {
+                opts->warn_trigraphs = 1;
+                opts->warn_comments = 1;
+            }
+            break;
+
+        case 'M':
+            /* The style of the choices here is a bit mixed.
+               The chosen scheme is a hybrid of keeping all options in one string
+               and specifying each option in a separate argument:
+               -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
+               -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
+               -M[M][G][D file].  This is awkward to handle in specs, and is not
+               as extensible.  */
+            /* ??? -MG must be specified in addition to one of -M or -MM.
+               This can be relaxed in the future without breaking anything.
+               The converse isn't true.  */
+
+            /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
+            if (!strcmp(argv[i], "-MG"))
+            {
+                opts->print_deps_missing_files = 1;
+                break;
+            }
+            if (!strcmp(argv[i], "-M"))
+                opts->print_deps = 2;
+            else if (!strcmp(argv[i], "-MM"))
+                opts->print_deps = 1;
+            else if (!strcmp(argv[i], "-MD"))
+                opts->print_deps = 2;
+            else if (!strcmp(argv[i], "-MMD"))
+                opts->print_deps = 1;
+            /* For -MD and -MMD options, write deps on file named by next arg.  */
+            if (!strcmp(argv[i], "-MD") || !strcmp(argv[i], "-MMD"))
+            {
+                if (i+1 == argc)
+                    goto missing_filename;
+                opts->deps_file = argv[++i];
+            }
+            else
+            {
+                /* For -M and -MM, write deps on standard output
+                   and suppress the usual output.  */
+                opts->no_output = 1;
+            }
+            break;
+
+        case 'd':
+        {
+            char *p = argv[i] + 2;
+            char c;
+            while ((c = *p++) != 0) {
+                /* Arg to -d specifies what parts of macros to dump */
+                switch (c) {
+                case 'M':
+                    opts->dump_macros = dump_only;
+                    opts->no_output = 1;
+                    break;
+                case 'N':
+                    opts->dump_macros = dump_names;
+                    break;
+                case 'D':
+                    opts->dump_macros = dump_definitions;
+                    break;
+                case 'I':
+                    opts->dump_includes = 1;
+                    break;
+                }
+            }
+        }
+        break;
+
+        case 'g':
+            if (argv[i][2] == '3')
+                opts->debug_output = 1;
+            break;
+
+        case '-':
+            if (strcmp(argv[i], "--help") != 0)
+                return i;
+            print_help();
+            break;
+
+        case 'v':
+            fprintf(stderr, "GNU CPP version %s", version_string);
 #ifdef TARGET_VERSION
-      TARGET_VERSION;
+            TARGET_VERSION;
 #endif
-      fprintf (stderr, "\n");
-      opts->verbose = 1;
-      break;
-      
-    case 'H':
-      opts->print_include_names = 1;
-      break;
-      
-    case 'D':
-      if (argv[i][2] != 0)
-	push_pending (pfile, "-D", argv[i] + 2);
-      else if (i + 1 == argc)
-	{
-	  cpp_fatal (pfile, "Macro name missing after -D option");
-	  return argc;
-	}
-      else
-	i++, push_pending (pfile, "-D", argv[i]);
-      break;
-      
-    case 'A':
-      {
-	char *p;
-	
-	if (argv[i][2] != 0)
-	  p = argv[i] + 2;
-	else if (i + 1 == argc)
-	  {
-	    cpp_fatal (pfile, "Assertion missing after -A option");
-	    return argc;
-	  }
-	else
-	  p = argv[++i];
-	
-	if (!strcmp (p, "-")) {
-	  struct cpp_pending **ptr;
-	  /* -A- eliminates all predefined macros and assertions.
-	     Let's include also any that were specified earlier
-	     on the command line.  That way we can get rid of any
-	     that were passed automatically in from GCC.  */
-	  opts->inhibit_predefs = 1;
-	  for (ptr = &opts->pending; *ptr != NULL; )
-	    {
-	      struct cpp_pending *pend = *ptr;
-	      if (pend->cmd && pend->cmd[0] == '-'
-		  && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
-		{
-		  *ptr = pend->next;
-		  free (pend);
-		}
-	      else
-		ptr = &pend->next;
-	    }
-	} else {
-	  push_pending (pfile, "-A", p);
-	}
-      }
-    break;
-    
-    case 'U':		/* JF #undef something */
-      if (argv[i][2] != 0)
-	push_pending (pfile, "-U", argv[i] + 2);
-      else if (i + 1 == argc)
-	{
-	  cpp_fatal (pfile, "Macro name missing after -U option");
-	  return argc;
-	}
-      else
-	push_pending (pfile, "-U", argv[i+1]), i++;
-      break;
-      
-    case 'C':
-      opts->put_out_comments = 1;
-      break;
-      
-    case 'E':			/* -E comes from cc -E; ignore it.  */
-      break;
-      
-    case 'P':
-      opts->no_line_commands = 1;
-      break;
-      
-    case '$':			/* Don't include $ in identifiers.  */
-      opts->dollars_in_ident = 0;
-      break;
-      
-    case 'n':
-      if (!strcmp (argv[i], "-nostdinc"))
-	/* -nostdinc causes no default include directories.
-	   You must specify all include-file directories with -I.  */
-	opts->no_standard_includes = 1;
-      else if (!strcmp (argv[i], "-nostdinc++"))
-	/* -nostdinc++ causes no default C++-specific include directories. */
-	opts->no_standard_cplusplus_includes = 1;
+            fprintf(stderr, "\n");
+            opts->verbose = 1;
+            break;
+
+        case 'H':
+            opts->print_include_names = 1;
+            break;
+
+        case 'D':
+            if (argv[i][2] != 0)
+                push_pending(pfile, "-D", argv[i] + 2);
+            else if (i + 1 == argc)
+            {
+                cpp_fatal(pfile, "Macro name missing after -D option");
+                return argc;
+            }
+            else
+                i++, push_pending(pfile, "-D", argv[i]);
+            break;
+
+        case 'U':       /* JF #undef something */
+            if (argv[i][2] != 0)
+                push_pending(pfile, "-U", argv[i] + 2);
+            else if (i + 1 == argc)
+            {
+                cpp_fatal(pfile, "Macro name missing after -U option");
+                return argc;
+            }
+            else
+                push_pending(pfile, "-U", argv[i+1]), i++;
+            break;
+
+        case 'C':
+            opts->put_out_comments = 1;
+            break;
+
+        case 'E':               /* -E comes from cc -E; ignore it.  */
+            break;
+
+        case 'P':
+            opts->no_line_commands = 1;
+            break;
+
+        case '$':               /* Don't include $ in identifiers.  */
+            opts->dollars_in_ident = 0;
+            break;
+
+        case 'n':
+            if (!strcmp(argv[i], "-nostdinc"))
+                /* -nostdinc causes no default include directories.
+                   You must specify all include-file directories with -I.  */
+                opts->no_standard_includes = 1;
+            else if (!strcmp(argv[i], "-nostdinc++"))
+                /* -nostdinc++ causes no default C++-specific include directories. */
+                opts->no_standard_cplusplus_includes = 1;
 #if 0
-      else if (!strcmp (argv[i], "-noprecomp"))
-	no_precomp = 1;
+            else if (!strcmp(argv[i], "-noprecomp"))
+                no_precomp = 1;
 #endif
-      break;
-      
-    case 'r':
-      if (!strcmp (argv[i], "-remap"))
-	opts->remap = 1;
-      break;
-      
-    case 'u':
-      /* Sun compiler passes undocumented switch "-undef".
-	 Let's assume it means to inhibit the predefined symbols.  */
-      opts->inhibit_predefs = 1;
-      break;
-      
-    case '\0': /* JF handle '-' as file name meaning stdin or stdout */
-      if (opts->in_fname == NULL) {
-	opts->in_fname = "";
-	break;
-      } else if (opts->out_fname == NULL) {
-	opts->out_fname = "";
-	break;
-      }	/* else fall through into error */
-
-    default:
-      return i;
+            break;
+
+        case 'r':
+            if (!strcmp(argv[i], "-remap"))
+                opts->remap = 1;
+            break;
+
+        case 'u':
+            /* Sun compiler passes undocumented switch "-undef".
+               Let's assume it means to inhibit the predefined symbols.  */
+            opts->inhibit_predefs = 1;
+            break;
+
+        case '\0': /* JF handle '-' as file name meaning stdin or stdout */
+            if (opts->in_fname == NULL) {
+                opts->in_fname = "";
+                break;
+            } else if (opts->out_fname == NULL) {
+                opts->out_fname = "";
+                break;
+            } /* else fall through into error */
+
+        default:
+            return i;
+        }
     }
-  }
 
-  return i + 1;
+    return i + 1;
 }
 
 /* Handle command-line options in (argc, argv).
@@ -5794,656 +5503,388 @@ cpp_handle_option (pfile, argc, argv)
    Returns number of strings consumed.  */
 
 int
-cpp_handle_options (pfile, argc, argv)
-     cpp_reader *pfile;
-     int argc;
-     char **argv;
+cpp_handle_options(cpp_reader *pfile, int argc, char **argv)
 {
-  int i;
-  int strings_processed;
-  for (i = 0; i < argc; i += strings_processed)
+    int i;
+    int strings_processed;
+    for (i = 0; i < argc; i += strings_processed)
     {
-      strings_processed = cpp_handle_option (pfile, argc - i, argv + i);
-      if (strings_processed == 0)
-	break;
+        strings_processed = cpp_handle_option(pfile, argc - i, argv + i);
+        if (strings_processed == 0)
+            break;
     }
-  return i;
+    return i;
 }
-
+
 void
-cpp_finish (pfile)
-     cpp_reader *pfile;
+cpp_finish(cpp_reader *pfile)
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
-  
-  if (opts->print_deps)
+    struct cpp_options *opts = CPP_OPTIONS(pfile);
+
+    if (opts->print_deps)
     {
-      /* Stream on which to print the dependency information.  */
-      FILE *deps_stream;
-
-      /* Don't actually write the deps file if compilation has failed.  */
-      if (pfile->errors == 0)
-	{
-	  char *deps_mode = opts->print_deps_append ? "a" : "w";
-	  if (opts->deps_file == 0)
-	    deps_stream = stdout;
-	  else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
-	    cpp_pfatal_with_name (pfile, opts->deps_file);
-	  fputs (pfile->deps_buffer, deps_stream);
-	  putc ('\n', deps_stream);
-	  if (opts->deps_file)
-	    {
-	      if (ferror (deps_stream) || fclose (deps_stream) != 0)
-		cpp_fatal (pfile, "I/O error on output");
-	    }
-	}
+        /* Stream on which to print the dependency information.  */
+        FILE *deps_stream;
+
+        /* Don't actually write the deps file if compilation has failed.  */
+        if (pfile->errors == 0)
+        {
+            char *deps_mode = opts->print_deps_append ? "a" : "w";
+            if (opts->deps_file == 0)
+                deps_stream = stdout;
+            else if ((deps_stream = fopen(opts->deps_file, deps_mode)) == 0)
+                cpp_pfatal_with_name(pfile, opts->deps_file);
+            fputs(pfile->deps_buffer, deps_stream);
+            putc('\n', deps_stream);
+            if (opts->deps_file)
+            {
+                if (ferror(deps_stream) || fclose(deps_stream) != 0)
+                    cpp_fatal(pfile, "I/O error on output");
+            }
+        }
     }
 
 #if 0
-  /* Debugging: dump statistics on the include hash table. */
-  {
-      struct include_hash *x;
-      int i, j;
+    /* Debugging: dump statistics on the include hash table. */
+    {
+        struct include_hash *x;
+        int i, j;
 
-      for(i = 0; i < ALL_INCLUDE_HASHSIZE; i++)
-      {
-	  x = pfile->all_include_files[i];
-	  j = 0;
-	  while(x)
-	  {
-	      j++;
-	      x = x->next;
-	  }
-	  fprintf(stderr, "%d/%d ", i, j);
-      }
-      fputc('\n', stderr);
-  }
+        for(i = 0; i < ALL_INCLUDE_HASHSIZE; i++)
+        {
+            x = pfile->all_include_files[i];
+            j = 0;
+            while(x)
+            {
+                j++;
+                x = x->next;
+            }
+            fprintf(stderr, "%d/%d ", i, j);
+        }
+        fputc('\n', stderr);
+    }
 #endif
-  
+
 }
 
 /* Free resources used by PFILE.
    This is the cpp_reader 'finalizer' or 'destructor' (in C++ terminology).  */
 
 void
-cpp_cleanup (pfile)
-     cpp_reader *pfile;
+cpp_cleanup(cpp_reader *pfile)
 {
-  int i;
-  while ( CPP_BUFFER (pfile) != CPP_NULL_BUFFER (pfile))
-    cpp_pop_buffer (pfile);
+    int i;
+    while ( CPP_BUFFER(pfile) != CPP_NULL_BUFFER(pfile))
+        cpp_pop_buffer(pfile);
 
-  if (pfile->token_buffer)
+    if (pfile->token_buffer)
     {
-      free (pfile->token_buffer);
-      pfile->token_buffer = NULL;
+        free(pfile->token_buffer);
+        pfile->token_buffer = NULL;
     }
 
-  if (pfile->deps_buffer)
+    if (pfile->deps_buffer)
     {
-      free (pfile->deps_buffer);
-      pfile->deps_buffer = NULL;
-      pfile->deps_allocated_size = 0;
+        free(pfile->deps_buffer);
+        pfile->deps_buffer = NULL;
+        pfile->deps_allocated_size = 0;
     }
 
-  while (pfile->if_stack)
+    while (pfile->if_stack)
     {
-      IF_STACK_FRAME *temp = pfile->if_stack;
-      pfile->if_stack = temp->next;
-      free (temp);
+        IF_STACK_FRAME *temp = pfile->if_stack;
+        pfile->if_stack = temp->next;
+        free(temp);
     }
 
-  for (i = ALL_INCLUDE_HASHSIZE; --i >= 0; )
+    for (i = ALL_INCLUDE_HASHSIZE; --i >= 0; )
     {
-      struct include_hash *imp = pfile->all_include_files[i];
-      while (imp)
-	{
-	  struct include_hash *next = imp->next;
+        struct include_hash *imp = pfile->all_include_files[i];
+        while (imp)
+        {
+            struct include_hash *next = imp->next;
 #if 0
-	  /* This gets freed elsewhere - I think. */
-	  free (imp->name);
+            /* This gets freed elsewhere - I think. */
+            free(imp->name);
 #endif
-	  free (imp);
-	  imp = next;
-	}
-      pfile->all_include_files[i] = 0;
-    }
-
-  cpp_hash_cleanup (pfile);
-}
-
-/* Read an assertion into the token buffer, converting to
-   canonical form: `#predicate(a n swe r)'  The next non-whitespace
-   character to read should be the first letter of the predicate.
-   Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
-   with answer (see callers for why). In case of 0, an error has been
-   printed. */
-static int
-parse_assertion (pfile)
-     cpp_reader *pfile;
-{
-  int c, dropwhite;
-  cpp_skip_hspace (pfile);
-  c = PEEKC();
-  if (! is_idstart[c])
-    {
-      cpp_error (pfile, "assertion predicate is not an identifier");
-      return 0;
-    }
-  CPP_PUTC(pfile, '#');
-  FORWARD(1);
-  parse_name(pfile, c);
-
-  c = PEEKC();
-  if (c != '(')
-    {
-      if (is_hor_space[c])
-	cpp_skip_hspace (pfile);
-      c = PEEKC();
-    }
-  if (c != '(')
-    return 1;
-
-  CPP_PUTC(pfile, '(');
-  FORWARD(1);
-  dropwhite = 1;
-  while ((c = GETC()) != ')')
-    {
-      if (is_hor_space[c])
-	{
-	  if (! dropwhite)
-	    {
-	      CPP_PUTC(pfile, ' ');
-	      dropwhite = 1;
-	    }
-	}
-      else if (c == '\\' && PEEKC() == '\n')
-	FORWARD(1);
-      else if (c == '\n' || c == EOF)
-	{
-	  if (c == '\n') FORWARD(-1);
-	  cpp_error (pfile, "un-terminated assertion answer");
-	  return 0;
-	}
-      else
-	{
-	  CPP_PUTC(pfile, c);
-	  dropwhite = 0;
-	}
-    }
-
-  if (pfile->limit[-1] == ' ')
-    pfile->limit[-1] = ')';
-  else if (pfile->limit[-1] == '(')
-    {
-      cpp_error (pfile, "empty token sequence in assertion");
-      return 0;
-    }
-  else
-    CPP_PUTC(pfile, ')');
-
-  CPP_NUL_TERMINATE(pfile);
-  return 2;
-}
-
-static int
-do_assert (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
-{
-  char *sym;
-  int ret, c;
-  HASHNODE *base, *this;
-  int baselen, thislen;
-
-  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
-      && !CPP_BUFFER (pfile)->system_header_p)
-    cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
-
-  cpp_skip_hspace (pfile);
-  sym = CPP_PWRITTEN (pfile);	/* remember where it starts */
-  ret = parse_assertion (pfile);
-  if (ret == 0)
-    goto error;
-  else if (ret == 1)
-    {
-      cpp_error (pfile, "missing token-sequence in `#assert'");
-      goto error;
-    }
-
-  cpp_skip_hspace (pfile);
-  c = PEEKC();
-  if (c != EOF && c != '\n')
-    {
-      cpp_error (pfile, "junk at end of `#assert'");
-      goto error;
-    }
-
-  thislen = strlen (sym);
-  baselen = strchr (sym, '(') - sym;
-  this = cpp_lookup (pfile, sym, thislen, -1);
-  if (this)
-    {
-      cpp_warning (pfile, "`%s' re-asserted", sym);
-      goto error;
-    }
-
-  base = cpp_lookup (pfile, sym, baselen, -1);
-  if (! base)
-    base = install (sym, baselen, T_ASSERT, 0, 0, -1);
-  else if (base->type != T_ASSERT)
-  {
-    /* Token clash - but with what?! */
-    cpp_fatal (pfile,
-	       "cpp internal error: base->type != T_ASSERT in do_assert");
-    goto error;
-  }
-
-  this = install (sym, thislen, T_ASSERT, 0,
-		  (char *)base->value.aschain, -1);
-  base->value.aschain = this;
-  
-  pfile->limit = sym; /* Pop */
-  return 0;
-
- error:
-  pfile->limit = sym; /* Pop */
-  skip_rest_of_line (pfile);
-  return 1;
-}
-
-static int
-do_unassert (pfile, keyword)
-     cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
-{
-  int c, ret;
-  char *sym;
-  long baselen, thislen;
-  HASHNODE *base, *this, *next;
-  
-  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
-      && !CPP_BUFFER (pfile)->system_header_p)
-    cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
-
-  cpp_skip_hspace (pfile);
-
-  sym = CPP_PWRITTEN (pfile);	/* remember where it starts */
-  ret = parse_assertion (pfile);
-  if (ret == 0)
-    goto error;
-  
-  cpp_skip_hspace (pfile);
-  c = PEEKC ();
-  if (c != EOF && c != '\n')
-      cpp_error (pfile, "junk at end of `#unassert'");
-
-  thislen = strlen (sym);
-  if (ret == 1)
-    {
-      base = cpp_lookup (pfile, sym, thislen, -1);
-      if (! base)
-	goto error;  /* It isn't an error to #undef what isn't #defined,
-			so it isn't an error to #unassert what isn't
-			#asserted either. */
-      
-      for (this = base->value.aschain; this; this = next)
-        {
-	  next = this->value.aschain;
-	  delete_macro (this);
-	}
-      delete_macro (base);
-    }
-  else
-    {
-      baselen = strchr (sym, '(') - sym;
-      base = cpp_lookup (pfile, sym, baselen, -1);
-      if (! base) goto error;
-      this = cpp_lookup (pfile, sym, thislen, -1);
-      if (! this) goto error;
-
-      next = base;
-      while (next->value.aschain != this)
-	next = next->value.aschain;
-
-      next->value.aschain = this->value.aschain;
-      delete_macro (this);
-
-      if (base->value.aschain == NULL)
-	delete_macro (base);  /* Last answer for this predicate deleted. */
-    }
-  
-  pfile->limit = sym; /* Pop */
-  return 0;
- error:
-  pfile->limit = sym; /* Pop */
-  skip_rest_of_line (pfile);
-  return 1;
-}
-
-int
-cpp_read_check_assertion (pfile)
-     cpp_reader *pfile;
-{
-  char *name = CPP_PWRITTEN (pfile);
-  int result;
-  HASHNODE *hp;
-  
-  FORWARD (1);  /* Skip '#' */
-  cpp_skip_hspace (pfile);
-  if (! parse_assertion (pfile))
-    result = 0;
-  else
-    {
-      hp = cpp_lookup (pfile, name, (char *)CPP_PWRITTEN (pfile) - name, -1);
-      result = (hp != 0);
+            free(imp);
+            imp = next;
+        }
+        pfile->all_include_files[i] = 0;
     }
 
-  pfile->limit = name;
-  return result;
+    cpp_hash_cleanup(pfile);
 }
 
 /* Initialize PMARK to remember the current position of PFILE.  */
 
 void
-parse_set_mark (pmark, pfile)
-     struct parse_marker *pmark;
-     cpp_reader *pfile;
+parse_set_mark(struct parse_marker *pmark, cpp_reader *pfile)
 {
-  cpp_buffer *pbuf = CPP_BUFFER (pfile);
-  pmark->next = pbuf->marks;
-  pbuf->marks = pmark;
-  pmark->buf = pbuf;
-  pmark->position = pbuf->cur - pbuf->buf;
+    cpp_buffer *pbuf = CPP_BUFFER(pfile);
+    pmark->next = pbuf->marks;
+    pbuf->marks = pmark;
+    pmark->buf = pbuf;
+    pmark->position = pbuf->cur - pbuf->buf;
 }
 
 /* Cleanup PMARK - we no longer need it.  */
 
 void
-parse_clear_mark (pmark)
-     struct parse_marker *pmark;
+parse_clear_mark(struct parse_marker *pmark)
 {
-  struct parse_marker **pp = &pmark->buf->marks;
-  for (; ; pp = &(*pp)->next) {
-    if (*pp == NULL) abort ();
-    if (*pp == pmark) break;
-  }
-  *pp = pmark->next;
+    struct parse_marker **pp = &pmark->buf->marks;
+    for (;; pp = &(*pp)->next) {
+        if (*pp == NULL) abort();
+        if (*pp == pmark) break;
+    }
+    *pp = pmark->next;
 }
 
 /* Backup the current position of PFILE to that saved in PMARK.  */
 
 void
-parse_goto_mark (pmark, pfile)
-     struct parse_marker *pmark;
-     cpp_reader *pfile;
+parse_goto_mark(struct parse_marker *pmark, cpp_reader *pfile)
 {
-  cpp_buffer *pbuf = CPP_BUFFER (pfile);
-  if (pbuf != pmark->buf)
-    cpp_fatal (pfile, "internal error %s", "parse_goto_mark");
-  pbuf->cur = pbuf->buf + pmark->position;
+    cpp_buffer *pbuf = CPP_BUFFER(pfile);
+    if (pbuf != pmark->buf)
+        cpp_fatal(pfile, "internal error %s", "parse_goto_mark");
+    pbuf->cur = pbuf->buf + pmark->position;
 }
 
 /* Reset PMARK to point to the current position of PFILE.  (Same
    as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster.  */
 
 void
-parse_move_mark (pmark, pfile)
-     struct parse_marker *pmark;
-     cpp_reader *pfile;
+parse_move_mark(struct parse_marker *pmark, cpp_reader *pfile)
 {
-  cpp_buffer *pbuf = CPP_BUFFER (pfile);
-  if (pbuf != pmark->buf)
-    cpp_fatal (pfile, "internal error %s", "parse_move_mark");
-  pmark->position = pbuf->cur - pbuf->buf;
+    cpp_buffer *pbuf = CPP_BUFFER(pfile);
+    if (pbuf != pmark->buf)
+        cpp_fatal(pfile, "internal error %s", "parse_move_mark");
+    pmark->position = pbuf->cur - pbuf->buf;
 }
 
-
+
 void
-cpp_print_file_and_line (pfile)
-     cpp_reader *pfile;
+cpp_print_file_and_line(cpp_reader *pfile)
 {
-  cpp_buffer *ip = cpp_file_buffer (pfile);
+    cpp_buffer *ip = cpp_file_buffer(pfile);
 
-  if (ip != NULL)
+    if (ip != NULL)
     {
-      long line, col;
-      cpp_buf_line_and_col (ip, &line, &col);
-      cpp_file_line_for_message (pfile, ip->nominal_fname,
-				 line, pfile->show_column ? col : -1);
+        long line, col;
+        cpp_buf_line_and_col(ip, &line, &col);
+        cpp_file_line_for_message(pfile, ip->nominal_fname,
+                                  line, pfile->show_column ? col : -1);
     }
 }
 
 static void
-v_cpp_error (pfile, msg, ap)
-  cpp_reader *pfile;
-  const char *msg;
-  va_list ap;
+v_cpp_error(cpp_reader *pfile, const char *msg, va_list ap)
 {
-  cpp_print_containing_files (pfile);
-  cpp_print_file_and_line (pfile);
-  v_cpp_message (pfile, 1, msg, ap);
+    cpp_print_containing_files(pfile);
+    cpp_print_file_and_line(pfile);
+    v_cpp_message(pfile, 1, msg, ap);
 }
 
 void
-cpp_error (cpp_reader * pfile, const char *msg, ...)
+cpp_error(cpp_reader * pfile, const char *msg, ...)
 {
-  va_list ap;
+    va_list ap;
 
-  va_start(ap, msg);
-  
+    va_start(ap, msg);
 
-  v_cpp_error (pfile, msg, ap);
-  va_end(ap);
+
+    v_cpp_error(pfile, msg, ap);
+    va_end(ap);
 }
 
 /* Print error message but don't count it.  */
 
 static void
-v_cpp_warning (pfile, msg, ap)
-  cpp_reader *pfile;
-  const char *msg;
-  va_list ap;
+v_cpp_warning(cpp_reader *pfile, const char *msg, va_list ap)
 {
-  if (CPP_OPTIONS (pfile)->inhibit_warnings)
-    return;
+    if (CPP_OPTIONS(pfile)->inhibit_warnings)
+        return;
 
-  if (CPP_OPTIONS (pfile)->warnings_are_errors)
-    pfile->errors++;
+    if (CPP_OPTIONS(pfile)->warnings_are_errors)
+        pfile->errors++;
 
-  cpp_print_containing_files (pfile);
-  cpp_print_file_and_line (pfile);
-  v_cpp_message (pfile, 0, msg, ap);
+    cpp_print_containing_files(pfile);
+    cpp_print_file_and_line(pfile);
+    v_cpp_message(pfile, 0, msg, ap);
 }
 
 void
-cpp_warning (cpp_reader * pfile, const char *msg, ...)
+cpp_warning(cpp_reader * pfile, const char *msg, ...)
 {
-  va_list ap;
-  
-  va_start (ap, msg);
-  
+    va_list ap;
+
+    va_start(ap, msg);
 
-  v_cpp_warning (pfile, msg, ap);
-  va_end(ap);
+
+    v_cpp_warning(pfile, msg, ap);
+    va_end(ap);
 }
 
 /* Print an error message and maybe count it.  */
 
 void
-cpp_pedwarn (cpp_reader * pfile, const char *msg, ...)
+cpp_pedwarn(cpp_reader * pfile, const char *msg, ...)
 {
-  va_list ap;
-  
-  va_start (ap, msg);
-  
-
-  if (CPP_OPTIONS (pfile)->pedantic_errors)
-    v_cpp_error (pfile, msg, ap);
-  else
-    v_cpp_warning (pfile, msg, ap);
-  va_end(ap);
+    va_list ap;
+
+    va_start(ap, msg);
+
+
+    if (CPP_OPTIONS(pfile)->pedantic_errors)
+        v_cpp_error(pfile, msg, ap);
+    else
+        v_cpp_warning(pfile, msg, ap);
+    va_end(ap);
 }
 
 static void
-v_cpp_error_with_line (pfile, line, column, msg, ap)
-  cpp_reader * pfile;
-  int line;
-  int column;
-  const char * msg;
-  va_list ap;
+v_cpp_error_with_line(cpp_reader *pfile, int line, int column, const char *msg, va_list ap)
 {
-  cpp_buffer *ip = cpp_file_buffer (pfile);
+    cpp_buffer *ip = cpp_file_buffer(pfile);
 
-  cpp_print_containing_files (pfile);
+    cpp_print_containing_files(pfile);
 
-  if (ip != NULL)
-    cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
+    if (ip != NULL)
+        cpp_file_line_for_message(pfile, ip->nominal_fname, line, column);
 
-  v_cpp_message (pfile, 1, msg, ap);
+    v_cpp_message(pfile, 1, msg, ap);
 }
 
 void
-cpp_error_with_line (cpp_reader * pfile, int line, int column, const char *msg, ...)
+cpp_error_with_line(cpp_reader * pfile, int line, int column, const char *msg, ...)
 {
-  va_list ap;
-  
-  va_start (ap, msg);
-  
+    va_list ap;
+
+    va_start(ap, msg);
 
-  v_cpp_error_with_line(pfile, line, column, msg, ap);
-  va_end(ap);
+
+    v_cpp_error_with_line(pfile, line, column, msg, ap);
+    va_end(ap);
 }
 
 static void
-v_cpp_warning_with_line (pfile, line, column, msg, ap)
-  cpp_reader * pfile;
-  int line;
-  int column;
-  const char *msg;
-  va_list ap;
+v_cpp_warning_with_line(cpp_reader *pfile, int line, int column, const char *msg, va_list ap)
 {
-  cpp_buffer *ip;
+    cpp_buffer *ip;
 
-  if (CPP_OPTIONS (pfile)->inhibit_warnings)
-    return;
+    if (CPP_OPTIONS(pfile)->inhibit_warnings)
+        return;
 
-  if (CPP_OPTIONS (pfile)->warnings_are_errors)
-    pfile->errors++;
+    if (CPP_OPTIONS(pfile)->warnings_are_errors)
+        pfile->errors++;
 
-  cpp_print_containing_files (pfile);
+    cpp_print_containing_files(pfile);
 
-  ip = cpp_file_buffer (pfile);
+    ip = cpp_file_buffer(pfile);
 
-  if (ip != NULL)
-    cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
+    if (ip != NULL)
+        cpp_file_line_for_message(pfile, ip->nominal_fname, line, column);
 
-  v_cpp_message (pfile, 0, msg, ap);
-}  
+    v_cpp_message(pfile, 0, msg, ap);
+}
 
 #if 0
 static void
-cpp_warning_with_line (cpp_reader * pfile, int line, int column, const char *msg, ...)
+cpp_warning_with_line(cpp_reader * pfile, int line, int column, const char *msg, ...)
 {
-  va_list ap;
-  
-  va_start (ap, msg);
-  
+    va_list ap;
 
-  v_cpp_warning_with_line (pfile, line, column, msg, ap);
-  va_end(ap);
+    va_start(ap, msg);
+
+
+    v_cpp_warning_with_line(pfile, line, column, msg, ap);
+    va_end(ap);
 }
 #endif
 
 void
-cpp_pedwarn_with_line (cpp_reader * pfile, int line, int column, const char *msg, ...)
+cpp_pedwarn_with_line(cpp_reader * pfile, int line, int column, const char *msg, ...)
 {
-  va_list ap;
-  
-  va_start (ap, msg);
-  
-
-  if (CPP_OPTIONS (pfile)->pedantic_errors)
-    v_cpp_error_with_line (pfile, column, line, msg, ap);
-  else
-    v_cpp_warning_with_line (pfile, line, column, msg, ap);
-  va_end(ap);
+    va_list ap;
+
+    va_start(ap, msg);
+
+
+    if (CPP_OPTIONS(pfile)->pedantic_errors)
+        v_cpp_error_with_line(pfile, column, line, msg, ap);
+    else
+        v_cpp_warning_with_line(pfile, line, column, msg, ap);
+    va_end(ap);
 }
 
 /* Report a warning (or an error if pedantic_errors)
    giving specified file name and line number, not current.  */
 
 void
-cpp_pedwarn_with_file_and_line (cpp_reader *pfile, char *file, int line, const char *msg, ...)
+cpp_pedwarn_with_file_and_line(cpp_reader *pfile, char *file, int line, const char *msg, ...)
 {
-  va_list ap;
-  
-  va_start (ap, msg);
+    va_list ap;
 
+    va_start(ap, msg);
 
-  if (!CPP_OPTIONS (pfile)->pedantic_errors
-      && CPP_OPTIONS (pfile)->inhibit_warnings)
-    return;
-  if (file != NULL)
-    cpp_file_line_for_message (pfile, file, line, -1);
-  v_cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors, msg, ap);
-  va_end(ap);
+
+    if (!CPP_OPTIONS(pfile)->pedantic_errors
+        && CPP_OPTIONS(pfile)->inhibit_warnings)
+        return;
+    if (file != NULL)
+        cpp_file_line_for_message(pfile, file, line, -1);
+    v_cpp_message(pfile, CPP_OPTIONS(pfile)->pedantic_errors, msg, ap);
+    va_end(ap);
 }
 
 /* my_strerror - return the descriptive text associated with an
    `errno' code.  */
 
 static char *
-my_strerror (errnum)
-     int errnum;
+my_strerror(int errnum)
 {
-  char *result;
+    char *result;
 
 #ifndef HAVE_STRERROR
-  result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
+    result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
 #else
-  result = strerror (errnum);
+    result = strerror(errnum);
 #endif
 
-  if (!result)
-    result = "undocumented I/O error";
+    if (!result)
+        result = "undocumented I/O error";
 
-  return result;
+    return result;
 }
 
 /* Error including a message from `errno'.  */
 
 void
-cpp_error_from_errno (pfile, name)
-     cpp_reader *pfile;
-     const char *name;
+cpp_error_from_errno(cpp_reader *pfile, const char *name)
 {
-  cpp_message_from_errno (pfile, 1, name);
+    cpp_message_from_errno(pfile, 1, name);
 }
 
 void
-cpp_message_from_errno (pfile, is_error, name)
-     cpp_reader *pfile;
-     int is_error;
-     const char *name;
+cpp_message_from_errno(cpp_reader *pfile, int is_error, const char *name)
 {
-  int e = errno;
-  cpp_buffer *ip = cpp_file_buffer (pfile);
+    int e = errno;
+    cpp_buffer *ip = cpp_file_buffer(pfile);
 
-  cpp_print_containing_files (pfile);
+    cpp_print_containing_files(pfile);
 
-  if (ip != NULL)
-    cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
+    if (ip != NULL)
+        cpp_file_line_for_message(pfile, ip->nominal_fname, ip->lineno, -1);
 
-  cpp_message (pfile, is_error, "%s: %s", name, my_strerror (e));
+    cpp_message(pfile, is_error, "%s: %s", name, my_strerror(e));
 }
 
 void
-cpp_perror_with_name (pfile, name)
-     cpp_reader *pfile;
-     const char *name;
+cpp_perror_with_name(cpp_reader *pfile, const char *name)
 {
-  cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
+    cpp_message(pfile, 1, "%s: %s: %s", progname, name, my_strerror(errno));
 }
 
 /* TODO:
diff --git a/gcc/gcc.c b/gcc/gcc.c
index 73fd31a..f5c98a4 100755
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -1,36 +1,33 @@
 /* Compiler driver program that can handle many languages.
    Copyright (C) 1987, 89, 92-98, 1999 Free Software Foundation, Inc.
 
-This file is part of GNU CC.
+   This file is part of GNU CC.
 
-GNU CC 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.
+   GNU CC 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.
 
-GNU CC 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.
+   GNU CC 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 GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.
-
-This paragraph is here to try to keep Sun CC from dying.
-The number of chars here seems crucial!!!!  */
+   You should have received a copy of the GNU General Public License
+   along with GNU CC; see the file COPYING.  If not, write to
+   the Free Software Foundation, 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 /* This program is the user interface to the C compiler and possibly to
-other compilers.  It is used because compilation is a complicated procedure
-which involves running several programs and passing temporary files between
-them, forwarding the users switches to those programs selectively,
-and deleting the temporary files at the end.
-
-CC recognizes how to compile each input file by suffixes in the file names.
-Once it knows which kind of compilation to perform, the procedure for
-compilation is specified by a string called a "spec".  */
-
+   other compilers.  It is used because compilation is a complicated procedure
+   which involves running several programs and passing temporary files between
+   them, forwarding the users switches to those programs selectively,
+   and deleting the temporary files at the end.
+
+   CC recognizes how to compile each input file by suffixes in the file names.
+   Once it knows which kind of compilation to perform, the procedure for
+   compilation is specified by a string called a "spec".  */
+
 #include "config.h"
 #include "system.h"
 #include <signal.h>
@@ -40,18 +37,10 @@ compilation is specified by a string called a "spec".  */
 
 
 /* By default there is no special suffix for executables.  */
-#ifdef EXECUTABLE_SUFFIX
-#define HAVE_EXECUTABLE_SUFFIX
-#else
 #define EXECUTABLE_SUFFIX ""
-#endif
 
 /* By default, the suffix for object files is ".o".  */
-#ifdef OBJECT_SUFFIX
-#define HAVE_OBJECT_SUFFIX
-#else
 #define OBJECT_SUFFIX ".o"
-#endif
 
 /* By default, colon separates directories in a path.  */
 #ifndef PATH_SEPARATOR
@@ -73,10 +62,6 @@ static char dir_separator_str[] = {DIR_SEPARATOR, 0};
 #define obstack_chunk_alloc xmalloc
 #define obstack_chunk_free free
 
-#ifndef GET_ENV_PATH_LIST
-#define GET_ENV_PATH_LIST(VAR,NAME)	do { (VAR) = getenv (NAME); } while (0)
-#endif
-
 #ifndef HAVE_KILL
 #define kill(p,s) raise(s)
 #endif
@@ -165,199 +150,199 @@ extern char *version_string;
 /* Forward declaration for prototypes.  */
 struct path_prefix;
 
-static void init_spec		(void);
-static void read_specs		(char *, int);
-static void set_spec		(char *, char *);
+static void init_spec           (void);
+static void read_specs          (char *, int);
+static void set_spec            (char *, char *);
 static struct compiler *lookup_compiler (char *, size_t, char *);
-static char *build_search_list	(struct path_prefix *, char *, int);
+static char *build_search_list  (struct path_prefix *, char *, int);
 static void putenv_from_prefixes (struct path_prefix *, char *);
-static char *find_a_file	(struct path_prefix *, char *, int);
-static void add_prefix		(struct path_prefix *, const char *,
-				       const char *, int, int, int *);
-static char *skip_whitespace	(char *);
-static void record_temp_file	(char *, int, int);
-static void delete_if_ordinary	(char *);
-static void delete_temp_files	(void);
+static char *find_a_file        (struct path_prefix *, char *, int);
+static void add_prefix          (struct path_prefix *, const char *,
+                                 const char *, int, int, int *);
+static char *skip_whitespace    (char *);
+static void record_temp_file    (char *, int, int);
+static void delete_if_ordinary  (char *);
+static void delete_temp_files   (void);
 static void delete_failure_queue (void);
 static void clear_failure_queue (void);
-static int check_live_switch	(int, int);
-static char *handle_braces	(char *);
-static char *save_string	(const char *, int);
-extern int do_spec		(char *);
-static int do_spec_1		(char *, int, char *);
-static char *find_file		(char *);
-static int is_directory		(char *, char *, int);
-static void validate_switches	(char *);
+static int check_live_switch    (int, int);
+static char *handle_braces      (char *);
+static char *save_string        (const char *, int);
+extern int do_spec              (char *);
+static int do_spec_1            (char *, int, char *);
+static char *find_file          (char *);
+static int is_directory         (char *, char *, int);
+static void validate_switches   (char *);
 static void validate_all_switches (void);
-static void give_switch		(int, int, int);
-static int used_arg		(char *, int);
-static int default_arg		(char *, int);
-static void set_multilib_dir	(void);
-static void print_multilib_info	(void);
-static void pfatal_with_name	(char *) ATTRIBUTE_NORETURN;
-static void perror_with_name	(char *);
-static void pfatal_pexecute	(char *, char *) ATTRIBUTE_NORETURN;
-static void fatal		(char *, ...)
-  ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1;
-static void error		(char *, ...) ATTRIBUTE_PRINTF_1;
-static void display_help 	(void);
-
-void fancy_abort		(void) ATTRIBUTE_NORETURN;
-
-
+static void give_switch         (int, int, int);
+static int used_arg             (char *, int);
+static int default_arg          (char *, int);
+static void set_multilib_dir    (void);
+static void print_multilib_info (void);
+static void pfatal_with_name    (char *) ATTRIBUTE_NORETURN;
+static void perror_with_name    (char *);
+static void pfatal_pexecute     (char *, char *) ATTRIBUTE_NORETURN;
+static void fatal               (char *, ...)
+ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1;
+static void error               (char *, ...) ATTRIBUTE_PRINTF_1;
+static void display_help        (void);
+
+void fancy_abort                (void) ATTRIBUTE_NORETURN;
+
+
 /* Specs are strings containing lines, each of which (if not blank)
-is made up of a program name, and arguments separated by spaces.
-The program name must be exact and start from root, since no path
-is searched and it is unreliable to depend on the current working directory.
-Redirection of input or output is not supported; the subprograms must
-accept filenames saying what files to read and write.
-
-In addition, the specs can contain %-sequences to substitute variable text
-or for conditional text.  Here is a table of all defined %-sequences.
-Note that spaces are not generated automatically around the results of
-expanding these sequences; therefore, you can concatenate them together
-or with constant text in a single argument.
-
- %%	substitute one % into the program name or argument.
- %i     substitute the name of the input file being processed.
- %b     substitute the basename of the input file being processed.
-	This is the substring up to (and not including) the last period
-	and not including the directory.
- %gSUFFIX
-	substitute a file name that has suffix SUFFIX and is chosen
-	once per compilation, and mark the argument a la %d.  To reduce
-	exposure to denial-of-service attacks, the file name is now
-	chosen in a way that is hard to predict even when previously
-	chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
-	might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
-	the regexp "[.A-Za-z]*" or the special string "%O", which is
-	treated exactly as if %O had been pre-processed.  Previously, %g
-	was simply substituted with a file name chosen once per compilation,
-	without regard to any appended suffix (which was therefore treated
-	just like ordinary text), making such attacks more likely to succeed.
- %uSUFFIX
-	like %g, but generates a new temporary file name even if %uSUFFIX
-	was already seen.
- %USUFFIX
-	substitutes the last file name generated with %uSUFFIX, generating a
-	new one if there is no such last file name.  In the absence of any
-	%uSUFFIX, this is just like %gSUFFIX, except they don't share
-	the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
-	would involve the generation of two distinct file names, one
-	for each `%g.s' and another for each `%U.s'.  Previously, %U was
-	simply substituted with a file name chosen for the previous %u,
-	without regard to any appended suffix.
- %d	marks the argument containing or following the %d as a
-	temporary file name, so that that file will be deleted if CC exits
-	successfully.  Unlike %g, this contributes no text to the argument.
- %w	marks the argument containing or following the %w as the
-	"output file" of this compilation.  This puts the argument
-	into the sequence of arguments that %o will substitute later.
- %W{...}
-	like %{...} but mark last argument supplied within
-	as a file to be deleted on failure.
- %o	substitutes the names of all the output files, with spaces
-	automatically placed around them.  You should write spaces
-	around the %o as well or the results are undefined.
-	%o is for use in the specs for running the linker.
-	Input files whose names have no recognized suffix are not compiled
-	at all, but they are included among the output files, so they will
-	be linked.
- %O	substitutes the suffix for object files.  Note that this is
-	handled specially when it immediately follows %g, %u, or %U,
-	because of the need for those to form complete file names.  The
-	handling is such that %O is treated exactly as if it had already
-	been substituted, except that %g, %u, and %U do not currently
-	support additional SUFFIX characters following %O as they would
-	following, for example, `.o'.
- %p	substitutes the standard macro predefinitions for the
-	current target machine.  Use this when running cpp.
- %P	like %p, but puts `__' before and after the name of each macro.
-	(Except macros that already have __.)
-	This is for ANSI C.
- %I	Substitute a -iprefix option made from GCC_EXEC_PREFIX.
- %s     current argument is the name of a library or startup file of some sort.
+   is made up of a program name, and arguments separated by spaces.
+   The program name must be exact and start from root, since no path
+   is searched and it is unreliable to depend on the current working directory.
+   Redirection of input or output is not supported; the subprograms must
+   accept filenames saying what files to read and write.
+
+   In addition, the specs can contain %-sequences to substitute variable text
+   or for conditional text.  Here is a table of all defined %-sequences.
+   Note that spaces are not generated automatically around the results of
+   expanding these sequences; therefore, you can concatenate them together
+   or with constant text in a single argument.
+
+   %%	substitute one % into the program name or argument.
+   %i     substitute the name of the input file being processed.
+   %b     substitute the basename of the input file being processed.
+        This is the substring up to (and not including) the last period
+        and not including the directory.
+   %gSUFFIX
+        substitute a file name that has suffix SUFFIX and is chosen
+        once per compilation, and mark the argument a la %d.  To reduce
+        exposure to denial-of-service attacks, the file name is now
+        chosen in a way that is hard to predict even when previously
+        chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
+        might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
+        the regexp "[.A-Za-z]*" or the special string "%O", which is
+        treated exactly as if %O had been pre-processed.  Previously, %g
+        was simply substituted with a file name chosen once per compilation,
+        without regard to any appended suffix (which was therefore treated
+        just like ordinary text), making such attacks more likely to succeed.
+   %uSUFFIX
+        like %g, but generates a new temporary file name even if %uSUFFIX
+        was already seen.
+   %USUFFIX
+        substitutes the last file name generated with %uSUFFIX, generating a
+        new one if there is no such last file name.  In the absence of any
+        %uSUFFIX, this is just like %gSUFFIX, except they don't share
+        the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
+        would involve the generation of two distinct file names, one
+        for each `%g.s' and another for each `%U.s'.  Previously, %U was
+        simply substituted with a file name chosen for the previous %u,
+        without regard to any appended suffix.
+   %d	marks the argument containing or following the %d as a
+        temporary file name, so that that file will be deleted if CC exits
+        successfully.  Unlike %g, this contributes no text to the argument.
+   %w	marks the argument containing or following the %w as the
+        "output file" of this compilation.  This puts the argument
+        into the sequence of arguments that %o will substitute later.
+   %W{...}
+        like %{...} but mark last argument supplied within
+        as a file to be deleted on failure.
+   %o	substitutes the names of all the output files, with spaces
+        automatically placed around them.  You should write spaces
+        around the %o as well or the results are undefined.
+        %o is for use in the specs for running the linker.
+        Input files whose names have no recognized suffix are not compiled
+        at all, but they are included among the output files, so they will
+        be linked.
+   %O	substitutes the suffix for object files.  Note that this is
+        handled specially when it immediately follows %g, %u, or %U,
+        because of the need for those to form complete file names.  The
+        handling is such that %O is treated exactly as if it had already
+        been substituted, except that %g, %u, and %U do not currently
+        support additional SUFFIX characters following %O as they would
+        following, for example, `.o'.
+   %p	substitutes the standard macro predefinitions for the
+        current target machine.  Use this when running cpp.
+   %P	like %p, but puts `__' before and after the name of each macro.
+        (Except macros that already have __.)
+        This is for ANSI C.
+   %I	Substitute a -iprefix option made from GCC_EXEC_PREFIX.
+   %s     current argument is the name of a library or startup file of some sort.
         Search for that file in a standard list of directories
-	and substitute the full name found.
- %eSTR  Print STR as an error message.  STR is terminated by a newline.
+        and substitute the full name found.
+   %eSTR  Print STR as an error message.  STR is terminated by a newline.
         Use this when inconsistent options are detected.
- %x{OPTION}	Accumulate an option for %X.
- %X	Output the accumulated linker options specified by compilations.
- %Y	Output the accumulated assembler options specified by compilations.
- %Z	Output the accumulated preprocessor options specified by compilations.
- %v1	Substitute the major version number of GCC.
-	(For version 2.5.n, this is 2.)
- %v2	Substitute the minor version number of GCC.
-	(For version 2.5.n, this is 5.)
- %a     process ASM_SPEC as a spec.
+   %x{OPTION}	Accumulate an option for %X.
+   %X	Output the accumulated linker options specified by compilations.
+   %Y	Output the accumulated assembler options specified by compilations.
+   %Z	Output the accumulated preprocessor options specified by compilations.
+   %v1	Substitute the major version number of GCC.
+        (For version 2.5.n, this is 2.)
+   %v2	Substitute the minor version number of GCC.
+        (For version 2.5.n, this is 5.)
+   %a     process ASM_SPEC as a spec.
         This allows config.h to specify part of the spec for running as.
- %A	process ASM_FINAL_SPEC as a spec.  A capital A is actually
-	used here.  This can be used to run a post-processor after the
-	assembler has done its job.
- %D	Dump out a -L option for each directory in startfile_prefixes.
-	If multilib_dir is set, extra entries are generated with it affixed.
- %l     process LINK_SPEC as a spec.
- %L     process LIB_SPEC as a spec.
- %G     process LIBGCC_SPEC as a spec.
- %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
- %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
- %c	process SIGNED_CHAR_SPEC as a spec.
- %C     process CPP_SPEC as a spec.  A capital C is actually used here.
- %1	process CC1_SPEC as a spec.
- %|	output "-" if the input for the current command is coming from a pipe.
- %*	substitute the variable part of a matched option.  (See below.)
-	Note that each comma in the substituted string is replaced by
-	a single space.
- %{S}   substitutes the -S switch, if that switch was given to CC.
-	If that switch was not specified, this substitutes nothing.
-	Here S is a metasyntactic variable.
- %{S*}  substitutes all the switches specified to CC whose names start
-	with -S.  This is used for -o, -D, -I, etc; switches that take
-	arguments.  CC considers `-o foo' as being one switch whose
-	name starts with `o'.  %{o*} would substitute this text,
-	including the space; thus, two arguments would be generated.
- %{^S*} likewise, but don't put a blank between a switch and any args.
- %{S*:X} substitutes X if one or more switches whose names start with -S are
-	specified to CC.  Note that the tail part of the -S option
-	(i.e. the part matched by the `*') will be substituted for each
-	occurrence of %* within X.
- %{S:X} substitutes X, but only if the -S switch was given to CC.
- %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
- %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
- %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
- %{.S:X} substitutes X, but only if processing a file with suffix S.
- %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
- %{S|P:X} substitutes X if either -S or -P was given to CC.  This may be
-	  combined with ! and . as above binding stronger than the OR.
- %(Spec) processes a specification defined in a specs file as *Spec:
- %[Spec] as above, but put __ around -D arguments
-
-The conditional text X in a %{S:X} or %{!S:X} construct may contain
-other nested % constructs or spaces, or even newlines.  They are
-processed as usual, as described above.
-
-The -O, -f, -m, and -W switches are handled specifically in these
-constructs.  If another value of -O or the negated form of a -f, -m, or
--W switch is found later in the command line, the earlier switch
-value is ignored, except with {S*} where S is just one letter; this
-passes all matching options.
-
-The character | at the beginning of the predicate text is used to indicate
-that a command should be piped to the following command, but only if -pipe
-is specified.
-
-Note that it is built into CC which switches take arguments and which
-do not.  You might think it would be useful to generalize this to
-allow each compiler's spec to say which switches take arguments.  But
-this cannot be done in a consistent fashion.  CC cannot even decide
-which input files have been specified without knowing which switches
-take arguments, and it must know which input files to compile in order
-to tell which compilers to run.
-
-CC also knows implicitly that arguments starting in `-l' are to be
-treated as compiler output files, and passed to the linker in their
-proper position among the other output files.  */
-
+   %A	process ASM_FINAL_SPEC as a spec.  A capital A is actually
+        used here.  This can be used to run a post-processor after the
+        assembler has done its job.
+   %D	Dump out a -L option for each directory in startfile_prefixes.
+        If multilib_dir is set, extra entries are generated with it affixed.
+   %l     process LINK_SPEC as a spec.
+   %L     process LIB_SPEC as a spec.
+   %G     process LIBGCC_SPEC as a spec.
+   %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
+   %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
+   %c	process SIGNED_CHAR_SPEC as a spec.
+   %C     process CPP_SPEC as a spec.  A capital C is actually used here.
+   %1	process CC1_SPEC as a spec.
+   %|	output "-" if the input for the current command is coming from a pipe.
+   %*	substitute the variable part of a matched option.  (See below.)
+        Note that each comma in the substituted string is replaced by
+        a single space.
+   %{S}   substitutes the -S switch, if that switch was given to CC.
+        If that switch was not specified, this substitutes nothing.
+        Here S is a metasyntactic variable.
+   %{S*}  substitutes all the switches specified to CC whose names start
+        with -S.  This is used for -o, -D, -I, etc; switches that take
+        arguments.  CC considers `-o foo' as being one switch whose
+        name starts with `o'.  %{o*} would substitute this text,
+        including the space; thus, two arguments would be generated.
+   %{^S*} likewise, but don't put a blank between a switch and any args.
+   %{S*:X} substitutes X if one or more switches whose names start with -S are
+        specified to CC.  Note that the tail part of the -S option
+        (i.e. the part matched by the `*') will be substituted for each
+        occurrence of %* within X.
+   %{S:X} substitutes X, but only if the -S switch was given to CC.
+   %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
+   %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
+   %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
+   %{.S:X} substitutes X, but only if processing a file with suffix S.
+   %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
+   %{S|P:X} substitutes X if either -S or -P was given to CC.  This may be
+          combined with ! and . as above binding stronger than the OR.
+   %(Spec) processes a specification defined in a specs file as *Spec:
+   %[Spec] as above, but put __ around -D arguments
+
+   The conditional text X in a %{S:X} or %{!S:X} construct may contain
+   other nested % constructs or spaces, or even newlines.  They are
+   processed as usual, as described above.
+
+   The -O, -f, -m, and -W switches are handled specifically in these
+   constructs.  If another value of -O or the negated form of a -f, -m, or
+   -W switch is found later in the command line, the earlier switch
+   value is ignored, except with {S*} where S is just one letter; this
+   passes all matching options.
+
+   The character | at the beginning of the predicate text is used to indicate
+   that a command should be piped to the following command, but only if -pipe
+   is specified.
+
+   Note that it is built into CC which switches take arguments and which
+   do not.  You might think it would be useful to generalize this to
+   allow each compiler's spec to say which switches take arguments.  But
+   this cannot be done in a consistent fashion.  CC cannot even decide
+   which input files have been specified without knowing which switches
+   take arguments, and it must know which input files to compile in order
+   to tell which compilers to run.
+
+   CC also knows implicitly that arguments starting in `-l' are to be
+   treated as compiler output files, and passed to the linker in their
+   proper position among the other output files.  */
+
 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1.  */
 
 /* config.h can define ASM_SPEC to provide extra args to the assembler
@@ -400,7 +385,7 @@ proper position among the other output files.  */
 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 #ifndef STARTFILE_SPEC
 #define STARTFILE_SPEC  \
-  "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
+    "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
 #endif
 
 /* config.h can define SWITCHES_NEED_SPACES to control which options
@@ -429,6 +414,10 @@ proper position among the other output files.  */
 #define LINKER_NAME "ld"
 #endif
 
+#ifndef CPP_PREDEFINES
+#define CPP_PREDEFINES ""
+#endif
+
 static char *cpp_spec = CPP_SPEC;
 static char *cpp_predefines = CPP_PREDEFINES;
 static char *cc1_spec = CC1_SPEC;
@@ -461,8 +450,8 @@ static char *multilib_defaults;
 static char *multilib_defaults_raw[] = MULTILIB_DEFAULTS;
 
 struct user_specs {
-  struct user_specs *next;
-  char *filename;
+    struct user_specs *next;
+    char *filename;
 };
 
 static struct user_specs *user_specs_head, *user_specs_tail;
@@ -470,11 +459,11 @@ static struct user_specs *user_specs_head, *user_specs_tail;
 /* This defines which switch letters take arguments.  */
 
 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
-  ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
-   || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
-   || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
-   || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
-   || (CHAR) == 'B' || (CHAR) == 'b')
+    ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
+     || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
+     || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
+     || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
+     || (CHAR) == 'B' || (CHAR) == 'b')
 
 #ifndef SWITCH_TAKES_ARG
 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
@@ -482,39 +471,27 @@ static struct user_specs *user_specs_head, *user_specs_tail;
 
 /* This defines which multi-letter switches take arguments.  */
 
-#define DEFAULT_WORD_SWITCH_TAKES_ARG(STR)		\
- (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext")	\
-  || !strcmp (STR, "Tbss") || !strcmp (STR, "include")	\
-  || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
-  || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
-  || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
-  || !strcmp (STR, "isystem") || !strcmp (STR, "specs"))
+#define DEFAULT_WORD_SWITCH_TAKES_ARG(STR)              \
+    (!strcmp(STR, "Tdata") || !strcmp(STR, "Ttext")      \
+     || !strcmp(STR, "Tbss") || !strcmp(STR, "include")  \
+     || !strcmp(STR, "imacros") || !strcmp(STR, "aux-info") \
+     || !strcmp(STR, "idirafter") || !strcmp(STR, "iprefix") \
+     || !strcmp(STR, "iwithprefix") || !strcmp(STR, "iwithprefixbefore") \
+     || !strcmp(STR, "isystem") || !strcmp(STR, "specs"))
 
 #ifndef WORD_SWITCH_TAKES_ARG
-#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
-#endif
-
-
-#ifdef HAVE_EXECUTABLE_SUFFIX
-/* This defines which switches stop a full compilation.  */
-#define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
-  ((CHAR) == 'c' || (CHAR) == 'S')
-
-#ifndef SWITCH_CURTAILS_COMPILATION
-#define SWITCH_CURTAILS_COMPILATION(CHAR) \
-  DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
-#endif
+#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG(STR)
 #endif
 
 /* Record the mapping from file suffixes for compilation specs.  */
 
 struct compiler
 {
-  char *suffix;			/* Use this compiler for input files
-				   whose names end in this suffix.  */
+    char *suffix;               /* Use this compiler for input files
+                                   whose names end in this suffix.  */
 
-  char *spec[4];		/* To use this compiler, concatenate these
-				   specs and pass to do_spec.  */
+    char *spec[4];              /* To use this compiler, concatenate these
+                                   specs and pass to do_spec.  */
 };
 
 /* Pointer to a vector of `struct compiler' that gives the spec for
@@ -536,10 +513,10 @@ static int n_compilers;
 
 static struct compiler default_compilers[] =
 {
-  {".c", {"@c"}},
-  {"@c",
-   {
-     "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
+    {".c", {"@c"}},
+    {"@c",
+     {
+         "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
 	%{C} %{v} %{A*} %{I*} %{P} %I\
 	%{C:%{!E:%eGNU C does not support -C without using -E}}\
 	%{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
@@ -550,8 +527,8 @@ static struct compiler default_compilers[] =
         %{traditional} %{ftraditional:-traditional}\
         %{traditional-cpp:-traditional}\
 	%{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
-        %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}",
-     "%{!E:%{!M:%{!MM:cc1 %i %1 \
+        %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ,
+         "%{!E:%{!M:%{!MM:cc1 %i %1 \
                   -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*} %{A*} %{I*} %I\
                   %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
                   %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
@@ -571,9 +548,9 @@ static struct compiler default_compilers[] =
                   %{!S:as %a %Y\
 		     %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
                      %{!pipe:%g.s} %A\n }}}}"
-  }},
-  {"-",
-   {"%{E:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
+     }},
+    {"-",
+     {"%{E:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
 	%{C} %{v} %{A*} %{I*} %{P} %I\
 	%{C:%{!E:%eGNU C does not support -C without using -E}}\
 	%{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
@@ -586,9 +563,9 @@ static struct compiler default_compilers[] =
 	%{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
         %i %W{o*}}\
     %{!E:%e-E required when input is from standard input}"}},
-  {".h", {"@c-header"}},
-  {"@c-header",
-   {"%{!E:%eCompilation of header file requested} \
+    {".h", {"@c-header"}},
+    {"@c-header",
+     {"%{!E:%eCompilation of header file requested} \
     cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 	%{C:%{!E:%eGNU C does not support -C without using -E}}\
 	 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
@@ -600,9 +577,9 @@ static struct compiler default_compilers[] =
         %{traditional-cpp:-traditional}\
 	%{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
         %i %W{o*}"}},
-  {".i", {"@cpp-output"}},
-  {"@cpp-output",
-   "%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a*}\
+    {".i", {"@cpp-output"}},
+    {"@cpp-output",
+     "%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a*}\
 			%{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
 			%{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
 			%{aux-info*}\
@@ -610,16 +587,15 @@ static struct compiler default_compilers[] =
 			%{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
 		     %{!S:as %a %Y\
 			     %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
-			     %{!pipe:%g.s} %A\n }}}}"
-  },
-  {".s", {"@assembler"}},
-  {"@assembler",
-   {"%{!M:%{!MM:%{!E:%{!S:as %a %Y\
+			     %{!pipe:%g.s} %A\n }}}}"                                                                                                                                                                                                                                                                                                                                                                                       },
+    {".s", {"@assembler"}},
+    {"@assembler",
+     {"%{!M:%{!MM:%{!E:%{!S:as %a %Y\
 		            %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
 			    %i %A\n }}}}"}},
-  {".S", {"@assembler-with-cpp"}},
-  {"@assembler-with-cpp",
-   {"cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
+    {".S", {"@assembler-with-cpp"}},
+    {"@assembler-with-cpp",
+     {"cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
 	%{C:%{!E:%eGNU C does not support -C without using -E}}\
 	%{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
         -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
@@ -631,14 +607,14 @@ static struct compiler default_compilers[] =
     "%{!M:%{!MM:%{!E:%{!S:as %a %Y\
                     %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
 		    %{!pipe:%g.s} %A\n }}}}"}},
-  /* Mark end of table */
-  {0, {0}}
+    /* Mark end of table */
+    {0, {0}}
 };
 
 /* Number of elements in default_compilers, not counting the terminator.  */
 
 static int n_default_compilers
-  = (sizeof default_compilers / sizeof (struct compiler)) - 1;
+    = (sizeof default_compilers / sizeof (struct compiler)) - 1;
 
 /* Here is the spec for running the linker, after compiling all files.  */
 
@@ -676,343 +652,339 @@ static char **assembler_options;
    and substituted into the preprocessor command with %Z.  */
 static int n_preprocessor_options;
 static char **preprocessor_options;
-
+
 /* Define how to map long options into short ones.  */
 
 /* This structure describes one mapping.  */
 struct option_map
 {
-  /* The long option's name.  */
-  char *name;
-  /* The equivalent short option.  */
-  char *equivalent;
-  /* Argument info.  A string of flag chars; NULL equals no options.
-     a => argument required.
-     o => argument optional.
-     j => join argument to equivalent, making one word.
+    /* The long option's name.  */
+    char *name;
+    /* The equivalent short option.  */
+    char *equivalent;
+    /* Argument info.  A string of flag chars; NULL equals no options.
+       a => argument required.
+       o => argument optional.
+       j => join argument to equivalent, making one word.
      * => require other text after NAME as an argument.  */
-  char *arg_info;
+    char *arg_info;
 };
 
 /* This is the table of mappings.  Mappings are tried sequentially
    for each option encountered; the first one that matches, wins.  */
 
 struct option_map option_map[] =
- {
-   {"--all-warnings", "-Wall", 0},
-   {"--ansi", "-ansi", 0},
-   {"--assemble", "-S", 0},
-   {"--assert", "-A", "a"},
-   {"--classpath", "-fclasspath=", "aj"},
-   {"--CLASSPATH", "-fCLASSPATH=", "aj"},
-   {"--comments", "-C", 0},
-   {"--compile", "-c", 0},
-   {"--debug", "-g", "oj"},
-   {"--define-macro", "-D", "aj"},
-   {"--dependencies", "-M", 0},
-   {"--dump", "-d", "a"},
-   {"--dumpbase", "-dumpbase", "a"},
-   {"--entry", "-e", 0},
-   {"--extra-warnings", "-W", 0},
-   {"--for-assembler", "-Wa", "a"},
-   {"--for-linker", "-Xlinker", "a"},
-   {"--force-link", "-u", "a"},
-   {"--imacros", "-imacros", "a"},
-   {"--include", "-include", "a"},
-   {"--include-barrier", "-I-", 0},
-   {"--include-directory", "-I", "aj"},
-   {"--include-directory-after", "-idirafter", "a"},
-   {"--include-prefix", "-iprefix", "a"},
-   {"--include-with-prefix", "-iwithprefix", "a"},
-   {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
-   {"--include-with-prefix-after", "-iwithprefix", "a"},
-   {"--language", "-x", "a"},
-   {"--library-directory", "-L", "a"},
-   {"--machine", "-m", "aj"},
-   {"--machine-", "-m", "*j"},
-   {"--no-line-commands", "-P", 0},
-   {"--no-precompiled-includes", "-noprecomp", 0},
-   {"--no-standard-includes", "-nostdinc", 0},
-   {"--no-standard-libraries", "-nostdlib", 0},
-   {"--no-warnings", "-w", 0},
-   {"--optimize", "-O", "oj"},
-   {"--output", "-o", "a"},
-   {"--output-class-directory", "-foutput-class-dir=", "ja"},
-   {"--pedantic", "-pedantic", 0},
-   {"--pedantic-errors", "-pedantic-errors", 0},
-   {"--pipe", "-pipe", 0},
-   {"--prefix", "-B", "a"},
-   {"--preprocess", "-E", 0},
-   {"--print-search-dirs", "-print-search-dirs", 0},
-   {"--print-file-name", "-print-file-name=", "aj"},
-   {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
-   {"--print-missing-file-dependencies", "-MG", 0},
-   {"--print-multi-lib", "-print-multi-lib", 0},
-   {"--print-multi-directory", "-print-multi-directory", 0},
-   {"--print-prog-name", "-print-prog-name=", "aj"},
-   {"--profile", "-p", 0},
-   {"--profile-blocks", "-a", 0},
-   {"--quiet", "-q", 0},
-   {"--save-temps", "-save-temps", 0},
-   {"--shared", "-shared", 0},
-   {"--silent", "-q", 0},
-   {"--specs", "-specs=", "aj"},
-   {"--static", "-static", 0},
-   {"--std", "-std=", "aj"},
-   {"--symbolic", "-symbolic", 0},
-   {"--target", "-b", "a"},
-   {"--trace-includes", "-H", 0},
-   {"--traditional", "-traditional", 0},
-   {"--traditional-cpp", "-traditional-cpp", 0},
-   {"--trigraphs", "-trigraphs", 0},
-   {"--undefine-macro", "-U", "aj"},
-   {"--use-version", "-V", "a"},
-   {"--user-dependencies", "-MM", 0},
-   {"--verbose", "-v", 0},
-   {"--version", "-dumpversion", 0},
-   {"--warn-", "-W", "*j"},
-   {"--write-dependencies", "-MD", 0},
-   {"--write-user-dependencies", "-MMD", 0},
-   {"--", "-f", "*j"}
- };
-
+{
+    {"--all-warnings", "-Wall", 0},
+    {"--ansi", "-ansi", 0},
+    {"--assemble", "-S", 0},
+    {"--assert", "-A", "a"},
+    {"--classpath", "-fclasspath=", "aj"},
+    {"--CLASSPATH", "-fCLASSPATH=", "aj"},
+    {"--comments", "-C", 0},
+    {"--compile", "-c", 0},
+    {"--debug", "-g", "oj"},
+    {"--define-macro", "-D", "aj"},
+    {"--dependencies", "-M", 0},
+    {"--dump", "-d", "a"},
+    {"--dumpbase", "-dumpbase", "a"},
+    {"--entry", "-e", 0},
+    {"--extra-warnings", "-W", 0},
+    {"--for-assembler", "-Wa", "a"},
+    {"--for-linker", "-Xlinker", "a"},
+    {"--force-link", "-u", "a"},
+    {"--imacros", "-imacros", "a"},
+    {"--include", "-include", "a"},
+    {"--include-barrier", "-I-", 0},
+    {"--include-directory", "-I", "aj"},
+    {"--include-directory-after", "-idirafter", "a"},
+    {"--include-prefix", "-iprefix", "a"},
+    {"--include-with-prefix", "-iwithprefix", "a"},
+    {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
+    {"--include-with-prefix-after", "-iwithprefix", "a"},
+    {"--language", "-x", "a"},
+    {"--library-directory", "-L", "a"},
+    {"--machine", "-m", "aj"},
+    {"--machine-", "-m", "*j"},
+    {"--no-line-commands", "-P", 0},
+    {"--no-precompiled-includes", "-noprecomp", 0},
+    {"--no-standard-includes", "-nostdinc", 0},
+    {"--no-standard-libraries", "-nostdlib", 0},
+    {"--no-warnings", "-w", 0},
+    {"--optimize", "-O", "oj"},
+    {"--output", "-o", "a"},
+    {"--output-class-directory", "-foutput-class-dir=", "ja"},
+    {"--pedantic", "-pedantic", 0},
+    {"--pedantic-errors", "-pedantic-errors", 0},
+    {"--pipe", "-pipe", 0},
+    {"--prefix", "-B", "a"},
+    {"--preprocess", "-E", 0},
+    {"--print-search-dirs", "-print-search-dirs", 0},
+    {"--print-file-name", "-print-file-name=", "aj"},
+    {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
+    {"--print-missing-file-dependencies", "-MG", 0},
+    {"--print-multi-lib", "-print-multi-lib", 0},
+    {"--print-multi-directory", "-print-multi-directory", 0},
+    {"--print-prog-name", "-print-prog-name=", "aj"},
+    {"--profile", "-p", 0},
+    {"--profile-blocks", "-a", 0},
+    {"--quiet", "-q", 0},
+    {"--save-temps", "-save-temps", 0},
+    {"--shared", "-shared", 0},
+    {"--silent", "-q", 0},
+    {"--specs", "-specs=", "aj"},
+    {"--static", "-static", 0},
+    {"--std", "-std=", "aj"},
+    {"--symbolic", "-symbolic", 0},
+    {"--target", "-b", "a"},
+    {"--trace-includes", "-H", 0},
+    {"--traditional", "-traditional", 0},
+    {"--traditional-cpp", "-traditional-cpp", 0},
+    {"--trigraphs", "-trigraphs", 0},
+    {"--undefine-macro", "-U", "aj"},
+    {"--use-version", "-V", "a"},
+    {"--user-dependencies", "-MM", 0},
+    {"--verbose", "-v", 0},
+    {"--version", "-dumpversion", 0},
+    {"--warn-", "-W", "*j"},
+    {"--write-dependencies", "-MD", 0},
+    {"--write-user-dependencies", "-MMD", 0},
+    {"--", "-f", "*j"}
+};
+
 /* Translate the options described by *ARGCP and *ARGVP.
    Make a new vector and store it back in *ARGVP,
    and store its length in *ARGVC.  */
 
 static void
-translate_options (argcp, argvp)
-     int *argcp;
-     char ***argvp;
+translate_options(int *argcp, char ***argvp)
 {
-  int i;
-  int argc = *argcp;
-  char **argv = *argvp;
-  char **newv = (char **) xmalloc ((argc + 2) * 2 * sizeof (char *));
-  int newindex = 0;
+    int i;
+    int argc = *argcp;
+    char **argv = *argvp;
+    char **newv = (char **) xmalloc((argc + 2) * 2 * sizeof (char *));
+    int newindex = 0;
 
-  i = 0;
-  newv[newindex++] = argv[i++];
+    i = 0;
+    newv[newindex++] = argv[i++];
 
-  while (i < argc)
+    while (i < argc)
     {
-      /* Translate -- options.  */
-      if (argv[i][0] == '-' && argv[i][1] == '-')
-	{
-	  size_t j;
-	  /* Find a mapping that applies to this option.  */
-	  for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
-	    {
-	      size_t optlen = strlen (option_map[j].name);
-	      size_t arglen = strlen (argv[i]);
-	      size_t complen = arglen > optlen ? optlen : arglen;
-	      char *arginfo = option_map[j].arg_info;
-
-	      if (arginfo == 0)
-		arginfo = "";
-
-	      if (!strncmp (argv[i], option_map[j].name, complen))
-		{
-		  char *arg = 0;
-
-		  if (arglen < optlen)
-		    {
-		      size_t k;
-		      for (k = j + 1;
-			   k < sizeof (option_map) / sizeof (option_map[0]);
-			   k++)
-			if (strlen (option_map[k].name) >= arglen
-			    && !strncmp (argv[i], option_map[k].name, arglen))
-			  {
-			    error ("Ambiguous abbreviation %s", argv[i]);
-			    break;
-			  }
-
-		      if (k != sizeof (option_map) / sizeof (option_map[0]))
-			break;
-		    }
-
-		  if (arglen > optlen)
-		    {
-		      /* If the option has an argument, accept that.  */
-		      if (argv[i][optlen] == '=')
-			arg = argv[i] + optlen + 1;
-
-		      /* If this mapping requires extra text at end of name,
-			 accept that as "argument".  */
-		      else if (strchr (arginfo, '*') != 0)
-			arg = argv[i] + optlen;
-
-		      /* Otherwise, extra text at end means mismatch.
-			 Try other mappings.  */
-		      else
-			continue;
-		    }
-
-		  else if (strchr (arginfo, '*') != 0)
-		    {
-		      error ("Incomplete `%s' option", option_map[j].name);
-		      break;
-		    }
-
-		  /* Handle arguments.  */
-		  if (strchr (arginfo, 'a') != 0)
-		    {
-		      if (arg == 0)
-			{
-			  if (i + 1 == argc)
-			    {
-			      error ("Missing argument to `%s' option",
-				     option_map[j].name);
-			      break;
-			    }
-
-			  arg = argv[++i];
-			}
-		    }
-		  else if (strchr (arginfo, '*') != 0)
-		    ;
-		  else if (strchr (arginfo, 'o') == 0)
-		    {
-		      if (arg != 0)
-			error ("Extraneous argument to `%s' option",
-			       option_map[j].name);
-		      arg = 0;
-		    }
-
-		  /* Store the translation as one argv elt or as two.  */
-		  if (arg != 0 && strchr (arginfo, 'j') != 0)
-		    newv[newindex++] = concat (option_map[j].equivalent, arg,
-					       NULL);
-		  else if (arg != 0)
-		    {
-		      newv[newindex++] = option_map[j].equivalent;
-		      newv[newindex++] = arg;
-		    }
-		  else
-		    newv[newindex++] = option_map[j].equivalent;
-
-		  break;
-		}
-	    }
-	  i++;
-	}
-
-      /* Handle old-fashioned options--just copy them through,
-	 with their arguments.  */
-      else if (argv[i][0] == '-')
-	{
-	  char *p = argv[i] + 1;
-	  int c = *p;
-	  int nskip = 1;
-
-	  if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
-	    nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
-	  else if (WORD_SWITCH_TAKES_ARG (p))
-	    nskip += WORD_SWITCH_TAKES_ARG (p);
-	  else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
-		   && p[1] == 0)
-	    nskip += 1;
-	  else if (! strcmp (p, "Xlinker"))
-	    nskip += 1;
-
-	  /* Watch out for an option at the end of the command line that
-	     is missing arguments, and avoid skipping past the end of the
-	     command line.  */
-	  if (nskip + i > argc)
-	    nskip = argc - i;
-
-	  while (nskip > 0)
-	    {
-	      newv[newindex++] = argv[i++];
-	      nskip--;
-	    }
-	}
-      else
-	/* Ordinary operands, or +e options.  */
-	newv[newindex++] = argv[i++];
+        /* Translate -- options.  */
+        if (argv[i][0] == '-' && argv[i][1] == '-')
+        {
+            size_t j;
+            /* Find a mapping that applies to this option.  */
+            for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
+            {
+                size_t optlen = strlen(option_map[j].name);
+                size_t arglen = strlen(argv[i]);
+                size_t complen = arglen > optlen ? optlen : arglen;
+                char *arginfo = option_map[j].arg_info;
+
+                if (arginfo == 0)
+                    arginfo = "";
+
+                if (!strncmp(argv[i], option_map[j].name, complen))
+                {
+                    char *arg = 0;
+
+                    if (arglen < optlen)
+                    {
+                        size_t k;
+                        for (k = j + 1;
+                             k < sizeof (option_map) / sizeof (option_map[0]);
+                             k++)
+                            if (strlen(option_map[k].name) >= arglen
+                                && !strncmp(argv[i], option_map[k].name, arglen))
+                            {
+                                error("Ambiguous abbreviation %s", argv[i]);
+                                break;
+                            }
+
+                        if (k != sizeof (option_map) / sizeof (option_map[0]))
+                            break;
+                    }
+
+                    if (arglen > optlen)
+                    {
+                        /* If the option has an argument, accept that.  */
+                        if (argv[i][optlen] == '=')
+                            arg = argv[i] + optlen + 1;
+
+                        /* If this mapping requires extra text at end of name,
+                           accept that as "argument".  */
+                        else if (strchr(arginfo, '*') != 0)
+                            arg = argv[i] + optlen;
+
+                        /* Otherwise, extra text at end means mismatch.
+                           Try other mappings.  */
+                        else
+                            continue;
+                    }
+
+                    else if (strchr(arginfo, '*') != 0)
+                    {
+                        error("Incomplete `%s' option", option_map[j].name);
+                        break;
+                    }
+
+                    /* Handle arguments.  */
+                    if (strchr(arginfo, 'a') != 0)
+                    {
+                        if (arg == 0)
+                        {
+                            if (i + 1 == argc)
+                            {
+                                error("Missing argument to `%s' option",
+                                      option_map[j].name);
+                                break;
+                            }
+
+                            arg = argv[++i];
+                        }
+                    }
+                    else if (strchr(arginfo, '*') != 0)
+                        ;
+                    else if (strchr(arginfo, 'o') == 0)
+                    {
+                        if (arg != 0)
+                            error("Extraneous argument to `%s' option",
+                                  option_map[j].name);
+                        arg = 0;
+                    }
+
+                    /* Store the translation as one argv elt or as two.  */
+                    if (arg != 0 && strchr(arginfo, 'j') != 0)
+                        newv[newindex++] = concat(option_map[j].equivalent, arg,
+                                                  NULL);
+                    else if (arg != 0)
+                    {
+                        newv[newindex++] = option_map[j].equivalent;
+                        newv[newindex++] = arg;
+                    }
+                    else
+                        newv[newindex++] = option_map[j].equivalent;
+
+                    break;
+                }
+            }
+            i++;
+        }
+
+        /* Handle old-fashioned options--just copy them through,
+           with their arguments.  */
+        else if (argv[i][0] == '-')
+        {
+            char *p = argv[i] + 1;
+            int c = *p;
+            int nskip = 1;
+
+            if (SWITCH_TAKES_ARG(c) > (p[1] != 0))
+                nskip += SWITCH_TAKES_ARG(c) - (p[1] != 0);
+            else if (WORD_SWITCH_TAKES_ARG(p))
+                nskip += WORD_SWITCH_TAKES_ARG(p);
+            else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
+                     && p[1] == 0)
+                nskip += 1;
+            else if (!strcmp(p, "Xlinker"))
+                nskip += 1;
+
+            /* Watch out for an option at the end of the command line that
+               is missing arguments, and avoid skipping past the end of the
+               command line.  */
+            if (nskip + i > argc)
+                nskip = argc - i;
+
+            while (nskip > 0)
+            {
+                newv[newindex++] = argv[i++];
+                nskip--;
+            }
+        }
+        else
+            /* Ordinary operands, or +e options.  */
+            newv[newindex++] = argv[i++];
     }
 
-  newv[newindex] = 0;
+    newv[newindex] = 0;
 
-  *argvp = newv;
-  *argcp = newindex;
+    *argvp = newv;
+    *argcp = newindex;
 }
-
+
 char *
-xstrerror(e)
-     int e;
+xstrerror(int e)
 {
     return strerror(e);
 }
-
+
 static char *
-skip_whitespace (p)
-     char *p;
+skip_whitespace(char *p)
 {
-  while (1)
+    while (1)
     {
-      /* A fully-blank line is a delimiter in the SPEC file and shouldn't
-	 be considered whitespace.  */
-      if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
-	return p + 1;
-      else if (*p == '\n' || *p == ' ' || *p == '\t')
-	p++;
-      else if (*p == '#')
-	{
-	  while (*p != '\n') p++;
-	  p++;
-	}
-      else
-	break;
+        /* A fully-blank line is a delimiter in the SPEC file and shouldn't
+           be considered whitespace.  */
+        if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
+            return p + 1;
+        else if (*p == '\n' || *p == ' ' || *p == '\t')
+            p++;
+        else if (*p == '#')
+        {
+            while (*p != '\n') p++;
+            p++;
+        }
+        else
+            break;
     }
 
-  return p;
+    return p;
 }
-
+
 /* Structure to keep track of the specs that have been defined so far.
    These are accessed using %(specname) or %[specname] in a compiler
    or link spec.  */
 
 struct spec_list
 {
-				/* The following 2 fields must be first */
-				/* to allow EXTRA_SPECS to be initialized */
-  char *name;			/* name of the spec.  */
-  char *ptr;			/* available ptr if no static pointer */
-
-				/* The following fields are not initialized */
-				/* by EXTRA_SPECS */
-  char **ptr_spec;		/* pointer to the spec itself.  */
-  struct spec_list *next;	/* Next spec in linked list.  */
-  int name_len;			/* length of the name */
-  int alloc_p;			/* whether string was allocated */
+    /* The following 2 fields must be first */
+    /* to allow EXTRA_SPECS to be initialized */
+    char *name;                 /* name of the spec.  */
+    char *ptr;                  /* available ptr if no static pointer */
+
+    /* The following fields are not initialized */
+    /* by EXTRA_SPECS */
+    char **ptr_spec;            /* pointer to the spec itself.  */
+    struct spec_list *next;     /* Next spec in linked list.  */
+    int name_len;               /* length of the name */
+    int alloc_p;                /* whether string was allocated */
 };
 
 #define INIT_STATIC_SPEC(NAME,PTR) \
-{ NAME, NULL, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
+    { NAME, NULL, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
 
 /* List of statically defined specs */
 static struct spec_list static_specs[] = {
-  INIT_STATIC_SPEC ("asm",			&asm_spec),
-  INIT_STATIC_SPEC ("asm_final",		&asm_final_spec),
-  INIT_STATIC_SPEC ("cpp",			&cpp_spec),
-  INIT_STATIC_SPEC ("cc1",			&cc1_spec),
-  INIT_STATIC_SPEC ("endfile",			&endfile_spec),
-  INIT_STATIC_SPEC ("link",			&link_spec),
-  INIT_STATIC_SPEC ("lib",			&lib_spec),
-  INIT_STATIC_SPEC ("libgcc",			&libgcc_spec),
-  INIT_STATIC_SPEC ("startfile",		&startfile_spec),
-  INIT_STATIC_SPEC ("switches_need_spaces",	&switches_need_spaces),
-  INIT_STATIC_SPEC ("signed_char",		&signed_char_spec),
-  INIT_STATIC_SPEC ("predefines",		&cpp_predefines),
-  INIT_STATIC_SPEC ("cross_compile",		&cross_compile),
-  INIT_STATIC_SPEC ("version",			&compiler_version),
-  INIT_STATIC_SPEC ("multilib",			&multilib_select),
-  INIT_STATIC_SPEC ("multilib_defaults",	&multilib_defaults),
-  INIT_STATIC_SPEC ("multilib_extra",		&multilib_extra),
-  INIT_STATIC_SPEC ("multilib_matches",		&multilib_matches),
-  INIT_STATIC_SPEC ("linker",			&linker_name_spec),
+    INIT_STATIC_SPEC("asm",                      &asm_spec),
+    INIT_STATIC_SPEC("asm_final",                &asm_final_spec),
+    INIT_STATIC_SPEC("cpp",                      &cpp_spec),
+    INIT_STATIC_SPEC("cc1",                      &cc1_spec),
+    INIT_STATIC_SPEC("endfile",                  &endfile_spec),
+    INIT_STATIC_SPEC("link",                     &link_spec),
+    INIT_STATIC_SPEC("lib",                      &lib_spec),
+    INIT_STATIC_SPEC("libgcc",                   &libgcc_spec),
+    INIT_STATIC_SPEC("startfile",                &startfile_spec),
+    INIT_STATIC_SPEC("switches_need_spaces",     &switches_need_spaces),
+    INIT_STATIC_SPEC("signed_char",              &signed_char_spec),
+    INIT_STATIC_SPEC("predefines",               &cpp_predefines),
+    INIT_STATIC_SPEC("cross_compile",            &cross_compile),
+    INIT_STATIC_SPEC("version",                  &compiler_version),
+    INIT_STATIC_SPEC("multilib",                 &multilib_select),
+    INIT_STATIC_SPEC("multilib_defaults",        &multilib_defaults),
+    INIT_STATIC_SPEC("multilib_extra",           &multilib_extra),
+    INIT_STATIC_SPEC("multilib_matches",         &multilib_matches),
+    INIT_STATIC_SPEC("linker",                   &linker_name_spec),
 };
 
 
@@ -1020,96 +992,94 @@ static struct spec_list static_specs[] = {
 
 static struct spec_list *specs = (struct spec_list *)0;
 
-
+
 /* Initialize the specs lookup routines.  */
 
 static void
-init_spec ()
+init_spec()
 {
-  struct spec_list *next = (struct spec_list *)0;
-  struct spec_list *sl   = (struct spec_list *)0;
-  int i;
+    struct spec_list *next = (struct spec_list *)0;
+    struct spec_list *sl   = (struct spec_list *)0;
+    int i;
 
-  if (specs)
-    return;			/* already initialized */
+    if (specs)
+        return;                 /* already initialized */
 
-  if (verbose_flag)
-    fprintf (stderr, "Using builtin specs.\n");
+    if (verbose_flag)
+        fprintf(stderr, "Using builtin specs.\n");
 
-  for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1; i >= 0; i--)
+    for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1; i >= 0; i--)
     {
-      sl = &static_specs[i];
-      sl->next = next;
-      next = sl;
+        sl = &static_specs[i];
+        sl->next = next;
+        next = sl;
     }
 
-  specs = sl;
+    specs = sl;
 }
 
-
+
 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
    removed; If the spec starts with a + then SPEC is added to the end of the
    current spec.  */
 
 static void
-set_spec (name, spec)
-     char *name;
-     char *spec;
+set_spec(char *name, char *spec)
 {
-  struct spec_list *sl;
-  char *old_spec;
-  int name_len = strlen (name);
-  int i;
+    struct spec_list *sl;
+    char *old_spec;
+    int name_len = strlen(name);
+    int i;
 
-  /* If this is the first call, initialize the statically allocated specs */
-  if (!specs)
+    /* If this is the first call, initialize the statically allocated specs */
+    if (!specs)
     {
-      struct spec_list *next = (struct spec_list *)0;
-      for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1;
-	   i >= 0; i--)
-	{
-	  sl = &static_specs[i];
-	  sl->next = next;
-	  next = sl;
-	}
-      specs = sl;
+        struct spec_list *next = (struct spec_list *)0;
+        for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1;
+             i >= 0; i--)
+        {
+            sl = &static_specs[i];
+            sl->next = next;
+            next = sl;
+        }
+        specs = sl;
     }
 
-  /* See if the spec already exists */
-  for (sl = specs; sl; sl = sl->next)
-    if (name_len == sl->name_len && !strcmp (sl->name, name))
-      break;
+    /* See if the spec already exists */
+    for (sl = specs; sl; sl = sl->next)
+        if (name_len == sl->name_len && !strcmp(sl->name, name))
+            break;
 
-  if (!sl)
+    if (!sl)
     {
-      /* Not found - make it */
-      sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
-      sl->name = save_string (name, strlen (name));
-      sl->name_len = name_len;
-      sl->ptr_spec = &sl->ptr;
-      sl->alloc_p = 0;
-      *(sl->ptr_spec) = "";
-      sl->next = specs;
-      specs = sl;
+        /* Not found - make it */
+        sl = (struct spec_list *) xmalloc(sizeof (struct spec_list));
+        sl->name = save_string(name, strlen(name));
+        sl->name_len = name_len;
+        sl->ptr_spec = &sl->ptr;
+        sl->alloc_p = 0;
+        *(sl->ptr_spec) = "";
+        sl->next = specs;
+        specs = sl;
     }
 
-  old_spec = *(sl->ptr_spec);
-  *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
-		     ? concat (old_spec, spec + 1, NULL)
-		     : save_string (spec, strlen (spec)));
+    old_spec = *(sl->ptr_spec);
+    *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE((unsigned char)spec[1]))
+                       ? concat(old_spec, spec + 1, NULL)
+                       : save_string(spec, strlen(spec)));
 
 #ifdef DEBUG_SPECS
-  if (verbose_flag)
-    fprintf (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
+    if (verbose_flag)
+        fprintf(stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
 #endif
 
-  /* Free the old spec */
-  if (old_spec && sl->alloc_p)
-    free (old_spec);
+    /* Free the old spec */
+    if (old_spec && sl->alloc_p)
+        free(old_spec);
 
-  sl->alloc_p = 1;
+    sl->alloc_p = 1;
 }
-
+
 /* Accumulate a command (program name and args), and run it.  */
 
 /* Vector of pointers to arguments in the current line of specifications.  */
@@ -1134,12 +1104,12 @@ extern char *make_temp_file (char *);
    temp file.  */
 
 static struct temp_name {
-  char *suffix;		/* suffix associated with the code.  */
-  int length;		/* strlen (suffix).  */
-  int unique;		/* Indicates whether %g or %u/%U was used.  */
-  char *filename;	/* associated filename.  */
-  int filename_length;	/* strlen (filename).  */
-  struct temp_name *next;
+    char *suffix;       /* suffix associated with the code.  */
+    int length;         /* strlen (suffix).  */
+    int unique;         /* Indicates whether %g or %u/%U was used.  */
+    char *filename;     /* associated filename.  */
+    int filename_length; /* strlen (filename).  */
+    struct temp_name *next;
 } *temp_names;
 
 
@@ -1154,23 +1124,23 @@ static int signal_count;
 /* Name with which this program was invoked.  */
 
 static char *programname;
-
+
 /* Structures to keep track of prefixes to try when looking for files.  */
 
 struct prefix_list
 {
-  char *prefix;               /* String to prepend to the path.  */
-  struct prefix_list *next;   /* Next in linked list.  */
-  int require_machine_suffix; /* Don't use without machine_suffix.  */
-  /* 2 means try both machine_suffix and just_machine_suffix.  */
-  int *used_flag_ptr;	      /* 1 if a file was found with this prefix.  */
+    char *prefix;             /* String to prepend to the path.  */
+    struct prefix_list *next; /* Next in linked list.  */
+    int require_machine_suffix; /* Don't use without machine_suffix.  */
+    /* 2 means try both machine_suffix and just_machine_suffix.  */
+    int *used_flag_ptr;       /* 1 if a file was found with this prefix.  */
 };
 
 struct path_prefix
 {
-  struct prefix_list *plist;  /* List of prefixes to try */
-  int max_len;                /* Max length of a prefix in PLIST */
-  char *name;                 /* Name of this list (used in config stuff) */
+    struct prefix_list *plist; /* List of prefixes to try */
+    int max_len;              /* Max length of a prefix in PLIST */
+    char *name;               /* Name of this list (used in config stuff) */
 };
 
 /* List of prefixes to try when looking for executables.  */
@@ -1232,9 +1202,9 @@ static char *multilib_dir;
 /* Clear out the vector of arguments (after a command is executed).  */
 
 static void
-clear_args ()
+clear_args()
 {
-  argbuf_index = 0;
+    argbuf_index = 0;
 }
 
 /* Add one argument to the vector at the end.
@@ -1245,279 +1215,275 @@ clear_args ()
     and the file should be deleted if this compilation fails.  */
 
 static void
-store_arg (arg, delete_always, delete_failure)
-     char *arg;
-     int delete_always, delete_failure;
+store_arg(char *arg, int delete_always, int delete_failure)
 {
-  if (argbuf_index + 1 == argbuf_length)
-    argbuf
-      = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
+    if (argbuf_index + 1 == argbuf_length)
+        argbuf
+            = (char **) xrealloc(argbuf, (argbuf_length *= 2) * sizeof (char *));
 
-  argbuf[argbuf_index++] = arg;
-  argbuf[argbuf_index] = 0;
+    argbuf[argbuf_index++] = arg;
+    argbuf[argbuf_index] = 0;
 
-  if (delete_always || delete_failure)
-    record_temp_file (arg, delete_always, delete_failure);
+    if (delete_always || delete_failure)
+        record_temp_file(arg, delete_always, delete_failure);
 }
-
+
 /* Read compilation specs from a file named FILENAME,
    replacing the default ones.
 
    A suffix which starts with `*' is a definition for
    one of the machine-specific sub-specs.  The "suffix" should be
-   *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
+ * asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
    The corresponding spec is stored in asm_spec, etc.,
    rather than in the `compilers' vector.
 
    Anything invalid in the file is a fatal error.  */
 
 static void
-read_specs (filename, main_p)
-     char *filename;
-     int main_p;
+read_specs(char *filename, int main_p)
 {
-  int desc;
-  int readlen;
-  struct stat statbuf;
-  char *buffer;
-  register char *p;
-
-  if (verbose_flag)
-    fprintf (stderr, "Reading specs from %s\n", filename);
-
-  /* Open and stat the file.  */
-  desc = open (filename, O_RDONLY, 0);
-  if (desc < 0)
-    pfatal_with_name (filename);
-  if (stat (filename, &statbuf) < 0)
-    pfatal_with_name (filename);
-
-  /* Read contents of file into BUFFER.  */
-  buffer = xmalloc ((unsigned) statbuf.st_size + 1);
-  readlen = read (desc, buffer, (unsigned) statbuf.st_size);
-  if (readlen < 0)
-    pfatal_with_name (filename);
-  buffer[readlen] = 0;
-  close (desc);
-
-  /* Scan BUFFER for specs, putting them in the vector.  */
-  p = buffer;
-  while (1)
+    int desc;
+    int readlen;
+    struct stat statbuf;
+    char *buffer;
+    register char *p;
+
+    if (verbose_flag)
+        fprintf(stderr, "Reading specs from %s\n", filename);
+
+    /* Open and stat the file.  */
+    desc = open(filename, O_RDONLY, 0);
+    if (desc < 0)
+        pfatal_with_name(filename);
+    if (stat(filename, &statbuf) < 0)
+        pfatal_with_name(filename);
+
+    /* Read contents of file into BUFFER.  */
+    buffer = xmalloc((unsigned) statbuf.st_size + 1);
+    readlen = read(desc, buffer, (unsigned) statbuf.st_size);
+    if (readlen < 0)
+        pfatal_with_name(filename);
+    buffer[readlen] = 0;
+    close(desc);
+
+    /* Scan BUFFER for specs, putting them in the vector.  */
+    p = buffer;
+    while (1)
     {
-      char *suffix;
-      char *spec;
-      char *in, *out, *p1, *p2, *p3;
-
-      /* Advance P in BUFFER to the next nonblank nocomment line.  */
-      p = skip_whitespace (p);
-      if (*p == 0)
-	break;
-
-      /* Is this a special command that starts with '%'? */
-      /* Don't allow this for the main specs file, since it would
-	 encourage people to overwrite it.  */
-      if (*p == '%' && !main_p)
-	{
-	  p1 = p;
-	  while (*p && *p != '\n')
-	    p++;
-
-	  p++;			/* Skip '\n' */
-
-	  if (!strncmp (p1, "%include", sizeof ("%include")-1)
-	      && (p1[sizeof "%include" - 1] == ' '
-		  || p1[sizeof "%include" - 1] == '\t'))
-	    {
-	      char *new_filename;
-
-	      p1 += sizeof ("%include");
-	      while (*p1 == ' ' || *p1 == '\t')
-		p1++;
-
-	      if (*p1++ != '<' || p[-2] != '>')
-		fatal ("specs %%include syntax malformed after %ld characters",
-		       (long) (p1 - buffer + 1));
-
-	      p[-2] = '\0';
-	      new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
-	      read_specs (new_filename ? new_filename : p1, FALSE);
-	      continue;
-	    }
-	  else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
-		   && (p1[sizeof "%include_noerr" - 1] == ' '
-		       || p1[sizeof "%include_noerr" - 1] == '\t'))
-	    {
-	      char *new_filename;
-
-	      p1 += sizeof "%include_noerr";
-	      while (*p1 == ' ' || *p1 == '\t') p1++;
-
-	      if (*p1++ != '<' || p[-2] != '>')
-		fatal ("specs %%include syntax malformed after %ld characters",
-		       (long) (p1 - buffer + 1));
-
-	      p[-2] = '\0';
-	      new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
-	      if (new_filename)
-		read_specs (new_filename, FALSE);
-	      else if (verbose_flag)
-		fprintf (stderr, "Could not find specs file %s\n", p1);
-	      continue;
-	    }
-	  else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
-		   && (p1[sizeof "%rename" - 1] == ' '
-		       || p1[sizeof "%rename" - 1] == '\t'))
-	    {
-	      int name_len;
-	      struct spec_list *sl;
-
-	      /* Get original name */
-	      p1 += sizeof "%rename";
-	      while (*p1 == ' ' || *p1 == '\t')
-		p1++;
-
-	      if (! ISALPHA ((unsigned char)*p1))
-		fatal ("specs %%rename syntax malformed after %ld characters",
-		       (long) (p1 - buffer));
-
-	      p2 = p1;
-	      while (*p2 && !ISSPACE ((unsigned char)*p2))
-		p2++;
-
-	      if (*p2 != ' ' && *p2 != '\t')
-		fatal ("specs %%rename syntax malformed after %ld characters",
-		       (long) (p2 - buffer));
-
-	      name_len = p2 - p1;
-	      *p2++ = '\0';
-	      while (*p2 == ' ' || *p2 == '\t')
-		p2++;
-
-	      if (! ISALPHA ((unsigned char)*p2))
-		fatal ("specs %%rename syntax malformed after %ld characters",
-		       (long) (p2 - buffer));
-
-	      /* Get new spec name */
-	      p3 = p2;
-	      while (*p3 && !ISSPACE ((unsigned char)*p3))
-		p3++;
-
-	      if (p3 != p-1)
-		fatal ("specs %%rename syntax malformed after %ld characters",
-		       (long) (p3 - buffer));
-	      *p3 = '\0';
-
-	      for (sl = specs; sl; sl = sl->next)
-		if (name_len == sl->name_len && !strcmp (sl->name, p1))
-		  break;
-
-	      if (!sl)
-		fatal ("specs %s spec was not found to be renamed", p1);
-
-	      if (strcmp (p1, p2) == 0)
-		continue;
-
-	      if (verbose_flag)
-		{
-		  fprintf (stderr, "rename spec %s to %s\n", p1, p2);
+        char *suffix;
+        char *spec;
+        char *in, *out, *p1, *p2, *p3;
+
+        /* Advance P in BUFFER to the next nonblank nocomment line.  */
+        p = skip_whitespace(p);
+        if (*p == 0)
+            break;
+
+        /* Is this a special command that starts with '%'? */
+        /* Don't allow this for the main specs file, since it would
+           encourage people to overwrite it.  */
+        if (*p == '%' && !main_p)
+        {
+            p1 = p;
+            while (*p && *p != '\n')
+                p++;
+
+            p++;                /* Skip '\n' */
+
+            if (!strncmp(p1, "%include", sizeof ("%include")-1)
+                && (p1[sizeof "%include" - 1] == ' '
+                    || p1[sizeof "%include" - 1] == '\t'))
+            {
+                char *new_filename;
+
+                p1 += sizeof ("%include");
+                while (*p1 == ' ' || *p1 == '\t')
+                    p1++;
+
+                if (*p1++ != '<' || p[-2] != '>')
+                    fatal("specs %%include syntax malformed after %ld characters",
+                          (long) (p1 - buffer + 1));
+
+                p[-2] = '\0';
+                new_filename = find_a_file(&startfile_prefixes, p1, R_OK);
+                read_specs(new_filename ? new_filename : p1, FALSE);
+                continue;
+            }
+            else if (!strncmp(p1, "%include_noerr", sizeof "%include_noerr" - 1)
+                     && (p1[sizeof "%include_noerr" - 1] == ' '
+                         || p1[sizeof "%include_noerr" - 1] == '\t'))
+            {
+                char *new_filename;
+
+                p1 += sizeof "%include_noerr";
+                while (*p1 == ' ' || *p1 == '\t') p1++;
+
+                if (*p1++ != '<' || p[-2] != '>')
+                    fatal("specs %%include syntax malformed after %ld characters",
+                          (long) (p1 - buffer + 1));
+
+                p[-2] = '\0';
+                new_filename = find_a_file(&startfile_prefixes, p1, R_OK);
+                if (new_filename)
+                    read_specs(new_filename, FALSE);
+                else if (verbose_flag)
+                    fprintf(stderr, "Could not find specs file %s\n", p1);
+                continue;
+            }
+            else if (!strncmp(p1, "%rename", sizeof "%rename" - 1)
+                     && (p1[sizeof "%rename" - 1] == ' '
+                         || p1[sizeof "%rename" - 1] == '\t'))
+            {
+                int name_len;
+                struct spec_list *sl;
+
+                /* Get original name */
+                p1 += sizeof "%rename";
+                while (*p1 == ' ' || *p1 == '\t')
+                    p1++;
+
+                if (!ISALPHA((unsigned char)*p1))
+                    fatal("specs %%rename syntax malformed after %ld characters",
+                          (long) (p1 - buffer));
+
+                p2 = p1;
+                while (*p2 && !ISSPACE((unsigned char)*p2))
+                    p2++;
+
+                if (*p2 != ' ' && *p2 != '\t')
+                    fatal("specs %%rename syntax malformed after %ld characters",
+                          (long) (p2 - buffer));
+
+                name_len = p2 - p1;
+                *p2++ = '\0';
+                while (*p2 == ' ' || *p2 == '\t')
+                    p2++;
+
+                if (!ISALPHA((unsigned char)*p2))
+                    fatal("specs %%rename syntax malformed after %ld characters",
+                          (long) (p2 - buffer));
+
+                /* Get new spec name */
+                p3 = p2;
+                while (*p3 && !ISSPACE((unsigned char)*p3))
+                    p3++;
+
+                if (p3 != p-1)
+                    fatal("specs %%rename syntax malformed after %ld characters",
+                          (long) (p3 - buffer));
+                *p3 = '\0';
+
+                for (sl = specs; sl; sl = sl->next)
+                    if (name_len == sl->name_len && !strcmp(sl->name, p1))
+                        break;
+
+                if (!sl)
+                    fatal("specs %s spec was not found to be renamed", p1);
+
+                if (strcmp(p1, p2) == 0)
+                    continue;
+
+                if (verbose_flag)
+                {
+                    fprintf(stderr, "rename spec %s to %s\n", p1, p2);
 #ifdef DEBUG_SPECS
-		  fprintf (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
+                    fprintf(stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
 #endif
-		}
-
-	      set_spec (p2, *(sl->ptr_spec));
-	      if (sl->alloc_p)
-		free (*(sl->ptr_spec));
-
-	      *(sl->ptr_spec) = "";
-	      sl->alloc_p = 0;
-	      continue;
-	    }
-	  else
-	    fatal ("specs unknown %% command after %ld characters",
-		   (long) (p1 - buffer));
-	}
-
-      /* Find the colon that should end the suffix.  */
-      p1 = p;
-      while (*p1 && *p1 != ':' && *p1 != '\n')
-	p1++;
-
-      /* The colon shouldn't be missing.  */
-      if (*p1 != ':')
-	fatal ("specs file malformed after %ld characters",
-	       (long) (p1 - buffer));
-
-      /* Skip back over trailing whitespace.  */
-      p2 = p1;
-      while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
-	p2--;
-
-      /* Copy the suffix to a string.  */
-      suffix = save_string (p, p2 - p);
-      /* Find the next line.  */
-      p = skip_whitespace (p1 + 1);
-      if (p[1] == 0)
-	fatal ("specs file malformed after %ld characters",
-	       (long) (p - buffer));
-
-      p1 = p;
-      /* Find next blank line or end of string.  */
-      while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
-	p1++;
-
-      /* Specs end at the blank line and do not include the newline.  */
-      spec = save_string (p, p1 - p);
-      p = p1;
-
-      /* Delete backslash-newline sequences from the spec.  */
-      in = spec;
-      out = spec;
-      while (*in != 0)
-	{
-	  if (in[0] == '\\' && in[1] == '\n')
-	    in += 2;
-	  else if (in[0] == '#')
-	    while (*in && *in != '\n')
-	      in++;
-
-	  else
-	    *out++ = *in++;
-	}
-      *out = 0;
-
-      if (suffix[0] == '*')
-	{
-	  if (! strcmp (suffix, "*link_command"))
-	    link_command_spec = spec;
-	  else
-	    set_spec (suffix + 1, spec);
-	}
-      else
-	{
-	  /* Add this pair to the vector.  */
-	  compilers
-	    = ((struct compiler *)
-	       xrealloc (compilers,
-			 (n_compilers + 2) * sizeof (struct compiler)));
-
-	  compilers[n_compilers].suffix = suffix;
-	  zero_memory ((char *) compilers[n_compilers].spec,
-		 sizeof compilers[n_compilers].spec);
-	  compilers[n_compilers].spec[0] = spec;
-	  n_compilers++;
-	  zero_memory ((char *) &compilers[n_compilers],
-		 sizeof compilers[n_compilers]);
-	}
-
-      if (*suffix == 0)
-	link_command_spec = spec;
+                }
+
+                set_spec(p2, *(sl->ptr_spec));
+                if (sl->alloc_p)
+                    free(*(sl->ptr_spec));
+
+                *(sl->ptr_spec) = "";
+                sl->alloc_p = 0;
+                continue;
+            }
+            else
+                fatal("specs unknown %% command after %ld characters",
+                      (long) (p1 - buffer));
+        }
+
+        /* Find the colon that should end the suffix.  */
+        p1 = p;
+        while (*p1 && *p1 != ':' && *p1 != '\n')
+            p1++;
+
+        /* The colon shouldn't be missing.  */
+        if (*p1 != ':')
+            fatal("specs file malformed after %ld characters",
+                  (long) (p1 - buffer));
+
+        /* Skip back over trailing whitespace.  */
+        p2 = p1;
+        while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
+            p2--;
+
+        /* Copy the suffix to a string.  */
+        suffix = save_string(p, p2 - p);
+        /* Find the next line.  */
+        p = skip_whitespace(p1 + 1);
+        if (p[1] == 0)
+            fatal("specs file malformed after %ld characters",
+                  (long) (p - buffer));
+
+        p1 = p;
+        /* Find next blank line or end of string.  */
+        while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
+            p1++;
+
+        /* Specs end at the blank line and do not include the newline.  */
+        spec = save_string(p, p1 - p);
+        p = p1;
+
+        /* Delete backslash-newline sequences from the spec.  */
+        in = spec;
+        out = spec;
+        while (*in != 0)
+        {
+            if (in[0] == '\\' && in[1] == '\n')
+                in += 2;
+            else if (in[0] == '#')
+                while (*in && *in != '\n')
+                    in++;
+
+            else
+                *out++ = *in++;
+        }
+        *out = 0;
+
+        if (suffix[0] == '*')
+        {
+            if (!strcmp(suffix, "*link_command"))
+                link_command_spec = spec;
+            else
+                set_spec(suffix + 1, spec);
+        }
+        else
+        {
+            /* Add this pair to the vector.  */
+            compilers
+                = ((struct compiler *)
+                   xrealloc(compilers,
+                            (n_compilers + 2) * sizeof (struct compiler)));
+
+            compilers[n_compilers].suffix = suffix;
+            zero_memory((char *) compilers[n_compilers].spec,
+                        sizeof compilers[n_compilers].spec);
+            compilers[n_compilers].spec[0] = spec;
+            n_compilers++;
+            zero_memory((char *) &compilers[n_compilers],
+                        sizeof compilers[n_compilers]);
+        }
+
+        if (*suffix == 0)
+            link_command_spec = spec;
     }
 
-  if (link_command_spec == 0)
-    fatal ("spec file has no spec for linking");
+    if (link_command_spec == 0)
+        fatal("spec file has no spec for linking");
 }
-
+
 /* Record the names of temporary files we tell compilers to write,
    and delete them at the end of the run.  */
 
@@ -1542,8 +1508,8 @@ static int temp_filename_length;
 
 struct temp_file
 {
-  char *name;
-  struct temp_file *next;
+    char *name;
+    struct temp_file *next;
 };
 
 /* Queue of files to delete on success or failure of compilation.  */
@@ -1558,96 +1524,92 @@ static struct temp_file *failure_delete_queue;
    otherwise delete it in any case.  */
 
 static void
-record_temp_file (filename, always_delete, fail_delete)
-     char *filename;
-     int always_delete;
-     int fail_delete;
+record_temp_file(char *filename, int always_delete, int fail_delete)
 {
-  register char *name;
-  name = xmalloc (strlen (filename) + 1);
-  strcpy (name, filename);
+    register char *name;
+    name = xmalloc(strlen(filename) + 1);
+    strcpy(name, filename);
 
-  if (always_delete)
+    if (always_delete)
     {
-      register struct temp_file *temp;
-      for (temp = always_delete_queue; temp; temp = temp->next)
-	if (! strcmp (name, temp->name))
-	  goto already1;
+        register struct temp_file *temp;
+        for (temp = always_delete_queue; temp; temp = temp->next)
+            if (!strcmp(name, temp->name))
+                goto already1;
 
-      temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
-      temp->next = always_delete_queue;
-      temp->name = name;
-      always_delete_queue = temp;
+        temp = (struct temp_file *) xmalloc(sizeof (struct temp_file));
+        temp->next = always_delete_queue;
+        temp->name = name;
+        always_delete_queue = temp;
 
-    already1:;
+already1:;
     }
 
-  if (fail_delete)
+    if (fail_delete)
     {
-      register struct temp_file *temp;
-      for (temp = failure_delete_queue; temp; temp = temp->next)
-	if (! strcmp (name, temp->name))
-	  goto already2;
+        register struct temp_file *temp;
+        for (temp = failure_delete_queue; temp; temp = temp->next)
+            if (!strcmp(name, temp->name))
+                goto already2;
 
-      temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
-      temp->next = failure_delete_queue;
-      temp->name = name;
-      failure_delete_queue = temp;
+        temp = (struct temp_file *) xmalloc(sizeof (struct temp_file));
+        temp->next = failure_delete_queue;
+        temp->name = name;
+        failure_delete_queue = temp;
 
-    already2:;
+already2:;
     }
 }
 
 /* Delete all the temporary files whose names we previously recorded.  */
 
 static void
-delete_if_ordinary (name)
-     char *name;
+delete_if_ordinary(char *name)
 {
-  struct stat st;
+    struct stat st;
 #ifdef DEBUG
-  int i, c;
+    int i, c;
 
-  printf ("Delete %s? (y or n) ", name);
-  fflush (stdout);
-  i = getchar ();
-  if (i != '\n')
-    while ((c = getchar ()) != '\n' && c != EOF)
-      ;
+    printf("Delete %s? (y or n) ", name);
+    fflush(stdout);
+    i = getchar();
+    if (i != '\n')
+        while ((c = getchar()) != '\n' && c != EOF)
+            ;
 
-  if (i == 'y' || i == 'Y')
+    if (i == 'y' || i == 'Y')
 #endif /* DEBUG */
-    if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
-      if (unlink (name) < 0)
-	if (verbose_flag)
-	  perror_with_name (name);
+    if (stat(name, &st) >= 0 && S_ISREG(st.st_mode))
+        if (unlink(name) < 0)
+            if (verbose_flag)
+                perror_with_name(name);
 }
 
 static void
-delete_temp_files ()
+delete_temp_files()
 {
-  register struct temp_file *temp;
+    register struct temp_file *temp;
 
-  for (temp = always_delete_queue; temp; temp = temp->next)
-    delete_if_ordinary (temp->name);
-  always_delete_queue = 0;
+    for (temp = always_delete_queue; temp; temp = temp->next)
+        delete_if_ordinary(temp->name);
+    always_delete_queue = 0;
 }
 
 /* Delete all the files to be deleted on error.  */
 
 static void
-delete_failure_queue ()
+delete_failure_queue()
 {
-  register struct temp_file *temp;
+    register struct temp_file *temp;
 
-  for (temp = failure_delete_queue; temp; temp = temp->next)
-    delete_if_ordinary (temp->name);
+    for (temp = failure_delete_queue; temp; temp = temp->next)
+        delete_if_ordinary(temp->name);
 }
 
 static void
-clear_failure_queue ()
+clear_failure_queue()
 {
-  failure_delete_queue = 0;
+    failure_delete_queue = 0;
 }
 
 /* Build a list of search directories from PATHS.
@@ -1657,72 +1619,67 @@ clear_failure_queue ()
    It is also used by the --print-search-dirs flag.  */
 
 static char *
-build_search_list (paths, prefix, check_dir_p)
-     struct path_prefix *paths;
-     char *prefix;
-     int check_dir_p;
+build_search_list(struct path_prefix *paths, char *prefix, int check_dir_p)
 {
-  int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
-  int just_suffix_len
-    = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
-  int first_time = TRUE;
-  struct prefix_list *pprefix;
+    int suffix_len = (machine_suffix) ? strlen(machine_suffix) : 0;
+    int just_suffix_len
+        = (just_machine_suffix) ? strlen(just_machine_suffix) : 0;
+    int first_time = TRUE;
+    struct prefix_list *pprefix;
 
-  obstack_grow (&collect_obstack, prefix, strlen (prefix));
+    obstack_grow(&collect_obstack, prefix, strlen(prefix));
 
-  for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
+    for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
     {
-      int len = strlen (pprefix->prefix);
-
-      if (machine_suffix
-	  && (! check_dir_p
-	      || is_directory (pprefix->prefix, machine_suffix, 0)))
-	{
-	  if (!first_time)
-	    obstack_1grow (&collect_obstack, PATH_SEPARATOR);
-	    
-	  first_time = FALSE;
-	  obstack_grow (&collect_obstack, pprefix->prefix, len);
-	  obstack_grow (&collect_obstack, machine_suffix, suffix_len);
-	}
-
-      if (just_machine_suffix
-	  && pprefix->require_machine_suffix == 2
-	  && (! check_dir_p
-	      || is_directory (pprefix->prefix, just_machine_suffix, 0)))
-	{
-	  if (! first_time)
-	    obstack_1grow (&collect_obstack, PATH_SEPARATOR);
-	    
-	  first_time = FALSE;
-	  obstack_grow (&collect_obstack, pprefix->prefix, len);
-	  obstack_grow (&collect_obstack, just_machine_suffix,
-			just_suffix_len);
-	}
-
-      if (! pprefix->require_machine_suffix)
-	{
-	  if (! first_time)
-	    obstack_1grow (&collect_obstack, PATH_SEPARATOR);
-
-	  first_time = FALSE;
-	  obstack_grow (&collect_obstack, pprefix->prefix, len);
-	}
+        int len = strlen(pprefix->prefix);
+
+        if (machine_suffix
+            && (!check_dir_p
+                || is_directory(pprefix->prefix, machine_suffix, 0)))
+        {
+            if (!first_time)
+                obstack_1grow(&collect_obstack, PATH_SEPARATOR);
+
+            first_time = FALSE;
+            obstack_grow(&collect_obstack, pprefix->prefix, len);
+            obstack_grow(&collect_obstack, machine_suffix, suffix_len);
+        }
+
+        if (just_machine_suffix
+            && pprefix->require_machine_suffix == 2
+            && (!check_dir_p
+                || is_directory(pprefix->prefix, just_machine_suffix, 0)))
+        {
+            if (!first_time)
+                obstack_1grow(&collect_obstack, PATH_SEPARATOR);
+
+            first_time = FALSE;
+            obstack_grow(&collect_obstack, pprefix->prefix, len);
+            obstack_grow(&collect_obstack, just_machine_suffix,
+                         just_suffix_len);
+        }
+
+        if (!pprefix->require_machine_suffix)
+        {
+            if (!first_time)
+                obstack_1grow(&collect_obstack, PATH_SEPARATOR);
+
+            first_time = FALSE;
+            obstack_grow(&collect_obstack, pprefix->prefix, len);
+        }
     }
 
-  obstack_1grow (&collect_obstack, '\0');
-  return obstack_finish (&collect_obstack);
+    obstack_1grow(&collect_obstack, '\0');
+    return obstack_finish(&collect_obstack);
 }
 
 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
    for collect.  */
 
 static void
-putenv_from_prefixes (paths, env_var)
-     struct path_prefix *paths;
-     char *env_var;
+putenv_from_prefixes(struct path_prefix *paths, char *env_var)
 {
-  putenv (build_search_list (paths, env_var, 1));
+    putenv(build_search_list(paths, env_var, 1));
 }
 
 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
@@ -1730,150 +1687,147 @@ putenv_from_prefixes (paths, env_var)
    Return 0 if not found, otherwise return its name, allocated with malloc.  */
 
 static char *
-find_a_file (pprefix, name, mode)
-     struct path_prefix *pprefix;
-     char *name;
-     int mode;
+find_a_file(struct path_prefix *pprefix, char *name, int mode)
 {
-  char *temp;
-  char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
-  struct prefix_list *pl;
-  int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
+    char *temp;
+    char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
+    struct prefix_list *pl;
+    int len = pprefix->max_len + strlen(name) + strlen(file_suffix) + 1;
 
 #ifdef DEFAULT_ASSEMBLER
-  if (! strcmp(name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) {
-    name = DEFAULT_ASSEMBLER;
-    len = strlen(name)+1;
-    temp = xmalloc (len);
-    strcpy (temp, name);
-    return temp;
-  }
+    if (!strcmp(name, "as") && access(DEFAULT_ASSEMBLER, mode) == 0) {
+        name = DEFAULT_ASSEMBLER;
+        len = strlen(name)+1;
+        temp = xmalloc(len);
+        strcpy(temp, name);
+        return temp;
+    }
 #endif
 
 #ifdef DEFAULT_LINKER
-  if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) {
-    name = DEFAULT_LINKER;
-    len = strlen(name)+1;
-    temp = xmalloc (len);
-    strcpy (temp, name);
-    return temp;
-  }
+    if (!strcmp(name, "ld") && access(DEFAULT_LINKER, mode) == 0) {
+        name = DEFAULT_LINKER;
+        len = strlen(name)+1;
+        temp = xmalloc(len);
+        strcpy(temp, name);
+        return temp;
+    }
 #endif
 
-  if (machine_suffix)
-    len += strlen (machine_suffix);
+    if (machine_suffix)
+        len += strlen(machine_suffix);
 
-  temp = xmalloc (len);
+    temp = xmalloc(len);
 
-  /* Determine the filename to execute (special case for absolute paths).  */
+    /* Determine the filename to execute (special case for absolute paths).  */
 
-  if (*name == '/' || *name == DIR_SEPARATOR
-      /* Check for disk name on MS-DOS-based systems.  */
-      || (DIR_SEPARATOR == '\\' && name[1] == ':'
-	  && (name[2] == DIR_SEPARATOR || name[2] == '/')))
+    if (*name == '/' || *name == DIR_SEPARATOR
+        /* Check for disk name on MS-DOS-based systems.  */
+        || (DIR_SEPARATOR == '\\' && name[1] == ':'
+            && (name[2] == DIR_SEPARATOR || name[2] == '/')))
     {
-      if (access (name, mode) == 0)
-	{
-	  strcpy (temp, name);
-	  return temp;
-	}
+        if (access(name, mode) == 0)
+        {
+            strcpy(temp, name);
+            return temp;
+        }
     }
-  else
-    for (pl = pprefix->plist; pl; pl = pl->next)
-      {
-	if (machine_suffix)
-	  {
-	    /* Some systems have a suffix for executable files.
-	       So try appending that first.  */
-	    if (file_suffix[0] != 0)
-	      {
-		strcpy (temp, pl->prefix);
-		strcat (temp, machine_suffix);
-		strcat (temp, name);
-		strcat (temp, file_suffix);
-		if (access (temp, mode) == 0)
-		  {
-		    if (pl->used_flag_ptr != 0)
-		      *pl->used_flag_ptr = 1;
-		    return temp;
-		  }
-	      }
-
-	    /* Now try just the name.  */
-	    strcpy (temp, pl->prefix);
-	    strcat (temp, machine_suffix);
-	    strcat (temp, name);
-	    if (access (temp, mode) == 0)
-	      {
-		if (pl->used_flag_ptr != 0)
-		  *pl->used_flag_ptr = 1;
-		return temp;
-	      }
-	  }
-
-	/* Certain prefixes are tried with just the machine type,
-	   not the version.  This is used for finding as, ld, etc.  */
-	if (just_machine_suffix && pl->require_machine_suffix == 2)
-	  {
-	    /* Some systems have a suffix for executable files.
-	       So try appending that first.  */
-	    if (file_suffix[0] != 0)
-	      {
-		strcpy (temp, pl->prefix);
-		strcat (temp, just_machine_suffix);
-		strcat (temp, name);
-		strcat (temp, file_suffix);
-		if (access (temp, mode) == 0)
-		  {
-		    if (pl->used_flag_ptr != 0)
-		      *pl->used_flag_ptr = 1;
-		    return temp;
-		  }
-	      }
-
-	    strcpy (temp, pl->prefix);
-	    strcat (temp, just_machine_suffix);
-	    strcat (temp, name);
-	    if (access (temp, mode) == 0)
-	      {
-		if (pl->used_flag_ptr != 0)
-		  *pl->used_flag_ptr = 1;
-		return temp;
-	      }
-	  }
-
-	/* Certain prefixes can't be used without the machine suffix
-	   when the machine or version is explicitly specified.  */
-	if (! pl->require_machine_suffix)
-	  {
-	    /* Some systems have a suffix for executable files.
-	       So try appending that first.  */
-	    if (file_suffix[0] != 0)
-	      {
-		strcpy (temp, pl->prefix);
-		strcat (temp, name);
-		strcat (temp, file_suffix);
-		if (access (temp, mode) == 0)
-		  {
-		    if (pl->used_flag_ptr != 0)
-		      *pl->used_flag_ptr = 1;
-		    return temp;
-		  }
-	      }
-
-	    strcpy (temp, pl->prefix);
-	    strcat (temp, name);
-	    if (access (temp, mode) == 0)
-	      {
-		if (pl->used_flag_ptr != 0)
-		  *pl->used_flag_ptr = 1;
-		return temp;
-	      }
-	  }
-      }
-
-  free (temp);
-  return 0;
+    else
+        for (pl = pprefix->plist; pl; pl = pl->next)
+        {
+            if (machine_suffix)
+            {
+                /* Some systems have a suffix for executable files.
+                   So try appending that first.  */
+                if (file_suffix[0] != 0)
+                {
+                    strcpy(temp, pl->prefix);
+                    strcat(temp, machine_suffix);
+                    strcat(temp, name);
+                    strcat(temp, file_suffix);
+                    if (access(temp, mode) == 0)
+                    {
+                        if (pl->used_flag_ptr != 0)
+                            *pl->used_flag_ptr = 1;
+                        return temp;
+                    }
+                }
+
+                /* Now try just the name.  */
+                strcpy(temp, pl->prefix);
+                strcat(temp, machine_suffix);
+                strcat(temp, name);
+                if (access(temp, mode) == 0)
+                {
+                    if (pl->used_flag_ptr != 0)
+                        *pl->used_flag_ptr = 1;
+                    return temp;
+                }
+            }
+
+            /* Certain prefixes are tried with just the machine type,
+               not the version.  This is used for finding as, ld, etc.  */
+            if (just_machine_suffix && pl->require_machine_suffix == 2)
+            {
+                /* Some systems have a suffix for executable files.
+                   So try appending that first.  */
+                if (file_suffix[0] != 0)
+                {
+                    strcpy(temp, pl->prefix);
+                    strcat(temp, just_machine_suffix);
+                    strcat(temp, name);
+                    strcat(temp, file_suffix);
+                    if (access(temp, mode) == 0)
+                    {
+                        if (pl->used_flag_ptr != 0)
+                            *pl->used_flag_ptr = 1;
+                        return temp;
+                    }
+                }
+
+                strcpy(temp, pl->prefix);
+                strcat(temp, just_machine_suffix);
+                strcat(temp, name);
+                if (access(temp, mode) == 0)
+                {
+                    if (pl->used_flag_ptr != 0)
+                        *pl->used_flag_ptr = 1;
+                    return temp;
+                }
+            }
+
+            /* Certain prefixes can't be used without the machine suffix
+               when the machine or version is explicitly specified.  */
+            if (!pl->require_machine_suffix)
+            {
+                /* Some systems have a suffix for executable files.
+                   So try appending that first.  */
+                if (file_suffix[0] != 0)
+                {
+                    strcpy(temp, pl->prefix);
+                    strcat(temp, name);
+                    strcat(temp, file_suffix);
+                    if (access(temp, mode) == 0)
+                    {
+                        if (pl->used_flag_ptr != 0)
+                            *pl->used_flag_ptr = 1;
+                        return temp;
+                    }
+                }
+
+                strcpy(temp, pl->prefix);
+                strcat(temp, name);
+                if (access(temp, mode) == 0)
+                {
+                    if (pl->used_flag_ptr != 0)
+                        *pl->used_flag_ptr = 1;
+                    return temp;
+                }
+            }
+        }
+
+    free(temp);
+    return 0;
 }
 
 /* Add an entry for PREFIX in PLIST.  If FIRST is set, it goes
@@ -1890,74 +1844,67 @@ find_a_file (pprefix, name, mode)
    2 means try both machine_suffix and just_machine_suffix.  */
 
 static void
-add_prefix (pprefix, prefix, component, first, require_machine_suffix, warn)
-     struct path_prefix *pprefix;
-     const char *prefix;
-     const char *component;
-     int first;
-     int require_machine_suffix;
-     int *warn;
+add_prefix(struct path_prefix *pprefix, const char *prefix, const char *component, int first, int require_machine_suffix, int *warn)
 {
-  struct prefix_list *pl, **prev;
-  int len;
+    struct prefix_list *pl, **prev;
+    int len;
 
-  if (! first && pprefix->plist)
+    if (!first && pprefix->plist)
     {
-      for (pl = pprefix->plist; pl->next; pl = pl->next)
-	;
-      prev = &pl->next;
+        for (pl = pprefix->plist; pl->next; pl = pl->next)
+            ;
+        prev = &pl->next;
     }
-  else
-    prev = &pprefix->plist;
-
-  /* Keep track of the longest prefix */
-
-  prefix = update_path (prefix, component);
-  len = strlen (prefix);
-  if (len > pprefix->max_len)
-    pprefix->max_len = len;
-
-  pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
-  pl->prefix = save_string (prefix, len);
-  pl->require_machine_suffix = require_machine_suffix;
-  pl->used_flag_ptr = warn;
-  if (warn)
-    *warn = 0;
-
-  if (*prev)
-    pl->next = *prev;
-  else
-    pl->next = (struct prefix_list *) 0;
-  *prev = pl;
+    else
+        prev = &pprefix->plist;
+
+    /* Keep track of the longest prefix */
+
+    prefix = update_path(prefix, component);
+    len = strlen(prefix);
+    if (len > pprefix->max_len)
+        pprefix->max_len = len;
+
+    pl = (struct prefix_list *) xmalloc(sizeof (struct prefix_list));
+    pl->prefix = save_string(prefix, len);
+    pl->require_machine_suffix = require_machine_suffix;
+    pl->used_flag_ptr = warn;
+    if (warn)
+        *warn = 0;
+
+    if (*prev)
+        pl->next = *prev;
+    else
+        pl->next = (struct prefix_list *) 0;
+    *prev = pl;
 }
 
 /* Print warnings for any prefixes in the list PPREFIX that were not used.  */
 
 static void
-unused_prefix_warnings (pprefix)
-     struct path_prefix *pprefix;
+unused_prefix_warnings(struct path_prefix *pprefix)
 {
-  struct prefix_list *pl = pprefix->plist;
+    struct prefix_list *pl = pprefix->plist;
 
-  while (pl)
+    while (pl)
     {
-      if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
-	{
-	  if (pl->require_machine_suffix && machine_suffix)
-	    error ("file path prefix `%s%s' never used", pl->prefix,
-		   machine_suffix);
-	  else
-	    error ("file path prefix `%s' never used", pl->prefix);
-
-	  /* Prevent duplicate warnings.  */
-	  *pl->used_flag_ptr = 1;
-	}
-
-      pl = pl->next;
+        if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
+        {
+            if (pl->require_machine_suffix && machine_suffix)
+                error("file path prefix `%s%s' never used", pl->prefix,
+                      machine_suffix);
+            else
+                error("file path prefix `%s' never used", pl->prefix);
+
+            /* Prevent duplicate warnings.  */
+            *pl->used_flag_ptr = 1;
+        }
+
+        pl = pl->next;
     }
 }
 
-
+
 /* Execute the command specified by the arguments on the current line of spec.
    When using pipes, this includes several piped-together commands
    with `|' between them.
@@ -1965,157 +1912,157 @@ unused_prefix_warnings (pprefix)
    Return 0 if successful, -1 if failed.  */
 
 static int
-execute ()
+execute()
 {
-  int i;
-  int n_commands;		/* # of command.  */
-  char *string;
-  struct command
+    int i;
+    int n_commands;             /* # of command.  */
+    char *string;
+    struct command
     {
-      char *prog;		/* program name.  */
-      char **argv;		/* vector of args.  */
-      int pid;			/* pid of process for this command.  */
+        char *prog;             /* program name.  */
+        char **argv;            /* vector of args.  */
+        int pid;                /* pid of process for this command.  */
     };
 
-  struct command *commands;	/* each command buffer with above info.  */
+    struct command *commands;   /* each command buffer with above info.  */
 
-  /* Count # of piped commands.  */
-  for (n_commands = 1, i = 0; i < argbuf_index; i++)
-    if (strcmp (argbuf[i], "|") == 0)
-      n_commands++;
+    /* Count # of piped commands.  */
+    for (n_commands = 1, i = 0; i < argbuf_index; i++)
+        if (strcmp(argbuf[i], "|") == 0)
+            n_commands++;
 
-  /* Get storage for each command.  */
-  commands
-    = (struct command *) alloca (n_commands * sizeof (struct command));
+    /* Get storage for each command.  */
+    commands
+        = (struct command *) alloca(n_commands * sizeof (struct command));
 
-  /* Split argbuf into its separate piped processes,
-     and record info about each one.
-     Also search for the programs that are to be run.  */
+    /* Split argbuf into its separate piped processes,
+       and record info about each one.
+       Also search for the programs that are to be run.  */
 
-  commands[0].prog = argbuf[0]; /* first command.  */
-  commands[0].argv = &argbuf[0];
-  string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
+    commands[0].prog = argbuf[0]; /* first command.  */
+    commands[0].argv = &argbuf[0];
+    string = find_a_file(&exec_prefixes, commands[0].prog, X_OK);
 
-  if (string)
-    commands[0].argv[0] = string;
+    if (string)
+        commands[0].argv[0] = string;
 
-  for (n_commands = 1, i = 0; i < argbuf_index; i++)
-    if (strcmp (argbuf[i], "|") == 0)
-      {				/* each command.  */
-	argbuf[i] = 0;	/* termination of command args.  */
-	commands[n_commands].prog = argbuf[i + 1];
-	commands[n_commands].argv = &argbuf[i + 1];
-	string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
-	if (string)
-	  commands[n_commands].argv[0] = string;
-	n_commands++;
-      }
+    for (n_commands = 1, i = 0; i < argbuf_index; i++)
+        if (strcmp(argbuf[i], "|") == 0)
+        {                       /* each command.  */
+            argbuf[i] = 0; /* termination of command args.  */
+            commands[n_commands].prog = argbuf[i + 1];
+            commands[n_commands].argv = &argbuf[i + 1];
+            string = find_a_file(&exec_prefixes, commands[n_commands].prog, X_OK);
+            if (string)
+                commands[n_commands].argv[0] = string;
+            n_commands++;
+        }
 
-  argbuf[argbuf_index] = 0;
+    argbuf[argbuf_index] = 0;
 
-  /* If -v, print what we are about to do, and maybe query.  */
+    /* If -v, print what we are about to do, and maybe query.  */
 
-  if (verbose_flag)
+    if (verbose_flag)
     {
-      /* For help listings, put a blank line between sub-processes.  */
-      if (print_help_list)
-	fputc ('\n', stderr);
-      
-      /* Print each piped command as a separate line.  */
-      for (i = 0; i < n_commands ; i++)
-	{
-	  char **j;
-
-	  for (j = commands[i].argv; *j; j++)
-	    fprintf (stderr, " %s", *j);
-
-	  /* Print a pipe symbol after all but the last command.  */
-	  if (i + 1 != n_commands)
-	    fprintf (stderr, " |");
-	  fprintf (stderr, "\n");
-	}
-      fflush (stderr);
+        /* For help listings, put a blank line between sub-processes.  */
+        if (print_help_list)
+            fputc('\n', stderr);
+
+        /* Print each piped command as a separate line.  */
+        for (i = 0; i < n_commands; i++)
+        {
+            char **j;
+
+            for (j = commands[i].argv; *j; j++)
+                fprintf(stderr, " %s", *j);
+
+            /* Print a pipe symbol after all but the last command.  */
+            if (i + 1 != n_commands)
+                fprintf(stderr, " |");
+            fprintf(stderr, "\n");
+        }
+        fflush(stderr);
 #ifdef DEBUG
-      fprintf (stderr, "\nGo ahead? (y or n) ");
-      fflush (stderr);
-      i = getchar ();
-      if (i != '\n')
-	while (getchar () != '\n')
-	  ;
-
-      if (i != 'y' && i != 'Y')
-	return 0;
+        fprintf(stderr, "\nGo ahead? (y or n) ");
+        fflush(stderr);
+        i = getchar();
+        if (i != '\n')
+            while (getchar() != '\n')
+                ;
+
+        if (i != 'y' && i != 'Y')
+            return 0;
 #endif /* DEBUG */
     }
 
-  /* Run each piped subprocess.  */
+    /* Run each piped subprocess.  */
 
-  for (i = 0; i < n_commands; i++)
+    for (i = 0; i < n_commands; i++)
     {
-      char *errmsg_fmt, *errmsg_arg;
-      char *string = commands[i].argv[0];
-
-      commands[i].pid = pexecute (string, commands[i].argv,
-				  programname, temp_filename,
-				  &errmsg_fmt, &errmsg_arg,
-				  ((i == 0 ? PEXECUTE_FIRST : 0)
-				   | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
-				   | (string == commands[i].prog
-				      ? PEXECUTE_SEARCH : 0)
-				   | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
-
-      if (commands[i].pid == -1)
-	pfatal_pexecute (errmsg_fmt, errmsg_arg);
-
-      if (string != commands[i].prog)
-	free (string);
+        char *errmsg_fmt, *errmsg_arg;
+        char *string = commands[i].argv[0];
+
+        commands[i].pid = pexecute(string, commands[i].argv,
+                                   programname, temp_filename,
+                                   &errmsg_fmt, &errmsg_arg,
+                                   ((i == 0 ? PEXECUTE_FIRST : 0)
+                                    | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
+                                    | (string == commands[i].prog
+                                       ? PEXECUTE_SEARCH : 0)
+                                    | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
+
+        if (commands[i].pid == -1)
+            pfatal_pexecute(errmsg_fmt, errmsg_arg);
+
+        if (string != commands[i].prog)
+            free(string);
     }
 
-  execution_count++;
-
-  /* Wait for all the subprocesses to finish.
-     We don't care what order they finish in;
-     we know that N_COMMANDS waits will get them all.
-     Ignore subprocesses that we don't know about,
-     since they can be spawned by the process that exec'ed us.  */
-
-  {
-    int ret_code = 0;
-
-    for (i = 0; i < n_commands; )
-      {
-	int j;
-	int status;
-	int pid;
-
-	pid = pwait (commands[i].pid, &status, 0);
-	if (pid < 0)
-	  abort ();
-
-	for (j = 0; j < n_commands; j++)
-	  if (commands[j].pid == pid)
-	    {
-	      i++;
-	      if (status != 0)
-		{
-		  if (WIFSIGNALED (status))
-		    {
-		      fatal ("Internal compiler error: program %s got fatal signal %d",
-			     commands[j].prog, WTERMSIG (status));
-		      signal_count++;
-		      ret_code = -1;
-		    }
-		  else if (WIFEXITED (status)
-			   && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
-		    ret_code = -1;
-		}
-	      break;
-	    }
-      }
-    return ret_code;
-  }
+    execution_count++;
+
+    /* Wait for all the subprocesses to finish.
+       We don't care what order they finish in;
+       we know that N_COMMANDS waits will get them all.
+       Ignore subprocesses that we don't know about,
+       since they can be spawned by the process that exec'ed us.  */
+
+    {
+        int ret_code = 0;
+
+        for (i = 0; i < n_commands; )
+        {
+            int j;
+            int status;
+            int pid;
+
+            pid = pwait(commands[i].pid, &status, 0);
+            if (pid < 0)
+                abort();
+
+            for (j = 0; j < n_commands; j++)
+                if (commands[j].pid == pid)
+                {
+                    i++;
+                    if (status != 0)
+                    {
+                        if (WIFSIGNALED(status))
+                        {
+                            fatal("Internal compiler error: program %s got fatal signal %d",
+                                  commands[j].prog, WTERMSIG(status));
+                            signal_count++;
+                            ret_code = -1;
+                        }
+                        else if (WIFEXITED(status)
+                                 && WEXITSTATUS(status) >= MIN_FATAL_STATUS)
+                            ret_code = -1;
+                    }
+                    break;
+                }
+        }
+        return ret_code;
+    }
 }
-
+
 /* Find all the switches given to us
    and make a vector describing them.
    The elements of the vector are strings, one per switch given.
@@ -2129,10 +2076,10 @@ execute ()
 
 struct switchstr
 {
-  char *part1;
-  char **args;
-  int live_cond;
-  int valid;
+    char *part1;
+    char **args;
+    int live_cond;
+    int valid;
 };
 
 static struct switchstr *switches;
@@ -2141,8 +2088,8 @@ static int n_switches;
 
 struct infile
 {
-  char *name;
-  char *language;
+    char *name;
+    char *language;
 };
 
 /* Also a vector of input files specified.  */
@@ -2169,858 +2116,661 @@ static int warn_std;
 /* Gives value to pass as "warn" to add_prefix for standard prefixes.  */
 static int *warn_std_ptr = 0;
 
-
-#if defined(HAVE_OBJECT_SUFFIX) || defined(HAVE_EXECUTABLE_SUFFIX)
-
-/* Convert NAME to a new name if it is the standard suffix.  DO_EXE
-   is true if we should look for an executable suffix as well.  */
+/* Display the command line switches accepted by gcc.  */
+static void
+display_help()
+{
+    printf("Usage: %s [options] file...\n", programname);
+    printf("Options:\n");
+
+    printf("  --help                   Display this information\n");
+    if (!verbose_flag)
+        printf("  (Use '-v --help' to display command line options of sub-processes)\n");
+    printf("  -dumpspecs               Display all of the built in spec strings\n");
+    printf("  -dumpversion             Display the version of the compiler\n");
+    printf("  -dumpmachine             Display the compiler's target processor\n");
+    printf("  -print-search-dirs       Display the directories in the compiler's search path\n");
+    printf("  -print-libgcc-file-name  Display the name of the compiler's companion library\n");
+    printf("  -print-file-name=<lib>   Display the full path to library <lib>\n");
+    printf("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n");
+    printf("  -print-multi-directory   Display the root directory for versions of libgcc\n");
+    printf("  -print-multi-lib         Display the mapping between command line options and\n");
+    printf("                            multiple library search directories\n");
+    printf("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n");
+    printf("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n");
+    printf("  -Wl,<options>            Pass comma-separated <options> on to the linker\n");
+    printf("  -Xlinker <arg>           Pass <arg> on to the linker\n");
+    printf("  -save-temps              Do not delete intermediate files\n");
+    printf("  -pipe                    Use pipes rather than intermediate files\n");
+    printf("  -specs=<file>            Override builtin specs with the contents of <file>\n");
+    printf("  -std=<standard>          Assume that the input sources are for <standard>\n");
+    printf("  -B <directory>           Add <directory> to the compiler's search paths\n");
+    printf("  -b <machine>             Run gcc for target <machine>, if installed\n");
+    printf("  -V <version>             Run gcc version number <version>, if installed\n");
+    printf("  -v                       Display the programs invoked by the compiler\n");
+    printf("  -E                       Preprocess only; do not compile, assemble or link\n");
+    printf("  -S                       Compile only; do not assemble or link\n");
+    printf("  -c                       Compile and assemble, but do not link\n");
+    printf("  -o <file>                Place the output into <file>\n");
+    printf("  -x <language>            Specify the language of the following input files\n");
+    printf("                            Permissable languages include: c c++ assembler none\n");
+    printf("                            'none' means revert to the default behaviour of\n");
+    printf("                            guessing the language based on the file's extension\n");
+
+    printf("\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n");
+    printf("the various sub-processes invoked by %s.  In order to pass other options\n",
+           programname);
+    printf("on to these processes the -W<letter> options must be used.\n");
+
+    /* The rest of the options are displayed by invocations of the various
+       sub-processes.  */
+}
 
-static char *
-convert_filename (name, do_exe)
-     char *name;
-     int do_exe;
+static void
+add_preprocessor_option(char *option, int len)
 {
-  int i;
-  int len = strlen (name);
-
-#ifdef HAVE_OBJECT_SUFFIX
-  /* Convert x.o to x.obj if OBJECT_SUFFIX is ".obj".  */
-  if (len > 2
-      && name[len - 2] == '.'
-      && name[len - 1] == 'o')
-    {
-      obstack_grow (&obstack, name, len - 2);
-      obstack_grow0 (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
-      name = obstack_finish (&obstack);
-    }
-#endif
+    n_preprocessor_options++;
 
-#ifdef HAVE_EXECUTABLE_SUFFIX
-  /* If there is no filetype, make it the executable suffix (which includes
-     the ".").  But don't get confused if we have just "-o".  */
-  if (! do_exe || EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
-    return name;
+    if (!preprocessor_options)
+        preprocessor_options
+            = (char **) xmalloc(n_preprocessor_options * sizeof (char *));
+    else
+        preprocessor_options
+            = (char **) xrealloc(preprocessor_options,
+                                 n_preprocessor_options * sizeof (char *));
 
-  for (i = len - 1; i >= 0; i--)
-    if (name[i] == '/' || name[i] == DIR_SEPARATOR)
-      break;
+    preprocessor_options [n_preprocessor_options - 1] = save_string(option, len);
+}
 
-  for (i++; i < len; i++)
-    if (name[i] == '.')
-      return name;
+static void
+add_assembler_option(char *option, int len)
+{
+    n_assembler_options++;
 
-  obstack_grow (&obstack, name, len);
-  obstack_grow0 (&obstack, EXECUTABLE_SUFFIX, strlen (EXECUTABLE_SUFFIX));
-  name = obstack_finish (&obstack);
-#endif
+    if (!assembler_options)
+        assembler_options
+            = (char **) xmalloc(n_assembler_options * sizeof (char *));
+    else
+        assembler_options
+            = (char **) xrealloc(assembler_options,
+                                 n_assembler_options * sizeof (char *));
 
-  return name;
+    assembler_options [n_assembler_options - 1] = save_string(option, len);
 }
-#endif
-
-/* Display the command line switches accepted by gcc.  */
+
 static void
-display_help ()
+add_linker_option(char *option, int len)
 {
-  printf ("Usage: %s [options] file...\n", programname);
-  printf ("Options:\n");
-
-  printf ("  --help                   Display this information\n");
-  if (! verbose_flag)
-    printf ("  (Use '-v --help' to display command line options of sub-processes)\n");
-  printf ("  -dumpspecs               Display all of the built in spec strings\n");
-  printf ("  -dumpversion             Display the version of the compiler\n");
-  printf ("  -dumpmachine             Display the compiler's target processor\n");
-  printf ("  -print-search-dirs       Display the directories in the compiler's search path\n");
-  printf ("  -print-libgcc-file-name  Display the name of the compiler's companion library\n");
-  printf ("  -print-file-name=<lib>   Display the full path to library <lib>\n");
-  printf ("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n");
-  printf ("  -print-multi-directory   Display the root directory for versions of libgcc\n");
-  printf ("  -print-multi-lib         Display the mapping between command line options and\n");
-  printf ("                            multiple library search directories\n");
-  printf ("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n");
-  printf ("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n");
-  printf ("  -Wl,<options>            Pass comma-separated <options> on to the linker\n");
-  printf ("  -Xlinker <arg>           Pass <arg> on to the linker\n");
-  printf ("  -save-temps              Do not delete intermediate files\n");
-  printf ("  -pipe                    Use pipes rather than intermediate files\n");
-  printf ("  -specs=<file>            Override builtin specs with the contents of <file>\n");
-  printf ("  -std=<standard>          Assume that the input sources are for <standard>\n");
-  printf ("  -B <directory>           Add <directory> to the compiler's search paths\n");
-  printf ("  -b <machine>             Run gcc for target <machine>, if installed\n");
-  printf ("  -V <version>             Run gcc version number <version>, if installed\n");
-  printf ("  -v                       Display the programs invoked by the compiler\n");
-  printf ("  -E                       Preprocess only; do not compile, assemble or link\n");
-  printf ("  -S                       Compile only; do not assemble or link\n");
-  printf ("  -c                       Compile and assemble, but do not link\n");
-  printf ("  -o <file>                Place the output into <file>\n");
-  printf ("  -x <language>            Specify the language of the following input files\n");
-  printf ("                            Permissable languages include: c c++ assembler none\n");
-  printf ("                            'none' means revert to the default behaviour of\n");
-  printf ("                            guessing the language based on the file's extension\n");
-
-  printf ("\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n");
-  printf ("the various sub-processes invoked by %s.  In order to pass other options\n",
-	  programname);
-  printf ("on to these processes the -W<letter> options must be used.\n");
-
-  /* The rest of the options are displayed by invocations of the various
-     sub-processes.  */
-}
+    n_linker_options++;
 
-static void 								
-add_preprocessor_option (option, len)					
-     char * option;							
-     int    len;							
-{									
-  n_preprocessor_options++;							
-									
-  if (! preprocessor_options)						
-    preprocessor_options							
-      = (char **) xmalloc (n_preprocessor_options * sizeof (char *));	
-  else									
-    preprocessor_options							
-      = (char **) xrealloc (preprocessor_options,				
-			    n_preprocessor_options * sizeof (char *));	
-  									
-  preprocessor_options [n_preprocessor_options - 1] = save_string (option, len);  
-}
-     
-static void 								
-add_assembler_option (option, len)					
-     char * option;							
-     int    len;							
-{									
-  n_assembler_options++;							
-									
-  if (! assembler_options)						
-    assembler_options							
-      = (char **) xmalloc (n_assembler_options * sizeof (char *));	
-  else									
-    assembler_options							
-      = (char **) xrealloc (assembler_options,				
-			    n_assembler_options * sizeof (char *));	
-  									
-  assembler_options [n_assembler_options - 1] = save_string (option, len);  
-}
-     
-static void 								
-add_linker_option (option, len)					
-     char * option;							
-     int    len;							
-{									
-  n_linker_options++;							
-									
-  if (! linker_options)						
-    linker_options							
-      = (char **) xmalloc (n_linker_options * sizeof (char *));	
-  else									
-    linker_options							
-      = (char **) xrealloc (linker_options,				
-			    n_linker_options * sizeof (char *));	
-  									
-  linker_options [n_linker_options - 1] = save_string (option, len);  
+    if (!linker_options)
+        linker_options
+            = (char **) xmalloc(n_linker_options * sizeof (char *));
+    else
+        linker_options
+            = (char **) xrealloc(linker_options,
+                                 n_linker_options * sizeof (char *));
+
+    linker_options [n_linker_options - 1] = save_string(option, len);
 }
-
+
 /* Create the vector `switches' and its contents.
    Store its length in `n_switches'.  */
 
 static void
-process_command (argc, argv)
-     int argc;
-     char **argv;
+process_command(int argc, char **argv)
 {
-  register int i;
-  char *temp;
-  char *spec_lang = 0;
-  int last_language_n_infiles;
-  int have_c = 0;
-  int have_o = 0;
-  int lang_n_infiles = 0;
-
-  n_switches = 0;
-  n_infiles = 0;
-  added_libraries = 0;
-
-  /* Figure compiler version from version string.  */
-
-  compiler_version = save_string (version_string, strlen (version_string));
-  for (temp = compiler_version; *temp; ++temp)
+    register int i;
+    char *temp;
+    char *spec_lang = 0;
+    int last_language_n_infiles;
+    int have_c = 0;
+    int have_o = 0;
+    int lang_n_infiles = 0;
+
+    n_switches = 0;
+    n_infiles = 0;
+    added_libraries = 0;
+
+    /* Figure compiler version from version string.  */
+
+    compiler_version = save_string(version_string, strlen(version_string));
+    for (temp = compiler_version; *temp; ++temp)
     {
-      if (*temp == ' ')
-	{
-	  *temp = '\0';
-	  break;
-	}
+        if (*temp == ' ')
+        {
+            *temp = '\0';
+            break;
+        }
     }
 
-  /* COMPILER_PATH and LIBRARY_PATH have values
-     that are lists of directory names with colons.  */
+    /* Convert new-style -- options to old-style.  */
+    translate_options(&argc, &argv);
 
-  GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
-  if (temp)
-    {
-      char *startp, *endp;
-      char *nstore = (char *) alloca (strlen (temp) + 3);
-
-      startp = endp = temp;
-      while (1)
-	{
-	  if (*endp == PATH_SEPARATOR || *endp == 0)
-	    {
-	      strncpy (nstore, startp, endp-startp);
-	      if (endp == startp)
-		strcpy (nstore, concat (".", dir_separator_str, NULL));
-	      else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
-		{
-		  nstore[endp-startp] = DIR_SEPARATOR;
-		  nstore[endp-startp+1] = 0;
-		}
-	      else
-		nstore[endp-startp] = 0;
-	      add_prefix (&exec_prefixes, nstore, 0, 0, 0, NULL);
-	      add_prefix (&include_prefixes,
-			  concat (nstore, "include", NULL),
-			  0, 0, 0, NULL);
-	      if (*endp == 0)
-		break;
-	      endp = startp = endp + 1;
-	    }
-	  else
-	    endp++;
-	}
-    }
 
-  GET_ENV_PATH_LIST (temp, "LIBRARY_PATH");
-  if (temp && *cross_compile == '0')
-    {
-      char *startp, *endp;
-      char *nstore = (char *) alloca (strlen (temp) + 3);
-
-      startp = endp = temp;
-      while (1)
-	{
-	  if (*endp == PATH_SEPARATOR || *endp == 0)
-	    {
-	      strncpy (nstore, startp, endp-startp);
-	      if (endp == startp)
-		strcpy (nstore, concat (".", dir_separator_str, NULL));
-	      else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
-		{
-		  nstore[endp-startp] = DIR_SEPARATOR;
-		  nstore[endp-startp+1] = 0;
-		}
-	      else
-		nstore[endp-startp] = 0;
-	      add_prefix (&startfile_prefixes, nstore, NULL,
-			  0, 0, NULL);
-	      if (*endp == 0)
-		break;
-	      endp = startp = endp + 1;
-	    }
-	  else
-	    endp++;
-	}
-    }
+    /* Scan argv twice.  Here, the first time, just count how many switches
+       there will be in their vector, and how many input files in theirs.
+       Here we also parse the switches that cc itself uses (e.g. -v).  */
 
-  /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
-  GET_ENV_PATH_LIST (temp, "LPATH");
-  if (temp && *cross_compile == '0')
+    for (i = 1; i < argc; i++)
     {
-      char *startp, *endp;
-      char *nstore = (char *) alloca (strlen (temp) + 3);
-
-      startp = endp = temp;
-      while (1)
-	{
-	  if (*endp == PATH_SEPARATOR || *endp == 0)
-	    {
-	      strncpy (nstore, startp, endp-startp);
-	      if (endp == startp)
-		strcpy (nstore, concat (".", dir_separator_str, NULL));
-	      else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
-		{
-		  nstore[endp-startp] = DIR_SEPARATOR;
-		  nstore[endp-startp+1] = 0;
-		}
-	      else
-		nstore[endp-startp] = 0;
-	      add_prefix (&startfile_prefixes, nstore, NULL,
-			  0, 0, NULL);
-	      if (*endp == 0)
-		break;
-	      endp = startp = endp + 1;
-	    }
-	  else
-	    endp++;
-	}
-    }
+        if (!strcmp(argv[i], "-dumpspecs"))
+        {
+            struct spec_list *sl;
+            init_spec();
+            for (sl = specs; sl; sl = sl->next)
+                printf("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
+            exit(0);
+        }
+        else if (!strcmp(argv[i], "-dumpversion"))
+        {
+            printf("%s\n", spec_version);
+            exit(0);
+        }
+        else if (!strcmp(argv[i], "-dumpmachine"))
+        {
+            printf("%s\n", spec_machine);
+            exit(0);
+        }
+        else if (strcmp(argv[i], "-fhelp") == 0)
+        {
+            /* translate_options () has turned --help into -fhelp.  */
+            print_help_list = 1;
+
+            /* We will be passing a dummy file on to the sub-processes.  */
+            n_infiles++;
+            n_switches++;
+
+            add_preprocessor_option("--help", 6);
+            add_assembler_option("--help", 6);
+            add_linker_option("--help", 6);
+        }
+        else if (!strcmp(argv[i], "-print-search-dirs"))
+            print_search_dirs = 1;
+        else if (!strcmp(argv[i], "-print-libgcc-file-name"))
+            print_file_name = "libgcc.a";
+        else if (!strncmp(argv[i], "-print-file-name=", 17))
+            print_file_name = argv[i] + 17;
+        else if (!strncmp(argv[i], "-print-prog-name=", 17))
+            print_prog_name = argv[i] + 17;
+        else if (!strcmp(argv[i], "-print-multi-lib"))
+            print_multi_lib = 1;
+        else if (!strcmp(argv[i], "-print-multi-directory"))
+            print_multi_directory = 1;
+        else if (!strncmp(argv[i], "-Wa,", 4))
+        {
+            int prev, j;
+            /* Pass the rest of this option to the assembler.  */
 
-  /* Convert new-style -- options to old-style.  */
-  translate_options (&argc, &argv);
+            /* Split the argument at commas.  */
+            prev = 4;
+            for (j = 4; argv[i][j]; j++)
+            {
+                if (argv[i][j] == ',')
+                {
+                    add_assembler_option(argv[i] + prev, j - prev);
+                    prev = j + 1;
+                }
+            }
 
+            /* Record the part after the last comma.  */
+            add_assembler_option(argv[i] + prev, j - prev);
+        }
+        else if (!strncmp(argv[i], "-Wp,", 4))
+        {
+            int prev, j;
+            /* Pass the rest of this option to the preprocessor.  */
 
-  /* Scan argv twice.  Here, the first time, just count how many switches
-     there will be in their vector, and how many input files in theirs.
-     Here we also parse the switches that cc itself uses (e.g. -v).  */
+            /* Split the argument at commas.  */
+            prev = 4;
+            for (j = 4; argv[i][j]; j++)
+            {
+                if (argv[i][j] == ',')
+                {
+                    add_preprocessor_option(argv[i] + prev, j - prev);
+                    prev = j + 1;
+                }
+            }
 
-  for (i = 1; i < argc; i++)
-    {
-      if (! strcmp (argv[i], "-dumpspecs"))
-	{
-	  struct spec_list *sl;
-	  init_spec ();
-	  for (sl = specs; sl; sl = sl->next)
-	    printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
-	  exit (0);
-	}
-      else if (! strcmp (argv[i], "-dumpversion"))
-	{
-	  printf ("%s\n", spec_version);
-	  exit (0);
-	}
-      else if (! strcmp (argv[i], "-dumpmachine"))
-	{
-	  printf ("%s\n", spec_machine);
-	  exit  (0);
-	}
-      else if (strcmp (argv[i], "-fhelp") == 0)
-	{
-	  /* translate_options () has turned --help into -fhelp.  */
-	  print_help_list = 1;
-
-	  /* We will be passing a dummy file on to the sub-processes.  */
-	  n_infiles++;
-	  n_switches++;
-	  
-	  add_preprocessor_option ("--help", 6);
-	  add_assembler_option ("--help", 6);
-	  add_linker_option ("--help", 6);
-	}
-      else if (! strcmp (argv[i], "-print-search-dirs"))
-	print_search_dirs = 1;
-      else if (! strcmp (argv[i], "-print-libgcc-file-name"))
-	print_file_name = "libgcc.a";
-      else if (! strncmp (argv[i], "-print-file-name=", 17))
-	print_file_name = argv[i] + 17;
-      else if (! strncmp (argv[i], "-print-prog-name=", 17))
-	print_prog_name = argv[i] + 17;
-      else if (! strcmp (argv[i], "-print-multi-lib"))
-	print_multi_lib = 1;
-      else if (! strcmp (argv[i], "-print-multi-directory"))
-	print_multi_directory = 1;
-      else if (! strncmp (argv[i], "-Wa,", 4))
-	{
-	  int prev, j;
-	  /* Pass the rest of this option to the assembler.  */
-
-	  /* Split the argument at commas.  */
-	  prev = 4;
-	  for (j = 4; argv[i][j]; j++)
-	    if (argv[i][j] == ',')
-	      {
-		add_assembler_option (argv[i] + prev, j - prev);
-		prev = j + 1;
-	      }
-	  
-	  /* Record the part after the last comma.  */
-	  add_assembler_option (argv[i] + prev, j - prev);
-	}
-      else if (! strncmp (argv[i], "-Wp,", 4))
-	{
-	  int prev, j;
-	  /* Pass the rest of this option to the preprocessor.  */
-
-	  /* Split the argument at commas.  */
-	  prev = 4;
-	  for (j = 4; argv[i][j]; j++)
-	    if (argv[i][j] == ',')
-	      {
-		add_preprocessor_option (argv[i] + prev, j - prev);
-		prev = j + 1;
-	      }
-	  
-	  /* Record the part after the last comma.  */
-	  add_preprocessor_option (argv[i] + prev, j - prev);
-	}
-      else if (argv[i][0] == '+' && argv[i][1] == 'e')
-	/* The +e options to the C++ front-end.  */
-	n_switches++;
-      else if (strncmp (argv[i], "-Wl,", 4) == 0)
-	{
-	  int j;
-	  /* Split the argument at commas.  */
-	  for (j = 3; argv[i][j]; j++)
-	    n_infiles += (argv[i][j] == ',');
-	}
-      else if (strcmp (argv[i], "-Xlinker") == 0)
-	{
-	  if (i + 1 == argc)
-	    fatal ("argument to `-Xlinker' is missing");
-
-	  n_infiles++;
-	  i++;
-	}
-      else if (strncmp (argv[i], "-l", 2) == 0)
-	n_infiles++;
-      else if (strcmp (argv[i], "-save-temps") == 0)
-	{
-	  save_temps_flag = 1;
-	  n_switches++;
-	}
-      else if (strcmp (argv[i], "-specs") == 0)
-	{
-	  struct user_specs *user = (struct user_specs *)
-	    xmalloc (sizeof (struct user_specs));
-	  if (++i >= argc)
-	    fatal ("argument to `-specs' is missing");
-
-	  user->next = (struct user_specs *)0;
-	  user->filename = argv[i];
-	  if (user_specs_tail)
-	    user_specs_tail->next = user;
-	  else
-	    user_specs_head = user;
-	  user_specs_tail = user;
-	}
-      else if (strncmp (argv[i], "-specs=", 7) == 0)
-	{
-	  struct user_specs *user = (struct user_specs *)
-	    xmalloc (sizeof (struct user_specs));
-	  if (strlen (argv[i]) == 7)
-	    fatal ("argument to `-specs=' is missing");
-
-	  user->next = (struct user_specs *)0;
-	  user->filename = argv[i]+7;
-	  if (user_specs_tail)
-	    user_specs_tail->next = user;
-	  else
-	    user_specs_head = user;
-	  user_specs_tail = user;
-	}
-      else if (argv[i][0] == '-' && argv[i][1] != 0)
-	{
-	  register char *p = &argv[i][1];
-	  register int c = *p;
-
-	  switch (c)
-	    {
-	    case 'b':
-              n_switches++;
-	      if (p[1] == 0 && i + 1 == argc)
-		fatal ("argument to `-b' is missing");
-	      if (p[1] == 0)
-		spec_machine = argv[++i];
-	      else
-		spec_machine = p + 1;
-
-	      warn_std_ptr = &warn_std;
-	      break;
-
-	    case 'B':
-	      {
-		char *value;
-		if (p[1] == 0 && i + 1 == argc)
-		  fatal ("argument to `-B' is missing");
-		if (p[1] == 0)
-		  value = argv[++i];
-		else
-		  value = p + 1;
-		add_prefix (&exec_prefixes, value, NULL, 1, 0, &warn_B);
-		add_prefix (&startfile_prefixes, value, NULL,
-			    1, 0, &warn_B);
-		add_prefix (&include_prefixes, concat (value, "include",
-						       NULL),
-			    NULL, 1, 0, NULL);
-
-		/* As a kludge, if the arg is "[foo/]stageN/", just add
-		   "[foo/]include" to the include prefix.  */
-		{
-		  int len = strlen (value);
-		  if ((len == 7
-		       || (len > 7
-			   && (value[len - 8] == '/'
-			       || value[len - 8] == DIR_SEPARATOR)))
-		      && strncmp (value + len - 7, "stage", 5) == 0
-		      && ISDIGIT (value[len - 2])
-		      && (value[len - 1] == '/'
-			  || value[len - 1] == DIR_SEPARATOR))
-		    {
-		      if (len == 7)
-			add_prefix (&include_prefixes, "include", NULL,
-				    1, 0, NULL);
-		      else
-			{
-			  char *string = xmalloc (len + 1);
-			  strncpy (string, value, len-7);
-			  strcpy (string+len-7, "include");
-			  add_prefix (&include_prefixes, string, NULL,
-				      1, 0, NULL);
-			}
-		    }
-		}
+            /* Record the part after the last comma.  */
+            add_preprocessor_option(argv[i] + prev, j - prev);
+        }
+        else if (strncmp(argv[i], "-Wl,", 4) == 0)
+        {
+            int j;
+            /* Split the argument at commas.  */
+            for (j = 3; argv[i][j]; j++)
+                n_infiles += (argv[i][j] == ',');
+        }
+        else if (strcmp(argv[i], "-Xlinker") == 0)
+        {
+            if (i + 1 == argc)
+                fatal("argument to `-Xlinker' is missing");
+
+            n_infiles++;
+            i++;
+        }
+        else if (strncmp(argv[i], "-l", 2) == 0)
+            n_infiles++;
+        else if (strcmp(argv[i], "-save-temps") == 0)
+        {
+            save_temps_flag = 1;
+            n_switches++;
+        }
+        else if (strcmp(argv[i], "-specs") == 0)
+        {
+            struct user_specs *user = (struct user_specs *)
+                                      xmalloc(sizeof (struct user_specs));
+            if (++i >= argc)
+                fatal("argument to `-specs' is missing");
+
+            user->next = (struct user_specs *)0;
+            user->filename = argv[i];
+            if (user_specs_tail)
+                user_specs_tail->next = user;
+            else
+                user_specs_head = user;
+            user_specs_tail = user;
+        }
+        else if (strncmp(argv[i], "-specs=", 7) == 0)
+        {
+            struct user_specs *user = (struct user_specs *)
+                                      xmalloc(sizeof (struct user_specs));
+            if (strlen(argv[i]) == 7)
+                fatal("argument to `-specs=' is missing");
+
+            user->next = (struct user_specs *)0;
+            user->filename = argv[i]+7;
+            if (user_specs_tail)
+                user_specs_tail->next = user;
+            else
+                user_specs_head = user;
+            user_specs_tail = user;
+        }
+        else if (argv[i][0] == '-' && argv[i][1] != 0)
+        {
+            register char *p = &argv[i][1];
+            register int c = *p;
+
+            switch (c)
+            {
+            case 'b':
                 n_switches++;
-	      }
-	      break;
-
-	    case 'v':	/* Print our subcommands and print versions.  */
-	      n_switches++;
-	      /* If they do anything other than exactly `-v', don't set
-		 verbose_flag; rather, continue on to give the error.  */
-	      if (p[1] != 0)
-		break;
-	      verbose_flag++;
-	      break;
-
-	    case 'V':
-	      n_switches++;
-	      if (p[1] == 0 && i + 1 == argc)
-		fatal ("argument to `-V' is missing");
-	      if (p[1] == 0)
-		spec_version = argv[++i];
-	      else
-		spec_version = p + 1;
-	      compiler_version = spec_version;
-	      warn_std_ptr = &warn_std;
-
-	      /* Validate the version number.  Use the same checks
-		 done when inserting it into a spec.
-
-		 The format of the version string is
-		 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
-	      {
-		char *v = compiler_version;
-
-		/* Ignore leading non-digits.  i.e. "foo-" in "foo-2.7.2".  */
-		while (! ISDIGIT (*v))
-		  v++;
-
-		if (v > compiler_version && v[-1] != '-')
-		  fatal ("invalid version number format");
-
-		/* Set V after the first period.  */
-		while (ISDIGIT (*v))
-		  v++;
-
-		if (*v != '.')
-		  fatal ("invalid version number format");
-
-		v++;
-		while (ISDIGIT (*v))
-		  v++;
-
-		if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
-		  fatal ("invalid version number format");
-	      }
-	      break;
-
-	    case 'S':
-	    case 'c':
-	      if (p[1] == 0)
-		{
-		  have_c = 1;
-		  n_switches++;
-		  break;
-		}
-	      goto normal_switch;
-
-	    case 'o':
-	      have_o = 1;
-#if defined(HAVE_EXECUTABLE_SUFFIX)
-	      if (! have_c)
-		{
-		  int skip;
-		  
-		  /* Forward scan, just in case -S or -c is specified
-		     after -o.  */
-		  int j = i + 1;
-		  if (p[1] == 0)
-		    ++j;
-		  while (j < argc)
-		    {
-		      if (argv[j][0] == '-')
-			{
-			  if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
-			      && argv[j][2] == 0)
-			    {
-			      have_c = 1;
-			      break;
-			    }
-			  else if (skip = SWITCH_TAKES_ARG (argv[j][1]))
-			    j += skip - (argv[j][2] != 0);
-			  else if (skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))
-			    j += skip;
-			}
-		      j++;
-		    }
-		}
-#endif
-#if defined(HAVE_EXECUTABLE_SUFFIX) || defined(HAVE_OBJECT_SUFFIX)
-	      if (p[1] == 0)
-		argv[i+1] = convert_filename (argv[i+1], ! have_c);
-	      else
-		argv[i] = convert_filename (argv[i], ! have_c);
-#endif
-	      goto normal_switch;
-
-	    default:
-	    normal_switch:
-	      n_switches++;
-
-	      if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
-		i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
-	      else if (WORD_SWITCH_TAKES_ARG (p))
-		i += WORD_SWITCH_TAKES_ARG (p);
-	    }
-	}
-      else
-	{
-	  n_infiles++;
-	  lang_n_infiles++;
-	}
+                if (p[1] == 0 && i + 1 == argc)
+                    fatal("argument to `-b' is missing");
+                if (p[1] == 0)
+                    spec_machine = argv[++i];
+                else
+                    spec_machine = p + 1;
+
+                warn_std_ptr = &warn_std;
+                break;
+
+            case 'B':
+            {
+                char *value;
+                if (p[1] == 0 && i + 1 == argc)
+                    fatal("argument to `-B' is missing");
+                if (p[1] == 0)
+                    value = argv[++i];
+                else
+                    value = p + 1;
+                add_prefix(&exec_prefixes, value, NULL, 1, 0, &warn_B);
+                add_prefix(&startfile_prefixes, value, NULL,
+                           1, 0, &warn_B);
+                add_prefix(&include_prefixes, concat(value, "include",
+                                                     NULL),
+                           NULL, 1, 0, NULL);
+
+                /* As a kludge, if the arg is "[foo/]stageN/", just add
+                   "[foo/]include" to the include prefix.  */
+                {
+                    int len = strlen(value);
+                    if ((len == 7
+                         || (len > 7
+                             && (value[len - 8] == '/'
+                                 || value[len - 8] == DIR_SEPARATOR)))
+                        && strncmp(value + len - 7, "stage", 5) == 0
+                        && ISDIGIT(value[len - 2])
+                        && (value[len - 1] == '/'
+                            || value[len - 1] == DIR_SEPARATOR))
+                    {
+                        if (len == 7)
+                            add_prefix(&include_prefixes, "include", NULL,
+                                       1, 0, NULL);
+                        else
+                        {
+                            char *string = xmalloc(len + 1);
+                            strncpy(string, value, len-7);
+                            strcpy(string+len-7, "include");
+                            add_prefix(&include_prefixes, string, NULL,
+                                       1, 0, NULL);
+                        }
+                    }
+                }
+                n_switches++;
+            }
+            break;
+
+            case 'v':   /* Print our subcommands and print versions.  */
+                n_switches++;
+                /* If they do anything other than exactly `-v', don't set
+                   verbose_flag; rather, continue on to give the error.  */
+                if (p[1] != 0)
+                    break;
+                verbose_flag++;
+                break;
+
+            case 'V':
+                n_switches++;
+                if (p[1] == 0 && i + 1 == argc)
+                    fatal("argument to `-V' is missing");
+                if (p[1] == 0)
+                    spec_version = argv[++i];
+                else
+                    spec_version = p + 1;
+                compiler_version = spec_version;
+                warn_std_ptr = &warn_std;
+
+                /* Validate the version number.  Use the same checks
+                   done when inserting it into a spec.
+
+                   The format of the version string is
+                   ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
+                {
+                    char *v = compiler_version;
+
+                    /* Ignore leading non-digits.  i.e. "foo-" in "foo-2.7.2".  */
+                    while (!ISDIGIT(*v))
+                        v++;
+
+                    if (v > compiler_version && v[-1] != '-')
+                        fatal("invalid version number format");
+
+                    /* Set V after the first period.  */
+                    while (ISDIGIT(*v))
+                        v++;
+
+                    if (*v != '.')
+                        fatal("invalid version number format");
+
+                    v++;
+                    while (ISDIGIT(*v))
+                        v++;
+
+                    if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
+                        fatal("invalid version number format");
+                }
+                break;
+
+            case 'S':
+            case 'c':
+                if (p[1] == 0)
+                {
+                    have_c = 1;
+                    n_switches++;
+                    break;
+                }
+                goto normal_switch;
+
+            case 'o':
+                have_o = 1;
+                goto normal_switch;
+
+            default:
+normal_switch:
+                n_switches++;
+
+                if (SWITCH_TAKES_ARG(c) > (p[1] != 0))
+                    i += SWITCH_TAKES_ARG(c) - (p[1] != 0);
+                else if (WORD_SWITCH_TAKES_ARG(p))
+                    i += WORD_SWITCH_TAKES_ARG(p);
+            }
+        }
+        else
+        {
+            n_infiles++;
+            lang_n_infiles++;
+        }
     }
 
-  if (have_c && have_o && lang_n_infiles > 1)
-    fatal ("cannot specify -o with -c or -S and multiple compilations");
+    if (have_c && have_o && lang_n_infiles > 1)
+        fatal("cannot specify -o with -c or -S and multiple compilations");
 
-  /* Set up the search paths before we go looking for config files.  */
+    /* Set up the search paths before we go looking for config files.  */
 
-  /* These come before the md prefixes so that we will find gcc's subcommands
-     (such as cpp) rather than those of the host system.  */
-  /* Use 2 as fourth arg meaning try just the machine as a suffix,
-     as well as trying the machine and the version.  */
-  add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
-	      0, 2, warn_std_ptr);
-  add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
-	      0, 2, warn_std_ptr);
+    /* These come before the md prefixes so that we will find gcc's subcommands
+       (such as cpp) rather than those of the host system.  */
+    /* Use 2 as fourth arg meaning try just the machine as a suffix,
+       as well as trying the machine and the version.  */
+    add_prefix(&exec_prefixes, standard_exec_prefix, "BINUTILS",
+               0, 2, warn_std_ptr);
+    add_prefix(&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
+               0, 2, warn_std_ptr);
 
-  add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
-	      0, 1, warn_std_ptr);
-  add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
-	      0, 1, warn_std_ptr);
+    add_prefix(&startfile_prefixes, standard_exec_prefix, "BINUTILS",
+               0, 1, warn_std_ptr);
+    add_prefix(&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
+               0, 1, warn_std_ptr);
 
-  tooldir_prefix = concat (tooldir_base_prefix, spec_machine, 
-			   dir_separator_str, NULL);
+    tooldir_prefix = concat(tooldir_base_prefix, spec_machine,
+                            dir_separator_str, NULL);
 
-  /* If tooldir is relative, base it on exec_prefixes.  A relative
-     tooldir lets us move the installed tree as a unit.  */
+    /* If tooldir is relative, base it on exec_prefixes.  A relative
+       tooldir lets us move the installed tree as a unit.  */
 
-  if (*tooldir_prefix != '/' && *tooldir_prefix != DIR_SEPARATOR)
+    if (*tooldir_prefix != '/' && *tooldir_prefix != DIR_SEPARATOR)
     {
-      tooldir_prefix = concat (standard_exec_prefix, spec_machine,
-			       dir_separator_str, spec_version, 
-			       dir_separator_str, tooldir_prefix, NULL);
+        tooldir_prefix = concat(standard_exec_prefix, spec_machine,
+                                dir_separator_str, spec_version,
+                                dir_separator_str, tooldir_prefix, NULL);
     }
 
-  add_prefix (&exec_prefixes, 
-              concat (tooldir_prefix, "bin", dir_separator_str, NULL),
-	      "BINUTILS", 0, 0, NULL);
-  add_prefix (&startfile_prefixes,
-	      concat (tooldir_prefix, "lib", dir_separator_str, NULL),
-	      "BINUTILS", 0, 0, NULL);
+    add_prefix(&exec_prefixes,
+               concat(tooldir_prefix, "bin", dir_separator_str, NULL),
+               "BINUTILS", 0, 0, NULL);
+    add_prefix(&startfile_prefixes,
+               concat(tooldir_prefix, "lib", dir_separator_str, NULL),
+               "BINUTILS", 0, 0, NULL);
 
-  /* More prefixes are enabled in main, after we read the specs file
-     and determine whether this is cross-compilation or not.  */
+    /* More prefixes are enabled in main, after we read the specs file
+       and determine whether this is cross-compilation or not.  */
 
 
-  /* Then create the space for the vectors and scan again.  */
+    /* Then create the space for the vectors and scan again.  */
 
-  switches = ((struct switchstr *)
-	      xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
-  infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
-  n_switches = 0;
-  n_infiles = 0;
-  last_language_n_infiles = -1;
+    switches = ((struct switchstr *)
+                xmalloc((n_switches + 1) * sizeof (struct switchstr)));
+    infiles = (struct infile *) xmalloc((n_infiles + 1) * sizeof (struct infile));
+    n_switches = 0;
+    n_infiles = 0;
+    last_language_n_infiles = -1;
 
-  /* This, time, copy the text of each switch and store a pointer
-     to the copy in the vector of switches.
-     Store all the infiles in their vector.  */
+    /* This, time, copy the text of each switch and store a pointer
+       to the copy in the vector of switches.
+       Store all the infiles in their vector.  */
 
-  for (i = 1; i < argc; i++)
+    for (i = 1; i < argc; i++)
     {
-      /* Just skip the switches that were handled by the preceding loop.  */
-      if (! strncmp (argv[i], "-Wa,", 4))
-	;
-      else if (! strncmp (argv[i], "-Wp,", 4))
-	;
-      else if (! strcmp (argv[i], "-print-search-dirs"))
-	;
-      else if (! strcmp (argv[i], "-print-libgcc-file-name"))
-	;
-      else if (! strncmp (argv[i], "-print-file-name=", 17))
-	;
-      else if (! strncmp (argv[i], "-print-prog-name=", 17))
-	;
-      else if (! strcmp (argv[i], "-print-multi-lib"))
-	;
-      else if (! strcmp (argv[i], "-print-multi-directory"))
-	;
-      else if (strcmp (argv[i], "-fhelp") == 0)
-	{
-	  if (verbose_flag)
-	    {
-	      /* Create a dummy input file, so that we can pass --help on to
-		 the various sub-processes.  */
-	      infiles[n_infiles].language = "c";
-	      infiles[n_infiles++].name   = "help-dummy";
-	      
-	      /* Preserve the --help switch so that it can be caught by the
-		 cc1 spec string.  */
-	      switches[n_switches].part1     = "--help";
-	      switches[n_switches].args      = 0;
-	      switches[n_switches].live_cond = 0;
-	      switches[n_switches].valid     = 0;
-	      
-	      n_switches++;
-	    }
-	}
-      else if (argv[i][0] == '+' && argv[i][1] == 'e')
-	{
-	  /* Compensate for the +e options to the C++ front-end;
-	     they're there simply for cfront call-compatibility.  We do
-	     some magic in default_compilers to pass them down properly.
-	     Note we deliberately start at the `+' here, to avoid passing
-	     -e0 or -e1 down into the linker.  */
-	  switches[n_switches].part1 = &argv[i][0];
-	  switches[n_switches].args = 0;
-	  switches[n_switches].live_cond = 0;
-	  switches[n_switches].valid = 0;
-	  n_switches++;
-	}
-      else if (strncmp (argv[i], "-Wl,", 4) == 0)
-	{
-	  int prev, j;
-	  /* Split the argument at commas.  */
-	  prev = 4;
-	  for (j = 4; argv[i][j]; j++)
-	    if (argv[i][j] == ',')
-	      {
-		infiles[n_infiles].language = "*";
-		infiles[n_infiles++].name
-		  = save_string (argv[i] + prev, j - prev);
-		prev = j + 1;
-	      }
-	  /* Record the part after the last comma.  */
-	  infiles[n_infiles].language = "*";
-	  infiles[n_infiles++].name = argv[i] + prev;
-	}
-      else if (strcmp (argv[i], "-Xlinker") == 0)
-	{
-	  infiles[n_infiles].language = "*";
-	  infiles[n_infiles++].name = argv[++i];
-	}
-      else if (strncmp (argv[i], "-l", 2) == 0)
-	{
-	  infiles[n_infiles].language = "*";
-	  infiles[n_infiles++].name = argv[i];
-	}
-      else if (strcmp (argv[i], "-specs") == 0)
-	i++;
-      else if (strncmp (argv[i], "-specs=", 7) == 0)
-	;
-      /* -save-temps overrides -pipe, so that temp files are produced */
-      else if (save_temps_flag && strcmp (argv[i], "-pipe") == 0)
-	error ("Warning: -pipe ignored since -save-temps specified");
-      else if (argv[i][0] == '-' && argv[i][1] != 0)
-	{
-	  register char *p = &argv[i][1];
-	  register int c = *p;
-
-	  if (c == 'x')
-	    {
-	      if (p[1] == 0 && i + 1 == argc)
-		fatal ("argument to `-x' is missing");
-	      if (p[1] == 0)
-		spec_lang = argv[++i];
-	      else
-		spec_lang = p + 1;
-	      if (! strcmp (spec_lang, "none"))
-		/* Suppress the warning if -xnone comes after the last input
-		   file, because alternate command interfaces like g++ might
-		   find it useful to place -xnone after each input file.  */
-		spec_lang = 0;
-	      else
-		last_language_n_infiles = n_infiles;
-	      continue;
-	    }
-	  switches[n_switches].part1 = p;
-	  /* Deal with option arguments in separate argv elements.  */
-	  if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
-	      || WORD_SWITCH_TAKES_ARG (p))
-	    {
-	      int j = 0;
-	      int n_args = WORD_SWITCH_TAKES_ARG (p);
-
-	      if (n_args == 0)
-		{
-		  /* Count only the option arguments in separate argv elements.  */
-		  n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
-		}
-	      if (i + n_args >= argc)
-		fatal ("argument to `-%s' is missing", p);
-	      switches[n_switches].args
-		= (char **) xmalloc ((n_args + 1) * sizeof (char *));
-	      while (j < n_args)
-		switches[n_switches].args[j++] = argv[++i];
-	      /* Null-terminate the vector.  */
-	      switches[n_switches].args[j] = 0;
-	    }
-	  else if (strchr (switches_need_spaces, c))
-	    {
-	      /* On some systems, ld cannot handle some options without
-		 a space.  So split the option from its argument.  */
-	      char *part1 = (char *) xmalloc (2);
-	      part1[0] = c;
-	      part1[1] = '\0';
-	      
-	      switches[n_switches].part1 = part1;
-	      switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
-	      switches[n_switches].args[0] = xmalloc (strlen (p));
-	      strcpy (switches[n_switches].args[0], &p[1]);
-	      switches[n_switches].args[1] = 0;
-	    }
-	  else
-	    switches[n_switches].args = 0;
-
-	  switches[n_switches].live_cond = 0;
-	  switches[n_switches].valid = 0;
-	  /* This is always valid, since gcc.c itself understands it.  */
-	  if (!strcmp (p, "save-temps"))
-	    switches[n_switches].valid = 1;
-          else
+        /* Just skip the switches that were handled by the preceding loop.  */
+        if (!strncmp(argv[i], "-Wa,", 4))
+            ;
+        else if (!strncmp(argv[i], "-Wp,", 4))
+            ;
+        else if (!strcmp(argv[i], "-print-search-dirs"))
+            ;
+        else if (!strcmp(argv[i], "-print-libgcc-file-name"))
+            ;
+        else if (!strncmp(argv[i], "-print-file-name=", 17))
+            ;
+        else if (!strncmp(argv[i], "-print-prog-name=", 17))
+            ;
+        else if (!strcmp(argv[i], "-print-multi-lib"))
+            ;
+        else if (!strcmp(argv[i], "-print-multi-directory"))
+            ;
+        else if (strcmp(argv[i], "-fhelp") == 0)
+        {
+            if (verbose_flag)
             {
-              char ch = switches[n_switches].part1[0];
-              if (ch == 'V' || ch == 'b' || ch == 'B')
-                switches[n_switches].valid = 1;
+                /* Create a dummy input file, so that we can pass --help on to
+                   the various sub-processes.  */
+                infiles[n_infiles].language = "c";
+                infiles[n_infiles++].name   = "help-dummy";
+
+                /* Preserve the --help switch so that it can be caught by the
+                   cc1 spec string.  */
+                switches[n_switches].part1     = "--help";
+                switches[n_switches].args      = 0;
+                switches[n_switches].live_cond = 0;
+                switches[n_switches].valid     = 0;
+
+                n_switches++;
             }
-	  n_switches++;
-	}
-      else
-	{
-#ifdef HAVE_OBJECT_SUFFIX
-	  argv[i] = convert_filename (argv[i], 0);
-#endif
+        }
+        else if (argv[i][0] == '+' && argv[i][1] == 'e')
+        {
+            /* Compensate for the +e options to the C++ front-end;
+               they're there simply for cfront call-compatibility.  We do
+               some magic in default_compilers to pass them down properly.
+               Note we deliberately start at the `+' here, to avoid passing
+               -e0 or -e1 down into the linker.  */
+            switches[n_switches].part1 = &argv[i][0];
+            switches[n_switches].args = 0;
+            switches[n_switches].live_cond = 0;
+            switches[n_switches].valid = 0;
+            n_switches++;
+        }
+        else if (strncmp(argv[i], "-Wl,", 4) == 0)
+        {
+            int prev, j;
+            /* Split the argument at commas.  */
+            prev = 4;
+            for (j = 4; argv[i][j]; j++)
+                if (argv[i][j] == ',')
+                {
+                    infiles[n_infiles].language = "*";
+                    infiles[n_infiles++].name
+                        = save_string(argv[i] + prev, j - prev);
+                    prev = j + 1;
+                }
+            /* Record the part after the last comma.  */
+            infiles[n_infiles].language = "*";
+            infiles[n_infiles++].name = argv[i] + prev;
+        }
+        else if (strcmp(argv[i], "-Xlinker") == 0)
+        {
+            infiles[n_infiles].language = "*";
+            infiles[n_infiles++].name = argv[++i];
+        }
+        else if (strncmp(argv[i], "-l", 2) == 0)
+        {
+            infiles[n_infiles].language = "*";
+            infiles[n_infiles++].name = argv[i];
+        }
+        else if (strcmp(argv[i], "-specs") == 0)
+            i++;
+        else if (strncmp(argv[i], "-specs=", 7) == 0)
+            ;
+        /* -save-temps overrides -pipe, so that temp files are produced */
+        else if (save_temps_flag && strcmp(argv[i], "-pipe") == 0)
+            error("Warning: -pipe ignored since -save-temps specified");
+        else if (argv[i][0] == '-' && argv[i][1] != 0)
+        {
+            register char *p = &argv[i][1];
+            register int c = *p;
+
+            if (c == 'x')
+            {
+                if (p[1] == 0 && i + 1 == argc)
+                    fatal("argument to `-x' is missing");
+                if (p[1] == 0)
+                    spec_lang = argv[++i];
+                else
+                    spec_lang = p + 1;
+                if (!strcmp(spec_lang, "none"))
+                    /* Suppress the warning if -xnone comes after the last input
+                       file, because alternate command interfaces like g++ might
+                       find it useful to place -xnone after each input file.  */
+                    spec_lang = 0;
+                else
+                    last_language_n_infiles = n_infiles;
+                continue;
+            }
+            switches[n_switches].part1 = p;
+            /* Deal with option arguments in separate argv elements.  */
+            if ((SWITCH_TAKES_ARG(c) > (p[1] != 0))
+                || WORD_SWITCH_TAKES_ARG(p))
+            {
+                int j = 0;
+                int n_args = WORD_SWITCH_TAKES_ARG(p);
+
+                if (n_args == 0)
+                {
+                    /* Count only the option arguments in separate argv elements.  */
+                    n_args = SWITCH_TAKES_ARG(c) - (p[1] != 0);
+                }
+                if (i + n_args >= argc)
+                    fatal("argument to `-%s' is missing", p);
+                switches[n_switches].args
+                    = (char **) xmalloc((n_args + 1) * sizeof (char *));
+                while (j < n_args)
+                    switches[n_switches].args[j++] = argv[++i];
+                /* Null-terminate the vector.  */
+                switches[n_switches].args[j] = 0;
+            }
+            else if (strchr(switches_need_spaces, c))
+            {
+                /* On some systems, ld cannot handle some options without
+                   a space.  So split the option from its argument.  */
+                char *part1 = (char *) xmalloc(2);
+                part1[0] = c;
+                part1[1] = '\0';
+
+                switches[n_switches].part1 = part1;
+                switches[n_switches].args = (char **) xmalloc(2 * sizeof (char *));
+                switches[n_switches].args[0] = xmalloc(strlen(p));
+                strcpy(switches[n_switches].args[0], &p[1]);
+                switches[n_switches].args[1] = 0;
+            }
+            else
+                switches[n_switches].args = 0;
 
-	  if (strcmp (argv[i], "-") != 0 && access (argv[i], R_OK) < 0)
-	    {
-	      perror_with_name (argv[i]);
-	      error_count++;
-	    }
-	  else
-	    {
-	      infiles[n_infiles].language = spec_lang;
-	      infiles[n_infiles++].name = argv[i];
-	    }
-	}
+            switches[n_switches].live_cond = 0;
+            switches[n_switches].valid = 0;
+            /* This is always valid, since gcc.c itself understands it.  */
+            if (!strcmp(p, "save-temps"))
+                switches[n_switches].valid = 1;
+            else
+            {
+                char ch = switches[n_switches].part1[0];
+                if (ch == 'V' || ch == 'b' || ch == 'B')
+                    switches[n_switches].valid = 1;
+            }
+            n_switches++;
+        }
+        else
+        {
+            if (strcmp(argv[i], "-") != 0 && access(argv[i], R_OK) < 0)
+            {
+                perror_with_name(argv[i]);
+                error_count++;
+            }
+            else
+            {
+                infiles[n_infiles].language = spec_lang;
+                infiles[n_infiles++].name = argv[i];
+            }
+        }
     }
 
-  if (n_infiles == last_language_n_infiles && spec_lang != 0)
-    error ("Warning: `-x %s' after last input file has no effect", spec_lang);
+    if (n_infiles == last_language_n_infiles && spec_lang != 0)
+        error("Warning: `-x %s' after last input file has no effect", spec_lang);
 
-  switches[n_switches].part1 = 0;
-  infiles[n_infiles].name = 0;
+    switches[n_switches].part1 = 0;
+    infiles[n_infiles].name = 0;
 }
-
+
 /* Process a spec string, accumulating and running commands.  */
 
 /* These variables describe the input file name.
@@ -3063,32 +2813,31 @@ static int input_from_pipe;
    Returns 0 if the spec is successfully processed; -1 if failed.  */
 
 int
-do_spec (spec)
-     char *spec;
+do_spec(char *spec)
 {
-  int value;
+    int value;
 
-  clear_args ();
-  arg_going = 0;
-  delete_this_arg = 0;
-  this_is_output_file = 0;
-  this_is_library_file = 0;
-  input_from_pipe = 0;
+    clear_args();
+    arg_going = 0;
+    delete_this_arg = 0;
+    this_is_output_file = 0;
+    this_is_library_file = 0;
+    input_from_pipe = 0;
 
-  value = do_spec_1 (spec, 0, NULL);
+    value = do_spec_1(spec, 0, NULL);
 
-  /* Force out any unfinished command.
-     If -pipe, this forces out the last command if it ended in `|'.  */
-  if (value == 0)
+    /* Force out any unfinished command.
+       If -pipe, this forces out the last command if it ended in `|'.  */
+    if (value == 0)
     {
-      if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
-	argbuf_index--;
+        if (argbuf_index > 0 && !strcmp(argbuf[argbuf_index - 1], "|"))
+            argbuf_index--;
 
-      if (argbuf_index > 0)
-	value = execute ();
+        if (argbuf_index > 0)
+            value = execute();
     }
 
-  return value;
+    return value;
 }
 
 /* Process the sub-spec SPEC as a portion of a larger spec.
@@ -3104,1011 +2853,1007 @@ do_spec (spec)
    and the command on that line reported an error.  */
 
 static int
-do_spec_1 (spec, inswitch, soft_matched_part)
-     char *spec;
-     int inswitch;
-     char *soft_matched_part;
+do_spec_1(char *spec, int inswitch, char *soft_matched_part)
 {
-  register char *p = spec;
-  register int c;
-  int i;
-  char *string;
-  int value;
-
-  while ((c = *p++))
-    /* If substituting a switch, treat all chars like letters.
-       Otherwise, NL, SPC, TAB and % are special.  */
-    switch (inswitch ? 'a' : c)
-      {
-      case '\n':
-	/* End of line: finish any pending argument,
-	   then run the pending command if one has been started.  */
-	if (arg_going)
-	  {
-	    obstack_1grow (&obstack, 0);
-	    string = obstack_finish (&obstack);
-	    if (this_is_library_file)
-	      string = find_file (string);
-	    store_arg (string, delete_this_arg, this_is_output_file);
-	    if (this_is_output_file)
-	      outfiles[input_file_number] = string;
-	  }
-	arg_going = 0;
-
-	if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
-	  {
-	    for (i = 0; i < n_switches; i++)
-	      if (!strcmp (switches[i].part1, "pipe"))
-		break;
-
-	    /* A `|' before the newline means use a pipe here,
-	       but only if -pipe was specified.
-	       Otherwise, execute now and don't pass the `|' as an arg.  */
-	    if (i < n_switches)
-	      {
-		input_from_pipe = 1;
-		switches[i].valid = 1;
-		break;
-	      }
-	    else
-	      argbuf_index--;
-	  }
-
-	if (argbuf_index > 0)
-	  {
-	    value = execute ();
-	    if (value)
-	      return value;
-	  }
-	/* Reinitialize for a new command, and for a new argument.  */
-	clear_args ();
-	arg_going = 0;
-	delete_this_arg = 0;
-	this_is_output_file = 0;
-	this_is_library_file = 0;
-	input_from_pipe = 0;
-	break;
-
-      case '|':
-	/* End any pending argument.  */
-	if (arg_going)
-	  {
-	    obstack_1grow (&obstack, 0);
-	    string = obstack_finish (&obstack);
-	    if (this_is_library_file)
-	      string = find_file (string);
-	    store_arg (string, delete_this_arg, this_is_output_file);
-	    if (this_is_output_file)
-	      outfiles[input_file_number] = string;
-	  }
-
-	/* Use pipe */
-	obstack_1grow (&obstack, c);
-	arg_going = 1;
-	break;
-
-      case '\t':
-      case ' ':
-	/* Space or tab ends an argument if one is pending.  */
-	if (arg_going)
-	  {
-	    obstack_1grow (&obstack, 0);
-	    string = obstack_finish (&obstack);
-	    if (this_is_library_file)
-	      string = find_file (string);
-	    store_arg (string, delete_this_arg, this_is_output_file);
-	    if (this_is_output_file)
-	      outfiles[input_file_number] = string;
-	  }
-	/* Reinitialize for a new argument.  */
-	arg_going = 0;
-	delete_this_arg = 0;
-	this_is_output_file = 0;
-	this_is_library_file = 0;
-	break;
-
-      case '%':
-	switch (c = *p++)
-	  {
-	  case 0:
-	    fatal ("Invalid specification!  Bug in cc.");
-
-	  case 'b':
-	    obstack_grow (&obstack, input_basename, basename_length);
-	    arg_going = 1;
-	    break;
-
-	  case 'd':
-	    delete_this_arg = 2;
-	    break;
-
-	  /* Dump out the directories specified with LIBRARY_PATH,
-	     followed by the absolute directories
-	     that we search for startfiles.  */
-	  case 'D':
-	    {
-	      struct prefix_list *pl = startfile_prefixes.plist;
-	      size_t bufsize = 100;
-	      char *buffer = (char *) xmalloc (bufsize);
-	      int idx;
-
-	      for (; pl; pl = pl->next)
-		{
+    register char *p = spec;
+    register int c;
+    int i;
+    char *string;
+    int value;
+
+    while ((c = *p++))
+        /* If substituting a switch, treat all chars like letters.
+           Otherwise, NL, SPC, TAB and % are special.  */
+        switch (inswitch ? 'a' : c)
+        {
+        case '\n':
+            /* End of line: finish any pending argument,
+               then run the pending command if one has been started.  */
+            if (arg_going)
+            {
+                obstack_1grow(&obstack, 0);
+                string = obstack_finish(&obstack);
+                if (this_is_library_file)
+                    string = find_file(string);
+                store_arg(string, delete_this_arg, this_is_output_file);
+                if (this_is_output_file)
+                    outfiles[input_file_number] = string;
+            }
+            arg_going = 0;
+
+            if (argbuf_index > 0 && !strcmp(argbuf[argbuf_index - 1], "|"))
+            {
+                for (i = 0; i < n_switches; i++)
+                    if (!strcmp(switches[i].part1, "pipe"))
+                        break;
+
+                /* A `|' before the newline means use a pipe here,
+                   but only if -pipe was specified.
+                   Otherwise, execute now and don't pass the `|' as an arg.  */
+                if (i < n_switches)
+                {
+                    input_from_pipe = 1;
+                    switches[i].valid = 1;
+                    break;
+                }
+                else
+                    argbuf_index--;
+            }
+
+            if (argbuf_index > 0)
+            {
+                value = execute();
+                if (value)
+                    return value;
+            }
+            /* Reinitialize for a new command, and for a new argument.  */
+            clear_args();
+            arg_going = 0;
+            delete_this_arg = 0;
+            this_is_output_file = 0;
+            this_is_library_file = 0;
+            input_from_pipe = 0;
+            break;
+
+        case '|':
+            /* End any pending argument.  */
+            if (arg_going)
+            {
+                obstack_1grow(&obstack, 0);
+                string = obstack_finish(&obstack);
+                if (this_is_library_file)
+                    string = find_file(string);
+                store_arg(string, delete_this_arg, this_is_output_file);
+                if (this_is_output_file)
+                    outfiles[input_file_number] = string;
+            }
+
+            /* Use pipe */
+            obstack_1grow(&obstack, c);
+            arg_going = 1;
+            break;
+
+        case '\t':
+        case ' ':
+            /* Space or tab ends an argument if one is pending.  */
+            if (arg_going)
+            {
+                obstack_1grow(&obstack, 0);
+                string = obstack_finish(&obstack);
+                if (this_is_library_file)
+                    string = find_file(string);
+                store_arg(string, delete_this_arg, this_is_output_file);
+                if (this_is_output_file)
+                    outfiles[input_file_number] = string;
+            }
+            /* Reinitialize for a new argument.  */
+            arg_going = 0;
+            delete_this_arg = 0;
+            this_is_output_file = 0;
+            this_is_library_file = 0;
+            break;
+
+        case '%':
+            switch (c = *p++)
+            {
+            case 0:
+                fatal("Invalid specification!  Bug in cc.");
+
+            case 'b':
+                obstack_grow(&obstack, input_basename, basename_length);
+                arg_going = 1;
+                break;
+
+            case 'd':
+                delete_this_arg = 2;
+                break;
+
+            /* Dump out the directories specified with LIBRARY_PATH,
+               followed by the absolute directories
+               that we search for startfiles.  */
+            case 'D':
+            {
+                struct prefix_list *pl = startfile_prefixes.plist;
+                size_t bufsize = 100;
+                char *buffer = (char *) xmalloc(bufsize);
+                int idx;
+
+                for (; pl; pl = pl->next)
+                {
 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
-		  /* Used on systems which record the specified -L dirs
-		     and use them to search for dynamic linking.  */
-		  /* Relative directories always come from -B,
-		     and it is better not to use them for searching
-		     at run time.  In particular, stage1 loses  */
-		  if (pl->prefix[0] != '/' && pl->prefix[0] != DIR_SEPARATOR)
-		    continue;
+                    /* Used on systems which record the specified -L dirs
+                       and use them to search for dynamic linking.  */
+                    /* Relative directories always come from -B,
+                       and it is better not to use them for searching
+                       at run time.  In particular, stage1 loses  */
+                    if (pl->prefix[0] != '/' && pl->prefix[0] != DIR_SEPARATOR)
+                        continue;
 #endif
-		  /* Try subdirectory if there is one.  */
-		  if (multilib_dir != NULL)
-		    {
-		      if (machine_suffix)
-			{
-			  if (strlen (pl->prefix) + strlen (machine_suffix)
-			      >= bufsize)
-			    bufsize = (strlen (pl->prefix)
-				       + strlen (machine_suffix)) * 2 + 1;
-			  buffer = (char *) xrealloc (buffer, bufsize);
-			  strcpy (buffer, pl->prefix);
-			  strcat (buffer, machine_suffix);
-			  if (is_directory (buffer, multilib_dir, 1))
-			    {
-			      do_spec_1 ("-L", 0, NULL);
+                    /* Try subdirectory if there is one.  */
+                    if (multilib_dir != NULL)
+                    {
+                        if (machine_suffix)
+                        {
+                            if (strlen(pl->prefix) + strlen(machine_suffix)
+                                >= bufsize)
+                                bufsize = (strlen(pl->prefix)
+                                           + strlen(machine_suffix)) * 2 + 1;
+                            buffer = (char *) xrealloc(buffer, bufsize);
+                            strcpy(buffer, pl->prefix);
+                            strcat(buffer, machine_suffix);
+                            if (is_directory(buffer, multilib_dir, 1))
+                            {
+                                do_spec_1("-L", 0, NULL);
 #ifdef SPACE_AFTER_L_OPTION
-			      do_spec_1 (" ", 0, NULL);
+                                do_spec_1(" ", 0, NULL);
 #endif
-			      do_spec_1 (buffer, 1, NULL);
-			      do_spec_1 (multilib_dir, 1, NULL);
-			      /* Make this a separate argument.  */
-			      do_spec_1 (" ", 0, NULL);
-			    }
-			}
-		      if (!pl->require_machine_suffix)
-			{
-			  if (is_directory (pl->prefix, multilib_dir, 1))
-			    {
-			      do_spec_1 ("-L", 0, NULL);
+                                do_spec_1(buffer, 1, NULL);
+                                do_spec_1(multilib_dir, 1, NULL);
+                                /* Make this a separate argument.  */
+                                do_spec_1(" ", 0, NULL);
+                            }
+                        }
+                        if (!pl->require_machine_suffix)
+                        {
+                            if (is_directory(pl->prefix, multilib_dir, 1))
+                            {
+                                do_spec_1("-L", 0, NULL);
 #ifdef SPACE_AFTER_L_OPTION
-			      do_spec_1 (" ", 0, NULL);
+                                do_spec_1(" ", 0, NULL);
 #endif
-			      do_spec_1 (pl->prefix, 1, NULL);
-			      do_spec_1 (multilib_dir, 1, NULL);
-			      /* Make this a separate argument.  */
-			      do_spec_1 (" ", 0, NULL);
-			    }
-			}
-		    }
-		  if (machine_suffix)
-		    {
-		      if (is_directory (pl->prefix, machine_suffix, 1))
-			{
-			  do_spec_1 ("-L", 0, NULL);
+                                do_spec_1(pl->prefix, 1, NULL);
+                                do_spec_1(multilib_dir, 1, NULL);
+                                /* Make this a separate argument.  */
+                                do_spec_1(" ", 0, NULL);
+                            }
+                        }
+                    }
+                    if (machine_suffix)
+                    {
+                        if (is_directory(pl->prefix, machine_suffix, 1))
+                        {
+                            do_spec_1("-L", 0, NULL);
 #ifdef SPACE_AFTER_L_OPTION
-			  do_spec_1 (" ", 0, NULL);
+                            do_spec_1(" ", 0, NULL);
 #endif
-			  do_spec_1 (pl->prefix, 1, NULL);
-			  /* Remove slash from machine_suffix.  */
-			  if (strlen (machine_suffix) >= bufsize)
-			    bufsize = strlen (machine_suffix) * 2 + 1;
-			  buffer = (char *) xrealloc (buffer, bufsize);
-			  strcpy (buffer, machine_suffix);
-			  idx = strlen (buffer);
-			  if (buffer[idx - 1] == '/'
-			      || buffer[idx - 1] == DIR_SEPARATOR)
-			    buffer[idx - 1] = 0;
-			  do_spec_1 (buffer, 1, NULL);
-			  /* Make this a separate argument.  */
-			  do_spec_1 (" ", 0, NULL);
-			}
-		    }
-		  if (!pl->require_machine_suffix)
-		    {
-		      if (is_directory (pl->prefix, "", 1))
-			{
-			  do_spec_1 ("-L", 0, NULL);
+                            do_spec_1(pl->prefix, 1, NULL);
+                            /* Remove slash from machine_suffix.  */
+                            if (strlen(machine_suffix) >= bufsize)
+                                bufsize = strlen(machine_suffix) * 2 + 1;
+                            buffer = (char *) xrealloc(buffer, bufsize);
+                            strcpy(buffer, machine_suffix);
+                            idx = strlen(buffer);
+                            if (buffer[idx - 1] == '/'
+                                || buffer[idx - 1] == DIR_SEPARATOR)
+                                buffer[idx - 1] = 0;
+                            do_spec_1(buffer, 1, NULL);
+                            /* Make this a separate argument.  */
+                            do_spec_1(" ", 0, NULL);
+                        }
+                    }
+                    if (!pl->require_machine_suffix)
+                    {
+                        if (is_directory(pl->prefix, "", 1))
+                        {
+                            do_spec_1("-L", 0, NULL);
 #ifdef SPACE_AFTER_L_OPTION
-			  do_spec_1 (" ", 0, NULL);
+                            do_spec_1(" ", 0, NULL);
 #endif
-			  /* Remove slash from pl->prefix.  */
-			  if (strlen (pl->prefix) >= bufsize)
-			    bufsize = strlen (pl->prefix) * 2 + 1;
-			  buffer = (char *) xrealloc (buffer, bufsize);
-			  strcpy (buffer, pl->prefix);
-			  idx = strlen (buffer);
-			  if (buffer[idx - 1] == '/'
-			      || buffer[idx - 1] == DIR_SEPARATOR)
-			    buffer[idx - 1] = 0;
-			  do_spec_1 (buffer, 1, NULL);
-			  /* Make this a separate argument.  */
-			  do_spec_1 (" ", 0, NULL);
-			}
-		    }
-		}
-	      free (buffer);
-	    }
-	    break;
-
-	  case 'e':
-	    /* {...:%efoo} means report an error with `foo' as error message
-	       and don't execute any more commands for this file.  */
-	    {
-	      char *q = p;
-	      char *buf;
-	      while (*p != 0 && *p != '\n') p++;
-	      buf = (char *) alloca (p - q + 1);
-	      strncpy (buf, q, p - q);
-	      buf[p - q] = 0;
-	      error ("%s", buf);
-	      return -1;
-	    }
-	    break;
-
-	  case 'g':
-	  case 'u':
-	  case 'U':
-	    if (save_temps_flag)
-	      {
-		obstack_grow (&obstack, input_basename, basename_length);
-		delete_this_arg = 0;
-	      }
-	    else
-	      {
-		/* ??? This has a problem: the total number of
-		   values mktemp can return is limited.
-		   That matters for the names of object files.
-		   In 2.4, do something about that.  */
-		struct temp_name *t;
-		int suffix_length;
-		char *suffix = p;
-
-		if (p[0] == '%' && p[1] == 'O')
-		  {
-		    /* We don't support extra suffix characters after %O.  */
-		    if (*p == '.' || ISALPHA ((unsigned char)*p))
-		      abort ();
-		    suffix = OBJECT_SUFFIX;
-		    suffix_length = strlen (OBJECT_SUFFIX);
-		    p += 2;
-		  }
-		else
-		  {
-		    while (*p == '.' || ISALPHA ((unsigned char)*p))
-		      p++;
-		    suffix_length = p - suffix;
-		  }
-
-		/* See if we already have an association of %g/%u/%U and
-		   suffix.  */
-		for (t = temp_names; t; t = t->next)
-		  if (t->length == suffix_length
-		      && strncmp (t->suffix, suffix, suffix_length) == 0
-		      && t->unique == (c != 'g'))
-		    break;
-
-		/* Make a new association if needed.  %u requires one.  */
-		if (t == 0 || c == 'u')
-		  {
-		    if (t == 0)
-		      {
-			t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
-			t->next = temp_names;
-			temp_names = t;
-		      }
-		    t->length = suffix_length;
-		    t->suffix = save_string (suffix, suffix_length);
-		    t->unique = (c != 'g');
-		    temp_filename = make_temp_file (t->suffix);
-		    temp_filename_length = strlen (temp_filename);
-		    t->filename = temp_filename;
-		    t->filename_length = temp_filename_length;
-		  }
-
-		obstack_grow (&obstack, t->filename, t->filename_length);
-		delete_this_arg = 1;
-		delete_this_arg = 1;
-	      }
-	    arg_going = 1;
-	    break;
-
-	  case 'i':
-	    obstack_grow (&obstack, input_filename, input_filename_length);
-	    arg_going = 1;
-	    break;
-
-	  case 'I':
-	    {
-	      struct prefix_list *pl = include_prefixes.plist;
-
-	      for (; pl; pl = pl->next)
-		{
-		  do_spec_1 ("-isystem", 1, NULL);
-		  /* Make this a separate argument.  */
-		  do_spec_1 (" ", 0, NULL);
-		  do_spec_1 (pl->prefix, 1, NULL);
-		  do_spec_1 (" ", 0, NULL);
-		}
-	    }
-	    break;
-
-	  case 'o':
-	    {
-	      int max = n_infiles;
-	      for (i = 0; i < max; i++)
-		if (outfiles[i])
-		  store_arg (outfiles[i], 0, 0);
-	      break;
-	    }
-
-	  case 'O':
-	    obstack_grow (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
-	    arg_going = 1;
-	    break;
-
-	  case 's':
-	    this_is_library_file = 1;
-	    break;
-
-	  case 'w':
-	    this_is_output_file = 1;
-	    break;
-
-	  case 'W':
-	    {
-	      int cur_index = argbuf_index;
-	      /* Handle the {...} following the %W.  */
-	      if (*p != '{')
-		abort ();
-	      p = handle_braces (p + 1);
-	      if (p == 0)
-		return -1;
-	      /* If any args were output, mark the last one for deletion
-		 on failure.  */
-	      if (argbuf_index != cur_index)
-		record_temp_file (argbuf[argbuf_index - 1], 0, 1);
-	      break;
-	    }
-
-	  /* %x{OPTION} records OPTION for %X to output.  */
-	  case 'x':
-	    {
-	      char *p1 = p;
-	      char *string;
-
-	      /* Skip past the option value and make a copy.  */
-	      if (*p != '{')
-		abort ();
-	      while (*p++ != '}')
-		;
-	      string = save_string (p1 + 1, p - p1 - 2);
-
-	      /* See if we already recorded this option.  */
-	      for (i = 0; i < n_linker_options; i++)
-		if (! strcmp (string, linker_options[i]))
-		  {
-		    free (string);
-		    return 0;
-		  }
-
-	      /* This option is new; add it.  */
-	      add_linker_option (string, strlen (string));
-	    }
-	    break;
-
-	  /* Dump out the options accumulated previously using %x.  */
-	  case 'X':
-	    for (i = 0; i < n_linker_options; i++)
-	      {
-		do_spec_1 (linker_options[i], 1, NULL);
-		/* Make each accumulated option a separate argument.  */
-		do_spec_1 (" ", 0, NULL);
-	      }
-	    break;
-
-	  /* Dump out the options accumulated previously using -Wa,.  */
-	  case 'Y':
-	    for (i = 0; i < n_assembler_options; i++)
-	      {
-		do_spec_1 (assembler_options[i], 1, NULL);
-		/* Make each accumulated option a separate argument.  */
-		do_spec_1 (" ", 0, NULL);
-	      }
-	    break;
-
-	  /* Dump out the options accumulated previously using -Wp,.  */
-	  case 'Z':
-	    for (i = 0; i < n_preprocessor_options; i++)
-	      {
-		do_spec_1 (preprocessor_options[i], 1, NULL);
-		/* Make each accumulated option a separate argument.  */
-		do_spec_1 (" ", 0, NULL);
-	      }
-	    break;
-
-	    /* Here are digits and numbers that just process
-	       a certain constant string as a spec.  */
-
-	  case '1':
-	    value = do_spec_1 (cc1_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'a':
-	    value = do_spec_1 (asm_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'A':
-	    value = do_spec_1 (asm_final_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'c':
-	    value = do_spec_1 (signed_char_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'C':
-	    value = do_spec_1 (cpp_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'E':
-	    value = do_spec_1 (endfile_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'l':
-	    value = do_spec_1 (link_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'L':
-	    value = do_spec_1 (lib_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'G':
-	    value = do_spec_1 (libgcc_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	  case 'p':
-	    {
-	      char *x = (char *) alloca (strlen (cpp_predefines) + 1);
-	      char *buf = x;
-	      char *y;
-
-	      /* Copy all of the -D options in CPP_PREDEFINES into BUF.  */
-	      y = cpp_predefines;
-	      while (*y != 0)
-		{
-		  if (! strncmp (y, "-D", 2))
-		    /* Copy the whole option.  */
-		    while (*y && *y != ' ' && *y != '\t')
-		      *x++ = *y++;
-		  else if (*y == ' ' || *y == '\t')
-		    /* Copy whitespace to the result.  */
-		    *x++ = *y++;
-		  /* Don't copy other options.  */
-		  else
-		    y++;
-		}
-
-	      *x = 0;
-
-	      value = do_spec_1 (buf, 0, NULL);
-	      if (value != 0)
-		return value;
-	    }
-	    break;
-
-	  case 'P':
-	    {
-	      char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
-	      char *buf = x;
-	      char *y;
-
-	      /* Copy all of CPP_PREDEFINES into BUF,
-		 but put __ after every -D and at the end of each arg.  */
-	      y = cpp_predefines;
-	      while (*y != 0)
-		{
-		  if (! strncmp (y, "-D", 2))
-		    {
-		      int flag = 0;
-
-		      *x++ = *y++;
-		      *x++ = *y++;
-
-		      if (*y != '_'
-			  || (*(y+1) != '_'
-			      && ! ISUPPER ((unsigned char)*(y+1))))
-		        {
-			  /* Stick __ at front of macro name.  */
-			  *x++ = '_';
-			  *x++ = '_';
-			  /* Arrange to stick __ at the end as well.  */
-			  flag = 1;
-			}
-
-		      /* Copy the macro name.  */
-		      while (*y && *y != '=' && *y != ' ' && *y != '\t')
-			*x++ = *y++;
-
-		      if (flag)
-		        {
-			  *x++ = '_';
-			  *x++ = '_';
-			}
-
-		      /* Copy the value given, if any.  */
-		      while (*y && *y != ' ' && *y != '\t')
-			*x++ = *y++;
-		    }
-		  else if (*y == ' ' || *y == '\t')
-		    /* Copy whitespace to the result.  */
-		    *x++ = *y++;
-		  /* Don't copy -A options  */
-		  else
-		    y++;
-		}
-	      *x++ = ' ';
-
-	      /* Copy all of CPP_PREDEFINES into BUF,
-		 but put __ after every -D.  */
-	      y = cpp_predefines;
-	      while (*y != 0)
-		{
-		  if (! strncmp (y, "-D", 2))
-		    {
-		      y += 2;
-
-		      if (*y != '_'
-			  || (*(y+1) != '_'
-			      && ! ISUPPER ((unsigned char)*(y+1))))
-		        {
-			  /* Stick -D__ at front of macro name.  */
-			  *x++ = '-';
-			  *x++ = 'D';
-			  *x++ = '_';
-			  *x++ = '_';
-
-			  /* Copy the macro name.  */
-			  while (*y && *y != '=' && *y != ' ' && *y != '\t')
-			    *x++ = *y++;
-
-			  /* Copy the value given, if any.  */
-			  while (*y && *y != ' ' && *y != '\t')
-			    *x++ = *y++;
-			}
-		      else
-			{
-			  /* Do not copy this macro - we have just done it before */
-			  while (*y && *y != ' ' && *y != '\t')
-			    y++;
-			}
-		    }
-		  else if (*y == ' ' || *y == '\t')
-		    /* Copy whitespace to the result.  */
-		    *x++ = *y++;
-		  /* Don't copy -A options  */
-		  else
-		    y++;
-		}
-	      *x++ = ' ';
-
-	      /* Copy all of the -A options in CPP_PREDEFINES into BUF.  */
-	      y = cpp_predefines;
-	      while (*y != 0)
-		{
-		  if (! strncmp (y, "-A", 2))
-		    /* Copy the whole option.  */
-		    while (*y && *y != ' ' && *y != '\t')
-		      *x++ = *y++;
-		  else if (*y == ' ' || *y == '\t')
-		    /* Copy whitespace to the result.  */
-		    *x++ = *y++;
-		  /* Don't copy other options.  */
-		  else
-		    y++;
-		}
-
-	      *x = 0;
-
-	      value = do_spec_1 (buf, 0, NULL);
-	      if (value != 0)
-		return value;
-	    }
-	    break;
-
-	  case 'S':
-	    value = do_spec_1 (startfile_spec, 0, NULL);
-	    if (value != 0)
-	      return value;
-	    break;
-
-	    /* Here we define characters other than letters and digits.  */
-
-	  case '{':
-	    p = handle_braces (p);
-	    if (p == 0)
-	      return -1;
-	    break;
-
-	  case '%':
-	    obstack_1grow (&obstack, '%');
-	    break;
-
-	  case '*':
-	    do_spec_1 (soft_matched_part, 1, NULL);
-	    do_spec_1 (" ", 0, NULL);
-	    break;
-
-	    /* Process a string found as the value of a spec given by name.
-	       This feature allows individual machine descriptions
-	       to add and use their own specs.
-	       %[...] modifies -D options the way %P does;
-	       %(...) uses the spec unmodified.  */
-	  case '[':
-	    error ("Warning: use of obsolete %%[ operator in specs");
-	  case '(':
-	    {
-	      char *name = p;
-	      struct spec_list *sl;
-	      int len;
-
-	      /* The string after the S/P is the name of a spec that is to be
-		 processed.  */
-	      while (*p && *p != ')' && *p != ']')
-		p++;
-
-	      /* See if it's in the list */
-	      for (len = p - name, sl = specs; sl; sl = sl->next)
-		if (sl->name_len == len && !strncmp (sl->name, name, len))
-		  {
-		    name = *(sl->ptr_spec);
+                            /* Remove slash from pl->prefix.  */
+                            if (strlen(pl->prefix) >= bufsize)
+                                bufsize = strlen(pl->prefix) * 2 + 1;
+                            buffer = (char *) xrealloc(buffer, bufsize);
+                            strcpy(buffer, pl->prefix);
+                            idx = strlen(buffer);
+                            if (buffer[idx - 1] == '/'
+                                || buffer[idx - 1] == DIR_SEPARATOR)
+                                buffer[idx - 1] = 0;
+                            do_spec_1(buffer, 1, NULL);
+                            /* Make this a separate argument.  */
+                            do_spec_1(" ", 0, NULL);
+                        }
+                    }
+                }
+                free(buffer);
+            }
+            break;
+
+            case 'e':
+                /* {...:%efoo} means report an error with `foo' as error message
+                   and don't execute any more commands for this file.  */
+            {
+                char *q = p;
+                char *buf;
+                while (*p != 0 && *p != '\n') p++;
+                buf = (char *) alloca(p - q + 1);
+                strncpy(buf, q, p - q);
+                buf[p - q] = 0;
+                error("%s", buf);
+                return -1;
+            }
+            break;
+
+            case 'g':
+            case 'u':
+            case 'U':
+                if (save_temps_flag)
+                {
+                    obstack_grow(&obstack, input_basename, basename_length);
+                    delete_this_arg = 0;
+                }
+                else
+                {
+                    /* ??? This has a problem: the total number of
+                       values mktemp can return is limited.
+                       That matters for the names of object files.
+                       In 2.4, do something about that.  */
+                    struct temp_name *t;
+                    int suffix_length;
+                    char *suffix = p;
+
+                    if (p[0] == '%' && p[1] == 'O')
+                    {
+                        /* We don't support extra suffix characters after %O.  */
+                        if (*p == '.' || ISALPHA((unsigned char)*p))
+                            abort();
+                        suffix = OBJECT_SUFFIX;
+                        suffix_length = strlen(OBJECT_SUFFIX);
+                        p += 2;
+                    }
+                    else
+                    {
+                        while (*p == '.' || ISALPHA((unsigned char)*p))
+                            p++;
+                        suffix_length = p - suffix;
+                    }
+
+                    /* See if we already have an association of %g/%u/%U and
+                       suffix.  */
+                    for (t = temp_names; t; t = t->next)
+                        if (t->length == suffix_length
+                            && strncmp(t->suffix, suffix, suffix_length) == 0
+                            && t->unique == (c != 'g'))
+                            break;
+
+                    /* Make a new association if needed.  %u requires one.  */
+                    if (t == 0 || c == 'u')
+                    {
+                        if (t == 0)
+                        {
+                            t = (struct temp_name *) xmalloc(sizeof (struct temp_name));
+                            t->next = temp_names;
+                            temp_names = t;
+                        }
+                        t->length = suffix_length;
+                        t->suffix = save_string(suffix, suffix_length);
+                        t->unique = (c != 'g');
+                        temp_filename = make_temp_file(t->suffix);
+                        temp_filename_length = strlen(temp_filename);
+                        t->filename = temp_filename;
+                        t->filename_length = temp_filename_length;
+                    }
+
+                    obstack_grow(&obstack, t->filename, t->filename_length);
+                    delete_this_arg = 1;
+                    delete_this_arg = 1;
+                }
+                arg_going = 1;
+                break;
+
+            case 'i':
+                obstack_grow(&obstack, input_filename, input_filename_length);
+                arg_going = 1;
+                break;
+
+            case 'I':
+            {
+                struct prefix_list *pl = include_prefixes.plist;
+
+                for (; pl; pl = pl->next)
+                {
+                    do_spec_1("-isystem", 1, NULL);
+                    /* Make this a separate argument.  */
+                    do_spec_1(" ", 0, NULL);
+                    do_spec_1(pl->prefix, 1, NULL);
+                    do_spec_1(" ", 0, NULL);
+                }
+            }
+            break;
+
+            case 'o':
+            {
+                int max = n_infiles;
+                for (i = 0; i < max; i++)
+                    if (outfiles[i])
+                        store_arg(outfiles[i], 0, 0);
+                break;
+            }
+
+            case 'O':
+                obstack_grow(&obstack, OBJECT_SUFFIX, strlen(OBJECT_SUFFIX));
+                arg_going = 1;
+                break;
+
+            case 's':
+                this_is_library_file = 1;
+                break;
+
+            case 'w':
+                this_is_output_file = 1;
+                break;
+
+            case 'W':
+            {
+                int cur_index = argbuf_index;
+                /* Handle the {...} following the %W.  */
+                if (*p != '{')
+                    abort();
+                p = handle_braces(p + 1);
+                if (p == 0)
+                    return -1;
+                /* If any args were output, mark the last one for deletion
+                   on failure.  */
+                if (argbuf_index != cur_index)
+                    record_temp_file(argbuf[argbuf_index - 1], 0, 1);
+                break;
+            }
+
+            /* %x{OPTION} records OPTION for %X to output.  */
+            case 'x':
+            {
+                char *p1 = p;
+                char *string;
+
+                /* Skip past the option value and make a copy.  */
+                if (*p != '{')
+                    abort();
+                while (*p++ != '}')
+                    ;
+                string = save_string(p1 + 1, p - p1 - 2);
+
+                /* See if we already recorded this option.  */
+                for (i = 0; i < n_linker_options; i++)
+                    if (!strcmp(string, linker_options[i]))
+                    {
+                        free(string);
+                        return 0;
+                    }
+
+                /* This option is new; add it.  */
+                add_linker_option(string, strlen(string));
+            }
+            break;
+
+            /* Dump out the options accumulated previously using %x.  */
+            case 'X':
+                for (i = 0; i < n_linker_options; i++)
+                {
+                    do_spec_1(linker_options[i], 1, NULL);
+                    /* Make each accumulated option a separate argument.  */
+                    do_spec_1(" ", 0, NULL);
+                }
+                break;
+
+            /* Dump out the options accumulated previously using -Wa,.  */
+            case 'Y':
+                for (i = 0; i < n_assembler_options; i++)
+                {
+                    do_spec_1(assembler_options[i], 1, NULL);
+                    /* Make each accumulated option a separate argument.  */
+                    do_spec_1(" ", 0, NULL);
+                }
+                break;
+
+            /* Dump out the options accumulated previously using -Wp,.  */
+            case 'Z':
+                for (i = 0; i < n_preprocessor_options; i++)
+                {
+                    do_spec_1(preprocessor_options[i], 1, NULL);
+                    /* Make each accumulated option a separate argument.  */
+                    do_spec_1(" ", 0, NULL);
+                }
+                break;
+
+            /* Here are digits and numbers that just process
+               a certain constant string as a spec.  */
+
+            case '1':
+                value = do_spec_1(cc1_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'a':
+                value = do_spec_1(asm_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'A':
+                value = do_spec_1(asm_final_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'c':
+                value = do_spec_1(signed_char_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'C':
+                value = do_spec_1(cpp_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'E':
+                value = do_spec_1(endfile_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'l':
+                value = do_spec_1(link_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'L':
+                value = do_spec_1(lib_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'G':
+                value = do_spec_1(libgcc_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            case 'p':
+            {
+                char *x = (char *) alloca(strlen(cpp_predefines) + 1);
+                char *buf = x;
+                char *y;
+
+                /* Copy all of the -D options in CPP_PREDEFINES into BUF.  */
+                y = cpp_predefines;
+                while (*y != 0)
+                {
+                    if (!strncmp(y, "-D", 2))
+                        /* Copy the whole option.  */
+                        while (*y && *y != ' ' && *y != '\t')
+                            *x++ = *y++;
+                    else if (*y == ' ' || *y == '\t')
+                        /* Copy whitespace to the result.  */
+                        *x++ = *y++;
+                    /* Don't copy other options.  */
+                    else
+                        y++;
+                }
+
+                *x = 0;
+
+                value = do_spec_1(buf, 0, NULL);
+                if (value != 0)
+                    return value;
+            }
+            break;
+
+            case 'P':
+            {
+                char *x = (char *) alloca(strlen(cpp_predefines) * 4 + 1);
+                char *buf = x;
+                char *y;
+
+                /* Copy all of CPP_PREDEFINES into BUF,
+                   but put __ after every -D and at the end of each arg.  */
+                y = cpp_predefines;
+                while (*y != 0)
+                {
+                    if (!strncmp(y, "-D", 2))
+                    {
+                        int flag = 0;
+
+                        *x++ = *y++;
+                        *x++ = *y++;
+
+                        if (*y != '_'
+                            || (*(y+1) != '_'
+                                && !ISUPPER((unsigned char)*(y+1))))
+                        {
+                            /* Stick __ at front of macro name.  */
+                            *x++ = '_';
+                            *x++ = '_';
+                            /* Arrange to stick __ at the end as well.  */
+                            flag = 1;
+                        }
+
+                        /* Copy the macro name.  */
+                        while (*y && *y != '=' && *y != ' ' && *y != '\t')
+                            *x++ = *y++;
+
+                        if (flag)
+                        {
+                            *x++ = '_';
+                            *x++ = '_';
+                        }
+
+                        /* Copy the value given, if any.  */
+                        while (*y && *y != ' ' && *y != '\t')
+                            *x++ = *y++;
+                    }
+                    else if (*y == ' ' || *y == '\t')
+                        /* Copy whitespace to the result.  */
+                        *x++ = *y++;
+                    /* Don't copy -A options  */
+                    else
+                        y++;
+                }
+                *x++ = ' ';
+
+                /* Copy all of CPP_PREDEFINES into BUF,
+                   but put __ after every -D.  */
+                y = cpp_predefines;
+                while (*y != 0)
+                {
+                    if (!strncmp(y, "-D", 2))
+                    {
+                        y += 2;
+
+                        if (*y != '_'
+                            || (*(y+1) != '_'
+                                && !ISUPPER((unsigned char)*(y+1))))
+                        {
+                            /* Stick -D__ at front of macro name.  */
+                            *x++ = '-';
+                            *x++ = 'D';
+                            *x++ = '_';
+                            *x++ = '_';
+
+                            /* Copy the macro name.  */
+                            while (*y && *y != '=' && *y != ' ' && *y != '\t')
+                                *x++ = *y++;
+
+                            /* Copy the value given, if any.  */
+                            while (*y && *y != ' ' && *y != '\t')
+                                *x++ = *y++;
+                        }
+                        else
+                        {
+                            /* Do not copy this macro - we have just done it before */
+                            while (*y && *y != ' ' && *y != '\t')
+                                y++;
+                        }
+                    }
+                    else if (*y == ' ' || *y == '\t')
+                        /* Copy whitespace to the result.  */
+                        *x++ = *y++;
+                    /* Don't copy -A options  */
+                    else
+                        y++;
+                }
+                *x++ = ' ';
+
+                /* Copy all of the -A options in CPP_PREDEFINES into BUF.  */
+                y = cpp_predefines;
+                while (*y != 0)
+                {
+                    if (!strncmp(y, "-A", 2))
+                        /* Copy the whole option.  */
+                        while (*y && *y != ' ' && *y != '\t')
+                            *x++ = *y++;
+                    else if (*y == ' ' || *y == '\t')
+                        /* Copy whitespace to the result.  */
+                        *x++ = *y++;
+                    /* Don't copy other options.  */
+                    else
+                        y++;
+                }
+
+                *x = 0;
+
+                value = do_spec_1(buf, 0, NULL);
+                if (value != 0)
+                    return value;
+            }
+            break;
+
+            case 'S':
+                value = do_spec_1(startfile_spec, 0, NULL);
+                if (value != 0)
+                    return value;
+                break;
+
+            /* Here we define characters other than letters and digits.  */
+
+            case '{':
+                p = handle_braces(p);
+                if (p == 0)
+                    return -1;
+                break;
+
+            case '%':
+                obstack_1grow(&obstack, '%');
+                break;
+
+            case '*':
+                do_spec_1(soft_matched_part, 1, NULL);
+                do_spec_1(" ", 0, NULL);
+                break;
+
+            /* Process a string found as the value of a spec given by name.
+               This feature allows individual machine descriptions
+               to add and use their own specs.
+               %[...] modifies -D options the way %P does;
+               %(...) uses the spec unmodified.  */
+            case '[':
+                error("Warning: use of obsolete %%[ operator in specs");
+            case '(':
+            {
+                char *name = p;
+                struct spec_list *sl;
+                int len;
+
+                /* The string after the S/P is the name of a spec that is to be
+                   processed.  */
+                while (*p && *p != ')' && *p != ']')
+                    p++;
+
+                /* See if it's in the list */
+                for (len = p - name, sl = specs; sl; sl = sl->next)
+                    if (sl->name_len == len && !strncmp(sl->name, name, len))
+                    {
+                        name = *(sl->ptr_spec);
 #ifdef DEBUG_SPECS
-		    fprintf (stderr, "Processing spec %c%s%c, which is '%s'\n",
-			     c, sl->name, (c == '(') ? ')' : ']', name);
+                        fprintf(stderr, "Processing spec %c%s%c, which is '%s'\n",
+                                c, sl->name, (c == '(') ? ')' : ']', name);
 #endif
-		    break;
-		  }
-
-	      if (sl)
-		{
-		  if (c == '(')
-		    {
-		      value = do_spec_1 (name, 0, NULL);
-		      if (value != 0)
-			return value;
-		    }
-		  else
-		    {
-		      char *x = (char *) alloca (strlen (name) * 2 + 1);
-		      char *buf = x;
-		      char *y = name;
-		      int flag = 0;
-
-		      /* Copy all of NAME into BUF, but put __ after
-			 every -D and at the end of each arg,  */
-		      while (1)
-			{
-			  if (! strncmp (y, "-D", 2))
-			    {
-			      *x++ = '-';
-			      *x++ = 'D';
-			      *x++ = '_';
-			      *x++ = '_';
-			      y += 2;
-			      flag = 1;
-			      continue;
-			    }
-                          else if (flag && (*y == ' ' || *y == '\t' || *y == '='
-                                            || *y == '}' || *y == 0))
-			    {
-			      *x++ = '_';
-			      *x++ = '_';
-			      flag = 0;
-			    }
-                          if (*y == 0)
-			    break;
-			  else
-			    *x++ = *y++;
-			}
-		      *x = 0;
-
-		      value = do_spec_1 (buf, 0, NULL);
-		      if (value != 0)
-			return value;
-		    }
-		}
-
-	      /* Discard the closing paren or bracket.  */
-	      if (*p)
-		p++;
-	    }
-	    break;
-
-	  case 'v':
-	    {
-	      int c1 = *p++;  /* Select first or second version number.  */
-	      char *v = compiler_version;
-	      char *q;
-
-	      /* The format of the version string is
-		 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
-
-	      /* Ignore leading non-digits.  i.e. "foo-" in "foo-2.7.2".  */
-	      while (! ISDIGIT (*v))
-		v++;
-	      if (v > compiler_version && v[-1] != '-')
-		abort ();
-
-	      /* If desired, advance to second version number.  */
-	      if (c1 == '2')
-		{
-		  /* Set V after the first period.  */
-		  while (ISDIGIT (*v))
-		    v++;
-		  if (*v != '.')
-		    abort ();
-		  v++;
-		}
-
-	      /* Set Q at the next period or at the end.  */
-	      q = v;
-	      while (ISDIGIT (*q))
-		q++;
-	      if (*q != 0 && *q != ' ' && *q != '.' && *q != '-')
-		abort ();
-
-	      /* Put that part into the command.  */
-	      obstack_grow (&obstack, v, q - v);
-	      arg_going = 1;
-	    }
-	    break;
-
-	  case '|':
-	    if (input_from_pipe)
-	      do_spec_1 ("-", 0, NULL);
-	    break;
-
-	  default:
-	    abort ();
-	  }
-	break;
-
-      case '\\':
-	/* Backslash: treat next character as ordinary.  */
-	c = *p++;
-
-	/* fall through */
-      default:
-	/* Ordinary character: put it into the current argument.  */
-	obstack_1grow (&obstack, c);
-	arg_going = 1;
-      }
-
-  return 0;		/* End of string */
+                        break;
+                    }
+
+                if (sl)
+                {
+                    if (c == '(')
+                    {
+                        value = do_spec_1(name, 0, NULL);
+                        if (value != 0)
+                            return value;
+                    }
+                    else
+                    {
+                        char *x = (char *) alloca(strlen(name) * 2 + 1);
+                        char *buf = x;
+                        char *y = name;
+                        int flag = 0;
+
+                        /* Copy all of NAME into BUF, but put __ after
+                           every -D and at the end of each arg,  */
+                        while (1)
+                        {
+                            if (!strncmp(y, "-D", 2))
+                            {
+                                *x++ = '-';
+                                *x++ = 'D';
+                                *x++ = '_';
+                                *x++ = '_';
+                                y += 2;
+                                flag = 1;
+                                continue;
+                            }
+                            else if (flag && (*y == ' ' || *y == '\t' || *y == '='
+                                              || *y == '}' || *y == 0))
+                            {
+                                *x++ = '_';
+                                *x++ = '_';
+                                flag = 0;
+                            }
+                            if (*y == 0)
+                                break;
+                            else
+                                *x++ = *y++;
+                        }
+                        *x = 0;
+
+                        value = do_spec_1(buf, 0, NULL);
+                        if (value != 0)
+                            return value;
+                    }
+                }
+
+                /* Discard the closing paren or bracket.  */
+                if (*p)
+                    p++;
+            }
+            break;
+
+            case 'v':
+            {
+                int c1 = *p++; /* Select first or second version number.  */
+                char *v = compiler_version;
+                char *q;
+
+                /* The format of the version string is
+                   ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
+
+                /* Ignore leading non-digits.  i.e. "foo-" in "foo-2.7.2".  */
+                while (!ISDIGIT(*v))
+                    v++;
+                if (v > compiler_version && v[-1] != '-')
+                    abort();
+
+                /* If desired, advance to second version number.  */
+                if (c1 == '2')
+                {
+                    /* Set V after the first period.  */
+                    while (ISDIGIT(*v))
+                        v++;
+                    if (*v != '.')
+                        abort();
+                    v++;
+                }
+
+                /* Set Q at the next period or at the end.  */
+                q = v;
+                while (ISDIGIT(*q))
+                    q++;
+                if (*q != 0 && *q != ' ' && *q != '.' && *q != '-')
+                    abort();
+
+                /* Put that part into the command.  */
+                obstack_grow(&obstack, v, q - v);
+                arg_going = 1;
+            }
+            break;
+
+            case '|':
+                if (input_from_pipe)
+                    do_spec_1("-", 0, NULL);
+                break;
+
+            default:
+                abort();
+            }
+            break;
+
+        case '\\':
+            /* Backslash: treat next character as ordinary.  */
+            c = *p++;
+
+        /* fall through */
+        default:
+            /* Ordinary character: put it into the current argument.  */
+            obstack_1grow(&obstack, c);
+            arg_going = 1;
+        }
+
+    return 0;           /* End of string */
 }
 
 /* Return 0 if we call do_spec_1 and that returns -1.  */
 
 static char *
-handle_braces (p)
-     register char *p;
+handle_braces(register char *p)
 {
-  char *filter, *body = NULL, *endbody;
-  int pipe_p = 0;
-  int negate;
-  int suffix;
-  int include_blanks = 1;
-
-  if (*p == '^')
-    /* A '^' after the open-brace means to not give blanks before args.  */
-    include_blanks = 0, ++p;
-
-  if (*p == '|')
-    /* A `|' after the open-brace means,
-       if the test fails, output a single minus sign rather than nothing.
-       This is used in %{|!pipe:...}.  */
-    pipe_p = 1, ++p;
+    char *filter, *body = NULL, *endbody;
+    int pipe_p = 0;
+    int negate;
+    int suffix;
+    int include_blanks = 1;
+
+    if (*p == '^')
+        /* A '^' after the open-brace means to not give blanks before args.  */
+        include_blanks = 0, ++p;
+
+    if (*p == '|')
+        /* A `|' after the open-brace means,
+           if the test fails, output a single minus sign rather than nothing.
+           This is used in %{|!pipe:...}.  */
+        pipe_p = 1, ++p;
 
 next_member:
-  negate = suffix = 0;
+    negate = suffix = 0;
 
-  if (*p == '!')
-    /* A `!' after the open-brace negates the condition:
-       succeed if the specified switch is not present.  */
-    negate = 1, ++p;
+    if (*p == '!')
+        /* A `!' after the open-brace negates the condition:
+           succeed if the specified switch is not present.  */
+        negate = 1, ++p;
 
-  if (*p == '.')
+    if (*p == '.')
     /* A `.' after the open-brace means test against the current suffix.  */
     {
-      if (pipe_p)
-	abort ();
+        if (pipe_p)
+            abort();
 
-      suffix = 1;
-      ++p;
+        suffix = 1;
+        ++p;
     }
 
-  filter = p;
-  while (*p != ':' && *p != '}' && *p != '|') p++;
+    filter = p;
+    while (*p != ':' && *p != '}' && *p != '|') p++;
 
-  if (*p == '|' && pipe_p)
-    abort ();
+    if (*p == '|' && pipe_p)
+        abort();
 
-  if (!body)
+    if (!body)
     {
-      if (*p != '}')
+        if (*p != '}')
         {
-	  register int count = 1;
-	  register char *q = p;
-
-	  while (*q++ != ':') continue;
-	  body = q;
-	  
-	  while (count > 0)
-	    {
-	      if (*q == '{')
-	        count++;
-	      else if (*q == '}')
-	        count--;
-	      else if (*q == 0)
-	        abort ();
-	      q++;
-	    }
-	  endbody = q;
-	}
-      else
-	body = p, endbody = p+1;
+            register int count = 1;
+            register char *q = p;
+
+            while (*q++ != ':') continue;
+            body = q;
+
+            while (count > 0)
+            {
+                if (*q == '{')
+                    count++;
+                else if (*q == '}')
+                    count--;
+                else if (*q == 0)
+                    abort();
+                q++;
+            }
+            endbody = q;
+        }
+        else
+            body = p, endbody = p+1;
     }
 
-  if (suffix)
+    if (suffix)
     {
-      int found = (input_suffix != 0
-		   && (long) strlen (input_suffix) == (long)(p - filter)
-		   && strncmp (input_suffix, filter, p - filter) == 0);
+        int found = (input_suffix != 0
+                     && (long) strlen(input_suffix) == (long)(p - filter)
+                     && strncmp(input_suffix, filter, p - filter) == 0);
 
-      if (body[0] == '}')
-	abort ();
+        if (body[0] == '}')
+            abort();
 
-      if (negate != found
-	  && do_spec_1 (save_string (body, endbody-body-1), 0, NULL) < 0)
-	return 0;
+        if (negate != found
+            && do_spec_1(save_string(body, endbody-body-1), 0, NULL) < 0)
+            return 0;
     }
-  else if (p[-1] == '*' && p[0] == '}')
+    else if (p[-1] == '*' && p[0] == '}')
     {
-      /* Substitute all matching switches as separate args.  */
-      register int i;
-      --p;
-      for (i = 0; i < n_switches; i++)
-	if (!strncmp (switches[i].part1, filter, p - filter)
-	    && check_live_switch (i, p - filter))
-	  give_switch (i, 0, include_blanks);
+        /* Substitute all matching switches as separate args.  */
+        register int i;
+        --p;
+        for (i = 0; i < n_switches; i++)
+            if (!strncmp(switches[i].part1, filter, p - filter)
+                && check_live_switch(i, p - filter))
+                give_switch(i, 0, include_blanks);
     }
-  else
+    else
     {
-      /* Test for presence of the specified switch.  */
-      register int i;
-      int present = 0;
-
-      /* If name specified ends in *, as in {x*:...},
-	 check for %* and handle that case.  */
-      if (p[-1] == '*' && !negate)
-	{
-	  int substitution;
-	  char *r = body;
-
-	  /* First see whether we have %*.  */
-	  substitution = 0;
-	  while (r < endbody)
-	    {
-	      if (*r == '%' && r[1] == '*')
-		substitution = 1;
-	      r++;
-	    }
-	  /* If we do, handle that case.  */
-	  if (substitution)
-	    {
-	      /* Substitute all matching switches as separate args.
-		 But do this by substituting for %*
-		 in the text that follows the colon.  */
-
-	      unsigned hard_match_len = p - filter - 1;
-	      char *string = save_string (body, endbody - body - 1);
-
-	      for (i = 0; i < n_switches; i++)
-		if (!strncmp (switches[i].part1, filter, hard_match_len)
-		    && check_live_switch (i, -1))
-		  {
-		    do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
-		    /* Pass any arguments this switch has.  */
-		    give_switch (i, 1, 1);
-		  }
-
-	      /* We didn't match.  Try again.  */
-	      if (*p++ == '|')
-		goto next_member;
-	      return endbody;
-	    }
-	}
-
-      /* If name specified ends in *, as in {x*:...},
-	 check for presence of any switch name starting with x.  */
-      if (p[-1] == '*')
-	{
-	  for (i = 0; i < n_switches; i++)
-	    {
-	      unsigned hard_match_len = p - filter - 1;
-
-	      if (!strncmp (switches[i].part1, filter, hard_match_len)
-		  && check_live_switch (i, hard_match_len))
-		{
-		  present = 1;
-		}
-	    }
-	}
-      /* Otherwise, check for presence of exact name specified.  */
-      else
-	{
-	  for (i = 0; i < n_switches; i++)
-	    {
-	      if (!strncmp (switches[i].part1, filter, p - filter)
-		  && switches[i].part1[p - filter] == 0
-		  && check_live_switch (i, -1))
-		{
-		  present = 1;
-		  break;
-		}
-	    }
-	}
-
-      /* If it is as desired (present for %{s...}, absent for %{!s...})
-	 then substitute either the switch or the specified
-	 conditional text.  */
-      if (present != negate)
-	{
-	  if (*p == '}')
-	    {
-	      give_switch (i, 0, include_blanks);
-	    }
-	  else
-	    {
-	      if (do_spec_1 (save_string (body, endbody - body - 1),
-			     0, NULL) < 0)
-		return 0;
-	    }
-	}
-      else if (pipe_p)
-	{
-	  /* Here if a %{|...} conditional fails: output a minus sign,
-	     which means "standard output" or "standard input".  */
-	  do_spec_1 ("-", 0, NULL);
-	  return endbody;
-	}
+        /* Test for presence of the specified switch.  */
+        register int i;
+        int present = 0;
+
+        /* If name specified ends in *, as in {x*:...},
+           check for %* and handle that case.  */
+        if (p[-1] == '*' && !negate)
+        {
+            int substitution;
+            char *r = body;
+
+            /* First see whether we have %*.  */
+            substitution = 0;
+            while (r < endbody)
+            {
+                if (*r == '%' && r[1] == '*')
+                    substitution = 1;
+                r++;
+            }
+            /* If we do, handle that case.  */
+            if (substitution)
+            {
+                /* Substitute all matching switches as separate args.
+                   But do this by substituting for %*
+                   in the text that follows the colon.  */
+
+                unsigned hard_match_len = p - filter - 1;
+                char *string = save_string(body, endbody - body - 1);
+
+                for (i = 0; i < n_switches; i++)
+                    if (!strncmp(switches[i].part1, filter, hard_match_len)
+                        && check_live_switch(i, -1))
+                    {
+                        do_spec_1(string, 0, &switches[i].part1[hard_match_len]);
+                        /* Pass any arguments this switch has.  */
+                        give_switch(i, 1, 1);
+                    }
+
+                /* We didn't match.  Try again.  */
+                if (*p++ == '|')
+                    goto next_member;
+                return endbody;
+            }
+        }
+
+        /* If name specified ends in *, as in {x*:...},
+           check for presence of any switch name starting with x.  */
+        if (p[-1] == '*')
+        {
+            for (i = 0; i < n_switches; i++)
+            {
+                unsigned hard_match_len = p - filter - 1;
+
+                if (!strncmp(switches[i].part1, filter, hard_match_len)
+                    && check_live_switch(i, hard_match_len))
+                {
+                    present = 1;
+                }
+            }
+        }
+        /* Otherwise, check for presence of exact name specified.  */
+        else
+        {
+            for (i = 0; i < n_switches; i++)
+            {
+                if (!strncmp(switches[i].part1, filter, p - filter)
+                    && switches[i].part1[p - filter] == 0
+                    && check_live_switch(i, -1))
+                {
+                    present = 1;
+                    break;
+                }
+            }
+        }
+
+        /* If it is as desired (present for %{s...}, absent for %{!s...})
+           then substitute either the switch or the specified
+           conditional text.  */
+        if (present != negate)
+        {
+            if (*p == '}')
+            {
+                give_switch(i, 0, include_blanks);
+            }
+            else
+            {
+                if (do_spec_1(save_string(body, endbody - body - 1),
+                              0, NULL) < 0)
+                    return 0;
+            }
+        }
+        else if (pipe_p)
+        {
+            /* Here if a %{|...} conditional fails: output a minus sign,
+               which means "standard output" or "standard input".  */
+            do_spec_1("-", 0, NULL);
+            return endbody;
+        }
     }
 
-  /* We didn't match; try again.  */
-  if (*p++ == '|')
-    goto next_member;
+    /* We didn't match; try again.  */
+    if (*p++ == '|')
+        goto next_member;
 
-  return endbody;
+    return endbody;
 }
-
+
 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
    spec, or -1 if either exact match or %* is used.
@@ -4118,73 +3863,71 @@ next_member:
    with the "no-", similarly for a switch with the "no-" prefix.  */
 
 static int
-check_live_switch (switchnum, prefix_length)
-     int switchnum;
-     int prefix_length;
+check_live_switch(int switchnum, int prefix_length)
 {
-  char *name = switches[switchnum].part1;
-  int i;
-
-  /* In the common case of {<at-most-one-letter>*}, a negating
-     switch would always match, so ignore that case.  We will just
-     send the conflicting switches to the compiler phase.  */
-  if (prefix_length >= 0 && prefix_length <= 1)
-    return 1;
-
-  /* If we already processed this switch and determined if it was
-     live or not, return our past determination.  */
-  if (switches[switchnum].live_cond != 0)
-    return switches[switchnum].live_cond > 0;
-
-  /* Now search for duplicate in a manner that depends on the name.  */
-  switch (*name)
+    char *name = switches[switchnum].part1;
+    int i;
+
+    /* In the common case of {<at-most-one-letter>*}, a negating
+       switch would always match, so ignore that case.  We will just
+       send the conflicting switches to the compiler phase.  */
+    if (prefix_length >= 0 && prefix_length <= 1)
+        return 1;
+
+    /* If we already processed this switch and determined if it was
+       live or not, return our past determination.  */
+    if (switches[switchnum].live_cond != 0)
+        return switches[switchnum].live_cond > 0;
+
+    /* Now search for duplicate in a manner that depends on the name.  */
+    switch (*name)
     {
     case 'O':
-	for (i = switchnum + 1; i < n_switches; i++)
-	  if (switches[i].part1[0] == 'O')
-	    {
-	      switches[switchnum].valid = 1;
-	      switches[switchnum].live_cond = -1;
-	      return 0;
-	    }
-      break;
+        for (i = switchnum + 1; i < n_switches; i++)
+            if (switches[i].part1[0] == 'O')
+            {
+                switches[switchnum].valid = 1;
+                switches[switchnum].live_cond = -1;
+                return 0;
+            }
+        break;
 
     case 'W':  case 'f':  case 'm':
-      if (! strncmp (name + 1, "no-", 3))
-	{
-	  /* We have Xno-YYY, search for XYYY.  */
-	  for (i = switchnum + 1; i < n_switches; i++)
-	    if (switches[i].part1[0] == name[0]
-		&& ! strcmp (&switches[i].part1[1], &name[4]))
-	    {
-	      switches[switchnum].valid = 1;
-	      switches[switchnum].live_cond = -1;
-	      return 0;
-	    }
-	}
-      else
-	{
-	  /* We have XYYY, search for Xno-YYY.  */
-	  for (i = switchnum + 1; i < n_switches; i++)
-	    if (switches[i].part1[0] == name[0]
-		&& switches[i].part1[1] == 'n'
-		&& switches[i].part1[2] == 'o'
-		&& switches[i].part1[3] == '-'
-		&& !strcmp (&switches[i].part1[4], &name[1]))
-	    {
-	      switches[switchnum].valid = 1;
-	      switches[switchnum].live_cond = -1;
-	      return 0;
-	    }
-	}
-      break;
+        if (!strncmp(name + 1, "no-", 3))
+        {
+            /* We have Xno-YYY, search for XYYY.  */
+            for (i = switchnum + 1; i < n_switches; i++)
+                if (switches[i].part1[0] == name[0]
+                    && !strcmp(&switches[i].part1[1], &name[4]))
+                {
+                    switches[switchnum].valid = 1;
+                    switches[switchnum].live_cond = -1;
+                    return 0;
+                }
+        }
+        else
+        {
+            /* We have XYYY, search for Xno-YYY.  */
+            for (i = switchnum + 1; i < n_switches; i++)
+                if (switches[i].part1[0] == name[0]
+                    && switches[i].part1[1] == 'n'
+                    && switches[i].part1[2] == 'o'
+                    && switches[i].part1[3] == '-'
+                    && !strcmp(&switches[i].part1[4], &name[1]))
+                {
+                    switches[switchnum].valid = 1;
+                    switches[switchnum].live_cond = -1;
+                    return 0;
+                }
+        }
+        break;
     }
 
-  /* Otherwise the switch is live.  */
-  switches[switchnum].live_cond = 1;
-  return 1;
+    /* Otherwise the switch is live.  */
+    switches[switchnum].live_cond = 1;
+    return 1;
 }
-
+
 /* Pass a switch to the current accumulating command
    in the same form that we received it.
    SWITCHNUM identifies the switch; it is an index into
@@ -4197,62 +3940,58 @@ check_live_switch (switchnum, prefix_length)
    of the switch.  */
 
 static void
-give_switch (switchnum, omit_first_word, include_blanks)
-     int switchnum;
-     int omit_first_word;
-     int include_blanks;
+give_switch(int switchnum, int omit_first_word, int include_blanks)
 {
-  if (!omit_first_word)
+    if (!omit_first_word)
     {
-      do_spec_1 ("-", 0, NULL);
-      do_spec_1 (switches[switchnum].part1, 1, NULL);
+        do_spec_1("-", 0, NULL);
+        do_spec_1(switches[switchnum].part1, 1, NULL);
     }
 
-  if (switches[switchnum].args != 0)
+    if (switches[switchnum].args != 0)
     {
-      char **p;
-      for (p = switches[switchnum].args; *p; p++)
-	{
-	  if (include_blanks)
-	    do_spec_1 (" ", 0, NULL);
-	  do_spec_1 (*p, 1, NULL);
-	}
+        char **p;
+        for (p = switches[switchnum].args; *p; p++)
+        {
+            if (include_blanks)
+                do_spec_1(" ", 0, NULL);
+            do_spec_1(*p, 1, NULL);
+        }
     }
 
-  do_spec_1 (" ", 0, NULL);
-  switches[switchnum].valid = 1;
+    do_spec_1(" ", 0, NULL);
+    switches[switchnum].valid = 1;
 }
-
+
 /* Search for a file named NAME trying various prefixes including the
    user's -B prefix and some standard ones.
    Return the absolute file name found.  If nothing is found, return NAME.  */
 
 static char *
-find_file (name)
-     char *name;
+find_file(char *name)
 {
-  char *newname;
+    char *newname;
 
-  /* Try multilib_dir if it is defined.  */
-  if (multilib_dir != NULL)
+    /* Try multilib_dir if it is defined.  */
+    if (multilib_dir != NULL)
     {
-      char *try;
+        char *try;
 
-      try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2);
-      strcpy (try, multilib_dir);
-      strcat (try, dir_separator_str);
-      strcat (try, name);
+        try = (char *) alloca(strlen(multilib_dir) + strlen(name) + 2);
+        strcpy(try, multilib_dir);
+        strcat(try, dir_separator_str);
+        strcat(try, name);
 
-      newname = find_a_file (&startfile_prefixes, try, R_OK);
+        newname = find_a_file(&startfile_prefixes, try, R_OK);
 
-      /* If we don't find it in the multi library dir, then fall
-	 through and look for it in the normal places.  */
-      if (newname != NULL)
-	return newname;
+        /* If we don't find it in the multi library dir, then fall
+           through and look for it in the normal places.  */
+        if (newname != NULL)
+            return newname;
     }
 
-  newname = find_a_file (&startfile_prefixes, name, R_OK);
-  return newname ? newname : name;
+    newname = find_a_file(&startfile_prefixes, name, R_OK);
+    return newname ? newname : name;
 }
 
 /* Determine whether a directory exists.  If LINKER, return 0 for
@@ -4261,494 +4000,488 @@ find_file (name)
    limit.  */
 
 static int
-is_directory (path1, path2, linker)
-     char *path1;
-     char *path2;
-     int linker;
+is_directory(char *path1, char *path2, int linker)
 {
-  int len1 = strlen (path1);
-  int len2 = strlen (path2);
-  char *path = (char *) alloca (3 + len1 + len2);
-  char *cp;
-  struct stat st;
+    int len1 = strlen(path1);
+    int len2 = strlen(path2);
+    char *path = (char *) alloca(3 + len1 + len2);
+    char *cp;
+    struct stat st;
 
 #ifndef SMALL_ARG_MAX
-  if (! linker)
-    return 1;
+    if (!linker)
+        return 1;
 #endif
 
-  /* Construct the path from the two parts.  Ensure the string ends with "/.".
-     The resulting path will be a directory even if the given path is a
-     symbolic link.  */
-  memcpy (path, path1, len1);
-  memcpy (path + len1, path2, len2);
-  cp = path + len1 + len2;
-  if (cp[-1] != '/' && cp[-1] != DIR_SEPARATOR)
-    *cp++ = DIR_SEPARATOR;
-  *cp++ = '.';
-  *cp = '\0';
-
-  /* Exclude directories that the linker is known to search.  */
-  if (linker
-      && ((cp - path == 6
-	   && strcmp (path, concat (dir_separator_str, "lib", 
-				    dir_separator_str, ".", NULL)) == 0)
-	  || (cp - path == 10
-	      && strcmp (path, concat (dir_separator_str, "usr", 
-				       dir_separator_str, "lib", 
-				       dir_separator_str, ".", NULL)) == 0)))
-    return 0;
-
-  return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
+    /* Construct the path from the two parts.  Ensure the string ends with "/.".
+       The resulting path will be a directory even if the given path is a
+       symbolic link.  */
+    memcpy(path, path1, len1);
+    memcpy(path + len1, path2, len2);
+    cp = path + len1 + len2;
+    if (cp[-1] != '/' && cp[-1] != DIR_SEPARATOR)
+        *cp++ = DIR_SEPARATOR;
+    *cp++ = '.';
+    *cp = '\0';
+
+    /* Exclude directories that the linker is known to search.  */
+    if (linker
+        && ((cp - path == 6
+             && strcmp(path, concat(dir_separator_str, "lib",
+                                    dir_separator_str, ".", NULL)) == 0)
+            || (cp - path == 10
+                && strcmp(path, concat(dir_separator_str, "usr",
+                                       dir_separator_str, "lib",
+                                       dir_separator_str, ".", NULL)) == 0)))
+        return 0;
+
+    return (stat(path, &st) >= 0 && S_ISDIR(st.st_mode));
 }
-
+
 /* On fatal signals, delete all the temporary files.  */
 
 static void
-fatal_error (signum)
-     int signum;
+fatal_error(int signum)
 {
-  signal (signum, SIG_DFL);
-  delete_failure_queue ();
-  delete_temp_files ();
-  /* Get the same signal again, this time not handled,
-     so its normal effect occurs.  */
-  kill (getpid (), signum);
+    signal(signum, SIG_DFL);
+    delete_failure_queue();
+    delete_temp_files();
+    /* Get the same signal again, this time not handled,
+       so its normal effect occurs.  */
+    kill(getpid(), signum);
 }
 
 int
-main (argc, argv)
-     int argc;
-     char **argv;
+main(int argc, char **argv)
 {
-  register size_t i;
-  size_t j;
-  int value;
-  int linker_was_run = 0;
-  char *explicit_link_files;
-  char *specs_file;
-  char *p;
-  struct user_specs *uptr;
-
-  p = argv[0] + strlen (argv[0]);
-  while (p != argv[0] && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p;
-  programname = p;
-
-  if (signal (SIGINT, SIG_IGN) != SIG_IGN)
-    signal (SIGINT, fatal_error);
+    register size_t i;
+    size_t j;
+    int value;
+    int linker_was_run = 0;
+    char *explicit_link_files;
+    char *specs_file;
+    char *p;
+    struct user_specs *uptr;
+
+    p = argv[0] + strlen(argv[0]);
+    while (p != argv[0] && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p;
+    programname = p;
+
+    if (signal(SIGINT, SIG_IGN) != SIG_IGN)
+        signal(SIGINT, fatal_error);
 #ifdef SIGHUP
-  if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
-    signal (SIGHUP, fatal_error);
+    if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
+        signal(SIGHUP, fatal_error);
 #endif
-  if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
-    signal (SIGTERM, fatal_error);
+    if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
+        signal(SIGTERM, fatal_error);
 #ifdef SIGPIPE
-  if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
-    signal (SIGPIPE, fatal_error);
+    if (signal(SIGPIPE, SIG_IGN) != SIG_IGN)
+        signal(SIGPIPE, fatal_error);
 #endif
 
-  argbuf_length = 10;
-  argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
-
-  obstack_init (&obstack);
-
-  /* Build multilib_select, et. al from the separate lines that make up each
-     multilib selection.  */
-  {
-    char **q = multilib_raw;
-    int need_space;
-
-    obstack_init (&multilib_obstack);
-    while ((p = *q++) != (char *) 0)
-      obstack_grow (&multilib_obstack, p, strlen (p));
-
-    obstack_1grow (&multilib_obstack, 0);
-    multilib_select = obstack_finish (&multilib_obstack);
-
-    q = multilib_matches_raw;
-    while ((p = *q++) != (char *) 0)
-      obstack_grow (&multilib_obstack, p, strlen (p));
-
-    obstack_1grow (&multilib_obstack, 0);
-    multilib_matches = obstack_finish (&multilib_obstack);
-
-    need_space = FALSE;
-    for (i = 0;
-	 i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
-	 i++)
-      {
-	if (need_space)
-	  obstack_1grow (&multilib_obstack, ' ');
-	obstack_grow (&multilib_obstack,
-		      multilib_defaults_raw[i],
-		      strlen (multilib_defaults_raw[i]));
-	need_space = TRUE;
-      }
-
-    obstack_1grow (&multilib_obstack, 0);
-    multilib_defaults = obstack_finish (&multilib_obstack);
-  }
-
-  /* Set up to remember the pathname of gcc and any options
-     needed for collect.  We use argv[0] instead of programname because
-     we need the complete pathname.  */
-  obstack_init (&collect_obstack);
-  obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
-  obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
-  putenv (obstack_finish (&collect_obstack));
+    argbuf_length = 10;
+    argbuf = (char **) xmalloc(argbuf_length * sizeof (char *));
+
+    obstack_init(&obstack);
+
+    /* Build multilib_select, et. al from the separate lines that make up each
+       multilib selection.  */
+    {
+        char **q = multilib_raw;
+        int need_space;
+
+        obstack_init(&multilib_obstack);
+        while ((p = *q++) != (char *) 0)
+            obstack_grow(&multilib_obstack, p, strlen(p));
+
+        obstack_1grow(&multilib_obstack, 0);
+        multilib_select = obstack_finish(&multilib_obstack);
+
+        q = multilib_matches_raw;
+        while ((p = *q++) != (char *) 0)
+            obstack_grow(&multilib_obstack, p, strlen(p));
+
+        obstack_1grow(&multilib_obstack, 0);
+        multilib_matches = obstack_finish(&multilib_obstack);
+
+        need_space = FALSE;
+        for (i = 0;
+             i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
+             i++)
+        {
+            if (need_space)
+                obstack_1grow(&multilib_obstack, ' ');
+            obstack_grow(&multilib_obstack,
+                         multilib_defaults_raw[i],
+                         strlen(multilib_defaults_raw[i]));
+            need_space = TRUE;
+        }
+
+        obstack_1grow(&multilib_obstack, 0);
+        multilib_defaults = obstack_finish(&multilib_obstack);
+    }
+
+    /* Set up to remember the pathname of gcc and any options
+       needed for collect.  We use argv[0] instead of programname because
+       we need the complete pathname.  */
+    obstack_init(&collect_obstack);
+    obstack_grow(&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
+    obstack_grow(&collect_obstack, argv[0], strlen(argv[0])+1);
+    putenv(obstack_finish(&collect_obstack));
 
 #ifdef INIT_ENVIRONMENT
-  /* Set up any other necessary machine specific environment variables.  */
-  putenv (INIT_ENVIRONMENT);
+    /* Set up any other necessary machine specific environment variables.  */
+    putenv(INIT_ENVIRONMENT);
 #endif
 
-  /* Choose directory for temp files.  */
+    /* Choose directory for temp files.  */
 
 
-  /* Make a table of what switches there are (switches, n_switches).
-     Make a table of specified input files (infiles, n_infiles).
-     Decode switches that are handled locally.  */
+    /* Make a table of what switches there are (switches, n_switches).
+       Make a table of specified input files (infiles, n_infiles).
+       Decode switches that are handled locally.  */
 
-  process_command (argc, argv);
+    process_command(argc, argv);
 
-  {
-    int first_time;
+    {
+        int first_time;
 
-    /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
-       the compiler.  */
-    obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
-		  sizeof ("COLLECT_GCC_OPTIONS=")-1);
+        /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
+           the compiler.  */
+        obstack_grow(&collect_obstack, "COLLECT_GCC_OPTIONS=",
+                     sizeof ("COLLECT_GCC_OPTIONS=")-1);
 
-    first_time = TRUE;
-    for (i = 0; (int)i < n_switches; i++)
-      {
-	char **args;
-	char *p, *q;
-	if (!first_time)
-	  obstack_grow (&collect_obstack, " ", 1);
-
-	first_time = FALSE;
-	obstack_grow (&collect_obstack, "'-", 2);
-        q = switches[i].part1;
-	while ((p = strchr (q,'\'')))
-          {
-            obstack_grow (&collect_obstack, q, p-q);
-            obstack_grow (&collect_obstack, "'\\''", 4);
-            q = ++p;
-          }
-        obstack_grow (&collect_obstack, q, strlen (q));
-	obstack_grow (&collect_obstack, "'", 1);
-
-	for (args = switches[i].args; args && *args; args++)
-	  {
-	    obstack_grow (&collect_obstack, " '", 2);
-	    q = *args;
-	    while ((p = strchr (q,'\'')))
-	      {
-		obstack_grow (&collect_obstack, q, p-q);
-		obstack_grow (&collect_obstack, "'\\''", 4);
-		q = ++p;
-	      }
-	    obstack_grow (&collect_obstack, q, strlen (q));
-	    obstack_grow (&collect_obstack, "'", 1);
-	  }
-      }
-    obstack_grow (&collect_obstack, "\0", 1);
-    putenv (obstack_finish (&collect_obstack));
-  }
-
-  /* Initialize the vector of specs to just the default.
-     This means one element containing 0s, as a terminator.  */
-
-  compilers = (struct compiler *) xmalloc (sizeof default_compilers);
-  copy_memory ((char *) default_compilers, (char *) compilers,
-	 sizeof default_compilers);
-  n_compilers = n_default_compilers;
-
-  /* Read specs from a file if there is one.  */
-
-  machine_suffix = concat (spec_machine, dir_separator_str,
-			   spec_version, dir_separator_str, NULL);
-  just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
-
-  specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
-  /* Read the specs file unless it is a default one.  */
-  if (specs_file != 0 && strcmp (specs_file, "specs"))
-    read_specs (specs_file, TRUE);
-  else
-    init_spec ();
-
-  /* We need to check standard_exec_prefix/just_machine_suffix/specs
-     for any override of as, ld and libraries. */
-  specs_file = (char *) alloca (strlen (standard_exec_prefix)
-				+ strlen (just_machine_suffix)
-				+ sizeof ("specs"));
-
-  strcpy (specs_file, standard_exec_prefix);
-  strcat (specs_file, just_machine_suffix);
-  strcat (specs_file, "specs");
-  if (access (specs_file, R_OK) == 0)
-    read_specs (specs_file, TRUE);
- 
-  /* Process any user specified specs in the order given on the command
-     line.  */
-  for (uptr = user_specs_head; uptr; uptr = uptr->next)
+        first_time = TRUE;
+        for (i = 0; (int)i < n_switches; i++)
+        {
+            char **args;
+            char *p, *q;
+            if (!first_time)
+                obstack_grow(&collect_obstack, " ", 1);
+
+            first_time = FALSE;
+            obstack_grow(&collect_obstack, "'-", 2);
+            q = switches[i].part1;
+            while ((p = strchr(q,'\'')))
+            {
+                obstack_grow(&collect_obstack, q, p-q);
+                obstack_grow(&collect_obstack, "'\\''", 4);
+                q = ++p;
+            }
+            obstack_grow(&collect_obstack, q, strlen(q));
+            obstack_grow(&collect_obstack, "'", 1);
+
+            for (args = switches[i].args; args && *args; args++)
+            {
+                obstack_grow(&collect_obstack, " '", 2);
+                q = *args;
+                while ((p = strchr(q,'\'')))
+                {
+                    obstack_grow(&collect_obstack, q, p-q);
+                    obstack_grow(&collect_obstack, "'\\''", 4);
+                    q = ++p;
+                }
+                obstack_grow(&collect_obstack, q, strlen(q));
+                obstack_grow(&collect_obstack, "'", 1);
+            }
+        }
+        obstack_grow(&collect_obstack, "\0", 1);
+        putenv(obstack_finish(&collect_obstack));
+    }
+
+    /* Initialize the vector of specs to just the default.
+       This means one element containing 0s, as a terminator.  */
+
+    compilers = (struct compiler *) xmalloc(sizeof default_compilers);
+    copy_memory((char *) default_compilers, (char *) compilers,
+                sizeof default_compilers);
+    n_compilers = n_default_compilers;
+
+    /* Read specs from a file if there is one.  */
+
+    machine_suffix = concat(spec_machine, dir_separator_str,
+                            spec_version, dir_separator_str, NULL);
+    just_machine_suffix = concat(spec_machine, dir_separator_str, NULL);
+
+    specs_file = find_a_file(&startfile_prefixes, "specs", R_OK);
+    /* Read the specs file unless it is a default one.  */
+    if (specs_file != 0 && strcmp(specs_file, "specs"))
+        read_specs(specs_file, TRUE);
+    else
+        init_spec();
+
+    /* We need to check standard_exec_prefix/just_machine_suffix/specs
+       for any override of as, ld and libraries. */
+    specs_file = (char *) alloca(strlen(standard_exec_prefix)
+                                 + strlen(just_machine_suffix)
+                                 + sizeof ("specs"));
+
+    strcpy(specs_file, standard_exec_prefix);
+    strcat(specs_file, just_machine_suffix);
+    strcat(specs_file, "specs");
+    if (access(specs_file, R_OK) == 0)
+        read_specs(specs_file, TRUE);
+
+    /* Process any user specified specs in the order given on the command
+       line.  */
+    for (uptr = user_specs_head; uptr; uptr = uptr->next)
     {
-      char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
-      read_specs (filename ? filename : uptr->filename, FALSE);
+        char *filename = find_a_file(&startfile_prefixes, uptr->filename, R_OK);
+        read_specs(filename ? filename : uptr->filename, FALSE);
     }
 
-  /* Now we have the specs.
-     Set the `valid' bits for switches that match anything in any spec.  */
+    /* Now we have the specs.
+       Set the `valid' bits for switches that match anything in any spec.  */
 
-  validate_all_switches ();
+    validate_all_switches();
 
-  /* Now that we have the switches and the specs, set
-     the subdirectory based on the options.  */
-  set_multilib_dir ();
+    /* Now that we have the switches and the specs, set
+       the subdirectory based on the options.  */
+    set_multilib_dir();
 
-  /* Warn about any switches that no pass was interested in.  */
+    /* Warn about any switches that no pass was interested in.  */
 
-  for (i = 0; (int)i < n_switches; i++)
-    if (! switches[i].valid)
-      error ("unrecognized option `-%s'", switches[i].part1);
+    for (i = 0; (int)i < n_switches; i++)
+        if (!switches[i].valid)
+            error("unrecognized option `-%s'", switches[i].part1);
 
-  /* Obey some of the options.  */
+    /* Obey some of the options.  */
 
-  if (print_search_dirs)
+    if (print_search_dirs)
     {
-      printf ("install: %s%s\n", standard_exec_prefix, machine_suffix);
-      printf ("programs: %s\n", build_search_list (&exec_prefixes, "", 0));
-      printf ("libraries: %s\n", build_search_list (&startfile_prefixes, "", 0));
-      exit (0);
+        printf("install: %s%s\n", standard_exec_prefix, machine_suffix);
+        printf("programs: %s\n", build_search_list(&exec_prefixes, "", 0));
+        printf("libraries: %s\n", build_search_list(&startfile_prefixes, "", 0));
+        exit(0);
     }
 
-  if (print_file_name)
+    if (print_file_name)
     {
-      printf ("%s\n", find_file (print_file_name));
-      exit (0);
+        printf("%s\n", find_file(print_file_name));
+        exit(0);
     }
 
-  if (print_prog_name)
+    if (print_prog_name)
     {
-      char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
-      printf ("%s\n", (newname ? newname : print_prog_name));
-      exit (0);
+        char *newname = find_a_file(&exec_prefixes, print_prog_name, X_OK);
+        printf("%s\n", (newname ? newname : print_prog_name));
+        exit(0);
     }
 
-  if (print_multi_lib)
+    if (print_multi_lib)
     {
-      print_multilib_info ();
-      exit (0);
+        print_multilib_info();
+        exit(0);
     }
 
-  if (print_multi_directory)
+    if (print_multi_directory)
     {
-      if (multilib_dir == NULL)
-	printf (".\n");
-      else
-	printf ("%s\n", multilib_dir);
-      exit (0);
+        if (multilib_dir == NULL)
+            printf(".\n");
+        else
+            printf("%s\n", multilib_dir);
+        exit(0);
     }
 
-  if (print_help_list)
+    if (print_help_list)
     {
-      display_help ();
-
-      if (! verbose_flag)
-	{
-	  printf ("\nReport bugs to egcs-bugs@cygnus.com.\n");
-	  printf ("Please see the file BUGS (included with the sources) first.\n");
-	  
-	  exit (0);
-	}
-
-      /* We do not exit here.  Instead we have created a fake input file
-	 called 'help-dummy' which needs to be compiled, and we pass this
-	 on the the various sub-processes, along with the --help switch.  */
+        display_help();
+
+        if (!verbose_flag)
+        {
+            printf("\nReport bugs to egcs-bugs@cygnus.com.\n");
+            printf("Please see the file BUGS (included with the sources) first.\n");
+
+            exit(0);
+        }
+
+        /* We do not exit here.  Instead we have created a fake input file
+           called 'help-dummy' which needs to be compiled, and we pass this
+           on the the various sub-processes, along with the --help switch.  */
     }
-  
-  if (verbose_flag)
+
+    if (verbose_flag)
     {
-      int n;
-
-      /* compiler_version is truncated at the first space when initialized
-	 from version string, so truncate version_string at the first space
-	 before comparing.  */
-      for (n = 0; version_string[n]; n++)
-	if (version_string[n] == ' ')
-	  break;
-
-      if (! strncmp (version_string, compiler_version, n)
-	  && compiler_version[n] == 0)
-	fprintf (stderr, "gcc version %s\n", version_string);
-      else
-	fprintf (stderr, "gcc driver version %s executing gcc version %s\n",
-		 version_string, compiler_version);
-      /* CYGNUS LOCAL default-options */
-      {
-	/* We can't do this in translate_options, where we handle the environment
-	   variable, because the -v flag won't have been seen yet, so we handle
-	   it here instead.  */
-	char *opts = getenv ("GCC_DEFAULT_OPTIONS");
-	if (opts)
-	  fprintf (stderr, "GCC_DEFAULT_OPTIONS=%s\n", opts);
-      }
-      /* END CYGNUS LOCAL */
-
-      if (n_infiles == 0)
-	exit (0);
+        int n;
+
+        /* compiler_version is truncated at the first space when initialized
+           from version string, so truncate version_string at the first space
+           before comparing.  */
+        for (n = 0; version_string[n]; n++)
+            if (version_string[n] == ' ')
+                break;
+
+        if (!strncmp(version_string, compiler_version, n)
+            && compiler_version[n] == 0)
+            fprintf(stderr, "gcc version %s\n", version_string);
+        else
+            fprintf(stderr, "gcc driver version %s executing gcc version %s\n",
+                    version_string, compiler_version);
+        /* CYGNUS LOCAL default-options */
+        {
+            /* We can't do this in translate_options, where we handle the environment
+               variable, because the -v flag won't have been seen yet, so we handle
+               it here instead.  */
+            char *opts = getenv("GCC_DEFAULT_OPTIONS");
+            if (opts)
+                fprintf(stderr, "GCC_DEFAULT_OPTIONS=%s\n", opts);
+        }
+        /* END CYGNUS LOCAL */
+
+        if (n_infiles == 0)
+            exit(0);
     }
 
-  if (n_infiles == added_libraries)
-    fatal ("No input files");
+    if (n_infiles == added_libraries)
+        fatal("No input files");
 
-  /* Make a place to record the compiler output file names
-     that correspond to the input files.  */
+    /* Make a place to record the compiler output file names
+       that correspond to the input files.  */
 
-  i = n_infiles;
-  outfiles = (char **) xmalloc (i * sizeof (char *));
-  zero_memory ((char *) outfiles, i * sizeof (char *));
+    i = n_infiles;
+    outfiles = (char **) xmalloc(i * sizeof (char *));
+    zero_memory((char *) outfiles, i * sizeof (char *));
 
-  /* Record which files were specified explicitly as link input.  */
+    /* Record which files were specified explicitly as link input.  */
 
-  explicit_link_files = xmalloc (n_infiles);
-  zero_memory (explicit_link_files, n_infiles);
+    explicit_link_files = xmalloc(n_infiles);
+    zero_memory(explicit_link_files, n_infiles);
 
-  for (i = 0; (int)i < n_infiles; i++)
+    for (i = 0; (int)i < n_infiles; i++)
     {
-      register struct compiler *cp = 0;
-      int this_file_error = 0;
-
-      /* Tell do_spec what to substitute for %i.  */
-
-      input_filename = infiles[i].name;
-      input_filename_length = strlen (input_filename);
-      input_file_number = i;
-
-      /* Use the same thing in %o, unless cp->spec says otherwise.  */
-
-      outfiles[i] = input_filename;
-
-      /* Figure out which compiler from the file's suffix.  */
-
-      cp = lookup_compiler (infiles[i].name, input_filename_length,
-			    infiles[i].language);
-
-      if (cp)
-	{
-	  /* Ok, we found an applicable compiler.  Run its spec.  */
-	  /* First say how much of input_filename to substitute for %b  */
-	  register char *p;
-	  int len;
-
-	  if (cp->spec[0][0] == '#')
-	    error ("%s: %s compiler not installed on this system",
-		   input_filename, &cp->spec[0][1]);
-
-	  input_basename = input_filename;
-	  for (p = input_filename; *p; p++)
-	    if (*p == '/' || *p == DIR_SEPARATOR)
-	      input_basename = p + 1;
-
-	  /* Find a suffix starting with the last period,
-	     and set basename_length to exclude that suffix.  */
-	  basename_length = strlen (input_basename);
-	  p = input_basename + basename_length;
-	  while (p != input_basename && *p != '.') --p;
-	  if (*p == '.' && p != input_basename)
-	    {
-	      basename_length = p - input_basename;
-	      input_suffix = p + 1;
-	    }
-	  else
-	    input_suffix = "";
-
-	  len = 0;
-	  for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
-	    if (cp->spec[j])
-	      len += strlen (cp->spec[j]);
-
-	  p = (char *) xmalloc (len + 1);
-
-	  len = 0;
-	  for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
-	    if (cp->spec[j])
-	      {
-		strcpy (p + len, cp->spec[j]);
-		len += strlen (cp->spec[j]);
-	      }
-
-	  value = do_spec (p);
-	  free (p);
-	  if (value < 0)
-	    this_file_error = 1;
-	}
-
-      /* If this file's name does not contain a recognized suffix,
-	 record it as explicit linker input.  */
-
-      else
-	explicit_link_files[i] = 1;
-
-      /* Clear the delete-on-failure queue, deleting the files in it
-	 if this compilation failed.  */
-
-      if (this_file_error)
-	{
-	  delete_failure_queue ();
-	  error_count++;
-	}
-      /* If this compilation succeeded, don't delete those files later.  */
-      clear_failure_queue ();
+        register struct compiler *cp = 0;
+        int this_file_error = 0;
+
+        /* Tell do_spec what to substitute for %i.  */
+
+        input_filename = infiles[i].name;
+        input_filename_length = strlen(input_filename);
+        input_file_number = i;
+
+        /* Use the same thing in %o, unless cp->spec says otherwise.  */
+
+        outfiles[i] = input_filename;
+
+        /* Figure out which compiler from the file's suffix.  */
+
+        cp = lookup_compiler(infiles[i].name, input_filename_length,
+                             infiles[i].language);
+
+        if (cp)
+        {
+            /* Ok, we found an applicable compiler.  Run its spec.  */
+            /* First say how much of input_filename to substitute for %b  */
+            register char *p;
+            int len;
+
+            if (cp->spec[0][0] == '#')
+                error("%s: %s compiler not installed on this system",
+                      input_filename, &cp->spec[0][1]);
+
+            input_basename = input_filename;
+            for (p = input_filename; *p; p++)
+                if (*p == '/' || *p == DIR_SEPARATOR)
+                    input_basename = p + 1;
+
+            /* Find a suffix starting with the last period,
+               and set basename_length to exclude that suffix.  */
+            basename_length = strlen(input_basename);
+            p = input_basename + basename_length;
+            while (p != input_basename && *p != '.') --p;
+            if (*p == '.' && p != input_basename)
+            {
+                basename_length = p - input_basename;
+                input_suffix = p + 1;
+            }
+            else
+                input_suffix = "";
+
+            len = 0;
+            for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
+                if (cp->spec[j])
+                    len += strlen(cp->spec[j]);
+
+            p = (char *) xmalloc(len + 1);
+
+            len = 0;
+            for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
+                if (cp->spec[j])
+                {
+                    strcpy(p + len, cp->spec[j]);
+                    len += strlen(cp->spec[j]);
+                }
+
+            value = do_spec(p);
+            free(p);
+            if (value < 0)
+                this_file_error = 1;
+        }
+
+        /* If this file's name does not contain a recognized suffix,
+           record it as explicit linker input.  */
+
+        else
+            explicit_link_files[i] = 1;
+
+        /* Clear the delete-on-failure queue, deleting the files in it
+           if this compilation failed.  */
+
+        if (this_file_error)
+        {
+            delete_failure_queue();
+            error_count++;
+        }
+        /* If this compilation succeeded, don't delete those files later.  */
+        clear_failure_queue();
     }
 
 
-  /* Run ld to link all the compiler output files.  */
+    /* Run ld to link all the compiler output files.  */
 
-  if (error_count == 0)
+    if (error_count == 0)
     {
-      int tmp = execution_count;
+        int tmp = execution_count;
 
-      /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
-	 for collect.  */
-      putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH=");
-      putenv_from_prefixes (&startfile_prefixes, "LIBRARY_PATH=");
+        /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
+           for collect.  */
+        putenv_from_prefixes(&exec_prefixes, "COMPILER_PATH=");
+        putenv_from_prefixes(&startfile_prefixes, "LIBRARY_PATH=");
 
-      value = do_spec (link_command_spec);
-      if (value < 0)
-	error_count = 1;
-      linker_was_run = (tmp != execution_count);
+        value = do_spec(link_command_spec);
+        if (value < 0)
+            error_count = 1;
+        linker_was_run = (tmp != execution_count);
     }
 
-  /* Warn if a -B option was specified but the prefix was never used.  */
-  unused_prefix_warnings (&exec_prefixes);
-  unused_prefix_warnings (&startfile_prefixes);
+    /* Warn if a -B option was specified but the prefix was never used.  */
+    unused_prefix_warnings(&exec_prefixes);
+    unused_prefix_warnings(&startfile_prefixes);
 
-  /* If options said don't run linker,
-     complain about input files to be given to the linker.  */
+    /* If options said don't run linker,
+       complain about input files to be given to the linker.  */
 
-  if (! linker_was_run && error_count == 0)
-    for (i = 0; (int)i < n_infiles; i++)
-      if (explicit_link_files[i])
-	error ("%s: linker input file unused since linking not done",
-	       outfiles[i]);
+    if (!linker_was_run && error_count == 0)
+        for (i = 0; (int)i < n_infiles; i++)
+            if (explicit_link_files[i])
+                error("%s: linker input file unused since linking not done",
+                      outfiles[i]);
 
-  /* Delete some or all of the temporary files we made.  */
+    /* Delete some or all of the temporary files we made.  */
 
-  if (error_count)
-    delete_failure_queue ();
-  delete_temp_files ();
+    if (error_count)
+        delete_failure_queue();
+    delete_temp_files();
 
-  if (print_help_list)
+    if (print_help_list)
     {
-      printf ("\nReport bugs to egcs-bugs@cygnus.com.\n");
-      printf ("Please see the file BUGS (included with the sources) first.\n");
+        printf("\nReport bugs to egcs-bugs@cygnus.com.\n");
+        printf("Please see the file BUGS (included with the sources) first.\n");
     }
-  
-  exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
-  /* NOTREACHED */
-  return 0;
+
+    exit(error_count > 0 ? (signal_count ? 2 : 1) : 0);
+    /* NOTREACHED */
+    return 0;
 }
 
 /* Find the proper compilation spec for the file name NAME,
@@ -4756,374 +4489,357 @@ main (argc, argv)
    or 0 if this file is to be passed to the linker.  */
 
 static struct compiler *
-lookup_compiler (name, length, language)
-     char *name;
-     size_t length;
-     char *language;
+lookup_compiler(char *name, size_t length, char *language)
 {
-  struct compiler *cp;
+    struct compiler *cp;
 
-  /* If this was specified by the user to be a linker input, indicate that. */
-  if (language != 0 && language[0] == '*')
-    return 0;
+    /* If this was specified by the user to be a linker input, indicate that. */
+    if (language != 0 && language[0] == '*')
+        return 0;
 
-  /* Otherwise, look for the language, if one is spec'd.  */
-  if (language != 0)
+    /* Otherwise, look for the language, if one is spec'd.  */
+    if (language != 0)
     {
-      for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
-	if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
-	  return cp;
+        for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
+            if (cp->suffix[0] == '@' && !strcmp(cp->suffix + 1, language))
+                return cp;
 
-      error ("language %s not recognized", language);
-      return 0;
+        error("language %s not recognized", language);
+        return 0;
     }
 
-  /* Look for a suffix.  */
-  for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
+    /* Look for a suffix.  */
+    for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
     {
-      if (/* The suffix `-' matches only the file name `-'.  */
-	  (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
-	  || (strlen (cp->suffix) < length
-	      /* See if the suffix matches the end of NAME.  */
-	      && !strcmp (cp->suffix, name + length - strlen (cp->suffix))
-	 ))
-	{
-	  if (cp->spec[0][0] == '@')
-	    {
-	      struct compiler *new;
-
-	      /* An alias entry maps a suffix to a language.
-		 Search for the language; pass 0 for NAME and LENGTH
-		 to avoid infinite recursion if language not found.
-		 Construct the new compiler spec.  */
-	      language = cp->spec[0] + 1;
-	      new = (struct compiler *) xmalloc (sizeof (struct compiler));
-	      new->suffix = cp->suffix;
-	      copy_memory ((char *) lookup_compiler (NULL, 0, language)->spec,
-		     (char *) new->spec, sizeof new->spec);
-	      return new;
-	    }
-
-	  /* A non-alias entry: return it.  */
-	  return cp;
-	}
+        if ( /* The suffix `-' matches only the file name `-'.  */
+            (!strcmp(cp->suffix, "-") && !strcmp(name, "-"))
+            || (strlen(cp->suffix) < length
+                /* See if the suffix matches the end of NAME.  */
+                && !strcmp(cp->suffix, name + length - strlen(cp->suffix))
+                ))
+        {
+            if (cp->spec[0][0] == '@')
+            {
+                struct compiler *new;
+
+                /* An alias entry maps a suffix to a language.
+                   Search for the language; pass 0 for NAME and LENGTH
+                   to avoid infinite recursion if language not found.
+                   Construct the new compiler spec.  */
+                language = cp->spec[0] + 1;
+                new = (struct compiler *) xmalloc(sizeof (struct compiler));
+                new->suffix = cp->suffix;
+                copy_memory((char *) lookup_compiler(NULL, 0, language)->spec,
+                            (char *) new->spec, sizeof new->spec);
+                return new;
+            }
+
+            /* A non-alias entry: return it.  */
+            return cp;
+        }
     }
 
-  return 0;
+    return 0;
 }
-
+
 void *
-xmalloc (size)
-  size_t size;
+xmalloc(size_t size)
 {
-  register void *value = malloc (size);
-  if (value == 0)
-    fatal ("virtual memory exhausted");
-  return value;
+    register void *value = malloc(size);
+    if (value == 0)
+        fatal("virtual memory exhausted");
+    return value;
 }
 
 void *
-xrealloc (old, size)
-  void *old;
-  size_t size;
+xrealloc(void *old, size_t size)
 {
-  register void *ptr;
-  if (old)
-    ptr = realloc (old, size);
-  else
-    ptr = malloc (size);
-  if (ptr == 0)
-    fatal ("virtual memory exhausted");
-  return ptr;
+    register void *ptr;
+    if (old)
+        ptr = realloc(old, size);
+    else
+        ptr = malloc(size);
+    if (ptr == 0)
+        fatal("virtual memory exhausted");
+    return ptr;
 }
 
 static char *
-save_string (s, len)
-  const char *s;
-  int len;
+save_string(const char *s, int len)
 {
-  register char *result = xmalloc (len + 1);
+    register char *result = xmalloc(len + 1);
 
-  copy_memory (s, result, len);
-  result[len] = 0;
-  return result;
+    copy_memory(s, result, len);
+    result[len] = 0;
+    return result;
 }
 
 static void
-pfatal_with_name (name)
-     char *name;
+pfatal_with_name(char *name)
 {
-  fatal ("%s: %s", name, xstrerror (errno));
+    fatal("%s: %s", name, xstrerror(errno));
 }
 
 static void
-perror_with_name (name)
-     char *name;
+perror_with_name(char *name)
 {
-  error ("%s: %s", name, xstrerror (errno));
+    error("%s: %s", name, xstrerror(errno));
 }
 
 static void
-pfatal_pexecute (errmsg_fmt, errmsg_arg)
-     char *errmsg_fmt;
-     char *errmsg_arg;
+pfatal_pexecute(char *errmsg_fmt, char *errmsg_arg)
 {
-  int save_errno = errno;
+    int save_errno = errno;
 
-  if (errmsg_arg)
+    if (errmsg_arg)
     {
-      /* Space for trailing '\0' is in %s.  */
-      char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
-      sprintf (msg, errmsg_fmt, errmsg_arg);
-      errmsg_fmt = msg;
+        /* Space for trailing '\0' is in %s.  */
+        char *msg = xmalloc(strlen(errmsg_fmt) + strlen(errmsg_arg));
+        sprintf(msg, errmsg_fmt, errmsg_arg);
+        errmsg_fmt = msg;
     }
 
-  fatal ("%s: %s", errmsg_fmt, xstrerror (save_errno));
+    fatal("%s: %s", errmsg_fmt, xstrerror(save_errno));
 }
 
 /* More 'friendly' abort that prints the line and file.
    config.h can #define abort fancy_abort if you like that sort of thing.  */
 
 void
-fancy_abort ()
+fancy_abort()
 {
-  fatal ("Internal gcc abort.");
+    fatal("Internal gcc abort.");
 }
-
+
 /* Output an error message and exit */
 
 static void
-fatal (char *format, ...)
+fatal(char *format, ...)
 {
-  va_list ap;
+    va_list ap;
 
-  va_start (ap, format);
+    va_start(ap, format);
 
 
-  fprintf (stderr, "%s: ", programname);
-  vfprintf (stderr, format, ap);
-  va_end (ap);
-  fprintf (stderr, "\n");
-  delete_temp_files ();
-  exit (1);
+    fprintf(stderr, "%s: ", programname);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+    fprintf(stderr, "\n");
+    delete_temp_files();
+    exit(1);
 }
 
 static void
-error (char *format, ...)
+error(char *format, ...)
 {
-  va_list ap;
+    va_list ap;
 
-  va_start (ap, format);
+    va_start(ap, format);
 
 
-  fprintf (stderr, "%s: ", programname);
-  vfprintf (stderr, format, ap);
-  va_end (ap);
+    fprintf(stderr, "%s: ", programname);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
 
-  fprintf (stderr, "\n");
+    fprintf(stderr, "\n");
 }
-
+
 static void
-validate_all_switches ()
+validate_all_switches()
 {
-  struct compiler *comp;
-  register char *p;
-  register char c;
-  struct spec_list *spec;
+    struct compiler *comp;
+    register char *p;
+    register char c;
+    struct spec_list *spec;
 
-  for (comp = compilers; comp->spec[0]; comp++)
+    for (comp = compilers; comp->spec[0]; comp++)
     {
-      size_t i;
-      for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
-	{
-	  p = comp->spec[i];
-	  while ((c = *p++))
-	    if (c == '%' && *p == '{')
-	      /* We have a switch spec.  */
-	      validate_switches (p + 1);
-	}
+        size_t i;
+        for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
+        {
+            p = comp->spec[i];
+            while ((c = *p++))
+                if (c == '%' && *p == '{')
+                    /* We have a switch spec.  */
+                    validate_switches(p + 1);
+        }
     }
 
-  /* look through the linked list of specs read from the specs file */
-  for (spec = specs; spec ; spec = spec->next)
+    /* look through the linked list of specs read from the specs file */
+    for (spec = specs; spec; spec = spec->next)
     {
-      p = *(spec->ptr_spec);
-      while ((c = *p++))
-	if (c == '%' && *p == '{')
-	  /* We have a switch spec.  */
-	  validate_switches (p + 1);
+        p = *(spec->ptr_spec);
+        while ((c = *p++))
+            if (c == '%' && *p == '{')
+                /* We have a switch spec.  */
+                validate_switches(p + 1);
     }
 
-  p = link_command_spec;
-  while ((c = *p++))
-    if (c == '%' && *p == '{')
-      /* We have a switch spec.  */
-      validate_switches (p + 1);
+    p = link_command_spec;
+    while ((c = *p++))
+        if (c == '%' && *p == '{')
+            /* We have a switch spec.  */
+            validate_switches(p + 1);
 }
 
 /* Look at the switch-name that comes after START
    and mark as valid all supplied switches that match it.  */
 
 static void
-validate_switches (start)
-     char *start;
+validate_switches(char *start)
 {
-  register char *p = start;
-  char *filter;
-  register int i;
-  int suffix = 0;
+    register char *p = start;
+    char *filter;
+    register int i;
+    int suffix = 0;
 
-  if (*p == '|')
-    ++p;
+    if (*p == '|')
+        ++p;
 
-  if (*p == '!')
-    ++p;
+    if (*p == '!')
+        ++p;
 
-  if (*p == '.')
-    suffix = 1, ++p;
+    if (*p == '.')
+        suffix = 1, ++p;
 
-  filter = p;
-  while (*p != ':' && *p != '}') p++;
+    filter = p;
+    while (*p != ':' && *p != '}') p++;
 
-  if (suffix)
-    ;
-  else if (p[-1] == '*')
+    if (suffix)
+        ;
+    else if (p[-1] == '*')
     {
-      /* Mark all matching switches as valid.  */
-      --p;
-      for (i = 0; i < n_switches; i++)
-	if (!strncmp (switches[i].part1, filter, p - filter))
-	  switches[i].valid = 1;
+        /* Mark all matching switches as valid.  */
+        --p;
+        for (i = 0; i < n_switches; i++)
+            if (!strncmp(switches[i].part1, filter, p - filter))
+                switches[i].valid = 1;
     }
-  else
+    else
     {
-      /* Mark an exact matching switch as valid.  */
-      for (i = 0; i < n_switches; i++)
-	{
-	  if (!strncmp (switches[i].part1, filter, p - filter)
-	      && switches[i].part1[p - filter] == 0)
-	    switches[i].valid = 1;
-	}
+        /* Mark an exact matching switch as valid.  */
+        for (i = 0; i < n_switches; i++)
+        {
+            if (!strncmp(switches[i].part1, filter, p - filter)
+                && switches[i].part1[p - filter] == 0)
+                switches[i].valid = 1;
+        }
     }
 }
-
+
 /* Check whether a particular argument was used.  The first time we
    canonicalize the switches to keep only the ones we care about.  */
 
 static int
-used_arg (p, len)
-     char *p;
-     int len;
+used_arg(char *p, int len)
 {
-  struct mswitchstr {
-    char *str;
-    char *replace;
-    int len;
-    int rep_len;
-  };
+    struct mswitchstr {
+        char *str;
+        char *replace;
+        int len;
+        int rep_len;
+    };
 
-  static struct mswitchstr *mswitches;
-  static int n_mswitches;
-  int i, j;
+    static struct mswitchstr *mswitches;
+    static int n_mswitches;
+    int i, j;
 
-  if (!mswitches)
+    if (!mswitches)
     {
-      struct mswitchstr *matches;
-      char *q;
-      int cnt = 0;
-
-      /* Break multilib_matches into the component strings of string and replacement
-         string */
-      for (q = multilib_matches; *q != '\0'; q++)
-	if (*q == ';')
-	  cnt++;
-
-      matches = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
-      i = 0;
-      q = multilib_matches;
-      while (*q != '\0')
-	{
-	  matches[i].str = q;
-	  while (*q != ' ')
-	    {
-	      if (*q == '\0')
-		abort ();
-	      q++;
-	    }
-	  *q = '\0';
-	  matches[i].len = q - matches[i].str;
-
-	  matches[i].replace = ++q;
-	  while (*q != ';' && *q != '\0')
-	    {
-	      if (*q == ' ')
-		abort ();
-	      q++;
-	    }
-	  matches[i].rep_len = q - matches[i].replace;
-	  i++;
-	  if (*q == ';')
-	    *q++ = '\0';
-	  else
-	    break;
-	}
-
-      /* Now build a list of the replacement string for switches that we care
-	 about.  Make sure we allocate at least one entry.  This prevents
-	 xmalloc from calling fatal, and prevents us from re-executing this
-	 block of code.  */
-      mswitches
-	= (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
-					 * (n_switches ? n_switches : 1));
-      for (i = 0; i < n_switches; i++)
-	{
-	  int xlen = strlen (switches[i].part1);
-	  for (j = 0; j < cnt; j++)
-	    if (xlen == matches[j].len && ! strcmp (switches[i].part1, matches[j].str))
-	      {
-		mswitches[n_mswitches].str = matches[j].replace;
-		mswitches[n_mswitches].len = matches[j].rep_len;
-		mswitches[n_mswitches].replace = (char *)0;
-		mswitches[n_mswitches].rep_len = 0;
-		n_mswitches++;
-		break;
-	      }
-	}
+        struct mswitchstr *matches;
+        char *q;
+        int cnt = 0;
+
+        /* Break multilib_matches into the component strings of string and replacement
+           string */
+        for (q = multilib_matches; *q != '\0'; q++)
+            if (*q == ';')
+                cnt++;
+
+        matches = (struct mswitchstr *) alloca((sizeof (struct mswitchstr)) * cnt);
+        i = 0;
+        q = multilib_matches;
+        while (*q != '\0')
+        {
+            matches[i].str = q;
+            while (*q != ' ')
+            {
+                if (*q == '\0')
+                    abort();
+                q++;
+            }
+            *q = '\0';
+            matches[i].len = q - matches[i].str;
+
+            matches[i].replace = ++q;
+            while (*q != ';' && *q != '\0')
+            {
+                if (*q == ' ')
+                    abort();
+                q++;
+            }
+            matches[i].rep_len = q - matches[i].replace;
+            i++;
+            if (*q == ';')
+                *q++ = '\0';
+            else
+                break;
+        }
+
+        /* Now build a list of the replacement string for switches that we care
+           about.  Make sure we allocate at least one entry.  This prevents
+           xmalloc from calling fatal, and prevents us from re-executing this
+           block of code.  */
+        mswitches
+            = (struct mswitchstr *) xmalloc((sizeof (struct mswitchstr))
+                                            * (n_switches ? n_switches : 1));
+        for (i = 0; i < n_switches; i++)
+        {
+            int xlen = strlen(switches[i].part1);
+            for (j = 0; j < cnt; j++)
+                if (xlen == matches[j].len && !strcmp(switches[i].part1, matches[j].str))
+                {
+                    mswitches[n_mswitches].str = matches[j].replace;
+                    mswitches[n_mswitches].len = matches[j].rep_len;
+                    mswitches[n_mswitches].replace = (char *)0;
+                    mswitches[n_mswitches].rep_len = 0;
+                    n_mswitches++;
+                    break;
+                }
+        }
     }
 
-  for (i = 0; i < n_mswitches; i++)
-    if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
-      return 1;
+    for (i = 0; i < n_mswitches; i++)
+        if (len == mswitches[i].len && !strncmp(p, mswitches[i].str, len))
+            return 1;
 
-  return 0;
+    return 0;
 }
 
 static int
-default_arg (p, len)
-     char *p;
-     int len;
+default_arg(char *p, int len)
 {
-  char *start, *end;
+    char *start, *end;
 
-  for (start = multilib_defaults; *start != '\0'; start = end+1)
+    for (start = multilib_defaults; *start != '\0'; start = end+1)
     {
-      while (*start == ' ' || *start == '\t')
-	start++;
+        while (*start == ' ' || *start == '\t')
+            start++;
 
-      if (*start == '\0')
-	break;
+        if (*start == '\0')
+            break;
 
-      for (end = start+1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
-	;
+        for (end = start+1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
+            ;
 
-      if ((end - start) == len && strncmp (p, start, len) == 0)
-	return 1;
+        if ((end - start) == len && strncmp(p, start, len) == 0)
+            return 1;
 
-      if (*end == '\0')
-	break;
+        if (*end == '\0')
+            break;
     }
 
-  return 0;
+    return 0;
 }
 
 /* Work out the subdirectory to use based on the
@@ -5135,95 +4851,95 @@ default_arg (p, len)
    subdirectory will be used.  */
 
 static void
-set_multilib_dir ()
+set_multilib_dir()
 {
-  char *p = multilib_select;
-  int this_path_len;
-  char *this_path, *this_arg;
-  int not_arg;
-  int ok;
+    char *p = multilib_select;
+    int this_path_len;
+    char *this_path, *this_arg;
+    int not_arg;
+    int ok;
 
-  while (*p != '\0')
+    while (*p != '\0')
     {
-      /* Ignore newlines.  */
-      if (*p == '\n')
-	{
-	  ++p;
-	  continue;
-	}
-
-      /* Get the initial path.  */
-      this_path = p;
-      while (*p != ' ')
-	{
-	  if (*p == '\0')
-	    abort ();
-	  ++p;
-	}
-      this_path_len = p - this_path;
-
-      /* Check the arguments.  */
-      ok = 1;
-      ++p;
-      while (*p != ';')
-	{
-	  if (*p == '\0')
-	    abort ();
-
-	  if (! ok)
-	    {
-	      ++p;
-	      continue;
-	    }
-
-	  this_arg = p;
-	  while (*p != ' ' && *p != ';')
-	    {
-	      if (*p == '\0')
-		abort ();
-	      ++p;
-	    }
-
-	  if (*this_arg != '!')
-	    not_arg = 0;
-	  else
-	    {
-	      not_arg = 1;
-	      ++this_arg;
-	    }
-
-	  /* If this is a default argument, we can just ignore it.
-	     This is true even if this_arg begins with '!'.  Beginning
-	     with '!' does not mean that this argument is necessarily
-	     inappropriate for this library: it merely means that
-	     there is a more specific library which uses this
-	     argument.  If this argument is a default, we need not
-	     consider that more specific library.  */
-	  if (! default_arg (this_arg, p - this_arg))
-	    {
-	      ok = used_arg (this_arg, p - this_arg);
-	      if (not_arg)
-		ok = ! ok;
-	    }
-
-	  if (*p == ' ')
-	    ++p;
-	}
-
-      if (ok)
-	{
-	  if (this_path_len != 1
-	      || this_path[0] != '.')
-	    {
-	      multilib_dir = xmalloc (this_path_len + 1);
-	      strncpy (multilib_dir, this_path, this_path_len);
-	      multilib_dir[this_path_len] = '\0';
-	    }
-	  break;
-	}
-
-      ++p;
-    }      
+        /* Ignore newlines.  */
+        if (*p == '\n')
+        {
+            ++p;
+            continue;
+        }
+
+        /* Get the initial path.  */
+        this_path = p;
+        while (*p != ' ')
+        {
+            if (*p == '\0')
+                abort();
+            ++p;
+        }
+        this_path_len = p - this_path;
+
+        /* Check the arguments.  */
+        ok = 1;
+        ++p;
+        while (*p != ';')
+        {
+            if (*p == '\0')
+                abort();
+
+            if (!ok)
+            {
+                ++p;
+                continue;
+            }
+
+            this_arg = p;
+            while (*p != ' ' && *p != ';')
+            {
+                if (*p == '\0')
+                    abort();
+                ++p;
+            }
+
+            if (*this_arg != '!')
+                not_arg = 0;
+            else
+            {
+                not_arg = 1;
+                ++this_arg;
+            }
+
+            /* If this is a default argument, we can just ignore it.
+               This is true even if this_arg begins with '!'.  Beginning
+               with '!' does not mean that this argument is necessarily
+               inappropriate for this library: it merely means that
+               there is a more specific library which uses this
+               argument.  If this argument is a default, we need not
+               consider that more specific library.  */
+            if (!default_arg(this_arg, p - this_arg))
+            {
+                ok = used_arg(this_arg, p - this_arg);
+                if (not_arg)
+                    ok = !ok;
+            }
+
+            if (*p == ' ')
+                ++p;
+        }
+
+        if (ok)
+        {
+            if (this_path_len != 1
+                || this_path[0] != '.')
+            {
+                multilib_dir = xmalloc(this_path_len + 1);
+                strncpy(multilib_dir, this_path, this_path_len);
+                multilib_dir[this_path_len] = '\0';
+            }
+            break;
+        }
+
+        ++p;
+    }
 }
 
 /* Print out the multiple library subdirectory selection
@@ -5236,142 +4952,142 @@ set_multilib_dir ()
    generated by the genmultilib script.  */
 
 static void
-print_multilib_info ()
+print_multilib_info()
 {
-  char *p = multilib_select;
-  char *last_path = 0, *this_path;
-  int skip;
-  int last_path_len = 0;
+    char *p = multilib_select;
+    char *last_path = 0, *this_path;
+    int skip;
+    int last_path_len = 0;
 
-  while (*p != '\0')
+    while (*p != '\0')
     {
-      /* Ignore newlines.  */
-      if (*p == '\n')
-	{
-	  ++p;
-	  continue;
-	}
-
-      /* Get the initial path.  */
-      this_path = p;
-      while (*p != ' ')
-	{
-	  if (*p == '\0')
-	    abort ();
-	  ++p;
-	}
-
-      /* If this is a duplicate, skip it.  */
-      skip = (last_path != 0 && p - this_path == last_path_len
-	      && ! strncmp (last_path, this_path, last_path_len));
-
-      last_path = this_path;
-      last_path_len = p - this_path;
-
-      /* If this directory requires any default arguments, we can skip
-	 it.  We will already have printed a directory identical to
-	 this one which does not require that default argument.  */
-      if (! skip)
-	{
-	  char *q;
-
-	  q = p + 1;
-	  while (*q != ';')
-	    {
-	      char *arg;
-
-	      if (*q == '\0')
-		abort ();
-
-	      if (*q == '!')
-		arg = NULL;
-	      else
-		arg = q;
-
-	      while (*q != ' ' && *q != ';')
-		{
-		  if (*q == '\0')
-		    abort ();
-		  ++q;
-		}
-
-	      if (arg != NULL
-		  && default_arg (arg, q - arg))
-		{
-		  skip = 1;
-		  break;
-		}
-
-	      if (*q == ' ')
-		++q;
-	    }
-	}
-
-      if (! skip)
-	{
-	  char *p1;
-
-	  for (p1 = last_path; p1 < p; p1++)
-	    putchar (*p1);
-	  putchar (';');
-	}
-
-      ++p;
-      while (*p != ';')
-	{
-	  int use_arg;
-
-	  if (*p == '\0')
-	    abort ();
-
-	  if (skip)
-	    {
-	      ++p;
-	      continue;
-	    }
-
-	  use_arg = *p != '!';
-
-	  if (use_arg)
-	    putchar ('@');
-
-	  while (*p != ' ' && *p != ';')
-	    {
-	      if (*p == '\0')
-		abort ();
-	      if (use_arg)
-		putchar (*p);
-	      ++p;
-	    }
-
-	  if (*p == ' ')
-	    ++p;
-	}
-
-      if (! skip)
-	{
-	  /* If there are extra options, print them now */
-	  if (multilib_extra && *multilib_extra)
-	    {
-	      int print_at = TRUE;
-	      char *q;
-
-	      for (q = multilib_extra; *q != '\0'; q++)
-		{
-		  if (*q == ' ')
-		    print_at = TRUE;
-		  else
-		    {
-		      if (print_at)
-			putchar ('@');
-		      putchar (*q);
-		      print_at = FALSE;
-		    }
-		}
-	    }
-	  putchar ('\n');
-	}
-
-      ++p;
+        /* Ignore newlines.  */
+        if (*p == '\n')
+        {
+            ++p;
+            continue;
+        }
+
+        /* Get the initial path.  */
+        this_path = p;
+        while (*p != ' ')
+        {
+            if (*p == '\0')
+                abort();
+            ++p;
+        }
+
+        /* If this is a duplicate, skip it.  */
+        skip = (last_path != 0 && p - this_path == last_path_len
+                && !strncmp(last_path, this_path, last_path_len));
+
+        last_path = this_path;
+        last_path_len = p - this_path;
+
+        /* If this directory requires any default arguments, we can skip
+           it.  We will already have printed a directory identical to
+           this one which does not require that default argument.  */
+        if (!skip)
+        {
+            char *q;
+
+            q = p + 1;
+            while (*q != ';')
+            {
+                char *arg;
+
+                if (*q == '\0')
+                    abort();
+
+                if (*q == '!')
+                    arg = NULL;
+                else
+                    arg = q;
+
+                while (*q != ' ' && *q != ';')
+                {
+                    if (*q == '\0')
+                        abort();
+                    ++q;
+                }
+
+                if (arg != NULL
+                    && default_arg(arg, q - arg))
+                {
+                    skip = 1;
+                    break;
+                }
+
+                if (*q == ' ')
+                    ++q;
+            }
+        }
+
+        if (!skip)
+        {
+            char *p1;
+
+            for (p1 = last_path; p1 < p; p1++)
+                putchar(*p1);
+            putchar(';');
+        }
+
+        ++p;
+        while (*p != ';')
+        {
+            int use_arg;
+
+            if (*p == '\0')
+                abort();
+
+            if (skip)
+            {
+                ++p;
+                continue;
+            }
+
+            use_arg = *p != '!';
+
+            if (use_arg)
+                putchar('@');
+
+            while (*p != ' ' && *p != ';')
+            {
+                if (*p == '\0')
+                    abort();
+                if (use_arg)
+                    putchar(*p);
+                ++p;
+            }
+
+            if (*p == ' ')
+                ++p;
+        }
+
+        if (!skip)
+        {
+            /* If there are extra options, print them now */
+            if (multilib_extra && *multilib_extra)
+            {
+                int print_at = TRUE;
+                char *q;
+
+                for (q = multilib_extra; *q != '\0'; q++)
+                {
+                    if (*q == ' ')
+                        print_at = TRUE;
+                    else
+                    {
+                        if (print_at)
+                            putchar('@');
+                        putchar(*q);
+                        print_at = FALSE;
+                    }
+                }
+            }
+            putchar('\n');
+        }
+
+        ++p;
     }
 }