Use mcpp instead of icecpp

42 files changed, 576 insertions, 13042 deletions

diff --git a/cpp/config/Make.rules b/cpp/config/Make.rules
index 93f8e5d251a..f8ee74e5641 100644
--- a/cpp/config/Make.rules
+++ b/cpp/config/Make.rules
@@ -89,6 +89,12 @@ USE_READLINE		?= no
 #OPENSSL_HOME		?= /opt/openssl
 
 #
+# If Mcpp is not installed in a standard location where the  compiler 
+# can find it, set MCPP_HOME to the Mcpp installation directory.
+#
+#MCPP_HOME		?= /opt/mcpp
+
+#
 # Define if your OpenSSL requires Kerberos, and if Kerberos is not
 # installed in a standard location
 #
@@ -196,6 +202,7 @@ EXPAT_FLAGS             = $(if $(EXPAT_HOME),-I$(EXPAT_HOME)/include)
 EXPAT_LIBS              = $(if $(EXPAT_HOME),-L$(EXPAT_HOME)/$(libsubdir)) -lexpat
 EXPAT_RPATH_LINK        = $(if $(EXPAT_HOME),$(call rpathlink,$(EXPAT_HOME)/$(libsubdir)))
 
+MCPP_LIBS              = $(if $(MCPP_HOME),-L$(MCPP_HOME)/$(libsubdir)) -lmcpp
 
 ifeq ($(PLATFORM_HAS_READLINE),yes)
     ifeq ($(USE_READLINE),yes)
diff --git a/cpp/config/makedepend.py b/cpp/config/makedepend.py
index 605f2ba5a19..a7e3db5461e 100755
--- a/cpp/config/makedepend.py
+++ b/cpp/config/makedepend.py
@@ -20,6 +20,9 @@ for line in fileinput.input():
     if commentre.search(line, 0):
         continue;
 
+    if len(line) == 0:
+        continue
+
     line = string.replace(line, ".o:", "$(OBJEXT):")
 
     if(previous):
diff --git a/cpp/include/Slice/CPlusPlusUtil.h b/cpp/include/Slice/CPlusPlusUtil.h
index bdf72e95e29..04a8b4c7e07 100644
--- a/cpp/include/Slice/CPlusPlusUtil.h
+++ b/cpp/include/Slice/CPlusPlusUtil.h
@@ -23,7 +23,6 @@ struct ToIfdef
     SLICE_API char operator()(char);
 };
 
-SLICE_API std::string normalizePath(const std::string&);
 SLICE_API std::string changeInclude(const std::string&, const std::vector<std::string>&);
 SLICE_API void printHeader(::IceUtilInternal::Output&);
 SLICE_API void printVersionCheck(::IceUtilInternal::Output&);
diff --git a/cpp/include/Slice/Parser.h b/cpp/include/Slice/Parser.h
index 2b63b5c8db9..1e009f019d9 100644
--- a/cpp/include/Slice/Parser.h
+++ b/cpp/include/Slice/Parser.h
@@ -975,7 +975,7 @@ public:
 
     StringList includeFiles() const;
     
-    int parse(FILE*, bool, FeatureProfile profile = Ice);
+    int parse(const std::string&, FILE*, bool, FeatureProfile profile = Ice);
 
     virtual void destroy();
     virtual void visit(ParserVisitor*, bool);
diff --git a/cpp/include/Slice/Preprocessor.h b/cpp/include/Slice/Preprocessor.h
index 07925d53642..f296a82ff07 100644
--- a/cpp/include/Slice/Preprocessor.h
+++ b/cpp/include/Slice/Preprocessor.h
@@ -11,10 +11,12 @@
 #define PREPROCESSOR_H
 
 #include <IceUtil/Config.h>
+#include <vector>
 #ifdef __BCPLUSPLUS__
 #  include <stdio.h>
 #endif
 
+
 #ifndef SLICE_API
 #   ifdef SLICE_API_EXPORTS
 #       define SLICE_API ICE_DECLSPEC_EXPORT
@@ -30,7 +32,7 @@ class SLICE_API Preprocessor
 {
 public:
 
-    Preprocessor(const std::string&, const std::string&, const std::string&);
+    Preprocessor(const std::string&, const std::string&, const std::vector<std::string>&);
     ~Preprocessor();
     
     FILE* preprocess(bool);
@@ -38,7 +40,7 @@ public:
 
     enum Language { CPlusPlus, Java, CSharp, VisualBasic };
 
-    void printMakefileDependencies(Language);
+    void printMakefileDependencies(Language, const std::vector<std::string>&);
     
     std::string getBaseName();
 
@@ -48,11 +50,11 @@ public:
 private:
     
     bool checkInputFile();
-    std::string searchIceCpp();
 
     const std::string _path;
     const std::string _fileName;
-    const std::string _args;
+    const std::vector<std::string> _args;
+    std::string _cppFile;
     FILE* _cppHandle;
 };
 
diff --git a/cpp/src/FreezeScript/DumpDB.cpp b/cpp/src/FreezeScript/DumpDB.cpp
index 869042a9734..c1d29884086 100644
--- a/cpp/src/FreezeScript/DumpDB.cpp
+++ b/cpp/src/FreezeScript/DumpDB.cpp
@@ -122,7 +122,7 @@ printCatalogData(const string& dbName, const Freeze::CatalogData& data)
 static int
 run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
 {
-    string cppArgs;
+    vector<string> cppArgs;
     bool debug;
     bool ice = true; // Needs to be true in order to create default definitions.
     string outputFile;
@@ -234,7 +234,7 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("D");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            cppArgs += " -D" + *i;
+            cppArgs.push_back("-D" + *i);
         }
     }
     if(opts.isSet("U"))
@@ -242,7 +242,7 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("U");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            cppArgs += " -U" + *i;
+            cppArgs.push_back("-U" + *i);
         }
     }
     if(opts.isSet("I"))
@@ -250,7 +250,7 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("I");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            cppArgs += " -I" + *i;
+            cppArgs.push_back("-I" + *i);
         }
     }
     debug = opts.isSet("debug");
diff --git a/cpp/src/FreezeScript/Util.cpp b/cpp/src/FreezeScript/Util.cpp
index b8f5c17cfc8..642f91abe0d 100644
--- a/cpp/src/FreezeScript/Util.cpp
+++ b/cpp/src/FreezeScript/Util.cpp
@@ -169,8 +169,8 @@ FreezeScript::createEvictorSliceTypes(const Slice::UnitPtr& u)
 }
 
 bool
-FreezeScript::parseSlice(const string& n, const Slice::UnitPtr& u, const vector<string>& files, const string& cppArgs,
-                         bool debug)
+FreezeScript::parseSlice(const string& n, const Slice::UnitPtr& u, const vector<string>& files,
+                         const vector<string>& cppArgs, bool debug)
 {
     //
     // Parse the Slice files.
@@ -186,7 +186,7 @@ FreezeScript::parseSlice(const string& n, const Slice::UnitPtr& u, const vector<
             return false;
         }
 
-        int status = u->parse(cppHandle, debug);
+        int status = u->parse(*p, cppHandle, debug);
 
         if(!icecpp.close())
         {
diff --git a/cpp/src/FreezeScript/Util.h b/cpp/src/FreezeScript/Util.h
index fd777c65f40..bbf43764938 100644
--- a/cpp/src/FreezeScript/Util.h
+++ b/cpp/src/FreezeScript/Util.h
@@ -55,7 +55,8 @@ std::string typeName(const Slice::TypePtr&);
 std::string typeToString(const Slice::TypePtr&);
 bool ignoreType(const std::string&);
 void createEvictorSliceTypes(const Slice::UnitPtr&);
-bool parseSlice(const std::string&, const Slice::UnitPtr&, const std::vector<std::string>&, const std::string&, bool);
+bool parseSlice(const std::string&, const Slice::UnitPtr&, const std::vector<std::string>&, 
+                const std::vector<std::string>&, bool);
 
 typedef std::map<std::string, Freeze::CatalogData> CatalogDataMap;
 
diff --git a/cpp/src/FreezeScript/transformdb.cpp b/cpp/src/FreezeScript/transformdb.cpp
index dbd64cae3ea..467757e5862 100644
--- a/cpp/src/FreezeScript/transformdb.cpp
+++ b/cpp/src/FreezeScript/transformdb.cpp
@@ -215,8 +215,8 @@ transformDb(bool evictor,  const Ice::CommunicatorPtr& communicator,
 static int
 run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
 {
-    string oldCppArgs;
-    string newCppArgs;
+    vector<string> oldCppArgs;
+    vector<string> newCppArgs;
     bool debug;
     bool ice = true; // Needs to be true in order to create default definitions.
     string outputFile;
@@ -283,8 +283,8 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("D");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            oldCppArgs += " -D" + *i;
-            newCppArgs += " -D" + *i;
+            oldCppArgs.push_back("-D" + *i);
+            newCppArgs.push_back("-D" + *i);
         }
     }
     if(opts.isSet("U"))
@@ -292,8 +292,8 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("U");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            oldCppArgs += " -U" + *i;
-            newCppArgs += " -U" + *i;
+            oldCppArgs.push_back("-U" + *i);
+            newCppArgs.push_back("-U" + *i);
         }
     }
     debug = opts.isSet("debug");
@@ -315,7 +315,7 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("include-old");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            oldCppArgs += " -I" + *i;
+            oldCppArgs.push_back("-I" + *i);
         }
     }
     if(opts.isSet("include-new"))
@@ -323,7 +323,7 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         vector<string> optargs = opts.argVec("include-new");
         for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
         {
-            newCppArgs += " -I" + *i;
+            newCppArgs.push_back("-I" + *i);
         }
     }
     if(opts.isSet("old"))
diff --git a/cpp/src/Makefile b/cpp/src/Makefile
index 1008738359d..73ce13fc4f9 100644
--- a/cpp/src/Makefile
+++ b/cpp/src/Makefile
@@ -12,7 +12,6 @@ top_srcdir	= ..
 include $(top_srcdir)/config/Make.rules
 
 SUBDIRS		= IceUtil \
-		  icecpp \
 		  Slice \
 		  slice2cpp \
 		  slice2cppe \
diff --git a/cpp/src/Makefile.mak b/cpp/src/Makefile.mak
index 9fce6f07267..8ee814001ad 100644
--- a/cpp/src/Makefile.mak
+++ b/cpp/src/Makefile.mak
@@ -11,11 +11,7 @@ top_srcdir	= ..
 
 !include $(top_srcdir)/config/Make.rules.mak
 
-!if "$(CPP_COMPILER)" != "BCC2006"
-SUBDIRS		= icecpp
-!endif
-
-SUBDIRS		= $(SUBDIRS) IceUtil \
+SUBDIRS		= IceUtil \
 		  Slice \
 		  slice2cpp \
 		  slice2cppe \
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index 8b495c53f0c..adaafa98b3a 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -8,6 +8,7 @@
 // **********************************************************************
 
 #include <Slice/CPlusPlusUtil.h>
+#include <Slice/Util.h>
 
 using namespace std;
 using namespace Slice;
@@ -30,27 +31,11 @@ Slice::ToIfdef::operator()(char c)
 }
 
 string
-Slice::normalizePath(const string& path)
-{
-    string result = path;
-    replace(result.begin(), result.end(), '\\', '/');
-    string::size_type pos;
-    while((pos = result.find("//")) != string::npos)
-    {
-        result.replace(pos, 2, "/");
-    }
-    if(result.size() > 1 && isalpha(result[0]) && result[1] == ':')
-    {
-        result = result.substr(2);
-    }
-    return result;
-}
-
-string
 Slice::changeInclude(const string& orig, const vector<string>& includePaths)
 {
-    string file = normalizePath(orig);
+    string file = normalizePath(orig, true);
     string::size_type pos;
+    string cwd = getCwd();
 
     //
     // Compare each include path against the included file and select
@@ -59,7 +44,12 @@ Slice::changeInclude(const string& orig, const vector<string>& includePaths)
     string result = file;
     for(vector<string>::const_iterator p = includePaths.begin(); p != includePaths.end(); ++p)
     {
-        string includePath = normalizePath(*p);
+        string includePath = *p;
+        if(isAbsolute(orig) && !isAbsolute(includePath))
+        {
+            includePath = cwd + "/" + includePath;
+        }
+        includePath = normalizePath(includePath, true);
 
         if(file.compare(0, includePath.length(), includePath) == 0)
         {
diff --git a/cpp/src/Slice/Makefile b/cpp/src/Slice/Makefile
index db10d93cd5a..dc6784c8ad0 100644
--- a/cpp/src/Slice/Makefile
+++ b/cpp/src/Slice/Makefile
@@ -26,15 +26,16 @@ OBJS		= Scanner.o \
 		  PythonUtil.o \
 		  DotNetNames.o \
 		  RubyUtil.o \
-                  MD5.o \
-                  MD5I.o
+		  Util.o \
+		  MD5.o \
+		  MD5I.o
 
 SRCS		= $(OBJS:.o=.cpp)
 
 include $(top_srcdir)/config/Make.rules
 
 CPPFLAGS	:= -I.. $(CPPFLAGS) -DSLICE_API_EXPORTS 
-LINKWITH	:= -lIceUtil
+LINKWITH	:= -lIceUtil $(MCPP_LIBS)
 BISONFLAGS	:= --name-prefix "slice_" $(BISONFLAGS)
 
 ifeq ($(STATICLIBS),yes)
diff --git a/cpp/src/Slice/Makefile.mak b/cpp/src/Slice/Makefile.mak
index 6b1d7d0d6f7..660bb0ffdd2 100644
--- a/cpp/src/Slice/Makefile.mak
+++ b/cpp/src/Slice/Makefile.mak
@@ -25,8 +25,9 @@ OBJS		= Scanner.obj \
 		  PythonUtil.obj \
 		  DotNetNames.obj \
 		  RubyUtil.obj \
-                  MD5.obj \
-                  MD5I.obj
+		  Util.obj \
+		  MD5.obj \
+		  MD5I.obj
 
 SRCS		= $(OBJS:.obj=.cpp)
 
@@ -50,7 +51,7 @@ $(LIBNAME): $(OBJS)
 $(LIBNAME): $(DLLNAME)
 
 $(DLLNAME): $(OBJS)
-	$(LINK) $(LD_DLLFLAGS) $(PDBFLAGS) $(OBJS) $(PREOUT)$@ $(PRELIBS)$(BASELIBS)
+	$(LINK) $(LD_DLLFLAGS) $(PDBFLAGS) $(OBJS) $(PREOUT)$@ $(PRELIBS)$(BASELIBS) mcpp.lib
 	move $(DLLNAME:.dll=.lib) $(LIBNAME)
 	@if exist $@.manifest echo ^ ^ ^ Embedding manifest using $(MT) && \
 	    $(MT) -nologo -manifest $@.manifest -outputresource:$@;#2 && del /q $@.manifest
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 7f79e2bf54c..e2bea935547 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -9,12 +9,19 @@
 
 #include <IceUtil/Functional.h>
 #include <IceUtil/InputUtil.h>
+#include <IceUtil/StringUtil.h>
+#include <IceUtil/Unicode.h>
 #include <Slice/Parser.h>
 #include <Slice/GrammarUtil.h>
+#include <Slice/Util.h>
 #ifdef __BCPLUSPLUS__
 #  include <iterator>
 #endif
 
+#ifdef _WIN32
+#   include <io.h>
+#endif
+
 using namespace std;
 using namespace Slice;
 
@@ -4987,6 +4994,88 @@ Slice::Unit::nextLine()
     _currentLine++;
 }
 
+#ifdef _WIN32
+//
+// On Windows mcpp output does not maintain filename capitalization
+// so we have to manually fix it up.
+//
+string
+fixCapitalization(const string& path)
+{
+    if(!isAbsolute(path))
+    {
+        return path;
+    }
+
+    vector<string> result;
+    IceUtilInternal::splitString(path, "/", result);
+    string currentPath = result[0];
+    for(unsigned int i = 1; i < result.size(); ++i)
+    {
+        const wstring fs = IceUtil::stringToWstring(currentPath + "/*");
+
+#ifdef __BCPLUSPLUS__
+        struct _wffblk data;
+        int h = _wfindfirst(fs.c_str(), &data, FA_DIREC);
+        if(h == -1)
+        {
+            return path;
+        }
+
+        while(true)
+        {
+            string name = IceUtil::wstringToString(data.ff_name);
+            assert(!name.empty());
+
+            if(_stricmp(name.c_str(), result[i].c_str()) == 0)
+            {
+                currentPath += "/" + name;
+                _wfindclose(&data);
+                break;
+            }
+
+            if(_wfindnext(&data) == -1)
+            {
+                _wfindclose(&data);
+                return path;
+            }
+       }
+#else
+        struct _wfinddata_t data;
+#    if defined(_MSC_VER) && (_MSC_VER < 1300)
+        long h = _wfindfirst(fs.c_str(), &data);
+#    else
+        intptr_t h = _wfindfirst(fs.c_str(), &data);
+#    endif
+        if(h == -1)
+        {
+            return path;
+        }
+
+        while(true)
+        {
+            string name = IceUtil::wstringToString(data.name);
+            assert(!name.empty());
+
+            if(_stricmp(name.c_str(), result[i].c_str()) == 0)
+            {
+                currentPath += "/" + name;
+                _findclose(h);
+                break;
+            }
+        
+            if(_wfindnext(h, &data) == -1)
+            {
+                _findclose(h);
+                return path;
+            }
+        }
+#endif
+    }
+    return currentPath;
+}
+#endif
+
 void
 Slice::Unit::scanPosition(const char* s)
 {
@@ -5011,32 +5100,6 @@ Slice::Unit::scanPosition(const char* s)
     }
     eraseWhiteSpace(line);
 
-    //
-    // If the string ends in <whitespace>1 or <whitespace>2, it is a push or pop directive.
-    //
-    enum LineType { File, Push, Pop };
-
-    LineType type = File;
-
-    idx = line.find_last_of(" \t\r");
-    if(idx != string::npos)
-    {
-        ++idx;
-        if(line.substr(idx) == "1")
-        {
-            type = Push;
-            line.erase(idx);
-            eraseWhiteSpace(line);
-
-        }
-        else if(line.substr(idx) == "2")
-        {
-            type = Pop;
-            line.erase(idx);
-            eraseWhiteSpace(line);
-        }
-    }
-
     string currentFile;
     if(!line.empty())
     {
@@ -5054,6 +5117,35 @@ Slice::Unit::scanPosition(const char* s)
         }
     }
 
+#ifdef _WIN32
+    currentFile = fixCapitalization(currentFile);
+#endif
+    currentFile = normalizePath(currentFile, false);
+
+    enum LineType { File, Push, Pop };
+
+    LineType type = File;
+
+    if(_currentLine == 0)
+    {
+        if(currentFile != _topLevelFile)
+        {
+            type = Push;
+            line.erase(idx);
+            eraseWhiteSpace(line);
+        }
+    }
+    else
+    {
+        DefinitionContextPtr dc = currentDefinitionContext();
+        if(dc != 0 && !dc->filename().empty() && dc->filename() != currentFile)
+        {
+            type = Pop;
+            line.erase(idx);
+            eraseWhiteSpace(line);
+        }
+    }
+
     switch(type)
     {
         case Push:
@@ -5417,7 +5509,7 @@ Slice::Unit::includeFiles() const
 }
 
 int
-Slice::Unit::parse(FILE* file, bool debug, Slice::FeatureProfile profile)
+Slice::Unit::parse(const string& filename, FILE* file, bool debug, Slice::FeatureProfile profile)
 {
     slice_debug = debug ? 1 : 0;
 
@@ -5428,6 +5520,7 @@ Slice::Unit::parse(FILE* file, bool debug, Slice::FeatureProfile profile)
     _currentLine = 1;
     _currentIncludeLevel = 0;
     _featureProfile = profile;
+    _topLevelFile = normalizePath(filename);
     pushContainer(this);
     pushDefinitionContext();
 
@@ -5502,6 +5595,7 @@ Slice::Unit::Unit(bool ignRedefs, bool all, bool allowIcePrefix, bool caseSensit
     _caseSensitive(caseSensitive),
     _defaultGlobalMetadata(defaultGlobalMetadata),
     _errors(0)
+
 {
     _unit = this;
 }
diff --git a/cpp/src/Slice/Preprocessor.cpp b/cpp/src/Slice/Preprocessor.cpp
index 863e7f61d65..9129296ac8d 100644
--- a/cpp/src/Slice/Preprocessor.cpp
+++ b/cpp/src/Slice/Preprocessor.cpp
@@ -7,22 +7,42 @@
 //
 // **********************************************************************
 
+#include <IceUtil/DisableWarnings.h>
 #include <Slice/Preprocessor.h>
+#include <Slice/Util.h>
 #include <IceUtil/StringUtil.h>
+#include <IceUtil/UUID.h>
+#include <IceUtil/Unicode.h>
 #include <algorithm>
 #include <fstream>
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #ifndef _WIN32
-
 #   include <sys/wait.h>
 #endif
 
 using namespace std;
 using namespace Slice;
 
-Slice::Preprocessor::Preprocessor(const string& path, const string& fileName, const string& args) :
+//
+// mcpp defines
+//
+namespace Slice
+{
+
+enum Outdest
+{
+    Out=0, Err=1, Dbg=2, Num_Outdest=3
+}; 
+
+};
+
+extern "C" int   mcpp_lib_main(int argc, char** argv);
+extern "C" void  mcpp_use_mem_buffers(int tf);
+extern "C" char* mcpp_get_mem_buffer(Outdest od);
+
+Slice::Preprocessor::Preprocessor(const string& path, const string& fileName, const vector<string>& args) :
     _path(path),
     _fileName(fileName),
     _args(args),
@@ -86,7 +106,7 @@ Slice::Preprocessor::normalizeIncludePath(const string& path)
 	result.erase(result.size() - 1);
     }
 
-    return "\"" + result + "\"";
+    return result;
 }
 
 FILE*
@@ -97,70 +117,203 @@ Slice::Preprocessor::preprocess(bool keepComments)
         return 0;
     }
 
-    string cmd = searchIceCpp();
-
-    if(cmd.empty())
+    //
+    // Build arguments list.
+    //
+    vector<string> args = _args;
+    if(keepComments)
     {
-        return 0;
+        args.push_back("-C");
     }
+    args.push_back(_fileName);
 
-    if(keepComments)
+    char** argv = new char*[args.size() + 1];
+    argv[0] = "mcpp";
+    for(unsigned int i = 0; i < args.size(); ++i)
     {
-        cmd += " -C";
+        argv[i + 1] = (char*) args[i].c_str();
     }
     
-    cmd += " " + _args + " \"" + _fileName + "\"";
+    //
+    // Call mcpp using memory buffer.
+    //
+    mcpp_use_mem_buffers(1);
+    mcpp_lib_main(args.size() + 1, argv);
+    delete argv;
 
     //
-    // Open a pipe for reading to redirect icecpp output to _cppHandle.
+    // Write output to temporary file. Print errors to stderr.
     //
+    string result;
+    char* buf = mcpp_get_mem_buffer(Out);
+
+    _cppFile = ".preprocess." + IceUtil::generateUUID();
 #ifdef _WIN32
-    _cppHandle = _popen(cmd.c_str(), "r");
+    _cppHandle = ::_wfopen(IceUtil::stringToWstring(_cppFile).c_str(), IceUtil::stringToWstring("w+").c_str());
 #else
-    _cppHandle = popen(cmd.c_str(), "r");
+    _cppHandle = ::fopen(_cppFile.c_str(), "w+");
 #endif
+    if(buf)
+    {
+        ::fwrite(buf, strlen(buf), 1, _cppHandle);
+    }
+    ::rewind(_cppHandle);
+
+    char* err = mcpp_get_mem_buffer(Err);
+    if(err)
+    {
+        ::fputs(err, stderr);
+    }
+
+    mcpp_use_mem_buffers(0);
+
     return _cppHandle;
 }
 
 void
-Slice::Preprocessor::printMakefileDependencies(Language lang)
+Slice::Preprocessor::printMakefileDependencies(Language lang, const vector<string>& includePaths)
 {
     if(!checkInputFile())
     {
         return;
     }
 
-    string cmd = searchIceCpp();
-    
-    if(cmd.empty())
+    //
+    // Build arguments list.
+    //
+    vector<string> args = _args;
+    args.push_back("-M");
+    args.push_back(_fileName);
+
+    char** argv = new char*[args.size() + 1];
+    for(unsigned int i = 0; i < args.size(); ++i)
     {
-        return;
+        argv[i + 1] = (char*) args[i].c_str();
     }
     
-    cmd += " -M " + _args + " \"" + _fileName + "\"";
+    //
+    // Call mcpp using memory buffer.
+    //
+    mcpp_use_mem_buffers(1);
+    mcpp_lib_main(args.size() + 1, argv);
+    delete argv;
+
+    //
+    // Get mcpp output/errors.
+    //
+    string unprocessed;
+    char* buf = mcpp_get_mem_buffer(Out);
+    if(buf)
+    {
+        unprocessed = string(buf);
+    }
+
+    char* err = mcpp_get_mem_buffer(Err);
+    if(err)
+    {
+        ::fputs(err, stderr);
+    }
+    mcpp_use_mem_buffers(0);
+
+    //
+    // We now need to massage then result to get desire output.
+    // First make it a single line.
+    //
+    string::size_type pos;
+    while((pos = unprocessed.find("\\\n")) != string::npos)
+    {
+        unprocessed.replace(pos, 2, "");
+    }
 
+    //
+    // Get the main output file name.
+    //
 #ifdef _WIN32
-    FILE* cppHandle = _popen(cmd.c_str(), "r");
+     string suffix = ".obj:";
 #else
-    FILE* cppHandle = popen(cmd.c_str(), "r");
+     string suffix = ".o:";
 #endif
+    pos = unprocessed.find(suffix) + suffix.size();
+    string result = unprocessed.substr(0, pos);
+
+    //
+    // Process each dependency.
+    //
+    string::size_type end;
+    while((end = unprocessed.find(".ice", pos)) != string::npos)
+    {
+        end += 4;
+        string file = unprocessed.substr(pos, end - pos);
+
+        //
+        // Strip white space from the file name.
+        //
+        int b = file.find_first_not_of(" \t");
+        int e = file.find_last_not_of(" \t");
+        file = file.substr(b, e - b + 1);
+        
+        //
+        // Normalize paths if not relative path.
+        //
+        if(isAbsolute(file))
+        {
+            string newFile = file;
+            string cwd = getCwd();
+            for(vector<string>::const_iterator p = includePaths.begin(); p != includePaths.end(); ++p)
+            {
+                string includePath = *p;
+                if(!isAbsolute(includePath))
+                {
+                    includePath = cwd + "/" + includePath;
+                }
+                includePath = normalizePath(includePath, false);
+
+                if(file.compare(0, includePath.length(), includePath) == 0)
+                {
+                    string s = *p + file.substr(includePath.length());
+                    if(isAbsolute(newFile) || s.size() < newFile.size())
+                    {
+                        newFile = s;
+                    }
+                }
+            }
+            file = newFile;
+        }
+
+        //
+        // Escape spaces in the file name.
+        //
+        string::size_type space = 0;
+        while((space = file.find(" ", space)) != string::npos)
+        {
+            file.replace(space, 1, "\\ ");
+            space += 2;
+        }
+
+        //
+        // Add to result
+        //
+        result += " \\\n " + file;
+        pos = end;
+    }
+    result += "\n";
 
     /*
      * icecpp emits dependencies in any of the following formats, depending on the
      * length of the filenames:
      *
-     * x.cpp: /path/x.ice /path/y.ice
+     * x.o[bj]: /path/x.ice /path/y.ice
      *
-     * x.cpp: /path/x.ice \ 
+     * x.o[bj]: /path/x.ice \ 
      *  /path/y.ice
      *
-     * x.cpp: /path/x.ice /path/y.ice \ 
+     * x.o[bj]: /path/x.ice /path/y.ice \ 
      *  /path/z.ice
      *
-     * x.cpp: \ 
+     * x.o[bj]: \ 
      *  /path/x.ice
      *
-     * x.cpp: \ 
+     * x.o[bj]: \ 
      *  /path/x.ice \ 
      *  /path/y.ice
      *
@@ -172,10 +325,13 @@ Slice::Preprocessor::printMakefileDependencies(Language lang)
     {
         case CPlusPlus:
         {
-            char buf[1024];
-            while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
+            //
+            // Change .o[bj] suffix to .cpp suffix.
+            //
+            string::size_type pos;
+            while((pos = result.find(suffix)) != string::npos)
             {
-                fputs(buf, stdout);
+                result.replace(pos, suffix.size() - 1, ".cpp");
             }
             break;
         }
@@ -185,37 +341,28 @@ Slice::Preprocessor::printMakefileDependencies(Language lang)
             // We want to shift the files left one position, so that
             // "x.cpp: x.ice y.ice" becomes "x.ice: y.ice".
             //
-            // Since the pipe input can be returned a line at a time, we collect
-            // all of the output into one string before manipulating it.
-            //
-            string deps;
-            char buf[1024];
-            while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
-            {
-                deps.append(buf, strlen(buf));
-            }
 
             //
             // Remove the first file.
             //
-            string::size_type start = deps.find(".cpp:");
+            string::size_type start = result.find(suffix);
             assert(start != string::npos);
-            start = deps.find_first_not_of(" \t\r\n\\", start + 5); // Skip to beginning of next file.
+            start = result.find_first_not_of(" \t\r\n\\", start + suffix.size()); // Skip to beginning of next file.
             assert(start != string::npos);
-            deps.erase(0, start);
+            result.erase(0, start);
 
             //
             // Find end of next file.
             //
             string::size_type pos = 0;
-            while((pos = deps.find_first_of(" :\t\r\n\\", pos + 1)) != string::npos)
+            while((pos = result.find_first_of(" :\t\r\n\\", pos + 1)) != string::npos)
             {
-                if(deps[pos] == ':')
+                if(result[pos] == ':')
                 {
-                    deps.insert(pos, 1, '\\'); // Escape colons.
+                    result.insert(pos, 1, '\\'); // Escape colons.
                     ++pos;
                 }
-                else if(deps[pos] == '\\') // Ignore escaped characters.
+                else if(result[pos] == '\\') // Ignore escaped characters.
                 {
                     ++pos;
                 }
@@ -227,75 +374,23 @@ Slice::Preprocessor::printMakefileDependencies(Language lang)
 
             if(pos == string::npos)
             {
-                deps.append(":");
+                result.append(":");
             }
             else
             {
-                deps.insert(pos, 1, ':');
+                result.insert(pos, 1, ':');
             }
-
-            fputs(deps.c_str(), stdout);
             break;
         }
         case CSharp:
         {
             //
-            // Change .cpp suffix to .cs suffix.
+            // Change .o[bj] suffix to .cs suffix.
             //
-            char buf[1024];
-            while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
+            string::size_type pos;
+            while((pos = result.find(suffix)) != string::npos)
             {
-                char* dot;
-                char* colon = strchr(buf, ':');
-                if(colon != NULL)
-                {
-                    *colon = '\0';
-                    dot = strrchr(buf, '.');
-                    *colon = ':';
-                    if(dot != NULL)
-                    {
-                        if(strncmp(dot, ".cpp:", 5) == 0)
-                        {
-                            *dot = '\0';
-                            fputs(buf, stdout);
-                            fputs(".cs", stdout);
-                            fputs(colon, stdout);
-                            continue;
-                        }
-                    }
-                }
-                fputs(buf, stdout);
-            }
-            break;
-        }
-        case VisualBasic:
-        {
-            //
-            // Change .cpp suffix to .vb suffix.
-            //
-            char buf[1024];
-            while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
-            {
-                char* dot;
-                char* colon = strchr(buf, ':');
-                if(colon != NULL)
-                {
-                    *colon = '\0';
-                    dot = strrchr(buf, '.');
-                    *colon = ':';
-                    if(dot != NULL)
-                    {
-                        if(strncmp(dot, ".cpp:", 5) == 0)
-                        {
-                            *dot = '\0';
-                            fputs(buf, stdout);
-                            fputs(".vb", stdout);
-                            fputs(colon, stdout);
-                            continue;
-                        }
-                    }
-                }
-                fputs(buf, stdout);
+                result.replace(pos, suffix.size() - 1, ".cpp");
             }
             break;
         }
@@ -305,6 +400,11 @@ Slice::Preprocessor::printMakefileDependencies(Language lang)
             break;
         }
     }
+
+    //
+    // Output result
+    //
+    fputs(result.c_str(), stdout);
 }
 
 bool
@@ -312,22 +412,18 @@ Slice::Preprocessor::close()
 {
     assert(_cppHandle);
 
-#ifndef _WIN32
-    int status = pclose(_cppHandle);
-    _cppHandle = 0;
-
-    if(WIFEXITED(status) && WEXITSTATUS(status) != 0)
-    {
-        return false;
-    }
-#else
-    int status = _pclose(_cppHandle);
+    int status = fclose(_cppHandle);
     _cppHandle = 0;
 
     if(status != 0)
     {
         return false;
     }
+
+#ifdef _WIN32
+    _unlink(_cppFile.c_str());
+#else
+    unlink(_cppFile.c_str());
 #endif
     
     return true;
@@ -360,35 +456,3 @@ Slice::Preprocessor::checkInputFile()
 
     return true;
 }
-
-string
-Slice::Preprocessor::searchIceCpp()
-{
-#ifndef _WIN32
-    const char* icecpp = "icecpp";
-#else
-    const char* icecpp = "icecpp.exe";
-#endif
-
-    string::size_type pos = _path.find_last_of("/\\");
-    if(pos != string::npos)
-    {
-        string path = _path.substr(0, pos + 1);
-        path += icecpp;
-
-        struct stat st;
-        if(stat(path.c_str(), &st) == 0)
-        {
-#ifndef _WIN32
-            if(st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
-#else
-            if(st.st_mode & (S_IEXEC))
-#endif
-            {
-                return path;
-            }
-        }
-    }
-
-    return icecpp;
-}
diff --git a/cpp/src/Slice/PythonUtil.cpp b/cpp/src/Slice/PythonUtil.cpp
index 1dad0ec46b6..515e42a9f75 100644
--- a/cpp/src/Slice/PythonUtil.cpp
+++ b/cpp/src/Slice/PythonUtil.cpp
@@ -9,6 +9,7 @@
 
 #include <Slice/PythonUtil.h>
 #include <Slice/Checksum.h>
+#include <Slice/Util.h>
 #include <IceUtil/IceUtil.h>
 #include <IceUtil/StringUtil.h>
 #include <IceUtil/InputUtil.h>
@@ -1761,23 +1762,11 @@ Slice::Python::CodeVisitor::collectExceptionMembers(const ExceptionPtr& p, Membe
 }
 
 static string
-normalizePath(const string& path)
-{
-    string result = path;
-    replace(result.begin(), result.end(), '\\', '/');
-    string::size_type pos;
-    while((pos = result.find("//")) != string::npos)
-    {
-        result.replace(pos, 2, "/");
-    }
-    return result;
-}
-
-static string
 changeInclude(const string& inc, const vector<string>& includePaths)
 {
     string orig = normalizePath(inc);
     string curr = orig; // The current shortest pathname.
+    string cwd = getCwd();
 
     //
     // Compare the pathname of the included file against each of the include directories.
@@ -1787,10 +1776,15 @@ changeInclude(const string& inc, const vector<string>& includePaths)
     for(vector<string>::const_iterator p = includePaths.begin(); p != includePaths.end(); ++p)
     {
         string includePath = *p;
+        if(isAbsolute(orig) && !isAbsolute(includePath))
+        {
+            includePath = cwd + "/" + includePath;
+        }
+        includePath = normalizePath(includePath);
 
-        if(orig.compare(0, p->size(), *p) == 0)
+        if(orig.compare(0, includePath.size(), includePath) == 0)
         {
-            string s = orig.substr(p->size());
+            string s = orig.substr(includePath.size());
             if(s.size() < curr.size())
             {
                 curr = s;
diff --git a/cpp/src/Slice/RubyUtil.cpp b/cpp/src/Slice/RubyUtil.cpp
index 47bf17f6c52..1b078e08b7d 100644
--- a/cpp/src/Slice/RubyUtil.cpp
+++ b/cpp/src/Slice/RubyUtil.cpp
@@ -9,6 +9,7 @@
 
 #include <Slice/RubyUtil.h>
 #include <Slice/Checksum.h>
+#include <Slice/Util.h>
 #include <IceUtil/Functional.h>
 #include <IceUtil/InputUtil.h>
 
@@ -1588,23 +1589,11 @@ Slice::Ruby::CodeVisitor::collectExceptionMembers(const ExceptionPtr& p, MemberI
 }
 
 static string
-normalizePath(const string& path)
-{
-    string result = path;
-    replace(result.begin(), result.end(), '\\', '/');
-    string::size_type pos;
-    while((pos = result.find("//")) != string::npos)
-    {
-        result.replace(pos, 2, "/");
-    }
-    return result;
-}
-
-static string
 changeInclude(const string& inc, const vector<string>& includePaths)
 {
     string orig = normalizePath(inc);
     string curr = orig; // The current shortest pathname.
+    string cwd = getCwd();
 
     //
     // Compare the pathname of the included file against each of the include directories.
@@ -1614,10 +1603,15 @@ changeInclude(const string& inc, const vector<string>& includePaths)
     for(vector<string>::const_iterator p = includePaths.begin(); p != includePaths.end(); ++p)
     {
         string includePath = *p;
+        if(isAbsolute(orig) && !isAbsolute(includePath))
+        {
+            includePath = cwd + "/" + includePath;
+        }
+        includePath = normalizePath(includePath);
 
-        if(orig.compare(0, p->size(), *p) == 0)
+        if(orig.compare(0, includePath.size(), includePath) == 0)
         {
-            string s = orig.substr(p->size());
+            string s = orig.substr(includePath.size());
             if(s.size() < curr.size())
             {
                 curr = s;
diff --git a/cpp/src/Slice/Util.cpp b/cpp/src/Slice/Util.cpp
new file mode 100644
index 00000000000..1c4e82ff0f4
--- /dev/null
+++ b/cpp/src/Slice/Util.cpp
@@ -0,0 +1,85 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Slice/Util.h>
+#include <IceUtil/Unicode.h>
+
+#ifdef __hpux
+#  include <unistd.h>
+#endif
+
+using namespace std;
+using namespace Slice;
+
+string
+Slice::getCwd()
+{
+#ifdef _WIN32
+    wchar_t cwdbuf[_MAX_PATH];
+    if(_wgetcwd(cwdbuf, _MAX_PATH) != NULL)
+    {
+        return IceUtil::wstringToString(cwdbuf);
+    }
+#else
+    char cwdbuf[PATH_MAX];
+    if(::getcwd(cwdbuf, PATH_MAX) != NULL)
+    {
+        return cwdbuf;
+    }
+#endif
+    return "";
+}
+
+bool
+Slice::isAbsolute(const string& path)
+{
+#ifdef _WIN32
+        if(path[0] == '\\' || path[0] == '/' || path.size() > 1 && isalpha(path[0]) && path[1] == ':')
+#else
+        if(path[0] == '/')
+#endif
+        {
+            return true;
+        }
+
+        return false;
+}
+
+string
+Slice::normalizePath(const string& path, bool removeDriveLetter)
+{
+    string result = path;
+    replace(result.begin(), result.end(), '\\', '/');
+    string::size_type pos;
+    while((pos = result.find("//")) != string::npos)
+    {
+        result.replace(pos, 2, "/");
+    }
+    pos = 0;
+    while((pos = result.find("/..", pos)) != string::npos)
+    {
+        string::size_type last = result.find_last_of("/", pos - 1);
+        if(last != string::npos && result.substr(last, 4) != "/../")
+        {
+            result.erase(last, pos - last + 3);
+            pos = last;
+        }
+        else
+        {
+            ++pos;
+        }
+    }
+
+    if(removeDriveLetter && result.size() > 1 && isalpha(result[0]) && result[1] == ':')
+    {
+        result = result.substr(2);
+    }
+
+    return result;
+}
diff --git a/cpp/src/Slice/Util.h b/cpp/src/Slice/Util.h
new file mode 100644
index 00000000000..a3a9b38745c
--- /dev/null
+++ b/cpp/src/Slice/Util.h
@@ -0,0 +1,24 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef _SLICE_UTIL_H
+#define _SLICEP_UTIL_H
+
+#include <Slice/Parser.h>
+
+namespace Slice
+{
+
+SLICE_API std::string getCwd();
+SLICE_API bool isAbsolute(const std::string&);
+SLICE_API std::string normalizePath(const std::string&, bool = false);
+
+}
+
+#endif
diff --git a/cpp/src/icecpp/.gitignore b/cpp/src/icecpp/.gitignore
deleted file mode 100644
index c8cafb9ec4c..00000000000
--- a/cpp/src/icecpp/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-// Generated by makegitignore.py
-
-// IMPORTANT: Do not edit this file -- any edits made here will be lost!
-cexp.c
diff --git a/cpp/src/icecpp/COPYING b/cpp/src/icecpp/COPYING
deleted file mode 100644
index a6991c36ce4..00000000000
--- a/cpp/src/icecpp/COPYING
+++ /dev/null
@@ -1,340 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-                       51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) 19yy  <name of author>
-
-    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 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) 19yy name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.
diff --git a/cpp/src/icecpp/Makefile b/cpp/src/icecpp/Makefile
deleted file mode 100644
index d7a54655318..00000000000
--- a/cpp/src/icecpp/Makefile
+++ /dev/null
@@ -1,35 +0,0 @@
-# **********************************************************************
-#
-# Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
-#
-# This copy of Ice is licensed to you under the terms described in the
-# ICE_LICENSE file included in this distribution.
-#
-# **********************************************************************
-
-top_srcdir	= ../..
-
-NAME		= $(top_srcdir)/bin/icecpp
-
-TARGETS		= $(NAME)
-
-OBJS		= cccp.o \
-		  cexp.o \
-		  prefix.o
-
-include $(top_srcdir)/config/Make.rules
-
-CFLAGS += -I. -DPREFIX=\"\"
-
-cexp.c: cexp.y
-	bison -o cexp.c cexp.y
-
-$(NAME): $(OBJS)
-	rm -f $@
-	$(CC) $(CFLAGS) -o $@ $(OBJS)
-
-install:: all
-	$(call installprogram,$(NAME),$(install_bindir))
-
-clean::
-	-rm -f cexp.c
diff --git a/cpp/src/icecpp/Makefile.mak b/cpp/src/icecpp/Makefile.mak
deleted file mode 100644
index 052c8efce6c..00000000000
--- a/cpp/src/icecpp/Makefile.mak
+++ /dev/null
@@ -1,55 +0,0 @@
-# **********************************************************************
-#
-# Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
-#
-# This copy of Ice is licensed to you under the terms described in the
-# ICE_LICENSE file included in this distribution.
-#
-# **********************************************************************
-
-top_srcdir	= ..\..
-
-NAME		= $(top_srcdir)\bin\icecpp.exe
-
-TARGETS		= $(NAME)
-
-OBJS		= cccp.obj \
-		  cexp.obj \
-		  prefix.obj
-
-!include $(top_srcdir)/config/Make.rules.mak
-
-CFLAGS = $(CFLAGS) -I. -I../../include -DWIN32_LEAN_AND_MEAN
-
-!if "$(CPP_COMPILER)" != "BCC2006"
-LINKWITH	= advapi32.lib
-!endif
-
-!if "$(CPP_COMPILER)" != "BCC2006" && "$(OPTIMIZE)" != "yes"
-PDBFLAGS        = /pdb:$(NAME:.exe=.pdb)
-!endif
-
-cexp.c: cexp.y
-	bison -o cexp.c cexp.y
-
-prefix.obj: prefix.c
-	$(CC) /c $(CPPFLAGS) $(CFLAGS) -D__STDC__ prefix.c
-
-$(NAME): $(OBJS)
-	$(LINK) $(LD_EXEFLAGS) $(PDBFLAGS) $(OBJS) $(SETARGV) $(PREOUT)$@ $(PRELIBS)$(LINKWITH)
-	@if exist $@.manifest echo ^ ^ ^ Embedding manifest using $(MT) && \
-	    $(MT) -nologo -manifest $@.manifest -outputresource:$@;#1 && del /q $@.manifest
-
-install:: all
-	copy $(NAME) $(install_bindir)
-
-!if "$(CPP_COMPILER)" != "BCC2006" && "$(OPTIMIZE)" != "yes"
-
-install:: all
-	copy $(NAME:.exe=.pdb) $(install_bindir)
-
-!endif
-
-clean::
-	del /q cexp.c
-	del /q $(NAME:.exe=.*)
diff --git a/cpp/src/icecpp/cccp.c b/cpp/src/icecpp/cccp.c
deleted file mode 100644
index 7c350441055..00000000000
--- a/cpp/src/icecpp/cccp.c
+++ /dev/null
@@ -1,10444 +0,0 @@
-/* C Compatible Compiler Preprocessor (CCCP)
-   Copyright (C) 1986, 87, 89, 92-97, 1998 Free Software Foundation, Inc.
-   Written 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 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, 51
-Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#include "config.h"
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <signal.h>
-
-#ifdef TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-# include <sys/time.h>
-# else
-#  include <time.h>
-#endif
-#endif
-
-#ifdef HAVE_SYS_RESOURCE_H
-# include <sys/resource.h>
-#endif
-
-#if HAVE_FCNTL_H
-# include <fcntl.h>
-#endif
-
-#if HAVE_LIMITS_H
-# include <limits.h>
-#endif
-
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-
-#ifdef HAVE_STRING_H
-# include <string.h>
-#else
-# ifdef HAVE_STRINGS_H
-#  include <strings.h>
-#endif
-#endif
-
-typedef unsigned char U_CHAR;
-
-#include "gansidecl.h"
-#include "pcp.h"
-
-#ifdef NEED_DECLARATION_INDEX
-extern char *index ();
-#endif
-
-#ifdef NEED_DECLARATION_RINDEX
-extern char *rindex ();
-#endif
-
-#ifdef NEED_DECLARATION_GETENV
-extern char *getenv ();
-#endif
-
-#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
-# define __attribute__(x)
-#endif
-
-#ifndef STANDARD_INCLUDE_DIR
-# define STANDARD_INCLUDE_DIR "/usr/include"
-#endif
-
-/* By default, colon separates directories in a path.  */
-#ifndef PATH_SEPARATOR
-# define PATH_SEPARATOR ':'
-#endif
-
-/* By default, the suffix for object files is ".o".  */
-#ifdef OBJECT_SUFFIX
-# define HAVE_OBJECT_SUFFIX
-#else
-# define OBJECT_SUFFIX ".o"
-#endif
-
-#if defined (__STDC__) && defined (HAVE_VPRINTF)
-# include <stdarg.h>
-# define PRINTF_ALIST(msg) char *msg, ...
-# define PRINTF_DCL(msg)
-# define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (__printf__, m, n)))
-#else
-# include <varargs.h>
-# define PRINTF_ALIST(msg) msg, va_alist
-# define PRINTF_DCL(msg) char *msg; va_dcl
-# define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (__printf__, m, n)))
-# define vfprintf(file, msg, args) \
-    { \
-      char *a0 = va_arg(args, char *); \
-      char *a1 = va_arg(args, char *); \
-      char *a2 = va_arg(args, char *); \
-      char *a3 = va_arg(args, char *); \
-      fprintf (file, msg, a0, a1, a2, a3); \
-    }
-#endif
-
-#define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
-#define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
-#define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
-
-/* VMS-specific definitions */
-#ifdef VMS
-#include <descrip.h>
-#define open(fname,mode,prot)   VMS_open (fname,mode,prot)
-#define fopen(fname,mode)       VMS_fopen (fname,mode)
-#define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
-#define fstat(fd,stbuf)         VMS_fstat (fd,stbuf)
-static int VMS_fstat (), VMS_stat ();
-static int VMS_open ();
-static FILE *VMS_fopen ();
-static FILE *VMS_freopen ();
-static void hack_vms_include_specification ();
-#define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
-#define INO_T_HASH(a) 0
-#define INCLUDE_LEN_FUDGE 12    /* leave room for VMS syntax conversion */
-#endif /* VMS */
-
-/* Windows does not natively support inodes, and neither does MSDOS.  */
-#if (defined (_WIN32) && ! defined (CYGWIN32)) || defined (__MSDOS__)
-#define INO_T_EQ(a, b) 0
-#endif
-
-#ifndef O_RDONLY
-#define O_RDONLY 0
-#endif
-
-#undef MIN
-#undef MAX
-#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
-#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
-
-/* Find the largest host integer type and set its size and type.
-   Watch out: on some crazy hosts `long' is shorter than `int'.  */
-
-#ifndef HOST_WIDE_INT
-# if HAVE_INTTYPES_H
-#  include <inttypes.h>
-#  define HOST_WIDE_INT intmax_t
-# else
-#  if (HOST_BITS_PER_LONG <= HOST_BITS_PER_INT && HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_INT)
-#   define HOST_WIDE_INT int
-#  else
-#  if (HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_LONG || ! (defined LONG_LONG_MAX || defined LLONG_MAX))
-#   define HOST_WIDE_INT long
-#  else
-#   define HOST_WIDE_INT long long
-#  endif
-#  endif
-# endif
-#endif
-
-#ifndef S_ISREG
-#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
-#endif
-
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
-#endif
-
-#ifndef INO_T_EQ
-#define INO_T_EQ(a, b) ((a) == (b))
-#endif
-
-#ifndef INO_T_HASH
-#define INO_T_HASH(a) (a)
-#endif
-
-#ifndef INCLUDE_LEN_FUDGE
-#define INCLUDE_LEN_FUDGE 0
-#endif
-
-/* External declarations.  */
-
-/* extern char *version_string; */
-
-extern char *update_path PROTO((char *, char *));
-//#ifndef VMS
-//#ifndef HAVE_STRERROR
-//extern int sys_nerr;
-//extern char *sys_errlist[];
-//#else /* HAVE_STRERROR */
-//char *strerror ();
-//#endif
-//#else /* VMS */
-//char *strerror (int,...);
-//#endif
-HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
-HOST_WIDE_INT parse_c_expression PROTO((char *, int));
-
-#ifndef errno
-extern int errno;
-#endif
-
-/* Name under which this program was invoked.  */
-
-static char *progname;
-
-/* Nonzero means use extra default include directories for C++.  */
-
-static int cplusplus;
-
-/* Nonzero means handle cplusplus style comments */
-
-static int cplusplus_comments;
-
-/* Nonzero means handle #import, for objective C.  */
-
-static int objc;
-
-/* Nonzero means this is an assembly file, and allow
-   unknown directives, which could be comments.  */
-
-static int lang_asm;
-
-/* Current maximum length of directory names in the search path
-   for include files.  (Altered as we get more of them.)  */
-
-static int max_include_len;
-
-/* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
-
-static int for_lint = 0;
-
-/* Nonzero means copy comments into the output file.  */
-
-static int put_out_comments = 0;
-
-/* Nonzero means don't process the ANSI trigraph sequences.  */
-
-static int no_trigraphs = 0;
-
-/* Nonzero means print the names of included files rather than
-   the preprocessed output.  1 means just the #include "...",
-   2 means #include <...> as well.  */
-
-static int print_deps = 0;
-
-/* Nonzero if missing .h files in -M output are assumed to be generated
-   files and not errors.  */
-
-static int print_deps_missing_files = 0;
-
-/* Nonzero means print names of header files (-H).  */
-
-static int print_include_names = 0;
-
-/* Nonzero means don't output line number information.  */
-
-static int no_line_directives;
-
-/* Nonzero means output the text in failing conditionals,
-   inside #failed ... #endfailed.  */
-
-static int output_conditionals;
-
-/* dump_only means inhibit output of the preprocessed text
-             and instead output the definitions of all user-defined
-             macros in a form suitable for use as input to cccp.
-   dump_names means pass #define and the macro name through to output.
-   dump_definitions means pass the whole definition (plus #define) through
-*/
-
-static enum {dump_none, dump_only, dump_names, dump_definitions}
-     dump_macros = dump_none;
-
-/* Nonzero means pass all #define and #undef directives which we actually
-   process through to the output stream.  This feature is used primarily
-   to allow cc1 to record the #defines and #undefs for the sake of
-   debuggers which understand about preprocessor macros, but it may
-   also be useful with -E to figure out how symbols are defined, and
-   where they are defined.  */
-static int debug_output = 0;
-
-/* Nonzero means pass #include lines through to the output,
-   even if they are ifdefed out.  */
-static int dump_includes;
-
-/* Nonzero indicates special processing used by the pcp program.  The
-   special effects of this mode are: 
-     
-     Inhibit all macro expansion, except those inside #if directives.
-
-     Process #define directives normally, and output their contents 
-     to the output file.
-
-     Output preconditions to pcp_outfile indicating all the relevant
-     preconditions for use of this file in a later cpp run.
-*/
-static FILE *pcp_outfile;
-
-/* Nonzero means we are inside an IF during a -pcp run.  In this mode
-   macro expansion is done, and preconditions are output for all macro
-   uses requiring them.  */
-static int pcp_inside_if;
-
-/* Nonzero means never to include precompiled files.
-   This is 1 since there's no way now to make precompiled files,
-   so it's not worth testing for them.  */
-static int no_precomp = 1;
-
-/* Nonzero means give all the error messages the ANSI standard requires.  */
-
-int pedantic;
-
-/* Nonzero means try to make failure to fit ANSI C an error.  */
-
-static int pedantic_errors;
-
-/* Nonzero means don't print warning messages.  -w.  */
-
-static int inhibit_warnings = 0;
-
-/* Nonzero means warn if slash-star appears in a slash-star comment,
-   or if newline-backslash appears in a slash-slash comment.  */
-
-static int warn_comments;
-
-/* Nonzero means warn if a macro argument is (or would be)
-   stringified with -traditional.  */
-
-static int warn_stringify;
-
-/* Nonzero means warn if there are any trigraphs.  */
-
-static int warn_trigraphs;
-
-/* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
-
-static int warn_undef;
-
-/* Nonzero means warn if #import is used.  */
-
-static int warn_import = 1;
-
-/* Nonzero means turn warnings into errors.  */
-
-static int warnings_are_errors;
-
-/* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
-
-int traditional;
-
-/* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
-
-int c89;
-
-/* Nonzero causes output not to be done,
-   but directives such as #define that have side effects
-   are still obeyed.  */
-
-static int no_output;
-
-/* Nonzero means we should look for header.gcc files that remap file names.  */
-static int remap;
-
-/* Nonzero means this file was included with a -imacros or -include
-   command line and should not be recorded as an include file.  */
-
-static int no_record_file;
-
-/* Nonzero means that we have finished processing the command line options.
-   This flag is used to decide whether or not to issue certain errors
-   and/or warnings.  */
-
-static int done_initializing = 0;
-
-/* Line where a newline was first seen in a string constant.  */
-
-static int multiline_string_line = 0;
-
-/* I/O buffer structure.
-   The `fname' field is nonzero for source files and #include files
-   and for the dummy text used for -D and -U.
-   It is zero for rescanning results of macro expansion
-   and for expanding macro arguments.  */
-#define INPUT_STACK_MAX 400
-static struct file_buf {
-  char *fname;
-  /* Filename specified with #line directive.  */
-  char *nominal_fname;
-  /* Include file description.  */
-  struct include_file *inc;
-  /* Record where in the search path this file was found.
-     For #include_next.  */
-  struct file_name_list *dir;
-  int lineno;
-  int length;
-  U_CHAR *buf;
-  U_CHAR *bufp;
-  /* Macro that this level is the expansion of.
-     Included so that we can reenable the macro
-     at the end of this level.  */
-  struct hashnode *macro;
-  /* Value of if_stack at start of this file.
-     Used to prohibit unmatched #endif (etc) in an include file.  */
-  struct if_stack *if_stack;
-  /* Object to be freed at end of input at this level.  */
-  U_CHAR *free_ptr;
-  /* True if this is a system header file; see is_system_include.  */
-  char system_header_p;
-} instack[INPUT_STACK_MAX];
-
-static int last_error_tick;        /* Incremented each time we print it.  */
-static int input_file_stack_tick;  /* Incremented when the status changes.  */
-
-/* Current nesting level of input sources.
-   `instack[indepth]' is the level currently being read.  */
-static int indepth = -1;
-#define CHECK_DEPTH(code) \
-  if (indepth >= (INPUT_STACK_MAX - 1))                                 \
-    {                                                                   \
-      error_with_line (line_for_error (instack[indepth].lineno),        \
-                       "macro or `#include' recursion too deep");       \
-      code;                                                             \
-    }
-
-/* Current depth in #include directives that use <...>.  */
-static int system_include_depth = 0;
-
-typedef struct file_buf FILE_BUF;
-
-/* The output buffer.  Its LENGTH field is the amount of room allocated
-   for the buffer, not the number of chars actually present.  To get
-   that, subtract outbuf.buf from outbuf.bufp.  */
-
-#define OUTBUF_SIZE 10  /* initial size of output buffer */
-static FILE_BUF outbuf;
-
-/* Grow output buffer OBUF points at
-   so it can hold at least NEEDED more chars.  */
-
-#define check_expand(OBUF, NEEDED)  \
-  (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED))   \
-   ? grow_outbuf ((OBUF), (NEEDED)) : 0)
-
-struct file_name_list
-  {
-    struct file_name_list *next;
-    /* If the following is 1, it is a C-language system include
-       directory.  */
-    int c_system_include_path;
-    /* Mapping of file names for this directory.  */
-    struct file_name_map *name_map;
-    /* Non-zero if name_map is valid.  */
-    int got_name_map;
-    /* The include directory status.  */
-    struct stat st;
-    /* The include prefix: "" denotes the working directory,
-       otherwise fname must end in '/'.
-       The actual size is dynamically allocated.  */
-    char fname[1];
-  };
-
-/* #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++.  */
-} include_defaults_array[]
-#ifdef INCLUDE_DEFAULTS
-  = INCLUDE_DEFAULTS;
-#else
-  = {
-    /* Pick up GNU C++ specific include files.  */
-    { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1 },
-    { OLD_GPLUSPLUS_INCLUDE_DIR, 0, 1, 1 },
-#ifdef CROSS_COMPILE
-    /* This is the dir for fixincludes.  Put it just before
-       the files that we fix.  */
-    { GCC_INCLUDE_DIR, "GCC", 0, 0 },
-    /* For cross-compilation, this dir name is generated
-       automatically in Makefile.in.  */
-    { CROSS_INCLUDE_DIR, "GCC", 0, 0 },
-#ifdef TOOL_INCLUDE_DIR
-    /* This is another place that the target system's headers might be.  */
-    { TOOL_INCLUDE_DIR, "BINUTILS", 0, 0 },
-#endif
-#else /* not CROSS_COMPILE */
-#ifdef LOCAL_INCLUDE_DIR
-    /* This should be /usr/local/include and should come before
-       the fixincludes-fixed header files.  */
-    { LOCAL_INCLUDE_DIR, 0, 0, 1 },
-#endif
-#ifdef TOOL_INCLUDE_DIR
-    /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
-       Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h.  */
-    { TOOL_INCLUDE_DIR, "BINUTILS", 0, 0 },
-#endif
-    /* This is the dir for fixincludes.  Put it just before
-       the files that we fix.  */
-    { GCC_INCLUDE_DIR, "GCC", 0, 0 },
-    /* Some systems have an extra dir of include files.  */
-#ifdef SYSTEM_INCLUDE_DIR
-    { SYSTEM_INCLUDE_DIR, 0, 0, 0 },
-#endif
-#ifndef STANDARD_INCLUDE_COMPONENT
-#define STANDARD_INCLUDE_COMPONENT 0
-#endif
-    { STANDARD_INCLUDE_DIR, STANDARD_INCLUDE_COMPONENT, 0, 0 },
-#endif /* not CROSS_COMPILE */
-    { 0, 0, 0, 0 }
-    };
-#endif /* no INCLUDE_DEFAULTS */
-
-/* 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.  */
-static struct default_include *include_defaults = include_defaults_array;
-
-static struct file_name_list *include = 0;      /* First dir to search */
-        /* First dir to search for <file> */
-/* This is the first element to use for #include <...>.
-   If it is 0, use the entire chain for such includes.  */
-static struct file_name_list *first_bracket_include = 0;
-/* This is the first element in the chain that corresponds to
-   a directory of system header files.  */
-static struct file_name_list *first_system_include = 0;
-static struct file_name_list *last_include = 0; /* Last in chain */
-
-/* Chain of include directories to put at the end of the other chain.  */
-static struct file_name_list *after_include = 0;
-static struct file_name_list *last_after_include = 0;   /* Last in chain */
-
-/* Chain to put at the start of the system include files.  */
-static struct file_name_list *before_system = 0;
-static struct file_name_list *last_before_system = 0;   /* Last in chain */
-
-/* Directory prefix that should replace `/usr' in the standard
-   include file directories.  */
-static char *include_prefix;
-
-/* Maintain and search list of included files.  */
-
-struct include_file {
-  struct include_file *next; /* for include_hashtab */
-  struct include_file *next_ino; /* for include_ino_hashtab */
-  char *fname;
-  /* If the following is the empty string, it means #pragma once
-     was seen in this include file, or #import was applied to the file.
-     Otherwise, if it is nonzero, it is a macro name.
-     Don't include the file again if that macro is defined.  */
-  U_CHAR *control_macro;
-  /* Nonzero if the dependency on this include file has been output.  */
-  int deps_output;
-  struct stat st;
-};
-
-/* Hash tables of files already included with #include or #import.
-   include_hashtab is by full name; include_ino_hashtab is by inode number.  */
-
-#define INCLUDE_HASHSIZE 61
-static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
-static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
-
-/* Global list of strings read in from precompiled files.  This list
-   is kept in the order the strings are read in, with new strings being
-   added at the end through stringlist_tailp.  We use this list to output
-   the strings at the end of the run. 
-*/
-static STRINGDEF *stringlist;
-static STRINGDEF **stringlist_tailp = &stringlist;
-
-
-/* Structure returned by create_definition */
-typedef struct macrodef MACRODEF;
-struct macrodef
-{
-  struct definition *defn;
-  U_CHAR *symnam;
-  int symlen;
-};
-
-enum sharp_token_type {
-  NO_SHARP_TOKEN = 0,           /* token not present */
-
-  SHARP_TOKEN = '#',            /* token spelled with # only */
-  WHITE_SHARP_TOKEN,            /* token spelled with # and white space */
-
-  PERCENT_COLON_TOKEN = '%',    /* token spelled with %: only */
-  WHITE_PERCENT_COLON_TOKEN     /* token spelled with %: and white space */
-};
-
-/* Structure allocated for every #define.  For a simple replacement
-   such as
-        #define foo bar ,
-   nargs = -1, the `pattern' list is null, and the expansion is just
-   the replacement text.  Nargs = 0 means a functionlike macro with no args,
-   e.g.,
-       #define getchar() getc (stdin) .
-   When there are args, the expansion is the replacement text with the
-   args squashed out, and the reflist is a list describing how to
-   build the output from the input: e.g., "3 chars, then the 1st arg,
-   then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
-   The chars here come from the expansion.  Whatever is left of the
-   expansion after the last arg-occurrence is copied after that arg.
-   Note that the reflist can be arbitrarily long---
-   its length depends on the number of times the arguments appear in
-   the replacement text, not how many args there are.  Example:
-   #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
-   pattern list
-     { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
-   where (x, y) means (nchars, argno).  */
-
-typedef struct definition DEFINITION;
-struct definition {
-  int nargs;
-  int length;                   /* length of expansion string */
-  int predefined;               /* True if the macro was builtin or */
-                                /* came from the command line */
-  U_CHAR *expansion;
-  int line;                     /* Line number of definition */
-  char *file;                   /* File of definition */
-  char rest_args;               /* Nonzero if last arg. absorbs the rest */
-  struct reflist {
-    struct reflist *next;
-
-    enum sharp_token_type stringify;    /* set if a # operator before arg */
-    enum sharp_token_type raw_before;   /* set if a ## operator before arg */
-    enum sharp_token_type raw_after;    /* set if a ## operator after arg */
-
-    char rest_args;             /* Nonzero if this arg. absorbs the rest */
-    int nchars;                 /* Number of literal chars to copy before
-                                   this arg occurrence.  */
-    int argno;                  /* Number of arg to substitute (origin-0) */
-  } *pattern;
-  union {
-    /* Names of macro args, concatenated in reverse order
-       with comma-space between them.
-       The only use of this is that we warn on redefinition
-       if this differs between the old and new definitions.  */
-    U_CHAR *argnames;
-  } args;
-};
-
-/* different kinds of things that can appear in the value field
-   of a hash node.  Actually, this may be useless now.  */
-union hashval {
-  char *cpval;
-  DEFINITION *defn;
-  KEYDEF *keydef;
-};
-
-/*
- * 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)
- *              { 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)
- *              { wow (1, 2); }         ->      { process (2, 1, 2); }
- *              { wow (one); }          ->      { process (one); {
- */
-static char rest_extension[] = "...";
-#define REST_EXTENSION_LENGTH   (sizeof (rest_extension) - 1)
-
-/* The structure of a node in the hash table.  The hash table
-   has entries for all tokens defined by #define directives (type T_MACRO),
-   plus some special tokens like __LINE__ (these each have their own
-   type, and the appropriate code is run when that type of node is seen.
-   It does not contain control words like "#define", which are recognized
-   by a separate piece of code.  */
-
-/* different flavors of hash nodes --- also used in keyword table */
-enum node_type {
- T_DEFINE = 1,  /* the `#define' keyword */
- T_INCLUDE,     /* the `#include' keyword */
- T_INCLUDE_NEXT, /* the `#include_next' keyword */
- T_IMPORT,      /* the `#import' keyword */
- T_IFDEF,       /* the `#ifdef' keyword */
- T_IFNDEF,      /* the `#ifndef' keyword */
- T_IF,          /* the `#if' keyword */
- T_ELSE,        /* `#else' */
- T_PRAGMA,      /* `#pragma' */
- T_ELIF,        /* `#elif' */
- T_UNDEF,       /* `#undef' */
- T_LINE,        /* `#line' */
- T_ERROR,       /* `#error' */
- T_WARNING,     /* `#warning' */
- T_ENDIF,       /* `#endif' */
- T_SCCS,        /* `#sccs', used on system V.  */
- T_IDENT,       /* `#ident', used on system V.  */
- T_ASSERT,      /* `#assert', taken from system V.  */
- T_UNASSERT,    /* `#unassert', taken from system V.  */
- T_SPECLINE,    /* special symbol `__LINE__' */
- T_DATE,        /* `__DATE__' */
- T_FILE,        /* `__FILE__' */
- T_BASE_FILE,   /* `__BASE_FILE__' */
- T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
- T_VERSION,     /* `__VERSION__' */
- T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
- T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
- T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
- T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
- T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
- T_IMMEDIATE_PREFIX_TYPE,  /* `__IMMEDIATE_PREFIX__' */
- T_TIME,        /* `__TIME__' */
- T_CONST,       /* Constant value, used by `__STDC__' */
- T_MACRO,       /* macro defined by `#define' */
- T_DISABLED,    /* macro temporarily turned off for rescan */
- T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
- T_PCSTRING,    /* precompiled string (hashval is KEYDEF *) */
- T_UNUSED       /* Used for something not defined.  */
- };
-
-struct hashnode {
-  struct hashnode *next;        /* double links for easy deletion */
-  struct hashnode *prev;
-  struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
-                                   chain is kept, in case the node is the head
-                                   of the chain and gets deleted.  */
-  enum node_type type;          /* type of special token */
-  int length;                   /* length of token, for quick comparison */
-  U_CHAR *name;                 /* the actual name */
-  union hashval value;          /* pointer to expansion, or whatever */
-};
-
-typedef struct hashnode HASHNODE;
-
-/* Some definitions for the hash table.  The hash function MUST be
-   computed as shown in hashf () below.  That is because the rescan
-   loop computes the hash value `on the fly' for most tokens,
-   in order to avoid the overhead of a lot of procedure calls to
-   the hashf () function.  Hashf () only exists for the sake of
-   politeness, for use when speed isn't so important.  */
-
-#define HASHSIZE 1403
-static HASHNODE *hashtab[HASHSIZE];
-#define HASHSTEP(old, c) ((old << 2) + c)
-#define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
-
-/* Symbols to predefine.  */
-
-#ifdef CPP_PREDEFINES
-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,
-   it would be best to do something here to figure out automatically
-   from other information what type to use.  */
-
-/* The string value for __SIZE_TYPE__.  */
-
-#ifndef SIZE_TYPE
-#define SIZE_TYPE "long unsigned int"
-#endif
-
-/* The string value for __PTRDIFF_TYPE__.  */
-
-#ifndef PTRDIFF_TYPE
-#define PTRDIFF_TYPE "long int"
-#endif
-
-/* The string value for __WCHAR_TYPE__.  */
-
-#ifndef WCHAR_TYPE
-#define WCHAR_TYPE "int"
-#endif
-char * wchar_type = WCHAR_TYPE;
-#undef WCHAR_TYPE
-
-/* The string value for __USER_LABEL_PREFIX__ */
-
-#ifndef USER_LABEL_PREFIX
-#define USER_LABEL_PREFIX ""
-#endif
-
-/* The string value for __REGISTER_PREFIX__ */
-
-#ifndef REGISTER_PREFIX
-#define REGISTER_PREFIX ""
-#endif
-
-/* The string value for __IMMEDIATE_PREFIX__ */
-
-#ifndef IMMEDIATE_PREFIX
-#define IMMEDIATE_PREFIX ""
-#endif
-
-/* In the definition of a #assert name, this structure forms
-   a list of the individual values asserted.
-   Each value is itself a list of "tokens".
-   These are strings that are compared by name.  */
-
-struct tokenlist_list {
-  struct tokenlist_list *next;
-  struct arglist *tokens;
-};
-
-struct assertion_hashnode {
-  struct assertion_hashnode *next;      /* double links for easy deletion */
-  struct assertion_hashnode *prev;
-  /* also, a back pointer to this node's hash
-     chain is kept, in case the node is the head
-     of the chain and gets deleted.  */
-  struct assertion_hashnode **bucket_hdr;
-  int length;                   /* length of token, for quick comparison */
-  U_CHAR *name;                 /* the actual name */
-  /* List of token-sequences.  */
-  struct tokenlist_list *value;
-};
-
-typedef struct assertion_hashnode ASSERTION_HASHNODE;
-
-/* Some definitions for the hash table.  The hash function MUST be
-   computed as shown in hashf below.  That is because the rescan
-   loop computes the hash value `on the fly' for most tokens,
-   in order to avoid the overhead of a lot of procedure calls to
-   the hashf function.  hashf only exists for the sake of
-   politeness, for use when speed isn't so important.  */
-
-#define ASSERTION_HASHSIZE 37
-static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
-
-/* Nonzero means inhibit macroexpansion of what seem to be
-   assertion tests, in rescan.  For #if.  */
-static int assertions_flag;
-
-/* `struct directive' defines one #-directive, including how to handle it.  */
-
-#define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
-
-struct directive {
-  int length;                   /* Length of name */
-  int (*func) DO_PROTO; /* Function to handle directive */
-  char *name;                   /* Name of directive */
-  enum node_type type;          /* Code which describes which directive.  */
-};
-
-#define IS_INCLUDE_DIRECTIVE_TYPE(t) \
-((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT)
-
-/* These functions are declared to return int instead of void since they
-   are going to be placed in the table and some old compilers have trouble with
-   pointers to functions returning void.  */
-
-static int do_assert DO_PROTO;
-static int do_define DO_PROTO;
-static int do_elif DO_PROTO;
-static int do_else DO_PROTO;
-static int do_endif DO_PROTO;
-static int do_error DO_PROTO;
-static int do_ident DO_PROTO;
-static int do_if DO_PROTO;
-static int do_include DO_PROTO;
-static int do_line DO_PROTO;
-static int do_pragma DO_PROTO;
-#ifdef SCCS_DIRECTIVE
-static int do_sccs DO_PROTO;
-#endif
-static int do_unassert DO_PROTO;
-static int do_undef DO_PROTO;
-static int do_warning DO_PROTO;
-static int do_xifdef DO_PROTO;
-
-/* Here is the actual list of #-directives, most-often-used first.  */
-
-static struct directive directive_table[] = {
-  {  6, do_define, "define", T_DEFINE},
-  {  2, do_if, "if", T_IF},
-  {  5, do_xifdef, "ifdef", T_IFDEF},
-  {  6, do_xifdef, "ifndef", T_IFNDEF},
-  {  5, do_endif, "endif", T_ENDIF},
-  {  4, do_else, "else", T_ELSE},
-  {  4, do_elif, "elif", T_ELIF},
-  {  4, do_line, "line", T_LINE},
-  {  7, do_include, "include", T_INCLUDE},
-  { 12, do_include, "include_next", T_INCLUDE_NEXT},
-  {  6, do_include, "import", T_IMPORT},
-  {  5, do_undef, "undef", T_UNDEF},
-  {  5, do_error, "error", T_ERROR},
-  {  7, do_warning, "warning", T_WARNING},
-#ifdef SCCS_DIRECTIVE
-  {  4, do_sccs, "sccs", T_SCCS},
-#endif
-  {  6, do_pragma, "pragma", T_PRAGMA},
-  {  5, do_ident, "ident", T_IDENT},
-  {  6, do_assert, "assert", T_ASSERT},
-  {  8, do_unassert, "unassert", T_UNASSERT},
-  {  -1, 0, "", T_UNUSED},
-};
-
-/* When a directive handler is called,
-   this points to the # (or the : of the %:) that started the directive.  */
-U_CHAR *directive_start;
-
-/* table to tell if char can be part of a C identifier.  */
-U_CHAR is_idchar[256];
-/* table to tell if char can be first char of a c identifier.  */
-U_CHAR is_idstart[256];
-/* table to tell if c is horizontal space.  */
-static U_CHAR is_hor_space[256];
-/* table to tell if c is horizontal or vertical space.  */
-U_CHAR is_space[256];
-/* names of some characters */
-static char *char_name[256];
-
-#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)
-  
-static int errors = 0;                  /* Error counter for exit code */
-
-/* Name of output file, for error messages.  */
-static char *out_fname;
-
-
-/* Stack of conditionals currently in progress
-   (including both successful and failing conditionals).  */
-
-struct if_stack {
-  struct if_stack *next;        /* for chaining to the next stack frame */
-  char *fname;          /* copied from input when frame is made */
-  int lineno;                   /* similarly */
-  int if_succeeded;             /* true if a leg of this if-group
-                                    has been passed through rescan */
-  U_CHAR *control_macro;        /* For #ifndef at start of file,
-                                   this is the macro name tested.  */
-  enum node_type type;          /* type of last directive seen in this group */
-};
-typedef struct if_stack IF_STACK_FRAME;
-static IF_STACK_FRAME *if_stack = NULL;
-
-/* Buffer of -M output.  */
-static char *deps_buffer;
-
-/* Number of bytes allocated in above.  */
-static int deps_allocated_size;
-
-/* Number of bytes used.  */
-static int deps_size;
-
-/* Number of bytes since the last newline.  */
-static int deps_column;
-
-/* Nonzero means -I- has been seen,
-   so don't look for #include "foo" the source-file directory.  */
-static int ignore_srcdir;
-
-static int safe_read PROTO((int, char *, int));
-static void safe_write PROTO((int, char *, int));
-
-int main PROTO((int, char **));
-
-static void path_include PROTO((char *));
-
-static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
-
-static void trigraph_pcp PROTO((FILE_BUF *));
-
-static void newline_fix PROTO((U_CHAR *));
-static void name_newline_fix PROTO((U_CHAR *));
-
-static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
-
-static void rescan PROTO((FILE_BUF *, int));
-
-static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
-
-static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
-
-static struct tm *timestamp PROTO((void));
-static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
-
-static int is_system_include PROTO((char *));
-static char *base_name PROTO((char *));
-static int absolute_filename PROTO((char *));
-static size_t simplify_filename PROTO((char *));
-
-static char *read_filename_string PROTO((int, FILE *));
-static struct file_name_map *read_name_map PROTO((char *));
-static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
-static char *remap_include_file PROTO((char *, struct file_name_list *));
-static int lookup_ino_include PROTO((struct include_file *));
-
-static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
-static void record_control_macro PROTO((struct include_file *, U_CHAR *));
-
-static char *check_precompiled PROTO((int, struct stat *, char *, char **));
-static int check_preconditions PROTO((char *));
-static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
-static void pcstring_used PROTO((HASHNODE *));
-static void write_output PROTO((void));
-static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
-
-static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
-
-static int check_macro_name PROTO((U_CHAR *, char *));
-static int compare_defs PROTO((DEFINITION *, DEFINITION *));
-static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
-
-static DEFINITION *collect_expansion  PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
-
-int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
-static int compare_token_lists PROTO((struct arglist *, struct arglist *));
-
-static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
-static void free_token_list PROTO((struct arglist *));
-
-static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
-static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
-static void delete_assertion PROTO((ASSERTION_HASHNODE *));
-
-static void do_once PROTO((void));
-
-static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
-static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
-static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
-static void validate_else PROTO((U_CHAR *, U_CHAR *));
-
-static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
-static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
-static char *quote_string PROTO((char *, char *));
-static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
-
-/* Last arg to output_line_directive.  */
-enum file_change_code {same_file, enter_file, leave_file};
-static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
-
-static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
-
-struct argdata;
-static char *macarg PROTO((struct argdata *, int));
-
-static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, struct hashnode *, int *, int *, int *, int));
-
-static int discard_comments PROTO((U_CHAR *, int, int));
-
-static int change_newlines PROTO((U_CHAR *, int));
-
-char *my_strerror PROTO((int));
-void error PRINTF_PROTO_1((char *, ...));
-static void verror PROTO((char *, va_list));
-static void error_from_errno PROTO((char *));
-void warning PRINTF_PROTO_1((char *, ...));
-static void vwarning PROTO((char *, va_list));
-static void error_with_line PRINTF_PROTO_2((int, char *, ...));
-static void verror_with_line PROTO((int, char *, va_list));
-static void vwarning_with_line PROTO((int, char *, va_list));
-static void warning_with_line PRINTF_PROTO_2((int, char *, ...));
-void pedwarn PRINTF_PROTO_1((char *, ...));
-void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
-static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
-
-static void print_containing_files PROTO((void));
-
-static int line_for_error PROTO((int));
-static int grow_outbuf PROTO((FILE_BUF *, int));
-
-static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
-HASHNODE *lookup PROTO((U_CHAR *, int, int));
-static void delete_macro PROTO((HASHNODE *));
-static int hashf PROTO((U_CHAR *, int, int));
-
-static void dump_single_macro PROTO((HASHNODE *, FILE *));
-static void dump_all_macros PROTO((void));
-static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
-static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
-
-static void initialize_char_syntax PROTO((void));
-static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
-
-static void make_definition PROTO((char *, FILE_BUF *));
-static void make_undef PROTO((char *, FILE_BUF *));
-
-static void make_assertion PROTO((char *, char *));
-
-static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, char *, char *, char *));
-static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
-
-static int quote_string_for_make PROTO((char *, char *));
-static void deps_output PROTO((char *, int));
-
-static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
-void fancy_abort PROTO((void)) __attribute__ ((noreturn));
-static void perror_with_name PROTO((char *));
-static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
-static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
-
-static void memory_full PROTO((void)) __attribute__ ((noreturn));
-GENERIC_PTR xmalloc PROTO((size_t));
-static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
-static GENERIC_PTR xcalloc PROTO((size_t, size_t));
-static char *savestring PROTO((char *));
-
-/* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
-   retrying if necessary.  If MAX_READ_LEN is defined, read at most
-   that bytes at a time.  Return a negative value if an error occurs,
-   otherwise return the actual number of bytes read,
-   which must be LEN unless end-of-file was reached.  */
-
-static int
-safe_read (desc, ptr, len)
-     int desc;
-     char *ptr;
-     int len;
-{
-  int left, rcount, nchars;
-
-  left = len;
-  while (left > 0) {
-    rcount = left;
-#ifdef MAX_READ_LEN
-    if (rcount > MAX_READ_LEN)
-      rcount = MAX_READ_LEN;
-#endif
-    nchars = read (desc, ptr, rcount);
-    if (nchars < 0)
-      {
-#ifdef EINTR
-        if (errno == EINTR)
-          continue;
-#endif
-        return nchars;
-      }
-    if (nchars == 0)
-      break;
-    ptr += nchars;
-    left -= nchars;
-  }
-  return len - left;
-}
-
-/* Write LEN bytes at PTR to descriptor DESC,
-   retrying if necessary, and treating any real error as fatal.
-   If MAX_WRITE_LEN is defined, write at most that many bytes at a time.  */
-
-static void
-safe_write (desc, ptr, len)
-     int desc;
-     char *ptr;
-     int len;
-{
-  int wcount, written;
-
-  while (len > 0) {
-    wcount = len;
-#ifdef MAX_WRITE_LEN
-    if (wcount > MAX_WRITE_LEN)
-      wcount = MAX_WRITE_LEN;
-#endif
-    written = write (desc, ptr, wcount);
-    if (written < 0)
-      {
-#ifdef EINTR
-        if (errno == EINTR)
-          continue;
-#endif
-        pfatal_with_name (out_fname);
-      }
-    ptr += written;
-    len -= written;
-  }
-}
-
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  struct stat st;
-  char *in_fname;
-  char *cp;
-  int f, i;
-  FILE_BUF *fp;
-  char **pend_files = (char **) xmalloc (argc * sizeof (char *));
-  char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
-  char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
-  char **pend_assertions = (char **) xmalloc (argc * sizeof (char *));
-  char **pend_includes = (char **) xmalloc (argc * sizeof (char *));
-
-  /* Record the option used with each element of pend_assertions.
-     This is preparation for supporting more than one option for making
-     an assertion.  */
-  char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *));
-  int inhibit_predefs = 0;
-  int no_standard_includes = 0;
-  int no_standard_cplusplus_includes = 0;
-  int missing_newline = 0;
-
-  /* Non-0 means don't output the preprocessed program.  */
-  int inhibit_output = 0;
-  /* Non-0 means -v, so print the full set of include dirs.  */
-  int verbose = 0;
-
-  /* File name which deps are being written to.
-     This is 0 if deps are being written to stdout.  */
-  char *deps_file = 0;
-  /* Fopen file mode to open deps_file with.  */
-  char *deps_mode = "a";
-  /* Stream on which to print the dependency information.  */
-  FILE *deps_stream = 0;
-  /* Target-name to write with the dependency information.  */
-  char *deps_target = 0;
-
-#if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
-  /* Get rid of any avoidable limit on stack size.  */
-  {
-    struct rlimit rlim;
-
-    /* Set the stack limit huge so that alloca (particularly stringtab
-       in dbxread.c) does not fail.  */
-    getrlimit (RLIMIT_STACK, &rlim);
-    rlim.rlim_cur = rlim.rlim_max;
-    setrlimit (RLIMIT_STACK, &rlim);
-  }
-#endif
-
-#ifdef SIGPIPE
-  signal (SIGPIPE, pipe_closed);
-#endif
-
-  progname = base_name (argv[0]);
-
-#ifdef VMS
-  {
-    /* Remove extension from PROGNAME.  */
-    char *p;
-    char *s = progname = savestring (progname);
-
-    if ((p = rindex (s, ';')) != 0) *p = '\0';  /* strip version number */
-    if ((p = rindex (s, '.')) != 0              /* strip type iff ".exe" */
-        && (p[1] == 'e' || p[1] == 'E')
-        && (p[2] == 'x' || p[2] == 'X')
-        && (p[3] == 'e' || p[3] == 'E')
-        && !p[4])
-      *p = '\0';
-  }
-#endif
-
-  in_fname = NULL;
-  out_fname = NULL;
-
-  /* Initialize is_idchar.  */
-  initialize_char_syntax ();
-
-  no_line_directives = 0;
-  no_trigraphs = 1;
-  dump_macros = dump_none;
-  no_output = 0;
-  cplusplus = 0;
-  cplusplus_comments = 1;
-
-  bzero ((char *) pend_files, argc * sizeof (char *));
-  bzero ((char *) pend_defs, argc * sizeof (char *));
-  bzero ((char *) pend_undefs, argc * sizeof (char *));
-  bzero ((char *) pend_assertions, argc * sizeof (char *));
-  bzero ((char *) pend_includes, argc * sizeof (char *));
-
-  /* Process switches and find input file name.  */
-
-  for (i = 1; i < argc; i++) {
-    if (argv[i][0] != '-') {
-      if (out_fname != NULL)
-        fatal ("Usage: %s [switches] input output", argv[0]);
-      else if (in_fname != NULL)
-        out_fname = argv[i];
-      else
-        in_fname = argv[i];
-    } else {
-      switch (argv[i][1]) {
-
-      case 'i':
-        if (!strcmp (argv[i], "-include")) {
-          if (i + 1 == argc)
-            fatal ("Filename missing after `-include' option");
-          else
-            simplify_filename (pend_includes[i] = argv[++i]);
-        }
-        if (!strcmp (argv[i], "-imacros")) {
-          if (i + 1 == argc)
-            fatal ("Filename missing after `-imacros' option");
-          else
-            simplify_filename (pend_files[i] = argv[++i]);
-        }
-        if (!strcmp (argv[i], "-iprefix")) {
-          if (i + 1 == argc)
-            fatal ("Filename missing after `-iprefix' option");
-          else
-            include_prefix = argv[++i];
-        }
-        if (!strcmp (argv[i], "-ifoutput")) {
-          output_conditionals = 1;
-        }
-        if (!strcmp (argv[i], "-isystem")) {
-          struct file_name_list *dirtmp;
-
-          if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
-                                              "", argv[++i])))
-            break;
-          dirtmp->c_system_include_path = 1;
-
-          if (before_system == 0)
-            before_system = dirtmp;
-          else
-            last_before_system->next = dirtmp;
-          last_before_system = dirtmp; /* Tail follows the last one */
-        }
-        /* Add directory to end of path for includes,
-           with the default prefix at the front of its name.  */
-        if (!strcmp (argv[i], "-iwithprefix")) {
-          struct file_name_list *dirtmp;
-          char *prefix;
-
-          if (include_prefix != 0)
-            prefix = include_prefix;
-          else {
-            prefix = savestring (GCC_INCLUDE_DIR);
-            /* Remove the `include' from /usr/local/lib/gcc.../include.  */
-            if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
-              prefix[strlen (prefix) - 7] = 0;
-          }
-
-          if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
-                                              prefix, argv[++i])))
-            break;
-
-          if (after_include == 0)
-            after_include = dirtmp;
-          else
-            last_after_include->next = dirtmp;
-          last_after_include = dirtmp; /* Tail follows the last one */
-        }
-        /* Add directory to main path for includes,
-           with the default prefix at the front of its name.  */
-        if (!strcmp (argv[i], "-iwithprefixbefore")) {
-          struct file_name_list *dirtmp;
-          char *prefix;
-
-          if (include_prefix != 0)
-            prefix = include_prefix;
-          else {
-            prefix = savestring (GCC_INCLUDE_DIR);
-            /* Remove the `include' from /usr/local/lib/gcc.../include.  */
-            if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
-              prefix[strlen (prefix) - 7] = 0;
-          }
-
-          dirtmp = new_include_prefix (NULL_PTR, NULL_PTR, prefix, argv[++i]);
-          append_include_chain (dirtmp, dirtmp);
-        }
-        /* Add directory to end of path for includes.  */
-        if (!strcmp (argv[i], "-idirafter")) {
-          struct file_name_list *dirtmp;
-
-          if (! (dirtmp = new_include_prefix (NULL_PTR, NULL_PTR,
-                                              "", argv[++i])))
-            break;
-
-          if (after_include == 0)
-            after_include = dirtmp;
-          else
-            last_after_include->next = dirtmp;
-          last_after_include = dirtmp; /* Tail follows the last one */
-        }
-        break;
-
-      case 'o':
-        if (out_fname != NULL)
-          fatal ("Output filename specified twice");
-        if (i + 1 == argc)
-          fatal ("Filename missing after -o option");
-        out_fname = argv[++i];
-        if (!strcmp (out_fname, "-"))
-          out_fname = "";
-        break;
-
-      case 'p':
-        if (!strcmp (argv[i], "-pedantic"))
-          pedantic = 1;
-        else if (!strcmp (argv[i], "-pedantic-errors")) {
-          pedantic = 1;
-          pedantic_errors = 1;
-        } else if (!strcmp (argv[i], "-pcp")) {
-          char *pcp_fname;
-          if (i + 1 == argc)
-            fatal ("Filename missing after -pcp option");
-          pcp_fname = argv[++i];
-          pcp_outfile
-            = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
-               ? fopen (pcp_fname, "w")
-               : stdout);
-          if (pcp_outfile == 0)
-            pfatal_with_name (pcp_fname);
-          no_precomp = 1;
-        }
-        break;
-
-      case 't':
-        if (!strcmp (argv[i], "-traditional")) {
-          traditional = 1;
-          cplusplus_comments = 0;
-        } else if (!strcmp (argv[i], "-trigraphs")) {
-          no_trigraphs = 0;
-        }
-        break;
-
-      case 'l':
-        if (! strcmp (argv[i], "-lang-c"))
-          cplusplus = 0, cplusplus_comments = 1, c89 = 0, objc = 0;
-        if (! strcmp (argv[i], "-lang-c89"))
-          cplusplus = 0, cplusplus_comments = 0, c89 = 1, objc = 0;
-        if (! strcmp (argv[i], "-lang-c++"))
-          cplusplus = 1, cplusplus_comments = 1, c89 = 0, objc = 0;
-        if (! strcmp (argv[i], "-lang-objc"))
-          cplusplus = 0, cplusplus_comments = 1, c89 = 0, objc = 1;
-        if (! strcmp (argv[i], "-lang-objc++"))
-          cplusplus = 1, cplusplus_comments = 1, c89 = 0, objc = 1;
-        if (! strcmp (argv[i], "-lang-asm"))
-          lang_asm = 1;
-        if (! strcmp (argv[i], "-lint"))
-          for_lint = 1;
-        break;
-
-      case '+':
-        cplusplus = 1, cplusplus_comments = 1;
-        break;
-
-      case 'w':
-        inhibit_warnings = 1;
-        break;
-
-      case 'W':
-        if (!strcmp (argv[i], "-Wtrigraphs"))
-          warn_trigraphs = 1;
-        else if (!strcmp (argv[i], "-Wno-trigraphs"))
-          warn_trigraphs = 0;
-        else if (!strcmp (argv[i], "-Wcomment"))
-          warn_comments = 1;
-        else if (!strcmp (argv[i], "-Wno-comment"))
-          warn_comments = 0;
-        else if (!strcmp (argv[i], "-Wcomments"))
-          warn_comments = 1;
-        else if (!strcmp (argv[i], "-Wno-comments"))
-          warn_comments = 0;
-        else if (!strcmp (argv[i], "-Wtraditional"))
-          warn_stringify = 1;
-        else if (!strcmp (argv[i], "-Wno-traditional"))
-          warn_stringify = 0;
-        else if (!strcmp (argv[i], "-Wundef"))
-          warn_undef = 1;
-        else if (!strcmp (argv[i], "-Wno-undef"))
-          warn_undef = 0;
-        else if (!strcmp (argv[i], "-Wimport"))
-          warn_import = 1;
-        else if (!strcmp (argv[i], "-Wno-import"))
-          warn_import = 0;
-        else if (!strcmp (argv[i], "-Werror"))
-          warnings_are_errors = 1;
-        else if (!strcmp (argv[i], "-Wno-error"))
-          warnings_are_errors = 0;
-        else if (!strcmp (argv[i], "-Wall"))
-          {
-            warn_trigraphs = 1;
-            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"))
-          {
-            print_deps_missing_files = 1;
-            break;
-          }
-        if (!strcmp (argv[i], "-M"))
-          print_deps = 2;
-        else if (!strcmp (argv[i], "-MM"))
-          print_deps = 1;
-        else if (!strcmp (argv[i], "-MD"))
-          print_deps = 2;
-        else if (!strcmp (argv[i], "-MMD"))
-          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)
-            fatal ("Filename missing after %s option", argv[i]);
-          i++;
-          deps_file = argv[i];
-          deps_mode = "w";
-        } else {
-          /* For -M and -MM, write deps on standard output
-             and suppress the usual output.  */
-          deps_stream = stdout;
-          inhibit_output = 1;
-        }         
-        break;
-
-      case 'd':
-        {
-          char *p = argv[i] + 2;
-          char c;
-          while ((c = *p++)) {
-            /* Arg to -d specifies what parts of macros to dump */
-            switch (c) {
-            case 'M':
-              dump_macros = dump_only;
-              no_output = 1;
-              break;
-            case 'N':
-              dump_macros = dump_names;
-              break;
-            case 'D':
-              dump_macros = dump_definitions;
-              break;
-            case 'I':
-              dump_includes = 1;
-              break;
-            }
-          }
-        }
-        break;
-
-      case 'g':
-        if (argv[i][2] == '3')
-          debug_output = 1;
-        break;
-
-      case 'v':
-        fprintf (stderr, "GNU CPP version %s", version_string);
-#ifdef TARGET_VERSION
-        TARGET_VERSION;
-#endif
-        fprintf (stderr, "\n");
-        verbose = 1;
-        break;
-
-      case 'H':
-        print_include_names = 1;
-        break;
-
-      case 'D':
-        if (argv[i][2] != 0)
-          pend_defs[i] = argv[i] + 2;
-        else if (i + 1 == argc)
-          fatal ("Macro name missing after -D option");
-        else
-          i++, pend_defs[i] = argv[i];
-        break;
-
-      case 'A':
-        {
-          char *p;
-
-          if (argv[i][2] != 0)
-            p = argv[i] + 2;
-          else if (i + 1 == argc)
-            fatal ("Assertion missing after -A option");
-          else
-            p = argv[++i];
-
-          if (!strcmp (p, "-")) {
-            /* -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.  */
-            int j;
-            inhibit_predefs = 1;
-            for (j = 0; j < i; j++)
-              pend_defs[j] = pend_assertions[j] = 0;
-          } else {
-            pend_assertions[i] = p;
-            pend_assertion_options[i] = "-A";
-          }
-        }
-        break;
-
-      case 'U':         /* JF #undef something */
-        if (argv[i][2] != 0)
-          pend_undefs[i] = argv[i] + 2;
-        else if (i + 1 == argc)
-          fatal ("Macro name missing after -U option");
-        else
-          pend_undefs[i] = argv[i+1], i++;
-        break;
-
-      case 'C':
-        put_out_comments = 1;
-        break;
-
-      case 'E':                 /* -E comes from cc -E; ignore it.  */
-        break;
-
-      case 'P':
-        no_line_directives = 1;
-        break;
-
-      case '$':                 /* Don't include $ in identifiers.  */
-        is_idchar['$'] = is_idstart['$'] = 0;
-        break;
-
-      case 'I':                 /* Add directory to path for includes.  */
-        {
-          struct file_name_list *dirtmp;
-
-          if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
-            ignore_srcdir = 1;
-            /* Don't use any preceding -I directories for #include <...>.  */
-            first_bracket_include = 0;
-          }
-          else {
-            dirtmp = new_include_prefix (last_include, NULL_PTR, "",
-                                         argv[i][2] ? argv[i] + 2 : argv[++i]);
-            append_include_chain (dirtmp, dirtmp);
-          }
-        }
-        break;
-
-      case 'n':
-        if (!strcmp (argv[i], "-nostdinc"))
-          /* -nostdinc causes no default include directories.
-             You must specify all include-file directories with -I.  */
-          no_standard_includes = 1;
-        else if (!strcmp (argv[i], "-nostdinc++"))
-          /* -nostdinc++ causes no default C++-specific include directories. */
-          no_standard_cplusplus_includes = 1;
-        else if (!strcmp (argv[i], "-noprecomp"))
-          no_precomp = 1;
-        break;
-
-      case 'r':
-        if (!strcmp (argv[i], "-remap"))
-          remap = 1;
-        break;
-
-      case 'u':
-        /* Sun compiler passes undocumented switch "-undef".
-           Let's assume it means to inhibit the predefined symbols.  */
-        inhibit_predefs = 1;
-        break;
-
-      case '\0': /* JF handle '-' as file name meaning stdin or stdout */
-        if (in_fname == NULL) {
-          in_fname = "";
-          break;
-        } else if (out_fname == NULL) {
-          out_fname = "";
-          break;
-        }       /* else fall through into error */
-
-      default:
-        fatal ("Invalid option `%s'", argv[i]);
-      }
-    }
-  }
-
-  /* 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.  */
-  cp = getenv ("CPATH");
-  if (cp && ! no_standard_includes)
-    path_include (cp);
-
-  /* Initialize output buffer */
-
-  outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
-  outbuf.bufp = outbuf.buf;
-  outbuf.length = OUTBUF_SIZE;
-
-  /* Do partial setup of input buffer for the sake of generating
-     early #line directives (when -g is in effect).  */
-
-  fp = &instack[++indepth];
-  if (in_fname == NULL)
-    in_fname = "";
-  fp->nominal_fname = fp->fname = in_fname;
-  fp->lineno = 0;
-
-  /* In C++, wchar_t is a distinct basic type, and we can expect
-     __wchar_t to be defined by cc1plus.  */
-  if (cplusplus)
-    wchar_type = "__wchar_t";
-
-  /* Install __LINE__, etc.  Must follow initialize_char_syntax
-     and option processing.  */
-  initialize_builtins (fp, &outbuf);
-
-  /* Do standard #defines and assertions
-     that identify system and machine type.  */
-
-  if (!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 (debug_output)
-          output_line_directive (fp, &outbuf, 0, same_file);
-        make_definition (q, &outbuf);
-        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 ("-A", assertion);
-        *termination = (char) save_char;
-        p = termination;
-        while (*p == ' ' || *p == '\t')
-          p++;
-      } else {
-        abort ();
-      }
-    }
-  }
-
-  /* Now handle the command line options.  */
-
-  /* Do -U's, -D's and -A's in the order they were seen.  */
-  for (i = 1; i < argc; i++) {
-    if (pend_undefs[i]) {
-      if (debug_output)
-        output_line_directive (fp, &outbuf, 0, same_file);
-      make_undef (pend_undefs[i], &outbuf);
-    }
-    if (pend_defs[i]) {
-      if (debug_output)
-        output_line_directive (fp, &outbuf, 0, same_file);
-      make_definition (pend_defs[i], &outbuf);
-    }
-    if (pend_assertions[i])
-      make_assertion (pend_assertion_options[i], pend_assertions[i]);
-  }
-
-  done_initializing = 1;
-
-  { /* Read the appropriate environment variable and if it exists
-       replace include_defaults with the listed path.  */
-    char *epath = 0;
-    switch ((objc << 1) + cplusplus)
-      {
-      case 0:
-        epath = getenv ("C_INCLUDE_PATH");
-        break;
-      case 1:
-        epath = getenv ("CPLUS_INCLUDE_PATH");
-        break;
-      case 2:
-        epath = getenv ("OBJC_INCLUDE_PATH");
-        break;
-      case 3:
-        epath = getenv ("OBJCPLUS_INCLUDE_PATH");
-        break;
-      }
-    /* If the environment var for this language is set,
-       add to the default list of include directories.  */
-    if (epath) {
-      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) {
-        char c = *endp++;
-        if (c == PATH_SEPARATOR || !c) {
-          endp[-1] = 0;
-          include_defaults[num_dirs].fname
-            = startp == endp ? "." : savestring (startp);
-          endp[-1] = c;
-          include_defaults[num_dirs].component = 0;
-          include_defaults[num_dirs].cplusplus = cplusplus;
-          include_defaults[num_dirs].cxx_aware = 1;
-          num_dirs++;
-          if (!c)
-            break;
-          startp = endp;
-        }
-      }
-      /* Put the usual defaults back in at the end.  */
-      bcopy ((char *) include_defaults_array,
-             (char *) &include_defaults[num_dirs],
-             sizeof (include_defaults_array));
-    }
-  }
-
-  append_include_chain (before_system, last_before_system);
-  first_system_include = before_system;
-
-  /* Unless -fnostdinc,
-     tack on the standard include file dirs to the specified list */
-  if (!no_standard_includes) {
-    struct default_include *p = include_defaults;
-    char *specd_prefix = include_prefix;
-    char *default_prefix = savestring (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 || (cplusplus && !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.  */
-            struct file_name_list *new
-              = new_include_prefix (NULL_PTR, NULL_PTR, specd_prefix,
-                                    p->fname + default_len);
-            if (new) {
-              new->c_system_include_path = !p->cxx_aware;
-              append_include_chain (new, new);
-              if (first_system_include == 0)
-                first_system_include = new;
-            }
-          }
-        }
-      }
-    /* Search ordinary names for GNU include directories.  */
-    for (p = include_defaults; p->fname; p++) {
-      /* Some standard dirs are only for C++.  */
-      if (!p->cplusplus || (cplusplus && !no_standard_cplusplus_includes)) {
-        struct file_name_list *new
-          = new_include_prefix (NULL_PTR, p->component, "", p->fname);
-        if (new) {
-          new->c_system_include_path = !p->cxx_aware;
-          append_include_chain (new, new);
-          if (first_system_include == 0)
-            first_system_include = new;
-        }
-      }
-    }
-  }
-
-  /* Tack the after_include chain at the end of the include chain.  */
-  append_include_chain (after_include, last_after_include);
-  if (first_system_include == 0)
-    first_system_include = after_include;
-
-  /* With -v, print the list of dirs to search.  */
-  if (verbose) {
-    struct file_name_list *p;
-    fprintf (stderr, "#include \"...\" search starts here:\n");
-    for (p = include; p; p = p->next) {
-      if (p == first_bracket_include)
-        fprintf (stderr, "#include <...> search starts here:\n");
-      if (!p->fname[0])
-        fprintf (stderr, " .\n");
-      else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
-        fprintf (stderr, " %s\n", p->fname);
-      else
-        /* Omit trailing '/'.  */
-        fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, p->fname);
-    }
-    fprintf (stderr, "End of search list.\n");
-  }
-
-  /* -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 (print_deps_missing_files && (print_deps == 0 || !inhibit_output))
-    fatal ("-MG must be specified with one of -M or -MM");
-
-  /* Either of two environment variables can specify output of deps.
-     Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
-     where OUTPUT_FILE is the file to write deps info to
-     and DEPS_TARGET is the target to mention in the deps.  */
-
-  if (print_deps == 0
-      && (getenv ("SUNPRO_DEPENDENCIES") != 0
-          || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
-    char *spec = getenv ("DEPENDENCIES_OUTPUT");
-    char *s;
-    char *output_file;
-
-    if (spec == 0) {
-      spec = getenv ("SUNPRO_DEPENDENCIES");
-      print_deps = 2;
-    }
-    else
-      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) {
-      deps_target = s + 1;
-      output_file = xmalloc (s - spec + 1);
-      bcopy (spec, output_file, s - spec);
-      output_file[s - spec] = 0;
-    }
-    else {
-      deps_target = 0;
-      output_file = spec;
-    }
-      
-    deps_file = output_file;
-    deps_mode = "a";
-  }
-
-  /* For -M, print the expected object file name
-     as the target of this Make-rule.  */
-  if (print_deps) {
-    deps_allocated_size = 200;
-    deps_buffer = xmalloc (deps_allocated_size);
-    deps_buffer[0] = 0;
-    deps_size = 0;
-    deps_column = 0;
-
-    if (deps_target) {
-      deps_output (deps_target, ':');
-    } else if (*in_fname == 0) {
-      deps_output ("-", ':');
-    } else {
-      char *p, *q;
-      int len;
-
-      q = base_name (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;
-      if (len >= 2
-          && p[len - 2] == '.'
-          && index("cCsSm", p[len - 1]))
-        q = p + (len - 2);
-      else if (len >= 3
-               && p[len - 3] == '.'
-               && p[len - 2] == 'c'
-               && p[len - 1] == 'c')
-        q = p + (len - 3);
-      else if (len >= 4
-               && p[len - 4] == '.'
-               && p[len - 3] == 'c'
-               && p[len - 2] == 'x'
-               && p[len - 1] == 'x')
-        q = p + (len - 4);
-      else if (len >= 4
-               && p[len - 4] == '.'
-               && p[len - 3] == 'c'
-               && p[len - 2] == 'p'
-               && p[len - 1] == 'p')
-        q = p + (len - 4);
-      /*
-       * The slice suffix.
-       */
-      else if (len >= 4
-               && p[len - 4] == '.'
-               && p[len - 3] == 'i'
-               && p[len - 2] == 'c'
-               && p[len - 1] == 'e')
-        q = p + (len - 4);
-
-      /* Supply our own suffix.  */
-      strcpy (q, OBJECT_SUFFIX);
-
-      deps_output (p, ':');
-      deps_output (in_fname, ' ');
-    }
-  }
-
-  /* Scan the -imacros files before the main input.
-     Much like #including them, but with no_output set
-     so that only their macro definitions matter.  */
-
-  no_output++; no_record_file++;
-  for (i = 1; i < argc; i++)
-    if (pend_files[i]) {
-      struct include_file *inc;
-      int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
-      if (fd < 0) {
-        perror_with_name (pend_files[i]);
-        return FATAL_EXIT_CODE;
-      }
-      finclude (fd, inc, &outbuf, 0, NULL_PTR);
-    }
-  no_output--; no_record_file--;
-
-  /* Copy the entire contents of the main input file into
-     the stacked input buffer previously allocated for it.  */
-
-  /* JF check for stdin */
-  if (in_fname == NULL || *in_fname == 0) {
-    in_fname = "";
-    f = 0;
-  } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
-    goto perror;
-
-  if (fstat (f, &st) != 0)
-    pfatal_with_name (in_fname);
-  fp->nominal_fname = fp->fname = in_fname;
-  fp->lineno = 1;
-  fp->system_header_p = 0;
-  /* JF all this is mine about reading pipes and ttys */
-  if (! S_ISREG (st.st_mode)) {
-    /* Read input from a file that is not a normal disk file.
-       We cannot preallocate a buffer with the correct size,
-       so we must read in the file a piece at the time and make it bigger.  */
-    int size;
-    int bsize;
-    int cnt;
-
-    if (S_ISDIR (st.st_mode))
-      fatal ("Input file `%s' is a directory", in_fname);
-
-    bsize = 2000;
-    size = 0;
-    fp->buf = (U_CHAR *) xmalloc (bsize + 2);
-    for (;;) {
-      cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
-      if (cnt < 0) goto perror; /* error! */
-      size += cnt;
-      if (size != bsize) break; /* End of file */
-      bsize *= 2;
-      fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
-    }
-    fp->length = size;
-  } else {
-    /* Read a file whose size we can determine in advance.
-       For the sake of VMS, st.st_size is just an upper bound.  */
-    size_t s = (size_t) st.st_size;
-    if (s != st.st_size || s + 2 < s)
-      memory_full ();
-    fp->buf = (U_CHAR *) xmalloc (s + 2);
-    fp->length = safe_read (f, (char *) fp->buf, s);
-    if (fp->length < 0) goto perror;
-  }
-  fp->bufp = fp->buf;
-  fp->if_stack = if_stack;
-
-  /* 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';
-
-  /* Unless inhibited, convert trigraphs in the input.  */
-
-  if (!no_trigraphs)
-    trigraph_pcp (fp);
-
-  /* Now that we know the input file is valid, open the output.  */
-
-  if (!out_fname || !strcmp (out_fname, ""))
-    out_fname = "stdout";
-  else if (! freopen (out_fname, "w", stdout))
-    pfatal_with_name (out_fname);
-
-  output_line_directive (fp, &outbuf, 0, same_file);
-
-  /* Scan the -include files before the main input.  */
-
-  no_record_file++;
-  for (i = 1; i < argc; i++)
-    if (pend_includes[i]) {
-      struct include_file *inc;
-      int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
-      if (fd < 0) {
-        perror_with_name (pend_includes[i]);
-        return FATAL_EXIT_CODE;
-      }
-      finclude (fd, inc, &outbuf, 0, NULL_PTR);
-    }
-  no_record_file--;
-
-  /* Scan the input, processing macros and directives.  */
-
-  rescan (&outbuf, 0);
-
-  if (missing_newline)
-    fp->lineno--;
-
-  if (pedantic && missing_newline)
-    pedwarn ("file does not end in newline");
-
-  /* Now we have processed the entire input
-     Write whichever kind of output has been requested.  */
-
-  if (dump_macros == dump_only)
-    dump_all_macros ();
-  else if (! inhibit_output) {
-    write_output ();
-  }
-
-  if (print_deps) {
-    /* Don't actually write the deps file if compilation has failed.  */
-    if (errors == 0) {
-      if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode)))
-        pfatal_with_name (deps_file);
-      fputs (deps_buffer, deps_stream);
-      putc ('\n', deps_stream);
-      if (deps_file) {
-        if (ferror (deps_stream) || fclose (deps_stream) != 0)
-          fatal ("I/O error on output");
-      }
-    }
-  }
-
-  if (pcp_outfile && pcp_outfile != stdout
-      && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0))
-    fatal ("I/O error on `-pcp' output");
-
-  if (ferror (stdout) || fclose (stdout) != 0)
-    fatal ("I/O error on output");
-
-  if (errors)
-    exit (FATAL_EXIT_CODE);
-  exit (SUCCESS_EXIT_CODE);
-
- perror:
-  pfatal_with_name (in_fname);
-  return 0;
-}
-
-/* Given a colon-separated list of file names PATH,
-   add all the names to the search path for include files.  */
-
-static void
-path_include (path)
-     char *path;
-{
-  char *p;
-
-  p = path;
-
-  if (*p)
-    while (1) {
-      char *q = p;
-      char c;
-      struct file_name_list *dirtmp;
-
-      /* Find the end of this name.  */
-      while ((c = *q++) != PATH_SEPARATOR && c)
-        continue;
-
-      q[-1] = 0;
-      dirtmp = new_include_prefix (last_include, NULL_PTR,
-                                   "", p == q ? "." : p);
-      q[-1] = c;
-      append_include_chain (dirtmp, dirtmp);
-
-      /* Advance past this name.  */
-      p = q;
-      if (! c)
-        break;
-    }
-}
-
-/* Return the address of the first character in S that equals C.
-   S is an array of length N, possibly containing '\0's, and followed by '\0'.
-   Return 0 if there is no such character.  Assume that C itself is not '\0'.
-   If we knew we could use memchr, we could just invoke memchr (S, C, N),
-   but unfortunately memchr isn't autoconfigured yet.  */
-
-static U_CHAR *
-index0 (s, c, n)
-     U_CHAR *s;
-     int c;
-     size_t n;
-{
-  char *p = (char *) s;
-  for (;;) {
-    char *q = (char*) index (p, c);
-    if (q)
-      return (U_CHAR *) q;
-    else {
-      size_t l = strlen (p);
-      if (l == n)
-        return 0;
-      l++;
-      p += l;
-      n -= l;
-    }
-  }
-}
-
-/* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
-   before main CCCP processing.  Name `pcp' is also in honor of the
-   drugs the trigraph designers must have been on.
-
-   Using an extra pass through the buffer takes a little extra time,
-   but is infinitely less hairy than trying to handle trigraphs inside
-   strings, etc. everywhere, and also makes sure that trigraphs are
-   only translated in the top level of processing.  */
-
-static void
-trigraph_pcp (buf)
-     FILE_BUF *buf;
-{
-  register U_CHAR c, *fptr, *bptr, *sptr, *lptr;
-  int len;
-
-  fptr = bptr = sptr = buf->buf;
-  lptr = fptr + buf->length;
-  while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
-    if (*++sptr != '?')
-      continue;
-    switch (*++sptr) {
-      case '=':
-      c = '#';
-      break;
-    case '(':
-      c = '[';
-      break;
-    case '/':
-      c = '\\';
-      break;
-    case ')':
-      c = ']';
-      break;
-    case '\'':
-      c = '^';
-      break;
-    case '<':
-      c = '{';
-      break;
-    case '!':
-      c = '|';
-      break;
-    case '>':
-      c = '}';
-      break;
-    case '-':
-      c  = '~';
-      break;
-    case '?':
-      sptr--;
-      continue;
-    default:
-      continue;
-    }
-    len = sptr - fptr - 2;
-
-    /* BSD doc says bcopy () works right for overlapping strings.  In ANSI
-       C, this will be memmove ().  */
-    if (bptr != fptr && len > 0)
-      bcopy ((char *) fptr, (char *) bptr, len);
-
-    bptr += len;
-    *bptr++ = c;
-    fptr = ++sptr;
-  }
-  len = buf->length - (fptr - buf->buf);
-  if (bptr != fptr && len > 0)
-    bcopy ((char *) fptr, (char *) bptr, len);
-  buf->length -= fptr - bptr;
-  buf->buf[buf->length] = '\0';
-  if (warn_trigraphs && fptr != bptr)
-    warning_with_line (0, "%lu trigraph(s) encountered",
-                       (unsigned long) (fptr - bptr) / 2);
-}
-
-/* Move all backslash-newline pairs out of embarrassing places.
-   Exchange all such pairs following BP
-   with any potentially-embarrassing characters that follow them.
-   Potentially-embarrassing characters are / and *
-   (because a backslash-newline inside a comment delimiter
-   would cause it not to be recognized).  */
-
-static void
-newline_fix (bp)
-     U_CHAR *bp;
-{
-  register U_CHAR *p = bp;
-
-  /* First count the backslash-newline pairs here.  */
-
-  while (p[0] == '\\' && p[1] == '\n')
-    p += 2;
-
-  /* What follows the backslash-newlines is not embarrassing.  */
-
-  if (*p != '/' && *p != '*')
-    return;
-
-  /* Copy all potentially embarrassing characters
-     that follow the backslash-newline pairs
-     down to where the pairs originally started.  */
-
-  while (*p == '*' || *p == '/')
-    *bp++ = *p++;
-
-  /* Now write the same number of pairs after the embarrassing chars.  */
-  while (bp < p) {
-    *bp++ = '\\';
-    *bp++ = '\n';
-  }
-}
-
-/* Like newline_fix but for use within a directive-name.
-   Move any backslash-newlines up past any following symbol constituents.  */
-
-static void
-name_newline_fix (bp)
-     U_CHAR *bp;
-{
-  register U_CHAR *p = bp;
-
-  /* First count the backslash-newline pairs here.  */
-  while (p[0] == '\\' && p[1] == '\n')
-    p += 2;
-
-  /* What follows the backslash-newlines is not embarrassing.  */
-
-  if (!is_idchar[*p])
-    return;
-
-  /* Copy all potentially embarrassing characters
-     that follow the backslash-newline pairs
-     down to where the pairs originally started.  */
-
-  while (is_idchar[*p])
-    *bp++ = *p++;
-
-  /* Now write the same number of pairs after the embarrassing chars.  */
-  while (bp < p) {
-    *bp++ = '\\';
-    *bp++ = '\n';
-  }
-}
-
-/* Look for lint commands in comments.
-
-   When we come in here, ibp points into a comment.  Limit is as one expects.
-   scan within the comment -- it should start, after lwsp, with a lint command.
-   If so that command is returned as a (constant) string.
-
-   Upon return, any arg will be pointed to with argstart and will be
-   arglen long.  Note that we don't parse that arg since it will just
-   be printed out again.  */
-
-static char *
-get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
-     register U_CHAR *ibp;
-     register U_CHAR *limit;
-     U_CHAR **argstart;         /* point to command arg */
-     int *arglen, *cmdlen;      /* how long they are */
-{
-  HOST_WIDE_INT linsize;
-  register U_CHAR *numptr;      /* temp for arg parsing */
-
-  *arglen = 0;
-
-  SKIP_WHITE_SPACE (ibp);
-
-  if (ibp >= limit) return NULL;
-
-  linsize = limit - ibp;
-  
-  /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
-  if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
-    *cmdlen = 10;
-    return "NOTREACHED";
-  }
-  if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
-    *cmdlen = 8;
-    return "ARGSUSED";
-  }
-  if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
-    *cmdlen = 11;
-    return "LINTLIBRARY";
-  }
-  if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
-    *cmdlen = 7;
-    ibp += 7; linsize -= 7;
-    if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
-
-    /* OK, read a number */
-    for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr);
-         numptr++);
-    *arglen = numptr - *argstart;
-    return "VARARGS";
-  }
-  return NULL;
-}
-
-/*
- * The main loop of the program.
- *
- * Read characters from the input stack, transferring them to the
- * output buffer OP.
- *
- * Macros are expanded and push levels on the input stack.
- * At the end of such a level it is popped off and we keep reading.
- * At the end of any other kind of level, we return.
- * #-directives are handled, except within macros.
- *
- * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
- * and insert them when appropriate.  This is set while scanning macro
- * arguments before substitution.  It is zero when scanning for final output.
- *   There are three types of Newline markers:
- *   * Newline -  follows a macro name that was not expanded
- *     because it appeared inside an expansion of the same macro.
- *     This marker prevents future expansion of that identifier.
- *     When the input is rescanned into the final output, these are deleted.
- *     These are also deleted by ## concatenation.
- *   * Newline Space (or Newline and any other whitespace character)
- *     stands for a place that tokens must be separated or whitespace
- *     is otherwise desirable, but where the ANSI standard specifies there
- *     is no whitespace.  This marker turns into a Space (or whichever other
- *     whitespace char appears in the marker) in the final output,
- *     but it turns into nothing in an argument that is stringified with #.
- *     Such stringified arguments are the only place where the ANSI standard
- *     specifies with precision that whitespace may not appear.
- *
- * During this function, IP->bufp is kept cached in IBP for speed of access.
- * Likewise, OP->bufp is kept in OBP.  Before calling a subroutine
- * IBP, IP and OBP must be copied back to memory.  IP and IBP are
- * copied back with the RECACHE macro.  OBP must be copied back from OP->bufp
- * explicitly, and before RECACHE, since RECACHE uses OBP.
- */
-
-static void
-rescan (op, output_marks)
-     FILE_BUF *op;
-     int output_marks;
-{
-  /* Character being scanned in main loop.  */
-  register U_CHAR c;
-
-  /* Length of pending accumulated identifier.  */
-  register int ident_length = 0;
-
-  /* Hash code of pending accumulated identifier.  */
-  register int hash = 0;
-
-  /* Current input level (&instack[indepth]).  */
-  FILE_BUF *ip;
-
-  /* Pointer for scanning input.  */
-  register U_CHAR *ibp;
-
-  /* Pointer to end of input.  End of scan is controlled by LIMIT.  */
-  register U_CHAR *limit;
-
-  /* Pointer for storing output.  */
-  register U_CHAR *obp;
-
-  /* REDO_CHAR is nonzero if we are processing an identifier
-     after backing up over the terminating character.
-     Sometimes we process an identifier without backing up over
-     the terminating character, if the terminating character
-     is not special.  Backing up is done so that the terminating character
-     will be dispatched on again once the identifier is dealt with.  */
-  int redo_char = 0;
-
-  /* 1 if within an identifier inside of which a concatenation
-     marker (Newline -) has been seen.  */
-  int concatenated = 0;
-
-  /* While scanning a comment or a string constant,
-     this records the line it started on, for error messages.  */
-  int start_line;
-
-  /* Record position of last `real' newline.  */
-  U_CHAR *beg_of_line;
-
-/* Pop the innermost input stack level, assuming it is a macro expansion.  */
-
-#define POPMACRO \
-do { ip->macro->type = T_MACRO;         \
-     if (ip->free_ptr) free (ip->free_ptr);     \
-     --indepth; } while (0)
-
-/* Reload `rescan's local variables that describe the current
-   level of the input stack.  */
-
-#define RECACHE  \
-do { ip = &instack[indepth];            \
-     ibp = ip->bufp;                    \
-     limit = ip->buf + ip->length;      \
-     op->bufp = obp;                    \
-     check_expand (op, limit - ibp);    \
-     beg_of_line = 0;                   \
-     obp = op->bufp; } while (0)
-
-  if (no_output && instack[indepth].fname != 0)
-    skip_if_group (&instack[indepth], 1, NULL);
-
-  obp = op->bufp;
-  RECACHE;
-
-  beg_of_line = ibp;
-
-  /* Our caller must always put a null after the end of
-     the input at each input stack level.  */
-  if (*limit != 0)
-    abort ();
-
-  while (1) {
-    c = *ibp++;
-    *obp++ = c;
-
-    switch (c) {
-    case '\\':
-      if (*ibp == '\n' && !ip->macro) {
-        /* At the top level, always merge lines ending with backslash-newline,
-           even in middle of identifier.  But do not merge lines in a macro,
-           since backslash might be followed by a newline-space marker.  */
-        ++ibp;
-        ++ip->lineno;
-        --obp;          /* remove backslash from obuf */
-        break;
-      }
-      /* If ANSI, backslash is just another character outside a string.  */
-      if (!traditional)
-        goto randomchar;
-      /* Otherwise, backslash suppresses specialness of following char,
-         so copy it here to prevent the switch from seeing it.
-         But first get any pending identifier processed.  */
-      if (ident_length > 0)
-        goto specialchar;
-      if (ibp < limit)
-        *obp++ = *ibp++;
-      break;
-
-    case '%':
-      if (ident_length || ip->macro || traditional)
-        goto randomchar;
-      while (*ibp == '\\' && ibp[1] == '\n') {
-        ibp += 2;
-        ++ip->lineno;
-      }
-      if (*ibp != ':')
-        break;
-      /* Treat this %: digraph as if it were #.  */
-      /* Fall through.  */
-
-    case '#':
-      if (assertions_flag) {
-        if (ident_length)
-          goto specialchar;
-        /* Copy #foo (bar lose) without macro expansion.  */
-        obp[-1] = '#';  /* In case it was '%'.  */
-        SKIP_WHITE_SPACE (ibp);
-        while (is_idchar[*ibp])
-          *obp++ = *ibp++;
-        SKIP_WHITE_SPACE (ibp);
-        if (*ibp == '(') {
-          ip->bufp = ibp;
-          skip_paren_group (ip);
-          bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
-          obp += ip->bufp - ibp;
-          ibp = ip->bufp;
-        }
-        break;
-      }
-
-      /* If this is expanding a macro definition, don't recognize
-         preprocessing directives.  */
-      if (ip->macro != 0)
-        goto randomchar;
-      /* If this is expand_into_temp_buffer,
-         don't recognize them either.  Warn about them
-         only after an actual newline at this level,
-         not at the beginning of the input level.  */
-      if (! ip->fname) {
-        if (ip->buf != beg_of_line)
-          warning ("preprocessing directive not recognized within macro arg");
-        goto randomchar;
-      }
-      if (ident_length)
-        goto specialchar;
-
-      
-      /* # keyword: a # must be first nonblank char on the line */
-      if (beg_of_line == 0)
-        goto randomchar;
-      {
-        U_CHAR *bp;
-
-        /* Scan from start of line, skipping whitespace, comments
-           and backslash-newlines, and see if we reach this #.
-           If not, this # is not special.  */
-        bp = beg_of_line;
-        /* If -traditional, require # to be at beginning of line.  */
-        if (!traditional) {
-          while (1) {
-            if (is_hor_space[*bp])
-              bp++;
-            else if (*bp == '\\' && bp[1] == '\n')
-              bp += 2;
-            else if (*bp == '/' && bp[1] == '*') {
-              bp += 2;
-              while (!(*bp == '*' && bp[1] == '/'))
-                bp++;
-              bp += 2;
-            }
-            /* There is no point in trying to deal with C++ // comments here,
-               because if there is one, then this # must be part of the
-               comment and we would never reach here.  */
-            else break;
-          }
-          if (c == '%') {
-            if (bp[0] != '%')
-              break;
-            while (bp[1] == '\\' && bp[2] == '\n')
-              bp += 2;
-            if (bp + 1 != ibp)
-              break;
-            /* %: appears at start of line; skip past the ':' too.  */
-            bp++;
-            ibp++;
-          }
-        }
-        if (bp + 1 != ibp)
-          goto randomchar;
-      }
-
-      /* This # can start a directive.  */
-
-      --obp;            /* Don't copy the '#' */
-
-      ip->bufp = ibp;
-      op->bufp = obp;
-      if (! handle_directive (ip, op)) {
-#ifdef USE_C_ALLOCA
-        alloca (0);
-#endif
-        /* Not a known directive: treat it as ordinary text.
-           IP, OP, IBP, etc. have not been changed.  */
-        if (no_output && instack[indepth].fname) {
-          /* If not generating expanded output,
-             what we do with ordinary text is skip it.
-             Discard everything until next # directive.  */
-          skip_if_group (&instack[indepth], 1, 0);
-          RECACHE;
-          beg_of_line = ibp;
-          break;
-        }
-        *obp++ = '#';   /* Copy # (even if it was originally %:).  */
-        /* Don't expand an identifier that could be a macro directive.
-           (Section 3.8.3 of the ANSI C standard)                       */
-        SKIP_WHITE_SPACE (ibp);
-        if (is_idstart[*ibp])
-          {
-            *obp++ = *ibp++;
-            while (is_idchar[*ibp])
-              *obp++ = *ibp++;
-          }
-        goto randomchar;
-      }
-#ifdef USE_C_ALLOCA
-      alloca (0);
-#endif
-      /* A # directive has been successfully processed.  */
-      /* If not generating expanded output, ignore everything until
-         next # directive.  */
-      if (no_output && instack[indepth].fname)
-        skip_if_group (&instack[indepth], 1, 0);
-      obp = op->bufp;
-      RECACHE;
-      beg_of_line = ibp;
-      break;
-
-    case '\"':                  /* skip quoted string */
-    case '\'':
-      /* A single quoted string is treated like a double -- some
-         programs (e.g., troff) are perverse this way */
-
-      /* Handle any pending identifier;
-         but the L in L'...' or L"..." is not an identifier.  */
-      if (ident_length) {
-        if (! (ident_length == 1 && hash == HASHSTEP (0, 'L')))
-          goto specialchar;
-        ident_length = hash = 0;
-      }
-
-      start_line = ip->lineno;
-
-      /* Skip ahead to a matching quote.  */
-
-      while (1) {
-        if (ibp >= limit) {
-          if (ip->macro != 0) {
-            /* try harder: this string crosses a macro expansion boundary.
-               This can happen naturally if -traditional.
-               Otherwise, only -D can make a macro with an unmatched quote.  */
-            POPMACRO;
-            RECACHE;
-            continue;
-          }
-          if (!traditional) {
-            error_with_line (line_for_error (start_line),
-                             "unterminated string or character constant");
-            if (multiline_string_line) {
-              error_with_line (multiline_string_line,
-                               "possible real start of unterminated constant");
-              multiline_string_line = 0;
-            }
-          }
-          break;
-        }
-        *obp++ = *ibp;
-        switch (*ibp++) {
-        case '\n':
-          ++ip->lineno;
-          ++op->lineno;
-          /* Traditionally, end of line ends a string constant with no error.
-             So exit the loop and record the new line.  */
-          if (traditional) {
-            beg_of_line = ibp;
-            goto while2end;
-          }
-          if (c == '\'') {
-            error_with_line (line_for_error (start_line),
-                             "unterminated character constant");
-            goto while2end;
-          }
-          if (multiline_string_line == 0) {
-            if (pedantic)
-              pedwarn_with_line (line_for_error (start_line),
-                                 "string constant runs past end of line");
-            multiline_string_line = ip->lineno - 1;
-          }
-          break;
-
-        case '\\':
-          if (*ibp == '\n') {
-            /* Backslash newline is replaced by nothing at all, but
-               keep the line counts correct.  But if we are reading
-               from a macro, keep the backslash newline, since backslash
-               newlines have already been processed.  */
-            if (ip->macro)
-              *obp++ = '\n';
-            else
-              --obp;
-            ++ibp;
-            ++ip->lineno;
-          } else {
-            /* ANSI stupidly requires that in \\ the second \
-               is *not* prevented from combining with a newline.  */
-            if (!ip->macro) {
-              while (*ibp == '\\' && ibp[1] == '\n') {
-                ibp += 2;
-                ++ip->lineno;
-              }
-            }
-            *obp++ = *ibp++;
-          }
-          break;
-
-        case '\"':
-        case '\'':
-          if (ibp[-1] == c)
-            goto while2end;
-          break;
-        }
-      }
-    while2end:
-      break;
-
-    case '/':
-      if (ip->macro != 0)
-        goto randomchar;
-      if (*ibp == '\\' && ibp[1] == '\n')
-        newline_fix (ibp);
-      if (*ibp != '*'
-          && !(cplusplus_comments && *ibp == '/'))
-        goto randomchar;
-      if (ident_length)
-        goto specialchar;
-
-      if (*ibp == '/') {
-        /* C++ style comment...  */
-        start_line = ip->lineno;
-
-        /* Comments are equivalent to spaces.  */
-        if (! put_out_comments)
-          obp[-1] = ' ';
-
-        {
-          U_CHAR *before_bp = ibp;
-
-          while (++ibp < limit) {
-            if (*ibp == '\n') {
-              if (ibp[-1] != '\\') {
-                if (put_out_comments) {
-                  bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
-                  obp += ibp - before_bp;
-                }
-                break;
-              }
-              if (warn_comments)
-                warning ("multiline `//' comment");
-              ++ip->lineno;
-              /* Copy the newline into the output buffer, in order to
-                 avoid the pain of a #line every time a multiline comment
-                 is seen.  */
-              if (!put_out_comments)
-                *obp++ = '\n';
-              ++op->lineno;
-            }
-          }
-          break;
-        }
-      }
-
-      /* Ordinary C comment.  Skip it, optionally copying it to output.  */
-
-      start_line = ip->lineno;
-
-      ++ibp;                    /* Skip the star.  */
-
-      /* If this cpp is for lint, we peek inside the comments: */
-      if (for_lint) {
-        U_CHAR *argbp;
-        int cmdlen, arglen;
-        char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
-
-        if (lintcmd != NULL) {
-          op->bufp = obp;
-          check_expand (op, cmdlen + arglen + 14);
-          obp = op->bufp;
-          /* I believe it is always safe to emit this newline: */
-          obp[-1] = '\n';
-          bcopy ("#pragma lint ", (char *) obp, 13);
-          obp += 13;
-          bcopy (lintcmd, (char *) obp, cmdlen);
-          obp += cmdlen;
-
-          if (arglen != 0) {
-            *(obp++) = ' ';
-            bcopy (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 #pragma's newline always
-             messes up the line count.  */
-          op->bufp = obp;
-          output_line_directive (ip, op, 0, same_file);
-          check_expand (op, limit - ibp + 2);
-          obp = op->bufp;
-          *(obp++) = '/';
-        }
-      }
-
-      /* Comments are equivalent to spaces.
-         Note that we already output the slash; we might not want it.
-         For -traditional, a comment is equivalent to nothing.  */
-      if (! put_out_comments) {
-        if (traditional)
-          obp--;
-        else
-          obp[-1] = ' ';
-      }
-      else
-        *obp++ = '*';
-
-      {
-        U_CHAR *before_bp = ibp;
-
-        for (;;) {
-          switch (*ibp++) {
-          case '*':
-            if (ibp[-2] == '/' && warn_comments)
-              warning ("`/*' within comment");
-            if (*ibp == '\\' && ibp[1] == '\n')
-              newline_fix (ibp);
-            if (*ibp == '/')
-              goto comment_end;
-            break;
-
-          case '\n':
-            ++ip->lineno;
-            /* Copy the newline into the output buffer, in order to
-               avoid the pain of a #line every time a multiline comment
-               is seen.  */
-            if (!put_out_comments)
-              *obp++ = '\n';
-            ++op->lineno;
-            break;
-
-          case 0:
-            if (limit < ibp) {
-              error_with_line (line_for_error (start_line),
-                               "unterminated comment");
-              goto limit_reached;
-            }
-            break;
-          }
-        }
-      comment_end:
-
-        ibp++;
-        if (put_out_comments) {
-          bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
-          obp += ibp - before_bp;
-        }
-      }
-      break;
-
-    case '$':
-      if (! is_idchar['$'])
-        goto randomchar;
-      if (pedantic)
-        pedwarn ("`$' in identifier");
-      goto letter;
-
-    case '0': case '1': case '2': case '3': case '4':
-    case '5': case '6': case '7': case '8': case '9':
-      /* If digit is not part of identifier, it starts a number,
-         which means that following letters are not an identifier.
-         "0x5" does not refer to an identifier "x5".
-         So copy all alphanumerics that follow without accumulating
-         as an identifier.  Periods also, for sake of "3.e7".  */
-
-      if (ident_length == 0) {
-        for (;;) {
-          if (!ip->macro) {
-            while (ibp[0] == '\\' && ibp[1] == '\n') {
-              ++ip->lineno;
-              ibp += 2;
-            }
-          }
-          c = *ibp++;
-          if (!is_idchar[c] && c != '.') {
-            --ibp;
-            break;
-          }
-          *obp++ = c;
-          /* A sign can be part of a preprocessing number
-             if it follows an `e' or `p'.  */
-          if (c == 'e' || c == 'E' || c == 'p' || c == 'P') {
-            if (!ip->macro) {
-              while (ibp[0] == '\\' && ibp[1] == '\n') {
-                ++ip->lineno;
-                ibp += 2;
-              }
-            }
-            if (*ibp == '+' || *ibp == '-') {
-              *obp++ = *ibp++;
-              /* But traditional C does not let the token go past the sign,
-                 and C89 does not allow `p'.  */
-              if (traditional || (c89 && (c == 'p' || c == 'P')))
-                break;
-            }
-          }
-        }
-        break;
-      }
-      /* fall through */
-
-    case '_':
-    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-    case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
-    case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
-    case 's': case 't': case 'u': case 'v': case 'w': case 'x':
-    case 'y': case 'z':
-    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-    case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
-    case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
-    case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
-    case 'Y': case 'Z':
-    letter:
-      ident_length++;
-      /* Compute step of hash function, to avoid a proc call on every token */
-      hash = HASHSTEP (hash, c);
-      break;
-
-    case '\n':
-      if (ip->fname == 0 && *ibp == '-') {
-        /* Newline - inhibits expansion of preceding token.
-           If expanding a macro arg, we keep the newline -.
-           In final output, it is deleted.
-           We recognize Newline - in macro bodies and macro args.  */
-        if (! concatenated) {
-          ident_length = 0;
-          hash = 0;
-        }
-        ibp++;
-        if (!output_marks) {
-          obp--;
-        } else {
-          /* If expanding a macro arg, keep the newline -.  */
-          *obp++ = '-';
-        }
-        break;
-      }
-
-      /* If reprocessing a macro expansion, newline is a special marker.  */
-      else if (ip->macro != 0) {
-        /* Newline White is a "funny space" to separate tokens that are
-           supposed to be separate but without space between.
-           Here White means any whitespace character.
-           Newline - marks a recursive macro use that is not
-           supposed to be expandable.  */
-
-        if (is_space[*ibp]) {
-          /* Newline Space does not prevent expansion of preceding token
-             so expand the preceding token and then come back.  */
-          if (ident_length > 0)
-            goto specialchar;
-
-          /* If generating final output, newline space makes a space.  */
-          if (!output_marks) {
-            obp[-1] = *ibp++;
-            /* And Newline Newline makes a newline, so count it.  */
-            if (obp[-1] == '\n')
-              op->lineno++;
-          } else {
-            /* If expanding a macro arg, keep the newline space.
-               If the arg gets stringified, newline space makes nothing.  */
-            *obp++ = *ibp++;
-          }
-        } else abort ();        /* Newline followed by something random?  */
-        break;
-      }
-
-      /* If there is a pending identifier, handle it and come back here.  */
-      if (ident_length > 0)
-        goto specialchar;
-
-      beg_of_line = ibp;
-
-      /* Update the line counts and output a #line if necessary.  */
-      ++ip->lineno;
-      ++op->lineno;
-      if (ip->lineno != op->lineno) {
-        op->bufp = obp;
-        output_line_directive (ip, op, 1, same_file);
-        check_expand (op, limit - ibp);
-        obp = op->bufp;
-      }
-      break;
-
-      /* Come here either after (1) a null character that is part of the input
-         or (2) at the end of the input, because there is a null there.  */
-    case 0:
-      if (ibp <= limit)
-        /* Our input really contains a null character.  */
-        goto randomchar;
-
-    limit_reached:
-      /* At end of a macro-expansion level, pop it and read next level.  */
-      if (ip->macro != 0) {
-        obp--;
-        ibp--;
-        /* If traditional, and we have an identifier that ends here,
-           process it now, so we get the right error for recursion.  */
-        if (traditional && ident_length
-            && ! is_idchar[*instack[indepth - 1].bufp]) {
-          redo_char = 1;
-          goto randomchar;
-        }
-        POPMACRO;
-        RECACHE;
-        break;
-      }
-
-      /* If we don't have a pending identifier,
-         return at end of input.  */
-      if (ident_length == 0) {
-        obp--;
-        ibp--;
-        op->bufp = obp;
-        ip->bufp = ibp;
-        goto ending;
-      }
-
-      /* If we do have a pending identifier, just consider this null
-         a special character and arrange to dispatch on it again.
-         The second time, IDENT_LENGTH will be zero so we will return.  */
-
-      /* Fall through */
-
-specialchar:
-
-      /* Handle the case of a character such as /, ', " or null
-         seen following an identifier.  Back over it so that
-         after the identifier is processed the special char
-         will be dispatched on again.  */
-
-      ibp--;
-      obp--;
-      redo_char = 1;
-
-    default:
-
-randomchar:
-
-      if (ident_length > 0) {
-        register HASHNODE *hp;
-
-        /* We have just seen an identifier end.  If it's a macro, expand it.
-
-           IDENT_LENGTH is the length of the identifier
-           and HASH is its hash code.
-
-           The identifier has already been copied to the output,
-           so if it is a macro we must remove it.
-
-           If REDO_CHAR is 0, the char that terminated the identifier
-           has been skipped in the output and the input.
-           OBP-IDENT_LENGTH-1 points to the identifier.
-           If the identifier is a macro, we must back over the terminator.
-
-           If REDO_CHAR is 1, the terminating char has already been
-           backed over.  OBP-IDENT_LENGTH points to the identifier.  */
-
-        if (!pcp_outfile || pcp_inside_if) {
-          for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
-               hp = hp->next) {
-            
-            if (hp->length == ident_length) {
-              int obufp_before_macroname;
-              int op_lineno_before_macroname;
-              register int i = ident_length;
-              register U_CHAR *p = hp->name;
-              register U_CHAR *q = obp - i;
-              int disabled;
-              
-              if (! redo_char)
-                q--;
-              
-              do {              /* All this to avoid a strncmp () */
-                if (*p++ != *q++)
-                  goto hashcollision;
-              } while (--i);
-              
-              /* We found a use of a macro name.
-                 see if the context shows it is a macro call.  */
-              
-              /* Back up over terminating character if not already done.  */
-              if (! redo_char) {
-                ibp--;
-                obp--;
-              }
-              
-              /* Save this as a displacement from the beginning of the output
-                 buffer.  We can not save this as a position in the output
-                 buffer, because it may get realloc'ed by RECACHE.  */
-              obufp_before_macroname = (obp - op->buf) - ident_length;
-              op_lineno_before_macroname = op->lineno;
-              
-              if (hp->type == T_PCSTRING) {
-                pcstring_used (hp); /* Mark the definition of this key
-                                       as needed, ensuring that it
-                                       will be output.  */
-                break;          /* Exit loop, since the key cannot have a
-                                   definition any longer.  */
-              }
-
-              /* Record whether the macro is disabled.  */
-              disabled = hp->type == T_DISABLED;
-              
-              /* This looks like a macro ref, but if the macro was disabled,
-                 just copy its name and put in a marker if requested.  */
-              
-              if (disabled) {
-#if 0
-                /* This error check caught useful cases such as
-                   #define foo(x,y) bar (x (y,0), y)
-                   foo (foo, baz)  */
-                if (traditional)
-                  error ("recursive use of macro `%s'", hp->name);
-#endif
-                
-                if (output_marks) {
-                  check_expand (op, limit - ibp + 2);
-                  *obp++ = '\n';
-                  *obp++ = '-';
-                }
-                break;
-              }
-              
-              /* 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->type == T_DISABLED)
-                  && hp->value.defn->nargs >= 0)
-                {
-                  U_CHAR *old_ibp = ibp;
-                  U_CHAR *old_obp = obp;
-                  int old_iln = ip->lineno;
-                  int old_oln = op->lineno;
-                  
-                  while (1) {
-                    /* Scan forward over whitespace, copying it to the output.  */
-                    if (ibp == limit && ip->macro != 0) {
-                      POPMACRO;
-                      RECACHE;
-                      old_ibp = ibp;
-                      old_obp = obp;
-                      old_iln = ip->lineno;
-                      old_oln = op->lineno;
-                    }
-                    else if (is_space[*ibp]) {
-                      *obp++ = *ibp++;
-                      if (ibp[-1] == '\n') {
-                        if (ip->macro == 0) {
-                          /* Newline in a file.  Count it.  */
-                          ++ip->lineno;
-                          ++op->lineno;
-                        } else if (!output_marks) {
-                          /* A newline mark, and we don't want marks
-                             in the output.  If it is newline-hyphen,
-                             discard it entirely.  Otherwise, it is
-                             newline-whitechar, so keep the whitechar.  */
-                          obp--;
-                          if (*ibp == '-')
-                            ibp++;
-                          else {
-                            if (*ibp == '\n')
-                              ++op->lineno;
-                            *obp++ = *ibp++;
-                          }
-                        } else {
-                          /* A newline mark; copy both chars to the output.  */
-                          *obp++ = *ibp++;
-                        }
-                      }
-                    }
-                    else if (ip->macro)
-                      break;
-                    else if (*ibp == '/') {
-                      /* If a comment, copy it unchanged or discard it.  */
-                      if (ibp[1] == '\\' && ibp[2] == '\n')
-                        newline_fix (ibp + 1);
-                      if (ibp[1] == '*') {
-                        if (put_out_comments) {
-                          *obp++ = '/';
-                          *obp++ = '*';
-                        } else if (! traditional) {
-                          *obp++ = ' ';
-                        }
-                        for (ibp += 2; ibp < limit; ibp++) {
-                          /* We need not worry about newline-marks,
-                             since they are never found in comments.  */
-                          if (ibp[0] == '*') {
-                            if (ibp[1] == '\\' && ibp[2] == '\n')
-                              newline_fix (ibp + 1);
-                            if (ibp[1] == '/') {
-                              ibp += 2;
-                              if (put_out_comments) {
-                                *obp++ = '*';
-                                *obp++ = '/';
-                              }
-                              break;
-                            }
-                          }
-                          if (*ibp == '\n') {
-                            /* Newline in a file.  Count it.  */
-                            ++ip->lineno;
-                            ++op->lineno;
-                          }
-                          if (put_out_comments)
-                            *obp++ = *ibp;
-                        }
-                      } else if (ibp[1] == '/' && cplusplus_comments) {
-                        if (put_out_comments) {
-                          *obp++ = '/';
-                          *obp++ = '/';
-                        } else if (! traditional) {
-                          *obp++ = ' ';
-                        }
-                        for (ibp += 2; *ibp != '\n' || ibp[-1] == '\\'; ibp++)
-                          if (put_out_comments)
-                            *obp++ = *ibp;
-                      } else
-                        break;
-                    }
-                    else if (ibp[0] == '\\' && ibp[1] == '\n') {
-                      ibp += 2;
-                      ++ip->lineno;
-                    }
-                    else break;
-                  }
-                  if (*ibp != '(') {
-                    /* It isn't a macro call.
-                       Put back the space that we just skipped.  */
-                    ibp = old_ibp;
-                    obp = old_obp;
-                    ip->lineno = old_iln;
-                    op->lineno = old_oln;
-                    /* Exit the for loop.  */
-                    break;
-                  }
-                }
-              
-              /* This is now known to be a macro call.
-                 Discard the macro name from the output,
-                 along with any following whitespace just copied,
-                 but preserve newlines if not outputting marks since this
-                 is more likely to do the right thing with line numbers.  */
-              obp = op->buf + obufp_before_macroname;
-              if (output_marks)
-                op->lineno = op_lineno_before_macroname;
-              else {
-                int newlines = op->lineno - op_lineno_before_macroname;
-                while (0 < newlines--)
-                  *obp++ = '\n';
-              }
-
-              /* Prevent accidental token-pasting with a character
-                 before the macro call.  */
-              if (!traditional && obp != op->buf) {
-                switch (obp[-1]) {
-                case '!':  case '%':  case '&':  case '*':
-                case '+':  case '-':  case '.':  case '/':
-                case ':':  case '<':  case '=':  case '>':
-                case '^':  case '|':
-                  /* If we are expanding a macro arg, make a newline marker
-                     to separate the tokens.  If we are making real output,
-                     a plain space will do.  */
-                  if (output_marks)
-                    *obp++ = '\n';
-                  *obp++ = ' ';
-                }
-              }
-
-              /* Expand the macro, reading arguments as needed,
-                 and push the expansion on the input stack.  */
-              ip->bufp = ibp;
-              op->bufp = obp;
-              macroexpand (hp, op);
-              
-              /* Reexamine input stack, since macroexpand has pushed
-                 a new level on it.  */
-              obp = op->bufp;
-              RECACHE;
-              break;
-            }
-hashcollision:
-            ;
-          }                     /* End hash-table-search loop */
-        }
-        ident_length = hash = 0; /* Stop collecting identifier */
-        redo_char = 0;
-        concatenated = 0;
-      }                         /* End if (ident_length > 0) */
-    }                           /* End switch */
-  }                             /* End per-char loop */
-
-  /* Come here to return -- but first give an error message
-     if there was an unterminated successful conditional.  */
- ending:
-  if (if_stack != ip->if_stack)
-    {
-      char *str;
-
-      switch (if_stack->type)
-        {
-        case T_IF:
-          str = "if";
-          break;
-        case T_IFDEF:
-          str = "ifdef";
-          break;
-        case T_IFNDEF:
-          str = "ifndef";
-          break;
-        case T_ELSE:
-          str = "else";
-          break;
-        case T_ELIF:
-          str = "elif";
-          break;
-        default:
-          abort ();
-        }
-
-      error_with_line (line_for_error (if_stack->lineno),
-                       "unterminated `#%s' conditional", str);
-  }
-  if_stack = ip->if_stack;
-}
-
-/*
- * Rescan a string into a temporary buffer and return the result
- * as a FILE_BUF.  Note this function returns a struct, not a pointer.
- *
- * OUTPUT_MARKS nonzero means keep Newline markers found in the input
- * and insert such markers when appropriate.  See `rescan' for details.
- * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
- * before substitution; it is 0 for other uses.
- */
-static FILE_BUF
-expand_to_temp_buffer (buf, limit, output_marks, assertions)
-     U_CHAR *buf, *limit;
-     int output_marks, assertions;
-{
-  register FILE_BUF *ip;
-  FILE_BUF obuf;
-  int length = limit - buf;
-  U_CHAR *buf1;
-  int odepth = indepth;
-  int save_assertions_flag = assertions_flag;
-
-  assertions_flag = assertions;
-
-  if (length < 0)
-    abort ();
-
-  /* Set up the input on the input stack.  */
-
-  buf1 = (U_CHAR *) alloca (length + 1);
-  {
-    register U_CHAR *p1 = buf;
-    register U_CHAR *p2 = buf1;
-
-    while (p1 != limit)
-      *p2++ = *p1++;
-  }
-  buf1[length] = 0;
-
-  /* Set up to receive the output.  */
-
-  obuf.length = length * 2 + 100; /* Usually enough.  Why be stingy?  */
-  obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
-  obuf.fname = 0;
-  obuf.macro = 0;
-  obuf.free_ptr = 0;
-
-  CHECK_DEPTH ({return obuf;});
-
-  ++indepth;
-
-  ip = &instack[indepth];
-  ip->fname = 0;
-  ip->nominal_fname = 0;
-  ip->inc = 0;
-  ip->system_header_p = 0;
-  ip->macro = 0;
-  ip->free_ptr = 0;
-  ip->length = length;
-  ip->buf = ip->bufp = buf1;
-  ip->if_stack = if_stack;
-
-  ip->lineno = obuf.lineno = 1;
-
-  /* Scan the input, create the output.  */
-  rescan (&obuf, output_marks);
-
-  /* Pop input stack to original state.  */
-  --indepth;
-
-  if (indepth != odepth)
-    abort ();
-
-  /* Record the output.  */
-  obuf.length = obuf.bufp - obuf.buf;
-
-  assertions_flag = save_assertions_flag;
-  return obuf;
-}
-
-/*
- * Process a # directive.  Expects IP->bufp to point after the '#', as in
- * `#define foo bar'.  Passes to the directive handler
- * (do_define, do_include, etc.): the addresses of the 1st and
- * last chars of the directive (starting immediately after the #
- * keyword), plus op and the keyword table pointer.  If the directive
- * contains comments it is copied into a temporary buffer sans comments
- * and the temporary buffer is passed to the directive handler instead.
- * Likewise for backslash-newlines.
- *
- * Returns nonzero if this was a known # directive.
- * Otherwise, returns zero, without advancing the input pointer.
- */
-
-static int
-handle_directive (ip, op)
-     FILE_BUF *ip, *op;
-{
-  register U_CHAR *bp, *cp;
-  register struct directive *kt;
-  register int ident_length;
-  U_CHAR *resume_p;
-
-  /* Nonzero means we must copy the entire directive
-     to get rid of comments or backslash-newlines.  */
-  int copy_directive = 0;
-
-  U_CHAR *ident, *after_ident;
-
-  bp = ip->bufp;
-
-  /* Record where the directive started.  do_xifdef needs this.  */
-  directive_start = bp - 1;
-
-  /* Skip whitespace and \-newline.  */
-  while (1) {
-    if (is_hor_space[*bp]) {
-      if (*bp != ' ' && *bp != '\t' && pedantic)
-        pedwarn ("%s in preprocessing directive", char_name[*bp]);
-      bp++;
-    } else if (*bp == '/') {
-      if (bp[1] == '\\' && bp[2] == '\n')
-        newline_fix (bp + 1);
-      if (! (bp[1] == '*' || (cplusplus_comments && bp[1] == '/')))
-        break;
-      ip->bufp = bp + 2;
-      skip_to_end_of_comment (ip, &ip->lineno, 0);
-      bp = ip->bufp;
-    } else if (*bp == '\\' && bp[1] == '\n') {
-      bp += 2; ip->lineno++;
-    } else break;
-  }
-
-  /* Now find end of directive name.
-     If we encounter a backslash-newline, exchange it with any following
-     symbol-constituents so that we end up with a contiguous name.  */
-
-  cp = bp;
-  while (1) {
-    if (is_idchar[*cp])
-      cp++;
-    else {
-      if (*cp == '\\' && cp[1] == '\n')
-        name_newline_fix (cp);
-      if (is_idchar[*cp])
-        cp++;
-      else break;
-    }
-  }
-  ident_length = cp - bp;
-  ident = bp;
-  after_ident = cp;
-
-  /* A line of just `#' becomes blank.  */
-
-  if (ident_length == 0 && *after_ident == '\n') {
-    ip->bufp = after_ident;
-    return 1;
-  }
-
-  if (ident_length == 0 || !is_idstart[*ident]) {
-    U_CHAR *p = ident;
-    while (is_idchar[*p]) {
-      if (*p < '0' || *p > '9')
-        break;
-      p++;
-    }
-    /* Handle # followed by a line number.  */
-    if (p != ident && !is_idchar[*p]) {
-      static struct directive line_directive_table[] = {
-        {  4, do_line, "line", T_LINE},
-      };
-      if (pedantic)
-        pedwarn ("`#' followed by integer");
-      after_ident = ident;
-      kt = line_directive_table;
-      goto old_linenum;
-    }
-
-    /* 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)
-          warning ("invalid preprocessing directive");
-        return 0;
-      }
-    }
-
-    if (!lang_asm)
-      error ("invalid preprocessing directive name");
-
-    return 0;
-  }
-
-  /*
-   * Decode the keyword and call the appropriate expansion
-   * routine, after moving the input pointer up to the next line.
-   */
-  for (kt = directive_table; kt->length > 0; kt++) {
-    if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
-      register U_CHAR *buf;
-      register U_CHAR *limit;
-      int unterminated;
-      int junk;
-      int *already_output;
-
-      /* Nonzero means do not delete comments within the directive.
-         #define needs this when -traditional.  */
-      int keep_comments;
-
-    old_linenum:
-
-      limit = ip->buf + ip->length;
-      unterminated = 0;
-      already_output = 0;
-      keep_comments = traditional && kt->type == T_DEFINE;
-      /* #import is defined only in Objective C, or when on the NeXT.  */
-      if (kt->type == T_IMPORT
-          && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
-        break;
-
-      /* Find the end of this directive (first newline not backslashed
-         and not in a string or comment).
-         Set COPY_DIRECTIVE if the directive must be copied
-         (it contains a backslash-newline or a comment).  */
-
-      buf = bp = after_ident;
-      while (bp < limit) {
-        register U_CHAR c = *bp++;
-        switch (c) {
-        case '\\':
-          if (bp < limit) {
-            if (*bp == '\n') {
-              ip->lineno++;
-              copy_directive = 1;
-              bp++;
-            } else if (traditional)
-              bp++;
-          }
-          break;
-
-        case '"':
-          /* "..." is special for #include.  */
-          if (IS_INCLUDE_DIRECTIVE_TYPE (kt->type)) {
-            while (bp < limit && *bp != '\n') {
-              if (*bp == '"') {
-                bp++;
-                break;
-              }
-              if (*bp == '\\' && bp[1] == '\n') {
-                ip->lineno++;
-                copy_directive = 1;
-                bp++;
-              }
-              bp++;
-            }
-            break;
-          }
-          /* Fall through.  */
-        case '\'':
-          bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, &copy_directive, &unterminated);
-          /* Don't bother calling the directive if we already got an error
-             message due to unterminated string.  Skip everything and pretend
-             we called the directive.  */
-          if (unterminated) {
-            if (traditional) {
-              /* Traditional preprocessing permits unterminated strings.  */
-              ip->bufp = bp;
-              goto endloop1;
-            }
-            ip->bufp = bp;
-            return 1;
-          }
-          break;
-
-          /* <...> is special for #include.  */
-        case '<':
-          if (! IS_INCLUDE_DIRECTIVE_TYPE (kt->type))
-            break;
-          while (bp < limit && *bp != '>' && *bp != '\n') {
-            if (*bp == '\\' && bp[1] == '\n') {
-              ip->lineno++;
-              copy_directive = 1;
-              bp++;
-            }
-            bp++;
-          }
-          break;
-
-        case '/':
-          if (*bp == '\\' && bp[1] == '\n')
-            newline_fix (bp);
-          if (*bp == '*'
-              || (cplusplus_comments && *bp == '/')) {
-            U_CHAR *obp = bp - 1;
-            ip->bufp = bp + 1;
-            skip_to_end_of_comment (ip, &ip->lineno, 0);
-            bp = ip->bufp;
-            /* No need to copy the directive because of a comment at the end;
-               just don't include the comment in the directive.  */
-            if (!put_out_comments) {
-              U_CHAR *p;
-              for (p = bp;  *p == ' ' || *p == '\t';  p++)
-                continue;
-              if (*p == '\n') {
-                bp = obp;
-                goto endloop1;
-              }
-            }
-            /* Don't remove the comments if -traditional.  */
-            if (! keep_comments)
-              copy_directive++;
-          }
-          break;
-
-        case '\f':
-        case '\r':
-        case '\v':
-          if (pedantic)
-            pedwarn ("%s in preprocessing directive", char_name[c]);
-          break;
-
-        case '\n':
-          --bp;         /* Point to the newline */
-          ip->bufp = bp;
-          goto endloop1;
-        }
-      }
-      ip->bufp = bp;
-
-    endloop1:
-      resume_p = ip->bufp;
-      /* BP is the end of the directive.
-         RESUME_P is the next interesting data after the directive.
-         A comment may come between.  */
-
-      /* If a directive should be copied through, and -C was given,
-         pass it through before removing comments.  */
-      if (!no_output && put_out_comments
-          && (kt->type == T_DEFINE ? dump_macros == dump_definitions
-              : IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
-              : kt->type == T_PRAGMA)) {
-        int len;
-
-        /* Output directive name.  */
-        check_expand (op, kt->length + 2);
-        /* Make sure # is at the start of a line */
-        if (op->bufp > op->buf && op->bufp[-1] != '\n') {
-          op->lineno++;
-          *op->bufp++ = '\n';
-        }
-        *op->bufp++ = '#';
-        bcopy (kt->name, op->bufp, kt->length);
-        op->bufp += kt->length;
-
-        /* Output arguments.  */
-        len = (bp - buf);
-        check_expand (op, len);
-        bcopy (buf, (char *) op->bufp, len);
-        op->bufp += len;
-        /* Take account of any (escaped) newlines just output.  */
-        while (--len >= 0)
-          if (buf[len] == '\n')
-            op->lineno++;
-
-        already_output = &junk;
-      }                         /* Don't we need a newline or #line? */
-
-      if (copy_directive) {
-        register U_CHAR *xp = buf;
-        /* Need to copy entire directive into temp buffer before dispatching */
-
-        cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
-                                                  some slop */
-        buf = cp;
-
-        /* Copy to the new buffer, deleting comments
-           and backslash-newlines (and whitespace surrounding the latter).  */
-
-        while (xp < bp) {
-          register U_CHAR c = *xp++;
-          *cp++ = c;
-
-          switch (c) {
-          case '\n':
-            abort ();  /* A bare newline should never part of the line.  */
-            break;
-
-            /* <...> is special for #include.  */
-          case '<':
-            if (! IS_INCLUDE_DIRECTIVE_TYPE (kt->type))
-              break;
-            while (xp < bp && c != '>') {
-              c = *xp++;
-              if (c == '\\' && xp < bp && *xp == '\n')
-                xp++;
-              else
-                *cp++ = c;
-            }
-            break;
-
-          case '\\':
-            if (*xp == '\n') {
-              xp++;
-              cp--;
-              if (cp != buf && is_hor_space[cp[-1]]) {
-                while (cp - 1 != buf && is_hor_space[cp[-2]])
-                  cp--;
-                SKIP_WHITE_SPACE (xp);
-              } else if (is_hor_space[*xp]) {
-                *cp++ = *xp++;
-                SKIP_WHITE_SPACE (xp);
-              }
-            } else if (traditional && xp < bp) {
-              *cp++ = *xp++;
-            }
-            break;
-
-          case '\'':
-          case '\"':
-            {
-              register U_CHAR *bp1
-                = skip_quoted_string (xp - 1, bp, ip->lineno,
-                                      NULL_PTR, NULL_PTR, NULL_PTR);
-              while (xp != bp1)
-                *cp++ = *xp++;
-            }
-            break;
-
-          case '/':
-            if (*xp == '*'
-                || (cplusplus_comments && *xp == '/')) {
-              ip->bufp = xp + 1;
-              /* If we already copied the directive through,
-                 already_output != 0 prevents outputting comment now.  */
-              skip_to_end_of_comment (ip, already_output, 0);
-              if (keep_comments)
-                while (xp != ip->bufp)
-                  *cp++ = *xp++;
-              /* Delete or replace the slash.  */
-              else if (traditional)
-                cp--;
-              else
-                cp[-1] = ' ';
-              xp = ip->bufp;
-            }
-          }
-        }
-
-        /* Null-terminate the copy.  */
-
-        *cp = 0;
-      } else
-        cp = bp;
-
-      ip->bufp = resume_p;
-
-      /* Some directives should be written out for cc1 to process,
-         just as if they were not defined.  And sometimes we're copying
-         directives through.  */
-
-      if (!no_output && already_output == 0
-          && (kt->type == T_DEFINE ? (int) dump_names <= (int) dump_macros
-              : IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
-              : kt->type == T_PRAGMA)) {
-        int len;
-
-        /* Output directive name.  */
-        check_expand (op, kt->length + 1);
-        *op->bufp++ = '#';
-        bcopy (kt->name, (char *) op->bufp, kt->length);
-        op->bufp += kt->length;
-
-        if (kt->type == T_DEFINE && dump_macros == dump_names) {
-          /* Output `#define name' only.  */
-          U_CHAR *xp = buf;
-          U_CHAR *yp;
-          SKIP_WHITE_SPACE (xp);
-          yp = xp;
-          while (is_idchar[*xp]) xp++;
-          len = (xp - yp);
-          check_expand (op, len + 1);
-          *op->bufp++ = ' ';
-          bcopy (yp, (char *) op->bufp, len);
-        } else {
-          /* Output entire directive.  */
-          len = (cp - buf);
-          check_expand (op, len);
-          bcopy (buf, (char *) op->bufp, len);
-        }
-        op->bufp += len;
-      }                         /* Don't we need a newline or #line? */
-
-      /* Call the appropriate directive handler.  buf now points to
-         either the appropriate place in the input buffer, or to
-         the temp buffer if it was necessary to make one.  cp
-         points to the first char after the contents of the (possibly
-         copied) directive, in either case.  */
-      (*kt->func) (buf, cp, op, kt);
-      check_expand (op, ip->length - (ip->bufp - ip->buf));
-
-      return 1;
-    }
-  }
-
-  /* It is deliberate that we don't warn about undefined directives.
-     That is the responsibility of cc1.  */
-  return 0;
-}
-
-static struct tm *
-timestamp ()
-{
-  static struct tm *timebuf;
-  if (!timebuf) {
-    time_t t = time ((time_t *) 0);
-    timebuf = localtime (&t);
-  }
-  return timebuf;
-}
-
-static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-                             "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
-                            };
-
-/*
- * expand things like __FILE__.  Place the expansion into the output
- * buffer *without* rescanning.
- */
-
-static void
-special_symbol (hp, op)
-     HASHNODE *hp;
-     FILE_BUF *op;
-{
-  char *buf;
-  int i, len;
-  int true_indepth;
-  FILE_BUF *ip = NULL;
-  struct tm *timebuf;
-
-  int paren = 0;                /* For special `defined' keyword */
-
-  if (pcp_outfile && pcp_inside_if
-      && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
-    error ("Predefined macro `%s' used inside `#if' during precompilation",
-           hp->name);
-    
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-  if (ip == NULL) {
-    error ("cccp error: not in any file?!");
-    return;                     /* the show must go on */
-  }
-
-  switch (hp->type) {
-  case T_FILE:
-  case T_BASE_FILE:
-    {
-      char *string;
-      if (hp->type == T_FILE)
-        string = ip->nominal_fname;
-      else
-        string = instack[0].nominal_fname;
-
-      if (string)
-        {
-          buf = (char *) alloca (3 + 4 * strlen (string));
-          quote_string (buf, string);
-        }
-      else
-        buf = "\"\"";
-
-      break;
-    }
-
-  case T_INCLUDE_LEVEL:
-    true_indepth = 0;
-    for (i = indepth; i >= 0; i--)
-      if (instack[i].fname != NULL)
-        true_indepth++;
-
-    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;
-
-#ifndef NO_BUILTIN_SIZE_TYPE
-  case T_SIZE_TYPE:
-    buf = SIZE_TYPE;
-    break;
-#endif
-
-#ifndef NO_BUILTIN_PTRDIFF_TYPE
-  case T_PTRDIFF_TYPE:
-    buf = PTRDIFF_TYPE;
-    break;
-#endif
-
-  case T_WCHAR_TYPE:
-    buf = wchar_type;
-    break;
-
-  case T_USER_LABEL_PREFIX_TYPE:
-    buf = USER_LABEL_PREFIX;
-    break;
-
-  case T_REGISTER_PREFIX_TYPE:
-    buf = REGISTER_PREFIX;
-    break;
-
-  case T_IMMEDIATE_PREFIX_TYPE:
-    buf = IMMEDIATE_PREFIX;
-    break;
-
-  case T_CONST:
-    buf = hp->value.cpval;
-#ifdef STDC_0_IN_SYSTEM_HEADERS
-    if (ip->system_header_p
-        && hp->length == 8 && bcmp (hp->name, "__STDC__", 8) == 0
-        && !lookup ((U_CHAR *) "__STRICT_ANSI__", -1, -1))
-      buf = "0";
-#endif
-    if (pcp_inside_if && pcp_outfile)
-      /* Output a precondition for this macro use */
-      fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
-    break;
-
-  case T_SPECLINE:
-    buf = (char *) alloca (10);
-    sprintf (buf, "%d", ip->lineno);
-    break;
-
-  case T_DATE:
-  case T_TIME:
-    buf = (char *) alloca (20);
-    timebuf = timestamp ();
-    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 = &instack[indepth];
-    SKIP_WHITE_SPACE (ip->bufp);
-    if (*ip->bufp == '(') {
-      paren++;
-      ip->bufp++;                       /* Skip over the paren */
-      SKIP_WHITE_SPACE (ip->bufp);
-    }
-
-    if (!is_idstart[*ip->bufp])
-      goto oops;
-    if (ip->bufp[0] == 'L' && (ip->bufp[1] == '\'' || ip->bufp[1] == '"'))
-      goto oops;
-    if ((hp = lookup (ip->bufp, -1, -1))) {
-      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);
-      buf = " 1 ";
-    }
-    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);
-      }
-    while (is_idchar[*ip->bufp])
-      ++ip->bufp;
-    SKIP_WHITE_SPACE (ip->bufp);
-    if (paren) {
-      if (*ip->bufp != ')')
-        goto oops;
-      ++ip->bufp;
-    }
-    break;
-
-oops:
-
-    error ("`defined' without an identifier");
-    break;
-
-  default:
-    error ("cccp error: invalid special hash type"); /* time for gdb */
-    abort ();
-  }
-  len = strlen (buf);
-  check_expand (op, len);
-  bcopy (buf, (char *) op->bufp, len);
-  op->bufp += len;
-
-  return;
-}
-
-
-/* Routines to handle #directives */
-
-/* Handle #include and #import.
-   This function expects to see "fname" or <fname> on the input.  */
-
-static int
-do_include (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
-  int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
-  static int import_warning = 0;
-  char *fname;          /* Dynamically allocated fname buffer */
-  char *pcftry;
-  char *pcfname;
-  char *fbeg, *fend;            /* Beginning and end of fname */
-  U_CHAR *fin;
-
-  struct file_name_list *search_start = include; /* Chain of dirs to search */
-  struct file_name_list *dsp;   /* First in chain, if #include "..." */
-  struct file_name_list *searchptr = 0;
-  size_t flen;
-
-  int f = -3;                   /* file number */
-  struct include_file *inc = 0;
-
-  int retried = 0;              /* Have already tried macro
-                                   expanding the include line*/
-  int angle_brackets = 0;       /* 0 for "...", 1 for <...> */
-#ifdef VMS
-  int vaxc_include = 0;         /* 1 for token without punctuation */
-#endif
-  int pcf = -1;
-  char *pcfbuf;
-  char *pcfbuflimit;
-  int pcfnum;
-
-  if (pedantic && !instack[indepth].system_header_p)
-    {
-      if (importing)
-        pedwarn ("ANSI C does not allow `#import'");
-      if (skip_dirs)
-        pedwarn ("ANSI C does not allow `#include_next'");
-    }
-
-  if (importing && warn_import && !inhibit_warnings
-      && !instack[indepth].system_header_p && !import_warning) {
-    import_warning = 1;
-    warning ("using `#import' is not recommended");
-    fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
-    fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
-    fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
-    fprintf (stderr, "  #ifndef _FOO_H_INCLUDED\n");
-    fprintf (stderr, "  #define _FOO_H_INCLUDED\n");
-    fprintf (stderr, "  ... <real contents of file> ...\n");
-    fprintf (stderr, "  #endif /* Not _FOO_H_INCLUDED */\n\n");
-    fprintf (stderr, "Then users can use `#include' any number of times.\n");
-    fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
-    fprintf (stderr, "when it is equipped with such a conditional.\n");
-  }
-
-get_filename:
-
-  fin = buf;
-  SKIP_WHITE_SPACE (fin);
-  /* Discard trailing whitespace so we can easily see
-     if we have parsed all the significant chars we were given.  */
-  while (limit != fin && is_hor_space[limit[-1]]) limit--;
-  fbeg = fend = (char *) alloca (limit - fin);
-
-  switch (*fin++) {
-  case '\"':
-    {
-      FILE_BUF *fp;
-      /* Copy the operand text, concatenating the strings.  */
-      {
-        for (;;) {
-          for (;;) {
-            if (fin == limit)
-              goto invalid_include_file_name;
-            *fend = *fin++;
-            if (*fend == '"')
-              break;
-            fend++;
-          }
-          if (fin == limit)
-            break;
-          /* If not at the end, there had better be another string.  */
-          /* Skip just horiz space, and don't go past limit.  */
-          while (fin != limit && is_hor_space[*fin]) fin++;
-          if (fin != limit && *fin == '\"')
-            fin++;
-          else
-            goto fail;
-        }
-      }
-
-      /* We have "filename".  Figure out directory this source
-         file is coming from and put it on the front of the list.  */
-
-      /* If -I- was specified, don't search current dir, only spec'd ones.  */
-      if (ignore_srcdir) break;
-
-      for (fp = &instack[indepth]; fp >= instack; fp--)
-        {
-          int n;
-          char *nam;
-
-          if ((nam = fp->nominal_fname) != NULL) {
-            /* Found a named file.  Figure out dir of the file,
-               and put it in front of the search list.  */
-            dsp = ((struct file_name_list *)
-                   alloca (sizeof (struct file_name_list) + strlen (nam)));
-            strcpy (dsp->fname, nam);
-            simplify_filename (dsp->fname);
-            nam = base_name (dsp->fname);
-            *nam = 0;
-            /* But for efficiency's sake, do not insert the dir
-               if it matches the search list's first dir.  */
-            dsp->next = search_start;
-            if (!search_start || strcmp (dsp->fname, search_start->fname)) {
-              search_start = dsp;
-              n = nam - dsp->fname;
-              if (n + INCLUDE_LEN_FUDGE > max_include_len)
-                max_include_len = n + INCLUDE_LEN_FUDGE;
-            }
-            dsp[0].got_name_map = 0;
-            break;
-          }
-        }
-      break;
-    }
-
-  case '<':
-    while (fin != limit && *fin != '>')
-      *fend++ = *fin++;
-    if (*fin == '>' && fin + 1 == limit) {
-      angle_brackets = 1;
-      /* If -I-, start with the first -I dir after the -I-.  */
-      search_start = first_bracket_include;
-      break;
-    }
-    goto fail;
-
-  default:
-#ifdef VMS
-    /*
-     * Support '#include xyz' like VAX-C to allow for easy use of all the
-     * decwindow include files. It defaults to '#include <xyz.h>' (so the
-     * code from case '<' is repeated here) and generates a warning.
-     * (Note: macro expansion of `xyz' takes precedence.)
-     */
-    if (retried && isalpha(*(U_CHAR *) (--fbeg))) {
-      while (fin != limit && (!isspace(*fin)))
-        *fend++ = *fin++;
-      warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
-      vaxc_include = 1;
-      if (fin == limit) {
-        angle_brackets = 1;
-        /* If -I-, start with the first -I dir after the -I-.  */
-        search_start = first_bracket_include;
-        break;
-      }
-    }
-#endif
-
-  fail:
-    if (! retried) {
-      /* Expand buffer and then remove any newline markers.
-         We can't just tell expand_to_temp_buffer to omit the markers,
-         since it would put extra spaces in include file names.  */
-      FILE_BUF trybuf;
-      U_CHAR *src;
-      int errors_before_expansion = errors;
-      trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
-      if (errors != errors_before_expansion) {
-        free (trybuf.buf);
-        goto invalid_include_file_name;
-      }
-      src = trybuf.buf;
-      buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
-      limit = buf;
-      while (src != trybuf.bufp) {
-        switch ((*limit++ = *src++)) {
-          case '\n':
-            limit--;
-            src++;
-            break;
-
-          case '\'':
-          case '\"':
-            {
-              U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
-                                                 NULL_PTR, NULL_PTR, NULL_PTR);
-              while (src != src1)
-                *limit++ = *src++;
-            }
-            break;
-        }
-      }
-      *limit = 0;
-      free (trybuf.buf);
-      retried = 1;
-      goto get_filename;
-    }
-
-  invalid_include_file_name:
-    error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
-    return 0;
-  }
-
-  /* For #include_next, skip in the search path
-     past the dir in which the containing file was found.  */
-  if (skip_dirs) {
-    FILE_BUF *fp;
-    for (fp = &instack[indepth]; fp >= instack; fp--)
-      if (fp->fname != NULL) {
-        /* fp->dir is null if the containing file was specified
-           with an absolute file name.  In that case, don't skip anything.  */
-        if (fp->dir)
-          search_start = fp->dir->next;
-        break;
-      }
-  }
-
-  *fend = 0;
-  flen = simplify_filename (fbeg);
-
-  if (flen == 0)
-    {
-      error ("empty file name in `#%s'", keyword->name);
-      return 0;
-    }
-
-  /* Allocate this permanently, because it gets stored in the definitions
-     of macros.  */
-  fname = xmalloc (max_include_len + flen + 1);
-  /* + 1 above for terminating null.  */
-
-  system_include_depth += angle_brackets;
-
-  /* If specified file name is absolute, just open it.  */
-
-  if (absolute_filename (fbeg)) {
-    strcpy (fname, fbeg);
-    f = open_include_file (fname, NULL_PTR, importing, &inc);
-  } else {
-
-    struct bypass_dir {
-      struct bypass_dir *next;
-      char *fname;
-      struct file_name_list *searchptr;
-    } **bypass_slot = 0;
-
-    /* Search directory path, trying to open the file.
-       Copy each filename tried into FNAME.  */
-
-    for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
-
-      if (searchptr == first_bracket_include) {
-        /* Go to bypass directory if we know we've seen this file before.  */
-        static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
-        struct bypass_dir *p;
-        bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
-                                             INCLUDE_HASHSIZE)];
-        for (p = *bypass_slot; p; p = p->next)
-          if (!strcmp (fbeg, p->fname)) {
-            searchptr = p->searchptr;
-            bypass_slot = 0;
-            break;
-          }
-      }
-
-      strcpy (fname, searchptr->fname);
-      strcat (fname, fbeg);
-#ifdef VMS
-      /* Change this 1/2 Unix 1/2 VMS file specification into a
-         full VMS file specification */
-      if (searchptr->fname[0]) {
-        /* Fix up the filename */
-        hack_vms_include_specification (fname, vaxc_include);
-      } else {
-        /* This is a normal VMS filespec, so use it unchanged.  */
-        strcpy (fname, fbeg);
-        /* if it's '#include filename', add the missing .h */
-        if (vaxc_include && index(fname,'.')==NULL) {
-          strcat (fname, ".h");
-        }
-      }
-#endif /* VMS */
-      f = open_include_file (fname, searchptr, importing, &inc);
-      if (f != -1) {
-        if (bypass_slot && searchptr != first_bracket_include) {
-          /* This is the first time we found this include file,
-             and we found it after first_bracket_include.
-             Record its location so that we can bypass to here next time.  */
-          struct bypass_dir *p
-            = (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
-          p->next = *bypass_slot;
-          p->fname = fname + strlen (searchptr->fname);
-          p->searchptr = searchptr;
-          *bypass_slot = p;
-        }
-        break;
-      }
-#ifdef VMS
-      /* Our VMS hacks can produce invalid filespecs, so don't worry
-         about errors other than EACCES.  */
-      if (errno == EACCES)
-        break;
-#else
-      if (errno != ENOENT && errno != ENOTDIR)
-        break;
-#endif
-    }
-  }
-
-
-  if (f < 0) {
-
-    if (f == -2) {
-      /* The file was already included.  */
-
-    /* If generating dependencies and -MG was specified, we assume missing
-       files are leaf files, living in the same directory as the source file
-       or other similar place; these missing files may be generated from
-       other files and may not exist yet (eg: y.tab.h).  */
-    } else if (print_deps_missing_files
-               && (system_include_depth != 0) < print_deps)
-      {
-        /* If it was requested as a system header file,
-           then assume it belongs in the first place to look for such.  */
-        if (angle_brackets)
-          {
-            if (search_start) {
-              char *p = (char *) alloca (strlen (search_start->fname)
-                                         + strlen (fbeg) + 1);
-              strcpy (p, search_start->fname);
-              strcat (p, fbeg);
-              deps_output (p, ' ');
-            }
-          }
-        else
-          {
-            /* Otherwise, omit the directory, as if the file existed
-               in the directory with the source.  */
-            deps_output (fbeg, ' ');
-          }
-      }
-    /* 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 (0 < print_deps  &&  print_deps <= (system_include_depth != 0))
-      warning ("No include path in which to find %s", fbeg);
-    else if (f != -3)
-      error_from_errno (fbeg);
-    else
-      error ("No include path in which to find %s", fbeg);
-
-  } else {
-
-    /* Actually process the file.  */
-
-    pcftry = (char *) alloca (strlen (fname) + 30);
-    pcfbuf = 0;
-    pcfnum = 0;
-
-    if (!no_precomp)
-      {
-        do {
-          sprintf (pcftry, "%s%d", fname, pcfnum++);
-
-          pcf = open (pcftry, O_RDONLY, 0666);
-          if (pcf != -1)
-            {
-              struct stat s;
-
-              if (fstat (pcf, &s) != 0)
-                pfatal_with_name (pcftry);
-              if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
-                  || inc->st.st_dev != s.st_dev)
-                {
-                  pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
-                  /* Don't need it any more.  */
-                  close (pcf);
-                }
-              else
-                {
-                  /* Don't need it at all.  */
-                  close (pcf);
-                  break;
-                }
-            }
-        } while (pcf != -1 && !pcfbuf);
-      }
-    
-    /* Actually process the file */
-    if (pcfbuf) {
-      pcfname = xmalloc (strlen (pcftry) + 1);
-      strcpy (pcfname, pcftry);
-      pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
-                  (U_CHAR *) fname, op);
-    }
-    else
-      finclude (f, inc, op, is_system_include (fname), searchptr);
-  }
-
-  system_include_depth -= angle_brackets;
-
-  return 0;
-}
-
-/* Return nonzero if the given FILENAME is an absolute pathname which
-   designates a file within one of the known "system" include file
-   directories.  We assume here that if the given FILENAME looks like
-   it is the name of a file which resides either directly in a "system"
-   include file directory, or within any subdirectory thereof, then the
-   given file must be a "system" include file.  This function tells us
-   if we should suppress pedantic errors/warnings for the given FILENAME.
-
-   The value is 2 if the file is a C-language system header file
-   for which C++ should (on most systems) assume `extern "C"'.  */
-
-static int
-is_system_include (filename)
-    register char *filename;
-{
-  struct file_name_list *searchptr;
-
-  for (searchptr = first_system_include; searchptr;
-       searchptr = searchptr->next)
-    if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
-      return searchptr->c_system_include_path + 1;
-  return 0;
-}
-
-/* Yield the non-directory suffix of a file name.  */
-
-static char *
-base_name (fname)
-     char *fname;
-{
-  char *s = fname;
-  char *p;
-#if defined (__MSDOS__) || defined (_WIN32)
-  if (isalpha (s[0]) && s[1] == ':') s += 2;
-#endif
-#ifdef VMS
-  if ((p = rindex (s, ':'))) s = p + 1; /* Skip device.  */
-  if ((p = rindex (s, ']'))) s = p + 1; /* Skip directory.  */
-  if ((p = rindex (s, '>'))) s = p + 1; /* Skip alternate (int'n'l) dir.  */
-  if (s != fname)
-    return s;
-#endif
-  if ((p = (char*) rindex (s, '/'))) s = p + 1;
-#ifdef DIR_SEPARATOR
-  if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
-#endif
-  return s;
-}
-
-/* Yield nonzero if FILENAME is absolute (i.e. not relative).  */
-
-static int
-absolute_filename (filename)
-     char *filename;
-{
-#if defined (__MSDOS__) || (defined (_WIN32) && !defined (__CYGWIN32__))
-  if (isalpha (filename[0]) && filename[1] == ':') filename += 2;
-#endif
-#if defined (__CYGWIN32__)
-  /* At present, any path that begins with a drive spec is absolute.  */
-  if (isalpha (filename[0]) && filename[1] == ':') return 1;
-#endif
-  if (filename[0] == '/') return 1;
-#ifdef DIR_SEPARATOR
-  if (filename[0] == DIR_SEPARATOR) return 1;
-#endif
-  return 0;
-}
-
-/* Remove unnecessary characters from FILENAME in place,
-   to avoid unnecessary filename aliasing.
-   Return the length of the resulting string.
-
-   Do only the simplifications allowed by Posix.
-   It is OK to miss simplifications on non-Posix hosts,
-   since this merely leads to suboptimal results.  */
-
-static size_t
-simplify_filename (filename)
-     char *filename;
-{
-  register char *from = filename;
-  register char *to = filename;
-  char *to0;
-
-  /* Remove redundant initial /s.  */
-  if (*from == '/') {
-    *to++ = '/';
-    if (*++from == '/') {
-      if (*++from == '/') {
-        /* 3 or more initial /s are equivalent to 1 /.  */
-        while (*++from == '/')
-          continue;
-      } else {
-        /* On some hosts // differs from /; Posix allows this.  */
-        static int slashslash_vs_slash;
-        if (slashslash_vs_slash == 0) {
-          struct stat s1, s2;
-          slashslash_vs_slash = ((stat ("/", &s1) == 0 && stat ("//", &s2) == 0
-                                  && INO_T_EQ (s1.st_ino, s2.st_ino)
-                                  && s1.st_dev == s2.st_dev)
-                                 ? 1 : -1);
-        }
-        if (slashslash_vs_slash < 0)
-          *to++ = '/';
-      }
-    }
-  }
-  to0 = to;
-
-  for (;;) {
-    if (from[0] == '.' && from[1] == '/')
-      from += 2;
-    else {
-      /* Copy this component and trailing /, if any.  */
-      while ((*to++ = *from++) != '/') {
-        if (!to[-1]) {
-          /* Trim . component at end of nonempty name.  */
-          to -= filename <= to - 3 && to[-3] == '/' && to[-2] == '.';
-
-          /* Trim unnecessary trailing /s.  */
-          while (to0 < --to && to[-1] == '/')
-            continue;
-
-          *to = 0;
-          return to - filename;
-        }
-      }
-    }
-
-    /* Skip /s after a /.  */
-    while (*from == '/')
-      from++;
-  }
-}
-
-/* The file_name_map structure holds a mapping of file names for a
-   particular directory.  This mapping is read from the file named
-   FILE_NAME_MAP_FILE in that directory.  Such a file can be used to
-   map filenames on a file system with severe filename restrictions,
-   such as DOS.  The format of the file name map file is just a series
-   of lines with two tokens on each line.  The first token is the name
-   to map, and the second token is the actual name to use.  */
-
-struct file_name_map
-{
-  struct file_name_map *map_next;
-  char *map_from;
-  char *map_to;
-};
-
-#define FILE_NAME_MAP_FILE "header.gcc"
-
-/* Read a space delimited string of unlimited length from a stdio
-   file.  */
-
-static char *
-read_filename_string (ch, f)
-     int ch;
-     FILE *f;
-{
-  char *alloc, *set;
-  int len;
-
-  len = 20;
-  set = alloc = xmalloc (len + 1);
-  if (! is_space[ch])
-    {
-      *set++ = ch;
-      while ((ch = getc (f)) != EOF && ! is_space[ch])
-        {
-          if (set - alloc == len)
-            {
-              len *= 2;
-              alloc = xrealloc (alloc, len + 1);
-              set = alloc + len / 2;
-            }
-          *set++ = ch;
-        }
-    }
-  *set = '\0';
-  ungetc (ch, f);
-  return alloc;
-}
-
-/* Read the file name map file for DIRNAME.
-   If DIRNAME is empty, read the map file for the working directory;
-   otherwise DIRNAME must end in '/'.  */
-
-static struct file_name_map *
-read_name_map (dirname)
-     char *dirname;
-{
-  /* This structure holds a linked list of file name maps, one per
-     directory.  */
-  struct file_name_map_list
-    {
-      struct file_name_map_list *map_list_next;
-      char *map_list_name;
-      struct file_name_map *map_list_map;
-    };
-  static struct file_name_map_list *map_list;
-  register struct file_name_map_list *map_list_ptr;
-  char *name;
-  FILE *f;
-  size_t dirlen;
-
-  for (map_list_ptr = map_list; map_list_ptr;
-       map_list_ptr = map_list_ptr->map_list_next)
-    if (! strcmp (map_list_ptr->map_list_name, dirname))
-      return map_list_ptr->map_list_map;
-
-  map_list_ptr = ((struct file_name_map_list *)
-                  xmalloc (sizeof (struct file_name_map_list)));
-  map_list_ptr->map_list_name = savestring (dirname);
-  map_list_ptr->map_list_map = NULL;
-
-  dirlen = strlen (dirname);
-  name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
-  strcpy (name, dirname);
-  strcat (name, FILE_NAME_MAP_FILE);
-  f = fopen (name, "r");
-  if (!f)
-    map_list_ptr->map_list_map = NULL;
-  else
-    {
-      int ch;
-
-      while ((ch = getc (f)) != EOF)
-        {
-          char *from, *to;
-          struct file_name_map *ptr;
-          size_t tolen;
-
-          if (is_space[ch])
-            continue;
-          from = read_filename_string (ch, f);
-          while ((ch = getc (f)) != EOF && is_hor_space[ch])
-            ;
-          to = read_filename_string (ch, f);
-
-          simplify_filename (from);
-          tolen = simplify_filename (to);
-
-          ptr = ((struct file_name_map *)
-                 xmalloc (sizeof (struct file_name_map)));
-          ptr->map_from = from;
-
-          /* Make the real filename absolute.  */
-          if (absolute_filename (to))
-            ptr->map_to = to;
-          else
-            {
-              ptr->map_to = xmalloc (dirlen + tolen + 1);
-              strcpy (ptr->map_to, dirname);
-              strcat (ptr->map_to, to);
-              free (to);
-            }         
-
-          ptr->map_next = map_list_ptr->map_list_map;
-          map_list_ptr->map_list_map = ptr;
-
-          while ((ch = getc (f)) != '\n')
-            if (ch == EOF)
-              break;
-        }
-      fclose (f);
-    }
-  
-  map_list_ptr->map_list_next = map_list;
-  map_list = map_list_ptr;
-
-  return map_list_ptr->map_list_map;
-}  
-
-/* Try to open include file FILENAME.  SEARCHPTR is the directory
-   being tried from the include file search path.
-   IMPORTING is "" if we are importing, null otherwise.
-   Return -2 if found, either a matching name or a matching inode.
-   Otherwise, open the file and return a file descriptor if successful
-   or -1 if unsuccessful.
-   Unless unsuccessful, put a descriptor of the included file into *PINC.
-   This function maps filenames on file systems based on information read by
-   read_name_map.  */
-
-static int
-open_include_file (filename, searchptr, importing, pinc)
-     char *filename;
-     struct file_name_list *searchptr;
-     U_CHAR *importing;
-     struct include_file **pinc;
-{
-  char *fname = remap ? remap_include_file (filename, searchptr) : filename;
-  int fd = -2;
-
-  /* Look up FNAME in include_hashtab.  */
-  struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
-                                                        strlen (fname),
-                                                        INCLUDE_HASHSIZE)];
-  struct include_file *inc, *head = *phead;
-  for (inc = head; inc; inc = inc->next)
-    if (!strcmp (fname, inc->fname))
-      break;
-
-  if (!inc
-      || ! inc->control_macro
-      || (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
-
-    fd = open (fname, O_RDONLY, 0);
-
-    if (fd < 0)
-      return fd;
-
-    if (!inc) {
-      /* FNAME was not in include_hashtab; insert a new entry.  */
-      inc = (struct include_file *) xmalloc (sizeof (struct include_file));
-      inc->next = head;
-      inc->fname = fname;
-      inc->control_macro = 0;
-      inc->deps_output = 0;
-      if (fstat (fd, &inc->st) != 0)
-        pfatal_with_name (fname);
-      *phead = inc;
-
-      /* Look for another file with the same inode and device.  */
-      if (lookup_ino_include (inc)
-          && inc->control_macro
-          && (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
-        close (fd);
-        fd = -2;
-      }
-    }
-
-    /* For -M, add this file to the dependencies.  */
-    if (! inc->deps_output  &&  (system_include_depth != 0) < print_deps) {
-      inc->deps_output = 1;
-      deps_output (fname, ' ');
-    }   
-
-    /* Handle -H option.  */
-    if (print_include_names)
-      fprintf (stderr, "%*s%s\n", indepth, "", fname);
-  }
-
-  if (importing)
-    inc->control_macro = importing;
-
-  *pinc = inc;
-  return fd;
-}
-
-/* Return the remapped name of the the include file FILENAME.
-   SEARCHPTR is the directory being tried from the include file path.  */
-
-static char *
-remap_include_file (filename, searchptr)
-     char *filename;
-     struct file_name_list *searchptr;
-{
-  register struct file_name_map *map;
-  register char *from;
-
-  if (searchptr)
-    {
-      if (! searchptr->got_name_map)
-        {
-          searchptr->name_map = read_name_map (searchptr->fname);
-          searchptr->got_name_map = 1;
-        }
-
-      /* Check the mapping for the directory we are using.  */
-      from = filename + strlen (searchptr->fname);
-      for (map = searchptr->name_map; map; map = map->map_next)
-        if (! strcmp (map->map_from, from))
-          return map->map_to;
-    }
-
-  from = base_name (filename);
-
-  if (from != filename || !searchptr)
-    {
-      /* Try to find a mapping file for the particular directory we are
-         looking in.  Thus #include <sys/types.h> will look up sys/types.h
-         in /usr/include/header.gcc and look up types.h in
-         /usr/include/sys/header.gcc.  */
-
-      char *dir = (char *) alloca (from - filename + 1);
-      bcopy (filename, dir, from - filename);
-      dir[from - filename] = '\0';
-
-      for (map = read_name_map (dir); map; map = map->map_next)
-        if (! strcmp (map->map_from, from))
-          return map->map_to;
-    }
-
-  return filename;
-}
-
-/* Insert INC into the include file table, hashed by device and inode number.
-   If a file with different name but same dev+ino was already in the table,
-   return 1 and set INC's control macro to the already-known macro.  */
-
-static int
-lookup_ino_include (inc)
-     struct include_file *inc;
-{
-  int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
-              % INCLUDE_HASHSIZE);
-  struct include_file *i = include_ino_hashtab[hash];
-  inc->next_ino = i;
-  include_ino_hashtab[hash] = inc;
-
-  for (; i; i = i->next_ino)
-    if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
-        && inc->st.st_dev == i->st.st_dev) {
-      inc->control_macro = i->control_macro;
-      return 1;
-    }
-
-  return 0;
-}
-
-/* Process file descriptor F, which corresponds to include file INC,
-   with output to OP.
-   SYSTEM_HEADER_P is 1 if this file resides in any one of the known
-   "system" include directories (as decided by the `is_system_include'
-   function above).
-   DIRPTR is the link in the dir path through which this file was found,
-   or 0 if the file name was absolute.  */
-
-static void
-finclude (f, inc, op, system_header_p, dirptr)
-     int f;
-     struct include_file *inc;
-     FILE_BUF *op;
-     int system_header_p;
-     struct file_name_list *dirptr;
-{
-  char *fname = inc->fname;
-  int i;
-  FILE_BUF *fp;                 /* For input stack frame */
-  int missing_newline = 0;
-
-  CHECK_DEPTH (return;);
-
-  fp = &instack[indepth + 1];
-  bzero ((char *) fp, sizeof (FILE_BUF));
-  fp->nominal_fname = fp->fname = fname;
-  fp->inc = inc;
-  fp->length = 0;
-  fp->lineno = 1;
-  fp->if_stack = if_stack;
-  fp->system_header_p = system_header_p;
-  fp->dir = dirptr;
-
-  if (S_ISREG (inc->st.st_mode)) {
-    size_t s = (size_t) inc->st.st_size;
-    if (s != inc->st.st_size || s + 2 < s)
-      memory_full ();
-    fp->buf = (U_CHAR *) xmalloc (s + 2);
-    fp->bufp = fp->buf;
-
-    /* Read the file contents, knowing that s is an upper bound
-       on the number of bytes we can read.  */
-    fp->length = safe_read (f, (char *) fp->buf, s);
-    if (fp->length < 0) goto nope;
-  }
-  else if (S_ISDIR (inc->st.st_mode)) {
-    error ("directory `%s' specified in #include", fname);
-    close (f);
-    return;
-  } else {
-    /* Cannot count its file size before reading.
-       First read the entire file into heap and
-       copy them into buffer on stack.  */
-
-    int bsize = 2000;
-    int st_size = 0;
-
-    fp->buf = (U_CHAR *) xmalloc (bsize + 2);
-
-    for (;;) {
-      i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
-      if (i < 0)
-        goto nope;      /* error! */
-      st_size += i;
-      if (st_size != bsize)
-        break;  /* End of file */
-      bsize *= 2;
-      fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
-    }
-    fp->bufp = fp->buf;
-    fp->length = st_size;
-  }
-
-  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';
-
-  /* Close descriptor now, so nesting does not use lots of descriptors.  */
-  close (f);
-
-  /* Must do this before calling trigraph_pcp, so that the correct file name
-     will be printed in warning messages.  */
-
-  indepth++;
-  input_file_stack_tick++;
-
-  if (!no_trigraphs)
-    trigraph_pcp (fp);
-
-  output_line_directive (fp, op, 0, enter_file);
-  rescan (op, 0);
-
-  if (missing_newline)
-    fp->lineno--;
-
-  if (pedantic && missing_newline)
-    pedwarn ("file does not end in newline");
-
-  indepth--;
-  input_file_stack_tick++;
-  output_line_directive (&instack[indepth], op, 0, leave_file);
-  free (fp->buf);
-  return;
-
- nope:
-
-  perror_with_name (fname);
-  close (f);
-  free (fp->buf);
-}
-
-/* Record that inclusion of the include file INC
-   should be controlled by the macro named MACRO_NAME.
-   This means that trying to include the file again
-   will do something if that macro is defined.  */
-
-static void
-record_control_macro (inc, macro_name)
-     struct include_file *inc;
-     U_CHAR *macro_name;
-{
-  if (!inc->control_macro || inc->control_macro[0])
-    inc->control_macro = macro_name;
-}
-
-/* Load the specified precompiled header into core, and verify its
-   preconditions.  PCF indicates the file descriptor to read, which must
-   be a regular file.  *ST is its file status.
-   FNAME indicates the file name of the original header.
-   *LIMIT will be set to an address one past the end of the file.
-   If the preconditions of the file are not satisfied, the buffer is 
-   freed and we return 0.  If the preconditions are satisfied, return
-   the address of the buffer following the preconditions.  The buffer, in
-   this case, should never be freed because various pieces of it will
-   be referred to until all precompiled strings are output at the end of
-   the run.  */
-
-static char *
-check_precompiled (pcf, st, fname, limit)
-     int pcf;
-     struct stat *st;
-     char *fname;
-     char **limit;
-{
-  int length = 0;
-  char *buf;
-  char *cp;
-
-  if (pcp_outfile)
-    return 0;
-
-  if (S_ISREG (st->st_mode))
-    {
-      size_t s = (size_t) st->st_size;
-      if (s != st->st_size || s + 2 < s)
-        memory_full ();
-      buf = xmalloc (s + 2);
-      length = safe_read (pcf, buf, s);
-      if (length < 0)
-        goto nope;
-    }
-  else
-    abort ();
-    
-  if (length > 0 && buf[length-1] != '\n')
-    buf[length++] = '\n';
-  buf[length] = '\0';
-  
-  *limit = buf + length;
-
-  /* File is in core.  Check the preconditions.  */
-  if (!check_preconditions (buf))
-    goto nope;
-  for (cp = buf; *cp; cp++)
-    ;
-#ifdef DEBUG_PCP
-  fprintf (stderr, "Using preinclude %s\n", fname);
-#endif
-  return cp + 1;
-
- nope:
-#ifdef DEBUG_PCP
-  fprintf (stderr, "Cannot use preinclude %s\n", fname);
-#endif
-  free (buf);
-  return 0;
-}
-
-/* PREC (null terminated) points to the preconditions of a
-   precompiled header.  These are a series of #define and #undef
-   lines which must match the current contents of the hash
-   table.  */
-
-static int 
-check_preconditions (prec)
-     char *prec;
-{
-  MACRODEF mdef;
-  char *lineend;
-  
-  while (*prec) {
-    lineend = (char*) index (prec, '\n');
-    
-    if (*prec++ != '#') {
-      error ("Bad format encountered while reading precompiled file");
-      return 0;
-    }
-    if (!strncmp (prec, "define", 6)) {
-      HASHNODE *hp;
-      
-      prec += 6;
-      mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
-
-      if (mdef.defn == 0)
-        abort ();
-      
-      if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL
-          || (hp->type != T_MACRO && hp->type != T_CONST)
-          || (hp->type == T_MACRO
-              && !compare_defs (mdef.defn, hp->value.defn)
-              && (mdef.defn->length != 2
-                  || mdef.defn->expansion[0] != '\n'
-                  || mdef.defn->expansion[1] != ' ')))
-        return 0;
-    } else if (!strncmp (prec, "undef", 5)) {
-      char *name;
-      int len;
-      
-      prec += 5;
-      while (is_hor_space[(U_CHAR) *prec])
-        prec++;
-      name = prec;
-      while (is_idchar[(U_CHAR) *prec])
-        prec++;
-      len = prec - name;
-      
-      if (lookup ((U_CHAR *) name, len, -1))
-        return 0;
-    } else {
-      error ("Bad format encountered while reading precompiled file");
-      return 0;
-    }
-    prec = lineend + 1;
-  }
-  /* They all passed successfully */
-  return 1;
-}
-
-/* Process the main body of a precompiled file.  BUF points to the
-   string section of the file, following the preconditions.  LIMIT is one
-   character past the end.  NAME is the name of the file being read
-   in.  OP is the main output buffer.  */
-
-static void
-pcfinclude (buf, limit, name, op)
-     U_CHAR *buf, *limit, *name;
-     FILE_BUF *op;
-{
-  FILE_BUF tmpbuf;
-  int nstrings;
-  U_CHAR *cp = buf;
-
-  /* First in the file comes 4 bytes indicating the number of strings, */
-  /* in network byte order. (MSB first).  */
-  nstrings = *cp++;
-  nstrings = (nstrings << 8) | *cp++;
-  nstrings = (nstrings << 8) | *cp++;
-  nstrings = (nstrings << 8) | *cp++;
-  
-  /* Looping over each string...  */
-  while (nstrings--) {
-    U_CHAR *string_start;
-    U_CHAR *endofthiskey;
-    STRINGDEF *str;
-    int nkeys;
-    
-    /* Each string starts with a STRINGDEF structure (str), followed */
-    /* by the text of the string (string_start) */
-
-    /* First skip to a longword boundary */
-    /* ??? Why a 4-byte boundary?  On all machines? */
-    /* NOTE: This works correctly even if size_t
-       is narrower than a pointer.
-       Do not try risky measures here to get another type to use!
-       Do not include stddef.h--it will fail!  */
-    if ((size_t) cp & 3)
-      cp += 4 - ((size_t) cp & 3);
-    
-    /* Now get the string.  */
-    str = (STRINGDEF *) (GENERIC_PTR) cp;
-    string_start = cp += sizeof (STRINGDEF);
-    
-    for (; *cp; cp++)           /* skip the string */
-      ;
-    
-    /* We need to macro expand the string here to ensure that the
-       proper definition environment is in place.  If it were only
-       expanded when we find out it is needed, macros necessary for
-       its proper expansion might have had their definitions changed.  */
-    tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
-    /* Lineno is already set in the precompiled file */
-    str->contents = tmpbuf.buf;
-    str->len = tmpbuf.length;
-    str->writeflag = 0;
-    str->filename = name;
-    str->output_mark = outbuf.bufp - outbuf.buf;
-    
-    str->chain = 0;
-    *stringlist_tailp = str;
-    stringlist_tailp = &str->chain;
-    
-    /* Next comes a fourbyte number indicating the number of keys
-       for this string.  */
-    nkeys = *cp++;
-    nkeys = (nkeys << 8) | *cp++;
-    nkeys = (nkeys << 8) | *cp++;
-    nkeys = (nkeys << 8) | *cp++;
-
-    /* If this number is -1, then the string is mandatory.  */
-    if (nkeys == -1)
-      str->writeflag = 1;
-    else
-      /* Otherwise, for each key, */
-      for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
-        KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
-        HASHNODE *hp;
-        
-        /* It starts with a KEYDEF structure */
-        cp += sizeof (KEYDEF);
-        
-        /* Find the end of the key.  At the end of this for loop we
-           advance CP to the start of the next key using this variable.  */
-        endofthiskey = cp + strlen ((char *) cp);
-        kp->str = str;
-        
-        /* Expand the key, and enter it into the hash table.  */
-        tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
-        tmpbuf.bufp = tmpbuf.buf;
-        
-        while (is_hor_space[*tmpbuf.bufp])
-          tmpbuf.bufp++;
-        if (!is_idstart[*tmpbuf.bufp]
-            || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
-          str->writeflag = 1;
-          continue;
-        }
-            
-        hp = lookup (tmpbuf.bufp, -1, -1);
-        if (hp == NULL) {
-          kp->chain = 0;
-          install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
-        }
-        else if (hp->type == T_PCSTRING) {
-          kp->chain = hp->value.keydef;
-          hp->value.keydef = kp;
-        }
-        else
-          str->writeflag = 1;
-      }
-  }
-  /* This output_line_directive serves to switch us back to the current
-     input file in case some of these strings get output (which will 
-     result in line directives for the header file being output).   */
-  output_line_directive (&instack[indepth], op, 0, enter_file);
-}
-
-/* Called from rescan when it hits a key for strings.  Mark them all
-   used and clean up.  */
-
-static void
-pcstring_used (hp)
-     HASHNODE *hp;
-{
-  KEYDEF *kp;
-  
-  for (kp = hp->value.keydef; kp; kp = kp->chain)
-    kp->str->writeflag = 1;
-  delete_macro (hp);
-}
-
-/* Write the output, interspersing precompiled strings in their
-   appropriate places.  */
-
-static void
-write_output ()
-{
-  STRINGDEF *next_string;
-  U_CHAR *cur_buf_loc;
-  int line_directive_len = 80;
-  char *line_directive = xmalloc (line_directive_len);
-  int len;
-
-  /* In each run through the loop, either cur_buf_loc ==
-     next_string_loc, in which case we print a series of strings, or
-     it is less than next_string_loc, in which case we write some of
-     the buffer.  */
-  cur_buf_loc = outbuf.buf; 
-  next_string = stringlist;
-  
-  while (cur_buf_loc < outbuf.bufp || next_string) {
-    if (next_string
-        && cur_buf_loc - outbuf.buf == next_string->output_mark) {
-      if (next_string->writeflag) {
-        len = 4 * strlen ((char *) next_string->filename) + 32;
-        while (len > line_directive_len)
-          line_directive = xrealloc (line_directive, 
-                                     line_directive_len *= 2);
-        sprintf (line_directive, "\n# %d ", next_string->lineno);
-        strcpy (quote_string (line_directive + strlen (line_directive),
-                              (char *) next_string->filename),
-                "\n");
-        safe_write (fileno (stdout), line_directive, strlen (line_directive));
-        safe_write (fileno (stdout),
-                    (char *) next_string->contents, next_string->len);
-      }       
-      next_string = next_string->chain;
-    }
-    else {
-      len = (next_string
-             ? (next_string->output_mark 
-                - (cur_buf_loc - outbuf.buf))
-             : outbuf.bufp - cur_buf_loc);
-      
-      safe_write (fileno (stdout), (char *) cur_buf_loc, len);
-      cur_buf_loc += len;
-    }
-  }
-  free (line_directive);
-}
-
-/* Pass a directive through to the output file.
-   BUF points to the contents of the directive, as a contiguous string.
-   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, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  register unsigned keyword_length = keyword->length;
-
-  check_expand (op, 1 + keyword_length + (limit - buf));
-  *op->bufp++ = '#';
-  bcopy (keyword->name, (char *) op->bufp, keyword_length);
-  op->bufp += keyword_length;
-  if (limit != buf && buf[0] != ' ')
-    *op->bufp++ = ' ';
-  bcopy ((char *) buf, (char *) op->bufp, limit - buf);
-  op->bufp += (limit - buf);
-#if 0
-  *op->bufp++ = '\n';
-  /* Count the line we have just made in the output,
-     to get in sync properly.  */
-  op->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
-   would contain pointers to the strings x, y, and z.
-   Collect_definition would then build a DEFINITION node,
-   with reflist nodes pointing to the places x, y, and z had
-   appeared.  So the arglist is just convenience data passed
-   between these two routines.  It is not kept around after
-   the current #define has been processed and entered into the
-   hash table.  */
-
-struct arglist {
-  struct arglist *next;
-  U_CHAR *name;
-  int length;
-  int argno;
-  char rest_args;
-};
-
-/* Create a DEFINITION node from a #define directive.  Arguments are 
-   as for do_define.  */
-
-static MACRODEF
-create_definition (buf, limit, op)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-{
-  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 line = instack[indepth].lineno;
-  char *file = instack[indepth].nominal_fname;
-  int rest_args = 0;
-
-  DEFINITION *defn;
-  int arglengths = 0;           /* Accumulate lengths of arg names
-                                   plus number of args.  */
-  MACRODEF mdef;
-
-  bp = buf;
-
-  while (is_hor_space[*bp])
-    bp++;
-
-  symname = bp;                 /* remember where it starts */
-  sym_length = check_macro_name (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)
-        pedwarn ("another parameter follows `%s'",
-                 rest_extension);
-
-      if (!is_idstart[*bp])
-        pedwarn ("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 (limit - bp > REST_EXTENSION_LENGTH
-            && bcmp (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 != ')')) {
-        error ("badly punctuated parameter list in `#define'");
-        goto nope;
-      }
-      if (*bp == ',') {
-        bp++;
-        SKIP_WHITE_SPACE (bp);
-        /* A comma at this point can only be followed by an identifier.  */
-        if (!is_idstart[*bp]) {
-          error ("badly punctuated parameter list in `#define'");
-          goto nope;
-        }
-      }
-      if (bp >= limit) {
-        error ("unterminated parameter list in `#define'");
-        goto nope;
-      }
-      {
-        struct arglist *otemp;
-
-        for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
-          if (temp->length == otemp->length
-              && bcmp (temp->name, otemp->name, temp->length) == 0) {
-              error ("duplicate argument name `%.*s' in `#define'",
-                     temp->length, temp->name);
-              goto nope;
-          }
-      }
-    }
-
-    ++bp;                       /* skip paren */
-    SKIP_WHITE_SPACE (bp);
-    /* now everything from bp before limit is the definition.  */
-    defn = collect_expansion (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) {
-        bcopy (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 if (sym_length) {
-          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 '~':
-              warning ("missing white space after `#define %.*s'",
-                       sym_length, symname);
-              break;
-
-            default:
-              pedwarn ("missing white space after `#define %.*s'",
-                       sym_length, symname);
-              break;
-          }
-        }
-      }
-    /* Now everything from bp before limit is the definition.  */
-    defn = collect_expansion (bp, limit, -1, NULL_PTR);
-    defn->args.argnames = (U_CHAR *) "";
-  }
-
-  defn->line = line;
-  defn->file = file;
-
-  /* OP is null if this is a predefinition */
-  defn->predefined = !op;
-  mdef.defn = defn;
-  mdef.symnam = symname;
-  mdef.symlen = sym_length;
-
-  return mdef;
-
- nope:
-  mdef.defn = 0;
-  return mdef;
-}
- 
-/* Process a #define directive.
-BUF points to the contents of the #define directive, as a contiguous string.
-LIMIT points to the first character past the end of the definition.
-KEYWORD is the keyword-table entry for #define.  */
-
-static int
-do_define (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  int hashcode;
-  MACRODEF mdef;
-
-  /* If this is a precompiler run (with -pcp) pass thru #define directives.  */
-  if (pcp_outfile && op)
-    pass_thru_directive (buf, limit, op, keyword);
-
-  mdef = create_definition (buf, limit, op);
-  if (mdef.defn == 0)
-    goto nope;
-
-  hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
-
-  {
-    HASHNODE *hp;
-    if ((hp = lookup (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 (mdef.defn, hp->value.defn);
-      /* Redefining a constant is ok with -D.  */
-      else if (hp->type == T_CONST)
-        ok = ! done_initializing;
-      /* Print the warning if it's not ok.  */
-      if (!ok) {
-        /* If we are passing through #define and #undef directives, do
-           that for this re-definition now.  */
-        if (debug_output && op)
-          pass_thru_directive (buf, limit, op, keyword);
-
-        pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
-        if (hp->type == T_MACRO)
-          pedwarn_with_file_and_line (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 {
-      /* If we are passing through #define and #undef directives, do
-         that for this new definition now.  */
-      if (debug_output && op)
-        pass_thru_directive (buf, limit, op, keyword);
-      install (mdef.symnam, mdef.symlen, T_MACRO,
-               (char *) mdef.defn, hashcode);
-    }
-  }
-
-  return 0;
-
-nope:
-
-  return 1;
-}
-
-/* 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 (symname, usage)
-     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 == '"')))
-    error ("invalid %s name", usage);
-  else if (!is_idstart[*symname]
-           || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
-    error ("invalid %s name `%.*s'", usage, sym_length, symname);
-  return sym_length;
-}
-
-/* Return zero if two DEFINITIONs are isomorphic.  */
-     
-static int
-compare_defs (d1, d2)
-     DEFINITION *d1, *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 (pedantic
-      && 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 && ! bcmp (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.
-   One of the parts starts at BEG1 and has LEN1 chars;
-   the other has LEN2 chars at BEG2.
-   Any sequence of whitespace matches any other sequence of whitespace.
-   FIRST means these parts are the first of a macro definition;
-    so ignore leading whitespace entirely.
-   LAST means these parts are the last of a macro definition;
-    so ignore trailing whitespace entirely.  */
-
-static int
-comp_def_part (first, beg1, len1, beg2, len2, last)
-     int first;
-     U_CHAR *beg1, *beg2;
-     int len1, 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);
-}
-
-/* Read a replacement list for a macro with parameters.
-   Build the DEFINITION structure.
-   Reads characters of text starting at BUF until END.
-   ARGLIST specifies the formal parameters to look for
-   in the text of the definition; NARGS is the number of args
-   in that list, or -1 for a macro name that wants no argument list.
-   MACRONAME is the macro name itself (so we can avoid recursive expansion)
-   and NAMELEN is its length in characters.
-   
-Note that comments, backslash-newlines, and leading white space
-have already been deleted from the argument.  */
-
-/* If there is no trailing whitespace, a Newline Space is added at the end
-   to prevent concatenation that would be contrary to the standard.  */
-
-static DEFINITION *
-collect_expansion (buf, end, nargs, arglist)
-     U_CHAR *buf, *end;
-     int nargs;
-     struct arglist *arglist;
-{
-  DEFINITION *defn;
-  register U_CHAR *p, *limit, *lastp, *exp_p;
-  struct reflist *endpat = NULL;
-  /* Pointer to first nonspace after last ## seen.  */
-  U_CHAR *concat = 0;
-  /* Pointer to first nonspace after last single-# seen.  */
-  U_CHAR *stringify = 0;
-  /* How those tokens were spelled.  */
-  enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
-  enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
-  int maxsize;
-  int expected_delimiter = '\0';
-
-  /* Scan thru the replacement list, ignoring comments and quoted
-     strings, picking up on the macro calls.  It does a linear search
-     thru the arg list on every potential symbol.  Profiling might say
-     that something smarter should happen.  */
-
-  if (end < buf)
-    abort ();
-
-  /* Find the beginning of the trailing whitespace.  */
-  limit = end;
-  p = buf;
-  while (p < limit && is_space[limit[-1]]) limit--;
-
-  /* Allocate space for the text in the macro definition.
-     Each input char may or may not need 1 byte,
-     so this is an upper bound.
-     The extra 3 are for invented trailing newline-marker and final null.  */
-  maxsize = (sizeof (DEFINITION)
-             + (limit - p) + 3);
-  defn = (DEFINITION *) xcalloc (1, maxsize);
-
-  defn->nargs = nargs;
-  exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
-  lastp = exp_p;
-
-  if (p[0] == '#'
-      ? p[1] == '#'
-      : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
-    error ("`##' at start of macro definition");
-    p += p[0] == '#' ? 2 : 4;
-  }
-
-  /* Process the main body of the definition.  */
-  while (p < limit) {
-    int skipped_arg = 0;
-    register U_CHAR c = *p++;
-
-    *exp_p++ = c;
-
-    if (!traditional) {
-      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 '%':
-        if (!expected_delimiter && *p == ':') {
-          /* %: is not a digraph if preceded by an odd number of '<'s.  */
-          U_CHAR *p0 = p - 1;
-          while (buf < p0 && p0[-1] == '<')
-            p0--;
-          if ((p - p0) & 1) {
-            /* Treat %:%: as ## and %: as #.  */
-            if (p[1] == '%' && p[2] == ':') {
-              p += 2;
-              goto sharp_sharp_token;
-            }
-            if (nargs >= 0) {
-              p++;
-              goto sharp_token;
-            }
-          }
-        }
-        break;
-
-      case '#':
-        /* # is ordinary inside a string.  */
-        if (expected_delimiter)
-          break;
-        if (*p == '#') {
-        sharp_sharp_token:
-          /* ##: 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++;
-          concat_sharp_token_type = c;
-          if (is_hor_space[*p]) {
-            concat_sharp_token_type = c + 1;
-            p++;
-            SKIP_WHITE_SPACE (p);
-          }
-          concat = p;
-          if (p == limit)
-            error ("`##' at end of macro definition");
-        } else if (nargs >= 0) {
-          /* Single #: stringify following argument ref.
-             Don't leave the # in the expansion.  */
-        sharp_token:
-          exp_p--;
-          stringify_sharp_token_type = c;
-          if (is_hor_space[*p]) {
-            stringify_sharp_token_type = c + 1;
-            p++;
-            SKIP_WHITE_SPACE (p);
-          }
-          if (! is_idstart[*p] || nargs == 0
-              || (*p == 'L' && (p[1] == '\'' || p[1] == '"')))
-            error ("`#' operator is not followed by a macro argument name");
-          else
-            stringify = p;
-        }
-        break;
-      }
-    } else {
-      /* In -traditional mode, recognize arguments inside strings and
-         and character constants, and ignore special properties of #.
-         Arguments inside strings are considered "stringified", but no
-         extra quote marks are supplied.  */
-      switch (c) {
-      case '\'':
-      case '\"':
-        if (expected_delimiter != '\0') {
-          if (c == expected_delimiter)
-            expected_delimiter = '\0';
-        } else
-          expected_delimiter = c;
-        break;
-
-      case '\\':
-        /* Backslash quotes delimiters and itself, but not macro args.  */
-        if (expected_delimiter != 0 && p < limit
-            && (*p == expected_delimiter || *p == '\\')) {
-          *exp_p++ = *p++;
-          continue;
-        }
-        break;
-
-      case '/':
-        if (expected_delimiter != '\0') /* No comments inside strings.  */
-          break;
-        if (*p == '*') {
-          /* If we find a comment that wasn't removed by handle_directive,
-             this must be -traditional.  So replace the comment with
-             nothing at all.  */
-          exp_p--;
-          while (++p < limit) {
-            if (p[0] == '*' && p[1] == '/') {
-              p += 2;
-              break;
-            }
-          }
-#if 0
-          /* 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
-              && bcmp (arg->name, id_beg, id_len) == 0) {
-            enum sharp_token_type tpat_stringify;
-            if (expected_delimiter) {
-              if (warn_stringify) {
-                if (traditional) {
-                  warning ("macro argument `%.*s' is stringified.",
-                           id_len, arg->name);
-                } else {
-                  warning ("macro arg `%.*s' would be stringified with -traditional.",
-                           id_len, arg->name);
-                }
-              }
-              /* If ANSI, don't actually substitute inside a string.  */
-              if (!traditional)
-                break;
-              tpat_stringify = SHARP_TOKEN;
-            } else {
-              tpat_stringify
-                = (stringify == id_beg
-                   ? stringify_sharp_token_type : NO_SHARP_TOKEN);
-            }
-            /* 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 ? concat_sharp_token_type : NO_SHARP_TOKEN;
-            tpat->raw_after = NO_SHARP_TOKEN;
-            tpat->rest_args = arg->rest_args;
-            tpat->stringify = tpat_stringify;
-
-            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[0]=='#'
-                  ? p1[1]=='#'
-                  : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
-                tpat->raw_after = p1[0] + (p != p1);
-            }
-            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)
-          error ("`#' operator should be followed by a macro argument name");
-      }
-    }
-  }
-
-  if (!traditional && expected_delimiter == 0) {
-    /* If ANSI, put in a newline-space marker to prevent token pasting.
-       But not if "inside a string" (which in ANSI mode happens only for
-       -D option).  */
-    *exp_p++ = '\n';
-    *exp_p++ = ' ';
-  }
-
-  *exp_p = '\0';
-
-  defn->length = exp_p - defn->expansion;
-
-  /* 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);
-#endif
-
-  return defn;
-}
-
-static int
-do_assert (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  U_CHAR *bp;                   /* temp ptr into input buffer */
-  U_CHAR *symname;              /* remember where symbol name starts */
-  int sym_length;               /* and how long it is */
-  struct arglist *tokens = NULL;
-
-  if (pedantic && done_initializing && !instack[indepth].system_header_p)
-    pedwarn ("ANSI C does not allow `#assert'");
-
-  bp = buf;
-
-  while (is_hor_space[*bp])
-    bp++;
-
-  symname = bp;                 /* remember where it starts */
-  sym_length = check_macro_name (bp, "assertion");
-  bp += sym_length;
-  /* #define doesn't do this, but we should.  */
-  SKIP_WHITE_SPACE (bp);
-
-  /* Lossage will occur if identifiers or control tokens are broken
-     across lines using backslash.  This is not the right place to take
-     care of that.  */
-
-  if (*bp != '(') {
-    error ("missing token-sequence in `#assert'");
-    return 1;
-  }
-
-  {
-    int error_flag = 0;
-
-    bp++;                       /* skip '(' */
-    SKIP_WHITE_SPACE (bp);
-
-    tokens = read_token_list (&bp, limit, &error_flag);
-    if (error_flag)
-      return 1;
-    if (tokens == 0) {
-      error ("empty token-sequence in `#assert'");
-      return 1;
-    }
-
-    ++bp;                       /* skip paren */
-    SKIP_WHITE_SPACE (bp);
-  }
-
-  /* If this name isn't already an assertion name, make it one.
-     Error if it was already in use in some other way.  */
-
-  {
-    ASSERTION_HASHNODE *hp;
-    int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
-    struct tokenlist_list *value
-      = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
-
-    hp = assertion_lookup (symname, sym_length, hashcode);
-    if (hp == NULL) {
-      if (sym_length == 7 && ! bcmp (symname, "defined", 7))
-        error ("`defined' redefined as assertion");
-      hp = assertion_install (symname, sym_length, hashcode);
-    }
-
-    /* Add the spec'd token-sequence to the list of such.  */
-    value->tokens = tokens;
-    value->next = hp->value;
-    hp->value = value;
-  }
-
-  return 0;
-}
-
-static int
-do_unassert (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  U_CHAR *bp;                   /* temp ptr into input buffer */
-  U_CHAR *symname;              /* remember where symbol name starts */
-  int sym_length;               /* and how long it is */
-
-  struct arglist *tokens = NULL;
-  int tokens_specified = 0;
-
-  if (pedantic && done_initializing && !instack[indepth].system_header_p)
-    pedwarn ("ANSI C does not allow `#unassert'");
-
-  bp = buf;
-
-  while (is_hor_space[*bp])
-    bp++;
-
-  symname = bp;                 /* remember where it starts */
-  sym_length = check_macro_name (bp, "assertion");
-  bp += sym_length;
-  /* #define doesn't do this, but we should.  */
-  SKIP_WHITE_SPACE (bp);
-
-  /* Lossage will occur if identifiers or control tokens are broken
-     across lines using backslash.  This is not the right place to take
-     care of that.  */
-
-  if (*bp == '(') {
-    int error_flag = 0;
-
-    bp++;                       /* skip '(' */
-    SKIP_WHITE_SPACE (bp);
-
-    tokens = read_token_list (&bp, limit, &error_flag);
-    if (error_flag)
-      return 1;
-    if (tokens == 0) {
-      error ("empty token list in `#unassert'");
-      return 1;
-    }
-
-    tokens_specified = 1;
-
-    ++bp;                       /* skip paren */
-    SKIP_WHITE_SPACE (bp);
-  }
-
-  {
-    ASSERTION_HASHNODE *hp;
-    int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
-    struct tokenlist_list *tail, *prev;
-
-    hp = assertion_lookup (symname, sym_length, hashcode);
-    if (hp == NULL)
-      return 1;
-
-    /* If no token list was specified, then eliminate this assertion
-       entirely.  */
-    if (! tokens_specified) {
-      struct tokenlist_list *next;
-      for (tail = hp->value; tail; tail = next) {
-        next = tail->next;
-        free_token_list (tail->tokens);
-        free (tail);
-      }
-      delete_assertion (hp);
-    } else {
-      /* If a list of tokens was given, then delete any matching list.  */
-
-      tail = hp->value;
-      prev = 0;
-      while (tail) {
-        struct tokenlist_list *next = tail->next;
-        if (compare_token_lists (tail->tokens, tokens)) {
-          if (prev)
-            prev->next = next;
-          else
-            hp->value = tail->next;
-          free_token_list (tail->tokens);
-          free (tail);
-        } else {
-          prev = tail;
-        }
-        tail = next;
-      }
-    }
-  }
-
-  return 0;
-}
-
-/* Test whether there is an assertion named NAME
-   and optionally whether it has an asserted token list TOKENS.
-   NAME is not null terminated; its length is SYM_LENGTH.
-   If TOKENS_SPECIFIED is 0, then don't check for any token list.  */
-
-int
-check_assertion (name, sym_length, tokens_specified, tokens)
-     U_CHAR *name;
-     int sym_length;
-     int tokens_specified;
-     struct arglist *tokens;
-{
-  ASSERTION_HASHNODE *hp;
-  int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
-
-  if (pedantic && !instack[indepth].system_header_p)
-    pedwarn ("ANSI C does not allow testing assertions");
-
-  hp = assertion_lookup (name, sym_length, hashcode);
-  if (hp == NULL)
-    /* It is not an assertion; just return false.  */
-    return 0;
-
-  /* If no token list was specified, then value is 1.  */
-  if (! tokens_specified)
-    return 1;
-
-  {
-    struct tokenlist_list *tail;
-
-    tail = hp->value;
-
-    /* If a list of tokens was given,
-       then succeed if the assertion records a matching list.  */
-
-    while (tail) {
-      if (compare_token_lists (tail->tokens, tokens))
-        return 1;
-      tail = tail->next;
-    }
-
-    /* Fail if the assertion has no matching list.  */
-    return 0;
-  }
-}
-
-/* Compare two lists of tokens for equality including order of tokens.  */
-
-static int
-compare_token_lists (l1, l2)
-     struct arglist *l1, *l2;
-{
-  while (l1 && l2) {
-    if (l1->length != l2->length)
-      return 0;
-    if (bcmp (l1->name, l2->name, l1->length))
-      return 0;
-    l1 = l1->next;
-    l2 = l2->next;
-  }
-
-  /* Succeed if both lists end at the same time.  */
-  return l1 == l2;
-}
-
-/* Read a space-separated list of tokens ending in a close parenthesis.
-   Return a list of strings, in the order they were written.
-   (In case of error, return 0 and store -1 in *ERROR_FLAG.)
-   Parse the text starting at *BPP, and update *BPP.
-   Don't parse beyond LIMIT.  */
-
-static struct arglist *
-read_token_list (bpp, limit, error_flag)
-     U_CHAR **bpp;
-     U_CHAR *limit;
-     int *error_flag;
-{
-  struct arglist *token_ptrs = 0;
-  U_CHAR *bp = *bpp;
-  int depth = 1;
-
-  *error_flag = 0;
-
-  /* Loop over the assertion value tokens.  */
-  while (depth > 0) {
-    struct arglist *temp;
-    int eofp = 0;
-    U_CHAR *beg = bp;
-
-    /* Find the end of the token.  */
-    if (*bp == '(') {
-      bp++;
-      depth++;
-    } else if (*bp == ')') {
-      depth--;
-      if (depth == 0)
-        break;
-      bp++;
-    } else if (*bp == '"' || *bp == '\'')
-      bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp);
-    else
-      while (! is_hor_space[*bp] && *bp != '(' && *bp != ')'
-             && *bp != '"' && *bp != '\'' && bp != limit)
-        bp++;
-
-    temp = (struct arglist *) xmalloc (sizeof (struct arglist));
-    temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
-    bcopy ((char *) beg, (char *) temp->name, bp - beg);
-    temp->name[bp - beg] = 0;
-    temp->next = token_ptrs;
-    token_ptrs = temp;
-    temp->length = bp - beg;
-
-    SKIP_WHITE_SPACE (bp);
-
-    if (bp >= limit) {
-      error ("unterminated token sequence in `#assert' or `#unassert'");
-      *error_flag = -1;
-      return 0;
-    }
-  }
-  *bpp = bp;
-
-  /* We accumulated the names in reverse order.
-     Now reverse them to get the proper order.  */
-  {
-    register struct arglist *prev = 0, *this, *next;
-    for (this = token_ptrs; this; this = next) {
-      next = this->next;
-      this->next = prev;
-      prev = this;
-    }
-    return prev;
-  }
-}
-
-static void
-free_token_list (tokens)
-     struct arglist *tokens;
-{
-  while (tokens) {
-    struct arglist *next = tokens->next;
-    free (tokens->name);
-    free (tokens);
-    tokens = next;
-  }
-}
-
-/* Install a name in the assertion hash table.
-
-   If LEN is >= 0, it is the length of the name.
-   Otherwise, compute the length by scanning the entire name.
-
-   If HASH is >= 0, it is the precomputed hash code.
-   Otherwise, compute the hash code.  */
-
-static ASSERTION_HASHNODE *
-assertion_install (name, len, hash)
-     U_CHAR *name;
-     int len;
-     int hash;
-{
-  register ASSERTION_HASHNODE *hp;
-  register int i, bucket;
-  register U_CHAR *p, *q;
-
-  i = sizeof (ASSERTION_HASHNODE) + len + 1;
-  hp = (ASSERTION_HASHNODE *) xmalloc (i);
-  bucket = hash;
-  hp->bucket_hdr = &assertion_hashtab[bucket];
-  hp->next = assertion_hashtab[bucket];
-  assertion_hashtab[bucket] = hp;
-  hp->prev = NULL;
-  if (hp->next != NULL)
-    hp->next->prev = hp;
-  hp->length = len;
-  hp->value = 0;
-  hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
-  p = hp->name;
-  q = name;
-  for (i = 0; i < len; i++)
-    *p++ = *q++;
-  hp->name[len] = 0;
-  return hp;
-}
-
-/* Find the most recent hash node for name name (ending with first
-   non-identifier char) installed by install
-
-   If LEN is >= 0, it is the length of the name.
-   Otherwise, compute the length by scanning the entire name.
-
-   If HASH is >= 0, it is the precomputed hash code.
-   Otherwise, compute the hash code.  */
-
-static ASSERTION_HASHNODE *
-assertion_lookup (name, len, hash)
-     U_CHAR *name;
-     int len;
-     int hash;
-{
-  register ASSERTION_HASHNODE *bucket;
-
-  bucket = assertion_hashtab[hash];
-  while (bucket) {
-    if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
-      return bucket;
-    bucket = bucket->next;
-  }
-  return NULL;
-}
-
-static void
-delete_assertion (hp)
-     ASSERTION_HASHNODE *hp;
-{
-
-  if (hp->prev != NULL)
-    hp->prev->next = hp->next;
-  if (hp->next != NULL)
-    hp->next->prev = hp->prev;
-
-  /* Make sure that the bucket chain header that the deleted guy was
-     on points to the right thing afterwards.  */
-  if (hp == *hp->bucket_hdr)
-    *hp->bucket_hdr = hp->next;
-
-  free (hp);
-}
-
-/*
- * interpret #line directive.  Remembers previously seen fnames
- * in its very own hash table.
- */
-#define FNAME_HASHSIZE 37
-
-static int
-do_line (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  register U_CHAR *bp;
-  FILE_BUF *ip = &instack[indepth];
-  FILE_BUF tem;
-  int new_lineno;
-  enum file_change_code file_change = same_file;
-
-  /* Expand any macros.  */
-  tem = expand_to_temp_buffer (buf, limit, 0, 0);
-
-  /* Point to macroexpanded line, which is null-terminated now.  */
-  bp = tem.buf;
-  SKIP_WHITE_SPACE (bp);
-
-  if (!isdigit (*bp)) {
-    error ("invalid format `#line' directive");
-    return 0;
-  }
-
-  /* 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 *) bp) - 1;
-
-  /* NEW_LINENO is one less than the actual line number here.  */
-  if (pedantic && new_lineno < 0)
-    pedwarn ("line number out of range in `#line' directive");
-
-  /* skip over the line number.  */
-  while (isdigit (*bp))
-    bp++;
-
-#if 0 /* #line 10"foo.c" is supposed to be allowed.  */
-  if (*bp && !is_space[*bp]) {
-    error ("invalid format `#line' directive");
-    return;
-  }
-#endif
-
-  SKIP_WHITE_SPACE (bp);
-
-  if (*bp == '\"') {
-    static HASHNODE *fname_table[FNAME_HASHSIZE];
-    HASHNODE *hp, **hash_bucket;
-    U_CHAR *fname, *p;
-    int fname_length;
-
-    fname = ++bp;
-
-    /* Turn the file name, which is a character string literal,
-       into a null-terminated string.  Do this in place.  */
-    p = bp;
-    for (;;)
-      switch ((*p++ = *bp++)) {
-      case '\0':
-        error ("invalid format `#line' directive");
-        return 0;
-
-      case '\\':
-        {
-          char *bpc = (char *) bp;
-          HOST_WIDE_INT c = parse_escape (&bpc, (HOST_WIDE_INT) (U_CHAR) (-1));
-          bp = (U_CHAR *) bpc;
-          if (c < 0)
-            p--;
-          else
-            p[-1] = c;
-        }
-        break;
-
-      case '\"':
-        p[-1] = 0;
-        goto fname_done;
-      }
-  fname_done:
-    fname_length = p - fname;
-
-    SKIP_WHITE_SPACE (bp);
-    if (*bp) {
-      if (pedantic)
-        pedwarn ("garbage at end of `#line' directive");
-      if (*bp == '1')
-        file_change = enter_file;
-      else if (*bp == '2')
-        file_change = leave_file;
-      else if (*bp == '3')
-        ip->system_header_p = 1;
-      else if (*bp == '4')
-        ip->system_header_p = 2;
-      else {
-        error ("invalid format `#line' directive");
-        return 0;
-      }
-
-      bp++;
-      SKIP_WHITE_SPACE (bp);
-      if (*bp == '3') {
-        ip->system_header_p = 1;
-        bp++;
-        SKIP_WHITE_SPACE (bp);
-      }
-      if (*bp == '4') {
-        ip->system_header_p = 2;
-        bp++;
-        SKIP_WHITE_SPACE (bp);
-      }
-      if (*bp) {
-        error ("invalid format `#line' directive");
-        return 0;
-      }
-    }
-
-    hash_bucket = &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
-    for (hp = *hash_bucket; hp != NULL; hp = hp->next)
-      if (hp->length == fname_length &&
-          bcmp (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);
-      bcopy (fname, hp->value.cpval, fname_length);
-    }
-  } else if (*bp) {
-    error ("invalid format `#line' directive");
-    return 0;
-  }
-
-  ip->lineno = new_lineno;
-  output_line_directive (ip, op, 0, file_change);
-  check_expand (op, ip->length - (ip->bufp - ip->buf));
-  return 0;
-}
-
-/* Remove the definition of a symbol from the symbol table.
-   according to un*x /lib/cpp, it is not an error to undef
-   something that has no definitions, so it isn't one here either.  */
-
-static int
-do_undef (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  int sym_length;
-  HASHNODE *hp;
-  U_CHAR *orig_buf = buf;
-
-  /* If this is a precompiler run (with -pcp) pass thru #undef directives.  */
-  if (pcp_outfile && op)
-    pass_thru_directive (buf, limit, op, keyword);
-
-  SKIP_WHITE_SPACE (buf);
-  sym_length = check_macro_name (buf, "macro");
-
-  while ((hp = lookup (buf, sym_length, -1)) != NULL) {
-    /* If we are generating additional info for debugging (with -g) we
-       need to pass through all effective #undef directives.  */
-    if (debug_output && op)
-      pass_thru_directive (orig_buf, limit, op, keyword);
-    if (hp->type != T_MACRO)
-      warning ("undefining `%s'", hp->name);
-    delete_macro (hp);
-  }
-
-  if (pedantic) {
-    buf += sym_length;
-    SKIP_WHITE_SPACE (buf);
-    if (buf != limit)
-      pedwarn ("garbage after `#undef' directive");
-  }
-  return 0;
-}
-
-/* Report an error detected by the program we are processing.
-   Use the text of the line in the error message.
-   (We use error because it prints the filename & line#.)  */
-
-static int
-do_error (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  int length = limit - buf;
-  U_CHAR *copy = (U_CHAR *) alloca (length + 1);
-  bcopy ((char *) buf, (char *) copy, length);
-  copy[length] = 0;
-  SKIP_WHITE_SPACE (copy);
-  error ("#error %s", copy);
-  return 0;
-}
-
-/* Report a warning detected by the program we are processing.
-   Use the text of the line in the warning message, then continue.
-   (We use error because it prints the filename & line#.)  */
-
-static int
-do_warning (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  int length = limit - buf;
-  U_CHAR *copy = (U_CHAR *) alloca (length + 1);
-  bcopy ((char *) buf, (char *) copy, length);
-  copy[length] = 0;
-  SKIP_WHITE_SPACE (copy);
-  /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
-     if -pedantic-errors is given, #warning should cause an error.  */
-  pedwarn ("#warning %s", copy);
-  return 0;
-}
-
-/* Remember the name of the current file being read from so that we can
-   avoid ever including it again.  */
-
-static void
-do_once ()
-{
-  int i;
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].inc) {
-      record_control_macro (instack[i].inc, (U_CHAR *) "");
-      break;
-    }
-}
-
-/* Report program identification.  */
-
-static int
-do_ident (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  FILE_BUF trybuf;
-  int len;
-
-  /* Allow #ident in system headers, since that's not user's fault.  */
-  if (pedantic && !instack[indepth].system_header_p)
-    pedwarn ("ANSI C does not allow `#ident'");
-
-  trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
-  buf = trybuf.buf;
-  len = trybuf.bufp - buf;
-
-  /* Output expanded directive.  */
-  check_expand (op, 7 + len);
-  bcopy ("#ident ", (char *) op->bufp, 7);
-  op->bufp += 7;
-  bcopy ((char *) buf, (char *) op->bufp, len);
-  op->bufp += len;
-
-  free (buf);
-  return 0;
-}
-
-/* #pragma and its argument line have already been copied to the output file.
-   Just check for some recognized pragmas that need validation here.  */
-
-static int
-do_pragma (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  SKIP_WHITE_SPACE (buf);
-  if (!strncmp ((char *) buf, "once", 4)) {
-    /* Allow #pragma once in system headers, since that's not the user's
-       fault.  */
-    if (!instack[indepth].system_header_p)
-      warning ("`#pragma once' is obsolete");
-    do_once ();
-  }
-
-  if (!strncmp ((char *) buf, "implementation", 14)) {
-    /* Be quiet about `#pragma implementation' for a file only if it hasn't
-       been included yet.  */
-
-    int h;
-    U_CHAR *p = buf + 14, *fname;
-    SKIP_WHITE_SPACE (p);
-    if (*p != '\"')
-      return 0;
-
-    fname = p + 1;
-    if ((p = (U_CHAR *) index ((char *) fname, '\"')))
-      *p = '\0';
-    
-    for (h = 0; h < INCLUDE_HASHSIZE; h++) {
-      struct include_file *inc;
-      for (inc = include_hashtab[h]; inc; inc = inc->next) {
-        if (!strcmp (base_name (inc->fname), (char *) fname)) {
-          warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
-          return 0;
-        }
-      }
-    }
-  }
-  return 0;
-}
-
-#if 0
-/* This was a fun hack, but #pragma seems to start to be useful.
-   By failing to recognize it, we pass it through unchanged to cc1.  */
-
-/* The behavior of the #pragma directive is implementation defined.
-   this implementation defines it as follows.  */
-
-static int
-do_pragma ()
-{
-  close (0);
-  if (open ("/dev/tty", O_RDONLY, 0666) != 0)
-    goto nope;
-  close (1);
-  if (open ("/dev/tty", O_WRONLY, 0666) != 1)
-    goto nope;
-  execl ("/usr/games/hack", "#pragma", 0);
-  execl ("/usr/games/rogue", "#pragma", 0);
-  execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
-  execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
-nope:
-  fatal ("You are in a maze of twisty compiler features, all different");
-}
-#endif
-
-#ifdef SCCS_DIRECTIVE
-
-/* Just ignore #sccs, on systems where we define it at all.  */
-
-static int
-do_sccs (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  if (pedantic)
-    pedwarn ("ANSI C does not allow `#sccs'");
-  return 0;
-}
-
-#endif /* defined (SCCS_DIRECTIVE) */
-
-/* Handle #if directive by
-     1) inserting special `defined' keyword into the hash table
-        that gets turned into 0 or 1 by special_symbol (thus,
-        if the luser has a symbol called `defined' already, it won't
-        work inside the #if directive)
-     2) rescan the input into a temporary output buffer
-     3) pass the output buffer to the yacc parser and collect a value
-     4) clean up the mess left from steps 1 and 2.
-     5) call conditional_skip to skip til the next #endif (etc.),
-        or not, depending on the value from step 3.  */
-
-static int
-do_if (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  HOST_WIDE_INT value;
-  FILE_BUF *ip = &instack[indepth];
-
-  value = eval_if_expression (buf, limit - buf);
-  conditional_skip (ip, value == 0, T_IF, NULL_PTR, op);
-  return 0;
-}
-
-/* Handle a #elif directive by not changing  if_stack  either.
-   see the comment above do_else.  */
-
-static int
-do_elif (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  HOST_WIDE_INT value;
-  FILE_BUF *ip = &instack[indepth];
-
-  if (if_stack == instack[indepth].if_stack) {
-    error ("`#elif' not within a conditional");
-    return 0;
-  } else {
-    if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
-      error ("`#elif' after `#else'");
-      fprintf (stderr, " (matches line %d", if_stack->lineno);
-      if (if_stack->fname != NULL && ip->fname != NULL
-          && strcmp (if_stack->fname, ip->nominal_fname) != 0)
-        fprintf (stderr, ", file %s", if_stack->fname);
-      fprintf (stderr, ")\n");
-    }
-    if_stack->type = T_ELIF;
-  }
-
-  if (if_stack->if_succeeded)
-    skip_if_group (ip, 0, op);
-  else {
-    value = eval_if_expression (buf, limit - buf);
-    if (value == 0)
-      skip_if_group (ip, 0, op);
-    else {
-      ++if_stack->if_succeeded; /* continue processing input */
-      output_line_directive (ip, op, 1, same_file);
-    }
-  }
-  return 0;
-}
-
-/* Evaluate a #if expression in BUF, of length LENGTH, then parse the
-   result as a C expression and return the value as an int.  */
-
-static HOST_WIDE_INT
-eval_if_expression (buf, length)
-     U_CHAR *buf;
-     int length;
-{
-  FILE_BUF temp_obuf;
-  HASHNODE *save_defined;
-  HOST_WIDE_INT value;
-
-  save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
-                          NULL_PTR, -1);
-  pcp_inside_if = 1;
-  temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
-  pcp_inside_if = 0;
-  delete_macro (save_defined);  /* clean up special symbol */
-
-  temp_obuf.buf[temp_obuf.length] = '\n';
-  value = parse_c_expression ((char *) temp_obuf.buf,
-                              warn_undef && !instack[indepth].system_header_p);
-
-  free (temp_obuf.buf);
-
-  return value;
-}
-
-/* routine to handle ifdef/ifndef.  Try to look up the symbol, then do
-   or don't skip to the #endif/#else/#elif depending on what directive
-   is actually being processed.  */
-
-static int
-do_xifdef (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  int skip;
-  FILE_BUF *ip = &instack[indepth];
-  U_CHAR *end; 
-  int start_of_file = 0;
-  U_CHAR *control_macro = 0;
-
-  /* Detect a #ifndef at start of file (not counting comments).  */
-  if (ip->fname != 0 && keyword->type == T_IFNDEF) {
-    U_CHAR *p = ip->buf;
-    while (p != directive_start) {
-      U_CHAR c = *p++;
-      if (is_space[c])
-        ;
-      /* Make no special provision for backslash-newline here; this is
-         slower if backslash-newlines are present, but it's correct,
-         and it's not worth it to tune for the rare backslash-newline.  */
-      else if (c == '/'
-               && (*p == '*' || (cplusplus_comments && *p == '/'))) {
-        /* Skip this comment.  */
-        int junk = 0;
-        U_CHAR *save_bufp = ip->bufp;
-        ip->bufp = p + 1;
-        p = skip_to_end_of_comment (ip, &junk, 1);
-        ip->bufp = save_bufp;
-      } else {
-        goto fail;
-      }
-    }
-    /* If we get here, this conditional is the beginning of the file.  */
-    start_of_file = 1;
-  fail: ;
-  }
-
-  /* Discard leading and trailing whitespace.  */
-  SKIP_WHITE_SPACE (buf);
-  while (limit != buf && is_hor_space[limit[-1]]) limit--;
-
-  /* Find the end of the identifier at the beginning.  */
-  for (end = buf; is_idchar[*end]; end++);
-
-  if (end == buf) {
-    skip = (keyword->type == T_IFDEF);
-    if (! traditional)
-      pedwarn (end == limit ? "`#%s' with no argument"
-               : "`#%s' argument starts with punctuation",
-               keyword->name);
-  } else {
-    HASHNODE *hp;
-
-    if (! traditional) {
-      if (isdigit (buf[0]))
-        pedwarn ("`#%s' argument starts with a digit", keyword->name);
-      else if (end != limit)
-        pedwarn ("garbage at end of `#%s' argument", keyword->name);
-    }
-
-    hp = lookup (buf, end-buf, -1);
-
-    if (pcp_outfile) {
-      /* Output a precondition for this macro.  */
-      if (hp
-          && (hp->type == T_CONST
-              || (hp->type == T_MACRO && 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);
-      }
-    }
-
-    skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
-    if (start_of_file && !skip) {
-      control_macro = (U_CHAR *) xmalloc (end - buf + 1);
-      bcopy ((char *) buf, (char *) control_macro, end - buf);
-      control_macro[end - buf] = 0;
-    }
-  }
-  
-  conditional_skip (ip, skip, T_IF, control_macro, op);
-  return 0;
-}
-
-/* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
-   If this is a #ifndef starting at the beginning of a file,
-   CONTROL_MACRO is the macro name tested by the #ifndef.
-   Otherwise, CONTROL_MACRO is 0.  */
-
-static void
-conditional_skip (ip, skip, type, control_macro, op)
-     FILE_BUF *ip;
-     int skip;
-     enum node_type type;
-     U_CHAR *control_macro;
-     FILE_BUF *op;
-{
-  IF_STACK_FRAME *temp;
-
-  temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
-  temp->fname = ip->nominal_fname;
-  temp->lineno = ip->lineno;
-  temp->next = if_stack;
-  temp->control_macro = control_macro;
-  if_stack = temp;
-
-  if_stack->type = type;
-
-  if (skip != 0) {
-    skip_if_group (ip, 0, op);
-    return;
-  } else {
-    ++if_stack->if_succeeded;
-    output_line_directive (ip, &outbuf, 1, same_file);
-  }
-}
-
-/* Skip to #endif, #else, or #elif.  adjust line numbers, etc.
-   Leaves input ptr at the sharp sign found.
-   If ANY is nonzero, return at next directive of any sort.  */
-     
-static void
-skip_if_group (ip, any, op)
-     FILE_BUF *ip;
-     int any;
-     FILE_BUF *op;
-{
-  register U_CHAR *bp = ip->bufp, *cp;
-  register U_CHAR *endb = ip->buf + ip->length;
-  struct directive *kt;
-  IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
-  U_CHAR *beg_of_line = bp;
-  register int ident_length;
-  U_CHAR *ident, *after_ident;
-  /* Save info about where the group starts.  */
-  U_CHAR *beg_of_group = bp;
-  int beg_lineno = ip->lineno;
-  int skipping_include_directive = 0;
-
-  if (output_conditionals && op != 0) {
-    char *ptr = "#failed\n";
-    int len = strlen (ptr);
-
-    if (op->bufp > op->buf && op->bufp[-1] != '\n')
-      {
-        *op->bufp++ = '\n';
-        op->lineno++;
-      }
-    check_expand (op, len);
-    bcopy (ptr, (char *) op->bufp, len);
-    op->bufp += len;
-    op->lineno++;
-    output_line_directive (ip, op, 1, 0);
-  }
-
-  while (bp < endb) {
-    switch (*bp++) {
-    case '/':                   /* possible comment */
-      if (*bp == '\\' && bp[1] == '\n')
-        newline_fix (bp);
-      if (*bp == '*'
-          || (cplusplus_comments && *bp == '/')) {
-        ip->bufp = ++bp;
-        bp = skip_to_end_of_comment (ip, &ip->lineno, 0);
-      }
-      break;
-    case '<':
-      if (skipping_include_directive) {
-        while (bp < endb && *bp != '>' && *bp != '\n') {
-          if (*bp == '\\' && bp[1] == '\n') {
-            ip->lineno++;
-            bp++;
-          }
-          bp++;
-        }
-      }
-      break;
-    case '\"':
-      if (skipping_include_directive) {
-        while (bp < endb && *bp != '\n') {
-          if (*bp == '"') {
-            bp++;
-            break;
-          }
-          if (*bp == '\\' && bp[1] == '\n') {
-            ip->lineno++;
-            bp++;
-          }
-          bp++;
-        }
-        break;
-      }
-      /* Fall through.  */
-    case '\'':
-      bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno,
-                               NULL_PTR, NULL_PTR);
-      break;
-    case '\\':
-      /* Char after backslash loses its special meaning in some cases.  */
-      if (*bp == '\n') {
-        ++ip->lineno;
-        bp++;
-      } else if (traditional && bp < endb)
-        bp++;
-      break;
-    case '\n':
-      ++ip->lineno;
-      beg_of_line = bp;
-      skipping_include_directive = 0;
-      break;
-    case '%':
-      if (beg_of_line == 0 || traditional)
-        break;
-      ip->bufp = bp - 1;
-      while (bp[0] == '\\' && bp[1] == '\n')
-        bp += 2;
-      if (*bp == ':')
-        goto sharp_token;
-      break;
-    case '#':
-      /* # keyword: a # must be first nonblank char on the line */
-      if (beg_of_line == 0)
-        break;
-      ip->bufp = bp - 1;
-    sharp_token:
-      /* Scan from start of line, skipping whitespace, comments
-         and backslash-newlines, and see if we reach this #.
-         If not, this # is not special.  */
-      bp = beg_of_line;
-      /* If -traditional, require # to be at beginning of line.  */
-      if (!traditional) {
-        while (1) {
-          if (is_hor_space[*bp])
-            bp++;
-          else if (*bp == '\\' && bp[1] == '\n')
-            bp += 2;
-          else if (*bp == '/' && bp[1] == '*') {
-            bp += 2;
-            while (!(*bp == '*' && bp[1] == '/'))
-              bp++;
-            bp += 2;
-          }
-          /* There is no point in trying to deal with C++ // comments here,
-             because if there is one, then this # must be part of the
-             comment and we would never reach here.  */
-          else break;
-        }
-      }
-      if (bp != ip->bufp) {
-        bp = ip->bufp + 1;      /* Reset bp to after the #.  */
-        break;
-      }
-
-      bp = ip->bufp + 1;        /* Point after the '#' */
-      if (ip->bufp[0] == '%') {
-        /* Skip past the ':' again.  */
-        while (*bp == '\\') {
-          ip->lineno++;
-          bp += 2;
-        }
-        bp++;
-      }
-
-      /* Skip whitespace and \-newline.  */
-      while (1) {
-        if (is_hor_space[*bp])
-          bp++;
-        else if (*bp == '\\' && bp[1] == '\n')
-          bp += 2;
-        else if (*bp == '/') {
-          if (bp[1] == '\\' && bp[2] == '\n')
-            newline_fix (bp + 1);
-          if (bp[1] == '*') {
-            for (bp += 2; ; bp++) {
-              if (*bp == '\n')
-                ip->lineno++;
-              else if (*bp == '*') {
-                if (bp[-1] == '/' && warn_comments)
-                  warning ("`/*' within comment");
-                if (bp[1] == '\\' && bp[2] == '\n')
-                  newline_fix (bp + 1);
-                if (bp[1] == '/')
-                  break;
-              }
-            }
-            bp += 2;
-          } else if (bp[1] == '/' && cplusplus_comments) {
-            for (bp += 2; ; bp++) {
-              if (*bp == '\n') {
-                if (bp[-1] != '\\')
-                  break;
-                if (warn_comments)
-                  warning ("multiline `//' comment");
-                ip->lineno++;
-              }
-            }
-          } else
-            break;
-        } else
-          break;
-      }
-
-      cp = bp;
-
-      /* Now find end of directive name.
-         If we encounter a backslash-newline, exchange it with any following
-         symbol-constituents so that we end up with a contiguous name.  */
-
-      while (1) {
-        if (is_idchar[*bp])
-          bp++;
-        else {
-          if (*bp == '\\' && bp[1] == '\n')
-            name_newline_fix (bp);
-          if (is_idchar[*bp])
-            bp++;
-          else break;
-        }
-      }
-      ident_length = bp - cp;
-      ident = cp;
-      after_ident = bp;
-
-      /* A line of just `#' becomes blank.  */
-
-      if (ident_length == 0 && *after_ident == '\n') {
-        continue;
-      }
-
-      if (ident_length == 0 || !is_idstart[*ident]) {
-        U_CHAR *p = ident;
-        while (is_idchar[*p]) {
-          if (*p < '0' || *p > '9')
-            break;
-          p++;
-        }
-        /* Handle # followed by a line number.  */
-        if (p != ident && !is_idchar[*p]) {
-          if (pedantic)
-            pedwarn ("`#' followed by integer");
-          continue;
-        }
-
-        /* 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)
-              pedwarn ("invalid preprocessing directive");
-            continue;
-          }
-        }
-
-        if (!lang_asm && pedantic)
-          pedwarn ("invalid preprocessing directive name");
-        continue;
-      }
-
-      for (kt = directive_table; kt->length >= 0; kt++) {
-        IF_STACK_FRAME *temp;
-        if (ident_length == kt->length
-            && bcmp (cp, kt->name, kt->length) == 0) {
-          /* If we are asked to return on next directive, do so now.  */
-          if (any)
-            goto done;
-
-          switch (kt->type) {
-          case T_IF:
-          case T_IFDEF:
-          case T_IFNDEF:
-            temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
-            temp->next = if_stack;
-            if_stack = temp;
-            temp->lineno = ip->lineno;
-            temp->fname = ip->nominal_fname;
-            temp->type = kt->type;
-            break;
-          case T_ELSE:
-          case T_ENDIF:
-            if (pedantic && if_stack != save_if_stack)
-              validate_else (bp, endb);
-          case T_ELIF:
-            if (if_stack == instack[indepth].if_stack) {
-              error ("`#%s' not within a conditional", kt->name);
-              break;
-            }
-            else if (if_stack == save_if_stack)
-              goto done;                /* found what we came for */
-
-            if (kt->type != T_ENDIF) {
-              if (if_stack->type == T_ELSE)
-                error ("`#else' or `#elif' after `#else'");
-              if_stack->type = kt->type;
-              break;
-            }
-
-            temp = if_stack;
-            if_stack = if_stack->next;
-            free (temp);
-            break;
-
-          case T_INCLUDE:
-          case T_INCLUDE_NEXT:
-          case T_IMPORT:
-            skipping_include_directive = 1;
-            break;
-
-          default:
-            break;
-          }
-          break;
-        }
-      }
-      /* Don't let erroneous code go by.  */
-      if (kt->length < 0 && !lang_asm && pedantic)
-        pedwarn ("invalid preprocessing directive name");
-    }
-  }
-
-  ip->bufp = bp;
-  /* after this returns, rescan will exit because ip->bufp
-     now points to the end of the buffer.
-     rescan is responsible for the error message also.  */
-
- done:
-  if (output_conditionals && op != 0) {
-    char *ptr = "#endfailed\n";
-    int len = strlen (ptr);
-
-    if (op->bufp > op->buf && op->bufp[-1] != '\n')
-      {
-        *op->bufp++ = '\n';
-        op->lineno++;
-      }
-    check_expand (op, beg_of_line - beg_of_group);
-    bcopy ((char *) beg_of_group, (char *) op->bufp,
-           beg_of_line - beg_of_group);
-    op->bufp += beg_of_line - beg_of_group;
-    op->lineno += ip->lineno - beg_lineno;
-    check_expand (op, len);
-    bcopy (ptr, (char *) op->bufp, len);
-    op->bufp += len;
-    op->lineno++;
-  }
-}
-
-/* Handle a #else directive.  Do this by just continuing processing
-   without changing  if_stack ;  this is so that the error message
-   for missing #endif's etc. will point to the original #if.  It
-   is possible that something different would be better.  */
-
-static int
-do_else (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  FILE_BUF *ip = &instack[indepth];
-
-  if (pedantic) {
-    SKIP_WHITE_SPACE (buf);
-    if (buf != limit)
-      pedwarn ("text following `#else' violates ANSI standard");
-  }
-
-  if (if_stack == instack[indepth].if_stack) {
-    error ("`#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.  */
-    if_stack->control_macro = 0;
-
-    if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
-      error ("`#else' after `#else'");
-      fprintf (stderr, " (matches line %d", if_stack->lineno);
-      if (strcmp (if_stack->fname, ip->nominal_fname) != 0)
-        fprintf (stderr, ", file %s", if_stack->fname);
-      fprintf (stderr, ")\n");
-    }
-    if_stack->type = T_ELSE;
-  }
-
-  if (if_stack->if_succeeded)
-    skip_if_group (ip, 0, op);
-  else {
-    ++if_stack->if_succeeded;   /* continue processing input */
-    output_line_directive (ip, op, 1, same_file);
-  }
-  return 0;
-}
-
-/* Unstack after #endif directive.  */
-
-static int
-do_endif (buf, limit, op, keyword)
-     U_CHAR *buf, *limit;
-     FILE_BUF *op;
-     struct directive *keyword;
-{
-  if (pedantic) {
-    SKIP_WHITE_SPACE (buf);
-    if (buf != limit)
-      pedwarn ("text following `#endif' violates ANSI standard");
-  }
-
-  if (if_stack == instack[indepth].if_stack)
-    error ("unbalanced `#endif'");
-  else {
-    IF_STACK_FRAME *temp = if_stack;
-    if_stack = if_stack->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.  */
-      FILE_BUF *ip = &instack[indepth];
-      U_CHAR *p = ip->bufp;
-      U_CHAR *ep = ip->buf + ip->length;
-
-      while (p != ep) {
-        U_CHAR c = *p++;
-        if (!is_space[c]) {
-          if (c == '/'
-              && (*p == '*' || (cplusplus_comments && *p == '/'))) {
-            /* Skip this comment.  */
-            int junk = 0;
-            U_CHAR *save_bufp = ip->bufp;
-            ip->bufp = p + 1;
-            p = skip_to_end_of_comment (ip, &junk, 1);
-            ip->bufp = save_bufp;
-          } else
-            goto fail;
-        }
-      }
-      /* If we get here, 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.
-
-         Do not do this for the top-level file in a -include or any
-         file in a -imacros.  */
-      if (indepth != 0
-          && ! (indepth == 1 && no_record_file)
-          && ! (no_record_file && no_output))
-        record_control_macro (ip->inc, temp->control_macro);
-    fail: ;
-    }
-    free (temp);
-    output_line_directive (&instack[indepth], op, 1, same_file);
-  }
-  return 0;
-}
-
-/* When an #else or #endif is found while skipping failed conditional,
-   if -pedantic was specified, this is called to warn about text after
-   the directive name.  P points to the first char after the directive
-   name.  */
-
-static void
-validate_else (p, limit)
-     register U_CHAR *p;
-     register U_CHAR *limit;
-{
-  /* Advance P over whitespace and comments.  */
-  while (1) {
-    while (*p == '\\' && p[1] == '\n')
-      p += 2;
-    if (is_hor_space[*p])
-      p++;
-    else if (*p == '/') {
-      while (p[1] == '\\' && p[2] == '\n')
-        p += 2;
-      if (p[1] == '*') {
-        /* Don't bother warning about unterminated comments
-           since that will happen later.  Just be sure to exit.  */
-        for (p += 2; ; p++) {
-          if (p == limit)
-            return;
-          if (*p == '*') {
-            while (p[1] == '\\' && p[2] == '\n')
-              p += 2;
-            if (p[1] == '/') {
-              p += 2;
-              break;
-            }
-          }
-        }
-      }
-      else if (cplusplus_comments && p[1] == '/')
-        return;
-      else break;
-    } else break;
-  }
-  if (*p != '\n')
-    pedwarn ("text following `#else' or `#endif' violates ANSI standard");
-}
-
-/* Skip a comment, assuming the input ptr immediately follows the
-   initial slash-star.  Bump *LINE_COUNTER for each newline.
-   (The canonical line counter is &ip->lineno.)
-   Don't use this routine (or the next one) if bumping the line
-   counter is not sufficient to deal with newlines in the string.
-
-   If NOWARN is nonzero, don't warn about slash-star inside a comment.
-   This feature is useful when processing a comment that is going to
-   be processed or was processed at another point in the preprocessor,
-   to avoid a duplicate warning.  Likewise for unterminated comment
-   errors.  */
-
-static U_CHAR *
-skip_to_end_of_comment (ip, line_counter, nowarn)
-     register FILE_BUF *ip;
-     int *line_counter;         /* place to remember newlines, or NULL */
-     int nowarn;
-{
-  register U_CHAR *limit = ip->buf + ip->length;
-  register U_CHAR *bp = ip->bufp;
-  FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
-  int start_line = line_counter ? *line_counter : 0;
-
-        /* JF this line_counter stuff is a crock to make sure the
-           comment is only put out once, no matter how many times
-           the comment is skipped.  It almost works */
-  if (op) {
-    *op->bufp++ = '/';
-    *op->bufp++ = bp[-1];
-  }
-  if (cplusplus_comments && bp[-1] == '/') {
-    for (; bp < limit; bp++) {
-      if (*bp == '\n') {
-        if (bp[-1] != '\\')
-          break;
-        if (!nowarn && warn_comments)
-          warning ("multiline `//' comment");
-        if (line_counter)
-          ++*line_counter;
-        if (op)
-          ++op->lineno;
-      }
-      if (op)
-        *op->bufp++ = *bp;
-    }
-    ip->bufp = bp;
-    return bp;
-  }
-  while (bp < limit) {
-    if (op)
-      *op->bufp++ = *bp;
-    switch (*bp++) {
-    case '\n':
-      /* If this is the end of the file, we have an unterminated comment.
-         Don't swallow the newline.  We are guaranteed that there will be a
-         trailing newline and various pieces assume it's there.  */
-      if (bp == limit)
-        {
-          --bp;
-          --limit;
-          break;
-        }
-      if (line_counter != NULL)
-        ++*line_counter;
-      if (op)
-        ++op->lineno;
-      break;
-    case '*':
-      if (bp[-2] == '/' && !nowarn && warn_comments)
-        warning ("`/*' within comment");
-      if (*bp == '\\' && bp[1] == '\n')
-        newline_fix (bp);
-      if (*bp == '/') {
-        if (op)
-          *op->bufp++ = '/';
-        ip->bufp = ++bp;
-        return bp;
-      }
-      break;
-    }
-  }
-
-  if (!nowarn)
-    error_with_line (line_for_error (start_line), "unterminated comment");
-  ip->bufp = bp;
-  return bp;
-}
-
-/* Skip over a quoted string.  BP points to the opening quote.
-   Returns a pointer after the closing quote.  Don't go past LIMIT.
-   START_LINE is the line number of the starting point (but it need
-   not be valid if the starting point is inside a macro expansion).
-
-   The input stack state is not changed.
-
-   If COUNT_NEWLINES is nonzero, it points to an int to increment
-   for each newline passed.
-
-   If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
-   if we pass a backslash-newline.
-
-   If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.  */
-
-static U_CHAR *
-skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
-     register U_CHAR *bp;
-     register U_CHAR *limit;
-     int start_line;
-     int *count_newlines;
-     int *backslash_newlines_p;
-     int *eofp;
-{
-  register U_CHAR c, match;
-
-  match = *bp++;
-  while (1) {
-    if (bp >= limit) {
-      error_with_line (line_for_error (start_line),
-                       "unterminated string or character constant");
-      error_with_line (multiline_string_line,
-                       "possible real start of unterminated constant");
-      multiline_string_line = 0;
-      if (eofp)
-        *eofp = 1;
-      break;
-    }
-    c = *bp++;
-    if (c == '\\') {
-      while (*bp == '\\' && bp[1] == '\n') {
-        if (backslash_newlines_p)
-          *backslash_newlines_p = 1;
-        if (count_newlines)
-          ++*count_newlines;
-        bp += 2;
-      }
-      if (*bp == '\n') {
-        if (backslash_newlines_p)
-          *backslash_newlines_p = 1;
-        if (count_newlines)
-          ++*count_newlines;
-      }
-      bp++;
-    } else if (c == '\n') {
-      if (traditional) {
-        /* Unterminated strings and character constants are 'valid'.  */
-        bp--;   /* Don't consume the newline.  */
-        if (eofp)
-          *eofp = 1;
-        break;
-      }
-      if (match == '\'') {
-        error_with_line (line_for_error (start_line),
-                         "unterminated string or character constant");
-        bp--;
-        if (eofp)
-          *eofp = 1;
-        break;
-      }
-      /* If not traditional, then allow newlines inside strings.  */
-      if (count_newlines)
-        ++*count_newlines;
-      if (multiline_string_line == 0) {
-        if (pedantic)
-          pedwarn_with_line (line_for_error (start_line),
-                             "string constant runs past end of line");
-        multiline_string_line = start_line;
-      }
-    } else if (c == match)
-      break;
-  }
-  return bp;
-}
-
-/* Place into DST a quoted string representing the string SRC.
-   Return the address of DST's terminating null.  */
-
-static char *
-quote_string (dst, src)
-     char *dst, *src;
-{
-  U_CHAR c;
-
-  *dst++ = '\"';
-  for (;;)
-    switch ((c = *src++))
-      {
-      default:
-        if (isprint (c))
-          *dst++ = c;
-        else
-          {
-            sprintf (dst, "\\%03o", c);
-            dst += 4;
-          }
-        break;
-
-      case '\"':
-      case '\\':
-        *dst++ = '\\';
-        *dst++ = c;
-        break;
-      
-      case '\0':
-        *dst++ = '\"';
-        *dst = '\0';
-        return dst;
-      }
-}
-
-/* Skip across a group of balanced parens, starting from IP->bufp.
-   IP->bufp is updated.  Use this with IP->bufp pointing at an open-paren.
-
-   This does not handle newlines, because it's used for the arg of #if,
-   where there aren't any newlines.  Also, backslash-newline can't appear.  */
-
-static U_CHAR *
-skip_paren_group (ip)
-     register FILE_BUF *ip;
-{
-  U_CHAR *limit = ip->buf + ip->length;
-  U_CHAR *p = ip->bufp;
-  int depth = 0;
-  int lines_dummy = 0;
-
-  while (p != limit) {
-    int c = *p++;
-    switch (c) {
-    case '(':
-      depth++;
-      break;
-
-    case ')':
-      depth--;
-      if (depth == 0)
-        return ip->bufp = p;
-      break;
-
-    case '/':
-      if (*p == '*') {
-        ip->bufp = p;
-        p = skip_to_end_of_comment (ip, &lines_dummy, 0);
-        p = ip->bufp;
-      }
-
-    case '"':
-    case '\'':
-      {
-        int eofp = 0;
-        p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp);
-        if (eofp)
-          return ip->bufp = p;
-      }
-      break;
-    }
-  }
-
-  ip->bufp = p;
-  return p;
-}
-
-/* Write out a #line directive, for instance, after an #include file.
-   If CONDITIONAL is nonzero, we can omit the #line if it would
-   appear to be a no-op, and we can output a few newlines instead
-   if we want to increase the line number by a small amount.
-   FILE_CHANGE says whether we are entering a file, leaving, or neither.  */
-
-static void
-output_line_directive (ip, op, conditional, file_change)
-     FILE_BUF *ip, *op;
-     int conditional;
-     enum file_change_code file_change;
-{
-  int len;
-  char *line_directive_buf, *line_end;
-
-  if (no_line_directives
-      || ip->fname == NULL
-      || no_output) {
-    op->lineno = ip->lineno;
-    return;
-  }
-
-  if (conditional) {
-    if (ip->lineno == op->lineno)
-      return;
-
-    /* If the inherited line number is a little too small,
-       output some newlines instead of a #line directive.  */
-    if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
-      check_expand (op, 10);
-      while (ip->lineno > op->lineno) {
-        *op->bufp++ = '\n';
-        op->lineno++;
-      }
-      return;
-    }
-  }
-
-  /* Output a positive line number if possible.  */
-  while (ip->lineno <= 0 && ip->bufp - ip->buf < ip->length
-         && *ip->bufp == '\n') {
-    ip->lineno++;
-    ip->bufp++;
-  }
-
-  line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
-  sprintf (line_directive_buf, "# %d ", ip->lineno);
-  line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
-                           ip->nominal_fname);
-  if (file_change != same_file) {
-    *line_end++ = ' ';
-    *line_end++ = file_change == enter_file ? '1' : '2';
-  }
-  /* Tell cc1 if following text comes from a system header file.  */
-  if (ip->system_header_p) {
-    *line_end++ = ' ';
-    *line_end++ = '3';
-  }
-#ifndef NO_IMPLICIT_EXTERN_C
-  /* Tell cc1plus if following text should be treated as C.  */
-  if (ip->system_header_p == 2 && cplusplus) {
-    *line_end++ = ' ';
-    *line_end++ = '4';
-  }
-#endif
-  *line_end++ = '\n';
-  len = line_end - line_directive_buf;
-  check_expand (op, len + 1);
-  if (op->bufp > op->buf && op->bufp[-1] != '\n')
-    *op->bufp++ = '\n';
-  bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
-  op->bufp += len;
-  op->lineno = ip->lineno;
-}
-
-/* This structure represents one parsed argument in a macro call.
-   `raw' points to the argument text as written (`raw_length' is its length).
-   `expanded' points to the argument's macro-expansion
-   (its length is `expand_length').
-   `stringified_length' is the length the argument would have
-   if stringified.
-   `use_count' is the number of times this macro arg is substituted
-   into the macro.  If the actual use count exceeds 10, 
-   the value stored is 10.
-   `free1' and `free2', if nonzero, point to blocks to be freed
-   when the macro argument data is no longer needed.  */
-
-struct argdata {
-  U_CHAR *raw, *expanded;
-  int raw_length, expand_length;
-  int stringified_length;
-  U_CHAR *free1, *free2;
-  char newlines;
-  char use_count;
-};
-
-/* Expand a macro call.
-   HP points to the symbol that is the macro being called.
-   Put the result of expansion onto the input stack
-   so that subsequent input by our caller will use it.
-
-   If macro wants arguments, caller has already verified that
-   an argument list follows; arguments come from the input stack.  */
-
-static void
-macroexpand (hp, op)
-     HASHNODE *hp;
-     FILE_BUF *op;
-{
-  int nargs;
-  DEFINITION *defn = hp->value.defn;
-  register U_CHAR *xbuf;
-  int xbuf_len;
-  int start_line = instack[indepth].lineno;
-  int rest_args, rest_zero;
-
-  CHECK_DEPTH (return;);
-
-  /* it might not actually be a macro.  */
-  if (hp->type != T_MACRO) {
-    special_symbol (hp, op);
-    return;
-  }
-
-  /* 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);
-  
-  nargs = defn->nargs;
-
-  if (nargs >= 0) {
-    register int i;
-    struct argdata *args;
-    char *parse_error = 0;
-
-    args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
-
-    for (i = 0; i < nargs; i++) {
-      args[i].raw = (U_CHAR *) "";
-      args[i].expanded = 0;
-      args[i].raw_length = args[i].expand_length
-        = args[i].stringified_length = 0;
-      args[i].free1 = args[i].free2 = 0;
-      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;
-    do {
-      /* Discard the open-parenthesis or comma before the next arg.  */
-      ++instack[indepth].bufp;
-      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;
-        parse_error = macarg (&args[i], rest_args);
-      }
-      else
-        parse_error = macarg (NULL_PTR, 0);
-      if (parse_error) {
-        error_with_line (line_for_error (start_line), parse_error);
-        break;
-      }
-      i++;
-    } while (*instack[indepth].bufp != ')');
-
-    /* If we got one arg but it was just whitespace, call that 0 args.  */
-    if (i == 1) {
-      register U_CHAR *bp = 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) {
-      if (! parse_error)
-        error ("arguments given to macro `%s'", hp->name);
-    } else if (i < nargs) {
-      /* traditional C allows foo() if foo wants one argument.  */
-      if (nargs == 1 && i == 0 && traditional)
-        ;
-      /* the rest args token is allowed to absorb 0 tokens */
-      else if (i == nargs - 1 && defn->rest_args)
-        rest_zero = 1;
-      else if (parse_error)
-        ;
-      else if (i == 0)
-        error ("macro `%s' used without args", hp->name);
-      else if (i == 1)
-        error ("macro `%s' used with just one arg", hp->name);
-      else
-        error ("macro `%s' used with only %d args", hp->name, i);
-    } else if (i > nargs) {
-      if (! parse_error)
-        error ("macro `%s' used with too many (%d) args", hp->name, i);
-    }
-
-    /* Swallow the closeparen.  */
-    ++instack[indepth].bufp;
-
-    /* If macro wants zero args, we parsed the arglist for checking only.
-       Read directly from the macro definition.  */
-    if (nargs == 0) {
-      xbuf = defn->expansion;
-      xbuf_len = defn->length;
-    } else {
-      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)
-          xbuf_len += args[ap->argno].stringified_length;
-        else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
-          /* 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].expanded == 0) {
-            FILE_BUF obuf;
-            obuf = expand_to_temp_buffer (args[ap->argno].raw,
-                                          args[ap->argno].raw + args[ap->argno].raw_length,
-                                          1, 0);
-
-            args[ap->argno].expanded = obuf.buf;
-            args[ap->argno].expand_length = obuf.length;
-            args[ap->argno].free2 = obuf.buf;
-          }
-
-          /* 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 != 0)
-                || (last_ap != NULL && last_ap->rest_args
-                    && last_ap->raw_after != 0))) {
-          /* 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) {
-          int arglen = arg->raw_length;
-          int escaped = 0;
-          int in_string = 0;
-          int c;
-          i = 0;
-          while (i < arglen
-                 && (c = arg->raw[i], is_space[c]))
-            i++;
-          while (i < arglen
-                 && (c = arg->raw[arglen - 1], is_space[c]))
-            arglen--;
-          if (!traditional)
-            xbuf[totlen++] = '\"'; /* insert beginning quote */
-          for (; i < arglen; i++) {
-            c = arg->raw[i];
-
-            if (! in_string) {
-              /* Special markers Newline Space
-                 generate nothing for a stringified argument.  */
-              if (c == '\n' && arg->raw[i+1] != '\n') {
-                i++;
-                continue;
-              }
-
-              /* Internal sequences of whitespace are replaced by one space
-                 except within an string or char token.  */
-              if (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c]) {
-                while (1) {
-                  /* Note that Newline Space does occur within whitespace
-                     sequences; consider it part of the sequence.  */
-                  if (c == '\n' && is_space[arg->raw[i+1]])
-                    i += 2;
-                  else if (c != '\n' && is_space[c])
-                    i++;
-                  else break;
-                  c = arg->raw[i];
-                }
-                i--;
-                c = ' ';
-              }
-            }
-
-            if (escaped)
-              escaped = 0;
-            else {
-              if (c == '\\')
-                escaped = 1;
-              if (in_string) {
-                if (c == in_string)
-                  in_string = 0;
-              } else if (c == '\"' || c == '\'')
-                in_string = c;
-            }
-
-            /* Escape these chars */
-            if (c == '\"' || (in_string && c == '\\'))
-              xbuf[totlen++] = '\\';
-            /* We used to output e.g. \008 for control characters here,
-               but this doesn't conform to the C Standard.
-               Just output the characters as-is.  */
-            xbuf[totlen++] = c;
-          }
-          if (!traditional)
-            xbuf[totlen++] = '\"'; /* insert ending quote */
-        } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
-          U_CHAR *p1 = arg->raw;
-          U_CHAR *l1 = p1 + arg->raw_length;
-          if (ap->raw_before != 0) {
-            while (p1 != l1 && is_space[*p1]) p1++;
-            while (p1 != l1 && is_idchar[*p1])
-              xbuf[totlen++] = *p1++;
-            /* Delete any no-reexpansion marker that follows
-               an identifier at the beginning of the argument
-               if the argument is concatenated with what precedes it.  */
-            if (p1[0] == '\n' && p1[1] == '-')
-              p1 += 2;
-          } else if (!traditional) {
-          /* Ordinary expanded use of the argument.
-             Put in newline-space markers to prevent token pasting.  */
-            xbuf[totlen++] = '\n';
-            xbuf[totlen++] = ' ';
-          }
-          if (ap->raw_after != 0) {
-            /* 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 a `-' is preceded by an odd number of newlines then it
-                   and the last newline are a no-reexpansion marker.  */
-                while (p2 != p1 && p2[-1] == '\n') p2--;
-                if ((l1 - 1 - p2) & 1) {
-                  l1 -= 2;
-                }
-                else break;
-              }
-              else break;
-            }
-          }
-
-          bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
-          totlen += l1 - p1;
-          if (!traditional && ap->raw_after == 0) {
-            /* Ordinary expanded use of the argument.
-               Put in newline-space markers to prevent token pasting.  */
-            xbuf[totlen++] = '\n';
-            xbuf[totlen++] = ' ';
-          }
-        } else {
-          /* Ordinary expanded use of the argument.
-             Put in newline-space markers to prevent token pasting.  */
-          if (!traditional) {
-            xbuf[totlen++] = '\n';
-            xbuf[totlen++] = ' ';
-          }
-          bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
-                 arg->expand_length);
-          totlen += arg->expand_length;
-          if (!traditional) {
-            xbuf[totlen++] = '\n';
-            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 (arg->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 != 0))
-          xbuf[totlen++] = exp[i];
-      }
-
-      xbuf[totlen] = 0;
-      xbuf_len = totlen;
-
-      for (i = 0; i < nargs; i++) {
-        if (args[i].free1 != 0)
-          free (args[i].free1);
-        if (args[i].free2 != 0)
-          free (args[i].free2);
-      }
-    }
-  } else {
-    xbuf = defn->expansion;
-    xbuf_len = defn->length;
-  }
-
-  /* Now put the expansion on the input stack
-     so our caller will commence reading from it.  */
-  {
-    register FILE_BUF *ip2;
-
-    ip2 = &instack[++indepth];
-
-    ip2->fname = 0;
-    ip2->nominal_fname = 0;
-    ip2->inc = 0;
-    /* This may not be exactly correct, but will give much better error
-       messages for nested macro calls than using a line number of zero.  */
-    ip2->lineno = start_line;
-    ip2->buf = xbuf;
-    ip2->length = xbuf_len;
-    ip2->bufp = xbuf;
-    ip2->free_ptr = (nargs > 0) ? xbuf : 0;
-    ip2->macro = hp;
-    ip2->if_stack = if_stack;
-    ip2->system_header_p = 0;
-
-    /* Recursive macro use sometimes works traditionally.
-       #define foo(x,y) bar (x (y,0), y)
-       foo (foo, baz)  */
-
-    if (!traditional)
-      hp->type = T_DISABLED;
-  }
-}
-
-/* Parse a macro argument and store the info on it into *ARGPTR.
-   REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
-   Return nonzero to indicate a syntax error.  */
-
-static char *
-macarg (argptr, rest_args)
-     register struct argdata *argptr;
-     int rest_args;
-{
-  FILE_BUF *ip = &instack[indepth];
-  int paren = 0;
-  int newlines = 0;
-  int comments = 0;
-  char *result = 0;
-
-  /* Try to parse as much of the argument as exists at this
-     input stack level.  */
-  U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro,
-                        &paren, &newlines, &comments, rest_args);
-
-  /* If we find the end of the argument at this level,
-     set up *ARGPTR to point at it in the input stack.  */
-  if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
-      && bp != ip->buf + ip->length) {
-    if (argptr != 0) {
-      argptr->raw = ip->bufp;
-      argptr->raw_length = bp - ip->bufp;
-      argptr->newlines = newlines;
-    }
-    ip->bufp = bp;
-  } else {
-    /* This input stack level ends before the macro argument does.
-       We must pop levels and keep parsing.
-       Therefore, we must allocate a temporary buffer and copy
-       the macro argument into it.  */
-    int bufsize = bp - ip->bufp;
-    int extra = newlines;
-    U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
-    int final_start = 0;
-
-    bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
-    ip->bufp = bp;
-    ip->lineno += newlines;
-
-    while (bp == ip->buf + ip->length) {
-      if (instack[indepth].macro == 0) {
-        result = "unterminated macro call";
-        break;
-      }
-      ip->macro->type = T_MACRO;
-      if (ip->free_ptr)
-        free (ip->free_ptr);
-      ip = &instack[--indepth];
-      newlines = 0;
-      comments = 0;
-      bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro, &paren,
-                    &newlines, &comments, rest_args);
-      final_start = bufsize;
-      bufsize += bp - ip->bufp;
-      extra += newlines;
-      buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
-      bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
-             bp - ip->bufp);
-      ip->bufp = bp;
-      ip->lineno += newlines;
-    }
-
-    /* Now, if arg is actually wanted, record its raw form,
-       discarding comments and duplicating newlines in whatever
-       part of it did not come from a macro expansion.
-       EXTRA space has been preallocated for duplicating the newlines.
-       FINAL_START is the index of the start of that part.  */
-    if (argptr != 0) {
-      argptr->raw = buffer;
-      argptr->raw_length = bufsize;
-      argptr->free1 = buffer;
-      argptr->newlines = newlines;
-      if ((newlines || comments) && ip->fname != 0)
-        argptr->raw_length
-          = final_start +
-            discard_comments (argptr->raw + final_start,
-                              argptr->raw_length - final_start,
-                              newlines);
-      argptr->raw[argptr->raw_length] = 0;
-      if (argptr->raw_length > bufsize + extra)
-        abort ();
-    }
-  }
-
-  /* If we are not discarding this argument,
-     macroexpand it and compute its length as stringified.
-     All this info goes into *ARGPTR.  */
-
-  if (argptr != 0) {
-    register U_CHAR *buf, *lim;
-    register int totlen;
-
-    buf = argptr->raw;
-    lim = buf + argptr->raw_length;
-
-    while (buf != lim && is_space[*buf])
-      buf++;
-    while (buf != lim && is_space[lim[-1]])
-      lim--;
-    totlen = traditional ? 0 : 2;       /* Count opening and closing quote.  */
-    while (buf != lim) {
-      register U_CHAR c = *buf++;
-      totlen++;
-      /* Internal sequences of whitespace are replaced by one space
-         in most cases, but not always.  So count all the whitespace
-         in case we need to keep it all.  */
-#if 0
-      if (is_space[c])
-        SKIP_ALL_WHITE_SPACE (buf);
-      else
-#endif
-      if (c == '\"' || c == '\\') /* escape these chars */
-        totlen++;
-    }
-    argptr->stringified_length = totlen;
-  }
-  return result;
-}
-
-/* Scan text from START (inclusive) up to LIMIT (exclusive),
-   taken from the expansion of MACRO,
-   counting parens in *DEPTHPTR,
-   and return if reach LIMIT
-   or before a `)' that would make *DEPTHPTR negative
-   or before a comma when *DEPTHPTR is zero.
-   Single and double quotes are matched and termination
-   is inhibited within them.  Comments also inhibit it.
-   Value returned is pointer to stopping place.
-
-   Increment *NEWLINES each time a newline is passed.
-   REST_ARGS notifies macarg1 that it should absorb the rest of the args.
-   Set *COMMENTS to 1 if a comment is seen.  */
-
-static U_CHAR *
-macarg1 (start, limit, macro, depthptr, newlines, comments, rest_args)
-     U_CHAR *start;
-     register U_CHAR *limit;
-     struct hashnode *macro;
-     int *depthptr, *newlines, *comments;
-     int rest_args;
-{
-  register U_CHAR *bp = start;
-
-  while (bp < limit) {
-    switch (*bp) {
-    case '(':
-      (*depthptr)++;
-      break;
-    case ')':
-      if (--(*depthptr) < 0)
-        return bp;
-      break;
-    case '\\':
-      /* Traditionally, backslash makes following char not special.  */
-      if (traditional && bp + 1 < limit && bp[1] != '\n')
-        bp++;
-      break;
-    case '\n':
-      ++*newlines;
-      break;
-    case '/':
-      if (macro)
-        break;
-      if (bp[1] == '\\' && bp[2] == '\n')
-        newline_fix (bp + 1);
-      if (bp[1] == '*') {
-        *comments = 1;
-        for (bp += 2; bp < limit; bp++) {
-          if (*bp == '\n')
-            ++*newlines;
-          else if (*bp == '*') {
-            if (bp[-1] == '/' && warn_comments)
-              warning ("`/*' within comment");
-            if (bp[1] == '\\' && bp[2] == '\n')
-              newline_fix (bp + 1);
-            if (bp[1] == '/') {
-              bp++;
-              break;
-            }
-          }
-        }
-      } else if (bp[1] == '/' && cplusplus_comments) {
-        *comments = 1;
-        for (bp += 2; bp < limit; bp++) {
-          if (*bp == '\n') {
-            ++*newlines;
-            if (bp[-1] != '\\')
-              break;
-            if (warn_comments)
-              warning ("multiline `//' comment");
-          }
-        }
-      }
-      break;
-    case '\'':
-    case '\"':
-      {
-        int quotec;
-        for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
-          if (*bp == '\\') {
-            bp++;
-            if (*bp == '\n')
-              ++*newlines;
-            if (!macro) {
-              while (*bp == '\\' && bp[1] == '\n') {
-                bp += 2;
-                ++*newlines;
-              }
-            }
-          } else if (*bp == '\n') {
-            ++*newlines;
-            if (quotec == '\'')
-              break;
-          }
-        }
-      }
-      break;
-    case ',':
-      /* if we've returned to lowest level and we aren't absorbing all args */
-      if ((*depthptr) == 0 && rest_args == 0)
-        return bp;
-      break;
-    }
-    bp++;
-  }
-
-  return bp;
-}
-
-/* Discard comments and duplicate newlines
-   in the string of length LENGTH at START,
-   except inside of string constants.
-   The string is copied into itself with its beginning staying fixed.  
-
-   NEWLINES is the number of newlines that must be duplicated.
-   We assume that that much extra space is available past the end
-   of the string.  */
-
-static int
-discard_comments (start, length, newlines)
-     U_CHAR *start;
-     int length;
-     int newlines;
-{
-  register U_CHAR *ibp;
-  register U_CHAR *obp;
-  register U_CHAR *limit;
-  register int c;
-
-  /* If we have newlines to duplicate, copy everything
-     that many characters up.  Then, in the second part,
-     we will have room to insert the newlines
-     while copying down.
-     NEWLINES may actually be too large, because it counts
-     newlines in string constants, and we don't duplicate those.
-     But that does no harm.  */
-  if (newlines > 0) {
-    ibp = start + length;
-    obp = ibp + newlines;
-    limit = start;
-    while (limit != ibp)
-      *--obp = *--ibp;
-  }
-
-  ibp = start + newlines;
-  limit = start + length + newlines;
-  obp = start;
-
-  while (ibp < limit) {
-    *obp++ = c = *ibp++;
-    switch (c) {
-    case '\n':
-      /* Duplicate the newline.  */
-      *obp++ = '\n';
-      break;
-
-    case '\\':
-      if (*ibp == '\n') {
-        obp--;
-        ibp++;
-      }
-      break;
-
-    case '/':
-      if (*ibp == '\\' && ibp[1] == '\n')
-        newline_fix (ibp);
-      /* Delete any comment.  */
-      if (cplusplus_comments && ibp[0] == '/') {
-        /* Comments are equivalent to spaces.  */
-        obp[-1] = ' ';
-        ibp++;
-        while (ibp < limit && (*ibp != '\n' || ibp[-1] == '\\'))
-          ibp++;
-        break;
-      }
-      if (ibp[0] != '*' || ibp + 1 >= limit)
-        break;
-      /* Comments are equivalent to spaces.
-         For -traditional, a comment is equivalent to nothing.  */
-      if (traditional)
-        obp--;
-      else
-        obp[-1] = ' ';
-      while (++ibp < limit) {
-        if (ibp[0] == '*') {
-          if (ibp[1] == '\\' && ibp[2] == '\n')
-            newline_fix (ibp + 1);
-          if (ibp[1] == '/') {
-            ibp += 2;
-            break;
-          }
-        }
-      }
-      break;
-
-    case '\'':
-    case '\"':
-      /* Notice and skip strings, so that we don't
-         think that comments start inside them,
-         and so we don't duplicate newlines in them.  */
-      {
-        int quotec = c;
-        while (ibp < limit) {
-          *obp++ = c = *ibp++;
-          if (c == quotec)
-            break;
-          if (c == '\n' && quotec == '\'')
-            break;
-          if (c == '\\') {
-            if (ibp < limit && *ibp == '\n') {
-              ibp++;
-              obp--;
-            } else {
-              while (*ibp == '\\' && ibp[1] == '\n')
-                ibp += 2;
-              if (ibp < limit)
-                *obp++ = *ibp++;
-            }
-          }
-        }
-      }
-      break;
-    }
-  }
-
-  return obp - start;
-}
-
-/* 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;
-{
-  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 '\n':
-      /* If this is a NEWLINE NEWLINE, then this is a real newline in the
-         string.  Skip past the newline and its duplicate.
-         Put a space in the output.  */
-      if (*ibp == '\n')
-        {
-          ibp++;
-          obp--;
-          *obp++ = ' ';
-        }
-      break;
-
-    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 && ibp[-2] != '\\')
-            break;
-          if (c == '\n' && quotec == '\'')
-            break;
-        }
-      }
-      break;
-    }
-  }
-
-  return obp - start;
-}
-
-/* my_strerror - return the descriptive text associated with an
-   `errno' code.  */
-
-char *
-my_strerror (errnum)
-     int errnum;
-{
-  char *result;
-
-#ifndef VMS
-#ifndef HAVE_STRERROR
-  result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
-#else
-  result = strerror (errnum);
-#endif
-#else   /* VMS */
-  /* VAXCRTL's strerror() takes an optional second argument, which only
-     matters when the first argument is EVMSERR.  However, it's simplest
-     just to pass it unconditionally.  `vaxc$errno' is declared in
-     <errno.h>, and maintained by the library in parallel with `errno'.
-     We assume that caller's `errnum' either matches the last setting of
-     `errno' by the library or else does not have the value `EVMSERR'.  */
-
-  result = strerror (errnum, vaxc$errno);
-#endif
-
-  if (!result)
-    result = "undocumented I/O error";
-
-  return result;
-}
-
-/* error - print error message and increment count of errors.  */
-
-void
-error (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  VA_START (args, msg);
-  verror (msg, args);
-  va_end (args);
-}
-
-static void
-verror (msg, args)
-     char *msg;
-     va_list args;
-{
-  int i;
-  FILE_BUF *ip = NULL;
-
-  print_containing_files ();
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-
-  if (ip != NULL)
-    fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-  errors++;
-}
-
-/* Error including a message from `errno'.  */
-
-static void
-error_from_errno (name)
-     char *name;
-{
-  int e = errno;
-  int i;
-  FILE_BUF *ip = NULL;
-
-  print_containing_files ();
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-
-  if (ip != NULL)
-    fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
-
-  fprintf (stderr, "%s: %s\n", name, my_strerror (e));
-
-  errors++;
-}
-
-/* Print error message but don't count it.  */
-
-void
-warning (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  VA_START (args, msg);
-  vwarning (msg, args);
-  va_end (args);
-}
-
-static void
-vwarning (msg, args)
-     char *msg;
-     va_list args;
-{
-  int i;
-  FILE_BUF *ip = NULL;
-
-  if (inhibit_warnings)
-    return;
-
-  if (warnings_are_errors)
-    errors++;
-
-  print_containing_files ();
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-
-  if (ip != NULL)
-    fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
-  fprintf (stderr, "warning: ");
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-}
-
-static void
-#if defined (__STDC__) && defined (HAVE_VPRINTF)
-error_with_line (int line, PRINTF_ALIST (msg))
-#else
-error_with_line (line, PRINTF_ALIST (msg))
-     int line;
-     PRINTF_DCL (msg)
-#endif
-{
-  va_list args;
-
-  VA_START (args, msg);
-  verror_with_line (line, msg, args);
-  va_end (args);
-}
-
-static void
-verror_with_line (line, msg, args)
-     int line;
-     char *msg;
-     va_list args;
-{
-  int i;
-  FILE_BUF *ip = NULL;
-
-  print_containing_files ();
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-
-  if (ip != NULL)
-    fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-  errors++;
-}
-
-static void
-#if defined (__STDC__) && defined (HAVE_VPRINTF)
-warning_with_line (int line, PRINTF_ALIST (msg))
-#else
-warning_with_line (line, PRINTF_ALIST (msg))
-     int line;
-     PRINTF_DCL (msg)
-#endif
-{
-  va_list args;
-
-  VA_START (args, msg);
-  vwarning_with_line (line, msg, args);
-  va_end (args);
-}
-
-static void
-vwarning_with_line (line, msg, args)
-     int line;
-     char *msg;
-     va_list args;
-{
-  int i;
-  FILE_BUF *ip = NULL;
-
-  if (inhibit_warnings)
-    return;
-
-  if (warnings_are_errors)
-    errors++;
-
-  print_containing_files ();
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-
-  if (ip != NULL)
-    fprintf (stderr, line ? "%s:%d: " : "%s: ", ip->nominal_fname, line);
-  fprintf (stderr, "warning: ");
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-}
-
-/* Print an error message and maybe count it.  */
-
-void
-pedwarn (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  VA_START (args, msg);
-  if (pedantic_errors)
-    verror (msg, args);
-  else
-    vwarning (msg, args);
-  va_end (args);
-}
-
-void
-#if defined (__STDC__) && defined (HAVE_VPRINTF)
-pedwarn_with_line (int line, PRINTF_ALIST (msg))
-#else
-pedwarn_with_line (line, PRINTF_ALIST (msg))
-     int line;
-     PRINTF_DCL (msg)
-#endif
-{
-  va_list args;
-
-  VA_START (args, msg);
-  if (pedantic_errors)
-    verror_with_line (line, msg, args);
-  else
-    vwarning_with_line (line, msg, args);
-  va_end (args);
-}
-
-/* Report a warning (or an error if pedantic_errors)
-   giving specified file name and line number, not current.  */
-
-static void
-#if defined (__STDC__) && defined (HAVE_VPRINTF)
-pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
-#else
-pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
-     char *file;
-     int line;
-     PRINTF_DCL (msg)
-#endif
-{
-  va_list args;
-
-  if (!pedantic_errors && inhibit_warnings)
-    return;
-  if (file != NULL)
-    fprintf (stderr, "%s:%d: ", file, line);
-  if (pedantic_errors)
-    errors++;
-  if (!pedantic_errors)
-    fprintf (stderr, "warning: ");
-  VA_START (args, msg);
-  vfprintf (stderr, msg, args);
-  va_end (args);
-  fprintf (stderr, "\n");
-}
-
-/* Print the file names and line numbers of the #include
-   directives which led to the current file.  */
-
-static void
-print_containing_files ()
-{
-  FILE_BUF *ip = NULL;
-  int i;
-  int first = 1;
-
-  /* If stack of files hasn't changed since we last printed
-     this info, don't repeat it.  */
-  if (last_error_tick == input_file_stack_tick)
-    return;
-
-  for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      break;
-    }
-
-  /* Give up if we don't find a source file.  */
-  if (ip == NULL)
-    return;
-
-  /* Find the other, outer source files.  */
-  for (i--; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
-      if (first) {
-        first = 0;
-        fprintf (stderr, "In file included");
-      } else {
-        fprintf (stderr, ",\n                ");
-      }
-
-      fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno);
-    }
-  if (! first)
-    fprintf (stderr, ":\n");
-
-  /* Record we have printed the status as of this time.  */
-  last_error_tick = input_file_stack_tick;
-}
-
-/* Return the line at which an error occurred.
-   The error is not necessarily associated with the current spot
-   in the input stack, so LINE says where.  LINE will have been
-   copied from ip->lineno for the current input level.
-   If the current level is for a file, we return LINE.
-   But if the current level is not for a file, LINE is meaningless.
-   In that case, we return the lineno of the innermost file.  */
-
-static int
-line_for_error (line)
-     int line;
-{
-  int i;
-  int line1 = line;
-
-  for (i = indepth; i >= 0; ) {
-    if (instack[i].fname != 0)
-      return line1;
-    i--;
-    if (i < 0)
-      return 0;
-    line1 = instack[i].lineno;
-  }
-  abort ();
-  /*NOTREACHED*/
-  return 0;
-}
-
-/*
- * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
- *
- * As things stand, nothing is ever placed in the output buffer to be
- * removed again except when it's KNOWN to be part of an identifier,
- * so flushing and moving down everything left, instead of expanding,
- * should work ok.
- */
-
-/* You might think void was cleaner for the return type,
-   but that would get type mismatch in check_expand in strict ANSI.  */
-
-static int
-grow_outbuf (obuf, needed)
-     register FILE_BUF *obuf;
-     register int needed;
-{
-  register U_CHAR *p;
-  int minsize;
-
-  if (obuf->length - (obuf->bufp - obuf->buf) > needed)
-    return 0;
-
-  /* Make it at least twice as big as it is now.  */
-  obuf->length *= 2;
-  /* Make it have at least 150% of the free space we will need.  */
-  minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
-  if (minsize > obuf->length)
-    obuf->length = minsize;
-
-  if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
-    memory_full ();
-
-  obuf->bufp = p + (obuf->bufp - obuf->buf);
-  obuf->buf = p;
-
-  return 0;
-}
-
-/* Symbol table for macro names and special symbols */
-
-/*
- * install a name in the main hash table, even if it is already there.
- *   name stops with first non alphanumeric, except leading '#'.
- * caller must check against redefinition if that is desired.
- * delete_macro () removes things installed by install () in fifo order.
- * this is important because of the `defined' special symbol used
- * in #if, and also if pushdef/popdef directives are ever implemented.
- *
- * If LEN is >= 0, it is the length of the name.
- * Otherwise, compute the length by scanning the entire name.
- *
- * If HASH is >= 0, it is the precomputed hash code.
- * Otherwise, compute the hash code. 
- */
-
-static HASHNODE *
-install (name, len, type, value, hash)
-     U_CHAR *name;
-     int len;
-     enum node_type type;
-     char *value;
-     int hash;
-{
-  register HASHNODE *hp;
-  register int i, bucket;
-  register U_CHAR *p, *q;
-
-  if (len < 0) {
-    p = name;
-    while (is_idchar[*p])
-      p++;
-    len = p - name;
-  }
-
-  if (hash < 0)
-    hash = hashf (name, len, HASHSIZE);
-
-  i = sizeof (HASHNODE) + len + 1;
-  hp = (HASHNODE *) xmalloc (i);
-  bucket = hash;
-  hp->bucket_hdr = &hashtab[bucket];
-  hp->next = hashtab[bucket];
-  hashtab[bucket] = hp;
-  hp->prev = NULL;
-  if (hp->next != NULL)
-    hp->next->prev = hp;
-  hp->type = type;
-  hp->length = len;
-  hp->value.cpval = value;
-  hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
-  p = hp->name;
-  q = name;
-  for (i = 0; i < len; i++)
-    *p++ = *q++;
-  hp->name[len] = 0;
-  return hp;
-}
-
-/*
- * find the most recent hash node for name name (ending with first
- * non-identifier char) installed by install
- *
- * If LEN is >= 0, it is the length of the name.
- * Otherwise, compute the length by scanning the entire name.
- *
- * If HASH is >= 0, it is the precomputed hash code.
- * Otherwise, compute the hash code.
- */
-
-HASHNODE *
-lookup (name, len, hash)
-     U_CHAR *name;
-     int len;
-     int hash;
-{
-  register U_CHAR *bp;
-  register HASHNODE *bucket;
-
-  if (len < 0) {
-    for (bp = name; is_idchar[*bp]; bp++) ;
-    len = bp - name;
-  }
-
-  if (hash < 0)
-    hash = hashf (name, len, HASHSIZE);
-
-  bucket = hashtab[hash];
-  while (bucket) {
-    if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
-      return bucket;
-    bucket = bucket->next;
-  }
-  return NULL;
-}
-
-/*
- * Delete a hash node.  Some weirdness to free junk from macros.
- * More such weirdness will have to be added if you define more hash
- * types that need it.
- */
-
-/* Note that the DEFINITION of a macro is removed from the hash table
-   but its storage is not freed.  This would be a storage leak
-   except that it is not reasonable to keep undefining and redefining
-   large numbers of macros many times.
-   In any case, this is necessary, because a macro can be #undef'd
-   in the middle of reading the arguments to a call to it.
-   If #undef freed the DEFINITION, that would crash.  */
-
-static void
-delete_macro (hp)
-     HASHNODE *hp;
-{
-
-  if (hp->prev != NULL)
-    hp->prev->next = hp->next;
-  if (hp->next != NULL)
-    hp->next->prev = hp->prev;
-
-  /* Make sure that the bucket chain header that the deleted guy was
-     on points to the right thing afterwards.  */
-  if (hp == *hp->bucket_hdr)
-    *hp->bucket_hdr = hp->next;
-
-#if 0
-  if (hp->type == T_MACRO) {
-    DEFINITION *d = hp->value.defn;
-    struct reflist *ap, *nextap;
-
-    for (ap = d->pattern; ap != NULL; ap = nextap) {
-      nextap = ap->next;
-      free (ap);
-    }
-    free (d);
-  }
-#endif
-  free (hp);
-}
-
-/*
- * return hash function on name.  must be compatible with the one
- * computed a step at a time, elsewhere
- */
-
-static int
-hashf (name, len, hashsize)
-     register U_CHAR *name;
-     register int len;
-     int hashsize;
-{
-  register int r = 0;
-
-  while (len--)
-    r = HASHSTEP (r, *name++);
-
-  return MAKE_POS (r) % hashsize;
-}
-
-
-/* Dump the definition of a single macro HP to OF.  */
-
-static void
-dump_single_macro (hp, of)
-     register HASHNODE *hp;
-     FILE *of;
-{
-  register DEFINITION *defn = hp->value.defn;
-  struct reflist *ap;
-  int offset;
-  int concat;
-
-
-  /* Print the definition of the macro HP.  */
-
-  fprintf (of, "#define %s", hp->name);
-
-  if (defn->nargs >= 0) {
-    int i;
-
-    fprintf (of, "(");
-    for (i = 0; i < defn->nargs; i++) {
-      dump_arg_n (defn, i, of);
-      if (i + 1 < defn->nargs)
-        fprintf (of, ", ");
-    }
-    fprintf (of, ")");
-  }
-
-  fprintf (of, " ");
-
-  offset = 0;
-  concat = 0;
-  for (ap = defn->pattern; ap != NULL; ap = ap->next) {
-    dump_defn_1 (defn->expansion, offset, ap->nchars, of);
-    offset += ap->nchars;
-    if (!traditional) {
-      if (ap->nchars != 0)
-        concat = 0;
-      if (ap->stringify) {
-        switch (ap->stringify) {
-         case SHARP_TOKEN: fprintf (of, "#"); break;
-         case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
-         case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
-         case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
-         default: abort ();
-        }
-      }
-      if (ap->raw_before != 0) {
-        if (concat) {
-          switch (ap->raw_before) {
-           case WHITE_SHARP_TOKEN:
-           case WHITE_PERCENT_COLON_TOKEN:
-            fprintf (of, " ");
-            break;
-           default:
-            break;
-          }
-        } else {
-          switch (ap->raw_before) {
-           case SHARP_TOKEN: fprintf (of, "##"); break;
-           case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
-           case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
-           case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
-           default: abort ();
-          }
-        }
-      }
-      concat = 0;
-    }
-    dump_arg_n (defn, ap->argno, of);
-    if (!traditional && ap->raw_after != 0) {
-      switch (ap->raw_after) {
-       case SHARP_TOKEN: fprintf (of, "##"); break;
-       case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
-       case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
-       case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
-       default: abort ();
-      }
-      concat = 1;
-    }
-  }
-  dump_defn_1 (defn->expansion, offset, defn->length - offset, of);
-  fprintf (of, "\n");
-}
-
-/* Dump all macro definitions as #defines to stdout.  */
-
-static void
-dump_all_macros ()
-{
-  int bucket;
-
-  for (bucket = 0; bucket < HASHSIZE; bucket++) {
-    register HASHNODE *hp;
-
-    for (hp = hashtab[bucket]; hp; hp= hp->next) {
-      if (hp->type == T_MACRO)
-        dump_single_macro (hp, stdout);
-    }
-  }
-}
-
-/* Output to OF a substring of a macro definition.
-   BASE is the beginning of the definition.
-   Output characters START thru LENGTH.
-   Unless traditional, discard newlines outside of strings, thus
-   converting funny-space markers to ordinary spaces.  */
-
-static void
-dump_defn_1 (base, start, length, of)
-     U_CHAR *base;
-     int start;
-     int length;
-     FILE *of;
-{
-  U_CHAR *p = base + start;
-  U_CHAR *limit = base + start + length;
-
-  if (traditional)
-    fwrite (p, sizeof (*p), length, of);
-  else {
-    while (p < limit) {
-      if (*p == '\"' || *p =='\'') {
-        U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
-                                         NULL_PTR, NULL_PTR);
-        fwrite (p, sizeof (*p), p1 - p, of);
-        p = p1;
-      } else {
-        if (*p != '\n')
-          putc (*p, of);
-        p++;
-      }
-    }
-  }
-}
-
-/* Print the name of argument number ARGNUM of macro definition DEFN
-   to OF.
-   Recall that DEFN->args.argnames contains all the arg names
-   concatenated in reverse order with comma-space in between.  */
-
-static void
-dump_arg_n (defn, argnum, of)
-     DEFINITION *defn;
-     int argnum;
-     FILE *of;
-{
-  register U_CHAR *p = defn->args.argnames;
-  while (argnum + 1 < defn->nargs) {
-    p = (U_CHAR *) index ((char *) p, ' ') + 1;
-    argnum++;
-  }
-
-  while (*p && *p != ',') {
-    putc (*p, of);
-    p++;
-  }
-}
-
-/* Initialize syntactic classifications of characters.  */
-
-static void
-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.
-   */
-  for (i = 'a'; i <= 'z'; i++) {
-    is_idchar[i - 'a' + 'A'] = 1;
-    is_idchar[i] = 1;
-    is_idstart[i - 'a' + 'A'] = 1;
-    is_idstart[i] = 1;
-  }
-  for (i = '0'; i <= '9'; i++)
-    is_idchar[i] = 1;
-  is_idchar['_'] = 1;
-  is_idstart['_'] = 1;
-  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;
-
-  char_name['\v'] = "vertical tab";
-  char_name['\f'] = "formfeed";
-  char_name['\r'] = "carriage return";
-}
-
-/* Initialize the built-in macros.  */
-
-static void
-initialize_builtins (inp, outp)
-     FILE_BUF *inp;
-     FILE_BUF *outp;
-{
-  install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
-  install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
-  install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
-  install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
-  install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
-  install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
-#ifndef NO_BUILTIN_SIZE_TYPE
-  install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
-#endif
-#ifndef NO_BUILTIN_PTRDIFF_TYPE
-  install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
-#endif
-  install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
-  install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
-           NULL_PTR, -1);
-  install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
-           NULL_PTR, -1);
-  install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
-           NULL_PTR, -1);
-  install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
-  if (!traditional) {
-    install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
-    install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
-  }
-  if (objc)
-    install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -1);
-/*  This is supplied using a -D by the compiler driver
-    so that it is present only when truly compiling with GNU C.  */
-/*  install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1);  */
-  install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
-
-  if (debug_output)
-    {
-      char directive[2048];
-      U_CHAR *udirective = (U_CHAR *) directive;
-      register struct directive *dp = &directive_table[0];
-      struct tm *timebuf = timestamp ();
-
-      sprintf (directive, " __BASE_FILE__ \"%s\"\n",
-               instack[0].nominal_fname);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-
-      sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-
-#ifndef NO_BUILTIN_SIZE_TYPE
-      sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-#endif
-
-#ifndef NO_BUILTIN_PTRDIFF_TYPE
-      sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-#endif
-
-      sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-
-      sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
-               monthnames[timebuf->tm_mon],
-               timebuf->tm_mday, timebuf->tm_year + 1900);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-
-      sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
-               timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
-      output_line_directive (inp, outp, 0, same_file);
-      pass_thru_directive (udirective, &udirective[strlen (directive)],
-                           outp, dp);
-
-      if (!traditional)
-        {
-          sprintf (directive, " __STDC__ 1");
-          output_line_directive (inp, outp, 0, same_file);
-          pass_thru_directive (udirective, &udirective[strlen (directive)],
-                               outp, dp);
-        }
-      if (objc)
-        {
-          sprintf (directive, " __OBJC__ 1");
-          output_line_directive (inp, outp, 0, same_file);
-          pass_thru_directive (udirective, &udirective[strlen (directive)],
-                               outp, dp);
-        }
-    }
-}
-
-/*
- * process a given definition string, for initialization
- * If STR is just an identifier, define it with value 1.
- * If STR has anything after the identifier, then it should
- * be identifier=definition.
- */
-
-static void
-make_definition (str, op)
-     char *str;
-     FILE_BUF *op;
-{
-  FILE_BUF *ip;
-  struct directive *kt;
-  U_CHAR *buf, *p;
-
-  p = buf = (U_CHAR *) str;
-  if (!is_idstart[*p]) {
-    error ("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");
-  } else if (*p != '=') {
-    error ("malformed option `-D %s'", str);
-    return;
-  } else {
-    U_CHAR *q;
-    /* Copy the entire option so we can modify it.  */
-    buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
-    strncpy ((char *) buf, str, p - (U_CHAR *) str);
-    /* Change the = to a space.  */
-    buf[p - (U_CHAR *) str] = ' ';
-    /* Scan for any backslash-newline and remove it.  */
-    p++;
-    q = &buf[p - (U_CHAR *) str];
-    while (*p) {
-      if (*p == '\"' || *p == '\'') {
-        int unterminated = 0;
-        U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
-                                         NULL_PTR, NULL_PTR, &unterminated);
-        if (unterminated)
-          return;
-        while (p != p1)
-          *q++ = *p++;
-      } else if (*p == '\\' && p[1] == '\n')
-        p += 2;
-      /* Change newline chars into newline-markers.  */
-      else if (*p == '\n')
-        {
-          *q++ = '\n';
-          *q++ = '\n';
-          p++;
-        }
-      else
-        *q++ = *p++;
-    }
-    *q = 0;
-  }
-  
-  ip = &instack[++indepth];
-  ip->nominal_fname = ip->fname = "*Initialization*";
-
-  ip->buf = ip->bufp = buf;
-  ip->length = strlen ((char *) buf);
-  ip->lineno = 1;
-  ip->macro = 0;
-  ip->free_ptr = 0;
-  ip->if_stack = if_stack;
-  ip->system_header_p = 0;
-
-  for (kt = directive_table; kt->type != T_DEFINE; kt++)
-    ;
-
-  /* Pass NULL instead of OP, since this is a "predefined" macro.  */
-  do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
-  --indepth;
-}
-
-/* JF, this does the work for the -U option */
-
-static void
-make_undef (str, op)
-     char *str;
-     FILE_BUF *op;
-{
-  FILE_BUF *ip;
-  struct directive *kt;
-
-  ip = &instack[++indepth];
-  ip->nominal_fname = ip->fname = "*undef*";
-
-  ip->buf = ip->bufp = (U_CHAR *) str;
-  ip->length = strlen (str);
-  ip->lineno = 1;
-  ip->macro = 0;
-  ip->free_ptr = 0;
-  ip->if_stack = if_stack;
-  ip->system_header_p = 0;
-
-  for (kt = directive_table; kt->type != T_UNDEF; kt++)
-    ;
-
-  do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
-  --indepth;
-}
-
-/* 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 (option, str)
-     char *option;
-     char *str;
-{
-  FILE_BUF *ip;
-  struct directive *kt;
-  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 (*p == '\\' && p[1] == '\n')
-      p += 2;
-    else
-      *q++ = *p++;
-  }
-  *q = 0;
-
-  p = buf;
-  if (!is_idstart[*p]) {
-    error ("malformed option `%s %s'", option, str);
-    return;
-  }
-  while (is_idchar[*++p])
-    ;
-  SKIP_WHITE_SPACE (p);
-  if (! (*p == 0 || *p == '(')) {
-    error ("malformed option `%s %s'", option, str);
-    return;
-  }
-  
-  ip = &instack[++indepth];
-  ip->nominal_fname = ip->fname = "*Initialization*";
-
-  ip->buf = ip->bufp = buf;
-  ip->length = strlen ((char *) buf);
-  ip->lineno = 1;
-  ip->macro = 0;
-  ip->free_ptr = 0;
-  ip->if_stack = if_stack;
-  ip->system_header_p = 0;
-
-  for (kt = directive_table; kt->type != T_ASSERT; kt++)
-    ;
-
-  /* Pass NULL as output ptr to do_define since we KNOW it never does
-     any output....  */
-  do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
-  --indepth;
-}
-
-#ifndef DIR_SEPARATOR
-#define DIR_SEPARATOR '/'
-#endif
-
-/* The previous include prefix, if any, is PREV_FILE_NAME.
-   Translate any pathnames with COMPONENT.
-   Allocate a new include prefix whose name is the
-   simplified concatenation of PREFIX and NAME,
-   with a trailing / added if needed.
-   But return 0 if the include prefix should be ignored,
-   e.g. because it is a duplicate of PREV_FILE_NAME.  */
-
-static struct file_name_list *
-new_include_prefix (prev_file_name, component, prefix, name)
-     struct file_name_list *prev_file_name;
-     char *component;
-     char *prefix;
-     char *name;
-{
-  if (name == 0)
-    fatal ("Directory name missing after command line option");
-
-  if (*name == 0)
-    /* Ignore the empty string.  */
-    return 0;
-
-  prefix = update_path (prefix, component);
-  name = update_path (name, component);
-
-  {
-    struct file_name_list *dir
-      = ((struct file_name_list *)
-         xmalloc (sizeof (struct file_name_list)
-                  + strlen (prefix) + strlen (name) + 2));
-    size_t len;
-    strcpy (dir->fname, prefix);
-    strcat (dir->fname, name);
-    len = simplify_filename (dir->fname);
-
-    /* Convert directory name to a prefix.  */
-    if (dir->fname[len - 1] != DIR_SEPARATOR) {
-      if (len == 1 && dir->fname[len - 1] == '.')
-        len = 0;
-      else
-        dir->fname[len++] = DIR_SEPARATOR;
-      dir->fname[len] = 0;
-    }
-
-    /* Ignore a directory whose name matches the previous one.  */
-    if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
-      /* But treat `-Idir -I- -Idir' as `-I- -Idir'.  */
-      if (!first_bracket_include)
-        first_bracket_include = prev_file_name;
-      free (dir);
-      return 0;
-    }
-
-#ifndef VMS
-    /* VMS can't stat dir prefixes, so skip these optimizations in VMS.  */
-
-    /* Add a trailing "." if there is a filename.  This increases the number
-       of systems that can stat directories.  We remove it below.  */
-    if (len != 0)
-      {
-        dir->fname[len] = '.';
-        dir->fname[len + 1] = 0;
-      }
-
-    /* Ignore a nonexistent directory.  */
-    if (stat (len ? dir->fname : ".", &dir->st) != 0) {
-      if (errno != ENOENT && errno != ENOTDIR)
-        error_from_errno (dir->fname);
-      free (dir);
-      return 0;
-    }
-
-    if (len != 0)
-      dir->fname[len] = 0;
-
-    /* Ignore a directory whose identity matches the previous one.  */
-    if (prev_file_name
-        && INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
-        && prev_file_name->st.st_dev == dir->st.st_dev) {
-      /* But treat `-Idir -I- -Idir' as `-I- -Idir'.  */
-      if (!first_bracket_include)
-        first_bracket_include = prev_file_name;
-      free (dir);
-      return 0;
-    }
-#endif /* ! VMS */
-
-    dir->next = 0;
-    dir->c_system_include_path = 0;
-    dir->got_name_map = 0;
-
-    return dir;
-  }
-}
-
-/* Append a chain of `struct file_name_list's
-   to the end of the main include chain.
-   FIRST is the beginning of the chain to append, and LAST is the end.  */
-
-static void
-append_include_chain (first, last)
-     struct file_name_list *first, *last;
-{
-  struct file_name_list *dir;
-
-  if (!first || !last)
-    return;
-
-  if (include == 0)
-    include = first;
-  else
-    last_include->next = first;
-
-  if (first_bracket_include == 0)
-    first_bracket_include = first;
-
-  for (dir = first; ; dir = dir->next) {
-    int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
-    if (len > max_include_len)
-      max_include_len = len;
-    if (dir == last)
-      break;
-  }
-
-  last->next = NULL;
-  last_include = last;
-}
-
-/* Place into DST a representation of the file named SRC that is suitable
-   for `make'.  Do not null-terminate DST.  Return its length.  */
-static int
-quote_string_for_make (dst, src)
-     char *dst;
-     char *src;
-{
-  char *p = src;
-  int i = 0;
-  for (;;)
-    {
-      char c = *p++;
-      switch (c)
-        {
-        case '\0':
-        case ' ':
-        case '\t':
-          {
-            /* GNU make uses a weird quoting scheme for white space.
-               A space or tab preceded by 2N+1 backslashes represents
-               N backslashes followed by space; a space or tab
-               preceded by 2N backslashes represents N backslashes at
-               the end of a file name; and backslashes in other
-               contexts should not be doubled.  */
-            char *q;
-            for (q = p - 1; src < q && q[-1] == '\\';  q--)
-              {
-                if (dst)
-                  dst[i] = '\\';
-                i++;
-              }
-          }
-          if (!c)
-            return i;
-          if (dst)
-            dst[i] = '\\';
-          i++;
-          goto ordinary_char;
-          
-        case '$':
-          if (dst)
-            dst[i] = c;
-          i++;
-          /* Fall through.  This can mishandle things like "$(" but
-             there's no easy fix.  */
-        default:
-        ordinary_char:
-          /* This can mishandle characters in the string "\0\n%*?[\\~";
-             exactly which chars are mishandled depends on the `make' version.
-             We know of no portable solution for this;
-             even GNU make 3.76.1 doesn't solve the problem entirely.
-             (Also, '\0' is mishandled due to our calling conventions.)  */
-          if (dst)
-            dst[i] = c;
-          i++;
-          break;
-        }
-    }
-}
-
-
-/* Add output to `deps_buffer' for the -M switch.
-   STRING points to the text to be output.
-   SPACER is ':' for targets, ' ' for dependencies.  */
-
-static void
-deps_output (string, spacer)
-     char *string;
-     int spacer;
-{
-  int size = quote_string_for_make ((char *) 0, string);
-
-  if (size == 0)
-    return;
-
-#ifndef MAX_OUTPUT_COLUMNS
-#define MAX_OUTPUT_COLUMNS 72
-#endif
-  if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
-      && 1 < deps_column) {
-    bcopy (" \\\n ", &deps_buffer[deps_size], 4);
-    deps_size += 4;
-    deps_column = 1;
-    if (spacer == ' ')
-      spacer = 0;
-  }
-
-  if (deps_size + size + 8 > deps_allocated_size) {
-    deps_allocated_size = (deps_size + size + 50) * 2;
-    deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
-  }
-  if (spacer == ' ') {
-    deps_buffer[deps_size++] = ' ';
-    deps_column++;
-  }
-  quote_string_for_make (&deps_buffer[deps_size], string);
-  deps_size += size;
-  deps_column += size;
-  if (spacer == ':') {
-    deps_buffer[deps_size++] = ':';
-    deps_column++;
-  }
-  deps_buffer[deps_size] = 0;
-}
-
-static void
-fatal (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  fprintf (stderr, "%s: ", progname);
-  VA_START (args, msg);
-  vfprintf (stderr, msg, args);
-  va_end (args);
-  fprintf (stderr, "\n");
-  exit (FATAL_EXIT_CODE);
-}
-
-/* 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 ()
-{
-  fatal ("Internal gcc abort.");
-}
-
-static void
-perror_with_name (name)
-     char *name;
-{
-  fprintf (stderr, "%s: %s: %s\n", progname, name, my_strerror (errno));
-  errors++;
-}
-
-static void
-pfatal_with_name (name)
-     char *name;
-{
-  perror_with_name (name);
-#ifdef VMS
-  exit (vaxc$errno);
-#else
-  exit (FATAL_EXIT_CODE);
-#endif
-}
-
-/* Handler for SIGPIPE.  */
-
-static void
-pipe_closed (signo)
-     /* If this is missing, some compilers complain.  */
-     int signo;
-{
-  fatal ("output pipe has been closed");
-}
-
-static void
-memory_full ()
-{
-  fatal ("Memory exhausted.");
-}
-
-
-GENERIC_PTR
-xmalloc (size)
-     size_t size;
-{
-  register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
-  if (!ptr)
-    memory_full ();
-  return ptr;
-}
-
-static GENERIC_PTR
-xrealloc (old, size)
-     GENERIC_PTR old;
-     size_t size;
-{
-  register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
-  if (!ptr)
-    memory_full ();
-  return ptr;
-}
-
-static GENERIC_PTR
-xcalloc (number, size)
-     size_t number, size;
-{
-  register size_t total = number * size;
-  register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
-  if (!ptr)
-    memory_full ();
-  bzero (ptr, total);
-  return ptr;
-}
-
-static char *
-savestring (input)
-     char *input;
-{
-  size_t size = strlen (input);
-  char *output = xmalloc (size + 1);
-  strcpy (output, input);
-  return output;
-}
-
-#ifdef VMS
-
-/* Under VMS we need to fix up the "include" specification filename so
-   that everything following the 1st slash is changed into its correct
-   VMS file specification.  */
-
-static void
-hack_vms_include_specification (fname, vaxc_include)
-     char *fname;
-     int vaxc_include;
-{
-  register char *cp, *cp1, *cp2;
-  int f, check_filename_before_returning;
-  char Local[512];
-
-  check_filename_before_returning = 0;
-
-  cp = base_name (fname);
-
-  /*
-   * Check if we have a vax-c style '#include filename'
-   * and add the missing .h
-   */
-  if (vaxc_include && !index (cp,'.'))
-    strcat (cp, ".h");
-
-  cp2 = Local;                  /* initialize */
-
-  /* We are trying to do a number of things here.  First of all, we are
-     trying to hammer the filenames into a standard format, such that later
-     processing can handle them.
-     
-     If the file name contains something like [dir.], then it recognizes this
-     as a root, and strips the ".]".  Later processing will add whatever is
-     needed to get things working properly.
-     
-     If no device is specified, then the first directory name is taken to be
-     a device name (or a rooted logical).  */
-
-  /* See if we found that 1st slash */
-  if (cp == 0) return;          /* Nothing to do!!! */
-  if (*cp != '/') return;       /* Nothing to do!!! */
-  /* Point to the UNIX filename part (which needs to be fixed!) */
-  cp1 = cp+1;
-  /* If the directory spec is not rooted, we can just copy
-     the UNIX filename part and we are done */
-  if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) {
-    if (cp[-2] != '.') {
-      /*
-       * The VMS part ends in a `]', and the preceding character is not a `.'.
-       * We strip the `]', and then splice the two parts of the name in the
-       * usual way.  Given the default locations for include files in cccp.c,
-       * we will only use this code if the user specifies alternate locations
-       * with the /include (-I) switch on the command line.  */
-      cp -= 1;                  /* Strip "]" */
-      cp1--;                    /* backspace */
-    } else {
-      /*
-       * The VMS part has a ".]" at the end, and this will not do.  Later
-       * processing will add a second directory spec, and this would be a syntax
-       * error.  Thus we strip the ".]", and thus merge the directory specs.
-       * We also backspace cp1, so that it points to a '/'.  This inhibits the
-       * generation of the 000000 root directory spec (which does not belong here
-       * in this case).
-       */
-      cp -= 2;                  /* Strip ".]" */
-      cp1--; };                 /* backspace */
-  } else {
-
-    /* We drop in here if there is no VMS style directory specification yet.
-     * If there is no device specification either, we make the first dir a
-     * device and try that.  If we do not do this, then we will be essentially
-     * searching the users default directory (as if they did a #include "asdf.h").
-     *
-     * Then all we need to do is to push a '[' into the output string. Later
-     * processing will fill this in, and close the bracket.
-     */
-    if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec.  take first dir */
-    *cp2++ = '[';               /* Open the directory specification */
-  }
-
-  /* at this point we assume that we have the device spec, and (at least
-     the opening "[" for a directory specification.  We may have directories
-     specified already */
-
-  /* If there are no other slashes then the filename will be
-     in the "root" directory.  Otherwise, we need to add
-     directory specifications.  */
-  if (index (cp1, '/') == 0) {
-    /* Just add "000000]" as the directory string */
-    strcpy (cp2, "000000]");
-    cp2 += strlen (cp2);
-    check_filename_before_returning = 1; /* we might need to fool with this later */
-  } else {
-    /* As long as there are still subdirectories to add, do them.  */
-    while (index (cp1, '/') != 0) {
-      /* If this token is "." we can ignore it */
-      if ((cp1[0] == '.') && (cp1[1] == '/')) {
-        cp1 += 2;
-        continue;
-      }
-      /* Add a subdirectory spec. Do not duplicate "." */
-      if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<')
-        *cp2++ = '.';
-      /* If this is ".." then the spec becomes "-" */
-      if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
-        /* Add "-" and skip the ".." */
-        *cp2++ = '-';
-        cp1 += 3;
-        continue;
-      }
-      /* Copy the subdirectory */
-      while (*cp1 != '/') *cp2++= *cp1++;
-      cp1++;                    /* Skip the "/" */
-    }
-    /* Close the directory specification */
-    if (cp2[-1] == '.')         /* no trailing periods */
-      cp2--;
-    *cp2++ = ']';
-  }
-  /* Now add the filename */
-  while (*cp1) *cp2++ = *cp1++;
-  *cp2 = 0;
-  /* Now append it to the original VMS spec.  */
-  strcpy (cp, Local);
-
-  /* If we put a [000000] in the filename, try to open it first. If this fails,
-     remove the [000000], and return that name.  This provides flexibility
-     to the user in that they can use both rooted and non-rooted logical names
-     to point to the location of the file.  */
-
-  if (check_filename_before_returning) {
-    f = open (fname, O_RDONLY, 0666);
-    if (f >= 0) {
-      /* The file name is OK as it is, so return it as is.  */
-      close (f);
-      return;
-    }
-    /* The filename did not work.  Try to remove the [000000] from the name,
-       and return it.  */
-    cp = index (fname, '[');
-    cp2 = index (fname, ']') + 1;
-    strcpy (cp, cp2);           /* this gets rid of it */
-  }
-  return;
-}
-#endif  /* VMS */
-
-#ifdef  VMS
-
-/* The following wrapper functions supply additional arguments to the VMS
-   I/O routines to optimize performance with file handling.  The arguments
-   are:
-     "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
-     "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
-     "fop=tef"- Truncate unused portions of file when closing file.
-     "shr=nil"- Disallow file sharing while file is open.  */
-
-static FILE *
-VMS_freopen (fname, type, oldfile)
-     char *fname;
-     char *type;
-     FILE *oldfile;
-{
-#undef freopen  /* Get back the real freopen routine.  */
-  if (strcmp (type, "w") == 0)
-    return freopen (fname, type, oldfile,
-                         "mbc=16", "deq=64", "fop=tef", "shr=nil");
-  return freopen (fname, type, oldfile, "mbc=16");
-}
-
-static FILE *
-VMS_fopen (fname, type)
-     char *fname;
-     char *type;
-{
-#undef fopen    /* Get back the real fopen routine.  */
-  /* The gcc-vms-1.42 distribution's header files prototype fopen with two
-     fixed arguments, which matches ANSI's specification but not VAXCRTL's
-     pre-ANSI implementation.  This hack circumvents the mismatch problem.  */
-  FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
-
-  if (*type == 'w')
-    return (*vmslib_fopen) (fname, type, "mbc=32",
-                            "deq=64", "fop=tef", "shr=nil");
-  else
-    return (*vmslib_fopen) (fname, type, "mbc=32");
-}
-
-static int 
-VMS_open (fname, flags, prot)
-     char *fname;
-     int flags;
-     int prot;
-{
-#undef open     /* Get back the real open routine.  */
-  return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
-}
-
-/* more VMS hackery */
-#include <fab.h>
-#include <nam.h>
-
-extern unsigned long sys$parse(), sys$search();
-
-/* Work around another library bug.  If a file is located via a searchlist,
-   and if the device it's on is not the same device as the one specified
-   in the first element of that searchlist, then both stat() and fstat()
-   will fail to return info about it.  `errno' will be set to EVMSERR, and
-   `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
-   We can get around this by fully parsing the filename and then passing
-   that absolute name to stat().
-
-   Without this fix, we can end up failing to find header files, which is
-   bad enough, but then compounding the problem by reporting the reason for
-   failure as "normal successful completion."  */
-
-#undef fstat    /* Get back to the library version.  */
-
-static int
-VMS_fstat (fd, statbuf)
-     int fd;
-     struct stat *statbuf;
-{
-  int result = fstat (fd, statbuf);
-
-  if (result < 0)
-    {
-      FILE *fp;
-      char nambuf[NAM$C_MAXRSS+1];
-
-      if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
-        result = VMS_stat (nambuf, statbuf);
-      /* No fclose(fp) here; that would close(fd) as well.  */
-    }
-
-  return result;
-}
-
-static int
-VMS_stat (name, statbuf)
-     const char *name;
-     struct stat *statbuf;
-{
-  int result = stat (name, statbuf);
-
-  if (result < 0)
-    {
-      struct FAB fab;
-      struct NAM nam;
-      char exp_nam[NAM$C_MAXRSS+1],  /* expanded name buffer for sys$parse */
-           res_nam[NAM$C_MAXRSS+1];  /* resultant name buffer for sys$search */
-
-      fab = cc$rms_fab;
-      fab.fab$l_fna = (char *) name;
-      fab.fab$b_fns = (unsigned char) strlen (name);
-      fab.fab$l_nam = (void *) &nam;
-      nam = cc$rms_nam;
-      nam.nam$l_esa = exp_nam,  nam.nam$b_ess = sizeof exp_nam - 1;
-      nam.nam$l_rsa = res_nam,  nam.nam$b_rss = sizeof res_nam - 1;
-      nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
-      if (sys$parse (&fab) & 1)
-        {
-          if (sys$search (&fab) & 1)
-            {
-              res_nam[nam.nam$b_rsl] = '\0';
-              result = stat (res_nam, statbuf);
-            }
-          /* Clean up searchlist context cached by the system.  */
-          nam.nam$b_nop = NAM$M_SYNCHK;
-          fab.fab$l_fna = 0,  fab.fab$b_fns = 0;
-          (void) sys$parse (&fab);
-        }
-    }
-
-  return result;
-}
-#endif /* VMS */
diff --git a/cpp/src/icecpp/cexp.y b/cpp/src/icecpp/cexp.y
deleted file mode 100644
index 69385cca9dc..00000000000
--- a/cpp/src/icecpp/cexp.y
+++ /dev/null
@@ -1,1223 +0,0 @@
-/* Parse C expressions for CCCP.
-   Copyright (C) 1987, 1992, 1994, 1995, 1996, 1997 Free Software Foundation.
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, 51
-Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
- In other words, you are welcome to use, share and improve this program.
- You are forbidden to forbid anyone else to use, share and improve
- what you give them.   Help stamp out software-hoarding!
-
- Adapted from expread.y of GDB by Paul Rubin, July 1986.  */
-
-/* Parse a C expression from text in a string  */
-   
-%{
-#include "config.h"
-#include <setjmp.h>
-/* #define YYDEBUG 1 */
-
-
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
-
-#ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-
-#ifdef HAVE_LIMITS_H
-# include <limits.h>
-#endif
-
-#ifdef MULTIBYTE_CHARS
-#include <locale.h>
-#endif
-
-#include <stdio.h>
-
-typedef unsigned char U_CHAR;
-
-/* This is used for communicating lists of keywords with cccp.c.  */
-struct arglist {
-  struct arglist *next;
-  U_CHAR *name;
-  int length;
-  int argno;
-};
-
-/* Define a generic NULL if one hasn't already been defined.  */
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef GENERIC_PTR
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define GENERIC_PTR void *
-#else
-#define GENERIC_PTR char *
-#endif
-#endif
-
-#ifndef NULL_PTR
-#define NULL_PTR ((GENERIC_PTR) 0)
-#endif
-
-/* Find the largest host integer type and set its size and type.
-   Watch out: on some crazy hosts `long' is shorter than `int'.  */
-
-#ifndef HOST_WIDE_INT
-# if HAVE_INTTYPES_H
-#  include <inttypes.h>
-#  define HOST_WIDE_INT intmax_t
-#  define unsigned_HOST_WIDE_INT uintmax_t
-# else
-#  if (HOST_BITS_PER_LONG <= HOST_BITS_PER_INT && HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_INT)
-#   define HOST_WIDE_INT int
-#  else
-#  if (HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_LONG || ! (defined LONG_LONG_MAX || defined LLONG_MAX))
-#   define HOST_WIDE_INT long
-#  else
-#   define HOST_WIDE_INT long long
-#  endif
-#  endif
-# endif
-#endif
-
-#ifndef unsigned_HOST_WIDE_INT
-#define unsigned_HOST_WIDE_INT unsigned HOST_WIDE_INT
-#endif
-
-#ifndef CHAR_BIT
-#define CHAR_BIT 8
-#endif
-
-#ifndef HOST_BITS_PER_WIDE_INT
-#define HOST_BITS_PER_WIDE_INT (CHAR_BIT * sizeof (HOST_WIDE_INT))
-#endif
-
-#ifdef _MSC_VER
-// I get these warnings from some bison versions:
-// warning C4102: 'yyoverflowlab' : unreferenced label
-#   pragma warning( disable : 4102 )
-#endif
-
-#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
-# define __attribute__(x)
-#endif
-
-#ifndef PROTO
-# if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#  define PROTO(ARGS) ARGS
-# else
-#  define PROTO(ARGS) ()
-# endif
-#endif
-
-#if defined (__STDC__) && defined (HAVE_VPRINTF)
-# include <stdarg.h>
-# define VA_START(va_list, var) va_start (va_list, var)
-# define PRINTF_ALIST(msg) char *msg, ...
-# define PRINTF_DCL(msg)
-# define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (__printf__, m, n)))
-#else
-# include <varargs.h>
-# define VA_START(va_list, var) va_start (va_list)
-# define PRINTF_ALIST(msg) msg, va_alist
-# define PRINTF_DCL(msg) char *msg; va_dcl
-# define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (__printf__, m, n)))
-# define vfprintf(file, msg, args) \
-    { \
-      char *a0 = va_arg(args, char *); \
-      char *a1 = va_arg(args, char *); \
-      char *a2 = va_arg(args, char *); \
-      char *a3 = va_arg(args, char *); \
-      fprintf (file, msg, a0, a1, a2, a3); \
-    }
-#endif
-
-#define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
-
-HOST_WIDE_INT parse_c_expression PROTO((char *, int));
-
-static int yylex PROTO((void));
-static void yyerror PROTO((char *)) __attribute__ ((noreturn));
-static HOST_WIDE_INT expression_value;
-#ifdef TEST_EXP_READER
-static int expression_signedp;
-#endif
-
-static jmp_buf parse_return_error;
-
-/* Nonzero means count most punctuation as part of a name.  */
-static int keyword_parsing = 0;
-
-/* Nonzero means do not evaluate this expression.
-   This is a count, since unevaluated expressions can nest.  */
-static int skip_evaluation;
-
-/* Nonzero means warn if undefined identifiers are evaluated.  */
-static int warn_undef;
-
-/* some external tables of character types */
-extern unsigned char is_idstart[], is_idchar[], is_space[];
-
-/* Flag for -pedantic.  */
-extern int pedantic;
-
-/* Flag for -traditional.  */
-extern int traditional;
-
-/* Flag for -lang-c89.  */
-extern int c89;
-
-#ifndef CHAR_TYPE_SIZE
-#define CHAR_TYPE_SIZE BITS_PER_UNIT
-#endif
-
-#ifndef INT_TYPE_SIZE
-#define INT_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef LONG_TYPE_SIZE
-#define LONG_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef MAX_CHAR_TYPE_SIZE
-#define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
-#endif
-
-#ifndef MAX_INT_TYPE_SIZE
-#define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
-#endif
-
-#ifndef MAX_LONG_TYPE_SIZE
-#define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
-#endif
-
-
-#define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
-			    ? (~ (~ (HOST_WIDE_INT) 0 << MAX_CHAR_TYPE_SIZE)) \
-			    : ~ (HOST_WIDE_INT) 0)
-
-
-/* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
-   Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
-   Suppose SIGNEDP is negative if the result is signed, zero if unsigned.
-   Then this yields nonzero if overflow occurred during the addition.
-   Overflow occurs if A and B have the same sign, but A and SUM differ in sign,
-   and SIGNEDP is negative.
-   Use `^' to test whether signs differ, and `< 0' to isolate the sign.  */
-#define overflow_sum_sign(a, b, sum, signedp) \
-	((~((a) ^ (b)) & ((a) ^ (sum)) & (signedp)) < 0)
-
-struct constant;
-
-GENERIC_PTR xmalloc PROTO((size_t));
-HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
-int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
-struct hashnode *lookup PROTO((U_CHAR *, int, int));
-void error PRINTF_PROTO_1((char *, ...));
-void pedwarn PRINTF_PROTO_1((char *, ...));
-void warning PRINTF_PROTO_1((char *, ...));
-
-static int parse_number PROTO((int));
-static HOST_WIDE_INT left_shift PROTO((struct constant *, unsigned_HOST_WIDE_INT));
-static HOST_WIDE_INT right_shift PROTO((struct constant *, unsigned_HOST_WIDE_INT));
-static void integer_overflow PROTO((void));
-
-/* `signedp' values */
-#define SIGNED (~0)
-#define UNSIGNED 0
-
-//
-// Required to allow the code to compile with VC 8 with bison 2.1.
-//
-#if defined(_MSC_VER) && _MSC_VER == 1400
-#   define __STDC__
-#   define YYMALLOC
-#   define YYFREE
-#endif
-
-//
-// Required to allow the code to compile with VC 6 and VC 71 with
-// bison 2.3.
-//
-#if defined(_MSC_VER) && _MSC_VER < 1400
-#   define YYMALLOC malloc
-#   define YYFREE free
-#endif
-
-%}
-
-%union {
-  struct constant {HOST_WIDE_INT value; int signedp;} integer;
-  struct name {U_CHAR *address; int length;} name;
-  struct arglist *keywords;
-}
-
-%type <integer> exp exp1 start
-%type <keywords> keywords
-%token <integer> INT CHAR
-%token <name> NAME
-%token <integer> ERROR
-
-%right '?' ':'
-%left ','
-%left OR
-%left AND
-%left '|'
-%left '^'
-%left '&'
-%left EQUAL NOTEQUAL
-%left '<' '>' LEQ GEQ
-%left LSH RSH
-%left '+' '-'
-%left '*' '/' '%'
-%right UNARY
-
-/* %expect 40 */
-%%
-
-start   :	exp1
-		{
-		  expression_value = $1.value;
-#ifdef TEST_EXP_READER
-		  expression_signedp = $1.signedp;
-#endif
-		}
-	;
-
-/* Expressions, including the comma operator.  */
-exp1	:	exp
-	|	exp1 ',' exp
-			{ if (pedantic)
-			    pedwarn ("comma operator in operand of `#if'");
-			  $$ = $3; }
-	;
-
-/* Expressions, not including the comma operator.  */
-exp	:	'-' exp    %prec UNARY
-			{ $$.value = - $2.value;
-			  $$.signedp = $2.signedp;
-			  if (($$.value & $2.value & $$.signedp) < 0)
-			    integer_overflow (); }
-	|	'!' exp    %prec UNARY
-			{ $$.value = ! $2.value;
-			  $$.signedp = SIGNED; }
-	|	'+' exp    %prec UNARY
-			{ $$ = $2; }
-	|	'~' exp    %prec UNARY
-			{ $$.value = ~ $2.value;
-			  $$.signedp = $2.signedp; }
-	|	'#' NAME
-  			{ $$.value = check_assertion ($2.address, $2.length,
-						      0, NULL_PTR);
-			  $$.signedp = SIGNED; }
-	|	'#' NAME
-			{ keyword_parsing = 1; }
-		'(' keywords ')'
-  			{ $$.value = check_assertion ($2.address, $2.length,
-						      1, $5);
-			  keyword_parsing = 0;
-			  $$.signedp = SIGNED; }
-	|	'(' exp1 ')'
-			{ $$ = $2; }
-	;
-
-/* Binary operators in order of decreasing precedence.  */
-exp	:	exp '*' exp
-			{ $$.signedp = $1.signedp & $3.signedp;
-			  if ($$.signedp)
-			    {
-			      $$.value = $1.value * $3.value;
-			      if ($1.value
-				  && ($$.value / $1.value != $3.value
-				      || ($$.value & $1.value & $3.value) < 0))
-				integer_overflow ();
-			    }
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					* $3.value); }
-	|	exp '/' exp
-			{ if ($3.value == 0)
-			    {
-			      if (!skip_evaluation)
-				error ("division by zero in #if");
-			      $3.value = 1;
-			    }
-			  $$.signedp = $1.signedp & $3.signedp;
-			  if ($$.signedp)
-			    {
-			      $$.value = $1.value / $3.value;
-			      if (($$.value & $1.value & $3.value) < 0)
-				integer_overflow ();
-			    }
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					/ $3.value); }
-	|	exp '%' exp
-			{ if ($3.value == 0)
-			    {
-			      if (!skip_evaluation)
-				error ("division by zero in #if");
-			      $3.value = 1;
-			    }
-			  $$.signedp = $1.signedp & $3.signedp;
-			  if ($$.signedp)
-			    $$.value = $1.value % $3.value;
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					% $3.value); }
-	|	exp '+' exp
-			{ $$.value = $1.value + $3.value;
-			  $$.signedp = $1.signedp & $3.signedp;
-			  if (overflow_sum_sign ($1.value, $3.value,
-						 $$.value, $$.signedp))
-			    integer_overflow (); }
-	|	exp '-' exp
-			{ $$.value = $1.value - $3.value;
-			  $$.signedp = $1.signedp & $3.signedp;
-			  if (overflow_sum_sign ($$.value, $3.value,
-						 $1.value, $$.signedp))
-			    integer_overflow (); }
-	|	exp LSH exp
-			{ $$.signedp = $1.signedp;
-			  if (($3.value & $3.signedp) < 0)
-			    $$.value = right_shift (&$1, -$3.value);
-			  else
-			    $$.value = left_shift (&$1, $3.value); }
-	|	exp RSH exp
-			{ $$.signedp = $1.signedp;
-			  if (($3.value & $3.signedp) < 0)
-			    $$.value = left_shift (&$1, -$3.value);
-			  else
-			    $$.value = right_shift (&$1, $3.value); }
-	|	exp EQUAL exp
-			{ $$.value = ($1.value == $3.value);
-			  $$.signedp = SIGNED; }
-	|	exp NOTEQUAL exp
-			{ $$.value = ($1.value != $3.value);
-			  $$.signedp = SIGNED; }
-	|	exp LEQ exp
-			{ $$.signedp = SIGNED;
-			  if ($1.signedp & $3.signedp)
-			    $$.value = $1.value <= $3.value;
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					<= $3.value); }
-	|	exp GEQ exp
-			{ $$.signedp = SIGNED;
-			  if ($1.signedp & $3.signedp)
-			    $$.value = $1.value >= $3.value;
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					>= $3.value); }
-	|	exp '<' exp
-			{ $$.signedp = SIGNED;
-			  if ($1.signedp & $3.signedp)
-			    $$.value = $1.value < $3.value;
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					< $3.value); }
-	|	exp '>' exp
-			{ $$.signedp = SIGNED;
-			  if ($1.signedp & $3.signedp)
-			    $$.value = $1.value > $3.value;
-			  else
-			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
-					> $3.value); }
-	|	exp '&' exp
-			{ $$.value = $1.value & $3.value;
-			  $$.signedp = $1.signedp & $3.signedp; }
-	|	exp '^' exp
-			{ $$.value = $1.value ^ $3.value;
-			  $$.signedp = $1.signedp & $3.signedp; }
-	|	exp '|' exp
-			{ $$.value = $1.value | $3.value;
-			  $$.signedp = $1.signedp & $3.signedp; }
-	|	exp AND
-			{ skip_evaluation += !$1.value; }
-		exp
-			{ skip_evaluation -= !$1.value;
-			  $$.value = ($1.value && $4.value);
-			  $$.signedp = SIGNED; }
-	|	exp OR
-			{ skip_evaluation += !!$1.value; }
-		exp
-			{ skip_evaluation -= !!$1.value;
-			  $$.value = ($1.value || $4.value);
-			  $$.signedp = SIGNED; }
-	|	exp '?'
-			{ skip_evaluation += !$1.value; }
-	        exp ':'
-			{ skip_evaluation += !!$1.value - !$1.value; }
-		exp
-			{ skip_evaluation -= !!$1.value;
-			  $$.value = $1.value ? $4.value : $7.value;
-			  $$.signedp = $4.signedp & $7.signedp; }
-	|	INT
-			{ $$ = yylval.integer; }
-	|	CHAR
-			{ $$ = yylval.integer; }
-	|	NAME
-			{ if (warn_undef && !skip_evaluation)
-			    warning ("`%.*s' is not defined",
-				     $1.length, $1.address);
-			  $$.value = 0;
-			  $$.signedp = SIGNED; }
-	;
-
-keywords :
-			{ $$ = 0; } 
-	|	'(' keywords ')' keywords
-			{ struct arglist *temp;
-			  $$ = (struct arglist *) xmalloc (sizeof (struct arglist));
-			  $$->next = $2;
-			  $$->name = (U_CHAR *) "(";
-			  $$->length = 1;
-			  temp = $$;
-			  while (temp != 0 && temp->next != 0)
-			    temp = temp->next;
-			  temp->next = (struct arglist *) xmalloc (sizeof (struct arglist));
-			  temp->next->next = $4;
-			  temp->next->name = (U_CHAR *) ")";
-			  temp->next->length = 1; }
-	|	NAME keywords
-			{ $$ = (struct arglist *) xmalloc (sizeof (struct arglist));
-			  $$->name = $1.address;
-			  $$->length = $1.length;
-			  $$->next = $2; } 
-	;
-%%
-
-/* During parsing of a C expression, the pointer to the next character
-   is in this variable.  */
-
-static char *lexptr;
-
-/* Take care of parsing a number (anything that starts with a digit).
-   Set yylval and return the token type; update lexptr.
-   LEN is the number of characters in it.  */
-
-/* maybe needs to actually deal with floating point numbers */
-
-static int
-parse_number (olen)
-     int olen;
-{
-  register char *p = lexptr;
-  register int c;
-  register unsigned_HOST_WIDE_INT n = 0, nd, max_over_base;
-  register int base = 10;
-  register int len = olen;
-  register int overflow = 0;
-  register int digit, largest_digit = 0;
-  int spec_long = 0;
-
-  yylval.integer.signedp = SIGNED;
-
-  if (*p == '0') {
-    base = 8;
-    if (len >= 3 && (p[1] == 'x' || p[1] == 'X')) {
-      p += 2;
-      base = 16;
-      len -= 2;
-    }
-  }
-
-  max_over_base = (unsigned_HOST_WIDE_INT) -1 / base;
-
-  for (; len > 0; len--) {
-    c = *p++;
-
-    if (c >= '0' && c <= '9')
-      digit = c - '0';
-    else if (base == 16 && c >= 'a' && c <= 'f')
-      digit = c - 'a' + 10;
-    else if (base == 16 && c >= 'A' && c <= 'F')
-      digit = c - 'A' + 10;
-    else {
-      /* `l' means long, and `u' means unsigned.  */
-      while (1) {
-	if (c == 'l' || c == 'L')
-	  {
-	    if (!pedantic < spec_long)
-	      yyerror ("too many `l's in integer constant");
-	    spec_long++;
-	  }
-	else if (c == 'u' || c == 'U')
-	  {
-	    if (! yylval.integer.signedp)
-	      yyerror ("two `u's in integer constant");
-	    yylval.integer.signedp = UNSIGNED;
-	  }
-	else {
-	  if (c == '.' || c == 'e' || c == 'E' || c == 'p' || c == 'P')
-	    yyerror ("Floating point numbers not allowed in #if expressions");
-	  else {
-	    char *buf = (char *) alloca (p - lexptr + 40);
-	    sprintf (buf, "missing white space after number `%.*s'",
-		     (int) (p - lexptr - 1), lexptr);
-	    yyerror (buf);
-	  }
-	}
-
-	if (--len == 0)
-	  break;
-	c = *p++;
-      }
-      /* Don't look for any more digits after the suffixes.  */
-      break;
-    }
-    if (largest_digit < digit)
-      largest_digit = digit;
-    nd = n * base + digit;
-    overflow |= (max_over_base < n) | (nd < n);
-    n = nd;
-  }
-
-  if (base <= largest_digit)
-    pedwarn ("integer constant contains digits beyond the radix");
-
-  if (overflow)
-    pedwarn ("integer constant out of range");
-
-  /* If too big to be signed, consider it unsigned.  */
-  if (((HOST_WIDE_INT) n & yylval.integer.signedp) < 0)
-    {
-      if (base == 10)
-	warning ("integer constant is so large that it is unsigned");
-      yylval.integer.signedp = UNSIGNED;
-    }
-
-  lexptr = p;
-  yylval.integer.value = n;
-  return INT;
-}
-
-struct token {
-  char *operator;
-  int token;
-};
-
-static struct token tokentab2[] = {
-  {"&&", AND},
-  {"||", OR},
-  {"<<", LSH},
-  {">>", RSH},
-  {"==", EQUAL},
-  {"!=", NOTEQUAL},
-  {"<=", LEQ},
-  {">=", GEQ},
-  {"++", ERROR},
-  {"--", ERROR},
-  {NULL, ERROR}
-};
-
-/* Read one token, getting characters through lexptr.  */
-
-static int
-yylex ()
-{
-  register int c;
-  register int namelen;
-  register unsigned char *tokstart;
-  register struct token *toktab;
-  
-  HOST_WIDE_INT mask;
-
- retry:
-
-  tokstart = (unsigned char *) lexptr;
-  c = *tokstart;
-  /* See if it is a special token of length 2.  */
-  if (! keyword_parsing)
-    for (toktab = tokentab2; toktab->operator != NULL; toktab++)
-      if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
-	lexptr += 2;
-	if (toktab->token == ERROR)
-	  {
-	    char *buf = (char *) alloca (40);
-	    sprintf (buf, "`%s' not allowed in operand of `#if'", toktab->operator);
-	    yyerror (buf);
-	  }
-	return toktab->token;
-      }
-
-  switch (c) {
-  case '\n':
-    return 0;
-    
-  case ' ':
-  case '\t':
-  case '\r':
-    lexptr++;
-    goto retry;
-
-  case '\'':
-    mask = MAX_CHAR_TYPE_MASK;
-  char_constant:
-    lexptr++;
-    if (keyword_parsing) {
-      char *start_ptr = lexptr - 1;
-      while (1) {
-	c = *lexptr++;
-	if (c == '\\')
-	  c = parse_escape (&lexptr, mask);
-	else if (c == '\'')
-	  break;
-      }
-      yylval.name.address = tokstart;
-      yylval.name.length = lexptr - start_ptr;
-      return NAME;
-    }
-
-    /* This code for reading a character constant
-       handles multicharacter constants and wide characters.
-       It is mostly copied from c-lex.c.  */
-    {
-      register HOST_WIDE_INT result = 0;
-      register int num_chars = 0;
-      unsigned width = MAX_CHAR_TYPE_SIZE;
-      int max_chars;
-      char *token_buffer;
-
-      max_chars = MAX_LONG_TYPE_SIZE / width;
-
-      token_buffer = (char *) alloca (max_chars + 1);
-
-      while (1)
-	{
-	  c = *lexptr++;
-
-	  if (c == '\'' || c == EOF)
-	    break;
-
-	  if (c == '\\')
-	    {
-	      c = parse_escape (&lexptr, mask);
-	    }
-
-	  num_chars++;
-
-	  /* Merge character into result; ignore excess chars.  */
-	  if (num_chars <= max_chars)
-	    {
-	      if (width < HOST_BITS_PER_WIDE_INT)
-		result = (result << width) | c;
-	      else
-		result = c;
-	      token_buffer[num_chars - 1] = c;
-	    }
-	}
-
-      token_buffer[num_chars] = 0;
-
-      if (c != '\'')
-	error ("malformatted character constant");
-      else if (num_chars == 0)
-	error ("empty character constant");
-      else if (num_chars > max_chars)
-	{
-	  num_chars = max_chars;
-	  error ("character constant too long");
-	}
-      else if (num_chars != 1 && ! traditional)
-	warning ("multi-character character constant");
-
-      /* If char type is signed, sign-extend the constant.  */
-      
-	{
-	  int num_bits = num_chars * width;
-
-	  if (lookup ((U_CHAR *) "__CHAR_UNSIGNED__",
-		      sizeof ("__CHAR_UNSIGNED__") - 1, -1)
-	      || ((result >> (num_bits - 1)) & 1) == 0)
-	    yylval.integer.value
-	      = result & (~ (unsigned_HOST_WIDE_INT) 0
-			  >> (HOST_BITS_PER_WIDE_INT - num_bits));
-	  else
-	    yylval.integer.value
-	      = result | ~(~ (unsigned_HOST_WIDE_INT) 0
-			   >> (HOST_BITS_PER_WIDE_INT - num_bits));
-	}
-    }
-
-    /* This is always a signed type.  */
-    yylval.integer.signedp = SIGNED;
-    
-    return CHAR;
-
-    /* some of these chars are invalid in constant expressions;
-       maybe do something about them later */
-  case '/':
-  case '+':
-  case '-':
-  case '*':
-  case '%':
-  case '|':
-  case '&':
-  case '^':
-  case '~':
-  case '!':
-  case '@':
-  case '<':
-  case '>':
-  case '[':
-  case ']':
-  case '.':
-  case '?':
-  case ':':
-  case '=':
-  case '{':
-  case '}':
-  case ',':
-  case '#':
-    if (keyword_parsing)
-      break;
-  case '(':
-  case ')':
-    lexptr++;
-    return c;
-
-  case '"':
-    mask = MAX_CHAR_TYPE_MASK;
-  string_constant:
-    if (keyword_parsing) {
-      char *start_ptr = lexptr;
-      lexptr++;
-      while (1) {
-	c = *lexptr++;
-	if (c == '\\')
-	  c = parse_escape (&lexptr, mask);
-	else if (c == '"')
-	  break;
-      }
-      yylval.name.address = tokstart;
-      yylval.name.length = lexptr - start_ptr;
-      return NAME;
-    }
-    yyerror ("string constants not allowed in #if expressions");
-    return ERROR;
-  }
-
-  if (c >= '0' && c <= '9' && !keyword_parsing) {
-    /* It's a number */
-    for (namelen = 1; ; namelen++) {
-      int d = tokstart[namelen];
-      if (! ((is_idchar[d] || d == '.')
-	     || ((d == '-' || d == '+')
-		 && (c == 'e' || c == 'E'
-		     || ((c == 'p' || c == 'P') && ! c89))
-		 && ! traditional)))
-	break;
-      c = d;
-    }
-    return parse_number (namelen);
-  }
-
-  /* It is a name.  See how long it is.  */
-
-  if (keyword_parsing) {
-    for (namelen = 0;; namelen++) {
-      if (is_space[tokstart[namelen]])
-	break;
-      if (tokstart[namelen] == '(' || tokstart[namelen] == ')')
-	break;
-      if (tokstart[namelen] == '"' || tokstart[namelen] == '\'')
-	break;
-    }
-  } else {
-    if (!is_idstart[c]) {
-      yyerror ("Invalid token in expression");
-      return ERROR;
-    }
-
-    for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
-      ;
-  }
-  
-  lexptr += namelen;
-  yylval.name.address = tokstart;
-  yylval.name.length = namelen;
-  return NAME;
-}
-
-
-/* Parse a C escape sequence.  STRING_PTR points to a variable
-   containing a pointer to the string to parse.  That pointer
-   is updated past the characters we use.  The value of the
-   escape sequence is returned.
-
-   RESULT_MASK is used to mask out the result;
-   an error is reported if bits are lost thereby.
-
-   A negative value means the sequence \ newline was seen,
-   which is supposed to be equivalent to nothing at all.
-
-   If \ is followed by a null character, we return a negative
-   value and leave the string pointer pointing at the null character.
-
-   If \ is followed by 000, we return 0 and leave the string pointer
-   after the zeros.  A value of 0 does not mean end of string.  */
-
-HOST_WIDE_INT
-parse_escape (string_ptr, result_mask)
-     char **string_ptr;
-     HOST_WIDE_INT result_mask;
-{
-  register int c = *(*string_ptr)++;
-  switch (c)
-    {
-    case 'a':
-      return TARGET_BELL;
-    case 'b':
-      return TARGET_BS;
-    case 'e':
-    case 'E':
-      if (pedantic)
-	pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
-      return 033;
-    case 'f':
-      return TARGET_FF;
-    case 'n':
-      return TARGET_NEWLINE;
-    case 'r':
-      return TARGET_CR;
-    case 't':
-      return TARGET_TAB;
-    case 'v':
-      return TARGET_VT;
-    case '\n':
-      return -2;
-    case 0:
-      (*string_ptr)--;
-      return 0;
-      
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-      {
-	register HOST_WIDE_INT i = c - '0';
-	register int count = 0;
-	while (++count < 3)
-	  {
-	    c = *(*string_ptr)++;
-	    if (c >= '0' && c <= '7')
-	      i = (i << 3) + c - '0';
-	    else
-	      {
-		(*string_ptr)--;
-		break;
-	      }
-	  }
-	if (i != (i & result_mask))
-	  {
-	    i &= result_mask;
-	    pedwarn ("octal escape sequence out of range");
-	  }
-	return i;
-      }
-    case 'x':
-      {
-	register unsigned_HOST_WIDE_INT i = 0, overflow = 0;
-	register int digits_found = 0, digit;
-	for (;;)
-	  {
-	    c = *(*string_ptr)++;
-	    if (c >= '0' && c <= '9')
-	      digit = c - '0';
-	    else if (c >= 'a' && c <= 'f')
-	      digit = c - 'a' + 10;
-	    else if (c >= 'A' && c <= 'F')
-	      digit = c - 'A' + 10;
-	    else
-	      {
-		(*string_ptr)--;
-		break;
-	      }
-	    overflow |= i ^ (i << 4 >> 4);
-	    i = (i << 4) + digit;
-	    digits_found = 1;
-	  }
-	if (!digits_found)
-	  yyerror ("\\x used with no following hex digits");
-	if (overflow | (i != (i & result_mask)))
-	  {
-	    i &= result_mask;
-	    pedwarn ("hex escape sequence out of range");
-	  }
-	return i;
-      }
-    default:
-      return c;
-    }
-}
-
-static void
-yyerror (s)
-     char *s;
-{
-  error ("%s", s);
-  skip_evaluation = 0;
-  longjmp (parse_return_error, 1);
-}
-
-static void
-integer_overflow ()
-{
-  if (!skip_evaluation && pedantic)
-    pedwarn ("integer overflow in preprocessor expression");
-}
-
-static HOST_WIDE_INT
-left_shift (a, b)
-     struct constant *a;
-     unsigned_HOST_WIDE_INT b;
-{
-   /* It's unclear from the C standard whether shifts can overflow.
-      The following code ignores overflow; perhaps a C standard
-      interpretation ruling is needed.  */
-  if (b >= HOST_BITS_PER_WIDE_INT)
-    return 0;
-  else
-    return (unsigned_HOST_WIDE_INT) a->value << b;
-}
-
-static HOST_WIDE_INT
-right_shift (a, b)
-     struct constant *a;
-     unsigned_HOST_WIDE_INT b;
-{
-  if (b >= HOST_BITS_PER_WIDE_INT)
-    return a->signedp ? a->value >> (HOST_BITS_PER_WIDE_INT - 1) : 0;
-  else if (a->signedp)
-    return a->value >> b;
-  else
-    return (unsigned_HOST_WIDE_INT) a->value >> b;
-}
-
-/* This page contains the entry point to this file.  */
-
-/* Parse STRING as an expression, and complain if this fails
-   to use up all of the contents of STRING.
-   STRING may contain '\0' bytes; it is terminated by the first '\n'
-   outside a string constant, so that we can diagnose '\0' properly.
-   If WARN_UNDEFINED is nonzero, warn if undefined identifiers are evaluated.
-   We do not support C comments.  They should be removed before
-   this function is called.  */
-
-HOST_WIDE_INT
-parse_c_expression (string, warn_undefined)
-     char *string;
-     int warn_undefined;
-{
-  lexptr = string;
-  warn_undef = warn_undefined;
-
-  /* if there is some sort of scanning error, just return 0 and assume
-     the parsing routine has printed an error message somewhere.
-     there is surely a better thing to do than this.     */
-  if (setjmp (parse_return_error))
-    return 0;
-
-  if (yyparse () != 0)
-    abort ();
-
-  if (*lexptr != '\n')
-    error ("Junk after end of expression.");
-
-  return expression_value;	/* set by yyparse () */
-}
-
-#ifdef TEST_EXP_READER
-
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-int pedantic;
-int traditional;
-
-int main PROTO((int, char **));
-static void initialize_random_junk PROTO((void));
-static void print_unsigned_host_wide_int PROTO((unsigned_HOST_WIDE_INT));
-
-/* Main program for testing purposes.  */
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  int n, c;
-  char buf[1024];
-  unsigned_HOST_WIDE_INT u;
-
-  pedantic = 1 < argc;
-  traditional = 2 < argc;
-#if YYDEBUG
-  yydebug = 3 < argc;
-#endif
-  initialize_random_junk ();
-
-  for (;;) {
-    printf ("enter expression: ");
-    n = 0;
-    while ((buf[n] = c = getchar ()) != '\n' && c != EOF)
-      n++;
-    if (c == EOF)
-      break;
-    parse_c_expression (buf, 1);
-    printf ("parser returned ");
-    u = (unsigned_HOST_WIDE_INT) expression_value;
-    if (expression_value < 0 && expression_signedp) {
-      u = -u;
-      printf ("-");
-    }
-    if (u == 0)
-      printf ("0");
-    else
-      print_unsigned_host_wide_int (u);
-    if (! expression_signedp)
-      printf("u");
-    printf ("\n");
-  }
-
-  return 0;
-}
-
-static void
-print_unsigned_host_wide_int (u)
-     unsigned_HOST_WIDE_INT u;
-{
-  if (u) {
-    print_unsigned_host_wide_int (u / 10);
-    putchar ('0' + (int) (u % 10));
-  }
-}
-
-/* table to tell if char can be part of a C identifier. */
-unsigned char is_idchar[256];
-/* table to tell if char can be first char of a c identifier. */
-unsigned char is_idstart[256];
-/* table to tell if c is horizontal or vertical space.  */
-unsigned char is_space[256];
-
-/*
- * initialize random junk in the hash table and maybe other places
- */
-static void
-initialize_random_junk ()
-{
-  register int i;
-
-  /*
-   * Set up is_idchar and is_idstart tables.  These should be
-   * faster than saying (is_alpha (c) || c == '_'), etc.
-   * Must do set up these things before calling any routines tthat
-   * refer to them.
-   */
-  for (i = 'a'; i <= 'z'; i++) {
-    ++is_idchar[i - 'a' + 'A'];
-    ++is_idchar[i];
-    ++is_idstart[i - 'a' + 'A'];
-    ++is_idstart[i];
-  }
-  for (i = '0'; i <= '9'; i++)
-    ++is_idchar[i];
-  ++is_idchar['_'];
-  ++is_idstart['_'];
-  ++is_idchar['$'];
-  ++is_idstart['$'];
-
-  ++is_space[' '];
-  ++is_space['\t'];
-  ++is_space['\v'];
-  ++is_space['\f'];
-  ++is_space['\n'];
-  ++is_space['\r'];
-}
-
-void
-error (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  VA_START (args, msg);
-  fprintf (stderr, "error: ");
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-  va_end (args);
-}
-
-void
-pedwarn (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  VA_START (args, msg);
-  fprintf (stderr, "pedwarn: ");
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-  va_end (args);
-}
-
-void
-warning (PRINTF_ALIST (msg))
-     PRINTF_DCL (msg)
-{
-  va_list args;
-
-  VA_START (args, msg);
-  fprintf (stderr, "warning: ");
-  vfprintf (stderr, msg, args);
-  fprintf (stderr, "\n");
-  va_end (args);
-}
-
-int
-check_assertion (name, sym_length, tokens_specified, tokens)
-     U_CHAR *name;
-     int sym_length;
-     int tokens_specified;
-     struct arglist *tokens;
-{
-  return 0;
-}
-
-struct hashnode *
-lookup (name, len, hash)
-     U_CHAR *name;
-     int len;
-     int hash;
-{
-  return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
-}
-
-GENERIC_PTR
-xmalloc (size)
-     size_t size;
-{
-  return (GENERIC_PTR) malloc (size);
-}
-#endif
diff --git a/cpp/src/icecpp/config.h b/cpp/src/icecpp/config.h
deleted file mode 100644
index 0553bbe6dc2..00000000000
--- a/cpp/src/icecpp/config.h
+++ /dev/null
@@ -1,95 +0,0 @@
-// **********************************************************************
-//
-// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
-//
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
-
-//
-// This configuration file is based on the one generated by the
-// configure script from the gcc-2.8.1 distribution.
-//
-
-#if defined(__linux) || defined(__FreeBSD__) \
-    || defined(__sun) || defined(__hpux) || defined(__APPLE__) \
-    || defined(_AIX) || defined(__osf1__)
-#   define TIME_WITH_SYS_TIME 1
-#   define HAVE_BCMP 1
-#   define HAVE_BCOPY 1
-#   define HAVE_BZERO 1
-#   define HAVE_GETRLIMIT 1
-#   define HAVE_INDEX 1
-#   define HAVE_RINDEX 1
-#   define HAVE_UNISTD_H 1
-#elif defined(_WIN32)
-#   include <malloc.h>
-#   include <io.h>
-#   ifdef _MSC_VER
-#       pragma warning( disable : 4018 )
-#       pragma warning( disable : 4244 )
-//
-//     Move deprecated warning on VC8 to level 4
-//
-#      if _MSC_VER==1400
-#         pragma warning( 4 : 4996 )
-#         pragma warning( 4 : 4267 )   
-#      endif
-#   endif
-#   ifdef _MSC_VER
-#      define alloca _alloca
-#   endif
-#endif
-
-#if defined(__linux) || defined(__FreeBSD__) || defined(__sun) || \
-    defined(__hpux) || defined(__APPLE__) || defined(_AIX)
-#   define HAVE_INTTYPES_H 1
-#endif
-
-#if defined(__hpux) || defined(_AIX)
-#   include <alloca.h>
-#endif
-
-#if defined(__sun) || defined(__osf1__)
-#   include <alloca.h>
-#   include <malloc.h>
-#   include <strings.h>
-#endif
-
-#define HAVE_SETRLIMIT 1
-#define HAVE_STRERROR 1
-#define HAVE_VPRINTF 1
-
-#define HAVE_FCNTL_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_STDDEF_H 1
-#define HAVE_STDLIB_H 1
-#define HAVE_STRING_H 1
-#define HAVE_STRINGS_H 1
-
-#define CHAR_TYPE_SIZE 8
-#define INT_TYPE_SIZE 32
-
-//
-// Should be sizeof(long) * 8; but 32 works well.
-//
-#define LONG_TYPE_SIZE 32
-
-
-#define TARGET_BELL 007
-#define TARGET_BS 010
-#define TARGET_TAB 011
-#define TARGET_NEWLINE 012
-#define TARGET_VT 013
-#define TARGET_FF 014
-#define TARGET_CR 015
-
-static char *version_string = "2.8.1";
-
-#define INCLUDE_DEFAULTS { { 0, 0, 0 } }
-#define GCC_INCLUDE_DIR ""
-#define FATAL_EXIT_CODE 33
-#define SUCCESS_EXIT_CODE 0
-#define PREFIX ""
-#define OBJECT_SUFFIX ".cpp" // For -M option.
diff --git a/cpp/src/icecpp/gansidecl.h b/cpp/src/icecpp/gansidecl.h
deleted file mode 100644
index 770386f84a6..00000000000
--- a/cpp/src/icecpp/gansidecl.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/* ANSI and traditional C compatibility macros.
-   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
-
-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 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-/* This file mimics some of the support provided by include/ansidecl.h
-   in binutils and gdb releases.
-   ??? Over time the two should be merged into one.  */
-
-#ifndef ANSIDECL_H
-#define ANSIDECL_H
-
-/* Add prototype support.  */
-#ifndef PROTO
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define PROTO(ARGS) ARGS
-#else
-#define PROTO(ARGS) ()
-#endif
-#endif
-
-#ifndef VPROTO
-#ifdef __STDC__
-#define PVPROTO(ARGS)           ARGS
-#define VPROTO(ARGS)            ARGS
-#define VA_START(va_list,var)  va_start(va_list,var)
-#else
-#define PVPROTO(ARGS)           ()
-#define VPROTO(ARGS)            (va_alist) va_dcl
-#define VA_START(va_list,var)  va_start(va_list)
-#endif
-#endif
-
-/* Define a generic NULL if one hasn't already been defined.  */
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef GENERIC_PTR
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define GENERIC_PTR void *
-#else
-#define GENERIC_PTR char *
-#endif
-#endif
-
-#ifndef NULL_PTR
-#define NULL_PTR ((GENERIC_PTR) 0)
-#endif
-
-#ifdef __STDC__
-
-#define PTR void *
-
-#else
-
-#define PTR char *
-#ifndef const
-#define const
-#endif
-
-#endif /* ! __STDC__ */
-
-/* We don't have autoconf for libgcc2.c since it's a target, so don't
-   define these functions, which aren't used there anyway.  */
-
-#ifndef IN_LIBGCC2
-
-#ifndef HAVE_BCOPY
-#define bcopy(src,dst,len) memcpy ((dst),(src),(len))
-#endif
-
-#ifndef HAVE_BZERO
-#define bzero(dst,len) memset ((dst),0,(len))
-#endif
-
-#ifndef HAVE_BCMP
-#define bcmp(left,right,len) memcmp ((left),(right),(len))
-#endif
-
-#ifndef HAVE_RINDEX
-#define rindex strrchr
-#endif
-
-#ifndef HAVE_INDEX
-#define index strchr
-#endif
-
-#endif /* IN_LIBGCC2 */
-
-#endif /* ANSIDECL_H */
diff --git a/cpp/src/icecpp/pcp.h b/cpp/src/icecpp/pcp.h
deleted file mode 100644
index fabd88dbe7c..00000000000
--- a/cpp/src/icecpp/pcp.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/* pcp.h -- Describes the format of a precompiled file
-   Copyright (C) 1990 Free Software Foundation, Inc.
-
-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 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,  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-
-
-/* Structure allocated for every string in a precompiled file */
-typedef struct stringdef STRINGDEF;
-struct stringdef
-{
-  U_CHAR *contents;             /* String to include */
-  int len;                      /* Its length */
-  int writeflag;                /* Whether we write this */
-  int lineno;                   /* Linenumber of source file */
-  U_CHAR *filename;             /* Name of source file */
-  STRINGDEF *chain;             /* Global list of strings in natural order */
-  int output_mark;              /* Where in the output this goes */
-};
-
-typedef struct keydef KEYDEF;
-struct keydef
-{
-  STRINGDEF *str;
-  KEYDEF *chain;
-};
-
-/* Format: */
-/* A precompiled file starts with a series of #define and #undef
- statements:
-    #define MAC DEF     ---   Indicates MAC must be defined with defn DEF
-    #define MAC         ---   Indicates MAC must be defined with any defn
-    #undef MAC          ---   Indicates MAC cannot be defined
-
-These preconditions must be true for a precompiled file to be used.  
-The preconditions section is null terminated. */
-
-/* Then, there is a four byte number (in network byte order) which */
- /* indicates the number of strings the file contains. */
-
-/* Each string contains a STRINGDEF structure.  The only component of */
- /* the STRINGDEF structure which is used is the lineno field, which */
- /* should hold the line number in the original header file.  */
- /* Then follows the string, followed by a null.  Then comes a four */
- /* byte number (again, in network byte order) indicating the number */
- /* of keys for this string.  Each key is a KEYDEF structure, with */
- /* irrelevant contents, followed by the null-terminated string. */
-
-/* If the number of keys is 0, then there are no keys for the string, */
- /* in other words, the string will never be included.  If the number */
- /* of keys is -1, this is a special flag indicating there are no keys */
- /* in the file, and the string is mandatory (that is, it must be */
- /* included regardless in the included output).  */
-
-/* A file, then, looks like this:
-
-  Precondition 1
-  Precondition 2
-  . 
-  .
-  .
-  <NUL>
-  Number of strings
-    STRINGDEF
-    String . . . <NUL>
-    Number of keys
-      KEYDEF
-      Key . . . <NUL>
-      KEYDEF 
-      Key . . . <NUL>
-      .
-      .
-      .
-    STRINGDEF
-    String . . . <NUL>
-    Number of keys
-      KEYDEF
-      Key . . . <NUL>
-      .
-      .
-      .
-    .
-    .
-    .
-
-*/
diff --git a/cpp/src/icecpp/prefix.c b/cpp/src/icecpp/prefix.c
deleted file mode 100644
index 5516d376360..00000000000
--- a/cpp/src/icecpp/prefix.c
+++ /dev/null
@@ -1,316 +0,0 @@
-/* Utility to update paths from internal to external forms.
-   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
-
-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 Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-GCC 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA
-*/
-
-/* This file contains routines to update a path, both to canonicalize
-   the directory format and to handle any prefix translation.
-
-   This file must be compiled with -DPREFIX= to specify the "prefix"
-   value used by configure.  If a filename does not begin with this
-   prefix, it will not be affected other than by directory canonicalization.
-
-   Each caller of 'update_path' may specify both a filename and
-   a translation prefix and consist of the name of the package that contains
-   the file ("@GCC", "@BINUTIL", "@GNU", etc).
-
-   If the prefix is not specified, the filename will only undergo
-   directory canonicalization.
-
-   If it is specified, the string given by PREFIX will be replaced
-   by the specified prefix (with a '@' in front unless the prefix begins
-   with a '$') and further translation will be done as follows
-   until none of the two conditions below are met:
-
-   1) If the filename begins with '@', the string between the '@' and
-   the end of the name or the first '/' or directory separator will
-   be considered a "key" and looked up as follows:
-
-   -- If this is a Win32 OS, then the Registry will be examined for
-      an entry of "key" in 
-
-      HKEY_LOCAL_MACHINE\SOFTWARE\Free Software Foundation\
-
-      if found, that value will be used.
-
-   -- If not found (or not a Win32 OS), the environment variable
-      key_ROOT (the value of "key" concatenated with the constant "_ROOT")
-      is tried.  If that fails, then PREFIX (see above) is used.
-
-   2) If the filename begins with a '$', the rest of the string up
-   to the end or the first '/' or directory separator will be used
-   as an environment variable, whose value will be returned.
-
-   Once all this is done, any '/' will be converted to DIR_SEPARATOR,
-   if they are different. 
-
-   NOTE:  using resolve_keyed_path under Win32 requires linking with
-   advapi32.dll.  */
-
-
-#include "config.h"
-#include "gansidecl.h"
-#ifdef __STDC__
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-static char *get_key_value      PROTO((char *));
-static char *translate_name     PROTO((char *));
-static char *concat             PVPROTO((char *, ...));
-static char *save_string        PROTO((char *, int));
-
-#ifdef _WIN32
-static char *lookup_key         PROTO((char *));
-static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE;
-#endif
-
-#ifndef _WIN32
-extern char *getenv ();
-#endif
-
-/* Given KEY, as above, return its value.  */
-
-static char *
-get_key_value (key)
-     char *key;
-{
-  char *prefix = 0;
-
-#ifdef _WIN32
-  prefix = lookup_key (key);
-#endif
-
-  if (prefix == 0)
-    prefix = getenv (concat (key, "_ROOT", NULL_PTR));
-
-  return prefix;
-}
-
-/* Concatenate a sequence of strings, returning the result.
-
-   This function is based on the one in libiberty.  */
-
-static char *
-concat VPROTO((char *first, ...))
-{
-  register int length;
-  register char *newstr;
-  register char *end;
-  register char *arg;
-  va_list args;
-#ifndef __STDC__
-  char *first;
-#endif
-
-  /* First compute the size of the result and get sufficient memory.  */
-
-  VA_START (args, first);
-#ifndef __STDC__
-  first = va_arg (args, char *);
-#endif
-
-  arg = first;
-  length = 0;
-
-  while (arg != 0)
-    {
-      length += (int) strlen (arg);
-      arg = va_arg (args, char *);
-    }
-
-  newstr = (char *) malloc (length + 1);
-  va_end (args);
-
-  /* Now copy the individual pieces to the result string.  */
-
-  VA_START (args, first);
-#ifndef __STDC__
-  first = va_arg (args, char *);
-#endif
-
-  end = newstr;
-  arg = first;
-  while (arg != 0)
-    {
-      while (*arg)
-        *end++ = *arg++;
-      arg = va_arg (args, char *);
-    }
-  *end = '\000';
-  va_end (args);
-
-  return (newstr);
-}
-
-/* Return a copy of a string that has been placed in the heap.  */
-
-static char *
-save_string (s, len)
-     char *s;
-     int len;
-{
-  register char *result = (char *) malloc (len + 1);
-
-  bcopy (s, result, len);
-  result[len] = 0;
-  return result;
-}
-
-#ifdef _WIN32
-
-/* Look up "key" in the registry, as above.  */
-
-static char *
-lookup_key (key)
-     char *key;
-{
-  char *dst;
-  DWORD size;
-  DWORD type;
-  LONG res;
-
-  if (reg_key == (HKEY) INVALID_HANDLE_VALUE)
-    {
-      res = RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE", 0,
-                           KEY_READ, &reg_key);
-
-      if (res == ERROR_SUCCESS)
-        res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0,
-                             KEY_READ, &reg_key);
-
-      if (res != ERROR_SUCCESS)
-        {
-          reg_key = (HKEY) INVALID_HANDLE_VALUE;
-          return 0;
-        }
-    }
-
-  size = 32;
-  dst = (char *) malloc (size);
-
-  res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
-  if (res == ERROR_MORE_DATA && type == REG_SZ)
-    {
-      dst = (char *) realloc (dst, size);
-      res = RegQueryValueExA (reg_key, key, 0, &type, dst, &size);
-    }
-
-  if (type != REG_SZ || res != ERROR_SUCCESS)
-    {
-      free (dst);
-      dst = 0;
-    }
-
-  return dst;
-}
-#endif
-
-/* If NAME starts with a '@' or '$', apply the translation rules above
-   and return a new name.  Otherwise, return the given name.  */
-
-static char *
-translate_name (name)
-     char *name;
-{
-  char code = name[0];
-  char *key, *prefix = 0;
-  int keylen;
-
-  if (code != '@' && code != '$')
-    return name;
-
-  for (keylen = 0;
-       (name[keylen + 1] != 0 && name[keylen + 1] != '/'
-#ifdef DIR_SEPARATOR
-        && name[keylen + 1] != DIR_SEPARATOR
-#endif
-        );
-       keylen++)
-    ;
-
-  key = alloca (keylen + 1);
-  strncpy (key, &name[1], keylen);
-  key[keylen] = 0;
-
-  name = &name[keylen + 1];
-
-  if (code == '@')
-    prefix = get_key_value (key);
-  else
-    prefix = getenv (key);
-
-  if (prefix == 0)
-    prefix = PREFIX;
-
-  /* Remove any trailing directory separator from what we got.  */
-  if (prefix[strlen (prefix) - 1] == '/'
-#ifdef DIR_SEPARATOR
-      || prefix[strlen (prefix) - 1] == DIR_SEPARATOR
-#endif
-      )
-    {
-      prefix = save_string (prefix, (int)strlen (prefix));
-      prefix[strlen (prefix) - 1] = 0;
-    }
-
-  return concat (prefix, name, NULL_PTR);
-}
-
-/* Update PATH using KEY if PATH starts with PREFIX.  */
-
-char *
-update_path (path, key)
-     char *path;
-     char *key;
-{
-  if (! strncmp (path, PREFIX, strlen (PREFIX)) && key != 0)
-    {
-      if (key[0] != '$')
-        key = concat ("@", key, NULL_PTR);
-
-      path = concat (key, &path[strlen (PREFIX)], NULL_PTR);
-
-      while (path[0] == '@' || path[0] == '$')
-        path = translate_name (path);
-    }
-      
-#ifdef DIR_SEPARATOR
-  if (DIR_SEPARATOR != '/')
-    {
-      int i;
-      int len = strlen (path);
-
-      path = save_string (path, len);
-      for (i = 0; i < len; i++)
-        if (path[i] == '/')
-          path[i] = DIR_SEPARATOR;
-    }
-#endif
-
-  return path;
-}
diff --git a/cpp/src/slice2cpp/Main.cpp b/cpp/src/slice2cpp/Main.cpp
index 2907108ef58..0edf14755d7 100644
--- a/cpp/src/slice2cpp/Main.cpp
+++ b/cpp/src/slice2cpp/Main.cpp
@@ -96,25 +96,25 @@ main(int argc, char* argv[])
     
     vector<string> extraHeaders = opts.argVec("add-header");
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths;
     includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+	cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -153,7 +153,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], *i, cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::CPlusPlus);
+            icecpp.printMakefileDependencies(Preprocessor::CPlusPlus, includePaths);
         }
         else
         {
@@ -183,7 +183,7 @@ main(int argc, char* argv[])
             else
             {
                 UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive);
-                int parseStatus = u->parse(cppHandle, debug);
+                int parseStatus = u->parse(*i, cppHandle, debug);
             
                 if(!icecpp.close())
                 {
diff --git a/cpp/src/slice2cppe/Main.cpp b/cpp/src/slice2cppe/Main.cpp
index cfc26feca6d..12f630139ac 100644
--- a/cpp/src/slice2cppe/Main.cpp
+++ b/cpp/src/slice2cppe/Main.cpp
@@ -92,24 +92,24 @@ main(int argc, char* argv[])
 
     vector<string>extraHeaders = opts.argVec("add-header");
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -144,7 +144,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], *i, cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::CPlusPlus);
+            icecpp.printMakefileDependencies(Preprocessor::CPlusPlus, includePaths);
         }
         else
         {
@@ -173,7 +173,7 @@ main(int argc, char* argv[])
             else
             {
                 UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive);
-                int parseStatus = u->parse(cppHandle, debug, Slice::IceE);
+                int parseStatus = u->parse(*i, cppHandle, debug, Slice::IceE);
             
                 if(!icecpp.close())
                 {
diff --git a/cpp/src/slice2cs/Main.cpp b/cpp/src/slice2cs/Main.cpp
index 52c818f6f78..ef7f8033012 100644
--- a/cpp/src/slice2cs/Main.cpp
+++ b/cpp/src/slice2cs/Main.cpp
@@ -85,24 +85,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -148,7 +148,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], *i, cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::CSharp);
+            icecpp.printMakefileDependencies(Preprocessor::CSharp, includePaths);
         }
         else
         {
@@ -177,7 +177,7 @@ main(int argc, char* argv[])
             else
             {
                 UnitPtr p = Unit::createUnit(false, false, ice, caseSensitive);
-                int parseStatus = p->parse(cppHandle, debug);
+                int parseStatus = p->parse(*i, cppHandle, debug);
 
                 if(!icecpp.close())
                 {
diff --git a/cpp/src/slice2docbook/Main.cpp b/cpp/src/slice2docbook/Main.cpp
index edac55bc4d5..29be2a76123 100644
--- a/cpp/src/slice2docbook/Main.cpp
+++ b/cpp/src/slice2docbook/Main.cpp
@@ -81,24 +81,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     optargs = opts.argVec("I");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -173,7 +173,7 @@ main(int argc, char* argv[])
         }
         else
         {
-            status = p->parse(cppHandle, debug);
+            status = p->parse(args[idx], cppHandle, debug);
         }
 
         if(!icecpp.close())
diff --git a/cpp/src/slice2freeze/Main.cpp b/cpp/src/slice2freeze/Main.cpp
index d1732d55bd2..b9b94ff92c0 100644
--- a/cpp/src/slice2freeze/Main.cpp
+++ b/cpp/src/slice2freeze/Main.cpp
@@ -1288,25 +1288,25 @@ main(int argc, char* argv[])
     string headerExtension = opts.optArg("header-ext");
     string sourceExtension = opts.optArg("source-ext");
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> extraHeaders = opts.argVec("add-header");
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess= opts.isSet("E");
@@ -1716,7 +1716,7 @@ main(int argc, char* argv[])
         }
         else
         {
-            status = u->parse(cppHandle, debug);
+            status = u->parse(args[idx], cppHandle, debug);
         }
 
         if(!icecpp.close())
diff --git a/cpp/src/slice2freezej/Main.cpp b/cpp/src/slice2freezej/Main.cpp
index a3c08207c7c..e430c562a9e 100644
--- a/cpp/src/slice2freezej/Main.cpp
+++ b/cpp/src/slice2freezej/Main.cpp
@@ -1159,24 +1159,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -1412,7 +1412,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], args[idx], cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::Java);
+            icecpp.printMakefileDependencies(Preprocessor::Java, includePaths);
         }
         else
         {
@@ -1439,7 +1439,7 @@ main(int argc, char* argv[])
             }
             else
             {
-                status = u->parse(cppHandle, debug);
+                status = u->parse(args[idx], cppHandle, debug);
             }
 
             if(!icecpp.close())
diff --git a/cpp/src/slice2html/Main.cpp b/cpp/src/slice2html/Main.cpp
index 08d25c5f403..a74f7d92f90 100644
--- a/cpp/src/slice2html/Main.cpp
+++ b/cpp/src/slice2html/Main.cpp
@@ -91,24 +91,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     optargs = opts.argVec("I");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -196,7 +196,7 @@ main(int argc, char* argv[])
         }
         else
         {
-            status = p->parse(cppHandle, debug);
+            status = p->parse(args[idx], cppHandle, debug);
         }
 
         if(!icecpp.close())
diff --git a/cpp/src/slice2java/Main.cpp b/cpp/src/slice2java/Main.cpp
index 94e2110f5f5..6f814593cb6 100644
--- a/cpp/src/slice2java/Main.cpp
+++ b/cpp/src/slice2java/Main.cpp
@@ -91,24 +91,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -160,7 +160,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], *i, cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::Java);
+            icecpp.printMakefileDependencies(Preprocessor::Java, includePaths);
         }
         else
         {
@@ -190,7 +190,7 @@ main(int argc, char* argv[])
             else
             {
                 UnitPtr p = Unit::createUnit(false, false, ice, caseSensitive, globalMetadata);
-                int parseStatus = p->parse(cppHandle, debug, Ice);
+                int parseStatus = p->parse(*i, cppHandle, debug, Ice);
 
                 if(!icecpp.close())
                 {
diff --git a/cpp/src/slice2javae/Main.cpp b/cpp/src/slice2javae/Main.cpp
index b3dc910f24f..ee32b1b5db3 100644
--- a/cpp/src/slice2javae/Main.cpp
+++ b/cpp/src/slice2javae/Main.cpp
@@ -81,24 +81,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -140,7 +140,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], *i, cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::Java);
+            icecpp.printMakefileDependencies(Preprocessor::Java, includePaths);
         }
         else
         {
@@ -170,7 +170,7 @@ main(int argc, char* argv[])
             else
             {
                 UnitPtr p = Unit::createUnit(false, false, ice, caseSensitive);
-                int parseStatus = p->parse(cppHandle, debug, Slice::IceE);
+                int parseStatus = p->parse(*i, cppHandle, debug, Slice::IceE);
 
                 if(!icecpp.close())
                 {
diff --git a/cpp/src/slice2py/Main.cpp b/cpp/src/slice2py/Main.cpp
index 26f39e36d44..b18f391f309 100644
--- a/cpp/src/slice2py/Main.cpp
+++ b/cpp/src/slice2py/Main.cpp
@@ -426,24 +426,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -501,7 +501,7 @@ main(int argc, char* argv[])
         else
         {
             UnitPtr u = Unit::createUnit(false, all, ice, caseSensitive);
-            int parseStatus = u->parse(cppHandle, debug);
+            int parseStatus = u->parse(*i, cppHandle, debug);
 
             if(!icecpp.close())
             {
diff --git a/cpp/src/slice2rb/Main.cpp b/cpp/src/slice2rb/Main.cpp
index 91f1ed1e499..67bae275a63 100644
--- a/cpp/src/slice2rb/Main.cpp
+++ b/cpp/src/slice2rb/Main.cpp
@@ -92,24 +92,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-	cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-	cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -163,7 +163,7 @@ main(int argc, char* argv[])
         else
         {
             UnitPtr u = Unit::createUnit(false, all, ice, caseSensitive);
-            int parseStatus = u->parse(cppHandle, debug);
+            int parseStatus = u->parse(*i, cppHandle, debug);
 
             if(!icecpp.close())
             {
diff --git a/cpp/src/slice2sl/Main.cpp b/cpp/src/slice2sl/Main.cpp
index 53418e7a080..010944528fa 100644
--- a/cpp/src/slice2sl/Main.cpp
+++ b/cpp/src/slice2sl/Main.cpp
@@ -75,24 +75,24 @@ main(int argc, char* argv[])
         return EXIT_SUCCESS;
     }
 
-    string cppArgs;
+    vector<string> cppArgs;
     vector<string> optargs = opts.argVec("D");
     vector<string>::const_iterator i;
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -D" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-D" + *i);
     }
 
     optargs = opts.argVec("U");
     for(i = optargs.begin(); i != optargs.end(); ++i)
     {
-        cppArgs += " -U" + Preprocessor::addQuotes(*i);
+        cppArgs.push_back("-U" + *i);
     }
 
     vector<string> includePaths = opts.argVec("I");
     for(i = includePaths.begin(); i != includePaths.end(); ++i)
     {
-	cppArgs += " -I" + Preprocessor::normalizeIncludePath(*i);
+        cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
     }
 
     bool preprocess = opts.isSet("E");
@@ -121,7 +121,7 @@ main(int argc, char* argv[])
         if(depend)
         {
             Preprocessor icecpp(argv[0], *i, cppArgs);
-            icecpp.printMakefileDependencies(Preprocessor::CSharp);
+            icecpp.printMakefileDependencies(Preprocessor::CSharp, includePaths);
         }
         else
         {
@@ -150,7 +150,7 @@ main(int argc, char* argv[])
             else
             {
                 UnitPtr p = Unit::createUnit(false, false, ice, caseSensitive);
-                int parseStatus = p->parse(cppHandle, debug);
+                int parseStatus = p->parse(*i, cppHandle, debug);
 
                 if(!icecpp.close())
                 {