-recoveredHEADmaster

155 files changed, 41378 insertions, 0 deletions

diff --git a/README b/README
new file mode 100644
index 0000000..b282938
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+Filenames of your source have to be unique, because gdb sometimes gets the whole relative path in the stackframe and sometimes not!
diff --git a/doc/man/man1/pathologist.1 b/doc/man/man1/pathologist.1
new file mode 100644
index 0000000..1fceff8
--- /dev/null
+++ b/doc/man/man1/pathologist.1
@@ -0,0 +1,21 @@
+.TH pathologist 1 2013-03-01 "Monkey Debugging System" "Version 0.1"
+
+.SH NAME
+pathologist \- Automatically generates bug reports.
+
+.SH SYNOPSIS
+.B pathologist -d FILE [ options ] [ -- ] BINARY
+.br
+.B pathologist -h | -v
+
+.SH DESCRIPTION
+With pathologist you can run an application and automatically generate a
+bug report, if the programm crashes. Before you can use pathologist, 
+you first have to generate an expression database with seaspider. For more
+information about how to use pathologist as part of the Monkey Debugging
+System see
+.B monkey(7)
+.\.
+
+
+.SH OPTIONS
diff --git a/doc/man/man1/seaspider.1 b/doc/man/man1/seaspider.1
new file mode 100644
index 0000000..e247883
--- /dev/null
+++ b/doc/man/man1/seaspider.1
@@ -0,0 +1,15 @@
+.TH seaspider 1 2013-03-01 "Monkey Debugging System" "Version 0.1"
+
+.SH NAME
+seaspider \- builds an expression database via static code analysis.
+
+.SH SYNOPSIS
+
+.SH DESCRIPTION
+For more information about how to use the generated database with pathologist
+as part of the Monkey Debugging System see
+.B monkey(7)
+.\.
+
+
+.SH OPTIONS
diff --git a/doc/man/man7/monkey.7 b/doc/man/man7/monkey.7
new file mode 100644
index 0000000..9087f8a
--- /dev/null
+++ b/doc/man/man7/monkey.7
@@ -0,0 +1,76 @@
+.TH monkey 7 2013-03-01 "Monkey Debugging System" "Version 0.1"
+
+.SH NAME
+monkey \- An automated debugging tool.
+
+.SH DESCRIPTION
+.P
+The Monkey Debugging System is a three part toolset for automtically generating
+bug reports from program crashes.
+.P
+To allow automated crash analysis with pathologist, you first have to generate
+an expression database with
+.B seaspider(1)
+. Seaspider will do some static code analysis and generate a sqlite database
+file containing all the expressions in your source code.  If you have
+some variables in your source code which contain private information
+of the user that must not be included in bug reports, you can specify
+an ignore file which contains regular expressions to exclude those
+variables from the database, and therefore prevent later appearance of
+the private data in the bug report.
+
+.P
+After the expression database has been generated, you can ship this database
+together with your application.  On the target system, the user can then use
+.B pathologist(1)
+, to run your application under supervision using 
+.B gdb(1)
+.  If the application crashes,
+a post-mortem analysis will be performed. The stack will be analyzed and all relevant
+expressions in the stacktrace and other information about the crash will be evaluated and written to a bug report
+in XML format. When the report has been succesfully written, Pathologist can
+send the report to the developer via mail.
+
+.P
+The third component of the monkey debugging system is the
+.B entomologist(1)
+, which is not yet functional.  The Entomologist but will provide comparison and clustering algorithms
+for the generated reports.
+
+.SH REQUIREMENTS
+.P
+To use the Monkey Debugging System, you have to fulfill the following
+requirements.
+
+.P
+Your project has to be written in C (C++ support is missing in Seaspider).
+
+.P
+To use Seaspider, your project has to be built with GNU Autotools. Other Build
+Systems are not supported, but it should still be possible to use them as well,
+if you can set the compiler and compiler options yourself.
+
+.P
+You need gdb in version 7 or later, and we have only tested the system on GNU/Linux.
+
+.SH LIMITATIONS
+.P
+Pathologist can only (nicely) handle the following signals at this time: SIGSEGV (Segfault),
+SIGABRT (Assertion), SIGBUS (Bad Memory Access), and SIGFPE (Arithmetic Exception).
+
+.P
+Your C source file names have to be globally unique in your project.
+
+.P
+Due to gdb changing the respective values on the stack while evaluating,
+increments and decrements are problematic if contained in the line of code,
+which causes the crash. Seaspider will just remove every single increment and
+decrement operator before writing expressions to the database, so if your
+program crashes on a line
+.B a = b[++c];
+, the report will only contain the
+value of
+.B b[c]
+.
+
+
diff --git a/entomologist/.classpath b/entomologist/.classpath
new file mode 100644
index 0000000..b10b8d9
--- /dev/null
+++ b/entomologist/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+        <classpathentry kind="src" path="src"/>
+        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+        <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/entomologist/.fatjar b/entomologist/.fatjar
new file mode 100644
index 0000000..ce6d1ab
--- /dev/null
+++ b/entomologist/.fatjar
@@ -0,0 +1,14 @@
+#Fat Jar Configuration File
+#Sun Jul 15 12:40:42 CEST 2012
+onejar.license.required=true
+manifest.classpath=
+manifest.removesigners=true
+onejar.checkbox=false
+jarname=mcomparator.jar
+manifest.mergeall=true
+manifest.mainclass=org.monkey.comparator.MonkeyComparator
+manifest.file=<createnew>
+jarname.isextern=false
+onejar.expand=
+excludes=
+includes=
diff --git a/entomologist/.project b/entomologist/.project
new file mode 100644
index 0000000..84d2b8a
--- /dev/null
+++ b/entomologist/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name>MonkeyBugComparator</name>
+        <comment></comment>
+        <projects>
+        </projects>
+        <buildSpec>
+                <buildCommand>
+                        <name>org.eclipse.jdt.core.javabuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+        </buildSpec>
+        <natures>
+                <nature>org.eclipse.jdt.core.javanature</nature>
+        </natures>
+</projectDescription>
diff --git a/entomologist/.settings/org.eclipse.jdt.core.prefs b/entomologist/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..9e22754
--- /dev/null
+++ b/entomologist/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+#Tue Jan 24 16:34:26 CET 2012
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/entomologist/build.xml b/entomologist/build.xml
new file mode 100644
index 0000000..3d99b77
--- /dev/null
+++ b/entomologist/build.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0"?>

+<project name="FatJar mcomparator.jar (experimental)" default="main" basedir=".">

+    <!-- this file was created by Fat-Jar Eclipse Plug-in -->

+    <!-- the ANT-Export is in a very early stage, so this -->

+    <!-- is only experimental, ANT 1.6 or above is        -->

+    <!-- required, feedback is always welcome:            -->

+    <!--       http://sourceforge.net/projects/fjep       -->

+    <!-- uncomment the following lines if using ANT outside Eclipse -->

+    <!--

+        <property name="fjepPath" value="reference:file:plugins/net.sf.fjep.fatjar_0.0.31/fatjar.jar"/>

+        <taskdef name="fatjar.build" classname="net.sf.fjep.anttask.FJBuildTask" classpath="${fjepPath}"/>

+        <typedef name="fatjar.manifest" classname="net.sf.fjep.anttask.FJManifestType" classpath="${fjepPath}"/>

+        <typedef name="fatjar.exclude" classname="net.sf.fjep.anttask.FJExcludeType" classpath="${fjepPath}"/>

+        <typedef name="fatjar.jarsource" classname="net.sf.fjep.anttask.FJJarSourceType" classpath="${fjepPath}"/>

+        <typedef name="fatjar.filesource" classname="net.sf.fjep.anttask.FJFileSourceType" classpath="${fjepPath}"/>

+    -->

+    <!-- uncomment the above lines to use ANT outside of Eclipse -->

+    <target name="main">

+        <fatjar.build output="mcomparator.jar">

+            <fatjar.manifest mainclass="org.monkey.comparator.MonkeyComparator"/>

+            <fatjar.filesource path="/home/safey/EclipseWorkspaceMonkeyComparator/MonkeyBugComparator/bin" relpath="">

+                <fatjar.exclude relpath="org/monkey/comparator/testing/"/>

+            </fatjar.filesource>

+        </fatjar.build>

+    </target>

+</project>

diff --git a/entomologist/comparator.properties b/entomologist/comparator.properties
new file mode 100644
index 0000000..0c4f95f
--- /dev/null
+++ b/entomologist/comparator.properties
@@ -0,0 +1,29 @@
+MAX_INT=2147483647
+MIN_INT=-2147483647
+ENABLE_VALUE_CLASSES=false
+LINE_NUMBER_DIFFERENCE_THRESHOLD=10
+
+# Features' scores
+GENERAL_PROPERTIES_FEATURE_SCORE=100
+STACK_TRACE_FEATURE_SCORE=50
+
+# Weights for feature: Bug General Properties
+BUG_CATEGORY_WEIGHT=0.75
+LINE_NUMBER_WEIGHT=0.00625
+BUG_FUNCTION_NAME_WEIGHT=0.1875
+FILE_NAME_WEIGHT=0.05625
+
+# Weights for feature: Stack-Trace
+# Weight of all function semantics in the stack-trace (function name, file name, line number)
+FUNCTION_SEMANTICS_WEIGHT=0.1
+# Weight of all expressions in the stack-trace 
+EXPRESSIONS_WEIGHT=0.9
+
+# Within the function semantics
+FUNCTION_NAME_WEIGHT=0.25
+FUNCTION_LINE_WEIGHT=0.25
+FUNCTION_FILE_NAME=0.5
+
+# Within the expressions of the function
+EXPRESSION_SYTNAX_WEIGHT=0.7
+EXPRESSION_VALUE_WEIGHT=0.3
diff --git a/entomologist/entomologist b/entomologist/entomologist
new file mode 100644
index 0000000..ac3ca9f
--- /dev/null
+++ b/entomologist/entomologist
@@ -0,0 +1,10 @@
+#! /bin/bash
+
+echo "Wrapper for the Monkey bug comparator (entomologist)"
+if ls mcomparator.jar &> /dev/null; then
+    java -jar mcomparator.jar $1 $2 $3 $4
+else
+    echo "Run: entomologist file1.xml file2.xml -p comparator.properties"
+    echo "mcomparator.jar must be in the same directory of this script."
+fi
+
diff --git a/entomologist/mcomparator.jar b/entomologist/mcomparator.jar
new file mode 100644
index 0000000..be6a8d4
--- /dev/null
+++ b/entomologist/mcomparator.jar
diff --git a/entomologist/src/org/monkey/comparator/BugComparator.java b/entomologist/src/org/monkey/comparator/BugComparator.java
new file mode 100644
index 0000000..d89af84
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/BugComparator.java
@@ -0,0 +1,30 @@
+package org.monkey.comparator;
+
+import java.util.ArrayList;
+
+public class BugComparator {
+        private static ArrayList<Feature> featureList = new ArrayList<Feature>();
+        
+        public static boolean register(Feature feature) {
+                featureList.add(feature);
+                return true;
+        }
+        
+        public static boolean unregister(Feature feature) {
+                featureList.remove(feature);
+                return true;
+        }
+        
+        public static double calculateScore() {
+                double totalScore = 0;
+                double featureScore;
+                Feature feature;
+                for (int i = 0; i < featureList.size(); i++) {
+                        feature = featureList.get(i);
+                        featureScore = feature.score();
+                        //System.out.println(feature.getFeatureName() + " score = " + featureScore);
+                        totalScore += featureScore;
+                }
+                return totalScore;
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/Constants.java b/entomologist/src/org/monkey/comparator/Constants.java
new file mode 100644
index 0000000..f707fdf
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/Constants.java
@@ -0,0 +1,65 @@
+package org.monkey.comparator;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Properties;
+
+public abstract class Constants {
+        public static int MAX_INT;
+        public static int MIN_INT;
+        public static boolean ENABLE_VALUE_CLASSES;
+        public static int LINE_NUMBER_DIFFERENCE_THRESHOLD;
+        
+        /* Features' scores */
+        public static double GENERAL_PROPERTIES_FEATURE_SCORE;
+        public static double STACK_TRACE_FEATURE_SCORE;
+        
+        /* Weights for feature: Bug General Properties */
+        public static double BUG_CATEGORY_WEIGHT;
+        public static double LINE_NUMBER_WEIGHT;
+        public static double BUG_FUNCTION_NAME_WEIGHT;
+        public static double FILE_NAME_WEIGHT;
+        
+        /* Weights for feature: Stack-Trace */
+        public static double FUNCTION_SEMANTICS_WEIGHT; // Weight of all function semantics in the stack-trace (function name, file name, line number)
+        public static double EXPRESSIONS_WEIGHT; // Weight of all expressions in the stack-trace 
+        
+        public static double FUNCTION_NAME_WEIGHT; // Within the function semantics
+        public static double FUNCTION_LINE_WEIGHT;
+        public static double FUNCTION_FILE_NAME;
+        
+        public static double EXPRESSION_SYTNAX_WEIGHT; // Within the expressions of the function
+        public static double EXPRESSION_VALUE_WEIGHT;
+        
+        public static void setUpConstants(String propertiesFilePath) {
+                Properties properties = new Properties();
+                try {
+                        properties.load(new FileInputStream(propertiesFilePath));
+                        MAX_INT = Integer.parseInt(properties.getProperty("MAX_INT"));
+                        MIN_INT = Integer.parseInt(properties.getProperty("MIN_INT"));
+                        ENABLE_VALUE_CLASSES = Boolean.parseBoolean(properties.getProperty("ENABLE_VALUE_CLASSES"));
+                        LINE_NUMBER_DIFFERENCE_THRESHOLD = Integer.parseInt(properties.getProperty("LINE_NUMBER_DIFFERENCE_THRESHOLD"));
+                        GENERAL_PROPERTIES_FEATURE_SCORE = Double.parseDouble(properties.getProperty("GENERAL_PROPERTIES_FEATURE_SCORE"));
+                        STACK_TRACE_FEATURE_SCORE = Double.parseDouble(properties.getProperty("STACK_TRACE_FEATURE_SCORE"));
+                        BUG_CATEGORY_WEIGHT = Double.parseDouble(properties.getProperty("BUG_CATEGORY_WEIGHT"));
+                        LINE_NUMBER_WEIGHT = Double.parseDouble(properties.getProperty("LINE_NUMBER_WEIGHT"));
+                        BUG_FUNCTION_NAME_WEIGHT = Double.parseDouble(properties.getProperty("BUG_FUNCTION_NAME_WEIGHT"));
+                        FILE_NAME_WEIGHT = Double.parseDouble(properties.getProperty("FILE_NAME_WEIGHT"));
+                        FUNCTION_SEMANTICS_WEIGHT = Double.parseDouble(properties.getProperty("FUNCTION_SEMANTICS_WEIGHT"));
+                        EXPRESSIONS_WEIGHT = Double.parseDouble(properties.getProperty("EXPRESSIONS_WEIGHT"));
+                        FUNCTION_NAME_WEIGHT = Double.parseDouble(properties.getProperty("FUNCTION_NAME_WEIGHT"));
+                        FUNCTION_LINE_WEIGHT = Double.parseDouble(properties.getProperty("FUNCTION_LINE_WEIGHT"));
+                        FUNCTION_FILE_NAME = Double.parseDouble(properties.getProperty("FUNCTION_FILE_NAME"));
+                        EXPRESSION_SYTNAX_WEIGHT = Double.parseDouble(properties.getProperty("EXPRESSION_SYTNAX_WEIGHT"));
+                        EXPRESSION_VALUE_WEIGHT = Double.parseDouble(properties.getProperty("EXPRESSION_VALUE_WEIGHT"));
+                } catch (FileNotFoundException e) {
+                        e.printStackTrace();
+                } catch (IOException e) {
+                        System.err.println("Fatal error: unable to read properties. Entomologist will exit now.");
+                        e.printStackTrace();
+                        System.exit(1);
+                }
+        }
+        
+}
diff --git a/entomologist/src/org/monkey/comparator/Feature.java b/entomologist/src/org/monkey/comparator/Feature.java
new file mode 100644
index 0000000..576ac44
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/Feature.java
@@ -0,0 +1,21 @@
+package org.monkey.comparator;
+
+import org.monkey.comparator.bo.Bug;
+
+public abstract class Feature {
+        protected Bug bugA;
+        protected Bug bugB;
+        protected String featureName = "Feature";
+        protected double featureTotalScore = 0;
+        
+        public Feature (Bug bugA, Bug bugB, double featureTotalScore) {
+                this.bugA = bugA;
+                this.bugB = bugB;
+                this.featureTotalScore = featureTotalScore;
+        }
+        
+        protected abstract String getFeatureName();
+        protected abstract void assignScorePoints();
+        public abstract double score();
+}
+
diff --git a/entomologist/src/org/monkey/comparator/GeneralPropertiesFeature.java b/entomologist/src/org/monkey/comparator/GeneralPropertiesFeature.java
new file mode 100644
index 0000000..ac4282c
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/GeneralPropertiesFeature.java
@@ -0,0 +1,52 @@
+package org.monkey.comparator;
+
+import org.monkey.comparator.bo.Bug;
+
+public class GeneralPropertiesFeature extends Feature {
+        private static double bugCategoryScore;
+        private static double lineNumberScore;
+        private static double functionNameScore;
+        private static double fileNameScore;
+        
+        public GeneralPropertiesFeature(Bug bugA, Bug bugB, double featureTotalScore) {
+                super(bugA, bugB, featureTotalScore);
+                featureName = "Feature: Bug General Properties";
+        }
+
+        private double compareGeneralProperties() {
+                double score = 0;
+                if (bugA.getCategory().equals(bugB.getCategory()))
+                        score += bugCategoryScore;
+                if (bugA.getFileName().equals(bugB.getFileName()))
+                        score += fileNameScore;
+                if (bugA.getFunctionName().equals(bugB.getFunctionName()))
+                        score += functionNameScore;
+                if (bugA.getLineNo() == bugB.getLineNo()) {
+                        score += lineNumberScore;
+                } else {
+                        score += Util.weightLineNumberDifference(bugA.getLineNo(), bugB.getLineNo()) * lineNumberScore;
+                }
+                
+                return score;
+        }
+                
+        @Override
+        public double score() {
+                assignScorePoints();
+                return compareGeneralProperties();
+        }
+
+        @Override
+        protected void assignScorePoints() {
+                bugCategoryScore = Constants.BUG_CATEGORY_WEIGHT * featureTotalScore;
+                lineNumberScore = Constants.LINE_NUMBER_WEIGHT * featureTotalScore;
+                functionNameScore = Constants.BUG_FUNCTION_NAME_WEIGHT * featureTotalScore;
+                fileNameScore = Constants.FILE_NAME_WEIGHT * featureTotalScore;
+        }
+
+        @Override
+        protected String getFeatureName() {
+                return featureName;
+        }
+
+}
diff --git a/entomologist/src/org/monkey/comparator/MonkeyComparator.java b/entomologist/src/org/monkey/comparator/MonkeyComparator.java
new file mode 100644
index 0000000..82428a2
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/MonkeyComparator.java
@@ -0,0 +1,75 @@
+package org.monkey.comparator;
+
+import java.io.File;
+import org.monkey.comparator.bo.Bug;
+import org.monkey.comparator.bo.XMLParser;
+
+public class MonkeyComparator {
+        public static double compareBugs(Bug bugA, Bug bugB, String propertiesFilePath) {
+                Constants.setUpConstants(propertiesFilePath);
+                
+                double similarityPercentage = 0;
+                double totalScore = Constants.GENERAL_PROPERTIES_FEATURE_SCORE + Constants.STACK_TRACE_FEATURE_SCORE;
+                
+                /* Register comparison features and start comparison */
+                Feature generalPropertiesFeature = new GeneralPropertiesFeature(bugA, bugB, Constants.GENERAL_PROPERTIES_FEATURE_SCORE);
+                Feature stackTraceFeature = new StackTraceFeature(bugA, bugB, Constants.STACK_TRACE_FEATURE_SCORE);
+                
+                BugComparator.register(generalPropertiesFeature);
+                BugComparator.register(stackTraceFeature);
+                similarityPercentage = (BugComparator.calculateScore() / totalScore) * 100;
+                
+                /* Cleanup */
+                BugComparator.unregister(generalPropertiesFeature);
+                BugComparator.unregister(stackTraceFeature);
+                
+                return similarityPercentage;
+        }
+        
+        private static void showErrorAndExit() {
+                System.err.println("Monkey Bug Comparator takes the following arguments: " +
+                                "file1.xml file2.xml -p configuration.properties");
+                System.exit(1);
+        }
+        
+        private static boolean checkFilePath(String filePath) {
+                if (new File(filePath).exists() == false) {
+                        System.err.println("File " + filePath + " not found!");
+                        showErrorAndExit();
+                }
+                return true;
+        }
+        public static void main(String[] args) {
+                String propertiesFilePath = null;
+                String bugAFilePath = null;
+                String bugBFilePath = null;
+                
+                if (args.length < 4)
+                        showErrorAndExit();
+                
+                for (int i = 0; i < args.length; i++) {
+                        if (args[i].equals("-p")) {
+                                propertiesFilePath = args[++i];
+                                checkFilePath(propertiesFilePath);
+                        }
+                        else if (null == bugAFilePath) {
+                                bugAFilePath = args[i];
+                                checkFilePath(bugAFilePath);
+                        } 
+                        else if (null == bugBFilePath) {
+                                bugBFilePath = args[i];
+                                checkFilePath(bugBFilePath);
+                        }
+                }
+                
+                if (null == propertiesFilePath || null == bugAFilePath || null == bugBFilePath)
+                        showErrorAndExit();
+                        
+                Bug bugA = XMLParser.parse(bugAFilePath);
+                Bug bugB = XMLParser.parse(bugBFilePath);
+                //XMLParser.printBug(bugA);
+                //XMLParser.printBug(bugB);
+                
+                System.out.println("Similarity Percentage = " + compareBugs(bugA, bugB, propertiesFilePath));
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/StackTraceFeature.java b/entomologist/src/org/monkey/comparator/StackTraceFeature.java
new file mode 100644
index 0000000..f2b13eb
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/StackTraceFeature.java
@@ -0,0 +1,167 @@
+package org.monkey.comparator;
+
+
+import org.monkey.comparator.bo.Bug;
+import org.monkey.comparator.bo.Epoch;
+import org.monkey.comparator.bo.Expression;
+import org.monkey.comparator.bo.Function;
+
+public class StackTraceFeature extends Feature {
+        private double functionNameScore;
+        private double functionLineNumberScore;
+        private double functionFileNameScore;
+        private double expressionSyntaxScore;
+        private double expressionValueScore;
+        private int functionNum;
+        private int expressionNum;
+        private int epochNum;
+        
+        public StackTraceFeature(Bug bugA, Bug bugB, double featureTotalScore) {
+                super(bugA, bugB, featureTotalScore);
+                featureName = "Feature: Stack-Trace";
+        }
+        
+        private double compareFunctions(int epochIndex) {
+                int numFunctionA = bugA.getEpoch(epochIndex).getFunctionNum();
+                int numFunctionB = bugB.getEpoch(epochIndex).getFunctionNum();
+                
+                if (numFunctionA >= numFunctionB)
+                        return doCompareFunctions(bugB.getEpoch(epochIndex), bugA.getEpoch(epochIndex));
+                return doCompareFunctions(bugA.getEpoch(epochIndex), bugB.getEpoch(epochIndex));
+        }
+        
+        private double doCompareFunctions(Epoch shorterEpoch, Epoch longerEpoch) {
+                double functionsScore = 0;
+                double expressionsScore = 0;
+                double tmpExpressionScore = 0;
+                
+                int numFunctionShorter = shorterEpoch.getFunctionNum();
+                int numFunctionLonger = longerEpoch.getFunctionNum();
+                Function functionShorterEpoch;
+                Function functionLongerEpoch;
+                for (int i = 0; i < numFunctionShorter; i++) {
+                        functionShorterEpoch = shorterEpoch.getFunction(i);
+                        for (int j = 0; j < numFunctionLonger; j++) {
+                                functionLongerEpoch = longerEpoch.getFunction(j);
+                                
+                                tmpExpressionScore = compareExpressions(functionShorterEpoch, functionLongerEpoch);
+                                expressionsScore += tmpExpressionScore;
+                                if (tmpExpressionScore > 0) {
+                                        if (functionShorterEpoch.getLineNo() == functionLongerEpoch.getLineNo()) {
+                                                functionsScore += functionLineNumberScore;
+                                        } else {
+                                                /* If there is some similarity in expressions, 
+                                                 * but function line numbers are not the same, 
+                                                 * score for function line numbers should NOT be zero */
+                                                functionsScore += Util.weightLineNumberDifference(functionShorterEpoch.getLineNo(), functionLongerEpoch.getLineNo()) 
+                                                                * functionLineNumberScore;
+                                        }
+                                        if(functionShorterEpoch.getFileName().equals(functionLongerEpoch.getFileName()))
+                                                functionsScore += functionFileNameScore;
+                                        if(functionShorterEpoch.getFunctionName().equals(functionLongerEpoch.getFunctionName()))
+                                                functionsScore += functionNameScore;
+                                        break;
+                                }
+                        }
+                }
+                return functionsScore + expressionsScore;
+        }
+        
+        private double compareExpressions(Function functionA, Function functionB) {
+                int numExpressionA = functionA.getExpressionNum();
+                int numExpressionB = functionB.getExpressionNum();
+                
+                if (numExpressionA >= numExpressionB)
+                        return doCompareExpressions(functionB, functionA);
+                return doCompareExpressions(functionA, functionB);
+        }
+        
+        private double doCompareExpressions(Function shorterFunction, Function longerFunction) {
+                double expressionsScore = 0;
+                int numExpressionShorter = shorterFunction.getExpressionNum();
+                int numExpressionLonger = longerFunction.getExpressionNum();
+                
+                Expression expressionShorterFunction;
+                Expression expressionLongerFunction;
+                for (int i = 0; i < numExpressionShorter; i++) {
+                        expressionShorterFunction = shorterFunction.getExpression(i);
+                        for (int j = 0; j < numExpressionLonger; j++) {
+                                expressionLongerFunction = longerFunction.getExpression(j);
+                                if (expressionShorterFunction.getName().equals(expressionLongerFunction.getName())) {
+                                        expressionsScore += expressionSyntaxScore;
+                                        if (ValueClassifier.classify(expressionShorterFunction.getValue(), expressionLongerFunction.getValue()))
+                                                expressionsScore += expressionValueScore;
+                                        break; // break inner loop
+                                }
+                        }
+                }
+                
+                return expressionsScore;
+        }
+        
+        @Override
+        public double score() {
+                assignScorePoints();
+                double finalScore = 0.0;
+                for (int i = 0; i < epochNum; i++)
+                        finalScore += compareFunctions(i);
+                return finalScore;
+        }
+
+        @Override
+        protected void assignScorePoints() {
+                int epochNumA = bugA.getEpochNum();
+                int epochNumB = bugB.getEpochNum();
+                epochNum = epochNumA <= epochNumB ? epochNumA : epochNumB; // compare the smallest number of epoch steps
+                
+                int expressionNumA, expressionNumB, functionNumA, functionNumB;
+                Function function;
+                for (int i = 0; i < epochNum; i++) {
+                        functionNumA = bugA.getEpoch(i).getFunctionNum();
+                        functionNumB = bugB.getEpoch(i).getFunctionNum();
+                        functionNum += functionNumA >= functionNumB ? functionNumA : functionNumB; // taking the larger number of functions of the two stack traces
+                        
+                        expressionNumA = 0;
+                        for (int j = 0; j < functionNumA; j++) {
+                                function = bugA.getEpoch(i).getFunction(j);
+                                expressionNumA += function.getExpressionNum();
+                        }
+                        
+                        expressionNumB = 0;
+                        for (int j = 0; j < functionNumB; j++) {
+                                function = bugB.getEpoch(i).getFunction(j);
+                                expressionNumB += function.getExpressionNum();
+                        }
+                        
+                        expressionNum += expressionNumA >= expressionNumB ? expressionNumA : expressionNumB; // taking the larger number of expressions of the two stack traces
+                }
+                
+        
+                double allFunctionSemanticsScore = Constants.FUNCTION_SEMANTICS_WEIGHT * featureTotalScore;
+                double singleFunctionSemanticsScore = (double)allFunctionSemanticsScore / (double)functionNum;
+                double allExpressionsScore = Constants.EXPRESSIONS_WEIGHT * featureTotalScore;
+                double singleExpressionScore = (double)allExpressionsScore / (double)expressionNum;
+                
+                /* Scoring for function semantics details */
+                functionNameScore = Constants.FUNCTION_NAME_WEIGHT *singleFunctionSemanticsScore;
+                functionFileNameScore = Constants.FUNCTION_FILE_NAME * singleFunctionSemanticsScore;
+                functionLineNumberScore = Constants.FUNCTION_LINE_WEIGHT * singleFunctionSemanticsScore;
+                
+                /* Scoring for expression semantics details */
+                expressionSyntaxScore = Constants.EXPRESSION_SYTNAX_WEIGHT * singleExpressionScore;
+                expressionValueScore = Constants.EXPRESSION_VALUE_WEIGHT * singleExpressionScore;
+        }
+        
+        
+        @Override
+        protected String getFeatureName() {
+                return featureName;
+        }
+        
+        /*
+        private double testTotalScore() {
+                return ((functionNameScore + functionFileNameScore + functionLineNumberScore) * functionNum) + ((expressionSyntaxScore + expressionValueScore) * expressionNum);
+        }
+        */
+
+}
diff --git a/entomologist/src/org/monkey/comparator/Util.java b/entomologist/src/org/monkey/comparator/Util.java
new file mode 100644
index 0000000..7f3f0c3
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/Util.java
@@ -0,0 +1,10 @@
+package org.monkey.comparator;
+
+public abstract class Util {
+        public static double weightLineNumberDifference(int lineNumberA, int lineNumberB) {
+                double diff = Math.abs(lineNumberA - lineNumberB);
+                double div = diff/(double)Constants.LINE_NUMBER_DIFFERENCE_THRESHOLD;
+                double weight = 1 - div;
+                return weight;
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/ValueClassifier.java b/entomologist/src/org/monkey/comparator/ValueClassifier.java
new file mode 100644
index 0000000..a81eafb
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/ValueClassifier.java
@@ -0,0 +1,75 @@
+package org.monkey.comparator;
+
+public class ValueClassifier {
+        public static boolean classify(String expressionValueA, String expressionValueB) {
+                /* If value classes disabled compare values normally and return */
+                if (Constants.ENABLE_VALUE_CLASSES == false) {
+                        if (expressionValueA.equals(expressionValueB))
+                                return true;
+                        return false;
+                }
+                
+                /* Value classes enabled */
+                if (((expressionValueA.startsWith("0x") || expressionValueA.equals("NULL")) 
+                                && (expressionValueB.startsWith("0x") || expressionValueB.equals("NULL")))) {
+                        return classifyPointer(expressionValueA, expressionValueB);
+                }
+                try {
+                        int iA = Integer.parseInt(expressionValueA);
+                        int iB = Integer.parseInt(expressionValueB);
+                        return classifyInteger(iA, iB);
+                }
+                catch (NumberFormatException e) {
+                        try {
+                                float fA = Float.parseFloat(expressionValueA);
+                                float fB = Float.parseFloat(expressionValueB);
+                                return classifyFloat(fA, fB);
+                        }
+                        catch (NumberFormatException ee) {
+                                return classifyString(expressionValueA, expressionValueB);
+                        }
+                }
+        }
+        
+        private static boolean classifyInteger(int expressionAValue, int expressionBValue) {
+                if (expressionAValue == 0 || expressionBValue == 0 || 
+                                expressionAValue == 1 || expressionBValue == 1 
+                                || expressionAValue == -1 || expressionBValue == -1 ||
+                                expressionAValue == Constants.MAX_INT || expressionBValue == Constants.MAX_INT ||
+                                expressionAValue == Constants.MIN_INT || expressionBValue == Constants.MIN_INT) {
+                        if (expressionAValue == expressionBValue)
+                                return true;
+                        return false;
+                }
+                return true;
+        }
+        
+        private static boolean classifyFloat(float bugAValue, float bugBValue) {
+                if (bugAValue == 0.0 || bugBValue == 0.0) {
+                        if (bugAValue == bugBValue)
+                                return true;
+                        return false;
+                }
+                return true;
+        }
+        
+        private static boolean classifyPointer(String bugAValue, String bugBValue) {
+                if (bugAValue.equals("NULL") || bugBValue.equals("NULL")) {
+                        if (bugAValue.equals(bugBValue))
+                                return true;
+                        return false;
+                }
+                return true;
+        }
+        
+        private static boolean classifyString(String bugAValue, String bugBValue) {
+                if (bugAValue.equals("NULL") || bugAValue.equals("") 
+                                || bugBValue.equals("NULL") || bugBValue.equals("")) {
+                        if (bugAValue.equals(bugBValue)) {
+                                return true;
+                        }
+                        return false;
+                }
+                return true;
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/bo/Bug.java b/entomologist/src/org/monkey/comparator/bo/Bug.java
new file mode 100644
index 0000000..62f4d24
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/bo/Bug.java
@@ -0,0 +1,44 @@
+package org.monkey.comparator.bo;
+
+import java.util.ArrayList;
+
+public class Bug {
+        private String category;
+        private String fileName;
+        private int lineNo;
+        private String functionName;
+        private ArrayList<Epoch> epochList = new ArrayList<Epoch>();
+        public void setFileName(String fileName) {
+                this.fileName = fileName;
+        }
+        public String getFileName() {
+                return fileName;
+        }
+        public void setLineNo(int lineNo) {
+                this.lineNo = lineNo;
+        }
+        public int getLineNo() {
+                return lineNo;
+        }
+        public void setFunctionName(String functionName) {
+                this.functionName = functionName;
+        }
+        public String getFunctionName() {
+                return functionName;
+        }
+        public void insertEpoch(Epoch epoch) {
+                this.epochList.add(epoch);
+        }
+        public Epoch getEpoch(int index) {
+                return epochList.get(index);
+        }
+        public void setCategory(String category) {
+                this.category = category;
+        }
+        public String getCategory() {
+                return category;
+        }
+        public int getEpochNum() {
+                return epochList.size();
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/bo/Epoch.java b/entomologist/src/org/monkey/comparator/bo/Epoch.java
new file mode 100644
index 0000000..71e2554
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/bo/Epoch.java
@@ -0,0 +1,24 @@
+package org.monkey.comparator.bo;
+
+import java.util.ArrayList;
+
+public class Epoch {
+        private int epochStep;
+        private ArrayList<Function> functionList = new ArrayList<Function>();
+        
+        public void setEpochStep(int epochStep) {
+                this.epochStep = epochStep;
+        }
+        public int getEpochStep() {
+                return epochStep;
+        }
+        public void insertFunction(Function function) {
+                this.functionList.add(function);
+        }
+        public Function getFunction(int index) {
+                return functionList.get(index);
+        }
+        public int getFunctionNum() {
+                return functionList.size();
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/bo/Expression.java b/entomologist/src/org/monkey/comparator/bo/Expression.java
new file mode 100644
index 0000000..7903189
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/bo/Expression.java
@@ -0,0 +1,19 @@
+package org.monkey.comparator.bo;
+
+public class Expression {
+        private String name;
+        private String value;
+        public void setName(String name) {
+                this.name = name;
+        }
+        public String getName() {
+                return name;
+        }
+        public void setValue(String value) {
+                this.value = value;
+        }
+        public String getValue() {
+                return value;
+        }
+
+}
diff --git a/entomologist/src/org/monkey/comparator/bo/Function.java b/entomologist/src/org/monkey/comparator/bo/Function.java
new file mode 100644
index 0000000..f6adbd2
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/bo/Function.java
@@ -0,0 +1,38 @@
+package org.monkey.comparator.bo;
+
+import java.util.ArrayList;
+
+public class Function {
+        private String functionName;
+        private int lineNo;
+        private String fileName;
+        private ArrayList<Expression> expressionList = new ArrayList<Expression>();
+        
+        public void setFunctionName(String functionName) {
+                this.functionName = functionName;
+        }
+        public String getFunctionName() {
+                return functionName;
+        }
+        public void setLineNo(int lineNo) {
+                this.lineNo = lineNo;
+        }
+        public int getLineNo() {
+                return lineNo;
+        }
+        public void insertExpression(Expression expression) {
+                this.expressionList.add(expression);
+        }
+        public Expression getExpression(int index) {
+                return expressionList.get(index);
+        }
+        public String getFileName() {
+                return fileName;
+        }
+        public void setFileName(String fileName) {
+                this.fileName = fileName;
+        }
+        public int getExpressionNum() {
+                return expressionList.size();
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/bo/XMLParser.java b/entomologist/src/org/monkey/comparator/bo/XMLParser.java
new file mode 100644
index 0000000..6254730
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/bo/XMLParser.java
@@ -0,0 +1,196 @@
+package org.monkey.comparator.bo;
+
+import java.io.File;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class XMLParser {
+        
+        /*
+         * The method parses Monkey's XML Bug Report.
+         * The following is an example the XML file the method expects for parsing
+         * <?xml version="1.0"?>
+                <crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+                        <history>
+                        <epoch step="0" >
+                                        <trace>
+                                                <function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+                                                        <expressions>
+                                                                <expression name="crashStruct" >NULL</expression>
+                                                        </expressions>
+                                                </function>
+                                        </trace>
+                                </epoch>
+                        </history>
+                </crash>
+         */
+        public static Bug parse(String filePath) {
+                Bug bug = new Bug();
+                try {
+                        NodeList epochNodeList;
+                        NodeList traceNodeList;
+                        NodeList functionNodeList;
+                        NodeList expressionNodeList;
+                        NodeList tmpNodeList;
+                        Node epochNode;
+                        Node traceNode;
+                        Node functionNode;
+                        Node expressionNode;
+                        Node tmpNode = null;
+                        Element element;
+                        Epoch epoch = null;
+                        Function function = null;
+                        Expression expression = null;
+                        File xmlFile = new File(filePath);
+
+                        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
+                                        .newInstance();
+                        DocumentBuilder documentBuilder = documentBuilderFactory
+                                        .newDocumentBuilder();
+                        Document document = documentBuilder.parse(xmlFile);
+                        document.getDocumentElement().normalize();
+
+                        /* Setting Bug Attributes */
+                        element = document.getDocumentElement(); /*
+                                                                                                         * This should be the crash
+                                                                                                         * node
+                                                                                                         */
+                        bug.setCategory(element.getAttribute("category"));
+                        bug.setFileName(element.getAttribute("file"));
+                        bug.setFunctionName(element.getAttribute("function"));
+                        bug.setLineNo(Integer.parseInt(element.getAttribute("line")));
+
+                        /* History is consisting of a list of epoch nodes */
+                        epochNodeList = document.getElementsByTagName("epoch");
+                        //printAllNodes(epochNodeList);
+                        for (int i = 0; i < epochNodeList.getLength(); i++) {
+                                epochNode = epochNodeList.item(i);
+                                if (epochNode.getNodeType() == Node.ELEMENT_NODE) {
+                                        epoch = new Epoch();
+                                        bug.insertEpoch(epoch);
+                                        epoch.setEpochStep(Integer.parseInt(epochNode
+                                                        .getAttributes().getNamedItem("step")
+                                                        .getNodeValue()));
+
+                                        /* Get the list of trace nodes for this epoch node */
+                                        traceNodeList = epochNode.getChildNodes();
+                                        for (int j = 0; j < traceNodeList.getLength(); j++) {
+                                                /* Get the list of function nodes for this trace node */
+                                                traceNode = traceNodeList.item(j);
+                                                if (traceNode.getNodeType() == Node.ELEMENT_NODE) {
+                                                        functionNodeList = traceNode.getChildNodes();
+                                                        for (int k = 0; k < functionNodeList.getLength(); k++) {
+                                                                functionNode = functionNodeList.item(k);
+                                                                if (functionNode.getNodeType() == Node.ELEMENT_NODE) {
+                                                                        function = new Function();
+                                                                        epoch.insertFunction(function);
+                                                                        function.setFunctionName(functionNode
+                                                                                        .getAttributes()
+                                                                                        .getNamedItem("name")
+                                                                                        .getNodeValue());
+                                                                        function.setLineNo(Integer
+                                                                                        .parseInt(functionNode
+                                                                                                        .getAttributes()
+                                                                                                        .getNamedItem("line")
+                                                                                                        .getNodeValue()));
+                                                                        function.setFileName(functionNode
+                                                                                        .getAttributes()
+                                                                                        .getNamedItem("file")
+                                                                                        .getNodeValue());
+
+                                                                        /*
+                                                                         * Get the list of expression nodes for this
+                                                                         * function
+                                                                         */
+                                                                        tmpNodeList = functionNode.getChildNodes();
+                                                                        for (int t = 0; t < tmpNodeList.getLength(); t++) { // skipping the
+                                                                                // unnecessary
+                                                                                // node
+                                                                                // named
+                                                                                // <expressions></expressions>
+                                                                                tmpNode = tmpNodeList.item(t);
+                                                                                if (tmpNode.getNodeName().equals("expressions"))
+                                                                                        break;
+                                                                        }
+                                                                        expressionNodeList = tmpNode.getChildNodes();
+                                                                        for (int l = 0; l < expressionNodeList
+                                                                                        .getLength(); l++) {
+                                                                                expressionNode = expressionNodeList
+                                                                                                .item(l);
+                                                                                if (expressionNode.getNodeType() == Node.ELEMENT_NODE) {
+                                                                                        expression = new Expression();
+                                                                                        function.insertExpression(expression);
+                                                                                        expression.setName(expressionNode
+                                                                                                        .getAttributes()
+                                                                                                        .getNamedItem("name")
+                                                                                                        .getNodeValue());
+                                                                                        expression.setValue(expressionNode
+                                                                                                        .getTextContent());
+                                                                                }
+                                                                        }
+                                                                } // end if functionNode
+                                                        } // end for functionNodeList
+                                                } // end if traceNode
+                                        } // end for traceNodeList
+                                } // end if epochNode
+                        } // end for epochNodeList
+                } catch (Exception e) {
+                        System.err.println("Fatal error: unable to parse XML file. Entomologist will exit now.");
+                        e.printStackTrace();
+                        System.exit(1);
+                }
+                return bug;
+        }
+
+        public static void printBug(Bug bug) {
+                Epoch epoch;
+                Function function;
+                Expression expression;
+                System.out.println("Bug:");
+                System.out.println("---------");
+                System.out.println("Category: " + bug.getCategory());
+                System.out.println("File Name: " + bug.getFileName());
+                System.out.println("Function Name: " + bug.getFunctionName());
+                System.out.println("Line Number: " + bug.getLineNo());
+                System.out.println("------------------------------------------------------");
+                for (int i = 0; i < bug.getEpochNum(); i++) {
+                        epoch = bug.getEpoch(i);
+                        System.out.println("Epoch Step: " + epoch.getEpochStep());
+                        System.out.println("---------------");
+                        for (int j = 0; j < epoch.getFunctionNum(); j++) {
+                                function = epoch.getFunction(j);
+                                System.out.println("Function: " + function.getFunctionName() + " file: " + function.getFileName() + " Lineno." + function.getLineNo());
+                                System.out.println("-----------------------------------------------------");
+                                for (int k = 0; k < function.getExpressionNum(); k++) {
+                                        expression = function.getExpression(k);
+                                        System.out.println(expression.getName() + " = " + expression.getValue());
+                                }
+                                System.out.println("");
+                        }
+                        System.out.println("");
+                }
+        }
+        
+        
+        
+        // This method is used for debugging
+        /*
+        private static void printAllNodes(NodeList nodeList) {
+                NodeList childNodes;
+                for (int i = 0; i < nodeList.getLength(); i++) {
+                        if (nodeList.item(i).getNodeType() == Node.ELEMENT_NODE) {
+                                System.out.println(nodeList.item(i).getNodeName() + " type ="
+                                                + nodeList.item(i).getNodeType());
+                                childNodes = nodeList.item(i).getChildNodes();
+                                printAllNodes(childNodes);
+                        }
+                }
+        }
+        */
+}
diff --git a/entomologist/src/org/monkey/comparator/testing/ComparatorTest.java b/entomologist/src/org/monkey/comparator/testing/ComparatorTest.java
new file mode 100644
index 0000000..5906fd3
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/ComparatorTest.java
@@ -0,0 +1,111 @@
+package org.monkey.comparator.testing;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.monkey.comparator.MonkeyComparator;
+import org.monkey.comparator.bo.Bug;
+import org.monkey.comparator.bo.XMLParser;
+
+public class ComparatorTest {
+
+        @Test
+        public void testTotalSimilarity() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey.xml");
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                assertEquals(100.0, similarityPercentage, 0);
+                System.out.println("score = " + similarityPercentage);
+        }
+        
+        @Test
+        public void testSameStackDifferentFunctionNames() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_fname.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                assertEquals(99.58333333333333, similarityPercentage, 0);
+                System.out.println("score = " + similarityPercentage);
+        }
+
+        @Test
+        public void testCommonAndDifferentExpressions() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_common_and_different_exp.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                assertEquals(93.33333333333333, similarityPercentage, 0);
+                System.out.println("score = " + similarityPercentage);
+        }
+        
+        @Test
+        public void testSlightlyDifferentStackTraces() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_trace.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                assertEquals(88.8888888888889, similarityPercentage, 0);
+                System.out.println("score = " + similarityPercentage);
+        }
+        
+        @Test
+        public void testNpeAndNpeExpressionsModified() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/npe.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/npe_expressions_modified.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                assertEquals(89.25, similarityPercentage, 0);
+                System.out.println("score = " + similarityPercentage);
+        }
+        
+        @Test
+        public void testNpeAndNpeExpressionsAndStackModified() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/npe.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/npe_expressions_and_stack_modified.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                assertEquals(80.76282051282053, similarityPercentage, 0);
+                System.out.println("score = " + similarityPercentage);
+        }
+        
+
+        @Test
+        public void testNpeAndDivisionByZero() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/npe.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/npe_divzero.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                System.out.println("score = " + similarityPercentage);
+                assertEquals(32.958333333333336, similarityPercentage, 0);
+        }
+        
+        @Test
+        public void testIdenticalHistory() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_trace.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_trace.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                System.out.println("score = " + similarityPercentage);
+                assertEquals(100.0, similarityPercentage, 0);
+        }
+        
+        @Test
+        public void testDifferentHistory() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_trace.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_history.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                System.out.println("score = " + similarityPercentage);
+                assertEquals(94.44444444444446, similarityPercentage, 0);
+        }
+        
+        @Test
+        public void testDifferentAndLongerHistory() {
+                Bug bugA = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_trace.xml");
+                Bug bugB = XMLParser.parse("src/org/monkey/comparator/testing/refs/monkey_different_and_longer_history.xml");
+                
+                double similarityPercentage = MonkeyComparator.compareBugs(bugA, bugB, "comparator.properties");
+                System.out.println("score = " + similarityPercentage);
+                assertEquals(94.44444444444446, similarityPercentage, 0);
+        }
+}
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/monkey.xml b/entomologist/src/org/monkey/comparator/testing/refs/monkey.xml
new file mode 100644
index 0000000..f484a32
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/monkey.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history>
+<epoch step="0" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/monkey_common_and_different_exp.xml b/entomologist/src/org/monkey/comparator/testing/refs/monkey_common_and_different_exp.xml
new file mode 100644
index 0000000..9b69ef2
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/monkey_common_and_different_exp.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history>
+<epoch step="0" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="p" >10</expression>
+<expression name="y" >6</expression>
+<expression name="ssss" >Hello</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="p" >10</expression>
+<expression name="y" >6</expression>
+<expression name="ssss" >Hello</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_and_longer_history.xml b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_and_longer_history.xml
new file mode 100644
index 0000000..2a2edde
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_and_longer_history.xml
@@ -0,0 +1,114 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history>
+<epoch step="0" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="i" >3</expression>
+<expression name="j" >7</expression>
+<expression name="k" >9</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="i" >3</expression>
+<expression name="j" >7</expression>
+<expression name="k" >9</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="i" >3</expression>
+<expression name="j" >7</expression>
+<expression name="k" >9</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_fname.xml b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_fname.xml
new file mode 100644
index 0000000..4bc9adb
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_fname.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history>
+<epoch step="0" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="theOtherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="theOtherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_history.xml b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_history.xml
new file mode 100644
index 0000000..7fc9ac0
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_history.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history>
+<epoch step="0" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="i" >3</expression>
+<expression name="j" >7</expression>
+<expression name="k" >9</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_trace.xml b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_trace.xml
new file mode 100644
index 0000000..200364c
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/monkey_different_trace.xml
@@ -0,0 +1,61 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history>
+<epoch step="0" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace>
+<function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="crashStruct" >NULL</expression>
+<expression name="x" >5</expression>
+<expression name="y" >6</expression>
+<expression name="s" >Hello</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions>
+<expression name="alpha" >1</expression>
+<expression name="beta" >2</expression>
+<expression name="gamma" >7</expression>
+<expression name="delta" >hurray</expression>
+</expressions>
+</function>
+<function name="anotherCrashFunction" line="3" file="bug_null_pointer_exception.c" depth="1" >
+<expressions>
+<expression name="a" >3</expression>
+<expression name="b" >7</expression>
+<expression name="c" >9</expression>
+<expression name="d" >112</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/npe.xml b/entomologist/src/org/monkey/comparator/testing/refs/npe.xml
new file mode 100644
index 0000000..a5ae517
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/npe.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue=&quot;hello!&quot;" >
+Not Evaluated</expression>
+<expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+Not Evaluated</expression>
+<expression name="crashStruct" >
+0x0</expression>
+</expressions>
+</function>
+<function name="main" line="19" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+Not Evaluated</expression>
+<expression name="argc" >
+Not Evaluated</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/npe_divzero.xml b/entomologist/src/org/monkey/comparator/testing/refs/npe_divzero.xml
new file mode 100644
index 0000000..7af7cfc
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/npe_divzero.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0"?>
+<crash category="Division By Zero" function="crashFunction" line="21" file="bug_null_pointer_exception.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="21" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+Not Evaluated</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+0</expression>
+<expression name="NULL" >
+Not Evaluated</expression>
+<expression name="crashStruct" >
+0x0</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+Not Evaluated</expression>
+<expression name="argc" >
+Not Evaluated</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/npe_expressions_and_stack_modified.xml b/entomologist/src/org/monkey/comparator/testing/refs/npe_expressions_and_stack_modified.xml
new file mode 100644
index 0000000..6082988
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/npe_expressions_and_stack_modified.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="20" file="bug_null_pointer_exception.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="20" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue=&quot;hello!&quot;" >
+Not Evaluated</expression>
+<expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+Not Evaluated</expression>
+<expression name="crashStruct" >
+0x0</expression>
+<expression name="a+b" >
+8</expression>
+<expression name="c" >
+8</expression>
+<expression name="b" >
+5</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+Not Evaluated</expression>
+<expression name="argc" >
+Not Evaluated</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/entomologist/src/org/monkey/comparator/testing/refs/npe_expressions_modified.xml b/entomologist/src/org/monkey/comparator/testing/refs/npe_expressions_modified.xml
new file mode 100644
index 0000000..ad2ac79
--- /dev/null
+++ b/entomologist/src/org/monkey/comparator/testing/refs/npe_expressions_modified.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="20" file="bug_null_pointer_exception.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="20" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue=&quot;hello!&quot;" >
+Not Evaluated</expression>
+<expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+Not Evaluated</expression>
+<expression name="crashStruct" >
+0x0</expression>
+<expression name="a+b" >
+8</expression>
+<expression name="c" >
+8</expression>
+<expression name="b" >
+5</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="main" line="25" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+Not Evaluated</expression>
+<expression name="argc" >
+Not Evaluated</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/monkey_build_script b/monkey_build_script
new file mode 100644
index 0000000..dad9937
--- /dev/null
+++ b/monkey_build_script
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+echo "################## UNINSTALLING MONKEY ##################"
+sudo make uninstall
+echo "################## CLEANING WORKING DIRECTORY ###########"
+sudo make clean
+sudo make distclean
+echo "################## BOOTSTRAPPING ########################"
+./bootstrap
+echo "################## CONFIGURING MONKEY ###################"
+CFLAGS="-g -O0" ./configure
+echo "################## BUILDING MONKEY ######################"
+make
+echo "################## INSTALLING MONKEY ####################"
+sudo make install
+
diff --git a/pathologist/ABOUT-NLS b/pathologist/ABOUT-NLS
new file mode 100644
index 0000000..83bc72e
--- /dev/null
+++ b/pathologist/ABOUT-NLS
@@ -0,0 +1,1068 @@
+1 Notes on the Free Translation Project
+***************************************
+
+Free software is going international!  The Free Translation Project is
+a way to get maintainers of free software, translators, and users all
+together, so that free software will gradually become able to speak many
+languages.  A few packages already provide translations for their
+messages.
+
+   If you found this `ABOUT-NLS' file inside a distribution, you may
+assume that the distributed package does use GNU `gettext' internally,
+itself available at your nearest GNU archive site.  But you do _not_
+need to install GNU `gettext' prior to configuring, installing or using
+this package with messages translated.
+
+   Installers will find here some useful hints.  These notes also
+explain how users should proceed for getting the programs to use the
+available translations.  They tell how people wanting to contribute and
+work on translations can contact the appropriate team.
+
+   When reporting bugs in the `intl/' directory or bugs which may be
+related to internationalization, you should tell about the version of
+`gettext' which is used.  The information can be found in the
+`intl/VERSION' file, in internationalized packages.
+
+1.1 Quick configuration advice
+==============================
+
+If you want to exploit the full power of internationalization, you
+should configure it using
+
+     ./configure --with-included-gettext
+
+to force usage of internationalizing routines provided within this
+package, despite the existence of internationalizing capabilities in the
+operating system where this package is being installed.  So far, only
+the `gettext' implementation in the GNU C library version 2 provides as
+many features (such as locale alias, message inheritance, automatic
+charset conversion or plural form handling) as the implementation here.
+It is also not possible to offer this additional functionality on top
+of a `catgets' implementation.  Future versions of GNU `gettext' will
+very likely convey even more functionality.  So it might be a good idea
+to change to GNU `gettext' as soon as possible.
+
+   So you need _not_ provide this option if you are using GNU libc 2 or
+you have installed a recent copy of the GNU gettext package with the
+included `libintl'.
+
+1.2 INSTALL Matters
+===================
+
+Some packages are "localizable" when properly installed; the programs
+they contain can be made to speak your own native language.  Most such
+packages use GNU `gettext'.  Other packages have their own ways to
+internationalization, predating GNU `gettext'.
+
+   By default, this package will be installed to allow translation of
+messages.  It will automatically detect whether the system already
+provides the GNU `gettext' functions.  If not, the included GNU
+`gettext' library will be used.  This library is wholly contained
+within this package, usually in the `intl/' subdirectory, so prior
+installation of the GNU `gettext' package is _not_ required.
+Installers may use special options at configuration time for changing
+the default behaviour.  The commands:
+
+     ./configure --with-included-gettext
+     ./configure --disable-nls
+
+will, respectively, bypass any pre-existing `gettext' to use the
+internationalizing routines provided within this package, or else,
+_totally_ disable translation of messages.
+
+   When you already have GNU `gettext' installed on your system and run
+configure without an option for your new package, `configure' will
+probably detect the previously built and installed `libintl.a' file and
+will decide to use this.  This might not be desirable.  You should use
+the more recent version of the GNU `gettext' library.  I.e. if the file
+`intl/VERSION' shows that the library which comes with this package is
+more recent, you should use
+
+     ./configure --with-included-gettext
+
+to prevent auto-detection.
+
+   The configuration process will not test for the `catgets' function
+and therefore it will not be used.  The reason is that even an
+emulation of `gettext' on top of `catgets' could not provide all the
+extensions of the GNU `gettext' library.
+
+   Internationalized packages usually have many `po/LL.po' files, where
+LL gives an ISO 639 two-letter code identifying the language.  Unless
+translations have been forbidden at `configure' time by using the
+`--disable-nls' switch, all available translations are installed
+together with the package.  However, the environment variable `LINGUAS'
+may be set, prior to configuration, to limit the installed set.
+`LINGUAS' should then contain a space separated list of two-letter
+codes, stating which languages are allowed.
+
+1.3 Using This Package
+======================
+
+As a user, if your language has been installed for this package, you
+only have to set the `LANG' environment variable to the appropriate
+`LL_CC' combination.  If you happen to have the `LC_ALL' or some other
+`LC_xxx' environment variables set, you should unset them before
+setting `LANG', otherwise the setting of `LANG' will not have the
+desired effect.  Here `LL' is an ISO 639 two-letter language code, and
+`CC' is an ISO 3166 two-letter country code.  For example, let's
+suppose that you speak German and live in Germany.  At the shell
+prompt, merely execute `setenv LANG de_DE' (in `csh'),
+`export LANG; LANG=de_DE' (in `sh') or `export LANG=de_DE' (in `bash').
+This can be done from your `.login' or `.profile' file, once and for
+all.
+
+   You might think that the country code specification is redundant.
+But in fact, some languages have dialects in different countries.  For
+example, `de_AT' is used for Austria, and `pt_BR' for Brazil.  The
+country code serves to distinguish the dialects.
+
+   The locale naming convention of `LL_CC', with `LL' denoting the
+language and `CC' denoting the country, is the one use on systems based
+on GNU libc.  On other systems, some variations of this scheme are
+used, such as `LL' or `LL_CC.ENCODING'.  You can get the list of
+locales supported by your system for your language by running the
+command `locale -a | grep '^LL''.
+
+   Not all programs have translations for all languages.  By default, an
+English message is shown in place of a nonexistent translation.  If you
+understand other languages, you can set up a priority list of languages.
+This is done through a different environment variable, called
+`LANGUAGE'.  GNU `gettext' gives preference to `LANGUAGE' over `LANG'
+for the purpose of message handling, but you still need to have `LANG'
+set to the primary language; this is required by other parts of the
+system libraries.  For example, some Swedish users who would rather
+read translations in German than English for when Swedish is not
+available, set `LANGUAGE' to `sv:de' while leaving `LANG' to `sv_SE'.
+
+   Special advice for Norwegian users: The language code for Norwegian
+bokma*l changed from `no' to `nb' recently (in 2003).  During the
+transition period, while some message catalogs for this language are
+installed under `nb' and some older ones under `no', it's recommended
+for Norwegian users to set `LANGUAGE' to `nb:no' so that both newer and
+older translations are used.
+
+   In the `LANGUAGE' environment variable, but not in the `LANG'
+environment variable, `LL_CC' combinations can be abbreviated as `LL'
+to denote the language's main dialect.  For example, `de' is equivalent
+to `de_DE' (German as spoken in Germany), and `pt' to `pt_PT'
+(Portuguese as spoken in Portugal) in this context.
+
+1.4 Translating Teams
+=====================
+
+For the Free Translation Project to be a success, we need interested
+people who like their own language and write it well, and who are also
+able to synergize with other translators speaking the same language.
+Each translation team has its own mailing list.  The up-to-date list of
+teams can be found at the Free Translation Project's homepage,
+`http://translationproject.org/', in the "Teams" area.
+
+   If you'd like to volunteer to _work_ at translating messages, you
+should become a member of the translating team for your own language.
+The subscribing address is _not_ the same as the list itself, it has
+`-request' appended.  For example, speakers of Swedish can send a
+message to `sv-request@li.org', having this message body:
+
+     subscribe
+
+   Keep in mind that team members are expected to participate
+_actively_ in translations, or at solving translational difficulties,
+rather than merely lurking around.  If your team does not exist yet and
+you want to start one, or if you are unsure about what to do or how to
+get started, please write to `coordinator@translationproject.org' to
+reach the coordinator for all translator teams.
+
+   The English team is special.  It works at improving and uniformizing
+the terminology in use.  Proven linguistic skills are praised more than
+programming skills, here.
+
+1.5 Available Packages
+======================
+
+Languages are not equally supported in all packages.  The following
+matrix shows the current state of internationalization, as of November
+2007.  The matrix shows, in regard of each package, for which languages
+PO files have been submitted to translation coordination, with a
+translation percentage of at least 50%.
+
+     Ready PO files       af am ar az be bg bs ca cs cy da de el en en_GB eo
+                        +----------------------------------------------------+
+     Compendium         |                      []       [] []        []      |
+     a2ps               |             []                [] [] []     []      |
+     aegis              |                                  ()                |
+     ant-phone          |                                  ()                |
+     anubis             |                                  []                |
+     ap-utils           |                                                    |
+     aspell             |                      [] []    [] []        []      |
+     bash               |                                                 [] |
+     bfd                |                                                    |
+     bibshelf           |                                  []                |
+     binutils           |                                                    |
+     bison              |                               [] []                |
+     bison-runtime      |                                  []                |
+     bluez-pin          | []                      []       [] []          [] |
+     cflow              |                               []                   |
+     clisp              |                               [] []    []          |
+     console-tools      |                         []       []                |
+     coreutils          |                []    [] []       []                |
+     cpio               |                                                    |
+     cpplib             |                      []       [] []                |
+     cryptonit          |                                  []                |
+     dialog             |                                                    |
+     diffutils          |                      [] []    [] [] []          [] |
+     doodle             |                                  []                |
+     e2fsprogs          |                         []       []                |
+     enscript           |                      []       [] []        []      |
+     fetchmail          |                      []       [] () []     []      |
+     findutils          |                []                                  |
+     findutils_stable   |                []    []       []                   |
+     flex               |                      []       [] []                |
+     fslint             |                                                    |
+     gas                |                                                    |
+     gawk               |                      []       [] []                |
+     gcal               |                      []                            |
+     gcc                |                                  []                |
+     gettext-examples   | []                   []          [] []          [] |
+     gettext-runtime    |             []       []       [] []             [] |
+     gettext-tools      |                      []          []                |
+     gip                |                []                                  |
+     gliv               |                []                []                |
+     glunarclock        |                []                                  |
+     gmult              | []                               []                |
+     gnubiff            |                                  ()                |
+     gnucash            |                      [] []       () ()     []      |
+     gnuedu             |                                                    |
+     gnulib             |                []                                  |
+     gnunet             |                                                    |
+     gnunet-gtk         |                                                    |
+     gnutls             |                                  []                |
+     gpe-aerial         |                         []       []                |
+     gpe-beam           |                         []       []                |
+     gpe-calendar       |                                                    |
+     gpe-clock          |                         []       []                |
+     gpe-conf           |                         []       []                |
+     gpe-contacts       |                                                    |
+     gpe-edit           |                         []                         |
+     gpe-filemanager    |                                                    |
+     gpe-go             |                         []                         |
+     gpe-login          |                         []       []                |
+     gpe-ownerinfo      |                         []       []                |
+     gpe-package        |                                                    |
+     gpe-sketchbook     |                         []       []                |
+     gpe-su             |                         []       []                |
+     gpe-taskmanager    |                         []       []                |
+     gpe-timesheet      |                         []                         |
+     gpe-today          |                         []       []                |
+     gpe-todo           |                                                    |
+     gphoto2            |                         []    [] []        []      |
+     gprof              |                               [] []                |
+     gpsdrive           |                                                    |
+     gramadoir          | []                               []                |
+     grep               |                         []                      [] |
+     gretl              |                                  ()                |
+     gsasl              |                                                    |
+     gss                |                                                    |
+     gst-plugins-bad    |                []             []                   |
+     gst-plugins-base   |                []             []                   |
+     gst-plugins-good   |                []    []       []                   |
+     gst-plugins-ugly   |                []             []                   |
+     gstreamer          | []             []    [] []    [] []        []      |
+     gtick              |                                  ()                |
+     gtkam              |             []          []    [] []                |
+     gtkorphan          |                []                []                |
+     gtkspell           |             []                   [] []          [] |
+     gutenprint         |                               []                   |
+     hello              |                []    []       [] []             [] |
+     herrie             |                                  []                |
+     hylafax            |                                                    |
+     idutils            |                               [] []                |
+     indent             |                      [] []       []             [] |
+     iso_15924          |                                                    |
+     iso_3166           |       []    [] [] [] [] [] [] [] [] []          [] |
+     iso_3166_2         |                                                    |
+     iso_4217           |                         []    [] []                |
+     iso_639            |                         []    [] []             [] |
+     jpilot             |                         []                         |
+     jtag               |                                                    |
+     jwhois             |                                                    |
+     kbd                |                         []    [] [] []             |
+     keytouch           |                      []          []                |
+     keytouch-editor    |                                  []                |
+     keytouch-keyboa... |                      []                            |
+     latrine            |                                  ()                |
+     ld                 |                               []                   |
+     leafpad            |                []    [] []       [] []             |
+     libc               |                      [] []    [] []                |
+     libexif            |                                  []                |
+     libextractor       |                                  []                |
+     libgpewidget       |                         []    [] []                |
+     libgpg-error       |                                  []                |
+     libgphoto2         |                               [] []                |
+     libgphoto2_port    |                               [] []                |
+     libgsasl           |                                                    |
+     libiconv           |                                  []             [] |
+     libidn             |                         []    []                [] |
+     lifelines          |                               [] ()                |
+     lilypond           |                                  []                |
+     lingoteach         |                                                    |
+     lprng              |                                                    |
+     lynx               |                      [] []    [] []                |
+     m4                 |                         []    [] [] []             |
+     mailfromd          |                                                    |
+     mailutils          |                      []                            |
+     make               |                               [] []                |
+     man-db             |                      []       [] []                |
+     minicom            |                         []    [] []                |
+     nano               |                []    []          []                |
+     opcodes            |                                  []                |
+     parted             |                         []       []                |
+     pilot-qof          |                                                    |
+     popt               |                         []    [] []                |
+     psmisc             |                []                                  |
+     pwdutils           |                                                    |
+     qof                |                                                    |
+     radius             |                      []                            |
+     recode             |             []       []       [] [] []          [] |
+     rpm                |                               []                   |
+     screem             |                                                    |
+     scrollkeeper       |          [] []       [] [] [] [] []        []      |
+     sed                |                      []          []             [] |
+     shared-mime-info   |                []    [] []    [] () []     []   [] |
+     sharutils          |                []    [] []    [] [] []             |
+     shishi             |                                                    |
+     skencil            |                               [] ()                |
+     solfege            |                                                    |
+     soundtracker       |                               [] []                |
+     sp                 |                                  []                |
+     system-tools-ba... |       []       [] [] [] []    [] [] []     []      |
+     tar                |                []                []                |
+     texinfo            |                               [] []             [] |
+     tin                |                                  ()        ()      |
+     tuxpaint           | []             []             [] []        []   [] |
+     unicode-han-tra... |                                                    |
+     unicode-transla... |                                                    |
+     util-linux         |                      [] []    [] []                |
+     util-linux-ng      |                      [] []    [] []                |
+     vorbis-tools       |                         []                         |
+     wastesedge         |                                  ()                |
+     wdiff              |                      []       [] []        []      |
+     wget               |                      [] []       []                |
+     xchat              |             [] []    [] []       [] []     []      |
+     xkeyboard-config   |                []                                  |
+     xpad               |                []             []           []      |
+                        +----------------------------------------------------+
+                          af am ar az be bg bs ca cs cy da de el en en_GB eo
+                           6  0  2  1  8 26  2 40 48  2 56 88 15  1  15   18
+
+                          es et eu fa fi fr  ga gl gu he hi hr hu id is it
+                        +--------------------------------------------------+
+     Compendium         | []          [] []  []                []          |
+     a2ps               |    []       [] []                             () |
+     aegis              |                                                  |
+     ant-phone          |                []                                |
+     anubis             |                []                                |
+     ap-utils           |             [] []                                |
+     aspell             |                []  []                         [] |
+     bash               | []                                               |
+     bfd                | []          []                                   |
+     bibshelf           | []                 []                         [] |
+     binutils           | []          [] []                                |
+     bison              | [] []          []  []                   []    [] |
+     bison-runtime      |    []          []  []                   []    [] |
+     bluez-pin          |             [] []  []                [] []       |
+     cflow              |                    []                            |
+     clisp              | []             []                                |
+     console-tools      |                                                  |
+     coreutils          | [] []       [] []  []                []          |
+     cpio               | []             []  []                            |
+     cpplib             | []             []                                |
+     cryptonit          |                []                                |
+     dialog             |       []           []                         [] |
+     diffutils          | []          [] []  [] []    []       [] []    [] |
+     doodle             |                    []                         [] |
+     e2fsprogs          | []             []                             [] |
+     enscript           |                []  []             []             |
+     fetchmail          | []                                               |
+     findutils          |    []              []                []          |
+     findutils_stable   |    []          []  []                []          |
+     flex               | []             []  []                            |
+     fslint             |                                                  |
+     gas                | []             []                                |
+     gawk               | []             []  []       []                () |
+     gcal               | []             []                                |
+     gcc                | []                                               |
+     gettext-examples   | []          [] []  []                [] []    [] |
+     gettext-runtime    | []          [] []  []                   []    [] |
+     gettext-tools      | []    []       []                             [] |
+     gip                | []    []       []  []                            |
+     gliv               |                ()                                |
+     glunarclock        |             []     []                []          |
+     gmult              |       []       []                             [] |
+     gnubiff            |                ()                             () |
+     gnucash            | ()             ()                    ()          |
+     gnuedu             | []                                               |
+     gnulib             | [] []              []                            |
+     gnunet             |                                                  |
+     gnunet-gtk         |                                                  |
+     gnutls             |                                                  |
+     gpe-aerial         | []             []                                |
+     gpe-beam           | []             []                                |
+     gpe-calendar       |                                                  |
+     gpe-clock          | []          [] []                    []          |
+     gpe-conf           |                []                                |
+     gpe-contacts       | []             []                                |
+     gpe-edit           | []             []                    [] []       |
+     gpe-filemanager    | []                                               |
+     gpe-go             | []             []                    []          |
+     gpe-login          | []             []                    []          |
+     gpe-ownerinfo      | []          [] []                    [] []       |
+     gpe-package        | []                                               |
+     gpe-sketchbook     | []             []                                |
+     gpe-su             | []          [] []                    []          |
+     gpe-taskmanager    | []          [] []                                |
+     gpe-timesheet      | []             []  []                   []       |
+     gpe-today          | []          [] []  []                            |
+     gpe-todo           | []                                               |
+     gphoto2            | []          [] []                    []       [] |
+     gprof              | []          [] []  []                   []       |
+     gpsdrive           |    []                                            |
+     gramadoir          |                []  []                            |
+     grep               | []          []     []                            |
+     gretl              | []    []       []                             () |
+     gsasl              |                    []                   []       |
+     gss                |                []  []                            |
+     gst-plugins-bad    | []          []                       []       [] |
+     gst-plugins-base   | []          []                       []       [] |
+     gst-plugins-good   | []    []    []                       []       [] |
+     gst-plugins-ugly   | []          []                       []       [] |
+     gstreamer          |             []                       []       [] |
+     gtick              |             []     []                         [] |
+     gtkam              | []             []                    []       [] |
+     gtkorphan          |                []                             [] |
+     gtkspell           | []    []    [] []  []                []       [] |
+     gutenprint         |                                      []          |
+     hello              | [] [] [] [] [] []  [] []    []    [] [] []    [] |
+     herrie             |                    []                            |
+     hylafax            |                                                  |
+     idutils            |                []  []                [] []    [] |
+     indent             | [] [] []    [] []  [] []             [] []    [] |
+     iso_15924          |                []                                |
+     iso_3166           | [] [] []    [] []     [] [] [] [] [] [] []    [] |
+     iso_3166_2         |                []                                |
+     iso_4217           | [] []       [] []                    []       [] |
+     iso_639            | []       [] [] []  []                []          |
+     jpilot             | []             []                                |
+     jtag               |                []                                |
+     jwhois             | []             []                    [] []    [] |
+     kbd                | []             []                                |
+     keytouch           |                []  []                         [] |
+     keytouch-editor    |                    []                            |
+     keytouch-keyboa... |                    []                         [] |
+     latrine            |                    []                         [] |
+     ld                 | []          [] []  []                            |
+     leafpad            | []             []  []       []       []       [] |
+     libc               | []          [] []     []             []          |
+     libexif            | []                                               |
+     libextractor       |                    []                            |
+     libgpewidget       | []             []  []                [] []       |
+     libgpg-error       |                []                                |
+     libgphoto2         | []             []                             [] |
+     libgphoto2_port    |                []                             [] |
+     libgsasl           |                []  []                            |
+     libiconv           |    []       []     []                            |
+     libidn             |                []                             [] |
+     lifelines          |                ()                                |
+     lilypond           | []          [] []                                |
+     lingoteach         |                []                       []    [] |
+     lprng              |                                                  |
+     lynx               |    []                                []       [] |
+     m4                 |                []  [] []                []       |
+     mailfromd          |                                                  |
+     mailutils          | []             []                                |
+     make               | []          [] []  [] []    []    []    []       |
+     man-db             |                                               [] |
+     minicom            | []          [] []                    []          |
+     nano               | []    []       []  [] []             []       [] |
+     opcodes            | []          [] []  []                            |
+     parted             |                []                       []    [] |
+     pilot-qof          |                                                  |
+     popt               |                []  [] []                   []    |
+     psmisc             |                                      []       [] |
+     pwdutils           |                                                  |
+     qof                |                                         []       |
+     radius             | []             []                                |
+     recode             | []             []  [] []    []       [] []    [] |
+     rpm                |                []                       []       |
+     screem             |                                                  |
+     scrollkeeper       | []          []                       []          |
+     sed                | [] []          []  []                []          |
+     shared-mime-info   | []    []    [] []                    []       [] |
+     sharutils          | [] []       [] []  [] []             []       [] |
+     shishi             |                []                                |
+     skencil            | []             []                                |
+     solfege            |                                               [] |
+     soundtracker       | []             []                             [] |
+     sp                 |                []                                |
+     system-tools-ba... | []    []    [] []  []             [] [] []    [] |
+     tar                |    [] []    []     []                []          |
+     texinfo            |                []           []       []          |
+     tin                |    []          ()                                |
+     tuxpaint           |                    []                []          |
+     unicode-han-tra... |                                                  |
+     unicode-transla... |                []  []                            |
+     util-linux         | [] []       [] []                    [] []    [] |
+     util-linux-ng      | [] []       [] []                    [] []    [] |
+     vorbis-tools       |                                                  |
+     wastesedge         |                ()                                |
+     wdiff              | [] []          []  [] []             [] []    [] |
+     wget               |    []       [] []  []             [] [] []    [] |
+     xchat              | []          [] []        []    []    []       [] |
+     xkeyboard-config   | []          [] []                    []          |
+     xpad               | []                 []                []          |
+                        +--------------------------------------------------+
+                          es et eu fa fi fr  ga gl gu he hi hr hu id is it
+                          85 22 14  2 48 101 61 12  2  8  2  6 53 29  1 52
+
+                          ja ka ko ku ky lg lt lv mk mn ms mt nb ne nl  nn
+                        +--------------------------------------------------+
+     Compendium         |                                           []     |
+     a2ps               |       ()                      []          []     |
+     aegis              |                                           ()     |
+     ant-phone          |                                           []     |
+     anubis             |                               []    []    []     |
+     ap-utils           |                               []                 |
+     aspell             |                            []             []     |
+     bash               |                                           []     |
+     bfd                |                                                  |
+     bibshelf           |                               []                 |
+     binutils           |                                                  |
+     bison              |                               []    []    []     |
+     bison-runtime      |                               []    []    []     |
+     bluez-pin          |          []                   []          []     |
+     cflow              |                                                  |
+     clisp              |                                           []     |
+     console-tools      |                                                  |
+     coreutils          |                                           []     |
+     cpio               |                                           []     |
+     cpplib             |                                           []     |
+     cryptonit          |                                           []     |
+     dialog             |                               []          []     |
+     diffutils          | []                            []          []     |
+     doodle             |                                                  |
+     e2fsprogs          |                                           []     |
+     enscript           |                                           []     |
+     fetchmail          | []                                        []     |
+     findutils          |                                           []     |
+     findutils_stable   |                                           []     |
+     flex               |       []                                  []     |
+     fslint             |                                                  |
+     gas                |                                                  |
+     gawk               | []                                        []     |
+     gcal               |                                                  |
+     gcc                |                                                  |
+     gettext-examples   | []                            []          []     |
+     gettext-runtime    | []    []                                  []     |
+     gettext-tools      | []    []                                         |
+     gip                |                               []          []     |
+     gliv               |                                           []     |
+     glunarclock        |                               []          []     |
+     gmult              | []                            []          []     |
+     gnubiff            |                                                  |
+     gnucash            | ()                                  () ()        |
+     gnuedu             |                                                  |
+     gnulib             | []                                        []     |
+     gnunet             |                                                  |
+     gnunet-gtk         |                                                  |
+     gnutls             |                               []                 |
+     gpe-aerial         |                                           []     |
+     gpe-beam           |                                           []     |
+     gpe-calendar       | []                                               |
+     gpe-clock          | []    []                                  []     |
+     gpe-conf           | []    []                                  []     |
+     gpe-contacts       |       []                                         |
+     gpe-edit           | []    []                                  []     |
+     gpe-filemanager    | []    []                                         |
+     gpe-go             | []    []                                  []     |
+     gpe-login          | []    []                                  []     |
+     gpe-ownerinfo      | []                                        []     |
+     gpe-package        | []    []                                         |
+     gpe-sketchbook     |       []                                  []     |
+     gpe-su             | []    []                                  []     |
+     gpe-taskmanager    | []    [] []                               []     |
+     gpe-timesheet      |                                           []     |
+     gpe-today          | []                                        []     |
+     gpe-todo           | []                                               |
+     gphoto2            | []                                        []     |
+     gprof              |                               []                 |
+     gpsdrive           |                                           []     |
+     gramadoir          |                                           ()     |
+     grep               |             []                            []     |
+     gretl              |                                                  |
+     gsasl              |                                           []     |
+     gss                |                                                  |
+     gst-plugins-bad    |                                           []     |
+     gst-plugins-base   |                                           []     |
+     gst-plugins-good   |                                           []     |
+     gst-plugins-ugly   |                                           []     |
+     gstreamer          |                                           []     |
+     gtick              |                                           []     |
+     gtkam              | []                                        []     |
+     gtkorphan          |                                           []     |
+     gtkspell           |                            []             []     |
+     gutenprint         |                                           []     |
+     hello              | [] [] []                      []    []    []  [] |
+     herrie             |                                           []     |
+     hylafax            |                                                  |
+     idutils            |                                           []     |
+     indent             | []                                        []     |
+     iso_15924          |                                           []     |
+     iso_3166           | []    [] []       []    []          []    []  [] |
+     iso_3166_2         |                                           []     |
+     iso_4217           | []                []                      []     |
+     iso_639            | []                []                      []  [] |
+     jpilot             | ()                                        ()     |
+     jtag               |                                                  |
+     jwhois             |                                           []     |
+     kbd                |                                           []     |
+     keytouch           |                                           []     |
+     keytouch-editor    |                                           []     |
+     keytouch-keyboa... |                                                  |
+     latrine            |                                           []     |
+     ld                 |                                                  |
+     leafpad            | []                []                             |
+     libc               | []    []                                  []     |
+     libexif            |                                                  |
+     libextractor       |                                                  |
+     libgpewidget       |                                           []     |
+     libgpg-error       |                                                  |
+     libgphoto2         | []                                               |
+     libgphoto2_port    | []                                               |
+     libgsasl           |                                           []     |
+     libiconv           |                                           []     |
+     libidn             | []                                        []     |
+     lifelines          |                                           []     |
+     lilypond           |                                           []     |
+     lingoteach         |                                           []     |
+     lprng              |                                                  |
+     lynx               | []                                        []     |
+     m4                 | []                                        []     |
+     mailfromd          |                                                  |
+     mailutils          |                                                  |
+     make               | []    []                                  []     |
+     man-db             |                                                  |
+     minicom            | []                                               |
+     nano               |                               []    []    []     |
+     opcodes            |                                           []     |
+     parted             | []                                        []     |
+     pilot-qof          |                                                  |
+     popt               | []    []                                  []     |
+     psmisc             | []                                  []    []     |
+     pwdutils           |                                                  |
+     qof                |                                                  |
+     radius             |                                                  |
+     recode             |                                           []     |
+     rpm                | []    []                                         |
+     screem             | []                                               |
+     scrollkeeper       |                                     [] [] []  [] |
+     sed                | []                                        []     |
+     shared-mime-info   | []    []          []          []    []    []  [] |
+     sharutils          | []                                        []     |
+     shishi             |                                                  |
+     skencil            |                                                  |
+     solfege            |                                     ()        () |
+     soundtracker       |                                                  |
+     sp                 | ()                                               |
+     system-tools-ba... | []    []          []                      []     |
+     tar                | []          []                            []     |
+     texinfo            |                                     []    []     |
+     tin                |                                                  |
+     tuxpaint           |                                     ()    []  [] |
+     unicode-han-tra... |                                                  |
+     unicode-transla... |                                                  |
+     util-linux         | []                                        []     |
+     util-linux-ng      | []                                        []     |
+     vorbis-tools       |                                                  |
+     wastesedge         |                                           []     |
+     wdiff              |                               []    []           |
+     wget               | []                                        []     |
+     xchat              | []    []                []                []     |
+     xkeyboard-config   |    [] []                                  []     |
+     xpad               |       []                      []          []     |
+                        +--------------------------------------------------+
+                          ja ka ko ku ky lg lt lv mk mn ms mt nb ne nl  nn
+                          51  2 25  3  2  0  6  0  2  2 20  0 11  1 103  6
+
+                          or pa pl pt pt_BR rm ro ru rw sk sl sq sr sv  ta
+                        +--------------------------------------------------+
+     Compendium         |          []  []      []       []          []     |
+     a2ps               |       ()     []      [] []       []    [] []     |
+     aegis              |                      () ()                       |
+     ant-phone          |                      []                   []     |
+     anubis             |       []             [] []                       |
+     ap-utils           |       ()                                         |
+     aspell             |                      [] []    []                 |
+     bash               |       []                      []                 |
+     bfd                |                                                  |
+     bibshelf           |                                           []     |
+     binutils           |                         []    []                 |
+     bison              |       []     []      [] []                []     |
+     bison-runtime      |       []     []      []          []       []     |
+     bluez-pin          |       []     []   [] [] []    [] []    [] []     |
+     cflow              |       []                                         |
+     clisp              |                         []                       |
+     console-tools      |                         []                       |
+     coreutils          |       []                []       []       []     |
+     cpio               |       []                []                []     |
+     cpplib             |                                           []     |
+     cryptonit          |              []                           []     |
+     dialog             |                                           []     |
+     diffutils          |       []     []      [] []             [] []     |
+     doodle             |                                     []    []     |
+     e2fsprogs          |       []                                  []     |
+     enscript           |              []      [] []       []       []     |
+     fetchmail          |       []                []          []           |
+     findutils          |       [] []                               []     |
+     findutils_stable   |       [] []          []       [] []       []     |
+     flex               |       []     []      [] []                []     |
+     fslint             |                                           []     |
+     gas                |                                                  |
+     gawk               |       []     []      []                   []     |
+     gcal               |                                           []     |
+     gcc                |                                        [] []     |
+     gettext-examples   |       [] []          [] []    [] []    [] []     |
+     gettext-runtime    |       [] []          [] []    [] []    [] []     |
+     gettext-tools      |       []             [] []    [] []    [] []     |
+     gip                |                   []          []       [] []     |
+     gliv               |       []     []      [] []    []          []     |
+     glunarclock        |              []      [] []    []       [] []     |
+     gmult              |                   [] []                [] []     |
+     gnubiff            |                      ()                   []     |
+     gnucash            |       ()                                  []     |
+     gnuedu             |                                                  |
+     gnulib             |       []                         []       []     |
+     gnunet             |                                                  |
+     gnunet-gtk         |                                           []     |
+     gnutls             |       []                                  []     |
+     gpe-aerial         |          []  []      [] []       []    [] []     |
+     gpe-beam           |          []  []      [] []       []    [] []     |
+     gpe-calendar       |                         []       []    [] []     |
+     gpe-clock          |          []  []      [] []    [] []    [] []     |
+     gpe-conf           |          []  []      [] []    [] []       []     |
+     gpe-contacts       |                      [] []       []    [] []     |
+     gpe-edit           |       [] []  []      [] []    [] []    [] []     |
+     gpe-filemanager    |                                  []       []     |
+     gpe-go             |       []     []      [] []    [] []    [] []     |
+     gpe-login          |          []  []      [] []    [] []    [] []     |
+     gpe-ownerinfo      |          []  []      [] []    [] []    [] []     |
+     gpe-package        |                                  []       []     |
+     gpe-sketchbook     |          []  []      [] []    [] []    [] []     |
+     gpe-su             |          []  []      [] []    [] []    [] []     |
+     gpe-taskmanager    |          []  []      [] []    [] []    [] []     |
+     gpe-timesheet      |          []  []      [] []    [] []    [] []     |
+     gpe-today          |          []  []      [] []    [] []    [] []     |
+     gpe-todo           |                         []       []    [] []     |
+     gphoto2            |    [] []             []       []       [] []     |
+     gprof              |              []      []                   []     |
+     gpsdrive           |                         []                []     |
+     gramadoir          |                               []          []     |
+     grep               |       []                      [] []       []     |
+     gretl              |       [] []  []                                  |
+     gsasl              |       []                               [] []     |
+     gss                |       []             []       []          []     |
+     gst-plugins-bad    |       []     []                           []     |
+     gst-plugins-base   |       []                                  []     |
+     gst-plugins-good   |       []                                  []     |
+     gst-plugins-ugly   |       []     []                           []     |
+     gstreamer          |       []                            [] [] []     |
+     gtick              |                         []                       |
+     gtkam              |    [] []     []         []                []     |
+     gtkorphan          |                                           []     |
+     gtkspell           |              []   [] [] []    [] []    [] []     |
+     gutenprint         |                                           []     |
+     hello              |       []     []      [] []    [] []    [] []     |
+     herrie             |       []                []                []     |
+     hylafax            |                                                  |
+     idutils            |       []     []      [] []                []     |
+     indent             |       []     []      [] []    []       [] []     |
+     iso_15924          |                                                  |
+     iso_3166           |    [] [] []  []      [] [] [] [] [] [] [] []  [] |
+     iso_3166_2         |                                                  |
+     iso_4217           |       [] []             [] []    []    [] []     |
+     iso_639            |       []                [] [] [] []    [] []     |
+     jpilot             |                                                  |
+     jtag               |                               []                 |
+     jwhois             |       []     []      []                   []     |
+     kbd                |       []             []                   []     |
+     keytouch           |                                           []     |
+     keytouch-editor    |                                           []     |
+     keytouch-keyboa... |                                           []     |
+     latrine            |                                                  |
+     ld                 |                                           []     |
+     leafpad            |       [] []             []    []          []  [] |
+     libc               |       []                []    []          []     |
+     libexif            |       []                      []                 |
+     libextractor       |                      []                   []     |
+     libgpewidget       |       [] []  []      []       [] []    [] []     |
+     libgpg-error       |       []             []                   []     |
+     libgphoto2         |       []                                         |
+     libgphoto2_port    |       []                []                []     |
+     libgsasl           |       []             []                [] []     |
+     libiconv           |                                  []    [] []     |
+     libidn             |       []                               [] ()     |
+     lifelines          |       []                                  []     |
+     lilypond           |                                                  |
+     lingoteach         |              []                                  |
+     lprng              |       []                                         |
+     lynx               |              []         []                []     |
+     m4                 |       []     []      [] []                []     |
+     mailfromd          |       []                                         |
+     mailutils          |       []                []                []     |
+     make               |       []     []         []                []     |
+     man-db             |       []             [] []                []     |
+     minicom            |       []     []      [] []                []     |
+     nano               |              []      [] []                []     |
+     opcodes            |                      []                   []     |
+     parted             |       []                                         |
+     pilot-qof          |                                                  |
+     popt               |       [] []             []                []     |
+     psmisc             |       []                                  []     |
+     pwdutils           |       []                                  []     |
+     qof                |              []                           []     |
+     radius             |       []                []                       |
+     recode             |       [] []  []      [] []       []       []     |
+     rpm                |       [] []             []                []     |
+     screem             |                                                  |
+     scrollkeeper       |       []             [] []    []    [] [] []     |
+     sed                |       [] []  []      [] []    [] []    [] []     |
+     shared-mime-info   |       [] []  []                     [] [] []     |
+     sharutils          |       []                []             [] []     |
+     shishi             |       []                                         |
+     skencil            |          []  []                           []     |
+     solfege            |              []                                  |
+     soundtracker       |                               []          []     |
+     sp                 |                                                  |
+     system-tools-ba... |    [] [] []  []      []             [] [] []  [] |
+     tar                |       []                []       []       []     |
+     texinfo            |       []             [] []                []     |
+     tin                |                         ()                       |
+     tuxpaint           |       [] []                      [] [] [] []     |
+     unicode-han-tra... |                                                  |
+     unicode-transla... |                                                  |
+     util-linux         |              []         []       []       []     |
+     util-linux-ng      |              []         []       []       []     |
+     vorbis-tools       |                         []                       |
+     wastesedge         |                                                  |
+     wdiff              |       []     []      [] []    [] []       []     |
+     wget               |          []             []    []          []     |
+     xchat              |    []                   []    [] [] [] [] []     |
+     xkeyboard-config   |                               [] []       []     |
+     xpad               |                               [] []       []     |
+                        +--------------------------------------------------+
+                          or pa pl pt pt_BR rm ro ru rw sk sl sq sr sv  ta
+                           0  5 77 31  53    4 58 72  3 45 46  9 45 122  3
+
+                          tg th tk tr uk ven vi  wa xh zh_CN zh_HK zh_TW zu
+                        +---------------------------------------------------+
+     Compendium         |          []        []         []          []      | 19
+     a2ps               |          [] []     []                             | 19
+     aegis              |                    []                             |  1
+     ant-phone          |          []        []                             |  6
+     anubis             |          [] []     []                             | 11
+     ap-utils           |             ()     []                             |  4
+     aspell             |             []     []  []                         | 16
+     bash               |          []                                       |  6
+     bfd                |                                                   |  2
+     bibshelf           |                    []                             |  7
+     binutils           |          [] []     []                     []      |  9
+     bison              |          [] []     []                     []      | 20
+     bison-runtime      |             []     []         []          []      | 18
+     bluez-pin          |          [] []     []  []     []          []      | 28
+     cflow              |             []     []                             |  5
+     clisp              |                                                   |  9
+     console-tools      |          []        []                             |  5
+     coreutils          |          [] []     []                             | 18
+     cpio               |          [] []     []         []                  | 11
+     cpplib             |          [] []     []         []          []      | 12
+     cryptonit          |                    []                             |  6
+     dialog             |                    []  []     []                  |  9
+     diffutils          |          [] []     []         []          []      | 29
+     doodle             |                    []                             |  6
+     e2fsprogs          |          []        []                             | 10
+     enscript           |          [] []     []                             | 16
+     fetchmail          |          []        []                             | 12
+     findutils          |          [] []     []                             | 11
+     findutils_stable   |          [] []     []                     []      | 18
+     flex               |          []        []                             | 15
+     fslint             |                    []                             |  2
+     gas                |          []                                       |  3
+     gawk               |          []        []         []                  | 16
+     gcal               |          []                                       |  5
+     gcc                |          []                   []          []      |  7
+     gettext-examples   |          [] []     []         []    []    []      | 29
+     gettext-runtime    |          [] []     []         []    []    []      | 28
+     gettext-tools      |          [] []     []         []          []      | 20
+     gip                |                    []                     []      | 13
+     gliv               |          []        []                             | 11
+     glunarclock        |                    []  []                 []      | 15
+     gmult              |          []        []         []          []      | 16
+     gnubiff            |                    []                             |  2
+     gnucash            |          () []                                    |  5
+     gnuedu             |                    []                             |  2
+     gnulib             |                    []                             | 10
+     gnunet             |                                                   |  0
+     gnunet-gtk         |          []        []                             |  3
+     gnutls             |                                                   |  4
+     gpe-aerial         |                    []         []                  | 14
+     gpe-beam           |                    []         []                  | 14
+     gpe-calendar       |                    []  []                         |  7
+     gpe-clock          |          []        []  []     []                  | 21
+     gpe-conf           |                    []  []     []                  | 16
+     gpe-contacts       |                    []         []                  | 10
+     gpe-edit           |          []        []  []     []          []      | 22
+     gpe-filemanager    |                    []  []                         |  7
+     gpe-go             |          []        []  []     []                  | 19
+     gpe-login          |          []        []  []     []          []      | 21
+     gpe-ownerinfo      |          []        []         []          []      | 21
+     gpe-package        |                    []                             |  6
+     gpe-sketchbook     |          []        []                             | 16
+     gpe-su             |          []        []  []     []                  | 21
+     gpe-taskmanager    |          []        []  []     []                  | 21
+     gpe-timesheet      |          []        []         []          []      | 18
+     gpe-today          |          []        []  []     []          []      | 21
+     gpe-todo           |                    []  []                         |  8
+     gphoto2            |             []     []         []          []      | 21
+     gprof              |          []        []                             | 13
+     gpsdrive           |                    []                             |  5
+     gramadoir          |                    []                             |  7
+     grep               |                    []                             | 12
+     gretl              |                                                   |  6
+     gsasl              |                    []         []          []      |  9
+     gss                |                    []                             |  7
+     gst-plugins-bad    |             []     []         []                  | 13
+     gst-plugins-base   |             []     []                             | 11
+     gst-plugins-good   |             []     []         []    []    []      | 16
+     gst-plugins-ugly   |             []     []         []                  | 13
+     gstreamer          |          [] []     []                             | 18
+     gtick              |             []     []                             |  7
+     gtkam              |                    []                             | 16
+     gtkorphan          |                    []                             |  7
+     gtkspell           |             []     []  []     []    []    []      | 27
+     gutenprint         |                                                   |  4
+     hello              |          [] []     []         []          []      | 38
+     herrie             |          []        []                             |  8
+     hylafax            |                                                   |  0
+     idutils            |          []        []                             | 15
+     indent             |          [] []     []         []          []      | 28
+     iso_15924          |                    []         []                  |  4
+     iso_3166           |    [] [] [] []     []  []     []    []    []      | 54
+     iso_3166_2         |                    []         []                  |  4
+     iso_4217           |    []    []        []         []    []            | 24
+     iso_639            |             []     []  []     []    []            | 26
+     jpilot             |          [] []     []         []                  |  7
+     jtag               |                    []                             |  3
+     jwhois             |          []        []                     []      | 13
+     kbd                |          [] []     []                             | 13
+     keytouch           |                    []                             |  8
+     keytouch-editor    |                    []                             |  5
+     keytouch-keyboa... |                    []                             |  5
+     latrine            |          []        []                             |  5
+     ld                 |          []        []         []          []      | 10
+     leafpad            |          [] []     []         []          []      | 24
+     libc               |          []                   []          []      | 19
+     libexif            |                    []                             |  5
+     libextractor       |                    []                             |  5
+     libgpewidget       |                    []  []     []                  | 20
+     libgpg-error       |                    []                             |  6
+     libgphoto2         |             []     []                             |  9
+     libgphoto2_port    |             []     []                     []      | 11
+     libgsasl           |                    []                             |  8
+     libiconv           |                    []  []                         | 11
+     libidn             |                    []         []                  | 11
+     lifelines          |                                                   |  4
+     lilypond           |                    []                             |  6
+     lingoteach         |                    []                             |  6
+     lprng              |                    []                             |  2
+     lynx               |          [] []     []                             | 15
+     m4                 |                    []         []          []      | 18
+     mailfromd          |             []     []                             |  3
+     mailutils          |             []     []                             |  8
+     make               |          []        []         []                  | 20
+     man-db             |                    []                             |  9
+     minicom            |                    []                             | 14
+     nano               |                    []         []          []      | 20
+     opcodes            |          []        []                             | 10
+     parted             |          [] []                            []      | 11
+     pilot-qof          |                    []                             |  1
+     popt               |          []        []         []          []      | 18
+     psmisc             |                    []         []                  | 10
+     pwdutils           |                    []                             |  3
+     qof                |                    []                             |  4
+     radius             |             []     []                             |  7
+     recode             |          []        []         []                  | 25
+     rpm                |          [] []     []                     []      | 13
+     screem             |                    []                             |  2
+     scrollkeeper       |          [] []     []                     []      | 26
+     sed                |          []        []         []          []      | 23
+     shared-mime-info   |             []     []         []                  | 29
+     sharutils          |          []        []                     []      | 23
+     shishi             |                    []                             |  3
+     skencil            |                    []                             |  7
+     solfege            |                    []                             |  3
+     soundtracker       |          []        []                             |  9
+     sp                 |          []                                       |  3
+     system-tools-ba... |    []    [] []     []     []  []          []      | 38
+     tar                |          [] []     []                             | 17
+     texinfo            |          []        []         []                  | 15
+     tin                |                                                   |  1
+     tuxpaint           |                    []  []                 []      | 19
+     unicode-han-tra... |                                                   |  0
+     unicode-transla... |                                                   |  2
+     util-linux         |          [] []     []                             | 20
+     util-linux-ng      |          [] []     []                             | 20
+     vorbis-tools       |             []     []                             |  4
+     wastesedge         |                                                   |  1
+     wdiff              |          []        []                             | 23
+     wget               |          []        []                     []      | 20
+     xchat              |             []     []         []          []      | 29
+     xkeyboard-config   |          [] []     []                             | 14
+     xpad               |                    []         []          []      | 15
+                        +---------------------------------------------------+
+       76 teams           tg th tk tr uk ven vi  wa xh zh_CN zh_HK zh_TW zu
+      163 domains          0  3  1 74 51  0  143 21  1  57     7    45    0  2036
+
+   Some counters in the preceding matrix are higher than the number of
+visible blocks let us expect.  This is because a few extra PO files are
+used for implementing regional variants of languages, or language
+dialects.
+
+   For a PO file in the matrix above to be effective, the package to
+which it applies should also have been internationalized and
+distributed as such by its maintainer.  There might be an observable
+lag between the mere existence a PO file and its wide availability in a
+distribution.
+
+   If November 2007 seems to be old, you may fetch a more recent copy
+of this `ABOUT-NLS' file on most GNU archive sites.  The most
+up-to-date matrix with full percentage details can be found at
+`http://translationproject.org/extra/matrix.html'.
+
+1.6 Using `gettext' in new packages
+===================================
+
+If you are writing a freely available program and want to
+internationalize it you are welcome to use GNU `gettext' in your
+package.  Of course you have to respect the GNU Library General Public
+License which covers the use of the GNU `gettext' library.  This means
+in particular that even non-free programs can use `libintl' as a shared
+library, whereas only free software can use `libintl' as a static
+library or use modified versions of `libintl'.
+
+   Once the sources are changed appropriately and the setup can handle
+the use of `gettext' the only thing missing are the translations.  The
+Free Translation Project is also available for packages which are not
+developed inside the GNU project.  Therefore the information given above
+applies also for every other Free Software Project.  Contact
+`coordinator@translationproject.org' to make the `.pot' files available
+to the translation teams.
+
diff --git a/pathologist/AUTHORS b/pathologist/AUTHORS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pathologist/AUTHORS
diff --git a/pathologist/COPYING b/pathologist/COPYING
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/pathologist/COPYING
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  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
+them 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 prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  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.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey 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;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If 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 convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  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.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+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.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     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
+state 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) <year>  <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 3 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, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program 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, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU 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 Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/pathologist/ChangeLog b/pathologist/ChangeLog
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pathologist/ChangeLog
diff --git a/pathologist/INSTALL b/pathologist/INSTALL
new file mode 100644
index 0000000..7d1c323
--- /dev/null
+++ b/pathologist/INSTALL
@@ -0,0 +1,365 @@
+Installation Instructions
+*************************
+
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
+2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+
+   Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without warranty of any kind.
+
+Basic Installation
+==================
+
+   Briefly, the shell commands `./configure; make; make install' should
+configure, build, and install this package.  The following
+more-detailed instructions are generic; see the `README' file for
+instructions specific to this package.  Some packages provide this
+`INSTALL' file but do not implement all of the features documented
+below.  The lack of an optional feature in a given package is not
+necessarily a bug.  More recommendations for GNU packages can be found
+in *note Makefile Conventions: (standards)Makefile Conventions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You need `configure.ac' if
+you want to change it or regenerate `configure' using a newer version
+of `autoconf'.
+
+   The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.
+
+     Running `configure' might take a while.  While running, it prints
+     some messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package, generally using the just-built uninstalled binaries.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.  When installing into a prefix owned by root, it is
+     recommended that the package be configured and built as a regular
+     user, and only the `make install' phase executed with root
+     privileges.
+
+  5. Optionally, type `make installcheck' to repeat any self-tests, but
+     this time using the binaries in their final installed location.
+     This target does not install anything.  Running this target as a
+     regular user, particularly if the prior `make install' required
+     root privileges, verifies that the installation completed
+     correctly.
+
+  6. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+  7. Often, you can also type `make uninstall' to remove the installed
+     files again.  In practice, not all packages have tested that
+     uninstallation works correctly, even though it is required by the
+     GNU Coding Standards.
+
+  8. Some packages, particularly those that use Automake, provide `make
+     distcheck', which can by used by developers to test that all other
+     targets like `make install' and `make uninstall' work correctly.
+     This target is generally not run by end users.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  Run `./configure --help'
+for details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you can use GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.  This
+is known as a "VPATH" build.
+
+   With a non-GNU `make', it is safer to compile the package for one
+architecture at a time in the source code directory.  After you have
+installed the package for one architecture, use `make distclean' before
+reconfiguring for another architecture.
+
+   On MacOS X 10.5 and later systems, you can create libraries and
+executables that work on multiple system types--known as "fat" or
+"universal" binaries--by specifying multiple `-arch' options to the
+compiler but only a single `-arch' option to the preprocessor.  Like
+this:
+
+     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CPP="gcc -E" CXXCPP="g++ -E"
+
+   This is not guaranteed to produce working output in all cases, you
+may have to build one architecture at a time and combine the results
+using the `lipo' tool if you have problems.
+
+Installation Names
+==================
+
+   By default, `make install' installs the package's commands under
+`/usr/local/bin', include files under `/usr/local/include', etc.  You
+can specify an installation prefix other than `/usr/local' by giving
+`configure' the option `--prefix=PREFIX', where PREFIX must be an
+absolute file name.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+pass the option `--exec-prefix=PREFIX' to `configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.  In general, the
+default for these options is expressed in terms of `${prefix}', so that
+specifying just `--prefix' will affect all of the other directory
+specifications that were not explicitly provided.
+
+   The most portable way to affect installation locations is to pass the
+correct locations to `configure'; however, many packages provide one or
+both of the following shortcuts of passing variable assignments to the
+`make install' command line to change installation locations without
+having to reconfigure or recompile.
+
+   The first method involves providing an override variable for each
+affected directory.  For example, `make install
+prefix=/alternate/directory' will choose an alternate location for all
+directory configuration variables that were expressed in terms of
+`${prefix}'.  Any directories that were specified during `configure',
+but not in terms of `${prefix}', must each be overridden at install
+time for the entire installation to be relocated.  The approach of
+makefile variable overrides for each directory variable is required by
+the GNU Coding Standards, and ideally causes no recompilation.
+However, some platforms have known limitations with the semantics of
+shared libraries that end up requiring recompilation when using this
+method, particularly noticeable in packages that use GNU Libtool.
+
+   The second method involves providing the `DESTDIR' variable.  For
+example, `make install DESTDIR=/alternate/directory' will prepend
+`/alternate/directory' before all installation names.  The approach of
+`DESTDIR' overrides is not required by the GNU Coding Standards, and
+does not work on platforms that have drive letters.  On the other hand,
+it does better at avoiding recompilation issues, and works well even
+when some directory options were not specified in terms of `${prefix}'
+at `configure' time.
+
+Optional Features
+=================
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+   Some packages offer the ability to configure how verbose the
+execution of `make' will be.  For these packages, running `./configure
+--enable-silent-rules' sets the default to minimal output, which can be
+overridden with `make V=1'; while running `./configure
+--disable-silent-rules' sets the default to verbose, which can be
+overridden with `make V=0'.
+
+Particular systems
+==================
+
+   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
+CC is not installed, it is recommended to use the following options in
+order to use an ANSI C compiler:
+
+     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
+
+and if that doesn't work, install pre-built binaries of GCC for HP-UX.
+
+   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
+parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
+a workaround.  If GNU CC is not installed, it is therefore recommended
+to try
+
+     ./configure CC="cc"
+
+and if that doesn't work, try
+
+     ./configure CC="cc -nodtk"
+
+   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
+directory contains several dysfunctional programs; working variants of
+these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
+in your `PATH', put it _after_ `/usr/bin'.
+
+   On Haiku, software installed for all users goes in `/boot/common',
+not `/usr/local'.  It is recommended to use the following options:
+
+     ./configure --prefix=/boot/common
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' cannot figure out
+automatically, but needs to determine by the type of machine the package
+will run on.  Usually, assuming the package is built to be run on the
+_same_ architectures, `configure' can figure that out, but if it prints
+a message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS
+     KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the option `--target=TYPE' to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+   Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+Unfortunately, this technique does not work for `CONFIG_SHELL' due to
+an Autoconf bug.  Until the bug is fixed you can use this workaround:
+
+     CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+`configure' Invocation
+======================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--help'
+`-h'
+     Print a summary of all of the options to `configure', and exit.
+
+`--help=short'
+`--help=recursive'
+     Print a summary of the options unique to this package's
+     `configure', and exit.  The `short' variant lists options used
+     only in the top level, while the `recursive' variant lists options
+     also present in any nested packages.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`--prefix=DIR'
+     Use DIR as the installation prefix.  *note Installation Names::
+     for more details, including other options available for fine-tuning
+     the installation locations.
+
+`--no-create'
+`-n'
+     Run the configure checks, but stop before creating any output
+     files.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
+
diff --git a/pathologist/Makefile.am b/pathologist/Makefile.am
new file mode 100644
index 0000000..acbfe9c
--- /dev/null
+++ b/pathologist/Makefile.am
@@ -0,0 +1,11 @@
+## Process this file with automake to produce Makefile.in
+
+SUBDIRS = refs/src src
+
+EXTRA_DIST = \
+ ABOUT-NLS \
+ config.rpath \
+ install-sh \
+ acinclude.m4
+
+ACLOCAL_AMFLAGS = -I m4
diff --git a/pathologist/NEWS b/pathologist/NEWS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pathologist/NEWS
diff --git a/pathologist/README b/pathologist/README
new file mode 100644
index 0000000..a166810
--- /dev/null
+++ b/pathologist/README
@@ -0,0 +1 @@
+This is a template for GNUnet extensions.
diff --git a/pathologist/bootstrap b/pathologist/bootstrap
new file mode 100755
index 0000000..c5d2098
--- /dev/null
+++ b/pathologist/bootstrap
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+libtoolize --automake --copy --force
+aclocal -I m4
+autoheader
+autoconf
+automake --add-missing --copy
+
diff --git a/pathologist/config.rpath b/pathologist/config.rpath
new file mode 100755
index 0000000..c547c68
--- /dev/null
+++ b/pathologist/config.rpath
@@ -0,0 +1,666 @@
+#! /bin/sh
+# Output a system dependent set of variables, describing how to set the
+# run time search path of shared libraries in an executable.
+#
+#   Copyright 1996-2007 Free Software Foundation, Inc.
+#   Taken from GNU libtool, 2001
+#   Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+#   This file is free software; the Free Software Foundation gives
+#   unlimited permission to copy and/or distribute it, with or without
+#   modifications, as long as this notice is preserved.
+#
+# The first argument passed to this file is the canonical host specification,
+#    CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or
+#    CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld
+# should be set by the caller.
+#
+# The set of defined variables is at the end of this script.
+
+# Known limitations:
+# - On IRIX 6.5 with CC="cc", the run time search patch must not be longer
+#   than 256 bytes, otherwise the compiler driver will dump core. The only
+#   known workaround is to choose shorter directory names for the build
+#   directory and/or the installation directory.
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+shrext=.so
+
+host="$1"
+host_cpu=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+# Code taken from libtool.m4's _LT_CC_BASENAME.
+
+for cc_temp in $CC""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`echo "$cc_temp" | sed -e 's%^.*/%%'`
+
+# Code taken from libtool.m4's AC_LIBTOOL_PROG_COMPILER_PIC.
+
+wl=
+if test "$GCC" = yes; then
+  wl='-Wl,'
+else
+  case "$host_os" in
+    aix*)
+      wl='-Wl,'
+      ;;
+    darwin*)
+      case $cc_basename in
+        xlc*)
+          wl='-Wl,'
+          ;;
+      esac
+      ;;
+    mingw* | cygwin* | pw32* | os2*)
+      ;;
+    hpux9* | hpux10* | hpux11*)
+      wl='-Wl,'
+      ;;
+    irix5* | irix6* | nonstopux*)
+      wl='-Wl,'
+      ;;
+    newsos6)
+      ;;
+    linux* | k*bsd*-gnu)
+      case $cc_basename in
+        icc* | ecc*)
+          wl='-Wl,'
+          ;;
+        pgcc | pgf77 | pgf90)
+          wl='-Wl,'
+          ;;
+        ccc*)
+          wl='-Wl,'
+          ;;
+        como)
+          wl='-lopt='
+          ;;
+        *)
+          case `$CC -V 2>&1 | sed 5q` in
+            *Sun\ C*)
+              wl='-Wl,'
+              ;;
+          esac
+          ;;
+      esac
+      ;;
+    osf3* | osf4* | osf5*)
+      wl='-Wl,'
+      ;;
+    rdos*)
+      ;;
+    solaris*)
+      wl='-Wl,'
+      ;;
+    sunos4*)
+      wl='-Qoption ld '
+      ;;
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      wl='-Wl,'
+      ;;
+    sysv4*MP*)
+      ;;
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      wl='-Wl,'
+      ;;
+    unicos*)
+      wl='-Wl,'
+      ;;
+    uts4*)
+      ;;
+  esac
+fi
+
+# Code taken from libtool.m4's AC_LIBTOOL_PROG_LD_SHLIBS.
+
+hardcode_libdir_flag_spec=
+hardcode_libdir_separator=
+hardcode_direct=no
+hardcode_minus_L=no
+
+case "$host_os" in
+  cygwin* | mingw* | pw32*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+esac
+
+ld_shlibs=yes
+if test "$with_gnu_ld" = yes; then
+  # Set some defaults for GNU ld with shared library support. These
+  # are reset later if shared libraries are not supported. Putting them
+  # here allows them to be overridden if necessary.
+  # Unlike libtool, we use -rpath here, not --rpath, since the documented
+  # option of GNU ld is called -rpath, not --rpath.
+  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+  case "$host_os" in
+    aix3* | aix4* | aix5*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+        ld_shlibs=no
+      fi
+      ;;
+    amigaos*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+      # that the semantics of dynamic libraries on AmigaOS, at least up
+      # to version 4, is to share data among multiple programs linked
+      # with the same dynamic library.  Since this doesn't match the
+      # behavior of shared libraries on other platforms, we cannot use
+      # them.
+      ld_shlibs=no
+      ;;
+    beos*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    cygwin* | mingw* | pw32*)
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    interix[3-9]*)
+      hardcode_direct=no
+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+      ;;
+    gnu* | linux* | k*bsd*-gnu)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    netbsd*)
+      ;;
+    solaris*)
+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
+        ld_shlibs=no
+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+          ld_shlibs=no
+          ;;
+        *)
+          if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+            hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
+          else
+            ld_shlibs=no
+          fi
+          ;;
+      esac
+      ;;
+    sunos4*)
+      hardcode_direct=yes
+      ;;
+    *)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+  esac
+  if test "$ld_shlibs" = no; then
+    hardcode_libdir_flag_spec=
+  fi
+else
+  case "$host_os" in
+    aix3*)
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test "$GCC" = yes; then
+        # Neither direct hardcoding nor static linking is supported with a
+        # broken collect2.
+        hardcode_direct=unsupported
+      fi
+      ;;
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+        # On IA64, the linker does run time linking by default, so we don't
+        # have to do anything special.
+        aix_use_runtimelinking=no
+      else
+        aix_use_runtimelinking=no
+        # Test if we are trying to use run time linking or normal
+        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+        # need to do runtime linking.
+        case $host_os in aix4.[23]|aix4.[23].*|aix5*)
+          for ld_flag in $LDFLAGS; do
+            if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+              aix_use_runtimelinking=yes
+              break
+            fi
+          done
+          ;;
+        esac
+      fi
+      hardcode_direct=yes
+      hardcode_libdir_separator=':'
+      if test "$GCC" = yes; then
+        case $host_os in aix4.[012]|aix4.[012].*)
+          collect2name=`${CC} -print-prog-name=collect2`
+          if test -f "$collect2name" && \
+            strings "$collect2name" | grep resolve_lib_name >/dev/null
+          then
+            # We have reworked collect2
+            :
+          else
+            # We have old collect2
+            hardcode_direct=unsupported
+            hardcode_minus_L=yes
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_libdir_separator=
+          fi
+          ;;
+        esac
+      fi
+      # Begin _LT_AC_SYS_LIBPATH_AIX.
+      echo 'int main () { return 0; }' > conftest.c
+      ${CC} ${LDFLAGS} conftest.c -o conftest
+      aix_libpath=`dump -H conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+      if test -z "$aix_libpath"; then
+        aix_libpath=`dump -HX64 conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+      fi
+      if test -z "$aix_libpath"; then
+        aix_libpath="/usr/lib:/lib"
+      fi
+      rm -f conftest.c conftest
+      # End _LT_AC_SYS_LIBPATH_AIX.
+      if test "$aix_use_runtimelinking" = yes; then
+        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+      else
+        if test "$host_cpu" = ia64; then
+          hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+        else
+          hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+        fi
+      fi
+      ;;
+    amigaos*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      # see comment about different semantics on the GNU ld section
+      ld_shlibs=no
+      ;;
+    bsdi[45]*)
+      ;;
+    cygwin* | mingw* | pw32*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec=' '
+      libext=lib
+      ;;
+    darwin* | rhapsody*)
+      hardcode_direct=no
+      if test "$GCC" = yes ; then
+        :
+      else
+        case $cc_basename in
+          xlc*)
+            ;;
+          *)
+            ld_shlibs=no
+            ;;
+        esac
+      fi
+      ;;
+    dgux*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      ;;
+    freebsd1*)
+      ld_shlibs=no
+      ;;
+    freebsd2.2*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      ;;
+    freebsd2*)
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      ;;
+    freebsd* | dragonfly*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      ;;
+    hpux9*)
+      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      ;;
+    hpux10*)
+      if test "$with_gnu_ld" = no; then
+        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+        hardcode_libdir_separator=:
+        hardcode_direct=yes
+        # hardcode_minus_L: Not really in the search PATH,
+        # but as the default location of the library.
+        hardcode_minus_L=yes
+      fi
+      ;;
+    hpux11*)
+      if test "$with_gnu_ld" = no; then
+        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+        hardcode_libdir_separator=:
+        case $host_cpu in
+          hppa*64*|ia64*)
+            hardcode_direct=no
+            ;;
+          *)
+            hardcode_direct=yes
+            # hardcode_minus_L: Not really in the search PATH,
+            # but as the default location of the library.
+            hardcode_minus_L=yes
+            ;;
+        esac
+      fi
+      ;;
+    irix5* | irix6* | nonstopux*)
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+    netbsd*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      ;;
+    newsos6)
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+    openbsd*)
+      if test -f /usr/libexec/ld.so; then
+        hardcode_direct=yes
+        if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+          hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+        else
+          case "$host_os" in
+            openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+              hardcode_libdir_flag_spec='-R$libdir'
+              ;;
+            *)
+              hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+              ;;
+          esac
+        fi
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      ;;
+    osf3*)
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+    osf4* | osf5*)
+      if test "$GCC" = yes; then
+        hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      else
+        # Both cc and cxx compiler support -rpath directly
+        hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      hardcode_libdir_separator=:
+      ;;
+    solaris*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      ;;
+    sunos4*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      ;;
+    sysv4)
+      case $host_vendor in
+        sni)
+          hardcode_direct=yes # is this really true???
+          ;;
+        siemens)
+          hardcode_direct=no
+          ;;
+        motorola)
+          hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+          ;;
+      esac
+      ;;
+    sysv4.3*)
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+        ld_shlibs=yes
+      fi
+      ;;
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+      ;;
+    sysv5* | sco3.2v5* | sco5v6*)
+      hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+      hardcode_libdir_separator=':'
+      ;;
+    uts4*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      ;;
+    *)
+      ld_shlibs=no
+      ;;
+  esac
+fi
+
+# Check dynamic linker characteristics
+# Code taken from libtool.m4's AC_LIBTOOL_SYS_DYNAMIC_LINKER.
+# Unlike libtool.m4, here we don't care about _all_ names of the library, but
+# only about the one the linker finds when passed -lNAME. This is the last
+# element of library_names_spec in libtool.m4, or possibly two of them if the
+# linker has special search rules.
+library_names_spec=      # the last element of library_names_spec in libtool.m4
+libname_spec='lib$name'
+case "$host_os" in
+  aix3*)
+    library_names_spec='$libname.a'
+    ;;
+  aix4* | aix5*)
+    library_names_spec='$libname$shrext'
+    ;;
+  amigaos*)
+    library_names_spec='$libname.a'
+    ;;
+  beos*)
+    library_names_spec='$libname$shrext'
+    ;;
+  bsdi[45]*)
+    library_names_spec='$libname$shrext'
+    ;;
+  cygwin* | mingw* | pw32*)
+    shrext=.dll
+    library_names_spec='$libname.dll.a $libname.lib'
+    ;;
+  darwin* | rhapsody*)
+    shrext=.dylib
+    library_names_spec='$libname$shrext'
+    ;;
+  dgux*)
+    library_names_spec='$libname$shrext'
+    ;;
+  freebsd1*)
+    ;;
+  freebsd* | dragonfly*)
+    case "$host_os" in
+      freebsd[123]*)
+        library_names_spec='$libname$shrext$versuffix' ;;
+      *)
+        library_names_spec='$libname$shrext' ;;
+    esac
+    ;;
+  gnu*)
+    library_names_spec='$libname$shrext'
+    ;;
+  hpux9* | hpux10* | hpux11*)
+    case $host_cpu in
+      ia64*)
+        shrext=.so
+        ;;
+      hppa*64*)
+        shrext=.sl
+        ;;
+      *)
+        shrext=.sl
+        ;;
+    esac
+    library_names_spec='$libname$shrext'
+    ;;
+  interix[3-9]*)
+    library_names_spec='$libname$shrext'
+    ;;
+  irix5* | irix6* | nonstopux*)
+    library_names_spec='$libname$shrext'
+    case "$host_os" in
+      irix5* | nonstopux*)
+        libsuff= shlibsuff=
+        ;;
+      *)
+        case $LD in
+          *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= ;;
+          *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 ;;
+          *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 ;;
+          *) libsuff= shlibsuff= ;;
+        esac
+        ;;
+    esac
+    ;;
+  linux*oldld* | linux*aout* | linux*coff*)
+    ;;
+  linux* | k*bsd*-gnu)
+    library_names_spec='$libname$shrext'
+    ;;
+  knetbsd*-gnu)
+    library_names_spec='$libname$shrext'
+    ;;
+  netbsd*)
+    library_names_spec='$libname$shrext'
+    ;;
+  newsos6)
+    library_names_spec='$libname$shrext'
+    ;;
+  nto-qnx*)
+    library_names_spec='$libname$shrext'
+    ;;
+  openbsd*)
+    library_names_spec='$libname$shrext$versuffix'
+    ;;
+  os2*)
+    libname_spec='$name'
+    shrext=.dll
+    library_names_spec='$libname.a'
+    ;;
+  osf3* | osf4* | osf5*)
+    library_names_spec='$libname$shrext'
+    ;;
+  rdos*)
+    ;;
+  solaris*)
+    library_names_spec='$libname$shrext'
+    ;;
+  sunos4*)
+    library_names_spec='$libname$shrext$versuffix'
+    ;;
+  sysv4 | sysv4.3*)
+    library_names_spec='$libname$shrext'
+    ;;
+  sysv4*MP*)
+    library_names_spec='$libname$shrext'
+    ;;
+  sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+    library_names_spec='$libname$shrext'
+    ;;
+  uts4*)
+    library_names_spec='$libname$shrext'
+    ;;
+esac
+
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+escaped_wl=`echo "X$wl" | sed -e 's/^X//' -e "$sed_quote_subst"`
+shlibext=`echo "$shrext" | sed -e 's,^\.,,'`
+escaped_libname_spec=`echo "X$libname_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
+escaped_library_names_spec=`echo "X$library_names_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
+escaped_hardcode_libdir_flag_spec=`echo "X$hardcode_libdir_flag_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
+
+LC_ALL=C sed -e 's/^\([a-zA-Z0-9_]*\)=/acl_cv_\1=/' <<EOF
+
+# How to pass a linker flag through the compiler.
+wl="$escaped_wl"
+
+# Static library suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally "so").
+shlibext="$shlibext"
+
+# Format of library name prefix.
+libname_spec="$escaped_libname_spec"
+
+# Library names that the linker finds when passed -lNAME.
+library_names_spec="$escaped_library_names_spec"
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec="$escaped_hardcode_libdir_flag_spec"
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator="$hardcode_libdir_separator"
+
+# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct="$hardcode_direct"
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L="$hardcode_minus_L"
+
+EOF
diff --git a/pathologist/configure.ac b/pathologist/configure.ac
new file mode 100644
index 0000000..0f63f2e
--- /dev/null
+++ b/pathologist/configure.ac
@@ -0,0 +1,221 @@
+# This file is part of GNUnet.
+# (C) 2001-2012 Christian Grothoff (and other contributing authors)
+#
+# GNUnet 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.
+#
+# GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+#
+#
+# Process this file with autoconf to produce a configure script.
+#
+AC_PREREQ(2.61)
+AC_INIT([monkey],[0.0.0],[bug-gnunet@gnu.org])
+AM_INIT_AUTOMAKE([monkey], [0.0.0])
+AM_CONFIG_HEADER(monkey_config.h)
+
+AH_TOP([#define _GNU_SOURCE  1])
+
+AC_ISC_POSIX
+AC_PROG_AWK
+AC_PROG_CC
+
+AC_PROG_MKDIR_P
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+AC_LIBTOOL_WIN32_DLL
+AC_PROG_CC
+AM_PROG_CC_STDC
+AC_HEADER_STDC
+AC_CANONICAL_HOST
+
+# dynamic libraries/plugins
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+
+AC_SYS_LARGEFILE
+AC_FUNC_FSEEKO
+
+CFLAGS="-Wall $CFLAGS"
+# use '-fno-strict-aliasing', but only if the compiler can take it
+if gcc -fno-strict-aliasing -S -o /dev/null -xc /dev/null >/dev/null 2>&1;
+then
+ CFLAGS="-fno-strict-aliasing $CFLAGS"
+fi
+
+
+# Check system type
+case "$host_os" in
+*darwin* | *rhapsody* | *macosx*)
+     AC_DEFINE_UNQUOTED(OSX,1,[This is an OS X system])
+     CFLAGS="-no-cpp-precomp $CFLAGS"
+     LDFLAGS="-flat_namespace -undefined suppress $LDFLAGS"
+     ;;
+linux*)
+     AC_DEFINE_UNQUOTED(LINUX,1,[This is a Linux system])
+     ;;
+freebsd*)
+     AC_DEFINE_UNQUOTED(SOMEBSD,1,[This is a BSD system])
+     AC_DEFINE_UNQUOTED(FREEBSD,1,[This is a FreeBSD system])
+     ;;
+openbsd*)
+     AC_DEFINE_UNQUOTED(SOMEBSD,1,[This is a BSD system])
+     AC_DEFINE_UNQUOTED(OPENBSD,1,[This is an OpenBSD system])
+     ;;
+netbsd*)
+     AC_DEFINE_UNQUOTED(SOMEBSD,1,[This is a BSD system])
+     AC_DEFINE_UNQUOTED(NETBSD,1,[This is a NetBSD system])
+     ;;
+*solaris*)
+     AC_DEFINE_UNQUOTED(SOLARIS,1,[This is a Solaris system])
+     AC_DEFINE_UNQUOTED(_REENTRANT,1,[Need with solaris or errno doesnt work])
+     build_target="solaris"
+     ;;
+*arm-linux*)
+     AC_DEFINE_UNQUOTED(LINUX,1,[This is a Linux system])
+     ;;
+*cygwin*)
+     AC_DEFINE_UNQUOTED(CYGWIN,1,[This is a Cygwin system])
+     AC_DEFINE_UNQUOTED(WINDOWS,1,[This is a Windows system])
+     AC_CHECK_LIB(intl, gettext)
+     LDFLAGS="$LDFLAGS -no-undefined"
+     build_target="cygwin"
+     ;;
+*mingw*)
+     AC_DEFINE_UNQUOTED(MINGW,1,[This is a MinGW system])
+     AC_DEFINE_UNQUOTED(WINDOWS,1,[This is a Windows system])
+     AC_DEFINE_UNQUOTED(_WIN32,1,[This is a Windows system])
+     AC_CHECK_LIB(intl, gettext)
+     LDFLAGS="$LDFLAGS -no-undefined -Wl,--export-all-symbols -lws2_32"
+     CFLAGS="-mms-bitfields $CFLAGS"
+     build_target="mingw"
+     ;;
+*)
+     AC_MSG_RESULT(Unrecognised OS $host_os)
+     AC_DEFINE_UNQUOTED(OTHEROS,1,[Some strange OS])
+;;
+esac
+
+AM_CONDITIONAL(MINGW,   test "$build_target" = "mingw")
+
+AC_CHECK_HEADERS([errno.h stdio.h unistd.h locale.h sys/stat.h sys/types.h langinfo.h libintl.h unistd.h stddef.h argz.h sys/socket.h netinet/in.h stdarg.h])
+
+# openssl
+openssl=0
+AC_MSG_CHECKING([for openssl])
+AC_ARG_WITH(openssl,
+   [  --with-openssl=PFX   base of openssl installation],
+   [AC_MSG_RESULT([$with_openssl])
+    case $with_openssl in
+      no)
+        ;;
+      yes)
+        AC_CHECK_HEADERS([openssl/ssl.h],
+            AC_CHECK_LIB([ssl], [SSL_new],
+             openssl=1))
+        ;;
+      *)
+        LDFLAGS="-L$with_openssl/lib $LDFLAGS"
+        CPPFLAGS="-I$with_openssl/include $CPPFLAGS"
+        AC_CHECK_HEADERS([openssl/ssl.h],
+            AC_CHECK_LIB([ssl], [SSL_new],
+              EXT_LIB_PATH="-L$with_openssl/lib $EXT_LIB_PATH"
+              openssl=1))
+        ;;
+    esac
+   ],
+   [AC_MSG_RESULT([--with-openssl not specified])
+    AC_CHECK_HEADERS([openssl/ssl.h],
+        AC_CHECK_LIB([ssl], [SSL_new],
+          openssl=1))])
+AM_CONDITIONAL(HAVE_OPENSSL, test x$openssl = x1)
+AC_DEFINE_UNQUOTED([HAVE_OPENSSL], $openssl, [We have openssl])
+
+
+
+# libesmtp
+esmtp=0
+AC_MSG_CHECKING([for libesmtp])
+AC_ARG_WITH(esmtp,
+   [  --with-esmtp=PFX        base of libesmtp installation],
+   [AC_MSG_RESULT([$with_esmtp])
+    case $with_esmtp in
+      no)
+        ;;
+      yes)
+        AC_CHECK_HEADERS(libesmtp.h,
+          AC_CHECK_LIB([esmtp], [smtp_start_session],
+            esmtp=1))
+        ;;
+      *)
+        LDFLAGS="-L$with_esmtp/lib $LDFLAGS"
+        CPPFLAGS="-I$with_esmtp/include $CPPFLAGS"
+        AC_CHECK_HEADERS(libesmtp.h,
+          AC_CHECK_LIB([esmtp], [smtp_start_session],
+            EXT_LIB_PATH="-L$with_esmtp/lib $EXT_LIB_PATH"
+              esmtp=1))
+        ;;
+    esac
+   ],
+   [AC_MSG_RESULT([--with-esmtp not specified])
+    AC_CHECK_HEADERS(libesmtp.h,
+      AC_CHECK_LIB([esmtp], [smtp_start_session],
+          esmtp=1))])
+AM_CONDITIONAL(HAVE_ESMTP, test x$esmtp = x1)
+AC_DEFINE_UNQUOTED([HAVE_ESMTP], $esmtp, [We have libesmtp])
+# restore LIBS
+LIBS=$SAVE_LIBS
+
+
+# gcov compilation
+AC_MSG_CHECKING(whether to compile with support for code coverage analysis)
+AC_ARG_ENABLE([coverage], 
+              AS_HELP_STRING([--enable-coverage],
+                             [compile the library with code coverage support]),
+              [use_gcov=${enableval}], 
+              [use_gcov=no])
+AC_MSG_RESULT($use_gcov)
+AM_CONDITIONAL([USE_COVERAGE], [test "x$use_gcov" = "xyes"])
+
+
+# should 'make check' run tests?
+AC_MSG_CHECKING(whether to run tests)
+AC_ARG_ENABLE([testruns],
+   [AS_HELP_STRING([--disable-testruns], [disable running tests on make check (default is YES)])],
+   [enable_tests_run=${enableval}],
+   [enable_tests_run=yes])
+AC_MSG_RESULT($enable_test_run)
+AM_CONDITIONAL([ENABLE_TEST_RUN], [test "x$enable_tests_run" = "xyes"])
+
+AC_CHECK_PROG(SSP_FOUND, seaspider, [yes], [no], [../seaspider/bin])
+AM_CONDITIONAL([SEASPIDER], [test "$SSP_FOUND" = yes])
+
+
+AC_DEFINE_DIR([PACKAGE_DATA], [datarootdir], [The directory for installing read-only architecture-independent data])
+
+# Set PACKAGE_SOURCE_DIR in gnunet_gtk_config.h.
+packagesrcdir=`cd $srcdir && pwd`
+AC_DEFINE_UNQUOTED(PACKAGE_SOURCE_DIR, "${packagesrcdir}", [source dir])
+
+AC_OUTPUT([
+Makefile
+src/Makefile
+src/include/Makefile
+src/mi/Makefile
+src/minixml/Makefile
+src/util/Makefile
+src/pathologist/Makefile
+refs/src/Makefile
+])
diff --git a/pathologist/contrib/monkey_sysinfo.sh b/pathologist/contrib/monkey_sysinfo.sh
new file mode 100755
index 0000000..d5c7866
--- /dev/null
+++ b/pathologist/contrib/monkey_sysinfo.sh
@@ -0,0 +1,228 @@
+#!/bin/sh
+
+TEST=`type type|grep not`
+if test -n "$TEST"; then
+  WHICH=which
+else
+  WHICH=type
+fi
+
+echo "\t<sysinfo>"
+OS=`uname -s 2>/dev/null`
+echo "\t\t<os>$OS</os>" 
+REL=`uname -r 2>/dev/null`
+echo "\t\t<os_release>$REL</os_release>"
+HW=`uname -m 2>/dev/null`
+echo "\t\t<hardware>$HW</hardware>"
+
+TEST=`$WHICH gcc 2>/dev/null`
+if test -n "$TEST"; then
+  VERS=`gcc --version 2>/dev/null | head -n 1`
+  echo "gcc            : $VERS"
+else
+  echo "gcc            : Not Found";
+fi
+
+TEST=`$WHICH gmake 2>/dev/null`
+if test -n "$TEST" ; then
+        gmake --version 2>/dev/null |\
+                awk -F, '{print $1}' |\
+                awk '/GNU Make/{print "GNU gmake      :",$NF}'
+else
+  TEST=`make --version 2>/dev/null`
+  if test -n "$TEST"; then
+                make --version 2>/dev/null |\
+                        awk -F, '{print $1}' |\
+                        awk '/GNU Make/{print "make           :",$NF}'
+  else
+                echo "make           : Not Found"
+  fi
+fi
+
+TEST=`$WHICH autoconf 2>/dev/null`
+if test -n "$TEST"; then
+  autoconf --version |\
+    head -n 1 |\
+    awk '{\
+        if (length($4) == 0) {\
+                print "autoconf       : "$3\
+        } else {\
+                print "autoconf       : "$4\
+        }}'
+else
+  echo "autoconf       : Not Found"
+fi
+
+TEST=`$WHICH automake 2>/dev/null`
+if test -n "$TEST"; then
+  automake --version 2>/dev/null |\
+    head -n 1 |\
+    awk '{print "automake       : "$4}'
+else
+  echo "automake       : Not Found"
+fi
+
+TEST=`$WHICH libtool 2>/dev/null`
+if test -n "$TEST"; then
+  libtool --version 2>/dev/null |\
+    head -n 1 |\
+    awk '{print "libtool        : "$4}'
+else
+  echo "libtool        : Not Found"
+fi
+
+TEST=`$WHICH extract 2>/dev/null`
+if test -n "$TEST"; then
+  extract -v 2>/dev/null |\
+    head -n 1 |\
+    awk '{print "libextractor   : "$2}'
+else
+  echo "libextractor   : Not Found"
+fi
+
+TEST=`$WHICH libgcrypt-config 2> /dev/null`
+if test -n "$TEST"; then
+  libgcrypt-config --version 2> /dev/null | \
+    awk '{print "libgcrypt      : "$1}'
+else
+  echo "libgcrypt      : Not Found"
+fi
+
+TEST=`$WHICH mysql_config 2> /dev/null`
+if test -n "$TEST"; then
+  mysql_config --version 2> /dev/null | \
+    awk '{print "mysql          : "$1}'
+else
+  echo "mysql          : Not Found"
+fi
+
+TEST=`$WHICH pkg-config 2> /dev/null`
+if test -n "$TEST"; then
+  pkg-config --version 2> /dev/null | \
+    awk '{print "pkg-config     : "$1}'
+else
+  echo "pkg-config     : Not Found"
+fi
+
+TEST=`$WHICH pkg-config 2> /dev/null`
+if test -n "$TEST"; then
+  pkg-config --modversion glib-2.0 2> /dev/null | \
+    awk '{print "glib2          : "$1}'
+else
+  echo "glib2          : Not Found"
+fi
+
+TEST=`$WHICH pkg-config 2> /dev/null`
+if test -n "$TEST"; then
+  pkg-config --modversion gtk+-2.0 2> /dev/null | \
+    awk '{print "gtk2+          : "$1}'
+else
+  echo "gtk2+          : Not Found"
+fi
+
+TEST=`$WHICH dpkg 2> /dev/null`
+if test -n "$TEST"; then
+  LINES=`dpkg -s libgmp3-dev | grep Version | wc -l`
+  if test "$LINES" = "1"
+  then
+    VERSION=`dpkg -s libgmp3-dev | grep Version | awk '{print $2}'`
+    echo "GMP            : libgmp3-dev-$VERSION.deb"
+  else
+    echo "GMP            : dpkg: libgmp3-dev not installed"
+  fi
+else
+  TEST=`$WHICH rpm 2> /dev/null`
+  if test -n "$TEST"; then
+    rpm -q gmp | sed -e "s/gmp-//" 2> /dev/null | \
+      awk '{print "GMP            : "$1.rpm}'
+  else
+    echo "GMP            : Test not available"
+  fi
+fi
+
+TEST=`$WHICH dpkg 2> /dev/null`
+if test -n "$TEST"; then
+  LINES=`dpkg -s libunistring-dev | grep Version | wc -l`
+  if test "$LINES" = "1"
+  then
+    VERSION=`dpkg -s libunistring-dev | grep Version | awk '{print $2}'`
+    echo "libunistring   : libunistring3-dev-$VERSION.deb"
+  else
+    echo "libunistring   : dpkg: libunistring3-dev not installed"
+  fi
+else
+  TEST=`$WHICH rpm 2> /dev/null`
+  if test -n "$TEST"; then
+    rpm -q unistring | sed -e "s/unistring-//" 2> /dev/null | \
+      awk '{print "libunistring   : "$1.rpm}'
+  else
+    echo "libunistring   : Test not available"
+  fi
+fi
+
+TEST=`$WHICH gettext 2> /dev/null`
+if test -n "$TEST"; then
+  gettext --version | head -n1 2> /dev/null | \
+    awk '{print "GNU gettext    : "$4}'
+else
+  echo "GNU gettext    : Not found"
+fi
+
+
+TEST=`$WHICH curl-config 2> /dev/null`
+if test -n "$TEST"; then
+  curl-config --version | head -n1 2> /dev/null | \
+    awk '{print "libcurl        : "$2}'
+else
+  echo "libcurl        : Not found"
+fi
+
+echo -n "libmicrohttpd  : "
+TMPFILE=`mktemp /tmp/mhd-version-testXXXXXX`
+cat - >$TMPFILE.c <<EOF
+#include <microhttpd.h>
+#include <stdio.h>
+int main()
+{
+  fprintf (stdout, "%X\n", MHD_VERSION);
+  return 0;
+}
+EOF
+
+gcc -o $TMPFILE $TMPFILE.c 2> /dev/null && $TMPFILE || echo "Not found"
+rm -f $TMPFILE $TMPFILE.bin
+
+
+echo -n "GNU GLPK       : "
+TMPFILE=`mktemp /tmp/glpk-version-testXXXXXX`
+cat - >$TMPFILE.c <<EOF
+#include <glpk.h>
+#include <stdio.h>
+int main()
+{
+  fprintf (stdout, "%u.%u\n", GLP_MAJOR_VERSION, GLP_MINOR_VERSION);
+  return 0;
+}
+EOF
+
+gcc -o $TMPFILE $TMPFILE.c 2> /dev/null && $TMPFILE || echo "Not found"
+rm -f $TMPFILE $TMPFILE.bin
+
+
+echo -n "GNUtls         : "
+TMPFILE=`mktemp /tmp/gnutls-version-testXXXXXX`
+cat - >$TMPFILE.c <<EOF
+#include <gnutls/gnutls.h>
+#include <stdio.h>
+int main()
+{
+  fprintf (stdout, "%s\n", GNUTLS_VERSION);
+  return 0;
+}
+EOF
+
+gcc -o $TMPFILE $TMPFILE.c 2> /dev/null && $TMPFILE || echo "Not found"
+rm -f $TMPFILE $TMPFILE.bin
+
+
+echo "\t</sysinfo>"
diff --git a/pathologist/m4/ac_define_dir.m4 b/pathologist/m4/ac_define_dir.m4
new file mode 100644
index 0000000..f7e028f
--- /dev/null
+++ b/pathologist/m4/ac_define_dir.m4
@@ -0,0 +1,35 @@
+dnl @synopsis AC_DEFINE_DIR(VARNAME, DIR [, DESCRIPTION])

+dnl

+dnl This macro _AC_DEFINEs VARNAME to the expansion of the DIR

+dnl variable, taking care of fixing up ${prefix} and such.

+dnl

+dnl VARNAME is offered as both a C preprocessor symbol, and an output

+dnl variable.

+dnl

+dnl Note that the 3 argument form is only supported with autoconf 2.13

+dnl and later (i.e. only where _AC_DEFINE supports 3 arguments).

+dnl

+dnl Examples:

+dnl

+dnl    AC_DEFINE_DIR(DATADIR, datadir)

+dnl    AC_DEFINE_DIR(PROG_PATH, bindir, [Location of installed binaries])

+dnl

+dnl @category Misc

+dnl @author Stepan Kasal <kasal@ucw.cz>

+dnl @author Andreas Schwab <schwab@suse.de>

+dnl @author Guido Draheim <guidod@gmx.de>

+dnl @author Alexandre Oliva

+dnl @version 2005-01-17

+dnl @license AllPermissive

+

+AC_DEFUN([AC_DEFINE_DIR], [

+  prefix_NONE=

+  exec_prefix_NONE=

+  test "x$prefix" = xNONE && prefix_NONE=yes && prefix=$ac_default_prefix

+  test "x$exec_prefix" = xNONE && exec_prefix_NONE=yes && exec_prefix=$prefix

+  eval ac_define_dir="\"[$]$2\""

+  AC_SUBST($1, "$ac_define_dir")

+  AC_DEFINE_UNQUOTED($1, "$ac_define_dir", [$3])

+  test "$prefix_NONE" && prefix=NONE

+  test "$exec_prefix_NONE" && exec_prefix=NONE

+])

diff --git a/pathologist/m4/libtool.m4 b/pathologist/m4/libtool.m4
new file mode 100644
index 0000000..a3fee53
--- /dev/null
+++ b/pathologist/m4/libtool.m4
@@ -0,0 +1,7377 @@
+# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
+#
+#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+#                 2006, 2007, 2008 Free Software Foundation, Inc.
+#   Written by Gordon Matzigkeit, 1996
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+m4_define([_LT_COPYING], [dnl
+#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+#                 2006, 2007, 2008 Free Software Foundation, Inc.
+#   Written by Gordon Matzigkeit, 1996
+#
+#   This file is part of GNU Libtool.
+#
+# GNU Libtool 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.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool 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 Libtool; see the file COPYING.  If not, a copy
+# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
+# obtained by writing to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+])
+
+# serial 56 LT_INIT
+
+
+# LT_PREREQ(VERSION)
+# ------------------
+# Complain and exit if this libtool version is less that VERSION.
+m4_defun([LT_PREREQ],
+[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
+       [m4_default([$3],
+                   [m4_fatal([Libtool version $1 or higher is required],
+                             63)])],
+       [$2])])
+
+
+# _LT_CHECK_BUILDDIR
+# ------------------
+# Complain if the absolute build directory name contains unusual characters
+m4_defun([_LT_CHECK_BUILDDIR],
+[case `pwd` in
+  *\ * | *\     *)
+    AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;
+esac
+])
+
+
+# LT_INIT([OPTIONS])
+# ------------------
+AC_DEFUN([LT_INIT],
+[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
+AC_BEFORE([$0], [LT_LANG])dnl
+AC_BEFORE([$0], [LT_OUTPUT])dnl
+AC_BEFORE([$0], [LTDL_INIT])dnl
+m4_require([_LT_CHECK_BUILDDIR])dnl
+
+dnl Autoconf doesn't catch unexpanded LT_ macros by default:
+m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
+m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl
+dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
+dnl unless we require an AC_DEFUNed macro:
+AC_REQUIRE([LTOPTIONS_VERSION])dnl
+AC_REQUIRE([LTSUGAR_VERSION])dnl
+AC_REQUIRE([LTVERSION_VERSION])dnl
+AC_REQUIRE([LTOBSOLETE_VERSION])dnl
+m4_require([_LT_PROG_LTMAIN])dnl
+
+dnl Parse OPTIONS
+_LT_SET_OPTIONS([$0], [$1])
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ltmain"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+AC_SUBST(LIBTOOL)dnl
+
+_LT_SETUP
+
+# Only expand once:
+m4_define([LT_INIT])
+])# LT_INIT
+
+# Old names:
+AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])
+AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
+dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
+
+
+# _LT_CC_BASENAME(CC)
+# -------------------
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+m4_defun([_LT_CC_BASENAME],
+[for cc_temp in $1""; do
+  case $cc_temp in
+    compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
+    distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$ECHO "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+])
+
+
+# _LT_FILEUTILS_DEFAULTS
+# ----------------------
+# It is okay to use these file commands and assume they have been set
+# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'.
+m4_defun([_LT_FILEUTILS_DEFAULTS],
+[: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+])# _LT_FILEUTILS_DEFAULTS
+
+
+# _LT_SETUP
+# ---------
+m4_defun([_LT_SETUP],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+_LT_DECL([], [host_alias], [0], [The host system])dnl
+_LT_DECL([], [host], [0])dnl
+_LT_DECL([], [host_os], [0])dnl
+dnl
+_LT_DECL([], [build_alias], [0], [The build system])dnl
+_LT_DECL([], [build], [0])dnl
+_LT_DECL([], [build_os], [0])dnl
+dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([LT_PATH_LD])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+dnl
+AC_REQUIRE([AC_PROG_LN_S])dnl
+test -z "$LN_S" && LN_S="ln -s"
+_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
+dnl
+AC_REQUIRE([LT_CMD_MAX_LEN])dnl
+_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
+_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
+dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_CHECK_SHELL_FEATURES])dnl
+m4_require([_LT_CMD_RELOAD])dnl
+m4_require([_LT_CHECK_MAGIC_METHOD])dnl
+m4_require([_LT_CMD_OLD_ARCHIVE])dnl
+m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
+
+_LT_CONFIG_LIBTOOL_INIT([
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}" ; then
+   setopt NO_GLOB_SUBST
+fi
+])
+if test -n "${ZSH_VERSION+set}" ; then
+   setopt NO_GLOB_SUBST
+fi
+
+_LT_CHECK_OBJDIR
+
+m4_require([_LT_TAG_COMPILER])dnl
+_LT_PROG_ECHO_BACKSLASH
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test "X${COLLECT_NAMES+set}" != Xset; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\([["`\\]]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+_LT_CC_BASENAME([$compiler])
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    _LT_PATH_MAGIC
+  fi
+  ;;
+esac
+
+# Use C for the default configuration in the libtool script
+LT_SUPPORTED_TAG([CC])
+_LT_LANG_C_CONFIG
+_LT_LANG_DEFAULT_CONFIG
+_LT_CONFIG_COMMANDS
+])# _LT_SETUP
+
+
+# _LT_PROG_LTMAIN
+# ---------------
+# Note that this code is called both from `configure', and `config.status'
+# now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
+# `config.status' has no value for ac_aux_dir unless we are using Automake,
+# so we pass a copy along to make sure it has a sensible value anyway.
+m4_defun([_LT_PROG_LTMAIN],
+[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
+_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
+ltmain="$ac_aux_dir/ltmain.sh"
+])# _LT_PROG_LTMAIN
+
+
+## ------------------------------------- ##
+## Accumulate code for creating libtool. ##
+## ------------------------------------- ##
+
+# So that we can recreate a full libtool script including additional
+# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
+# in macros and then make a single call at the end using the `libtool'
+# label.
+
+
+# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
+# ----------------------------------------
+# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL_INIT],
+[m4_ifval([$1],
+          [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
+                     [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_INIT])
+
+
+# _LT_CONFIG_LIBTOOL([COMMANDS])
+# ------------------------------
+# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL],
+[m4_ifval([$1],
+          [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
+                     [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
+
+
+# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
+# -----------------------------------------------------
+m4_defun([_LT_CONFIG_SAVE_COMMANDS],
+[_LT_CONFIG_LIBTOOL([$1])
+_LT_CONFIG_LIBTOOL_INIT([$2])
+])
+
+
+# _LT_FORMAT_COMMENT([COMMENT])
+# -----------------------------
+# Add leading comment marks to the start of each line, and a trailing
+# full-stop to the whole comment if one is not present already.
+m4_define([_LT_FORMAT_COMMENT],
+[m4_ifval([$1], [
+m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],
+              [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])
+)])
+
+
+
+## ------------------------ ##
+## FIXME: Eliminate VARNAME ##
+## ------------------------ ##
+
+
+# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
+# -------------------------------------------------------------------
+# CONFIGNAME is the name given to the value in the libtool script.
+# VARNAME is the (base) name used in the configure script.
+# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
+# VARNAME.  Any other value will be used directly.
+m4_define([_LT_DECL],
+[lt_if_append_uniq([lt_decl_varnames], [$2], [, ],
+    [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
+        [m4_ifval([$1], [$1], [$2])])
+    lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
+    m4_ifval([$4],
+        [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
+    lt_dict_add_subkey([lt_decl_dict], [$2],
+        [tagged?], [m4_ifval([$5], [yes], [no])])])
+])
+
+
+# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
+# --------------------------------------------------------
+m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
+
+
+# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_tag_varnames],
+[_lt_decl_filter([tagged?], [yes], $@)])
+
+
+# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])
+# ---------------------------------------------------------
+m4_define([_lt_decl_filter],
+[m4_case([$#],
+  [0], [m4_fatal([$0: too few arguments: $#])],
+  [1], [m4_fatal([$0: too few arguments: $#: $1])],
+  [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
+  [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
+  [lt_dict_filter([lt_decl_dict], $@)])[]dnl
+])
+
+
+# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
+# --------------------------------------------------
+m4_define([lt_decl_quote_varnames],
+[_lt_decl_filter([value], [1], $@)])
+
+
+# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_dquote_varnames],
+[_lt_decl_filter([value], [2], $@)])
+
+
+# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_varnames_tagged],
+[m4_assert([$# <= 2])dnl
+_$0(m4_quote(m4_default([$1], [[, ]])),
+    m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),
+    m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])
+m4_define([_lt_decl_varnames_tagged],
+[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
+
+
+# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_all_varnames],
+[_$0(m4_quote(m4_default([$1], [[, ]])),
+     m4_if([$2], [],
+           m4_quote(lt_decl_varnames),
+        m4_quote(m4_shift($@))))[]dnl
+])
+m4_define([_lt_decl_all_varnames],
+[lt_join($@, lt_decl_varnames_tagged([$1],
+                        lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
+])
+
+
+# _LT_CONFIG_STATUS_DECLARE([VARNAME])
+# ------------------------------------
+# Quote a variable value, and forward it to `config.status' so that its
+# declaration there will have the same value as in `configure'.  VARNAME
+# must have a single quote delimited value for this to work.
+m4_define([_LT_CONFIG_STATUS_DECLARE],
+[$1='`$ECHO "X$][$1" | $Xsed -e "$delay_single_quote_subst"`'])
+
+
+# _LT_CONFIG_STATUS_DECLARATIONS
+# ------------------------------
+# We delimit libtool config variables with single quotes, so when
+# we write them to config.status, we have to be sure to quote all
+# embedded single quotes properly.  In configure, this macro expands
+# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
+#
+#    <var>='`$ECHO "X$<var>" | $Xsed -e "$delay_single_quote_subst"`'
+m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
+    [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAGS
+# ----------------
+# Output comment and list of tags supported by the script
+m4_defun([_LT_LIBTOOL_TAGS],
+[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
+available_tags="_LT_TAGS"dnl
+])
+
+
+# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
+# -----------------------------------
+# Extract the dictionary values for VARNAME (optionally with TAG) and
+# expand to a commented shell variable setting:
+#
+#    # Some comment about what VAR is for.
+#    visible_name=$lt_internal_name
+m4_define([_LT_LIBTOOL_DECLARE],
+[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
+                                           [description])))[]dnl
+m4_pushdef([_libtool_name],
+    m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
+m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
+    [0], [_libtool_name=[$]$1],
+    [1], [_libtool_name=$lt_[]$1],
+    [2], [_libtool_name=$lt_[]$1],
+    [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
+m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
+])
+
+
+# _LT_LIBTOOL_CONFIG_VARS
+# -----------------------
+# Produce commented declarations of non-tagged libtool config variables
+# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
+# script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
+# section) are produced by _LT_LIBTOOL_TAG_VARS.
+m4_defun([_LT_LIBTOOL_CONFIG_VARS],
+[m4_foreach([_lt_var],
+    m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
+    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAG_VARS(TAG)
+# -------------------------
+m4_define([_LT_LIBTOOL_TAG_VARS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
+    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
+
+
+# _LT_TAGVAR(VARNAME, [TAGNAME])
+# ------------------------------
+m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
+
+
+# _LT_CONFIG_COMMANDS
+# -------------------
+# Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
+# variables for single and double quote escaping we saved from calls
+# to _LT_DECL, we can put quote escaped variables declarations
+# into `config.status', and then the shell code to quote escape them in
+# for loops in `config.status'.  Finally, any additional code accumulated
+# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
+m4_defun([_LT_CONFIG_COMMANDS],
+[AC_PROVIDE_IFELSE([LT_OUTPUT],
+        dnl If the libtool generation code has been placed in $CONFIG_LT,
+        dnl instead of duplicating it all over again into config.status,
+        dnl then we will have config.status run $CONFIG_LT later, so it
+        dnl needs to know what name is stored there:
+        [AC_CONFIG_COMMANDS([libtool],
+            [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
+    dnl If the libtool generation code is destined for config.status,
+    dnl expand the accumulated commands and init code now:
+    [AC_CONFIG_COMMANDS([libtool],
+        [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
+])#_LT_CONFIG_COMMANDS
+
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
+[
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+_LT_CONFIG_STATUS_DECLARATIONS
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# Quote evaled strings.
+for var in lt_decl_all_varnames([[ \
+]], lt_decl_quote_varnames); do
+    case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in
+    *[[\\\\\\\`\\"\\\$]]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Double-quote double-evaled strings.
+for var in lt_decl_all_varnames([[ \
+]], lt_decl_dquote_varnames); do
+    case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in
+    *[[\\\\\\\`\\"\\\$]]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Fix-up fallback echo if it was mangled by the above quoting rules.
+case \$lt_ECHO in
+*'\\\[$]0 --fallback-echo"')dnl "
+  lt_ECHO=\`\$ECHO "X\$lt_ECHO" | \$Xsed -e 's/\\\\\\\\\\\\\\\[$]0 --fallback-echo"\[$]/\[$]0 --fallback-echo"/'\`
+  ;;
+esac
+
+_LT_OUTPUT_LIBTOOL_INIT
+])
+
+
+# LT_OUTPUT
+# ---------
+# This macro allows early generation of the libtool script (before
+# AC_OUTPUT is called), incase it is used in configure for compilation
+# tests.
+AC_DEFUN([LT_OUTPUT],
+[: ${CONFIG_LT=./config.lt}
+AC_MSG_NOTICE([creating $CONFIG_LT])
+cat >"$CONFIG_LT" <<_LTEOF
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate a libtool stub with the current configuration.
+
+lt_cl_silent=false
+SHELL=\${CONFIG_SHELL-$SHELL}
+_LTEOF
+
+cat >>"$CONFIG_LT" <<\_LTEOF
+AS_SHELL_SANITIZE
+_AS_PREPARE
+
+exec AS_MESSAGE_FD>&1
+exec AS_MESSAGE_LOG_FD>>config.log
+{
+  echo
+  AS_BOX([Running $as_me.])
+} >&AS_MESSAGE_LOG_FD
+
+lt_cl_help="\
+\`$as_me' creates a local libtool stub from the current configuration,
+for use in further configure time tests before the real libtool is
+generated.
+
+Usage: $[0] [[OPTIONS]]
+
+  -h, --help      print this help, then exit
+  -V, --version   print version number, then exit
+  -q, --quiet     do not print progress messages
+  -d, --debug     don't remove temporary files
+
+Report bugs to <bug-libtool@gnu.org>."
+
+lt_cl_version="\
+m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
+m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
+configured by $[0], generated by m4_PACKAGE_STRING.
+
+Copyright (C) 2008 Free Software Foundation, Inc.
+This config.lt script is free software; the Free Software Foundation
+gives unlimited permision to copy, distribute and modify it."
+
+while test $[#] != 0
+do
+  case $[1] in
+    --version | --v* | -V )
+      echo "$lt_cl_version"; exit 0 ;;
+    --help | --h* | -h )
+      echo "$lt_cl_help"; exit 0 ;;
+    --debug | --d* | -d )
+      debug=: ;;
+    --quiet | --q* | --silent | --s* | -q )
+      lt_cl_silent=: ;;
+
+    -*) AC_MSG_ERROR([unrecognized option: $[1]
+Try \`$[0] --help' for more information.]) ;;
+
+    *) AC_MSG_ERROR([unrecognized argument: $[1]
+Try \`$[0] --help' for more information.]) ;;
+  esac
+  shift
+done
+
+if $lt_cl_silent; then
+  exec AS_MESSAGE_FD>/dev/null
+fi
+_LTEOF
+
+cat >>"$CONFIG_LT" <<_LTEOF
+_LT_OUTPUT_LIBTOOL_COMMANDS_INIT
+_LTEOF
+
+cat >>"$CONFIG_LT" <<\_LTEOF
+AC_MSG_NOTICE([creating $ofile])
+_LT_OUTPUT_LIBTOOL_COMMANDS
+AS_EXIT(0)
+_LTEOF
+chmod +x "$CONFIG_LT"
+
+# configure is writing to config.log, but config.lt does its own redirection,
+# appending to config.log, which fails on DOS, as config.log is still kept
+# open by configure.  Here we exec the FD to /dev/null, effectively closing
+# config.log, so it can be properly (re)opened and appended to by config.lt.
+if test "$no_create" != yes; then
+  lt_cl_success=:
+  test "$silent" = yes &&
+    lt_config_lt_args="$lt_config_lt_args --quiet"
+  exec AS_MESSAGE_LOG_FD>/dev/null
+  $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
+  exec AS_MESSAGE_LOG_FD>>config.log
+  $lt_cl_success || AS_EXIT(1)
+fi
+])# LT_OUTPUT
+
+
+# _LT_CONFIG(TAG)
+# ---------------
+# If TAG is the built-in tag, create an initial libtool script with a
+# default configuration from the untagged config vars.  Otherwise add code
+# to config.status for appending the configuration named by TAG from the
+# matching tagged config vars.
+m4_defun([_LT_CONFIG],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+_LT_CONFIG_SAVE_COMMANDS([
+  m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
+  m4_if(_LT_TAG, [C], [
+    # See if we are running on zsh, and set the options which allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}" ; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile="${ofile}T"
+    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+    $RM "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+
+# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+_LT_COPYING
+_LT_LIBTOOL_TAGS
+
+# ### BEGIN LIBTOOL CONFIG
+_LT_LIBTOOL_CONFIG_VARS
+_LT_LIBTOOL_TAG_VARS
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+  _LT_PROG_LTMAIN
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '/^# Generated shell functions inserted here/q' "$ltmain" >> "$cfgfile" \
+    || (rm -f "$cfgfile"; exit 1)
+
+  _LT_PROG_XSI_SHELLFNS
+
+  sed -n '/^# Generated shell functions inserted here/,$p' "$ltmain" >> "$cfgfile" \
+    || (rm -f "$cfgfile"; exit 1)
+
+  mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+],
+[cat <<_LT_EOF >> "$ofile"
+
+dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
+dnl in a comment (ie after a #).
+# ### BEGIN LIBTOOL TAG CONFIG: $1
+_LT_LIBTOOL_TAG_VARS(_LT_TAG)
+# ### END LIBTOOL TAG CONFIG: $1
+_LT_EOF
+])dnl /m4_if
+],
+[m4_if([$1], [], [
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    TIMESTAMP='$TIMESTAMP'
+    RM='$RM'
+    ofile='$ofile'], [])
+])dnl /_LT_CONFIG_SAVE_COMMANDS
+])# _LT_CONFIG
+
+
+# LT_SUPPORTED_TAG(TAG)
+# ---------------------
+# Trace this macro to discover what tags are supported by the libtool
+# --tag option, using:
+#    autoconf --trace 'LT_SUPPORTED_TAG:$1'
+AC_DEFUN([LT_SUPPORTED_TAG], [])
+
+
+# C support is built-in for now
+m4_define([_LT_LANG_C_enabled], [])
+m4_define([_LT_TAGS], [])
+
+
+# LT_LANG(LANG)
+# -------------
+# Enable libtool support for the given language if not already enabled.
+AC_DEFUN([LT_LANG],
+[AC_BEFORE([$0], [LT_OUTPUT])dnl
+m4_case([$1],
+  [C],                  [_LT_LANG(C)],
+  [C++],                [_LT_LANG(CXX)],
+  [Java],               [_LT_LANG(GCJ)],
+  [Fortran 77],         [_LT_LANG(F77)],
+  [Fortran],            [_LT_LANG(FC)],
+  [Windows Resource],   [_LT_LANG(RC)],
+  [m4_ifdef([_LT_LANG_]$1[_CONFIG],
+    [_LT_LANG($1)],
+    [m4_fatal([$0: unsupported language: "$1"])])])dnl
+])# LT_LANG
+
+
+# _LT_LANG(LANGNAME)
+# ------------------
+m4_defun([_LT_LANG],
+[m4_ifdef([_LT_LANG_]$1[_enabled], [],
+  [LT_SUPPORTED_TAG([$1])dnl
+  m4_append([_LT_TAGS], [$1 ])dnl
+  m4_define([_LT_LANG_]$1[_enabled], [])dnl
+  _LT_LANG_$1_CONFIG($1)])dnl
+])# _LT_LANG
+
+
+# _LT_LANG_DEFAULT_CONFIG
+# -----------------------
+m4_defun([_LT_LANG_DEFAULT_CONFIG],
+[AC_PROVIDE_IFELSE([AC_PROG_CXX],
+  [LT_LANG(CXX)],
+  [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_F77],
+  [LT_LANG(F77)],
+  [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_FC],
+  [LT_LANG(FC)],
+  [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])
+
+dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
+dnl pulling things in needlessly.
+AC_PROVIDE_IFELSE([AC_PROG_GCJ],
+  [LT_LANG(GCJ)],
+  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
+    [LT_LANG(GCJ)],
+    [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
+      [LT_LANG(GCJ)],
+      [m4_ifdef([AC_PROG_GCJ],
+        [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
+       m4_ifdef([A][M_PROG_GCJ],
+        [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
+       m4_ifdef([LT_PROG_GCJ],
+        [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
+
+AC_PROVIDE_IFELSE([LT_PROG_RC],
+  [LT_LANG(RC)],
+  [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
+])# _LT_LANG_DEFAULT_CONFIG
+
+# Obsolete macros:
+AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
+AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
+AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
+AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
+dnl AC_DEFUN([AC_LIBTOOL_F77], [])
+dnl AC_DEFUN([AC_LIBTOOL_FC], [])
+dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
+
+
+# _LT_TAG_COMPILER
+# ----------------
+m4_defun([_LT_TAG_COMPILER],
+[AC_REQUIRE([AC_PROG_CC])dnl
+
+_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
+_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
+_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
+_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+])# _LT_TAG_COMPILER
+
+
+# _LT_COMPILER_BOILERPLATE
+# ------------------------
+# Check for compiler boilerplate output or warnings with
+# the simple compiler test code.
+m4_defun([_LT_COMPILER_BOILERPLATE],
+[m4_require([_LT_DECL_SED])dnl
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+])# _LT_COMPILER_BOILERPLATE
+
+
+# _LT_LINKER_BOILERPLATE
+# ----------------------
+# Check for linker boilerplate output or warnings with
+# the simple link test code.
+m4_defun([_LT_LINKER_BOILERPLATE],
+[m4_require([_LT_DECL_SED])dnl
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+])# _LT_LINKER_BOILERPLATE
+
+# _LT_REQUIRED_DARWIN_CHECKS
+# -------------------------
+m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
+  case $host_os in
+    rhapsody* | darwin*)
+    AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
+    AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
+    AC_CHECK_TOOL([LIPO], [lipo], [:])
+    AC_CHECK_TOOL([OTOOL], [otool], [:])
+    AC_CHECK_TOOL([OTOOL64], [otool64], [:])
+    _LT_DECL([], [DSYMUTIL], [1],
+      [Tool to manipulate archived DWARF debug symbol files on Mac OS X])
+    _LT_DECL([], [NMEDIT], [1],
+      [Tool to change global to local symbols on Mac OS X])
+    _LT_DECL([], [LIPO], [1],
+      [Tool to manipulate fat objects and archives on Mac OS X])
+    _LT_DECL([], [OTOOL], [1],
+      [ldd/readelf like tool for Mach-O binaries on Mac OS X])
+    _LT_DECL([], [OTOOL64], [1],
+      [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])
+
+    AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
+      [lt_cv_apple_cc_single_mod=no
+      if test -z "${LT_MULTI_MODULE}"; then
+        # By default we will add the -single_module flag. You can override
+        # by either setting the environment variable LT_MULTI_MODULE
+        # non-empty at configure time, or by adding -multi_module to the
+        # link flags.
+        rm -rf libconftest.dylib*
+        echo "int foo(void){return 1;}" > conftest.c
+        echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
+        $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+          -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+        _lt_result=$?
+        if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then
+          lt_cv_apple_cc_single_mod=yes
+        else
+          cat conftest.err >&AS_MESSAGE_LOG_FD
+        fi
+        rm -rf libconftest.dylib*
+        rm -f conftest.*
+      fi])
+    AC_CACHE_CHECK([for -exported_symbols_list linker flag],
+      [lt_cv_ld_exported_symbols_list],
+      [lt_cv_ld_exported_symbols_list=no
+      save_LDFLAGS=$LDFLAGS
+      echo "_main" > conftest.sym
+      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+      AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+        [lt_cv_ld_exported_symbols_list=yes],
+        [lt_cv_ld_exported_symbols_list=no])
+        LDFLAGS="$save_LDFLAGS"
+    ])
+    case $host_os in
+    rhapsody* | darwin1.[[012]])
+      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
+    darwin1.*)
+      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+    darwin*) # darwin 5.x on
+      # if running on 10.5 or later, the deployment target defaults
+      # to the OS version, if on x86, and 10.4, the deployment
+      # target defaults to 10.4. Don't you love it?
+      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+        10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
+          _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+        10.[[012]]*)
+          _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+        10.*)
+          _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+      esac
+    ;;
+  esac
+    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
+      _lt_dar_single_mod='$single_module'
+    fi
+    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
+      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
+    else
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    fi
+    if test "$DSYMUTIL" != ":"; then
+      _lt_dsymutil='~$DSYMUTIL $lib || :'
+    else
+      _lt_dsymutil=
+    fi
+    ;;
+  esac
+])
+
+
+# _LT_DARWIN_LINKER_FEATURES
+# --------------------------
+# Checks for linker and compiler features on darwin
+m4_defun([_LT_DARWIN_LINKER_FEATURES],
+[
+  m4_require([_LT_REQUIRED_DARWIN_CHECKS])
+  _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+  _LT_TAGVAR(hardcode_direct, $1)=no
+  _LT_TAGVAR(hardcode_automatic, $1)=yes
+  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+  _LT_TAGVAR(whole_archive_flag_spec, $1)=''
+  _LT_TAGVAR(link_all_deplibs, $1)=yes
+  _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"
+  case $cc_basename in
+     ifort*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test "$_lt_dar_can_shared" = "yes"; then
+    output_verbose_link_cmd=echo
+    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
+    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
+    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
+    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+    m4_if([$1], [CXX],
+[   if test "$lt_cv_apple_cc_single_mod" != "yes"; then
+      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
+      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
+    fi
+],[])
+  else
+  _LT_TAGVAR(ld_shlibs, $1)=no
+  fi
+])
+
+# _LT_SYS_MODULE_PATH_AIX
+# -----------------------
+# Links a minimal program and checks the executable
+# for the system default hardcoded library path. In most cases,
+# this is /usr/lib:/lib, but when the MPI compilers are used
+# the location of the communication and MPI libs are included too.
+# If we don't find anything, use the default library path according
+# to the aix ld manual.
+m4_defun([_LT_SYS_MODULE_PATH_AIX],
+[m4_require([_LT_DECL_SED])dnl
+AC_LINK_IFELSE(AC_LANG_PROGRAM,[
+lt_aix_libpath_sed='
+    /Import File Strings/,/^$/ {
+        /^0/ {
+            s/^0  *\(.*\)$/\1/
+            p
+        }
+    }'
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then
+  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+fi],[])
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+])# _LT_SYS_MODULE_PATH_AIX
+
+
+# _LT_SHELL_INIT(ARG)
+# -------------------
+m4_define([_LT_SHELL_INIT],
+[ifdef([AC_DIVERSION_NOTICE],
+             [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
+         [AC_DIVERT_PUSH(NOTICE)])
+$1
+AC_DIVERT_POP
+])# _LT_SHELL_INIT
+
+
+# _LT_PROG_ECHO_BACKSLASH
+# -----------------------
+# Add some code to the start of the generated configure script which
+# will find an echo command which doesn't interpret backslashes.
+m4_defun([_LT_PROG_ECHO_BACKSLASH],
+[_LT_SHELL_INIT([
+# Check that we are running under the correct shell.
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+case X$lt_ECHO in
+X*--fallback-echo)
+  # Remove one level of quotation (which was required for Make).
+  ECHO=`echo "$lt_ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`
+  ;;
+esac
+
+ECHO=${lt_ECHO-echo}
+if test "X[$]1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X[$]1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' ; then
+  # Yippee, $ECHO works!
+  :
+else
+  # Restart under the correct shell.
+  exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}
+fi
+
+if test "X[$]1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<_LT_EOF
+[$]*
+_LT_EOF
+  exit 0
+fi
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+if test -z "$lt_ECHO"; then
+  if test "X${echo_test_string+set}" != Xset; then
+    # find a string as large as possible, as long as the shell can cope with it
+    for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
+      # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
+      if { echo_test_string=`eval $cmd`; } 2>/dev/null &&
+         { test "X$echo_test_string" = "X$echo_test_string"; } 2>/dev/null
+      then
+        break
+      fi
+    done
+  fi
+
+  if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
+     echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
+     test "X$echo_testing_string" = "X$echo_test_string"; then
+    :
+  else
+    # The Solaris, AIX, and Digital Unix default echo programs unquote
+    # backslashes.  This makes it impossible to quote backslashes using
+    #   echo "$something" | sed 's/\\/\\\\/g'
+    #
+    # So, first we look for a working echo in the user's PATH.
+
+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    for dir in $PATH /usr/ucb; do
+      IFS="$lt_save_ifs"
+      if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
+         test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
+         echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
+         test "X$echo_testing_string" = "X$echo_test_string"; then
+        ECHO="$dir/echo"
+        break
+      fi
+    done
+    IFS="$lt_save_ifs"
+
+    if test "X$ECHO" = Xecho; then
+      # We didn't find a better echo, so look for alternatives.
+      if test "X`{ print -r '\t'; } 2>/dev/null`" = 'X\t' &&
+         echo_testing_string=`{ print -r "$echo_test_string"; } 2>/dev/null` &&
+         test "X$echo_testing_string" = "X$echo_test_string"; then
+        # This shell has a builtin print -r that does the trick.
+        ECHO='print -r'
+      elif { test -f /bin/ksh || test -f /bin/ksh$ac_exeext; } &&
+           test "X$CONFIG_SHELL" != X/bin/ksh; then
+        # If we have ksh, try running configure again with it.
+        ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+        export ORIGINAL_CONFIG_SHELL
+        CONFIG_SHELL=/bin/ksh
+        export CONFIG_SHELL
+        exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}
+      else
+        # Try using printf.
+        ECHO='printf %s\n'
+        if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
+           echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
+           test "X$echo_testing_string" = "X$echo_test_string"; then
+          # Cool, printf works
+          :
+        elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+             test "X$echo_testing_string" = 'X\t' &&
+             echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+             test "X$echo_testing_string" = "X$echo_test_string"; then
+          CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
+          export CONFIG_SHELL
+          SHELL="$CONFIG_SHELL"
+          export SHELL
+          ECHO="$CONFIG_SHELL [$]0 --fallback-echo"
+        elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+             test "X$echo_testing_string" = 'X\t' &&
+             echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+             test "X$echo_testing_string" = "X$echo_test_string"; then
+          ECHO="$CONFIG_SHELL [$]0 --fallback-echo"
+        else
+          # maybe with a smaller string...
+          prev=:
+
+          for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do
+            if { test "X$echo_test_string" = "X`eval $cmd`"; } 2>/dev/null
+            then
+              break
+            fi
+            prev="$cmd"
+          done
+
+          if test "$prev" != 'sed 50q "[$]0"'; then
+            echo_test_string=`eval $prev`
+            export echo_test_string
+            exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}
+          else
+            # Oops.  We lost completely, so just stick with echo.
+            ECHO=echo
+          fi
+        fi
+      fi
+    fi
+  fi
+fi
+
+# Copy echo and quote the copy suitably for passing to libtool from
+# the Makefile, instead of quoting the original, which is used later.
+lt_ECHO=$ECHO
+if test "X$lt_ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then
+   lt_ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"
+fi
+
+AC_SUBST(lt_ECHO)
+])
+_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
+_LT_DECL([], [ECHO], [1],
+    [An echo program that does not interpret backslashes])
+])# _LT_PROG_ECHO_BACKSLASH
+
+
+# _LT_ENABLE_LOCK
+# ---------------
+m4_defun([_LT_ENABLE_LOCK],
+[AC_ARG_ENABLE([libtool-lock],
+  [AS_HELP_STRING([--disable-libtool-lock],
+    [avoid locking (might break parallel builds)])])
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.$ac_objext` in
+      *ELF-32*)
+        HPUX_IA64_MODE="32"
+        ;;
+      *ELF-64*)
+        HPUX_IA64_MODE="64"
+        ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '[#]line __oline__ "configure"' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    if test "$lt_cv_prog_gnu_ld" = yes; then
+      case `/usr/bin/file conftest.$ac_objext` in
+        *32-bit*)
+          LD="${LD-ld} -melf32bsmip"
+          ;;
+        *N32*)
+          LD="${LD-ld} -melf32bmipn32"
+          ;;
+        *64-bit*)
+          LD="${LD-ld} -melf64bmip"
+        ;;
+      esac
+    else
+      case `/usr/bin/file conftest.$ac_objext` in
+        *32-bit*)
+          LD="${LD-ld} -32"
+          ;;
+        *N32*)
+          LD="${LD-ld} -n32"
+          ;;
+        *64-bit*)
+          LD="${LD-ld} -64"
+          ;;
+      esac
+    fi
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.o` in
+      *32-bit*)
+        case $host in
+          x86_64-*kfreebsd*-gnu)
+            LD="${LD-ld} -m elf_i386_fbsd"
+            ;;
+          x86_64-*linux*)
+            LD="${LD-ld} -m elf_i386"
+            ;;
+          ppc64-*linux*|powerpc64-*linux*)
+            LD="${LD-ld} -m elf32ppclinux"
+            ;;
+          s390x-*linux*)
+            LD="${LD-ld} -m elf_s390"
+            ;;
+          sparc64-*linux*)
+            LD="${LD-ld} -m elf32_sparc"
+            ;;
+        esac
+        ;;
+      *64-bit*)
+        case $host in
+          x86_64-*kfreebsd*-gnu)
+            LD="${LD-ld} -m elf_x86_64_fbsd"
+            ;;
+          x86_64-*linux*)
+            LD="${LD-ld} -m elf_x86_64"
+            ;;
+          ppc*-*linux*|powerpc*-*linux*)
+            LD="${LD-ld} -m elf64ppc"
+            ;;
+          s390*-*linux*|s390*-*tpf*)
+            LD="${LD-ld} -m elf64_s390"
+            ;;
+          sparc*-*linux*)
+            LD="${LD-ld} -m elf64_sparc"
+            ;;
+        esac
+        ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
+    [AC_LANG_PUSH(C)
+     AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
+     AC_LANG_POP])
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+sparc*-*solaris*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*) LD="${LD-ld} -m elf64_sparc" ;;
+      *)
+        if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+          LD="${LD-ld} -64"
+        fi
+        ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+esac
+
+need_locks="$enable_libtool_lock"
+])# _LT_ENABLE_LOCK
+
+
+# _LT_CMD_OLD_ARCHIVE
+# -------------------
+m4_defun([_LT_CMD_OLD_ARCHIVE],
+[AC_CHECK_TOOL(AR, ar, false)
+test -z "$AR" && AR=ar
+test -z "$AR_FLAGS" && AR_FLAGS=cru
+_LT_DECL([], [AR], [1], [The archiver])
+_LT_DECL([], [AR_FLAGS], [1])
+
+AC_CHECK_TOOL(STRIP, strip, :)
+test -z "$STRIP" && STRIP=:
+_LT_DECL([], [STRIP], [1], [A symbol stripping program])
+
+AC_CHECK_TOOL(RANLIB, ranlib, :)
+test -z "$RANLIB" && RANLIB=:
+_LT_DECL([], [RANLIB], [1],
+    [Commands used to install an old-style archive])
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+fi
+_LT_DECL([], [old_postinstall_cmds], [2])
+_LT_DECL([], [old_postuninstall_cmds], [2])
+_LT_TAGDECL([], [old_archive_cmds], [2],
+    [Commands used to build an old-style archive])
+])# _LT_CMD_OLD_ARCHIVE
+
+
+# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#               [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------------------
+# Check whether the given compiler option works
+AC_DEFUN([_LT_COMPILER_OPTION],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+   m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$3"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       $2=yes
+     fi
+   fi
+   $RM conftest*
+])
+
+if test x"[$]$2" = xyes; then
+    m4_if([$5], , :, [$5])
+else
+    m4_if([$6], , :, [$6])
+fi
+])# _LT_COMPILER_OPTION
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])
+
+
+# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#                  [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------
+# Check whether the given linker option works
+AC_DEFUN([_LT_LINKER_OPTION],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $3"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&AS_MESSAGE_LOG_FD
+       $ECHO "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         $2=yes
+       fi
+     else
+       $2=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS="$save_LDFLAGS"
+])
+
+if test x"[$]$2" = xyes; then
+    m4_if([$4], , :, [$4])
+else
+    m4_if([$5], , :, [$5])
+fi
+])# _LT_LINKER_OPTION
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])
+
+
+# LT_CMD_MAX_LEN
+#---------------
+AC_DEFUN([LT_CMD_MAX_LEN],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+# find the maximum length of command line arguments
+AC_MSG_CHECKING([the maximum length of command line arguments])
+AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
+  i=0
+  teststring="ABCD"
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[         ]]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8 ; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test "X"`$SHELL [$]0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \
+                 = "XX$teststring$teststring"; } >/dev/null 2>&1 &&
+              test $i != 17 # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+])
+if test -n $lt_cv_sys_max_cmd_len ; then
+  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
+else
+  AC_MSG_RESULT(none)
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+_LT_DECL([], [max_cmd_len], [0],
+    [What is the maximum length of a command?])
+])# LT_CMD_MAX_LEN
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [])
+
+
+# _LT_HEADER_DLFCN
+# ----------------
+m4_defun([_LT_HEADER_DLFCN],
+[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
+])# _LT_HEADER_DLFCN
+
+
+# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
+#                      ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
+# ----------------------------------------------------------------
+m4_defun([_LT_TRY_DLOPEN_SELF],
+[m4_require([_LT_HEADER_DLFCN])dnl
+if test "$cross_compiling" = yes; then :
+  [$4]
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+[#line __oline__ "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL           RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL         DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL         0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW            RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW          DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW        RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW      DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW      0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+void fnord() { int i=42;}
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}]
+_LT_EOF
+  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) $1 ;;
+      x$lt_dlneed_uscore) $2 ;;
+      x$lt_dlunknown|x*) $3 ;;
+    esac
+  else :
+    # compilation failed
+    $3
+  fi
+fi
+rm -fr conftest*
+])# _LT_TRY_DLOPEN_SELF
+
+
+# LT_SYS_DLOPEN_SELF
+# ------------------
+AC_DEFUN([LT_SYS_DLOPEN_SELF],
+[m4_require([_LT_HEADER_DLFCN])dnl
+if test "x$enable_dlopen" != xyes; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32* | cegcc*)
+    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen_libs=
+    ;;
+
+  cygwin*)
+    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen_libs=
+    ;;
+
+  darwin*)
+  # if libdl is installed we need to link against it
+    AC_CHECK_LIB([dl], [dlopen],
+                [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
+    lt_cv_dlopen="dyld"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ])
+    ;;
+
+  *)
+    AC_CHECK_FUNC([shl_load],
+          [lt_cv_dlopen="shl_load"],
+      [AC_CHECK_LIB([dld], [shl_load],
+            [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"],
+        [AC_CHECK_FUNC([dlopen],
+              [lt_cv_dlopen="dlopen"],
+          [AC_CHECK_LIB([dl], [dlopen],
+                [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
+            [AC_CHECK_LIB([svld], [dlopen],
+                  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
+              [AC_CHECK_LIB([dld], [dld_link],
+                    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"])
+              ])
+            ])
+          ])
+        ])
+      ])
+    ;;
+  esac
+
+  if test "x$lt_cv_dlopen" != xno; then
+    enable_dlopen=yes
+  else
+    enable_dlopen=no
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS="$CPPFLAGS"
+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS="$LDFLAGS"
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS="$LIBS"
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    AC_CACHE_CHECK([whether a program can dlopen itself],
+          lt_cv_dlopen_self, [dnl
+          _LT_TRY_DLOPEN_SELF(
+            lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
+            lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
+    ])
+
+    if test "x$lt_cv_dlopen_self" = xyes; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
+          lt_cv_dlopen_self_static, [dnl
+          _LT_TRY_DLOPEN_SELF(
+            lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
+            lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
+      ])
+    fi
+
+    CPPFLAGS="$save_CPPFLAGS"
+    LDFLAGS="$save_LDFLAGS"
+    LIBS="$save_LIBS"
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+_LT_DECL([dlopen_support], [enable_dlopen], [0],
+         [Whether dlopen is supported])
+_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
+         [Whether dlopen of programs is supported])
+_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
+         [Whether dlopen of statically linked programs is supported])
+])# LT_SYS_DLOPEN_SELF
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [])
+
+
+# _LT_COMPILER_C_O([TAGNAME])
+# ---------------------------
+# Check to see if options -c and -o are simultaneously supported by compiler.
+# This macro does not hard code the compiler like AC_PROG_CC_C_O.
+m4_defun([_LT_COMPILER_C_O],
+[m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
+  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
+  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+     fi
+   fi
+   chmod u+w . 2>&AS_MESSAGE_LOG_FD
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+])
+_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
+        [Does compiler simultaneously support -c and -o options?])
+])# _LT_COMPILER_C_O
+
+
+# _LT_COMPILER_FILE_LOCKS([TAGNAME])
+# ----------------------------------
+# Check to see if we can do hard links to lock some files if needed
+m4_defun([_LT_COMPILER_FILE_LOCKS],
+[m4_require([_LT_ENABLE_LOCK])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+_LT_COMPILER_C_O([$1])
+
+hard_links="nottested"
+if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  AC_MSG_CHECKING([if we can lock with hard links])
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  AC_MSG_RESULT([$hard_links])
+  if test "$hard_links" = no; then
+    AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
+])# _LT_COMPILER_FILE_LOCKS
+
+
+# _LT_CHECK_OBJDIR
+# ----------------
+m4_defun([_LT_CHECK_OBJDIR],
+[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
+[rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null])
+objdir=$lt_cv_objdir
+_LT_DECL([], [objdir], [0],
+         [The name of the directory that contains temporary libtool files])dnl
+m4_pattern_allow([LT_OBJDIR])dnl
+AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/",
+  [Define to the sub-directory in which libtool stores uninstalled libraries.])
+])# _LT_CHECK_OBJDIR
+
+
+# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME])
+# --------------------------------------
+# Check hardcoding attributes.
+m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
+[AC_MSG_CHECKING([how to hardcode library paths into programs])
+_LT_TAGVAR(hardcode_action, $1)=
+if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
+   test -n "$_LT_TAGVAR(runpath_var, $1)" ||
+   test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then
+
+  # We can hardcode non-existent directories.
+  if test "$_LT_TAGVAR(hardcode_direct, $1)" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
+     test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then
+    # Linking always hardcodes the temporary library directory.
+    _LT_TAGVAR(hardcode_action, $1)=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    _LT_TAGVAR(hardcode_action, $1)=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  _LT_TAGVAR(hardcode_action, $1)=unsupported
+fi
+AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])
+
+if test "$_LT_TAGVAR(hardcode_action, $1)" = relink ||
+   test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+_LT_TAGDECL([], [hardcode_action], [0],
+    [How to hardcode a shared library path into an executable])
+])# _LT_LINKER_HARDCODE_LIBPATH
+
+
+# _LT_CMD_STRIPLIB
+# ----------------
+m4_defun([_LT_CMD_STRIPLIB],
+[m4_require([_LT_DECL_EGREP])
+striplib=
+old_striplib=
+AC_MSG_CHECKING([whether stripping libraries is possible])
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  AC_MSG_RESULT([yes])
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+  darwin*)
+    if test -n "$STRIP" ; then
+      striplib="$STRIP -x"
+      old_striplib="$STRIP -S"
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+    ;;
+  *)
+    AC_MSG_RESULT([no])
+    ;;
+  esac
+fi
+_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
+_LT_DECL([], [striplib], [1])
+])# _LT_CMD_STRIPLIB
+
+
+# _LT_SYS_DYNAMIC_LINKER([TAG])
+# -----------------------------
+# PORTME Fill in your ld.so characteristics
+m4_defun([_LT_SYS_DYNAMIC_LINKER],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_OBJDUMP])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_MSG_CHECKING([dynamic linker characteristics])
+m4_if([$1],
+        [], [
+if test "$GCC" = yes; then
+  case $host_os in
+    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
+    *) lt_awk_arg="/^libraries:/" ;;
+  esac
+  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if $ECHO "$lt_search_path_spec" | $GREP ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+  # Ok, now we have the path, separated by spaces, we can step through it
+  # and add multilib dir if necessary.
+  lt_tmp_lt_search_path_spec=
+  lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+  for lt_sys_path in $lt_search_path_spec; do
+    if test -d "$lt_sys_path/$lt_multi_os_dir"; then
+      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
+    else
+      test -d "$lt_sys_path" && \
+        lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+    fi
+  done
+  lt_search_path_spec=`$ECHO $lt_tmp_lt_search_path_spec | awk '
+BEGIN {RS=" "; FS="/|\n";} {
+  lt_foo="";
+  lt_count=0;
+  for (lt_i = NF; lt_i > 0; lt_i--) {
+    if ($lt_i != "" && $lt_i != ".") {
+      if ($lt_i == "..") {
+        lt_count++;
+      } else {
+        if (lt_count == 0) {
+          lt_foo="/" $lt_i lt_foo;
+        } else {
+          lt_count--;
+        }
+      }
+    }
+  }
+  if (lt_foo != "") { lt_freq[[lt_foo]]++; }
+  if (lt_freq[[lt_foo]] == 1) { print lt_foo; }
+}'`
+  sys_lib_search_path_spec=`$ECHO $lt_search_path_spec`
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi])
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix[[4-9]]*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[[01]] | aix4.[[01]].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+           echo ' yes '
+           echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+        :
+      else
+        can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$ECHO "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[[45]]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32* | yes,cegcc*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+m4_if([$1], [],[
+  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"])
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[[123]]*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[[01]]* | freebsdelf3.[[01]]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
+  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+interix[[3-9]]*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+        if test "$lt_cv_prog_gnu_ld" = yes; then
+                version_type=linux
+        else
+                version_type=irix
+        fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # Some binutils ld are patched to set DT_RUNPATH
+  save_LDFLAGS=$LDFLAGS
+  save_libdir=$libdir
+  eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \
+       LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+    [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],
+       [shlibpath_overrides_runpath=yes])])
+  LDFLAGS=$save_LDFLAGS
+  libdir=$save_libdir
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[   ]*hwcap[        ]/d;s/[:,      ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*)  need_version=yes ;;
+    *)                          need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[[89]] | openbsd2.[[89]].*)
+        shlibpath_overrides_runpath=no
+        ;;
+      *)
+        shlibpath_overrides_runpath=yes
+        ;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+        ;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+AC_MSG_RESULT([$dynamic_linker])
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
+  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+fi
+if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
+  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+fi
+
+_LT_DECL([], [variables_saved_for_relink], [1],
+    [Variables whose values should be saved in libtool wrapper scripts and
+    restored at link time])
+_LT_DECL([], [need_lib_prefix], [0],
+    [Do we need the "lib" prefix for modules?])
+_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
+_LT_DECL([], [version_type], [0], [Library versioning type])
+_LT_DECL([], [runpath_var], [0],  [Shared library runtime path variable])
+_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
+_LT_DECL([], [shlibpath_overrides_runpath], [0],
+    [Is shlibpath searched before the hard-coded library search path?])
+_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
+_LT_DECL([], [library_names_spec], [1],
+    [[List of archive names.  First name is the real one, the rest are links.
+    The last name is the one that the linker finds with -lNAME]])
+_LT_DECL([], [soname_spec], [1],
+    [[The coded name of the library, if different from the real name]])
+_LT_DECL([], [postinstall_cmds], [2],
+    [Command to use after installation of a shared archive])
+_LT_DECL([], [postuninstall_cmds], [2],
+    [Command to use after uninstallation of a shared archive])
+_LT_DECL([], [finish_cmds], [2],
+    [Commands used to finish a libtool library installation in a directory])
+_LT_DECL([], [finish_eval], [1],
+    [[As "finish_cmds", except a single script fragment to be evaled but
+    not shown]])
+_LT_DECL([], [hardcode_into_libs], [0],
+    [Whether we should hardcode library paths into libraries])
+_LT_DECL([], [sys_lib_search_path_spec], [2],
+    [Compile-time system search path for libraries])
+_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
+    [Run-time system search path for libraries])
+])# _LT_SYS_DYNAMIC_LINKER
+
+
+# _LT_PATH_TOOL_PREFIX(TOOL)
+# --------------------------
+# find a file program which can recognize shared library
+AC_DEFUN([_LT_PATH_TOOL_PREFIX],
+[m4_require([_LT_DECL_EGREP])dnl
+AC_MSG_CHECKING([for $1])
+AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
+[case $MAGIC_CMD in
+[[\\/*] |  ?:[\\/]*])
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+dnl $ac_dummy forces splitting on constant user-supplied paths.
+dnl POSIX.2 word splitting is done only on the output of word expansions,
+dnl not every word.  This closes a longstanding sh security hole.
+  ac_dummy="m4_if([$2], , $PATH, [$2])"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$1; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/$1"
+      if test -n "$file_magic_test_file"; then
+        case $deplibs_check_method in
+        "file_magic "*)
+          file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+            $EGREP "$file_magic_regex" > /dev/null; then
+            :
+          else
+            cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+          fi ;;
+        esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac])
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  AC_MSG_RESULT($MAGIC_CMD)
+else
+  AC_MSG_RESULT(no)
+fi
+_LT_DECL([], [MAGIC_CMD], [0],
+         [Used to examine libraries when file_magic_cmd begins with "file"])dnl
+])# _LT_PATH_TOOL_PREFIX
+
+# Old name:
+AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])
+
+
+# _LT_PATH_MAGIC
+# --------------
+# find a file program which can recognize a shared library
+m4_defun([_LT_PATH_MAGIC],
+[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
+  else
+    MAGIC_CMD=:
+  fi
+fi
+])# _LT_PATH_MAGIC
+
+
+# LT_PATH_LD
+# ----------
+# find the pathname to the GNU or non-GNU linker
+AC_DEFUN([LT_PATH_LD],
+[AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_DECL_EGREP])dnl
+
+AC_ARG_WITH([gnu-ld],
+    [AS_HELP_STRING([--with-gnu-ld],
+        [assume the C compiler uses GNU ld @<:@default=no@:>@])],
+    [test "$withval" = no || with_gnu_ld=yes],
+    [with_gnu_ld=no])dnl
+
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  AC_MSG_CHECKING([for ld used by $CC])
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [[\\/]]* | ?:[[\\/]]*)
+      re_direlt='/[[^/]][[^/]]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+        ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  AC_MSG_CHECKING([for GNU ld])
+else
+  AC_MSG_CHECKING([for non-GNU ld])
+fi
+AC_CACHE_VAL(lt_cv_path_LD,
+[if test -z "$LD"; then
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+        test "$with_gnu_ld" != no && break
+        ;;
+      *)
+        test "$with_gnu_ld" != yes && break
+        ;;
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi])
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  AC_MSG_RESULT($LD)
+else
+  AC_MSG_RESULT(no)
+fi
+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
+_LT_PATH_LD_GNU
+AC_SUBST([LD])
+
+_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
+])# LT_PATH_LD
+
+# Old names:
+AU_ALIAS([AM_PROG_LD], [LT_PATH_LD])
+AU_ALIAS([AC_PROG_LD], [LT_PATH_LD])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_PROG_LD], [])
+dnl AC_DEFUN([AC_PROG_LD], [])
+
+
+# _LT_PATH_LD_GNU
+#- --------------
+m4_defun([_LT_PATH_LD_GNU],
+[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
+[# I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac])
+with_gnu_ld=$lt_cv_prog_gnu_ld
+])# _LT_PATH_LD_GNU
+
+
+# _LT_CMD_RELOAD
+# --------------
+# find reload flag for linker
+#   -- PORTME Some linkers may need a different reload flag.
+m4_defun([_LT_CMD_RELOAD],
+[AC_CACHE_CHECK([for $LD option to reload object files],
+  lt_cv_ld_reload_flag,
+  [lt_cv_ld_reload_flag='-r'])
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  darwin*)
+    if test "$GCC" = yes; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+_LT_DECL([], [reload_flag], [1], [How to create reloadable object files])dnl
+_LT_DECL([], [reload_cmds], [2])dnl
+])# _LT_CMD_RELOAD
+
+
+# _LT_CHECK_MAGIC_METHOD
+# ----------------------
+# how to check for library dependencies
+#  -- PORTME fill in with the dynamic library characteristics
+m4_defun([_LT_CHECK_MAGIC_METHOD],
+[m4_require([_LT_DECL_EGREP])
+m4_require([_LT_DECL_OBJDUMP])
+AC_CACHE_CHECK([how to recognize dependent libraries],
+lt_cv_deplibs_check_method,
+[lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[[4-9]]*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[[45]]*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump',
+  # unless we find 'file', for example because we are cross-compiling.
+  if ( file / ) >/dev/null 2>&1; then
+    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+    lt_cv_file_magic_cmd='func_win32_libid'
+  else
+    lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+    lt_cv_file_magic_cmd='$OBJDUMP -f'
+  fi
+  ;;
+
+cegcc)
+  # use the weaker test based on 'objdump'. See mingw*.
+  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | dragonfly*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix[[3-9]]*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be Linux ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd* | netbsdelf*-gnu)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+*nto* | *qnx*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+openbsd*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+rdos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+tpf*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+])
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+_LT_DECL([], [deplibs_check_method], [1],
+    [Method to check whether dependent libraries are shared objects])
+_LT_DECL([], [file_magic_cmd], [1],
+    [Command to use when deplibs_check_method == "file_magic"])
+])# _LT_CHECK_MAGIC_METHOD
+
+
+# LT_PATH_NM
+# ----------
+# find the pathname to a BSD- or MS-compatible name lister
+AC_DEFUN([LT_PATH_NM],
+[AC_REQUIRE([AC_PROG_CC])dnl
+AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
+[if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM="$NM"
+else
+  lt_nm_to_check="${ac_tool_prefix}nm"
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS="$lt_save_ifs"
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm="$ac_dir/$lt_tmp_nm"
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+        # Check to see if the nm accepts a BSD-compat flag.
+        # Adding the `sed 1q' prevents false positives on HP-UX, which says:
+        #   nm: unknown option "B" ignored
+        # Tru64's nm complains that /dev/null is an invalid object file
+        case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+        */dev/null* | *'Invalid file or object type'*)
+          lt_cv_path_NM="$tmp_nm -B"
+          break
+          ;;
+        *)
+          case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+          */dev/null*)
+            lt_cv_path_NM="$tmp_nm -p"
+            break
+            ;;
+          *)
+            lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+            continue # so that we can try to find one that supports BSD flags
+            ;;
+          esac
+          ;;
+        esac
+      fi
+    done
+    IFS="$lt_save_ifs"
+  done
+  : ${lt_cv_path_NM=no}
+fi])
+if test "$lt_cv_path_NM" != "no"; then
+  NM="$lt_cv_path_NM"
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  AC_CHECK_TOOLS(DUMPBIN, ["dumpbin -symbols" "link -dump -symbols"], :)
+  AC_SUBST([DUMPBIN])
+  if test "$DUMPBIN" != ":"; then
+    NM="$DUMPBIN"
+  fi
+fi
+test -z "$NM" && NM=nm
+AC_SUBST([NM])
+_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl
+
+AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],
+  [lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:__oline__: $ac_compile\"" >&AS_MESSAGE_LOG_FD)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&AS_MESSAGE_LOG_FD
+  (eval echo "\"\$as_me:__oline__: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&AS_MESSAGE_LOG_FD
+  (eval echo "\"\$as_me:__oline__: output\"" >&AS_MESSAGE_LOG_FD)
+  cat conftest.out >&AS_MESSAGE_LOG_FD
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest*])
+])# LT_PATH_NM
+
+# Old names:
+AU_ALIAS([AM_PROG_NM], [LT_PATH_NM])
+AU_ALIAS([AC_PROG_NM], [LT_PATH_NM])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_PROG_NM], [])
+dnl AC_DEFUN([AC_PROG_NM], [])
+
+
+# LT_LIB_M
+# --------
+# check for math library
+AC_DEFUN([LT_LIB_M],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+LIBM=
+case $host in
+*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)
+  # These system don't have libm, or don't need it
+  ;;
+*-ncr-sysv4.3*)
+  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
+  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
+  ;;
+*)
+  AC_CHECK_LIB(m, cos, LIBM="-lm")
+  ;;
+esac
+AC_SUBST([LIBM])
+])# LT_LIB_M
+
+# Old name:
+AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_CHECK_LIBM], [])
+
+
+# _LT_COMPILER_NO_RTTI([TAGNAME])
+# -------------------------------
+m4_defun([_LT_COMPILER_NO_RTTI],
+[m4_require([_LT_TAG_COMPILER])dnl
+
+_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+
+if test "$GCC" = yes; then
+  _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+
+  _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
+    lt_cv_prog_compiler_rtti_exceptions,
+    [-fno-rtti -fno-exceptions], [],
+    [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
+fi
+_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
+        [Compiler flag to turn off builtin functions])
+])# _LT_COMPILER_NO_RTTI
+
+
+# _LT_CMD_GLOBAL_SYMBOLS
+# ----------------------
+m4_defun([_LT_CMD_GLOBAL_SYMBOLS],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+AC_REQUIRE([LT_PATH_LD])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+AC_MSG_CHECKING([command to parse $NM output from $compiler object])
+AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
+[
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[[BCDEGRST]]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[[BCDT]]'
+  ;;
+cygwin* | mingw* | pw32* | cegcc*)
+  symcode='[[ABCDGISTW]]'
+  ;;
+hpux*)
+  if test "$host_cpu" = ia64; then
+    symcode='[[ABCDEGRST]]'
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[[BCDEGRST]]'
+  ;;
+osf*)
+  symcode='[[BCDEGQRST]]'
+  ;;
+solaris*)
+  symcode='[[BDRT]]'
+  ;;
+sco3.2v5*)
+  symcode='[[DT]]'
+  ;;
+sysv4.2uw2*)
+  symcode='[[DT]]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[[ABDT]]'
+  ;;
+sysv4)
+  symcode='[[DFNSTU]]'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[[ABCDGIRSTW]]' ;;
+esac
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p'"
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"lib\2\", (void *) \&\2},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+    # Fake it for dumpbin and say T for any non-static function
+    # and D for any global variable.
+    # Also find C++ and __fastcall symbols from MSVC++,
+    # which start with @ or ?.
+    lt_cv_sys_global_symbol_pipe="$AWK ['"\
+"     {last_section=section; section=\$ 3};"\
+"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     \$ 0!~/External *\|/{next};"\
+"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+"     {if(hide[section]) next};"\
+"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
+"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
+"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
+"     ' prfx=^$ac_symprfx]"
+  else
+    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[     ]]\($symcode$symcode*\)[[       ]][[    ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+  fi
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if AC_TRY_EVAL(ac_compile); then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+        mv -f "$nlist"T "$nlist"
+      else
+        rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+        if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+          cat <<_LT_EOF > conftest.$ac_ext
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+          # Now generate the symbol file.
+          eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+          cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols.  */
+const struct {
+  const char *name;
+  void       *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[[]] =
+{
+  { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+          $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+          cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+          # Now try linking the two files.
+          mv conftest.$ac_objext conftstm.$ac_objext
+          lt_save_LIBS="$LIBS"
+          lt_save_CFLAGS="$CFLAGS"
+          LIBS="conftstm.$ac_objext"
+          CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
+          if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
+            pipe_works=yes
+          fi
+          LIBS="$lt_save_LIBS"
+          CFLAGS="$lt_save_CFLAGS"
+        else
+          echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
+        fi
+      else
+        echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
+    fi
+  else
+    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
+    cat conftest.$ac_ext >&5
+  fi
+  rm -rf conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test "$pipe_works" = yes; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+])
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  AC_MSG_RESULT(failed)
+else
+  AC_MSG_RESULT(ok)
+fi
+
+_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
+    [Take the output of nm and produce a listing of raw symbols and C names])
+_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
+    [Transform the output of nm in a proper C declaration])
+_LT_DECL([global_symbol_to_c_name_address],
+    [lt_cv_sys_global_symbol_to_c_name_address], [1],
+    [Transform the output of nm in a C name address pair])
+_LT_DECL([global_symbol_to_c_name_address_lib_prefix],
+    [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
+    [Transform the output of nm in a C name address pair when lib prefix is needed])
+]) # _LT_CMD_GLOBAL_SYMBOLS
+
+
+# _LT_COMPILER_PIC([TAGNAME])
+# ---------------------------
+m4_defun([_LT_COMPILER_PIC],
+[m4_require([_LT_TAG_COMPILER])dnl
+_LT_TAGVAR(lt_prog_compiler_wl, $1)=
+_LT_TAGVAR(lt_prog_compiler_pic, $1)=
+_LT_TAGVAR(lt_prog_compiler_static, $1)=
+
+AC_MSG_CHECKING([for $compiler option to produce PIC])
+m4_if([$1], [CXX], [
+  # C++ specific cases for pic, static, wl, etc.
+  if test "$GXX" = yes; then
+    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+        # AIX 5 now supports IA64 processor
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the `-m68020' flag to GCC prevents building anything better,
+            # like `-m68040'.
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | cygwin* | os2* | pw32* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      m4_if([$1], [GCJ], [],
+        [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+      ;;
+    interix[[3-9]]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+        ;;
+      *)
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        ;;
+      esac
+      ;;
+    *qnx* | *nto*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+      ;;
+    *)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix[[4-9]]*)
+        # All AIX code is PIC.
+        if test "$host_cpu" = ia64; then
+          # AIX 5 now supports IA64 processor
+          _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+        else
+          _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+        fi
+        ;;
+      chorus*)
+        case $cc_basename in
+        cxch68*)
+          # Green Hills C++ Compiler
+          # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+          ;;
+        esac
+        ;;
+      dgux*)
+        case $cc_basename in
+          ec++*)
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+            ;;
+          ghcx*)
+            # Green Hills C++ Compiler
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      freebsd* | dragonfly*)
+        # FreeBSD uses GNU C++
+        ;;
+      hpux9* | hpux10* | hpux11*)
+        case $cc_basename in
+          CC*)
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+            if test "$host_cpu" != ia64; then
+              _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+            fi
+            ;;
+          aCC*)
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+            case $host_cpu in
+            hppa*64*|ia64*)
+              # +Z the default
+              ;;
+            *)
+              _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+              ;;
+            esac
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      interix*)
+        # This is c89, which is MS Visual C++ (no shared libs)
+        # Anyone wants to do a port?
+        ;;
+      irix5* | irix6* | nonstopux*)
+        case $cc_basename in
+          CC*)
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+            # CC pic flag -KPIC is the default.
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      linux* | k*bsd*-gnu | kopensolaris*-gnu)
+        case $cc_basename in
+          KCC*)
+            # KAI C++ Compiler
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+            ;;
+          ecpc* )
+            # old Intel C++ for x86_64 which still supported -KPIC.
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+            ;;
+          icpc* )
+            # Intel C++, used to be incompatible with GCC.
+            # ICC 10 doesn't accept -KPIC any more.
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+            ;;
+          pgCC* | pgcpp*)
+            # Portland Group C++ compiler
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+            ;;
+          cxx*)
+            # Compaq C++
+            # Make sure the PIC flag is empty.  It appears that all Alpha
+            # Linux and Compaq Tru64 Unix objects are PIC.
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+            ;;
+          xlc* | xlC*)
+            # IBM XL 8.0 on PPC
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
+            ;;
+          *)
+            case `$CC -V 2>&1 | sed 5q` in
+            *Sun\ C*)
+              # Sun C++ 5.9
+              _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+              _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+              _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+              ;;
+            esac
+            ;;
+        esac
+        ;;
+      lynxos*)
+        ;;
+      m88k*)
+        ;;
+      mvs*)
+        case $cc_basename in
+          cxx*)
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      netbsd* | netbsdelf*-gnu)
+        ;;
+      *qnx* | *nto*)
+        # QNX uses GNU C++, but need to define -shared option too, otherwise
+        # it will coredump.
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+        ;;
+      osf3* | osf4* | osf5*)
+        case $cc_basename in
+          KCC*)
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+            ;;
+          RCC*)
+            # Rational C++ 2.4.1
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+            ;;
+          cxx*)
+            # Digital/Compaq C++
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            # Make sure the PIC flag is empty.  It appears that all Alpha
+            # Linux and Compaq Tru64 Unix objects are PIC.
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      psos*)
+        ;;
+      solaris*)
+        case $cc_basename in
+          CC*)
+            # Sun C++ 4.2, 5.x and Centerline C++
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+            ;;
+          gcx*)
+            # Green Hills C++ Compiler
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      sunos4*)
+        case $cc_basename in
+          CC*)
+            # Sun C++ 4.x
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+            ;;
+          lcc*)
+            # Lucid
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+        case $cc_basename in
+          CC*)
+            _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+            _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+            ;;
+        esac
+        ;;
+      tandem*)
+        case $cc_basename in
+          NCC*)
+            # NonStop-UX NCC 3.20
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+            ;;
+          *)
+            ;;
+        esac
+        ;;
+      vxworks*)
+        ;;
+      *)
+        _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+        ;;
+    esac
+  fi
+],
+[
+  if test "$GCC" = yes; then
+    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+        # AIX 5 now supports IA64 processor
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the `-m68020' flag to GCC prevents building anything better,
+            # like `-m68040'.
+            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      m4_if([$1], [GCJ], [],
+        [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+        # +Z the default
+        ;;
+      *)
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        ;;
+      esac
+      ;;
+
+    interix[[3-9]]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      enable_shared=no
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+
+    *)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      if test "$host_cpu" = ia64; then
+        # AIX 5 now supports IA64 processor
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      else
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      m4_if([$1], [GCJ], [],
+        [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+        # +Z the default
+        ;;
+      *)
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+        ;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC (with -KPIC) is the default.
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      case $cc_basename in
+      # old Intel for x86_64 which still supported -KPIC.
+      ecc*)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
+      # icc used to be incompatible with GCC.
+      # ICC 10 doesn't accept -KPIC any more.
+      icc* | ifort*)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
+      # Lahey Fortran 8.1.
+      lf95*)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='--static'
+        ;;
+      pgcc* | pgf77* | pgf90* | pgf95*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+        # which looks to be a dead project)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+        ;;
+      ccc*)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        # All Alpha code is PIC.
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+        ;;
+      xl*)
+        # IBM XL C 8.0/Fortran 10.1 on PPC
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
+        ;;
+      *)
+        case `$CC -V 2>&1 | sed 5q` in
+        *Sun\ C*)
+          # Sun C 5.9
+          _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+          _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+          _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+          ;;
+        *Sun\ F*)
+          # Sun Fortran 8.3 passes all unrecognized flags to the linker
+          _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+          _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+          _LT_TAGVAR(lt_prog_compiler_wl, $1)=''
+          ;;
+        esac
+        ;;
+      esac
+      ;;
+
+    newsos6)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+      ;;
+
+    osf3* | osf4* | osf5*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # All OSF/1 code is PIC.
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    rdos*)
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    solaris*)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95*)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
+      *)
+        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
+        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    unicos*)
+      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+
+    uts4*)
+      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    *)
+      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+    esac
+  fi
+])
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+    ;;
+  *)
+    _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
+    ;;
+esac
+AC_MSG_RESULT([$_LT_TAGVAR(lt_prog_compiler_pic, $1)])
+_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
+        [How to pass a linker flag through the compiler])
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
+  _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works],
+    [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)],
+    [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
+    [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in
+     "" | " "*) ;;
+     *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;;
+     esac],
+    [_LT_TAGVAR(lt_prog_compiler_pic, $1)=
+     _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
+fi
+_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
+        [Additional compiler flags for building library objects])
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\"
+_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
+  _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1),
+  $lt_tmp_static_flag,
+  [],
+  [_LT_TAGVAR(lt_prog_compiler_static, $1)=])
+_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
+        [Compiler flag to prevent dynamic linking])
+])# _LT_COMPILER_PIC
+
+
+# _LT_LINKER_SHLIBS([TAGNAME])
+# ----------------------------
+# See if the linker supports building shared libraries.
+m4_defun([_LT_LINKER_SHLIBS],
+[AC_REQUIRE([LT_PATH_LD])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+m4_if([$1], [CXX], [
+  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  case $host_os in
+  aix[[4-9]]*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to AIX nm, but means don't demangle with GNU nm
+    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+    else
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
+  ;;
+  cygwin* | mingw* | cegcc*)
+    _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;/^.*[[ ]]__nm__/s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  linux* | k*bsd*-gnu)
+    _LT_TAGVAR(link_all_deplibs, $1)=no
+  ;;
+  *)
+    _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  esac
+  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
+], [
+  runpath_var=
+  _LT_TAGVAR(allow_undefined_flag, $1)=
+  _LT_TAGVAR(always_export_symbols, $1)=no
+  _LT_TAGVAR(archive_cmds, $1)=
+  _LT_TAGVAR(archive_expsym_cmds, $1)=
+  _LT_TAGVAR(compiler_needs_object, $1)=no
+  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+  _LT_TAGVAR(export_dynamic_flag_spec, $1)=
+  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  _LT_TAGVAR(hardcode_automatic, $1)=no
+  _LT_TAGVAR(hardcode_direct, $1)=no
+  _LT_TAGVAR(hardcode_direct_absolute, $1)=no
+  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+  _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+  _LT_TAGVAR(hardcode_libdir_separator, $1)=
+  _LT_TAGVAR(hardcode_minus_L, $1)=no
+  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+  _LT_TAGVAR(inherit_rpath, $1)=no
+  _LT_TAGVAR(link_all_deplibs, $1)=unknown
+  _LT_TAGVAR(module_cmds, $1)=
+  _LT_TAGVAR(module_expsym_cmds, $1)=
+  _LT_TAGVAR(old_archive_from_new_cmds, $1)=
+  _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)=
+  _LT_TAGVAR(thread_safe_flag_spec, $1)=
+  _LT_TAGVAR(whole_archive_flag_spec, $1)=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  _LT_TAGVAR(include_expsyms, $1)=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  # Exclude shared library initialization/finalization symbols.
+dnl Note also adjust exclude_expsyms for C++ above.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  linux* | k*bsd*-gnu)
+    _LT_TAGVAR(link_all_deplibs, $1)=no
+    ;;
+  esac
+
+  _LT_TAGVAR(ld_shlibs, $1)=yes
+  if test "$with_gnu_ld" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+      _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+    else
+      _LT_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v 2>&1` in
+      *GNU\ gold*) supports_anon_versioning=yes ;;
+      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix[[3-9]]*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)=''
+        ;;
+      m68k)
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes
+        ;;
+      esac
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+        _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+        # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+        # support --undefined.  This deserves some investigation.  FIXME
+        _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+      # as there is no search path for DLLs.
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_TAGVAR(always_export_symbols, $1)=no
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+        # If the export-symbols file already is a .def file (1st line
+        # is EXPORTS), use it as is; otherwise, prepend...
+        _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    interix[[3-9]]*)
+      _LT_TAGVAR(hardcode_direct, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      tmp_diet=no
+      if test "$host_os" = linux-dietlibc; then
+        case $cc_basename in
+          diet\ *) tmp_diet=yes;;       # linux-dietlibc with static linking (!diet-dyn)
+        esac
+      fi
+      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+         && test "$tmp_diet" = no
+      then
+        tmp_addflag=
+        tmp_sharedflag='-shared'
+        case $cc_basename,$host_cpu in
+        pgcc*)                          # Portland Group C compiler
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
+          tmp_addflag=' $pic_flag'
+          ;;
+        pgf77* | pgf90* | pgf95*)       # Portland Group f77 and f90 compilers
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
+          tmp_addflag=' $pic_flag -Mnomain' ;;
+        ecc*,ia64* | icc*,ia64*)        # Intel C compiler on ia64
+          tmp_addflag=' -i_dynamic' ;;
+        efc*,ia64* | ifort*,ia64*)      # Intel Fortran compiler on ia64
+          tmp_addflag=' -i_dynamic -nofor_main' ;;
+        ifc* | ifort*)                  # Intel Fortran compiler
+          tmp_addflag=' -nofor_main' ;;
+        lf95*)                          # Lahey Fortran 8.1
+          _LT_TAGVAR(whole_archive_flag_spec, $1)=
+          tmp_sharedflag='--shared' ;;
+        xl[[cC]]*)                      # IBM XL C 8.0 on PPC (deal with xlf below)
+          tmp_sharedflag='-qmkshrobj'
+          tmp_addflag= ;;
+        esac
+        case `$CC -V 2>&1 | sed 5q` in
+        *Sun\ C*)                       # Sun C 5.9
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
+          _LT_TAGVAR(compiler_needs_object, $1)=yes
+          tmp_sharedflag='-G' ;;
+        *Sun\ F*)                       # Sun Fortran 8.3
+          tmp_sharedflag='-G' ;;
+        esac
+        _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+        if test "x$supports_anon_versioning" = xyes; then
+          _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+        fi
+
+        case $cc_basename in
+        xlf*)
+          # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+          _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'
+          _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -o $lib'
+          if test "x$supports_anon_versioning" = xyes; then
+            _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $compiler_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+          fi
+          ;;
+        esac
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+        _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+        wlarc=
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*)
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+        ;;
+        *)
+          # For security reasons, it is highly recommended that you always
+          # use absolute paths for naming shared libraries, and exclude the
+          # DT_RUNPATH tag from executables and libraries.  But doing so
+          # requires that you compile everything twice, which is a pain.
+          if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+          else
+            _LT_TAGVAR(ld_shlibs, $1)=no
+          fi
+        ;;
+      esac
+      ;;
+
+    sunos4*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+    esac
+
+    if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then
+      runpath_var=
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)=
+      _LT_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_TAGVAR(always_export_symbols, $1)=yes
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+        # Neither direct hardcoding nor static linking is supported with a
+        # broken collect2.
+        _LT_TAGVAR(hardcode_direct, $1)=unsupported
+      fi
+      ;;
+
+    aix[[4-9]]*)
+      if test "$host_cpu" = ia64; then
+        # On IA64, the linker does run time linking by default, so we don't
+        # have to do anything special.
+        aix_use_runtimelinking=no
+        exp_sym_flag='-Bexport'
+        no_entry_flag=""
+      else
+        # If we're using GNU nm, then we don't want the "-C" option.
+        # -C means demangle to AIX nm, but means don't demangle with GNU nm
+        if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+          _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+        else
+          _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+        fi
+        aix_use_runtimelinking=no
+
+        # Test if we are trying to use run time linking or normal
+        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+        # need to do runtime linking.
+        case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
+          for ld_flag in $LDFLAGS; do
+          if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+            aix_use_runtimelinking=yes
+            break
+          fi
+          done
+          ;;
+        esac
+
+        exp_sym_flag='-bexport'
+        no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      _LT_TAGVAR(archive_cmds, $1)=''
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
+
+      if test "$GCC" = yes; then
+        case $host_os in aix4.[[012]]|aix4.[[012]].*)
+        # We only want to do this on AIX 4.2 and lower, the check
+        # below for broken collect2 doesn't work under 4.3+
+          collect2name=`${CC} -print-prog-name=collect2`
+          if test -f "$collect2name" &&
+           strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+          then
+          # We have reworked collect2
+          :
+          else
+          # We have old collect2
+          _LT_TAGVAR(hardcode_direct, $1)=unsupported
+          # It fails to find uninstalled libraries when the uninstalled
+          # path is not listed in the libpath.  Setting hardcode_minus_L
+          # to unsupported forces relinking
+          _LT_TAGVAR(hardcode_minus_L, $1)=yes
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+          _LT_TAGVAR(hardcode_libdir_separator, $1)=
+          fi
+          ;;
+        esac
+        shared_flag='-shared'
+        if test "$aix_use_runtimelinking" = yes; then
+          shared_flag="$shared_flag "'${wl}-G'
+        fi
+        _LT_TAGVAR(link_all_deplibs, $1)=no
+      else
+        # not using gcc
+        if test "$host_cpu" = ia64; then
+        # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+        # chokes on -Wl,-G. The following line is correct:
+          shared_flag='-G'
+        else
+          if test "$aix_use_runtimelinking" = yes; then
+            shared_flag='${wl}-G'
+          else
+            shared_flag='${wl}-bM:SRE'
+          fi
+        fi
+      fi
+
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      _LT_TAGVAR(always_export_symbols, $1)=yes
+      if test "$aix_use_runtimelinking" = yes; then
+        # Warning - without using the other runtime loading flags (-brtl),
+        # -berok will link without error, but may produce a broken library.
+        _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+        _LT_SYS_MODULE_PATH_AIX
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+      else
+        if test "$host_cpu" = ia64; then
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+          _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+          _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+        else
+         # Determine the default libpath from the value encoded in an
+         # empty executable.
+         _LT_SYS_MODULE_PATH_AIX
+         _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+          # Warning - without using the other run time loading flags,
+          # -berok will link without error, but may produce a broken library.
+          _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+          _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+          # Exported symbols can be pulled into shared objects from archives
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+          _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+          # This is similar to how AIX traditionally builds its shared libraries.
+          _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+        fi
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)=''
+        ;;
+      m68k)
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes
+        ;;
+      esac
+      ;;
+
+    bsdi[[45]]*)
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `$ECHO "X$deplibs" | $Xsed -e '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+      # FIXME: Should let the user specify the lib program.
+      _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'
+      _LT_TAGVAR(fix_srcfile_path, $1)='`cygpath -w "$srcfile"`'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      ;;
+
+    darwin* | rhapsody*)
+      _LT_DARWIN_LINKER_FEATURES($1)
+      ;;
+
+    dgux*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    freebsd1*)
+      _LT_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | dragonfly*)
+      _LT_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+        _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      ;;
+
+    hpux10*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test "$with_gnu_ld" = no; then
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+        _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+        _LT_TAGVAR(hardcode_direct, $1)=yes
+        _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+        # hardcode_minus_L: Not really in the search PATH,
+        # but as the default location of the library.
+        _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+        case $host_cpu in
+        hppa*64*)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        ia64*)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        *)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        esac
+      else
+        case $host_cpu in
+        hppa*64*)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        ia64*)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        *)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        esac
+      fi
+      if test "$with_gnu_ld" = no; then
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+        case $host_cpu in
+        hppa*64*|ia64*)
+          _LT_TAGVAR(hardcode_direct, $1)=no
+          _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+          ;;
+        *)
+          _LT_TAGVAR(hardcode_direct, $1)=yes
+          _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+          _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+
+          # hardcode_minus_L: Not really in the search PATH,
+          # but as the default location of the library.
+          _LT_TAGVAR(hardcode_minus_L, $1)=yes
+          ;;
+        esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+        # Try to use the -exported_symbol ld option, if it does not
+        # work, assume that -exports_file does not work either and
+        # implicitly export all symbols.
+        save_LDFLAGS="$LDFLAGS"
+        LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
+        AC_LINK_IFELSE(int foo(void) {},
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+        )
+        LDFLAGS="$save_LDFLAGS"
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+      fi
+      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_TAGVAR(inherit_rpath, $1)=yes
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+        _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    newsos6)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *nto* | *qnx*)
+      ;;
+
+    openbsd*)
+      if test -f /usr/libexec/ld.so; then
+        _LT_TAGVAR(hardcode_direct, $1)=yes
+        _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+        _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+        if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+          _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+        else
+          case $host_os in
+           openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
+             _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+             _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+             ;;
+           *)
+             _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+             _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+             ;;
+          esac
+        fi
+      else
+        _LT_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    os2*)
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$ECHO DATA >> $output_objdir/$libname.def~$ECHO " SINGLE NONSHARED" >> $output_objdir/$libname.def~$ECHO EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+        _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+        _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    osf4* | osf5*)      # as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+        _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      else
+        _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+        $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
+
+        # Both c and cxx compiler support -rpath directly
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+      fi
+      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    solaris*)
+      _LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
+      if test "$GCC" = yes; then
+        wlarc='${wl}'
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $CC -shared ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+      else
+        case `$CC -V 2>&1` in
+        *"Compilers 5.0"*)
+          wlarc=''
+          _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+          _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+          ;;
+        *)
+          wlarc='${wl}'
+          _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+          _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+          ;;
+        esac
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      case $host_os in
+      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+      *)
+        # The compiler driver will combine and reorder linker options,
+        # but understands `-z linker_flag'.  GCC discards it without `$wl',
+        # but is careful enough not to reorder.
+        # Supported since Solaris 2.6 (maybe 2.5.1?)
+        if test "$GCC" = yes; then
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+        else
+          _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
+        fi
+        ;;
+      esac
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+        # Use $CC to link under sequent, because it throws in some extra .o
+        # files that make .init and .fini sections work.
+        _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_direct, $1)=yes
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+        sni)
+          _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+          _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true???
+        ;;
+        siemens)
+          ## LD is ld it makes a PLAMLIB
+          ## CC just makes a GrossModule.
+          _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+          _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
+          _LT_TAGVAR(hardcode_direct, $1)=no
+        ;;
+        motorola)
+          _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+          _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
+        ;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4.3*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+        _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+        _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+        runpath_var=LD_RUN_PATH
+        hardcode_runpath_var=yes
+        _LT_TAGVAR(ld_shlibs, $1)=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We can NOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
+      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_TAGVAR(link_all_deplibs, $1)=yes
+      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+        _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      _LT_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    esac
+
+    if test x$host_vendor = xsni; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym'
+        ;;
+      esac
+    fi
+  fi
+])
+AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
+test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld
+
+_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
+_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
+_LT_DECL([], [extract_expsyms_cmds], [2],
+    [The commands to extract the exported symbol list from a shared archive])
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in
+x|xyes)
+  # Assume -lc should be added
+  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $_LT_TAGVAR(archive_cmds, $1) in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      AC_MSG_CHECKING([whether -lc should be explicitly linked in])
+      $RM conftest*
+      echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)
+        pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)
+        _LT_TAGVAR(allow_undefined_flag, $1)=
+        if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
+        then
+          _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+        else
+          _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+        fi
+        _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $RM conftest*
+      AC_MSG_RESULT([$_LT_TAGVAR(archive_cmds_need_lc, $1)])
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
+    [Whether or not to add -lc for building shared libraries])
+_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
+    [enable_shared_with_static_runtimes], [0],
+    [Whether or not to disallow shared libs when runtime libs are static])
+_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
+    [Compiler flag to allow reflexive dlopens])
+_LT_TAGDECL([], [whole_archive_flag_spec], [1],
+    [Compiler flag to generate shared objects directly from archives])
+_LT_TAGDECL([], [compiler_needs_object], [1],
+    [Whether the compiler copes with passing no objects directly])
+_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
+    [Create an old-style archive from a shared archive])
+_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
+    [Create a temporary old-style archive to link instead of a shared archive])
+_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
+_LT_TAGDECL([], [archive_expsym_cmds], [2])
+_LT_TAGDECL([], [module_cmds], [2],
+    [Commands used to build a loadable module if different from building
+    a shared archive.])
+_LT_TAGDECL([], [module_expsym_cmds], [2])
+_LT_TAGDECL([], [with_gnu_ld], [1],
+    [Whether we are building with GNU ld or not])
+_LT_TAGDECL([], [allow_undefined_flag], [1],
+    [Flag that allows shared libraries with undefined symbols to be built])
+_LT_TAGDECL([], [no_undefined_flag], [1],
+    [Flag that enforces no undefined symbols])
+_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
+    [Flag to hardcode $libdir into a binary during linking.
+    This must work even if $libdir does not exist])
+_LT_TAGDECL([], [hardcode_libdir_flag_spec_ld], [1],
+    [[If ld is used when linking, flag to hardcode $libdir into a binary
+    during linking.  This must work even if $libdir does not exist]])
+_LT_TAGDECL([], [hardcode_libdir_separator], [1],
+    [Whether we need a single "-rpath" flag with a separated argument])
+_LT_TAGDECL([], [hardcode_direct], [0],
+    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+    DIR into the resulting binary])
+_LT_TAGDECL([], [hardcode_direct_absolute], [0],
+    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+    DIR into the resulting binary and the resulting library dependency is
+    "absolute", i.e impossible to change by setting ${shlibpath_var} if the
+    library is relocated])
+_LT_TAGDECL([], [hardcode_minus_L], [0],
+    [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+    into the resulting binary])
+_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
+    [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+    into the resulting binary])
+_LT_TAGDECL([], [hardcode_automatic], [0],
+    [Set to "yes" if building a shared library automatically hardcodes DIR
+    into the library and all subsequent libraries and executables linked
+    against it])
+_LT_TAGDECL([], [inherit_rpath], [0],
+    [Set to yes if linker adds runtime paths of dependent libraries
+    to runtime path list])
+_LT_TAGDECL([], [link_all_deplibs], [0],
+    [Whether libtool must link a program against all its dependency libraries])
+_LT_TAGDECL([], [fix_srcfile_path], [1],
+    [Fix the shell variable $srcfile for the compiler])
+_LT_TAGDECL([], [always_export_symbols], [0],
+    [Set to "yes" if exported symbols are required])
+_LT_TAGDECL([], [export_symbols_cmds], [2],
+    [The commands to list exported symbols])
+_LT_TAGDECL([], [exclude_expsyms], [1],
+    [Symbols that should not be listed in the preloaded symbols])
+_LT_TAGDECL([], [include_expsyms], [1],
+    [Symbols that must always be exported])
+_LT_TAGDECL([], [prelink_cmds], [2],
+    [Commands necessary for linking programs (against libraries) with templates])
+_LT_TAGDECL([], [file_list_spec], [1],
+    [Specify filename containing input files])
+dnl FIXME: Not yet implemented
+dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
+dnl    [Compiler flag to generate thread safe objects])
+])# _LT_LINKER_SHLIBS
+
+
+# _LT_LANG_C_CONFIG([TAG])
+# ------------------------
+# Ensure that the configuration variables for a C compiler are suitably
+# defined.  These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_C_CONFIG],
+[m4_require([_LT_DECL_EGREP])dnl
+lt_save_CC="$CC"
+AC_LANG_PUSH(C)
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+_LT_TAG_COMPILER
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  _LT_COMPILER_NO_RTTI($1)
+  _LT_COMPILER_PIC($1)
+  _LT_COMPILER_C_O($1)
+  _LT_COMPILER_FILE_LOCKS($1)
+  _LT_LINKER_SHLIBS($1)
+  _LT_SYS_DYNAMIC_LINKER($1)
+  _LT_LINKER_HARDCODE_LIBPATH($1)
+  LT_SYS_DLOPEN_SELF
+  _LT_CMD_STRIPLIB
+
+  # Report which library types will actually be built
+  AC_MSG_CHECKING([if libtool supports shared libraries])
+  AC_MSG_RESULT([$can_build_shared])
+
+  AC_MSG_CHECKING([whether to build shared libraries])
+  test "$can_build_shared" = "no" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case $host_os in
+  aix3*)
+    test "$enable_shared" = yes && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix[[4-9]]*)
+    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+      test "$enable_shared" = yes && enable_static=no
+    fi
+    ;;
+  esac
+  AC_MSG_RESULT([$enable_shared])
+
+  AC_MSG_CHECKING([whether to build static libraries])
+  # Make sure either enable_shared or enable_static is yes.
+  test "$enable_shared" = yes || enable_static=yes
+  AC_MSG_RESULT([$enable_static])
+
+  _LT_CONFIG($1)
+fi
+AC_LANG_POP
+CC="$lt_save_CC"
+])# _LT_LANG_C_CONFIG
+
+
+# _LT_PROG_CXX
+# ------------
+# Since AC_PROG_CXX is broken, in that it returns g++ if there is no c++
+# compiler, we have our own version here.
+m4_defun([_LT_PROG_CXX],
+[
+pushdef([AC_MSG_ERROR], [_lt_caught_CXX_error=yes])
+AC_PROG_CXX
+if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+    (test "X$CXX" != "Xg++"))) ; then
+  AC_PROG_CXXCPP
+else
+  _lt_caught_CXX_error=yes
+fi
+popdef([AC_MSG_ERROR])
+])# _LT_PROG_CXX
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([_LT_PROG_CXX], [])
+
+
+# _LT_LANG_CXX_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a C++ compiler are suitably
+# defined.  These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_CXX_CONFIG],
+[AC_REQUIRE([_LT_PROG_CXX])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_EGREP])dnl
+
+AC_LANG_PUSH(C++)
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(compiler_needs_object, $1)=no
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the CXX compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_caught_CXX_error" != yes; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="int some_variable = 0;"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+  _LT_TAG_COMPILER
+
+  # save warnings/boilerplate of simple test code
+  _LT_COMPILER_BOILERPLATE
+  _LT_LINKER_BOILERPLATE
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC=$CC
+  lt_save_LD=$LD
+  lt_save_GCC=$GCC
+  GCC=$GXX
+  lt_save_with_gnu_ld=$with_gnu_ld
+  lt_save_path_LD=$lt_cv_path_LD
+  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+  else
+    $as_unset lt_cv_prog_gnu_ld
+  fi
+  if test -n "${lt_cv_path_LDCXX+set}"; then
+    lt_cv_path_LD=$lt_cv_path_LDCXX
+  else
+    $as_unset lt_cv_path_LD
+  fi
+  test -z "${LDCXX+set}" || LD=$LDCXX
+  CC=${CXX-"c++"}
+  compiler=$CC
+  _LT_TAGVAR(compiler, $1)=$CC
+  _LT_CC_BASENAME([$compiler])
+
+  if test -n "$compiler"; then
+    # We don't want -fno-exception when compiling C++ code, so set the
+    # no_builtin_flag separately
+    if test "$GXX" = yes; then
+      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+    else
+      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+    fi
+
+    if test "$GXX" = yes; then
+      # Set up default GNU C++ configuration
+
+      LT_PATH_LD
+
+      # Check if GNU C++ uses GNU ld as the underlying linker, since the
+      # archiving commands below assume that GNU ld is being used.
+      if test "$with_gnu_ld" = yes; then
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+        # If archive_cmds runs LD, not CC, wlarc should be empty
+        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+        #     investigate it a little bit more. (MM)
+        wlarc='${wl}'
+
+        # ancient GNU ld didn't support --whole-archive et. al.
+        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+          $GREP 'no-whole-archive' > /dev/null; then
+          _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+        else
+          _LT_TAGVAR(whole_archive_flag_spec, $1)=
+        fi
+      else
+        with_gnu_ld=no
+        wlarc=
+
+        # A generic and very simple default shared library creation
+        # command for GNU C++ for the case where it uses the native
+        # linker, instead of GNU ld.  If possible, this setting should
+        # overridden to take advantage of the native linker features on
+        # the platform it is being used on.
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+      fi
+
+      # Commands to make compiler produce verbose output that lists
+      # what "hidden" libraries, object files and flags are used when
+      # linking a shared library.
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+
+    else
+      GXX=no
+      with_gnu_ld=no
+      wlarc=
+    fi
+
+    # PORTME: fill in a description of your system's C++ link characteristics
+    AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+    _LT_TAGVAR(ld_shlibs, $1)=yes
+    case $host_os in
+      aix3*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+      aix[[4-9]]*)
+        if test "$host_cpu" = ia64; then
+          # On IA64, the linker does run time linking by default, so we don't
+          # have to do anything special.
+          aix_use_runtimelinking=no
+          exp_sym_flag='-Bexport'
+          no_entry_flag=""
+        else
+          aix_use_runtimelinking=no
+
+          # Test if we are trying to use run time linking or normal
+          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+          # need to do runtime linking.
+          case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
+            for ld_flag in $LDFLAGS; do
+              case $ld_flag in
+              *-brtl*)
+                aix_use_runtimelinking=yes
+                break
+                ;;
+              esac
+            done
+            ;;
+          esac
+
+          exp_sym_flag='-bexport'
+          no_entry_flag='-bnoentry'
+        fi
+
+        # When large executables or shared objects are built, AIX ld can
+        # have problems creating the table of contents.  If linking a library
+        # or program results in "error TOC overflow" add -mminimal-toc to
+        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+        _LT_TAGVAR(archive_cmds, $1)=''
+        _LT_TAGVAR(hardcode_direct, $1)=yes
+        _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+        _LT_TAGVAR(link_all_deplibs, $1)=yes
+        _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
+
+        if test "$GXX" = yes; then
+          case $host_os in aix4.[[012]]|aix4.[[012]].*)
+          # We only want to do this on AIX 4.2 and lower, the check
+          # below for broken collect2 doesn't work under 4.3+
+          collect2name=`${CC} -print-prog-name=collect2`
+          if test -f "$collect2name" &&
+             strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+          then
+            # We have reworked collect2
+            :
+          else
+            # We have old collect2
+            _LT_TAGVAR(hardcode_direct, $1)=unsupported
+            # It fails to find uninstalled libraries when the uninstalled
+            # path is not listed in the libpath.  Setting hardcode_minus_L
+            # to unsupported forces relinking
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+            _LT_TAGVAR(hardcode_libdir_separator, $1)=
+          fi
+          esac
+          shared_flag='-shared'
+          if test "$aix_use_runtimelinking" = yes; then
+            shared_flag="$shared_flag "'${wl}-G'
+          fi
+        else
+          # not using gcc
+          if test "$host_cpu" = ia64; then
+          # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+          # chokes on -Wl,-G. The following line is correct:
+          shared_flag='-G'
+          else
+            if test "$aix_use_runtimelinking" = yes; then
+              shared_flag='${wl}-G'
+            else
+              shared_flag='${wl}-bM:SRE'
+            fi
+          fi
+        fi
+
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
+        # It seems that -bexpall does not export symbols beginning with
+        # underscore (_), so it is better to generate a list of symbols to
+        # export.
+        _LT_TAGVAR(always_export_symbols, $1)=yes
+        if test "$aix_use_runtimelinking" = yes; then
+          # Warning - without using the other runtime loading flags (-brtl),
+          # -berok will link without error, but may produce a broken library.
+          _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+          # Determine the default libpath from the value encoded in an empty
+          # executable.
+          _LT_SYS_MODULE_PATH_AIX
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+        else
+          if test "$host_cpu" = ia64; then
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+            _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+            _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+          else
+            # Determine the default libpath from the value encoded in an
+            # empty executable.
+            _LT_SYS_MODULE_PATH_AIX
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+            # Warning - without using the other run time loading flags,
+            # -berok will link without error, but may produce a broken library.
+            _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+            _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+            # Exported symbols can be pulled into shared objects from archives
+            _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+            _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+            # This is similar to how AIX traditionally builds its shared
+            # libraries.
+            _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+          fi
+        fi
+        ;;
+
+      beos*)
+        if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+          _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+          # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+          # support --undefined.  This deserves some investigation.  FIXME
+          _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+        else
+          _LT_TAGVAR(ld_shlibs, $1)=no
+        fi
+        ;;
+
+      chorus*)
+        case $cc_basename in
+          *)
+          # FIXME: insert proper C++ library support
+          _LT_TAGVAR(ld_shlibs, $1)=no
+          ;;
+        esac
+        ;;
+
+      cygwin* | mingw* | pw32* | cegcc*)
+        # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+        # as there is no search path for DLLs.
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+        _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+        _LT_TAGVAR(always_export_symbols, $1)=no
+        _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+
+        if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+          # If the export-symbols file already is a .def file (1st line
+          # is EXPORTS), use it as is; otherwise, prepend...
+          _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+            cp $export_symbols $output_objdir/$soname.def;
+          else
+            echo EXPORTS > $output_objdir/$soname.def;
+            cat $export_symbols >> $output_objdir/$soname.def;
+          fi~
+          $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+        else
+          _LT_TAGVAR(ld_shlibs, $1)=no
+        fi
+        ;;
+      darwin* | rhapsody*)
+        _LT_DARWIN_LINKER_FEATURES($1)
+        ;;
+
+      dgux*)
+        case $cc_basename in
+          ec++*)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          ghcx*)
+            # Green Hills C++ Compiler
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          *)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+        esac
+        ;;
+
+      freebsd[[12]]*)
+        # C++ shared libraries reported to be fairly broken before
+        # switch to ELF
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      freebsd-elf*)
+        _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+        ;;
+
+      freebsd* | dragonfly*)
+        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+        # conventions
+        _LT_TAGVAR(ld_shlibs, $1)=yes
+        ;;
+
+      gnu*)
+        ;;
+
+      hpux9*)
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+        _LT_TAGVAR(hardcode_direct, $1)=yes
+        _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+                                             # but as the default
+                                             # location of the library.
+
+        case $cc_basename in
+          CC*)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          aCC*)
+            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
+            ;;
+          *)
+            if test "$GXX" = yes; then
+              _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+            else
+              # FIXME: insert proper C++ library support
+              _LT_TAGVAR(ld_shlibs, $1)=no
+            fi
+            ;;
+        esac
+        ;;
+
+      hpux10*|hpux11*)
+        if test $with_gnu_ld = no; then
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+          _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+          case $host_cpu in
+            hppa*64*|ia64*)
+              ;;
+            *)
+              _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+              ;;
+          esac
+        fi
+        case $host_cpu in
+          hppa*64*|ia64*)
+            _LT_TAGVAR(hardcode_direct, $1)=no
+            _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+            ;;
+          *)
+            _LT_TAGVAR(hardcode_direct, $1)=yes
+            _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+            _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+                                                 # but as the default
+                                                 # location of the library.
+            ;;
+        esac
+
+        case $cc_basename in
+          CC*)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          aCC*)
+            case $host_cpu in
+              hppa*64*)
+                _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+                ;;
+              ia64*)
+                _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+                ;;
+              *)
+                _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+                ;;
+            esac
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
+            ;;
+          *)
+            if test "$GXX" = yes; then
+              if test $with_gnu_ld = no; then
+                case $host_cpu in
+                  hppa*64*)
+                    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+                    ;;
+                  ia64*)
+                    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+                    ;;
+                  *)
+                    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+                    ;;
+                esac
+              fi
+            else
+              # FIXME: insert proper C++ library support
+              _LT_TAGVAR(ld_shlibs, $1)=no
+            fi
+            ;;
+        esac
+        ;;
+
+      interix[[3-9]]*)
+        _LT_TAGVAR(hardcode_direct, $1)=no
+        _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+        # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+        # Instead, shared libraries are loaded at an image base (0x10000000 by
+        # default) and relocated if they conflict, which is a slow very memory
+        # consuming and fragmenting process.  To avoid this, we pick a random,
+        # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+        # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+        _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+        ;;
+      irix5* | irix6*)
+        case $cc_basename in
+          CC*)
+            # SGI C++
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
+
+            # Archives containing C++ object files must be created using
+            # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+            # necessary to make sure instantiated templates are included
+            # in the archive.
+            _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
+            ;;
+          *)
+            if test "$GXX" = yes; then
+              if test "$with_gnu_ld" = no; then
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+              else
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` -o $lib'
+              fi
+            fi
+            _LT_TAGVAR(link_all_deplibs, $1)=yes
+            ;;
+        esac
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+        _LT_TAGVAR(inherit_rpath, $1)=yes
+        ;;
+
+      linux* | k*bsd*-gnu | kopensolaris*-gnu)
+        case $cc_basename in
+          KCC*)
+            # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+            # KCC will only create a shared library if the output file
+            # ends with ".so" (or ".sl" for HP-UX), so rename the library
+            # to its proper name (with version) after linking.
+            _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
+
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+            _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+            # Archives containing C++ object files must be created using
+            # "CC -Bstatic", where "CC" is the KAI C++ compiler.
+            _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+            ;;
+          icpc* | ecpc* )
+            # Intel C++
+            with_gnu_ld=yes
+            # version 8.0 and above of icpc choke on multiply defined symbols
+            # if we add $predep_objects and $postdep_objects, however 7.1 and
+            # earlier do not add the objects themselves.
+            case `$CC -V 2>&1` in
+              *"Version 7."*)
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+                _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+                ;;
+              *)  # Version 8.0 or newer
+                tmp_idyn=
+                case $host_cpu in
+                  ia64*) tmp_idyn=' -i_dynamic';;
+                esac
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+                _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+                ;;
+            esac
+            _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+            _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+            _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+            ;;
+          pgCC* | pgcpp*)
+            # Portland Group C++ compiler
+            case `$CC -V` in
+            *pgCC\ [[1-5]]* | *pgcpp\ [[1-5]]*)
+              _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+                compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
+              _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
+                $RANLIB $oldlib'
+              _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+              _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+              ;;
+            *) # Version 6 will use weak symbols
+              _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+              _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+              ;;
+            esac
+
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+            _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+            _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
+            ;;
+          cxx*)
+            # Compaq C++
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+
+            runpath_var=LD_RUN_PATH
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+            _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`$ECHO "X$templist" | $Xsed -e "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
+            ;;
+          xl*)
+            # IBM XL 8.0 on PPC, with GNU ld
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+            _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+            _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            if test "x$supports_anon_versioning" = xyes; then
+              _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                echo "local: *; };" >> $output_objdir/$libname.ver~
+                $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+            fi
+            ;;
+          *)
+            case `$CC -V 2>&1 | sed 5q` in
+            *Sun\ C*)
+              # Sun C++ 5.9
+              _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+              _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+              _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
+              _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+              _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
+              _LT_TAGVAR(compiler_needs_object, $1)=yes
+
+              # Not sure whether something based on
+              # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
+              # would be better.
+              output_verbose_link_cmd='echo'
+
+              # Archives containing C++ object files must be created using
+              # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+              # necessary to make sure instantiated templates are included
+              # in the archive.
+              _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+              ;;
+            esac
+            ;;
+        esac
+        ;;
+
+      lynxos*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      m88k*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      mvs*)
+        case $cc_basename in
+          cxx*)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          *)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+        esac
+        ;;
+
+      netbsd*)
+        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+          _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+          wlarc=
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+          _LT_TAGVAR(hardcode_direct, $1)=yes
+          _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+        fi
+        # Workaround some broken pre-1.5 toolchains
+        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+        ;;
+
+      *nto* | *qnx*)
+        _LT_TAGVAR(ld_shlibs, $1)=yes
+        ;;
+
+      openbsd2*)
+        # C++ shared libraries are fairly broken
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      openbsd*)
+        if test -f /usr/libexec/ld.so; then
+          _LT_TAGVAR(hardcode_direct, $1)=yes
+          _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+          _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+          if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+            _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
+            _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+            _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+          fi
+          output_verbose_link_cmd=echo
+        else
+          _LT_TAGVAR(ld_shlibs, $1)=no
+        fi
+        ;;
+
+      osf3* | osf4* | osf5*)
+        case $cc_basename in
+          KCC*)
+            # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+            # KCC will only create a shared library if the output file
+            # ends with ".so" (or ".sl" for HP-UX), so rename the library
+            # to its proper name (with version) after linking.
+            _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+            _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+            # Archives containing C++ object files must be created using
+            # the KAI C++ compiler.
+            case $host in
+              osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;;
+              *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;;
+            esac
+            ;;
+          RCC*)
+            # Rational C++ 2.4.1
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          cxx*)
+            case $host in
+              osf3*)
+                _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && $ECHO "X${wl}-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
+                _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+                ;;
+              *)
+                _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
+                _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+                  echo "-hidden">> $lib.exp~
+                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp  `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~
+                  $RM $lib.exp'
+                _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+                ;;
+            esac
+
+            _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`$ECHO "X$templist" | $Xsed -e "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; $ECHO "X$list" | $Xsed'
+            ;;
+          *)
+            if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+              _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+              case $host in
+                osf3*)
+                  _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+                  ;;
+                *)
+                  _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+                  ;;
+              esac
+
+              _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+              _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+              # Commands to make compiler produce verbose output that lists
+              # what "hidden" libraries, object files and flags are used when
+              # linking a shared library.
+              output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+
+            else
+              # FIXME: insert proper C++ library support
+              _LT_TAGVAR(ld_shlibs, $1)=no
+            fi
+            ;;
+        esac
+        ;;
+
+      psos*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      sunos4*)
+        case $cc_basename in
+          CC*)
+            # Sun C++ 4.x
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          lcc*)
+            # Lucid
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          *)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+        esac
+        ;;
+
+      solaris*)
+        case $cc_basename in
+          CC*)
+            # Sun C++ 4.2, 5.x and Centerline C++
+            _LT_TAGVAR(archive_cmds_need_lc,$1)=yes
+            _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+            _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+            _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+              $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+            _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+            case $host_os in
+              solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+              *)
+                # The compiler driver will combine and reorder linker options,
+                # but understands `-z linker_flag'.
+                # Supported since Solaris 2.6 (maybe 2.5.1?)
+                _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
+                ;;
+            esac
+            _LT_TAGVAR(link_all_deplibs, $1)=yes
+
+            output_verbose_link_cmd='echo'
+
+            # Archives containing C++ object files must be created using
+            # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+            # necessary to make sure instantiated templates are included
+            # in the archive.
+            _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+            ;;
+          gcx*)
+            # Green Hills C++ Compiler
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+
+            # The C++ compiler must be used to create the archive.
+            _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+            ;;
+          *)
+            # GNU C++ compiler with Solaris linker
+            if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+              _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
+              if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+                _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+                _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+                # Commands to make compiler produce verbose output that lists
+                # what "hidden" libraries, object files and flags are used when
+                # linking a shared library.
+                output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+              else
+                # g++ 2.7 appears to require `-G' NOT `-shared' on this
+                # platform.
+                _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+                _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+                # Commands to make compiler produce verbose output that lists
+                # what "hidden" libraries, object files and flags are used when
+                # linking a shared library.
+                output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+              fi
+
+              _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
+              case $host_os in
+                solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+                *)
+                  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+                  ;;
+              esac
+            fi
+            ;;
+        esac
+        ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+      runpath_var='LD_RUN_PATH'
+
+      case $cc_basename in
+        CC*)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+        *)
+          _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+          ;;
+      esac
+      ;;
+
+      sysv5* | sco3.2v5* | sco5v6*)
+        # Note: We can NOT use -z defs as we might desire, because we do not
+        # link with -lc, and that would cause any symbols used from libc to
+        # always be unresolved, which means just about no library would
+        # ever link correctly.  If we're not using GNU ld we use -z text
+        # though, which does catch some bad symbols but isn't as heavy-handed
+        # as -z defs.
+        _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+        _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+        _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+        _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
+        _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+        _LT_TAGVAR(link_all_deplibs, $1)=yes
+        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+        runpath_var='LD_RUN_PATH'
+
+        case $cc_basename in
+          CC*)
+            _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+            _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+            ;;
+          *)
+            _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+            _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+            ;;
+        esac
+      ;;
+
+      tandem*)
+        case $cc_basename in
+          NCC*)
+            # NonStop-UX NCC 3.20
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+          *)
+            # FIXME: insert proper C++ library support
+            _LT_TAGVAR(ld_shlibs, $1)=no
+            ;;
+        esac
+        ;;
+
+      vxworks*)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+
+      *)
+        # FIXME: insert proper C++ library support
+        _LT_TAGVAR(ld_shlibs, $1)=no
+        ;;
+    esac
+
+    AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
+    test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+    _LT_TAGVAR(GCC, $1)="$GXX"
+    _LT_TAGVAR(LD, $1)="$LD"
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    _LT_SYS_HIDDEN_LIBDEPS($1)
+    _LT_COMPILER_PIC($1)
+    _LT_COMPILER_C_O($1)
+    _LT_COMPILER_FILE_LOCKS($1)
+    _LT_LINKER_SHLIBS($1)
+    _LT_SYS_DYNAMIC_LINKER($1)
+    _LT_LINKER_HARDCODE_LIBPATH($1)
+
+    _LT_CONFIG($1)
+  fi # test -n "$compiler"
+
+  CC=$lt_save_CC
+  LDCXX=$LD
+  LD=$lt_save_LD
+  GCC=$lt_save_GCC
+  with_gnu_ld=$lt_save_with_gnu_ld
+  lt_cv_path_LDCXX=$lt_cv_path_LD
+  lt_cv_path_LD=$lt_save_path_LD
+  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+fi # test "$_lt_caught_CXX_error" != yes
+
+AC_LANG_POP
+])# _LT_LANG_CXX_CONFIG
+
+
+# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
+# ---------------------------------
+# Figure out "hidden" library dependencies from verbose
+# compiler output when linking a shared library.
+# Parse the compiler output and extract the necessary
+# objects, libraries and library flags.
+m4_defun([_LT_SYS_HIDDEN_LIBDEPS],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+# Dependencies to place before and after the object being linked:
+_LT_TAGVAR(predep_objects, $1)=
+_LT_TAGVAR(postdep_objects, $1)=
+_LT_TAGVAR(predeps, $1)=
+_LT_TAGVAR(postdeps, $1)=
+_LT_TAGVAR(compiler_lib_search_path, $1)=
+
+dnl we can't use the lt_simple_compile_test_code here,
+dnl because it contains code intended for an executable,
+dnl not a library.  It's possible we should let each
+dnl tag define a new lt_????_link_test_code variable,
+dnl but it's only used here...
+m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
+int a;
+void foo (void) { a = 0; }
+_LT_EOF
+], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+_LT_EOF
+], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
+      subroutine foo
+      implicit none
+      integer*4 a
+      a=0
+      return
+      end
+_LT_EOF
+], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF
+      subroutine foo
+      implicit none
+      integer a
+      a=0
+      return
+      end
+_LT_EOF
+], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
+public class foo {
+  private int a;
+  public void bar (void) {
+    a = 0;
+  }
+};
+_LT_EOF
+])
+dnl Parse the compiler output and extract the necessary
+dnl objects, libraries and library flags.
+if AC_TRY_EVAL(ac_compile); then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  for p in `eval "$output_verbose_link_cmd"`; do
+    case $p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test $p = "-L" ||
+          test $p = "-R"; then
+         prev=$p
+         continue
+       else
+         prev=
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+         case $p in
+         -L* | -R*)
+           # Internal compiler library paths should come after those
+           # provided the user.  The postdeps already come after the
+           # user supplied libs so there is no need to process them.
+           if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
+             _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
+           else
+             _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
+           fi
+           ;;
+         # The "-l" case would never come before the object being
+         # linked, so don't bother handling this case.
+         esac
+       else
+         if test -z "$_LT_TAGVAR(postdeps, $1)"; then
+           _LT_TAGVAR(postdeps, $1)="${prev}${p}"
+         else
+           _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}"
+         fi
+       fi
+       ;;
+
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+         pre_test_object_deps_done=yes
+         continue
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+         if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
+           _LT_TAGVAR(predep_objects, $1)="$p"
+         else
+           _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
+         fi
+       else
+         if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
+           _LT_TAGVAR(postdep_objects, $1)="$p"
+         else
+           _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
+         fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling $1 test program"
+fi
+
+$RM -f confest.$objext
+
+# PORTME: override above test on systems where it is broken
+m4_if([$1], [CXX],
+[case $host_os in
+interix[[3-9]]*)
+  # Interix 3.5 installs completely hosed .la files for C++, so rather than
+  # hack all around it, let's just trust "g++" to DTRT.
+  _LT_TAGVAR(predep_objects,$1)=
+  _LT_TAGVAR(postdep_objects,$1)=
+  _LT_TAGVAR(postdeps,$1)=
+  ;;
+
+linux*)
+  case `$CC -V 2>&1 | sed 5q` in
+  *Sun\ C*)
+    # Sun C++ 5.9
+
+    # The more standards-conforming stlport4 library is
+    # incompatible with the Cstd library. Avoid specifying
+    # it if it's in CXXFLAGS. Ignore libCrun as
+    # -library=stlport4 depends on it.
+    case " $CXX $CXXFLAGS " in
+    *" -library=stlport4 "*)
+      solaris_use_stlport4=yes
+      ;;
+    esac
+
+    if test "$solaris_use_stlport4" != yes; then
+      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
+    fi
+    ;;
+  esac
+  ;;
+
+solaris*)
+  case $cc_basename in
+  CC*)
+    # The more standards-conforming stlport4 library is
+    # incompatible with the Cstd library. Avoid specifying
+    # it if it's in CXXFLAGS. Ignore libCrun as
+    # -library=stlport4 depends on it.
+    case " $CXX $CXXFLAGS " in
+    *" -library=stlport4 "*)
+      solaris_use_stlport4=yes
+      ;;
+    esac
+
+    # Adding this requires a known-good setup of shared libraries for
+    # Sun compiler versions before 5.6, else PIC objects from an old
+    # archive will be linked into the output, leading to subtle bugs.
+    if test "$solaris_use_stlport4" != yes; then
+      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
+    fi
+    ;;
+  esac
+  ;;
+esac
+])
+
+case " $_LT_TAGVAR(postdeps, $1) " in
+*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;;
+esac
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=
+if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
+fi
+_LT_TAGDECL([], [compiler_lib_search_dirs], [1],
+    [The directories searched by this compiler when creating a shared library])
+_LT_TAGDECL([], [predep_objects], [1],
+    [Dependencies to place before and after the objects being linked to
+    create a shared library])
+_LT_TAGDECL([], [postdep_objects], [1])
+_LT_TAGDECL([], [predeps], [1])
+_LT_TAGDECL([], [postdeps], [1])
+_LT_TAGDECL([], [compiler_lib_search_path], [1],
+    [The library search path used internally by the compiler when linking
+    a shared library])
+])# _LT_SYS_HIDDEN_LIBDEPS
+
+
+# _LT_PROG_F77
+# ------------
+# Since AC_PROG_F77 is broken, in that it returns the empty string
+# if there is no fortran compiler, we have our own version here.
+m4_defun([_LT_PROG_F77],
+[
+pushdef([AC_MSG_ERROR], [_lt_disable_F77=yes])
+AC_PROG_F77
+if test -z "$F77" || test "X$F77" = "Xno"; then
+  _lt_disable_F77=yes
+fi
+popdef([AC_MSG_ERROR])
+])# _LT_PROG_F77
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([_LT_PROG_F77], [])
+
+
+# _LT_LANG_F77_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a Fortran 77 compiler are
+# suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_F77_CONFIG],
+[AC_REQUIRE([_LT_PROG_F77])dnl
+AC_LANG_PUSH(Fortran 77)
+
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for f77 test sources.
+ac_ext=f
+
+# Object file extension for compiled f77 test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the F77 compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_disable_F77" != yes; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="\
+      subroutine t
+      return
+      end
+"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code="\
+      program t
+      end
+"
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+  _LT_TAG_COMPILER
+
+  # save warnings/boilerplate of simple test code
+  _LT_COMPILER_BOILERPLATE
+  _LT_LINKER_BOILERPLATE
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC="$CC"
+  lt_save_GCC=$GCC
+  CC=${F77-"f77"}
+  compiler=$CC
+  _LT_TAGVAR(compiler, $1)=$CC
+  _LT_CC_BASENAME([$compiler])
+  GCC=$G77
+  if test -n "$compiler"; then
+    AC_MSG_CHECKING([if libtool supports shared libraries])
+    AC_MSG_RESULT([$can_build_shared])
+
+    AC_MSG_CHECKING([whether to build shared libraries])
+    test "$can_build_shared" = "no" && enable_shared=no
+
+    # On AIX, shared libraries and static libraries use the same namespace, and
+    # are all built from PIC.
+    case $host_os in
+      aix3*)
+        test "$enable_shared" = yes && enable_static=no
+        if test -n "$RANLIB"; then
+          archive_cmds="$archive_cmds~\$RANLIB \$lib"
+          postinstall_cmds='$RANLIB $lib'
+        fi
+        ;;
+      aix[[4-9]]*)
+        if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+          test "$enable_shared" = yes && enable_static=no
+        fi
+        ;;
+    esac
+    AC_MSG_RESULT([$enable_shared])
+
+    AC_MSG_CHECKING([whether to build static libraries])
+    # Make sure either enable_shared or enable_static is yes.
+    test "$enable_shared" = yes || enable_static=yes
+    AC_MSG_RESULT([$enable_static])
+
+    _LT_TAGVAR(GCC, $1)="$G77"
+    _LT_TAGVAR(LD, $1)="$LD"
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    _LT_COMPILER_PIC($1)
+    _LT_COMPILER_C_O($1)
+    _LT_COMPILER_FILE_LOCKS($1)
+    _LT_LINKER_SHLIBS($1)
+    _LT_SYS_DYNAMIC_LINKER($1)
+    _LT_LINKER_HARDCODE_LIBPATH($1)
+
+    _LT_CONFIG($1)
+  fi # test -n "$compiler"
+
+  GCC=$lt_save_GCC
+  CC="$lt_save_CC"
+fi # test "$_lt_disable_F77" != yes
+
+AC_LANG_POP
+])# _LT_LANG_F77_CONFIG
+
+
+# _LT_PROG_FC
+# -----------
+# Since AC_PROG_FC is broken, in that it returns the empty string
+# if there is no fortran compiler, we have our own version here.
+m4_defun([_LT_PROG_FC],
+[
+pushdef([AC_MSG_ERROR], [_lt_disable_FC=yes])
+AC_PROG_FC
+if test -z "$FC" || test "X$FC" = "Xno"; then
+  _lt_disable_FC=yes
+fi
+popdef([AC_MSG_ERROR])
+])# _LT_PROG_FC
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([_LT_PROG_FC], [])
+
+
+# _LT_LANG_FC_CONFIG([TAG])
+# -------------------------
+# Ensure that the configuration variables for a Fortran compiler are
+# suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_FC_CONFIG],
+[AC_REQUIRE([_LT_PROG_FC])dnl
+AC_LANG_PUSH(Fortran)
+
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for fc test sources.
+ac_ext=${ac_fc_srcext-f}
+
+# Object file extension for compiled fc test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the FC compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_disable_FC" != yes; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="\
+      subroutine t
+      return
+      end
+"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code="\
+      program t
+      end
+"
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+  _LT_TAG_COMPILER
+
+  # save warnings/boilerplate of simple test code
+  _LT_COMPILER_BOILERPLATE
+  _LT_LINKER_BOILERPLATE
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC="$CC"
+  lt_save_GCC=$GCC
+  CC=${FC-"f95"}
+  compiler=$CC
+  GCC=$ac_cv_fc_compiler_gnu
+
+  _LT_TAGVAR(compiler, $1)=$CC
+  _LT_CC_BASENAME([$compiler])
+
+  if test -n "$compiler"; then
+    AC_MSG_CHECKING([if libtool supports shared libraries])
+    AC_MSG_RESULT([$can_build_shared])
+
+    AC_MSG_CHECKING([whether to build shared libraries])
+    test "$can_build_shared" = "no" && enable_shared=no
+
+    # On AIX, shared libraries and static libraries use the same namespace, and
+    # are all built from PIC.
+    case $host_os in
+      aix3*)
+        test "$enable_shared" = yes && enable_static=no
+        if test -n "$RANLIB"; then
+          archive_cmds="$archive_cmds~\$RANLIB \$lib"
+          postinstall_cmds='$RANLIB $lib'
+        fi
+        ;;
+      aix[[4-9]]*)
+        if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+          test "$enable_shared" = yes && enable_static=no
+        fi
+        ;;
+    esac
+    AC_MSG_RESULT([$enable_shared])
+
+    AC_MSG_CHECKING([whether to build static libraries])
+    # Make sure either enable_shared or enable_static is yes.
+    test "$enable_shared" = yes || enable_static=yes
+    AC_MSG_RESULT([$enable_static])
+
+    _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu"
+    _LT_TAGVAR(LD, $1)="$LD"
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    _LT_SYS_HIDDEN_LIBDEPS($1)
+    _LT_COMPILER_PIC($1)
+    _LT_COMPILER_C_O($1)
+    _LT_COMPILER_FILE_LOCKS($1)
+    _LT_LINKER_SHLIBS($1)
+    _LT_SYS_DYNAMIC_LINKER($1)
+    _LT_LINKER_HARDCODE_LIBPATH($1)
+
+    _LT_CONFIG($1)
+  fi # test -n "$compiler"
+
+  GCC=$lt_save_GCC
+  CC="$lt_save_CC"
+fi # test "$_lt_disable_FC" != yes
+
+AC_LANG_POP
+])# _LT_LANG_FC_CONFIG
+
+
+# _LT_LANG_GCJ_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Java Compiler compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_GCJ_CONFIG],
+[AC_REQUIRE([LT_PROG_GCJ])dnl
+AC_LANG_SAVE
+
+# Source file extension for Java test sources.
+ac_ext=java
+
+# Object file extension for compiled Java test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="class foo {}"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+lt_save_GCC=$GCC
+GCC=yes
+CC=${GCJ-"gcj"}
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)="$LD"
+_LT_CC_BASENAME([$compiler])
+
+# GCJ did not exist at the time GCC didn't implicitly link libc in.
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  _LT_COMPILER_NO_RTTI($1)
+  _LT_COMPILER_PIC($1)
+  _LT_COMPILER_C_O($1)
+  _LT_COMPILER_FILE_LOCKS($1)
+  _LT_LINKER_SHLIBS($1)
+  _LT_LINKER_HARDCODE_LIBPATH($1)
+
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC="$lt_save_CC"
+])# _LT_LANG_GCJ_CONFIG
+
+
+# _LT_LANG_RC_CONFIG([TAG])
+# -------------------------
+# Ensure that the configuration variables for the Windows resource compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_RC_CONFIG],
+[AC_REQUIRE([LT_PROG_RC])dnl
+AC_LANG_SAVE
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="$lt_simple_compile_test_code"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+lt_save_GCC=$GCC
+GCC=
+CC=${RC-"windres"}
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+
+if test -n "$compiler"; then
+  :
+  _LT_CONFIG($1)
+fi
+
+GCC=$lt_save_GCC
+AC_LANG_RESTORE
+CC="$lt_save_CC"
+])# _LT_LANG_RC_CONFIG
+
+
+# LT_PROG_GCJ
+# -----------
+AC_DEFUN([LT_PROG_GCJ],
+[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
+  [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
+    [AC_CHECK_TOOL(GCJ, gcj,)
+      test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
+      AC_SUBST(GCJFLAGS)])])[]dnl
+])
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_GCJ], [])
+
+
+# LT_PROG_RC
+# ----------
+AC_DEFUN([LT_PROG_RC],
+[AC_CHECK_TOOL(RC, windres,)
+])
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_RC], [])
+
+
+# _LT_DECL_EGREP
+# --------------
+# If we don't have a new enough Autoconf to choose the best grep
+# available, choose the one first in the user's PATH.
+m4_defun([_LT_DECL_EGREP],
+[AC_REQUIRE([AC_PROG_EGREP])dnl
+AC_REQUIRE([AC_PROG_FGREP])dnl
+test -z "$GREP" && GREP=grep
+_LT_DECL([], [GREP], [1], [A grep program that handles long lines])
+_LT_DECL([], [EGREP], [1], [An ERE matcher])
+_LT_DECL([], [FGREP], [1], [A literal string matcher])
+dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too
+AC_SUBST([GREP])
+])
+
+
+# _LT_DECL_OBJDUMP
+# --------------
+# If we don't have a new enough Autoconf to choose the best objdump
+# available, choose the one first in the user's PATH.
+m4_defun([_LT_DECL_OBJDUMP],
+[AC_CHECK_TOOL(OBJDUMP, objdump, false)
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper])
+AC_SUBST([OBJDUMP])
+])
+
+
+# _LT_DECL_SED
+# ------------
+# Check for a fully-functional sed program, that truncates
+# as few characters as possible.  Prefer GNU sed if found.
+m4_defun([_LT_DECL_SED],
+[AC_PROG_SED
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
+_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"],
+    [Sed that helps us avoid accidentally triggering echo(1) options like -n])
+])# _LT_DECL_SED
+
+m4_ifndef([AC_PROG_SED], [
+############################################################
+# NOTE: This macro has been submitted for inclusion into   #
+#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
+#  a released version of Autoconf we should remove this    #
+#  macro and use it instead.                               #
+############################################################
+
+m4_defun([AC_PROG_SED],
+[AC_MSG_CHECKING([for a sed that does not truncate output])
+AC_CACHE_VAL(lt_cv_path_SED,
+[# Loop through the user's path and test for sed and gsed.
+# Then use that list of sed's as ones to test for truncation.
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for lt_ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
+      fi
+    done
+  done
+done
+IFS=$as_save_IFS
+lt_ac_max=0
+lt_ac_count=0
+# Add /usr/xpg4/bin/sed as it is typically found on Solaris
+# along with /bin/sed that truncates output.
+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
+  test ! -f $lt_ac_sed && continue
+  cat /dev/null > conftest.in
+  lt_ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
+  # Check for GNU sed and select it if it is found.
+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
+    lt_cv_path_SED=$lt_ac_sed
+    break
+  fi
+  while true; do
+    cat conftest.in conftest.in >conftest.tmp
+    mv conftest.tmp conftest.in
+    cp conftest.in conftest.nl
+    echo >>conftest.nl
+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
+    cmp -s conftest.out conftest.nl || break
+    # 10000 chars as input seems more than enough
+    test $lt_ac_count -gt 10 && break
+    lt_ac_count=`expr $lt_ac_count + 1`
+    if test $lt_ac_count -gt $lt_ac_max; then
+      lt_ac_max=$lt_ac_count
+      lt_cv_path_SED=$lt_ac_sed
+    fi
+  done
+done
+])
+SED=$lt_cv_path_SED
+AC_SUBST([SED])
+AC_MSG_RESULT([$SED])
+])#AC_PROG_SED
+])#m4_ifndef
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_SED], [])
+
+
+# _LT_CHECK_SHELL_FEATURES
+# ------------------------
+# Find out whether the shell is Bourne or XSI compatible,
+# or has some other useful features.
+m4_defun([_LT_CHECK_SHELL_FEATURES],
+[AC_MSG_CHECKING([whether the shell understands some XSI constructs])
+# Try some XSI features
+xsi_shell=no
+( _lt_dummy="a/b/c"
+  test "${_lt_dummy##*/},${_lt_dummy%/*},"${_lt_dummy%"$_lt_dummy"}, \
+      = c,a/b,, \
+    && eval 'test $(( 1 + 1 )) -eq 2 \
+    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
+  && xsi_shell=yes
+AC_MSG_RESULT([$xsi_shell])
+_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell'])
+
+AC_MSG_CHECKING([whether the shell understands "+="])
+lt_shell_append=no
+( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \
+    >/dev/null 2>&1 \
+  && lt_shell_append=yes
+AC_MSG_RESULT([$lt_shell_append])
+_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append'])
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
+_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
+_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl
+_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
+])# _LT_CHECK_SHELL_FEATURES
+
+
+# _LT_PROG_XSI_SHELLFNS
+# ---------------------
+# Bourne and XSI compatible variants of some useful shell functions.
+m4_defun([_LT_PROG_XSI_SHELLFNS],
+[case $xsi_shell in
+  yes)
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_dirname file append nondir_replacement
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+func_dirname ()
+{
+  case ${1} in
+    */*) func_dirname_result="${1%/*}${2}" ;;
+    *  ) func_dirname_result="${3}" ;;
+  esac
+}
+
+# func_basename file
+func_basename ()
+{
+  func_basename_result="${1##*/}"
+}
+
+# func_dirname_and_basename file append nondir_replacement
+# perform func_basename and func_dirname in a single function
+# call:
+#   dirname:  Compute the dirname of FILE.  If nonempty,
+#             add APPEND to the result, otherwise set result
+#             to NONDIR_REPLACEMENT.
+#             value returned in "$func_dirname_result"
+#   basename: Compute filename of FILE.
+#             value retuned in "$func_basename_result"
+# Implementation must be kept synchronized with func_dirname
+# and func_basename. For efficiency, we do not delegate to
+# those functions but instead duplicate the functionality here.
+func_dirname_and_basename ()
+{
+  case ${1} in
+    */*) func_dirname_result="${1%/*}${2}" ;;
+    *  ) func_dirname_result="${3}" ;;
+  esac
+  func_basename_result="${1##*/}"
+}
+
+# func_stripname prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+func_stripname ()
+{
+  # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+  # positional parameters, so assign one to ordinary parameter first.
+  func_stripname_result=${3}
+  func_stripname_result=${func_stripname_result#"${1}"}
+  func_stripname_result=${func_stripname_result%"${2}"}
+}
+
+# func_opt_split
+func_opt_split ()
+{
+  func_opt_split_opt=${1%%=*}
+  func_opt_split_arg=${1#*=}
+}
+
+# func_lo2o object
+func_lo2o ()
+{
+  case ${1} in
+    *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
+    *)    func_lo2o_result=${1} ;;
+  esac
+}
+
+# func_xform libobj-or-source
+func_xform ()
+{
+  func_xform_result=${1%.*}.lo
+}
+
+# func_arith arithmetic-term...
+func_arith ()
+{
+  func_arith_result=$(( $[*] ))
+}
+
+# func_len string
+# STRING may not start with a hyphen.
+func_len ()
+{
+  func_len_result=${#1}
+}
+
+_LT_EOF
+    ;;
+  *) # Bourne compatible functions.
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_dirname file append nondir_replacement
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+func_dirname ()
+{
+  # Extract subdirectory from the argument.
+  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
+  if test "X$func_dirname_result" = "X${1}"; then
+    func_dirname_result="${3}"
+  else
+    func_dirname_result="$func_dirname_result${2}"
+  fi
+}
+
+# func_basename file
+func_basename ()
+{
+  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
+}
+
+dnl func_dirname_and_basename
+dnl A portable version of this function is already defined in general.m4sh
+dnl so there is no need for it here.
+
+# func_stripname prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+# func_strip_suffix prefix name
+func_stripname ()
+{
+  case ${2} in
+    .*) func_stripname_result=`$ECHO "X${3}" \
+           | $Xsed -e "s%^${1}%%" -e "s%\\\\${2}\$%%"`;;
+    *)  func_stripname_result=`$ECHO "X${3}" \
+           | $Xsed -e "s%^${1}%%" -e "s%${2}\$%%"`;;
+  esac
+}
+
+# sed scripts:
+my_sed_long_opt='1s/^\(-[[^=]]*\)=.*/\1/;q'
+my_sed_long_arg='1s/^-[[^=]]*=//'
+
+# func_opt_split
+func_opt_split ()
+{
+  func_opt_split_opt=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_opt"`
+  func_opt_split_arg=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_arg"`
+}
+
+# func_lo2o object
+func_lo2o ()
+{
+  func_lo2o_result=`$ECHO "X${1}" | $Xsed -e "$lo2o"`
+}
+
+# func_xform libobj-or-source
+func_xform ()
+{
+  func_xform_result=`$ECHO "X${1}" | $Xsed -e 's/\.[[^.]]*$/.lo/'`
+}
+
+# func_arith arithmetic-term...
+func_arith ()
+{
+  func_arith_result=`expr "$[@]"`
+}
+
+# func_len string
+# STRING may not start with a hyphen.
+func_len ()
+{
+  func_len_result=`expr "$[1]" : ".*" 2>/dev/null || echo $max_cmd_len`
+}
+
+_LT_EOF
+esac
+
+case $lt_shell_append in
+  yes)
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_append var value
+# Append VALUE to the end of shell variable VAR.
+func_append ()
+{
+  eval "$[1]+=\$[2]"
+}
+_LT_EOF
+    ;;
+  *)
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_append var value
+# Append VALUE to the end of shell variable VAR.
+func_append ()
+{
+  eval "$[1]=\$$[1]\$[2]"
+}
+
+_LT_EOF
+    ;;
+  esac
+])
diff --git a/pathologist/m4/ltoptions.m4 b/pathologist/m4/ltoptions.m4
new file mode 100644
index 0000000..34151a3
--- /dev/null
+++ b/pathologist/m4/ltoptions.m4
@@ -0,0 +1,368 @@
+# Helper functions for option handling.                    -*- Autoconf -*-
+#
+#   Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+#   Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+        _LT_MANGLE_DEFUN([$1], [$2]),
+    [m4_warning([Unknown $1 option `$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+            [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+                      [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME.  If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+    [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+  dnl
+  dnl Simply set some default values (i.e off) if boolean options were not
+  dnl specified:
+  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+  ])
+  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+  ])
+  dnl
+  dnl If no reference was made to various pairs of opposing options, then
+  dnl we run the default mode handler for the pair.  For example, if neither
+  dnl `shared' nor `disable-shared' was passed, we enable building of shared
+  dnl archives by default:
+  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+                   [_LT_ENABLE_FAST_INSTALL])
+  ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-cegcc*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [0], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the `shared' and
+# `disable-shared' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+        [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+        IFS="$lt_save_ifs"
+        if test "X$pkg" = "X$p"; then
+          enable_shared=yes
+        fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+        [Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the `static' and
+# `disable-static' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+        [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+        IFS="$lt_save_ifs"
+        if test "X$pkg" = "X$p"; then
+          enable_static=yes
+        fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+        [Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the `fast-install'
+# and `disable-fast-install' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+        IFS="$lt_save_ifs"
+        if test "X$pkg" = "X$p"; then
+          enable_fast_install=yes
+        fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+         [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# LT_INIT options.
+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AS_HELP_STRING([--with-pic],
+        [try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [pic_mode="$withval"],
+    [pic_mode=default])
+
+test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+                 [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+                 [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+                 [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+                 [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+                 [m4_define([_LTDL_TYPE], [convenience])])
diff --git a/pathologist/m4/ltsugar.m4 b/pathologist/m4/ltsugar.m4
new file mode 100644
index 0000000..9000a05
--- /dev/null
+++ b/pathologist/m4/ltsugar.m4
@@ -0,0 +1,123 @@
+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+       [$#], [2], [[$2]],
+       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59 which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+       [$#], 1, [],
+       [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+           m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+             [m4_foreach([_Lt_suffix],
+                ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+        [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+          [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+                 [lt_append([$1], [$2], [$3])$4],
+                 [$5])],
+          [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+        m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+        [$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+                      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])
diff --git a/pathologist/m4/ltversion.m4 b/pathologist/m4/ltversion.m4
new file mode 100644
index 0000000..f3c5309
--- /dev/null
+++ b/pathologist/m4/ltversion.m4
@@ -0,0 +1,23 @@
+# ltversion.m4 -- version numbers                       -*- Autoconf -*-
+#
+#   Copyright (C) 2004 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# Generated from ltversion.in.
+
+# serial 3017 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.2.6b])
+m4_define([LT_PACKAGE_REVISION], [1.3017])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.2.6b'
+macro_revision='1.3017'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])
diff --git a/pathologist/m4/lt~obsolete.m4 b/pathologist/m4/lt~obsolete.m4
new file mode 100644
index 0000000..637bb20
--- /dev/null
+++ b/pathologist/m4/lt~obsolete.m4
@@ -0,0 +1,92 @@
+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
+#
+#   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 4 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else.  This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. 
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION],   [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP],              [AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT],          [AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],     [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN],            [AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR],              [AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL],     [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN],            [AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER],        [AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK],                [AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],     [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],     [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR],          [AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR],             [AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],   [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC],              [AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU],             [AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG],     [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD],    [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],  [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],  [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP],           [AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED],             [AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME],            [AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE],   [AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE],     [AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL],           [AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP],           [AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN],         [AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],      [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG],           [AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL],    [AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX],            [AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77],            [AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ],            [AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_RC],              [AC_DEFUN([AC_LIBTOOL_RC])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],   [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG],       [AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG],     [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG],     [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],     [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],  [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG],      [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG],          [AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C],        [AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
diff --git a/pathologist/refs/db/bad_memory_access.db b/pathologist/refs/db/bad_memory_access.db
new file mode 100644
index 0000000..8635229
--- /dev/null
+++ b/pathologist/refs/db/bad_memory_access.db
diff --git a/pathologist/refs/db/bug_assertion_failure.db b/pathologist/refs/db/bug_assertion_failure.db
new file mode 100644
index 0000000..80b952c
--- /dev/null
+++ b/pathologist/refs/db/bug_assertion_failure.db
diff --git a/pathologist/refs/db/bug_bad_food.db b/pathologist/refs/db/bug_bad_food.db
new file mode 100644
index 0000000..0d0b4dd
--- /dev/null
+++ b/pathologist/refs/db/bug_bad_food.db
diff --git a/pathologist/refs/db/bug_bad_memory_access.db b/pathologist/refs/db/bug_bad_memory_access.db
new file mode 100644
index 0000000..f5388fd
--- /dev/null
+++ b/pathologist/refs/db/bug_bad_memory_access.db
diff --git a/pathologist/refs/db/bug_bug_assertion_failure.db b/pathologist/refs/db/bug_bug_assertion_failure.db
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pathologist/refs/db/bug_bug_assertion_failure.db
diff --git a/pathologist/refs/db/bug_division_by_zero_loop.db b/pathologist/refs/db/bug_division_by_zero_loop.db
new file mode 100644
index 0000000..8c103ef
--- /dev/null
+++ b/pathologist/refs/db/bug_division_by_zero_loop.db
diff --git a/pathologist/refs/db/bug_null_pointer_exception.db b/pathologist/refs/db/bug_null_pointer_exception.db
new file mode 100644
index 0000000..91b1c8a
--- /dev/null
+++ b/pathologist/refs/db/bug_null_pointer_exception.db
diff --git a/pathologist/refs/db/bug_null_pointer_exception_modified.db b/pathologist/refs/db/bug_null_pointer_exception_modified.db
new file mode 100644
index 0000000..6c264fb
--- /dev/null
+++ b/pathologist/refs/db/bug_null_pointer_exception_modified.db
diff --git a/pathologist/refs/reports/ref_bt_bug_assertion_failure.xml b/pathologist/refs/reports/ref_bt_bug_assertion_failure.xml
new file mode 100644
index 0000000..9bdccb2
--- /dev/null
+++ b/pathologist/refs/reports/ref_bt_bug_assertion_failure.xml
@@ -0,0 +1,75 @@
+<?xml version="1.0"?>
+<crash category="Assertion Failure" function="assertionFailure" line="9" file="bug_assertion_failure.c" >
+<history><epoch step="0" >
+<trace><function name="assertionFailure" line="9" file="bug_assertion_failure.c" depth="0" >
+<expressions><expression name="assert(x&lt;4)" >
+Not Evaluated</expression>
+<expression name="x&lt;4" >
+0</expression>
+<expression name="printf(&quot;Assertion Failure Now!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="x" >
+5</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_assertion_failure.c" depth="1" >
+<expressions><expression name="assertionFailure()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace><function name="assertionFailure" line="8" file="bug_assertion_failure.c" depth="0" >
+<expressions><expression name="printf(&quot;Assertion Failure Now!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="x" >
+5</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_assertion_failure.c" depth="1" >
+<expressions><expression name="assertionFailure()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace><function name="assertionFailure" line="7" file="bug_assertion_failure.c" depth="0" >
+<expressions><expression name="x" >
+-1073746936</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_assertion_failure.c" depth="1" >
+<expressions><expression name="assertionFailure()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace><function name="main" line="14" file="bug_assertion_failure.c" depth="0" >
+<expressions><expression name="assertionFailure()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bt_bug_bad_memory_access.xml b/pathologist/refs/reports/ref_bt_bug_bad_memory_access.xml
new file mode 100644
index 0000000..8647995
--- /dev/null
+++ b/pathologist/refs/reports/ref_bt_bug_bad_memory_access.xml
@@ -0,0 +1,103 @@
+<?xml version="1.0"?>
+<crash category="Bad memory access" function="badMemoryAccess" line="9" file="bug_bad_memory_access.c" >
+<valgrind>==10333== Memcheck, a memory error detector
+==10333== Copyright (C) 2002-2010, and GNU GPL&apos;d, by Julian Seward et al.
+==10333== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info
+==10333== Command: ../../refs/src/bug_bad_memory_access
+==10333== Parent PID: 10332
+==10333== 
+==10333== Invalid write of size 4
+==10333==    at 0x80483D0: badMemoryAccess (bug_bad_memory_access.c:9)
+==10333==    by 0x80483E2: main (bug_bad_memory_access.c:14)
+==10333==  Address 0x4252352 is not stack&apos;d, malloc&apos;d or (recently) free&apos;d
+==10333== 
+==10333== 
+==10333== Process terminating with default action of signal 11 (SIGSEGV)
+==10333==  Access not within mapped region at address 0x4252352
+==10333==    at 0x80483D0: badMemoryAccess (bug_bad_memory_access.c:9)
+==10333==    by 0x80483E2: main (bug_bad_memory_access.c:14)
+==10333==  If you believe this happened as a result of a stack
+==10333==  overflow in your program&apos;s main thread (unlikely but
+==10333==  possible), you can try to increase the size of the
+==10333==  main thread stack using the --main-stacksize= flag.
+==10333==  The main thread stack size used in this run was 16777216.
+==10333== 
+==10333== HEAP SUMMARY:
+==10333==     in use at exit: 0 bytes in 0 blocks
+==10333==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
+==10333== 
+==10333== All heap blocks were freed -- no leaks are possible
+==10333== 
+==10333== For counts of detected and suppressed errors, rerun with: -v
+==10333== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 11 from 6)</valgrind>
+<history><epoch step="0" >
+<trace><function name="badMemoryAccess" line="9" file="bug_bad_memory_access.c" depth="0" >
+<expressions><expression name="*p" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Bad memory access now!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="0x4252352" >
+69542738</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_bad_memory_access.c" depth="1" >
+<expressions><expression name="badMemoryAccess()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace><function name="badMemoryAccess" line="8" file="bug_bad_memory_access.c" depth="0" >
+<expressions><expression name="printf(&quot;Bad memory access now!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="0x4252352" >
+69542738</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_bad_memory_access.c" depth="1" >
+<expressions><expression name="badMemoryAccess()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace><function name="badMemoryAccess" line="7" file="bug_bad_memory_access.c" depth="0" >
+<expressions><expression name="0x4252352" >
+69542738</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_bad_memory_access.c" depth="1" >
+<expressions><expression name="badMemoryAccess()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace><function name="main" line="14" file="bug_bad_memory_access.c" depth="0" >
+<expressions><expression name="badMemoryAccess()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bt_bug_division_by_zero_depth_1.xml b/pathologist/refs/reports/ref_bt_bug_division_by_zero_depth_1.xml
new file mode 100644
index 0000000..7ae29ed
--- /dev/null
+++ b/pathologist/refs/reports/ref_bt_bug_division_by_zero_depth_1.xml
@@ -0,0 +1,264 @@
+<?xml version="1.0"?>
+<crash category="Division By Zero" function="main" line="14" file="bug_division_by_zero_loop.c" >
+<history><epoch step="0" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+Not Evaluated</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+0</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace><function name="main" line="13" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace><function name="main" line="11" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace><function name="main" line="15" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="4" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+-10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="5" >
+<trace><function name="main" line="13" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+-10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="6" >
+<trace><function name="main" line="11" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+-10</expression>
+<expression name="i&lt;5" >
+0</expression>
+<expression name="i" >
+1075441652</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="7" >
+<trace><function name="main" line="10" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+-10</expression>
+<expression name="i&lt;5" >
+0</expression>
+<expression name="i" >
+1075441652</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="8" >
+<trace><function name="main" line="8" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+-1073801840</expression>
+<expression name="i&lt;5" >
+0</expression>
+<expression name="i" >
+1075441652</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+1073801840</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="9" >
+<trace><function name="main" line="7" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+7</expression>
+<expression name="i&lt;5" >
+0</expression>
+<expression name="i" >
+1075441652</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+1073801840</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+134513787</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bt_bug_division_by_zero_nodepth.xml b/pathologist/refs/reports/ref_bt_bug_division_by_zero_nodepth.xml
new file mode 100644
index 0000000..408cb81
--- /dev/null
+++ b/pathologist/refs/reports/ref_bt_bug_division_by_zero_nodepth.xml
@@ -0,0 +1,130 @@
+<?xml version="1.0"?>
+<crash category="Division By Zero" function="main" line="14" file="bug_division_by_zero_loop.c" >
+<history><epoch step="0" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="result/k" >
+Not Evaluated</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace><function name="main" line="13" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace><function name="main" line="11" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace><function name="main" line="15" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="4" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="result/k" >
+-10</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="5" >
+<trace><function name="main" line="13" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+0</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="6" >
+<trace><function name="main" line="11" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="i&lt;5" >
+0</expression>
+<expression name="i" >
+1075441652</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="7" >
+<trace><function name="main" line="10" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="8" >
+<trace><function name="main" line="8" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="result" >
+1073801840</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+-1</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="9" >
+<trace><function name="main" line="7" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="-1" >
+-1</expression>
+<expression name="k" >
+134513787</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bt_bug_null_pointer_exception.xml b/pathologist/refs/reports/ref_bt_bug_null_pointer_exception.xml
new file mode 100644
index 0000000..aca18f3
--- /dev/null
+++ b/pathologist/refs/reports/ref_bt_bug_null_pointer_exception.xml
@@ -0,0 +1,79 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0x0</expression>
+</expressions>
+</function>
+<function name="main" line="19" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace><function name="crashFunction" line="13" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0x0</expression>
+</expressions>
+</function>
+<function name="main" line="19" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace><function name="crashFunction" line="12" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0xbfffec38</expression>
+</expressions>
+</function>
+<function name="main" line="19" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace><function name="main" line="19" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bt_bug_null_pointer_exception_modified.xml b/pathologist/refs/reports/ref_bt_bug_null_pointer_exception_modified.xml
new file mode 100644
index 0000000..b22f5ad
--- /dev/null
+++ b/pathologist/refs/reports/ref_bt_bug_null_pointer_exception_modified.xml
@@ -0,0 +1,197 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="20" file="bug_null_pointer_exception_modified.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="20" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0x0</expression>
+<expression name="a+b" >
+8</expression>
+<expression name="c" >
+8</expression>
+<expression name="b" >
+5</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="1" >
+<trace><function name="crashFunction" line="19" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0x0</expression>
+<expression name="a+b" >
+8</expression>
+<expression name="c" >
+8</expression>
+<expression name="b" >
+5</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="2" >
+<trace><function name="crashFunction" line="18" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0xb7fc0ff4</expression>
+<expression name="a+b" >
+8</expression>
+<expression name="c" >
+8</expression>
+<expression name="b" >
+5</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="3" >
+<trace><function name="crashFunction" line="17" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="a+b" >
+8</expression>
+<expression name="c" >
+134520820</expression>
+<expression name="b" >
+5</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="4" >
+<trace><function name="crashFunction" line="16" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="b" >
+-1073746904</expression>
+<expression name="a" >
+3</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="5" >
+<trace><function name="crashFunction" line="15" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="a" >
+134513721</expression>
+</expressions>
+</function>
+<function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="2" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+<epoch step="6" >
+<trace><function name="intermediateFunction" line="25" file="bug_null_pointer_exception_modified.c" depth="0" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+</expressions>
+</function>
+<function name="main" line="30" file="bug_null_pointer_exception_modified.c" depth="1" >
+<expressions><expression name="intermediateFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecd4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_assertion_failure.xml b/pathologist/refs/reports/ref_bug_assertion_failure.xml
new file mode 100644
index 0000000..6117765
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_assertion_failure.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<crash category="Assertion Failure" function="assertionFailure" line="9" file="bug_assertion_failure.c" >
+<history><epoch step="0" >
+<trace><function name="assertionFailure" line="9" file="bug_assertion_failure.c" depth="0" >
+<expressions><expression name="assert(x&lt;4)" >
+Not Evaluated</expression>
+<expression name="x&lt;4" >
+0</expression>
+<expression name="printf(&quot;Assertion Failure Now!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="x" >
+5</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_assertion_failure.c" depth="1" >
+<expressions><expression name="assertionFailure()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecf4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_bad_food.xml b/pathologist/refs/reports/ref_bug_bad_food.xml
new file mode 100644
index 0000000..485a4e0
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_bad_food.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0"?>
+<crash category="Bad memory access" function="main" line="8" file="bug_bad_food.c" >
+<valgrind>==563== Memcheck, a memory error detector
+==563== Copyright (C) 2002-2010, and GNU GPL&apos;d, by Julian Seward et al.
+==563== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info
+==563== Command: ../../refs/src/bug_bad_food
+==563== Parent PID: 562
+==563== 
+==563== Invalid read of size 4
+==563==    at 0x804840D: main (bug_bad_food.c:8)
+==563==  Address 0xbaadf00d is not stack&apos;d, malloc&apos;d or (recently) free&apos;d
+==563== 
+==563== 
+==563== Process terminating with default action of signal 11 (SIGSEGV)
+==563==  Access not within mapped region at address 0xBAADF00D
+==563==    at 0x804840D: main (bug_bad_food.c:8)
+==563==  If you believe this happened as a result of a stack
+==563==  overflow in your program&apos;s main thread (unlikely but
+==563==  possible), you can try to increase the size of the
+==563==  main thread stack using the --main-stacksize= flag.
+==563==  The main thread stack size used in this run was 16777216.
+==563== 
+==563== HEAP SUMMARY:
+==563==     in use at exit: 0 bytes in 0 blocks
+==563==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
+==563== 
+==563== All heap blocks were freed -- no leaks are possible
+==563== 
+==563== For counts of detected and suppressed errors, rerun with: -v
+==563== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 11 from 6)</valgrind>
+<history><epoch step="0" >
+<trace><function name="main" line="8" file="bug_bad_food.c" depth="0" >
+<expressions><expression name="NULL" >
+0x0</expression>
+<expression name="0xBAADF00D" >
+3131961357</expression>
+<expression name="argv" >
+0xbfffecc4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_bad_memory_access.xml b/pathologist/refs/reports/ref_bug_bad_memory_access.xml
new file mode 100644
index 0000000..bee2441
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_bad_memory_access.xml
@@ -0,0 +1,55 @@
+<?xml version="1.0"?>
+<crash category="Bad memory access" function="badMemoryAccess" line="9" file="bug_bad_memory_access.c" >
+<valgrind>==10321== Memcheck, a memory error detector
+==10321== Copyright (C) 2002-2010, and GNU GPL&apos;d, by Julian Seward et al.
+==10321== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info
+==10321== Command: ../../refs/src/bug_bad_memory_access
+==10321== Parent PID: 10320
+==10321== 
+==10321== Invalid write of size 4
+==10321==    at 0x80483D0: badMemoryAccess (bug_bad_memory_access.c:9)
+==10321==    by 0x80483E2: main (bug_bad_memory_access.c:14)
+==10321==  Address 0x4252352 is not stack&apos;d, malloc&apos;d or (recently) free&apos;d
+==10321== 
+==10321== 
+==10321== Process terminating with default action of signal 11 (SIGSEGV)
+==10321==  Access not within mapped region at address 0x4252352
+==10321==    at 0x80483D0: badMemoryAccess (bug_bad_memory_access.c:9)
+==10321==    by 0x80483E2: main (bug_bad_memory_access.c:14)
+==10321==  If you believe this happened as a result of a stack
+==10321==  overflow in your program&apos;s main thread (unlikely but
+==10321==  possible), you can try to increase the size of the
+==10321==  main thread stack using the --main-stacksize= flag.
+==10321==  The main thread stack size used in this run was 16777216.
+==10321== 
+==10321== HEAP SUMMARY:
+==10321==     in use at exit: 0 bytes in 0 blocks
+==10321==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
+==10321== 
+==10321== All heap blocks were freed -- no leaks are possible
+==10321== 
+==10321== For counts of detected and suppressed errors, rerun with: -v
+==10321== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 11 from 6)</valgrind>
+<history><epoch step="0" >
+<trace><function name="badMemoryAccess" line="9" file="bug_bad_memory_access.c" depth="0" >
+<expressions><expression name="*p" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Bad memory access now!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="0x4252352" >
+69542738</expression>
+</expressions>
+</function>
+<function name="main" line="14" file="bug_bad_memory_access.c" depth="1" >
+<expressions><expression name="badMemoryAccess()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffecb4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_division_by_zero_depth_1.xml b/pathologist/refs/reports/ref_bug_division_by_zero_depth_1.xml
new file mode 100644
index 0000000..5095fd0
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_division_by_zero_depth_1.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<crash category="Division By Zero" function="main" line="14" file="bug_division_by_zero_loop.c" >
+<history><epoch step="0" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+Not Evaluated</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+0</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_division_by_zero_depth_1000.xml b/pathologist/refs/reports/ref_bug_division_by_zero_depth_1000.xml
new file mode 100644
index 0000000..5095fd0
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_division_by_zero_depth_1000.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<crash category="Division By Zero" function="main" line="14" file="bug_division_by_zero_loop.c" >
+<history><epoch step="0" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="printf(&quot;result = %d\n&quot;,result)" >
+Not Evaluated</expression>
+<expression name="result/k" >
+Not Evaluated</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+<expression name="printf(&quot;I am alive!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="result" >
+-10</expression>
+<expression name="-1" >
+-1</expression>
+<expression name="k" >
+0</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_division_by_zero_nodepth.xml b/pathologist/refs/reports/ref_bug_division_by_zero_nodepth.xml
new file mode 100644
index 0000000..5bf6472
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_division_by_zero_nodepth.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<crash category="Division By Zero" function="main" line="14" file="bug_division_by_zero_loop.c" >
+<history><epoch step="0" >
+<trace><function name="main" line="14" file="bug_division_by_zero_loop.c" depth="0" >
+<expressions><expression name="result/k" >
+Not Evaluated</expression>
+<expression name="i&lt;5" >
+1</expression>
+<expression name="i" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/reports/ref_bug_null_pointer_exception.xml b/pathologist/refs/reports/ref_bug_null_pointer_exception.xml
new file mode 100644
index 0000000..cced7bd
--- /dev/null
+++ b/pathologist/refs/reports/ref_bug_null_pointer_exception.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<crash category="npe" function="crashFunction" line="14" file="bug_null_pointer_exception.c" >
+<history><epoch step="0" >
+<trace><function name="crashFunction" line="14" file="bug_null_pointer_exception.c" depth="0" >
+<expressions><expression name="crashStruct-&gt;crashValue" >
+Not Evaluated</expression>
+<expression name="printf(&quot;Now the program will crash!\n&quot;)" >
+Not Evaluated</expression>
+<expression name="NULL" >
+0x0</expression>
+<expression name="crashStruct" >
+0x0</expression>
+</expressions>
+</function>
+<function name="main" line="19" file="bug_null_pointer_exception.c" depth="1" >
+<expressions><expression name="crashFunction()" >
+Not Evaluated</expression>
+<expression name="argv" >
+0xbfffece4</expression>
+<expression name="argc" >
+1</expression>
+</expressions>
+</function>
+</trace>
+</epoch>
+</history>
+</crash>
diff --git a/pathologist/refs/src/Makefile.am b/pathologist/refs/src/Makefile.am
new file mode 100644
index 0000000..63d622a
--- /dev/null
+++ b/pathologist/refs/src/Makefile.am
@@ -0,0 +1,41 @@
+if MINGW
+        WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols
+endif
+
+
+if USE_COVERAGE
+        AM_CFLAGS = --coverage -g -O0
+        XLIB = -lgcov
+else
+        AM_CFLAGS = -g -O0
+endif
+
+
+noinst_PROGRAMS =
+        bug_null_pointer_exception \
+        bug_bad_memory_access \
+        bug_assertion_failure \
+        bug_crypto_crc \
+        bug_division_by_zero_loop \
+        bug_null_pointer_exception_modified \
+        bug_sigbus \
+        bug_bad_food
+
+check_PROGRAMS = \
+        bug_null_pointer_exception \
+        bug_bad_memory_access \
+        bug_assertion_failure \
+        bug_crypto_crc \
+        bug_division_by_zero_loop \
+        bug_null_pointer_exception_modified \
+        bug_sigbus \
+        bug_bad_food
+
+bug_null_pointer_exception_SOURCES = bug_null_pointer_exception.c
+bug_bad_memory_access_SOURCES = bug_bad_memory_access.c
+bug_assertion_failure_SOURCES = bug_assertion_failure.c
+bug_crypto_crc_SOURCES = bug_crypto_crc.c
+bug_division_by_zero_loop_SOURCES = bug_division_by_zero_loop.c
+bug_null_pointer_exception_modified_SOURCES = bug_null_pointer_exception_modified.c
+bug_sigbus_SOURCES = bug_sigbus.c
+bug_bad_food_SOURCES = bug_bad_food.c
diff --git a/pathologist/refs/src/bug_assertion_failure.c b/pathologist/refs/src/bug_assertion_failure.c
new file mode 100644
index 0000000..2dbc3f0
--- /dev/null
+++ b/pathologist/refs/src/bug_assertion_failure.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <assert.h>
+
+void assertionFailure()
+{
+        int x;
+        x = 5;
+        printf("Assertion Failure Now!\n");
+        assert(x < 4);
+}
+
+int main(int argc, char *argv[])
+{
+        assertionFailure();
+        return 0;
+}
diff --git a/pathologist/refs/src/bug_bad_food.c b/pathologist/refs/src/bug_bad_food.c
new file mode 100644
index 0000000..8c4de54
--- /dev/null
+++ b/pathologist/refs/src/bug_bad_food.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+  void *badfood = (void*) (long) 0xBAADF00D;
+  void *nil = NULL;
+
+  fprintf (stderr, "%d\n",
+           (int) (long) * (int*) ((1 == argc) ? badfood : nil));
+  return 0;
+}
diff --git a/pathologist/refs/src/bug_bad_memory_access.c b/pathologist/refs/src/bug_bad_memory_access.c
new file mode 100644
index 0000000..54e50ad
--- /dev/null
+++ b/pathologist/refs/src/bug_bad_memory_access.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <string.h>
+
+
+void badMemoryAccess()
+{
+        int *p = (int*) 0x4252352;
+        printf("Bad memory access now!\n");
+        *p = 5;
+}
+
+int main(int argc, char *argv[])
+{
+        badMemoryAccess();
+        return 0;
+}
diff --git a/pathologist/refs/src/bug_crypto_crc.c b/pathologist/refs/src/bug_crypto_crc.c
new file mode 100644
index 0000000..f252785
--- /dev/null
+++ b/pathologist/refs/src/bug_crypto_crc.c
@@ -0,0 +1,121 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006 Christian Grothoff (and other contributing authors)
+
+     GNUnet 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.
+
+     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+
+     For the actual CRC code:
+     Copyright abandoned; this code is in the public domain.
+     Provided to GNUnet by peter@horizon.com
+*/
+
+/**
+ * @file monkey/bug_crypto_crc.c
+ * @brief implementation of CRC32 (this code has been copied from GNUnet util source directory, and modified to be Seaspider friendly)
+ * @author Christian Grothoff, Safey A.Halim
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+
+#define Z_NULL  0
+
+
+#define POLYNOMIAL (unsigned long)0xedb88320
+static unsigned long crc_table[256];
+
+/*
+ * This routine writes each crc_table entry exactly once,
+ * with the ccorrect final value.  Thus, it is safe to call
+ * even on a table that someone else is using concurrently.
+ */
+static void 
+crc_init ()
+{
+  static int once;
+  unsigned int i, j;
+  unsigned long h = 1;
+
+  if (once)
+    return;
+  once = 1;
+  crc_table[0] = 0;
+  for (i = 128; i; i >>= 1)
+    {
+      h = (h >> 1) ^ ((h & 1) ? POLYNOMIAL : 0);
+      /* h is now crc_table[i] */
+      for (j = 0; j < 256; j += 2 * i)
+        crc_table[i + j] = crc_table[j] ^ h;
+    }
+}
+
+/*
+ * This computes the standard preset and inverted CRC, as used
+ * by most networking standards.  Start by passing in an initial
+ * chaining value of 0, and then pass in the return value from the
+ * previous crc32() call.  The final return value is the CRC.
+ * Note that this is a little-endian CRC, which is best used with
+ * data transmitted lsbit-first, and it should, itself, be appended
+ * to data in little-endian byte and bit order to preserve the
+ * property of detecting all burst errors of length 32 bits or less.
+ */
+static unsigned long
+crc_go (unsigned long crc, const char *buf, size_t len)
+{
+  crc_init ();
+  assert (crc_table[255] != 0);
+  crc ^= 0xffffffff;
+  while (len--)
+    crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+  return crc ^ 0xffffffff;
+}
+
+
+/**
+ * Compute the CRC32 checksum for the first len bytes of the buffer.
+ *
+ * @param buf the data over which we're taking the CRC
+ * @param len the length of the buffer
+ * @return the resulting CRC32 checksum
+ */
+int32_t
+crc32_n (const void *buf, size_t len)
+{
+  unsigned long crc;
+  crc = crc_go (0L, Z_NULL, 0);
+  crc = crc_go (crc, (char *) buf, len);
+  return crc;
+}
+
+
+int main ()
+{
+  char buf[1024];
+  int i;
+  for (i = 0; i < 1024; i++)
+  {
+     buf[i] = (char) i;
+  }
+  for (i = 0; i < 1024; i++)
+  {
+    printf("%d\n", crc32_n (&buf[i], 1024 - i));
+  }
+  return 0;
+}
+
+/* end of bug_crypto_crc.c */
diff --git a/pathologist/refs/src/bug_division_by_zero_loop.c b/pathologist/refs/src/bug_division_by_zero_loop.c
new file mode 100644
index 0000000..544b7d2
--- /dev/null
+++ b/pathologist/refs/src/bug_division_by_zero_loop.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+int
+main (int argc, char *argv[])
+{
+  int i, k, result, tmp;
+  k = -1;
+  result = 10;
+
+  printf("I am alive!\n");
+  for (i = 0; i < 5; i++)
+    {
+      k += i;
+      result = result / k;      /* Division by zero in second iteration */
+      printf("result = %d\n", result);
+    }
+  return 0;
+}
diff --git a/pathologist/refs/src/bug_null_pointer_exception.c b/pathologist/refs/src/bug_null_pointer_exception.c
new file mode 100644
index 0000000..4accd65
--- /dev/null
+++ b/pathologist/refs/src/bug_null_pointer_exception.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <string.h>
+
+
+struct CrashStruct {
+        const char *crashValue;
+};
+
+void crashFunction() 
+{
+        struct CrashStruct *crashStruct;
+        crashStruct = NULL;
+        printf("Now the program will crash!\n");
+        crashStruct->crashValue = "hello!";
+}
+
+int main(int argc, char *argv[]) 
+{
+        crashFunction();
+        return 0;
+}
diff --git a/pathologist/refs/src/bug_null_pointer_exception_modified.c b/pathologist/refs/src/bug_null_pointer_exception_modified.c
new file mode 100644
index 0000000..497b9f0
--- /dev/null
+++ b/pathologist/refs/src/bug_null_pointer_exception_modified.c
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <string.h>
+
+
+struct CrashStruct {
+        const char *crashValue;
+};
+
+void crashFunction()
+{
+        struct CrashStruct *crashStruct;
+        int a;
+        int b;
+        int c;
+        a = 3;
+        b = 5;
+        c = a + b;
+        crashStruct = NULL;
+        printf("Now the program will crash!\n");
+        crashStruct->crashValue = "hello!";
+}
+
+void intermediateFunction()
+{
+        crashFunction();
+}
+
+int main(int argc, char *argv[])
+{
+        intermediateFunction();
+        return 0;
+}
diff --git a/pathologist/refs/src/bug_sigbus.c b/pathologist/refs/src/bug_sigbus.c
new file mode 100644
index 0000000..39348ef
--- /dev/null
+++ b/pathologist/refs/src/bug_sigbus.c
@@ -0,0 +1,50 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+int main(int argc, char **argv)
+{
+//
+//      __asm__("pushf\n"
+//            "orl $0x40000, (%esp)\n"
+//            "popf");
+
+    int testvar = 0x12345678;
+    int *testvarp;
+
+    testvarp = &testvar;
+    printf("testvarp was %lx\n", testvarp);
+    printf("testvar was %lx\n", *testvarp);
+
+    testvarp = (int *)(((char *)testvarp) + 1);
+    printf("testvarp is %lx\n", testvarp);
+    printf("testvar is %lx\n", *testvarp);
+
+
+//      char* str;
+//      str = realloc(str,10);
+//      */
+//
+//      /*
+//    char *p;
+//
+//    __asm__("pushf\n"
+//            "orl $0x40000, (%esp)\n"
+//            "popf");
+//
+//    /*
+//     * malloc() always provides aligned memory.
+//     * Do not use stack variable like a[9], depending on the compiler you use,
+//     * a may not be aligned properly.
+//     */
+//    p = malloc(sizeof(int) + 1);
+//    memset(p, 0, sizeof(int) + 1);
+//
+//    /* making p unaligned */
+//    p++;
+//
+//    printf("%d\n", *(int *)p);
+//
+//    return 0;
+
+}
diff --git a/pathologist/src/Makefile.am b/pathologist/src/Makefile.am
new file mode 100644
index 0000000..d2b35f4
--- /dev/null
+++ b/pathologist/src/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = include mi util minixml pathologist .
+
diff --git a/pathologist/src/include/Makefile.am b/pathologist/src/include/Makefile.am
new file mode 100644
index 0000000..b301e48
--- /dev/null
+++ b/pathologist/src/include/Makefile.am
@@ -0,0 +1,9 @@
+SUBDIRS = .
+
+monkeyincludedir = $(includedir)/monkey
+
+monkeyinclude_HEADERS = \
+  monkey_common.h \
+  plibc.h \
+  gdbmi.h \
+  mxml.h
diff --git a/pathologist/src/include/gdbmi.h b/pathologist/src/include/gdbmi.h
new file mode 100644
index 0000000..588c50b
--- /dev/null
+++ b/pathologist/src/include/gdbmi.h
@@ -0,0 +1,730 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2009 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Comments:
+  Main header for libmigdb.
+  
+***************************************************************************/
+
+#ifndef GDBMI_H
+#define GDBMI_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h> /* pid_t */
+
+#define MI_OK                      0
+#define MI_OUT_OF_MEMORY           1
+#define MI_PIPE_CREATE             2
+#define MI_FORK                    3
+#define MI_DEBUGGER_RUN            4
+#define MI_PARSER                  5
+#define MI_UNKNOWN_ASYNC           6
+#define MI_UNKNOWN_RESULT          7
+#define MI_FROM_GDB                8
+#define MI_GDB_TIME_OUT            9
+#define MI_GDB_DIED               10
+#define MI_MISSING_XTERM          11
+#define MI_CREATE_TEMPORAL        12
+#define MI_MISSING_GDB            13
+#define MI_LAST_ERROR             13
+
+#define MI_R_NONE                  0 /* We are no waiting any response. */
+#define MI_R_SKIP                  1 /* We want to discard it. */
+#define MI_R_FE_AND_S              2 /* Wait for done. */
+#define MI_R_E_ARGS                3
+
+enum mi_val_type { t_const, t_tuple, t_list };
+
+/* Types and subtypes. */
+/* Type. */
+#define MI_T_OUT_OF_BAND   0
+#define MI_T_RESULT_RECORD 1
+/* Out of band subtypes. */
+#define MI_ST_ASYNC        0
+#define MI_ST_STREAM       1
+/* Async sub-subtypes. */
+#define MI_SST_EXEC        0
+#define MI_SST_STATUS      1
+#define MI_SST_NOTIFY      2
+/* Stream sub-subtypes. */
+#define MI_SST_CONSOLE     3
+#define MI_SST_TARGET      4
+#define MI_SST_LOG         5
+/* Classes. */
+/* Async classes. */
+#define MI_CL_UNKNOWN      0
+#define MI_CL_STOPPED      1
+#define MI_CL_DOWNLOAD     2
+/* Result classes. */
+#define MI_CL_DONE         2
+#define MI_CL_RUNNING      3
+#define MI_CL_CONNECTED    4
+#define MI_CL_ERROR        5
+#define MI_CL_EXIT         6
+
+#define MI_DEFAULT_TIME_OUT 10
+
+#define MI_DIS_ASM        0
+#define MI_DIS_SRC_ASM    1
+
+/* Implemented workaround for gdb bugs that we can dis/enable. */
+/* At least gdb<=6.1.1 fails to find a source file with absolute path if the
+   name is for a psym instead of a sym. psym==partially loaded symbol table. */
+#define MI_PSYM_SEARCH    0
+
+#define MI_VERSION_STR "0.8.12"
+#define MI_VERSION_MAJOR  0
+#define MI_VERSION_MIDDLE 8
+#define MI_VERSION_MINOR  12
+
+struct mi_results_struct
+{
+ char *var; /* Result name or NULL if just a value. */
+ enum mi_val_type type;
+ union
+ {
+  char *cstr;
+  struct mi_results_struct *rs;
+ } v;
+ struct mi_results_struct *next;
+};
+typedef struct mi_results_struct mi_results;
+
+struct mi_output_struct
+{
+ /* Type of output. */
+ char type;
+ char stype;
+ char sstype;
+ char tclass;
+ /* Content. */
+ mi_results *c;
+ /* Always modeled as a list. */
+ struct mi_output_struct *next;
+};
+typedef struct mi_output_struct mi_output;
+
+typedef void (*stream_cb)(const char *, void *);
+typedef void (*async_cb)(mi_output *o, void *);
+typedef int  (*tm_cb)(void *);
+
+/* Values of this structure shouldn't be manipulated by the user. */
+struct mi_h_struct
+{
+ /* Pipes connected to gdb. */
+ int to_gdb[2];
+ int from_gdb[2];
+ /* Streams for the pipes. */
+ FILE *to, *from;
+ /* PID of child gdb. */
+ pid_t pid;
+ char died;
+ /* Which rensponse we are waiting for. */
+ /*int response;*/
+ /* The line we are reading. */
+ char *line;
+ int   llen, lread;
+ /* Parsed output. */
+ mi_output *po, *last;
+ /* Tunneled streams callbacks. */
+ stream_cb console;
+ void *console_data;
+ stream_cb target;
+ void *target_data;
+ stream_cb log;
+ void *log_data;
+ /* Async responses callback. */
+ async_cb async;
+ void *async_data;
+ /* Callbacks to get echo of gdb dialog. */
+ stream_cb to_gdb_echo;
+ void *to_gdb_echo_data;
+ stream_cb from_gdb_echo;
+ void *from_gdb_echo_data;
+ /* Time out */
+ tm_cb time_out_cb;
+ void *time_out_cb_data;
+ int time_out;
+ /* Ugly workaround for some of the show responses :-( */
+ int catch_console;
+ char *catched_console;
+ /* MI version, currently unknown but the user can force v2 */
+ unsigned version;
+};
+typedef struct mi_h_struct mi_h;
+
+#define MI_TO(a) ((a)->to_gdb[1])
+
+enum mi_bkp_type { t_unknown=0, t_breakpoint=1, t_hw=2 };
+enum mi_bkp_disp { d_unknown=0, d_keep=1, d_del=2 };
+enum mi_bkp_mode { m_file_line=0, m_function=1, m_file_function=2, m_address=3 };
+
+struct mi_bkpt_struct
+{
+ int number;
+ enum mi_bkp_type type;
+ enum mi_bkp_disp disp; /* keep or del if temporal */
+ char enabled;
+ void *addr;
+ char *func;
+ char *file;
+ int line;
+ int ignore;
+ int times;
+
+ /* For the user: */
+ char *cond;
+ char *file_abs;
+ int thread;
+ enum mi_bkp_mode mode;
+ struct mi_bkpt_struct *next;
+};
+typedef struct mi_bkpt_struct mi_bkpt;
+
+enum mi_wp_mode { wm_unknown=0, wm_write=1, wm_read=2, wm_rw=3 };
+
+struct mi_wp_struct
+{
+ int number;
+ char *exp;
+ enum mi_wp_mode mode;
+
+ /* For the user: */
+ struct mi_wp_struct *next;
+ char enabled;
+};
+typedef struct mi_wp_struct mi_wp;
+
+struct mi_frames_struct
+{
+ int level;  /* The frame number, 0 being the topmost frame, i.e. the innermost
+                function. */
+ void *addr; /* The `$pc' value for that frame. */
+ char *func; /* Function name. */
+ char *file; /* File name of the source file where the function lives. */
+ char *from;
+ int line;   /* Line number corresponding to the `$pc'. */
+ /* When arguments are available: */
+ mi_results *args;
+ int thread_id;
+ /* When more than one is provided: */
+ struct mi_frames_struct *next;
+};
+typedef struct mi_frames_struct mi_frames;
+
+struct mi_aux_term_struct
+{
+ pid_t pid;
+ char *tty;
+};
+typedef struct mi_aux_term_struct mi_aux_term;
+
+struct mi_pty_struct
+{
+ char *slave;
+ int master;
+};
+typedef struct mi_pty_struct mi_pty;
+
+enum mi_gvar_fmt { fm_natural=0, fm_binary=1, fm_decimal=2, fm_hexadecimal=3,
+                   fm_octal=4,
+                   /* Only for registers format: */
+                   fm_raw=5 };
+enum mi_gvar_lang { lg_unknown=0, lg_c, lg_cpp, lg_java };
+
+#define MI_ATTR_DONT_KNOW   0
+#define MI_ATTR_NONEDITABLE 1
+#define MI_ATTR_EDITABLE    2
+
+struct mi_gvar_struct
+{
+ char *name;
+ int   numchild;
+ char *type;
+ enum mi_gvar_fmt format;
+ enum mi_gvar_lang lang;
+ char *exp;
+ int   attr;
+
+ /* MI v2 fills it, not yet implemented here. */
+ /* Use gmi_var_evaluate_expression. */
+ char *value;
+
+ /* Pointer to the parent. NULL if none. */
+ struct mi_gvar_struct *parent;
+ /* List containing the children.
+    Filled by gmi_var_list_children.
+    NULL if numchild==0 or not yet filled. */
+ struct mi_gvar_struct *child;
+ /* Next var in the list. */
+ struct mi_gvar_struct *next;
+
+ /* For the user: */
+ char opened;  /* We will show its children. 1 when we fill "child" */
+ char changed; /* Needs to be updated. 0 when created. */
+ int vischild; /* How many items visible. numchild when we fill "child" */
+ int depth;    /* How deep is this var. */
+ char ispointer;
+};
+typedef struct mi_gvar_struct mi_gvar;
+
+struct mi_gvar_chg_struct
+{
+ char *name;
+ int   in_scope;  /* if true the other fields apply. */
+ char *new_type;  /* NULL if type_changed==false */
+ int   new_num_children; /* only when new_type!=NULL */
+
+ struct mi_gvar_chg_struct *next;
+};
+typedef struct mi_gvar_chg_struct mi_gvar_chg;
+
+
+/* A list of assembler instructions. */
+struct mi_asm_insn_struct
+{
+ void *addr;
+ char *func;
+ unsigned offset;
+ char *inst;
+
+ struct mi_asm_insn_struct *next;
+};
+typedef struct mi_asm_insn_struct mi_asm_insn;
+
+/* A list of source lines containing assembler instructions. */
+struct mi_asm_insns_struct
+{
+ char *file;
+ int line;
+ mi_asm_insn *ins;
+
+ struct mi_asm_insns_struct *next;
+};
+typedef struct mi_asm_insns_struct mi_asm_insns;
+
+/* Changed register. */
+struct mi_chg_reg_struct
+{
+ int reg;
+ char *val;
+ char *name;
+ char updated;
+
+ struct mi_chg_reg_struct *next;
+};
+typedef struct mi_chg_reg_struct mi_chg_reg;
+
+/*
+ Examining gdb sources and looking at docs I can see the following "stop"
+reasons:
+
+Breakpoints:
+a) breakpoint-hit (bkptno) + frame
+Also: without reason for temporal breakpoints.
+
+Watchpoints:
+b) watchpoint-trigger (wpt={number,exp};value={old,new}) + frame
+c) read-watchpoint-trigger (hw-rwpt{number,exp};value={value}) + frame
+d) access-watchpoint-trigger (hw-awpt{number,exp};value={[old,]new}) + frame
+e) watchpoint-scope (wpnum) + frame
+
+Movement:
+f) function-finished ([gdb-result-var,return-value]) + frame
+g) location-reached + frame
+h) end-stepping-range + frame
+
+Exit:
+i) exited-signalled (signal-name,signal-meaning)
+j) exited (exit-code)
+k) exited-normally
+
+Signal:
+l) signal-received (signal-name,signal-meaning) + frame
+
+Plus: thread-id
+*/
+enum mi_stop_reason
+{
+ sr_unknown=0,
+ sr_bkpt_hit,
+ sr_wp_trigger, sr_read_wp_trigger, sr_access_wp_trigger, sr_wp_scope,
+ sr_function_finished, sr_location_reached, sr_end_stepping_range,
+ sr_exited_signalled, sr_exited, sr_exited_normally,
+ sr_signal_received
+};
+
+struct mi_stop_struct
+{
+ enum mi_stop_reason reason; /* If more than one reason just the last. */
+ /* Flags indicating if non-pointer fields are filled. */
+ char have_thread_id;
+ char have_bkptno;
+ char have_exit_code;
+ char have_wpno;
+ /* Where stopped. Doesn't exist for sr_exited*. */
+ int thread_id;
+ mi_frames *frame;
+ /* sr_bkpt_hit */
+ int bkptno;
+ /* sr_*wp_* no scope */
+ mi_wp *wp;
+ char *wp_old;
+ char *wp_val;
+ /* sr_wp_scope */
+ int wpno;
+ /* sr_function_finished. Not for void func. */
+ char *gdb_result_var;
+ char *return_value;
+ /* sr_exited_signalled, sr_signal_received */
+ char *signal_name;
+ char *signal_meaning;
+ /* sr_exited */
+ int exit_code;
+};
+typedef struct mi_stop_struct mi_stop;
+
+/* Variable containing the last error. */
+extern int mi_error;
+extern char *mi_error_from_gdb;
+const char *mi_get_error_str();
+
+/* Indicate the name of gdb exe. Default is /usr/bin/gdb */
+void mi_set_gdb_exe(const char *name);
+const char *mi_get_gdb_exe();
+/* Indicate the name of a file containing commands to send at start-up */
+void mi_set_gdb_start(const char *name);
+const char *mi_get_gdb_start();
+/* Indicate the name of a file containing commands to send after connection */
+void mi_set_gdb_conn(const char *name);
+const char *mi_get_gdb_conn();
+void mi_send_target_commands(mi_h *h);
+/* Connect to a local copy of gdb. */
+mi_h *mi_connect_local();
+/* Close connection. You should ask gdb to quit first. */
+void  mi_disconnect(mi_h *h);
+/* Force MI version. */
+#define MI_VERSION2U(maj,mid,min) (maj*0x1000000+mid*0x10000+min)
+void  mi_force_version(mi_h *h, unsigned vMajor, unsigned vMiddle,
+                       unsigned vMinor);
+void  mi_set_workaround(unsigned wa, int enable);
+int   mi_get_workaround(unsigned wa);
+/* Parse gdb output. */
+mi_output *mi_parse_gdb_output(const char *str);
+/* Functions to set/get the tunneled streams callbacks. */
+void mi_set_console_cb(mi_h *h, stream_cb cb, void *data);
+void mi_set_target_cb(mi_h *h, stream_cb cb, void *data);
+void mi_set_log_cb(mi_h *h, stream_cb cb, void *data);
+stream_cb mi_get_console_cb(mi_h *h, void **data);
+stream_cb mi_get_target_cb(mi_h *h, void **data);
+stream_cb mi_get_log_cb(mi_h *h, void **data);
+/* The callback to deal with async events. */
+void mi_set_async_cb(mi_h *h, async_cb cb, void *data);
+async_cb mi_get_async_cb(mi_h *h, void **data);
+/* Time out in gdb responses. */
+void mi_set_time_out_cb(mi_h *h, tm_cb cb, void *data);
+tm_cb mi_get_time_out_cb(mi_h *h, void **data);
+void mi_set_time_out(mi_h *h, int to);
+int mi_get_time_out(mi_h *h);
+/* Callbacks to "see" the dialog with gdb. */
+void mi_set_to_gdb_cb(mi_h *h, stream_cb cb, void *data);
+void mi_set_from_gdb_cb(mi_h *h, stream_cb cb, void *data);
+stream_cb mi_get_to_gdb_cb(mi_h *h, void **data);
+stream_cb mi_get_from_gdb_cb(mi_h *h, void **data);
+/* Sends a message to gdb. */
+int mi_send(mi_h *h, const char *format, ...);
+/* Wait until gdb sends a response. */
+mi_output *mi_get_response_blk(mi_h *h);
+/* Check if gdb sent a complete response. Use with mi_retire_response. */
+int mi_get_response(mi_h *h);
+/* Get the last response. Use with mi_get_response. */
+mi_output *mi_retire_response(mi_h *h);
+/* Look for a result record in gdb output. */
+mi_output *mi_get_rrecord(mi_output *r);
+/* Look if the output contains an async stop.
+   If that's the case return the reason for the stop.
+   If the output contains an error the description is returned in reason. */
+int mi_get_async_stop_reason(mi_output *r, char **reason);
+mi_stop *mi_get_stopped(mi_results *r);
+mi_frames *mi_get_async_frame(mi_output *r);
+/* Wait until gdb sends a response.
+   Then check if the response is of the desired type. */
+int mi_res_simple_exit(mi_h *h);
+int mi_res_simple_done(mi_h *h);
+int mi_res_simple_running(mi_h *h);
+int mi_res_simple_connected(mi_h *h);
+/* It additionally extracts an specified variable. */
+mi_results *mi_res_done_var(mi_h *h, const char *var);
+/* Extract a frames list from the response. */
+mi_frames *mi_res_frames_array(mi_h *h, const char *var);
+mi_frames *mi_res_frames_list(mi_h *h);
+mi_frames *mi_parse_frame(mi_results *c);
+mi_frames *mi_res_frame(mi_h *h);
+/* Create an auxiliar terminal using xterm. */
+mi_aux_term *gmi_start_xterm();
+/* Indicate the name of xterm exe. Default is /usr/bin/X11/xterm */
+void mi_set_xterm_exe(const char *name);
+const char *mi_get_xterm_exe();
+/* Kill the auxiliar terminal and release the structure. */
+void gmi_end_aux_term(mi_aux_term *t);
+/* Look for a free Linux VT for the child. */
+mi_aux_term *gmi_look_for_free_vt();
+/* Look for a free and usable Linux VT. */
+int mi_look_for_free_vt();
+/* Close master and release the structure. */
+void gmi_end_pty(mi_pty *p);
+/* Look for a free pseudo terminal. */
+mi_pty *gmi_look_for_free_pty();
+/* Extract a list of thread IDs from response. */
+int mi_res_thread_ids(mi_h *h, int **list);
+int mi_get_thread_ids(mi_output *res, int **list);
+/* A variable response. */
+mi_gvar *mi_res_gvar(mi_h *h, mi_gvar *cur, const char *expression);
+enum mi_gvar_fmt mi_format_str_to_enum(const char *format);
+const char *mi_format_enum_to_str(enum mi_gvar_fmt format);
+char mi_format_enum_to_char(enum mi_gvar_fmt format);
+enum mi_gvar_lang mi_lang_str_to_enum(const char *lang);
+const char *mi_lang_enum_to_str(enum mi_gvar_lang lang);
+int mi_res_changelist(mi_h *h, mi_gvar_chg **changed);
+int mi_res_children(mi_h *h, mi_gvar *v);
+mi_bkpt *mi_res_bkpt(mi_h *h);
+mi_wp *mi_res_wp(mi_h *h);
+char *mi_res_value(mi_h *h);
+mi_stop *mi_res_stop(mi_h *h);
+enum mi_stop_reason mi_reason_str_to_enum(const char *s);
+const char *mi_reason_enum_to_str(enum mi_stop_reason r);
+int mi_get_read_memory(mi_h *h, unsigned char *dest, unsigned ws, int *na,
+                       unsigned long *addr);
+mi_asm_insns *mi_get_asm_insns(mi_h *h);
+/* Starting point of the program. */
+void mi_set_main_func(const char *name);
+const char *mi_get_main_func();
+mi_chg_reg *mi_get_list_registers(mi_h *h, int *how_many);
+int mi_get_list_registers_l(mi_h *h, mi_chg_reg *l);
+mi_chg_reg *mi_get_list_changed_regs(mi_h *h);
+int mi_get_reg_values(mi_h *h, mi_chg_reg *l);
+mi_chg_reg *mi_get_reg_values_l(mi_h *h, int *how_many);
+int gmi_target_download(mi_h *h);
+
+/* Allocation functions: */
+void *mi_calloc(size_t count, size_t sz);
+void *mi_calloc1(size_t sz);
+char *mi_malloc(size_t sz);
+mi_results       *mi_alloc_results(void);
+mi_output        *mi_alloc_output(void);
+mi_frames        *mi_alloc_frames(void);
+mi_gvar          *mi_alloc_gvar(void);
+mi_gvar_chg      *mi_alloc_gvar_chg(void);
+mi_bkpt          *mi_alloc_bkpt(void);
+mi_wp            *mi_alloc_wp(void);
+mi_stop          *mi_alloc_stop(void);
+mi_asm_insns     *mi_alloc_asm_insns(void);
+mi_asm_insn      *mi_alloc_asm_insn(void);
+mi_chg_reg       *mi_alloc_chg_reg(void);
+void mi_free_output(mi_output *r);
+void mi_free_output_but(mi_output *r, mi_output *no, mi_results *no_r);
+void mi_free_frames(mi_frames *f);
+void mi_free_aux_term(mi_aux_term *t);
+void mi_free_results(mi_results *r);
+void mi_free_results_but(mi_results *r, mi_results *no);
+void mi_free_gvar(mi_gvar *v);
+void mi_free_gvar_chg(mi_gvar_chg *p);
+void mi_free_wp(mi_wp *wp);
+void mi_free_stop(mi_stop *s);
+void mi_free_asm_insns(mi_asm_insns *i);
+void mi_free_asm_insn(mi_asm_insn *i);
+void mi_free_charp_list(char **l);
+void mi_free_chg_reg(mi_chg_reg *r);
+
+/* Porgram control: */
+/* Specify the executable and arguments for local debug. */
+int gmi_set_unwind_on_signal_on(mi_h * h);
+int gmi_set_exec(mi_h *h, const char *file, const char *args);
+/* Start running the executable. Remote sessions starts running. */
+int gmi_exec_run(mi_h *h);
+/* Continue the execution after a "stop". */
+int gmi_exec_continue(mi_h *h);
+/* Continue the execution in reverse order after a "stop". */
+int gmi_exec_continue_reverse(mi_h *h);
+/* Indicate which terminal will use the target program. For local sessions. */
+int gmi_target_terminal(mi_h *h, const char *tty_name);
+/* Specify what's the local copy that have debug info. For remote sessions. */
+int gmi_file_symbol_file(mi_h *h, const char *file);
+/* Continue until function return, the return value is included in the async
+   response. */
+int gmi_exec_finish(mi_h *h);
+/* Continue backwardly until function return, the return value is included in
+  the async response.*/
+int gmi_exec_finish_reverse(mi_h *h);
+/* Stop the program using SIGINT. */
+int gmi_exec_interrupt(mi_h *h);
+/* Next line of code. */
+int gmi_exec_next(mi_h *h);
+/* Start recording a process */
+int gmi_exec_record_process(mi_h *h);
+/* Stop recording a process */
+int gmi_exec_record_stop(mi_h *h);
+/* Next count lines of code. */
+int gmi_exec_next_cnt(mi_h *h, int count);
+/* Next line of assembler code. */
+int gmi_exec_next_instruction(mi_h *h);
+/* Next line of code. Get inside functions. */
+int gmi_exec_step(mi_h *h);
+/* Previous line of code. Get inside functions. */
+int gmi_exec_step_back(mi_h *h);
+/*  Previous line of code (do not step into).*/
+int gmi_exec_next_reverse(mi_h *h);
+/* Next count lines of code. Get inside functions. */
+int gmi_exec_step_cnt(mi_h *h, int count);
+/* Next line of assembler code. Get inside calls. */
+int gmi_exec_step_instruction(mi_h *h);
+/* Execute until location is reached. If file is NULL then is until next line. */
+int gmi_exec_until(mi_h *h, const char *file, int line);
+int gmi_exec_until_addr(mi_h *h, void *addr);
+/* Return to previous frame inmediatly. */
+mi_frames *gmi_exec_return(mi_h *h);
+/* Just kill the program. Please read the notes in prg_control.c. */
+int gmi_exec_kill(mi_h *h);
+
+/* Target manipulation: */
+/* Connect to a remote gdbserver using the specified methode. */
+int gmi_target_select(mi_h *h, const char *type, const char *params);
+/* Attach to an already running process. */
+mi_frames *gmi_target_attach(mi_h *h, pid_t pid);
+/* Detach from an attached process. */
+int gmi_target_detach(mi_h *h);
+
+/* Miscellaneous commands: */
+/* Exit gdb killing the child is it is running. */
+void gmi_gdb_exit(mi_h *h);
+/* Send the version to the console. */
+int gmi_gdb_version(mi_h *h);
+/* Set a gdb variable. */
+int gmi_gdb_set(mi_h *h, const char *var, const char *val);
+/* Get a gdb variable. */
+char *gmi_gdb_show(mi_h *h, const char *var);
+
+/* Breakpoints manipulation: */
+/* Insert a breakpoint at file:line. */
+mi_bkpt *gmi_break_insert(mi_h *h, const char *file, int line);
+/* Insert a breakpoint, all available options. */
+mi_bkpt *gmi_break_insert_full(mi_h *h, int temporary, int hard_assist,
+                               const char *cond, int count, int thread,
+                               const char *where);
+mi_bkpt *gmi_break_insert_full_fl(mi_h *h, const char *file, int line,
+                                  int temporary, int hard_assist,
+                                  const char *cond, int count, int thread);
+/* Remove a breakpoint. */
+int gmi_break_delete(mi_h *h, int number);
+/* Free the memory used for a breakpoint description. */
+void mi_free_bkpt(mi_bkpt *b);
+/* Modify the "ignore" count for a breakpoint. */
+int gmi_break_set_times(mi_h *h, int number, int count);
+/* Associate a condition with the breakpoint. */
+int gmi_break_set_condition(mi_h *h, int number, const char *condition);
+/* Enable or disable a breakpoint. */
+int gmi_break_state(mi_h *h, int number, int enable);
+/* Set a watchpoint. It doesn't work for remote targets! */
+mi_wp *gmi_break_watch(mi_h *h, enum mi_wp_mode mode, const char *exp);
+
+/* Data Manipulation. */
+/* Evaluate an expression. Returns a parsed tree. */
+char *gmi_data_evaluate_expression(mi_h *h, const char *expression);
+/* Path for sources. */
+int gmi_dir(mi_h *h, const char *path);
+/* A very limited "data read memory" implementation. */
+int gmi_read_memory(mi_h *h, const char *exp, unsigned size,
+                    unsigned char *dest, int *na, int convAddr,
+                    unsigned long *addr);
+mi_asm_insns *gmi_data_disassemble_se(mi_h *h, const char *start,
+                                      const char *end, int mode);
+mi_asm_insns *gmi_data_disassemble_fl(mi_h *h, const char *file, int line,
+                                      int lines, int mode);
+mi_chg_reg *gmi_data_list_register_names(mi_h *h, int *how_many);
+int gmi_data_list_register_names_l(mi_h *h, mi_chg_reg *l);
+mi_chg_reg *gmi_data_list_changed_registers(mi_h *h);
+int gmi_data_list_register_values(mi_h *h, enum mi_gvar_fmt fmt, mi_chg_reg *l);
+mi_chg_reg *gmi_data_list_all_register_values(mi_h *h, enum mi_gvar_fmt fmt, int *how_many);
+
+/* Stack manipulation. */
+/* List of frames. Arguments aren't filled. */
+mi_frames *gmi_stack_list_frames(mi_h *h);
+/* List of frames. Indicating a range. */
+mi_frames *gmi_stack_list_frames_r(mi_h *h, int from, int to);
+/* List arguments. Only level and args filled. */
+mi_frames *gmi_stack_list_arguments(mi_h *h, int show);
+/* List arguments. Indicating a range. Only level and args filled. */
+mi_frames *gmi_stack_list_arguments_r(mi_h *h, int show, int from, int to);
+/* Information about the current frame, including args. */
+mi_frames *gmi_stack_info_frame(mi_h *h);
+/* Stack info depth. error => -1 */
+int gmi_stack_info_depth_get(mi_h *h);
+/* Set stack info depth. error => -1 */
+int gmi_stack_info_depth(mi_h *h, int max_depth);
+/* Change current frame. */
+int gmi_stack_select_frame(mi_h *h, int framenum);
+/* List of local vars. */
+mi_results *gmi_stack_list_locals(mi_h *h, int show);
+
+/* Thread. */
+/* List available thread ids. */
+int gmi_thread_list_ids(mi_h *h, int **list);
+/* Select a thread. */
+mi_frames *gmi_thread_select(mi_h *h, int id);
+/* List available threads. */
+mi_frames *gmi_thread_list_all_threads(mi_h *h);
+
+/* Variable objects. */
+/* Create a variable object. */
+mi_gvar *gmi_var_create_nm(mi_h *h, const char *name, int frame, const char *exp);
+mi_gvar *gmi_var_create(mi_h *h, int frame, const char *exp);
+/* Create the variable and also fill the lang and attr fields. */
+mi_gvar *gmi_full_var_create(mi_h *h, int frame, const char *exp);
+/* Delete a variable object. Doesn't free the mi_gvar data. */
+int gmi_var_delete(mi_h *h, mi_gvar *var);
+/* Set the format used to represent the result. */
+int gmi_var_set_format(mi_h *h, mi_gvar *var, enum mi_gvar_fmt format);
+/* Fill the format field with info from gdb. */
+int gmi_var_show_format(mi_h *h, mi_gvar *var);
+/* Fill the numchild field with info from gdb. */
+int gmi_var_info_num_children(mi_h *h, mi_gvar *var);
+/* Fill the type field with info from gdb. */
+int gmi_var_info_type(mi_h *h, mi_gvar *var);
+/* Fill the expression and lang fields with info from gdb.
+   Note that lang isn't filled during creation. */
+int gmi_var_info_expression(mi_h *h, mi_gvar *var);
+/* Fill the attr field with info from gdb.
+   Note that attr isn't filled during creation. */
+int gmi_var_show_attributes(mi_h *h, mi_gvar *var);
+/* Update variable. Use NULL for all.
+   Note that *changed can be NULL if none updated. */
+int gmi_var_update(mi_h *h, mi_gvar *var, mi_gvar_chg **changed);
+/* Change variable. Fills the value field. */
+int gmi_var_assign(mi_h *h, mi_gvar *var, const char *expression);
+/* Get current value for a variable. */
+int gmi_var_evaluate_expression(mi_h *h, mi_gvar *var);
+/* List children. It ONLY returns the first level information. :-( */
+int gmi_var_list_children(mi_h *h, mi_gvar *var);
+
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pathologist/src/include/monkey_common.h b/pathologist/src/include/monkey_common.h
new file mode 100644
index 0000000..4973ac5
--- /dev/null
+++ b/pathologist/src/include/monkey_common.h
@@ -0,0 +1,443 @@
+/**
+ * @file monkey_common.h
+ * @brief commonly used definitions
+ * @author Safey A.Halim
+ */
+
+#ifndef MONKEY_COMMON_H
+#define MONKEY_COMMON_H
+
+#include <stdio.h>
+/**
+ * Named constants for return values.
+ */
+#define MONKEY_OK      1
+#define MONKEY_SYSERR -1
+#define MONKEY_YES     1
+#define MONKEY_NO      0
+
+/**
+ * Use this for fatal errors that cannot be handled
+ */
+#define MONKEY_assert(cond) do { if (! (cond)) { fprintf(stderr, "Assertion failed at %s:%d.\n", __FILE__, __LINE__); abort(); } } while(0)
+
+/**
+ * Use this for fatal errors that cannot be handled
+ */
+#define MONKEY_assert_at(cond, f, l) do { if (! (cond)) { fprintf(stderr, "Assertion failed at %s:%d.\n", f, l); abort(); } } while(0)
+
+/**
+ * Use this for internal assertion violations that are
+ * not fatal (can be handled) but should not occur.
+ */
+#define MONKEY_break(cond)  do { if (! (cond)) { fprintf(stderr, "Assertion failed at %s:%d.\n", __FILE__, __LINE__); } } while(0)
+
+
+/* ******************** doubly-linked list *************** */
+/* To avoid mistakes: head->prev == tail->next == NULL     */
+
+/**
+ * Insert an element at the head of a DLL. Assumes that head, tail and
+ * element are structs with prev and next fields.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert(head,tail,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->next = (head); \
+  (element)->prev = NULL; \
+  if ((tail) == NULL) \
+    (tail) = element; \
+  else \
+    (head)->prev = element; \
+  (head) = (element); } while (0)
+
+
+/**
+ * Insert an element at the tail of a DLL. Assumes that head, tail and
+ * element are structs with prev and next fields.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert_tail(head,tail,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->prev = (tail); \
+  (element)->next = NULL; \
+  if ((head) == NULL) \
+    (head) = element; \
+  else \
+    (tail)->next = element; \
+  (tail) = (element); } while (0)
+
+
+/**
+ * Insert an element into a DLL after the given other element.  Insert
+ * at the head if the other element is NULL.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param other prior element, NULL for insertion at head of DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert_after(head,tail,other,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->prev = (other); \
+  if (NULL == other) \
+    { \
+      (element)->next = (head); \
+      (head) = (element); \
+    } \
+  else \
+    { \
+      (element)->next = (other)->next; \
+      (other)->next = (element); \
+    } \
+  if (NULL == (element)->next) \
+    (tail) = (element); \
+  else \
+    (element)->next->prev = (element); } while (0)
+
+
+/**
+ * Insert an element into a DLL before the given other element.  Insert
+ * at the tail if the other element is NULL.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param other prior element, NULL for insertion at head of DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert_before(head,tail,other,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->next = (other); \
+  if (NULL == other) \
+    { \
+      (element)->prev = (tail); \
+      (tail) = (element); \
+    } \
+  else \
+    { \
+      (element)->prev = (other)->prev; \
+      (other)->prev = (element); \
+    } \
+  if (NULL == (element)->prev) \
+    (head) = (element); \
+  else \
+    (element)->prev->next = (element); } while (0)
+
+
+/**
+ * Remove an element from a DLL. Assumes
+ * that head, tail and element are structs
+ * with prev and next fields.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param element element to remove
+ */
+#define MONKEY_CONTAINER_DLL_remove(head,tail,element) do { \
+  MONKEY_assert ( ( (element)->prev != NULL) || ((head) == (element))); \
+  MONKEY_assert ( ( (element)->next != NULL) || ((tail) == (element))); \
+  if ((element)->prev == NULL) \
+    (head) = (element)->next;  \
+  else \
+    (element)->prev->next = (element)->next; \
+  if ((element)->next == NULL) \
+    (tail) = (element)->prev;  \
+  else \
+    (element)->next->prev = (element)->prev; \
+  (element)->next = NULL; \
+  (element)->prev = NULL; } while (0)
+
+
+#define MONKEY_MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+#define MONKEY_MAX(a,b) (((a) > (b)) ? (a) : (b))
+
+/* ************************* allocation functions ****************** */
+
+/**
+ * Maximum allocation with MONKEY_malloc macro.
+ */
+#define MONKEY_MAX_MALLOC_CHECKED (1024 * 1024 * 40)
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate, must be
+ *        smaller than 40 MB.
+ * @return pointer to size bytes of memory, never NULL (!)
+ */
+#define MONKEY_malloc(size) MONKEY_xmalloc_(size, __FILE__, __LINE__)
+
+/**
+ * Allocate and initialize a block of memory.
+ *
+ * @param buf data to initalize the block with
+ * @param size the number of bytes in buf (and size of the allocation)
+ * @return pointer to size bytes of memory, never NULL (!)
+ */
+#define MONKEY_memdup(buf,size) MONKEY_xmemdup_(buf, size, __FILE__, __LINE__)
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
+#define MONKEY_malloc_large(size) MONKEY_xmalloc_unchecked_(size, __FILE__, __LINE__)
+
+/**
+ * Wrapper around realloc. Rellocates size bytes of memory.
+ *
+ * @param ptr the pointer to reallocate
+ * @param size the number of bytes to reallocate
+ * @return pointer to size bytes of memory
+ */
+#define MONKEY_realloc(ptr, size) MONKEY_xrealloc_(ptr, size, __FILE__, __LINE__)
+
+/**
+ * Wrapper around free. Frees the memory referred to by ptr.
+ * Note that is is generally better to free memory that was
+ * allocated with MONKEY_array_grow using MONKEY_array_grow(mem, size, 0) instead of MONKEY_free.
+ *
+ * @param ptr location where to free the memory. ptr must have
+ *     been returned by MONKEY_strdup, MONKEY_strndup, MONKEY_malloc or MONKEY_array_grow earlier.
+ */
+#define MONKEY_free(ptr) MONKEY_xfree_(ptr, __FILE__, __LINE__)
+
+/**
+ * Free the memory pointed to by ptr if ptr is not NULL.
+ * Equivalent to if (ptr!=null)MONKEY_free(ptr).
+ *
+ * @param ptr the location in memory to free
+ */
+#define MONKEY_free_non_null(ptr) do { void * __x__ = ptr; if (__x__ != NULL) { MONKEY_free(__x__); } } while(0)
+
+/**
+ * Wrapper around MONKEY_strdup.  Makes a copy of the zero-terminated string
+ * pointed to by a.
+ *
+ * @param a pointer to a zero-terminated string
+ * @return a copy of the string including zero-termination
+ */
+#define MONKEY_strdup(a) MONKEY_xstrdup_(a,__FILE__,__LINE__)
+
+/**
+ * Wrapper around MONKEY_strndup.  Makes a partial copy of the string
+ * pointed to by a.
+ *
+ * @param a pointer to a string
+ * @param length of the string to duplicate
+ * @return a partial copy of the string including zero-termination
+ */
+#define MONKEY_strndup(a,length) MONKEY_xstrndup_(a,length,__FILE__,__LINE__)
+
+/**
+ * Grow a well-typed (!) array.  This is a convenience
+ * method to grow a vector <tt>arr</tt> of size <tt>size</tt>
+ * to the new (target) size <tt>tsize</tt>.
+ * <p>
+ *
+ * Example (simple, well-typed stack):
+ *
+ * <pre>
+ * static struct foo * myVector = NULL;
+ * static int myVecLen = 0;
+ *
+ * static void push(struct foo * elem) {
+ *   MONKEY_array_grow(myVector, myVecLen, myVecLen+1);
+ *   memcpy(&myVector[myVecLen-1], elem, sizeof(struct foo));
+ * }
+ *
+ * static void pop(struct foo * elem) {
+ *   if (myVecLen == 0) die();
+ *   memcpy(elem, myVector[myVecLen-1], sizeof(struct foo));
+ *   MONKEY_array_grow(myVector, myVecLen, myVecLen-1);
+ * }
+ * </pre>
+ *
+ * @param arr base-pointer of the vector, may be NULL if size is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param size the number of elements in the existing vector (number
+ *        of elements to copy over)
+ * @param tsize the target size for the resulting vector, use 0 to
+ *        free the vector (then, arr will be NULL afterwards).
+ */
+#define MONKEY_array_grow(arr,size,tsize) MONKEY_xgrow_((void**)&arr, sizeof(arr[0]), &size, tsize, __FILE__, __LINE__)
+
+/**
+ * Append an element to a list (growing the
+ * list by one).
+ */
+#define MONKEY_array_append(arr,size,element) do { MONKEY_array_grow(arr,size,size+1); arr[size-1] = element; } while(0)
+
+/**
+ * Like snprintf, just aborts if the buffer is of insufficient size.
+ *
+ * @param buf pointer to buffer that is written to
+ * @param size number of bytes in buf
+ * @param format format strings
+ * @param ... data for format string
+ * @return number of bytes written to buf or negative value on error
+ */
+int
+MONKEY_snprintf (char *buf, size_t size, const char *format, ...);
+
+
+/**
+ * Like asprintf, just portable.
+ *
+ * @param buf set to a buffer of sufficient size (allocated, caller must free)
+ * @param format format string (see printf, fprintf, etc.)
+ * @param ... data for format string
+ * @return number of bytes in "*buf" excluding 0-termination
+ */
+int
+MONKEY_asprintf (char **buf, const char *format, ...);
+
+
+/**
+ * Replace all occurrences of a substring in a string
+ * @param string target string
+ * @param substr substring to replace
+ * @param replacement substitution of the substring
+ */
+char *
+MONKEY_str_replace_all ( const char *string, const char *substr, const char *replacement );
+
+/* ************** internal implementations, use macros above! ************** */
+
+/**
+ * Allocate memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use MONKEY_xmalloc_ directly. Use the
+ * MONKEY_malloc macro.
+ * The memory will be zero'ed out.
+ *
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *
+MONKEY_xmalloc_ (size_t size, const char *filename, int linenumber);
+
+
+
+/**
+ * Allocate and initialize memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use MONKEY_xmemdup_ directly. Use the
+ * MONKEY_memdup macro.
+ *
+ * @param buf buffer to initialize from (must contain size bytes)
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *
+MONKEY_xmemdup_ (const void *buf, size_t size, const char *filename,
+                 int linenumber);
+
+
+/**
+ * Allocate memory.  This function does not check if the allocation
+ * request is within reasonable bounds, allowing allocations larger
+ * than 40 MB.  If you don't expect the possibility of very large
+ * allocations, use MONKEY_malloc instead.  The memory will be zero'ed
+ * out.
+ *
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
+void *
+MONKEY_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber);
+
+/**
+ * Reallocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ */
+void *
+MONKEY_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber);
+
+/**
+ * Free memory. Merely a wrapper for the case that we
+ * want to keep track of allocations.  Don't use MONKEY_xfree_
+ * directly. Use the MONKEY_free macro.
+ *
+ * @param ptr pointer to memory to free
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ */
+void
+MONKEY_xfree_ (void *ptr, const char *filename, int linenumber);
+
+
+/**
+ * Dup a string. Don't call MONKEY_xstrdup_ directly. Use the MONKEY_strdup macro.
+ * @param str string to duplicate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return the duplicated string
+ */
+char *
+MONKEY_xstrdup_ (const char *str, const char *filename, int linenumber);
+
+/**
+ * Dup partially a string. Don't call MONKEY_xstrndup_ directly. Use the MONKEY_strndup macro.
+ *
+ * @param str string to duplicate
+ * @param len length of the string to duplicate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return the duplicated string
+ */
+char *
+MONKEY_xstrndup_ (const char *str, size_t len, const char *filename,
+                  int linenumber);
+
+/**
+ * Grow an array, the new elements are zeroed out.
+ * Grows old by (*oldCount-newCount)*elementSize
+ * bytes and sets *oldCount to newCount.
+ *
+ * Don't call MONKEY_xgrow_ directly. Use the MONKEY_array_grow macro.
+ *
+ * @param old address of the pointer to the array
+ *        *old may be NULL
+ * @param elementSize the size of the elements of the array
+ * @param oldCount address of the number of elements in the *old array
+ * @param newCount number of elements in the new array, may be 0 (then *old will be NULL afterwards)
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ */
+void
+MONKEY_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
+               unsigned int newCount, const char *filename, int linenumber);
+
+
+
+
+#if __STDC_VERSION__ < 199901L
+#if __GNUC__ >= 2
+#define __func__ __FUNCTION__
+#else
+#define __func__ "<unknown>"
+#endif
+#endif
+
+#endif /* MONKEY_COMMON_H */
diff --git a/pathologist/src/include/monkey_getopt_lib.h b/pathologist/src/include/monkey_getopt_lib.h
new file mode 100644
index 0000000..50d9cc1
--- /dev/null
+++ b/pathologist/src/include/monkey_getopt_lib.h
@@ -0,0 +1,367 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet 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.
+
+     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file include/gnunet_getopt_lib.h
+ * @brief command line parsing and --help formatting
+ *
+ * @author Christian Grothoff
+ */
+
+#ifndef MONKEY_GETOPT_LIB_H
+#define MONKEY_GETOPT_LIB_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+//#include "gnunet_configuration_lib.h"
+
+/**
+ * @brief General context for command line processors.
+ */
+struct MONKEY_GETOPT_CommandLineProcessorContext
+{
+
+  /**
+   * Name of the application
+   */
+  const char *binaryName;
+
+  /**
+   * Name of application with option summary
+   */
+  const char *binaryOptions;
+
+  /**
+   * Array with all command line options.
+   */
+  const struct MONKEY_GETOPT_CommandLineOption *allOptions;
+
+  /**
+   * Original command line
+   */
+  char *const *argv;
+
+  /**
+   * Total number of argv's.
+   */
+  unsigned int argc;
+
+  /**
+   * Current argument.
+   */
+  unsigned int currentArgument;
+
+};
+
+/**
+ * @brief Process a command line option
+ *
+ * @param ctx context for all options
+ * @param scls specific closure (for this processor)
+ * @param option long name of the option (i.e. "config" for --config)
+ * @param value argument, NULL if none was given
+ * @return MONKEY_OK to continue processing other options, MONKEY_SYSERR to abort
+ */
+typedef int (*MONKEY_GETOPT_CommandLineOptionProcessor) (struct
+                                                         MONKEY_GETOPT_CommandLineProcessorContext
+                                                         * ctx, void *scls,
+                                                         const char *option,
+                                                         const char *value);
+
+/**
+ * @brief Definition of a command line option.
+ */
+struct MONKEY_GETOPT_CommandLineOption
+{
+
+  /**
+   * Short name of the option (use '\\0' for none).
+   */
+  const char shortName;
+
+  /**
+   * Long name of the option (may not be NULL)
+   */
+  const char *name;
+
+  /**
+   * Name of the argument for the user in help text
+   */
+  const char *argumentHelp;
+
+  /**
+   * Help text for the option (description)
+   */
+  const char *description;
+
+  /**
+   * Is an argument required?  0: MONKEY_NO (includes optional), 1: MONKEY_YES.
+   */
+  int require_argument;
+
+  /**
+   * Handler for the option.
+   */
+  MONKEY_GETOPT_CommandLineOptionProcessor processor;
+
+  /**
+   * Specific closure to pass to the processor.
+   */
+  void *scls;
+
+};
+
+/**
+ * Macro defining the option to print the command line
+ * help text (-h option).
+ *
+ * @param about string with brief description of the application
+ */
+#define MONKEY_GETOPT_OPTION_HELP(about) \
+  { 'h', "help", (const char *) NULL, gettext_noop("print this help"), 0, &MONKEY_GETOPT_format_help_, (void *) about }
+
+
+/**
+ * Macro defining the option to print the version of
+ * the application (-v option)
+ *
+ * @param version string with the version number
+ */
+#define MONKEY_GETOPT_OPTION_VERSION(version) \
+  { 'v', "version", (const char *) NULL, gettext_noop("print the version number"), 0, &MONKEY_GETOPT_print_version_, (void *) version }
+
+
+/**
+ * Allow user to specify log file name (-l option)
+ *
+ * @param logfn set to the name of the logfile
+ */
+#define MONKEY_GETOPT_OPTION_LOGFILE(logfn)                             \
+  { 'l', "logfile", "LOGFILE", gettext_noop("configure logging to write logs to LOGFILE"), 1, &MONKEY_GETOPT_set_string, (void *) logfn }
+
+
+/**
+ * Allow user to specify log level (-L option)
+ *
+ * @param loglev set to the log level
+ */
+#define MONKEY_GETOPT_OPTION_LOGLEVEL(loglev)                           \
+  { 'L', "log", "LOGLEVEL", gettext_noop("configure logging to use LOGLEVEL"), 1, &MONKEY_GETOPT_set_string, (void *) loglev }
+
+
+/**
+ * Get number of verbose (-V) flags
+ *
+ * @param level where to store the verbosity level (should be an 'int')
+ */
+#define MONKEY_GETOPT_OPTION_VERBOSE(level)                             \
+  { 'V', "verbose", (const char *) NULL, gettext_noop("be verbose"), 0, &MONKEY_GETOPT_increment_value, (void *) level }
+
+
+/**
+ * Get configuration file name (-c option)
+ *
+ * @param fn set to the configuration file name
+ */
+#define MONKEY_GETOPT_OPTION_CFG_FILE(fn)                               \
+  { 'c', "config", "FILENAME", gettext_noop("use configuration file FILENAME"), 1, &MONKEY_GETOPT_set_string, (void *) fn }
+
+
+/**
+ * Marker for the end of the list of options.
+ */
+#define MONKEY_GETOPT_OPTION_END \
+  { '\0', NULL, NULL, NULL, 0, NULL, NULL }
+
+
+/**
+ * Parse the command line.
+ *
+ * @param binaryOptions Name of application with option summary
+ * @param allOptions defined options and handlers
+ * @param argc number of arguments
+ * @param argv actual arguments
+ * @return index into argv with first non-option
+ *   argument, or MONKEY_SYSERR on error
+ */
+int
+MONKEY_GETOPT_run (const char *binaryOptions,
+                   const struct MONKEY_GETOPT_CommandLineOption *allOptions,
+                   unsigned int argc, char *const *argv);
+
+
+/**
+ * Set an option of type 'unsigned long long' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned long long'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned long long')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_ulong (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                         void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'struct MONKEY_TIME_Relative' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'struct MONKEY_TIME_Relative'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'struct MONKEY_TIME_Relative')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_relative_time (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                                 void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'unsigned int' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned int')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_uint (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                        void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'int' from the command line to 1 if the
+ * given option is present.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_one (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                       void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'char *' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'char *'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'char *',
+ *             which will be allocated)
+ * @param option name of the option
+ * @param value actual value of the option (a string)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_string (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                          void *scls, const char *option, const char *value);
+
+/**
+ * Set an option of type 'unsigned int' from the command line. Each
+ * time the option flag is given, the value is incremented by one.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_increment_value (struct MONKEY_GETOPT_CommandLineProcessorContext
+                               *ctx, void *scls, const char *option,
+                               const char *value);
+
+
+/* *************** internal prototypes - use macros above! ************* */
+
+/**
+ * Print out details on command line options (implements --help).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to about text)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_format_help_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                            *ctx, void *scls, const char *option,
+                            const char *value);
+
+/**
+ * Print out program version (implements --version).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to version string)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_print_version_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                              *ctx, void *scls, const char *option,
+                              const char *value);
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+
+/* ifndef MONKEY_GETOPT_LIB_H */
+#endif
+/* end of gnunet_getopt_lib.h */
diff --git a/pathologist/src/include/mxml.h b/pathologist/src/include/mxml.h
new file mode 100644
index 0000000..79c711f
--- /dev/null
+++ b/pathologist/src/include/mxml.h
@@ -0,0 +1,329 @@
+/*
+ * "$Id: mxml.h 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Header file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Prevent multiple inclusion...
+ */
+
+#ifndef _mxml_h_
+#  define _mxml_h_
+
+/*
+ * Include necessary headers...
+ */
+
+#  include <stdio.h>
+#  include <stdlib.h>
+#  include <string.h>
+#  include <ctype.h>
+#  include <errno.h>
+
+
+/*
+ * Constants...
+ */
+
+#  define MXML_TAB              8       /* Tabs every N columns */
+
+#  define MXML_NO_CALLBACK      0       /* Don't use a type callback */
+#  define MXML_INTEGER_CALLBACK mxml_integer_cb
+                                        /* Treat all data as integers */
+#  define MXML_OPAQUE_CALLBACK  mxml_opaque_cb
+                                        /* Treat all data as opaque */
+#  define MXML_REAL_CALLBACK    mxml_real_cb
+                                        /* Treat all data as real numbers */
+#  define MXML_TEXT_CALLBACK    0       /* Treat all data as text */
+#  define MXML_IGNORE_CALLBACK  mxml_ignore_cb
+                                        /* Ignore all non-element content */
+
+#  define MXML_NO_PARENT        0       /* No parent for the node */
+
+#  define MXML_DESCEND          1       /* Descend when finding/walking */
+#  define MXML_NO_DESCEND       0       /* Don't descend when finding/walking */
+#  define MXML_DESCEND_FIRST    -1      /* Descend for first find */
+
+#  define MXML_WS_BEFORE_OPEN   0       /* Callback for before open tag */
+#  define MXML_WS_AFTER_OPEN    1       /* Callback for after open tag */
+#  define MXML_WS_BEFORE_CLOSE  2       /* Callback for before close tag */
+#  define MXML_WS_AFTER_CLOSE   3       /* Callback for after close tag */
+
+#  define MXML_ADD_BEFORE       0       /* Add node before specified node */
+#  define MXML_ADD_AFTER        1       /* Add node after specified node */
+#  define MXML_ADD_TO_PARENT    NULL    /* Add node relative to parent */
+
+
+/*
+ * Data types...
+ */
+
+typedef enum mxml_sax_event_e           /**** SAX event type. ****/
+{
+  MXML_SAX_CDATA,                       /* CDATA node */
+  MXML_SAX_COMMENT,                     /* Comment node */
+  MXML_SAX_DATA,                        /* Data node */
+  MXML_SAX_DIRECTIVE,                   /* Processing directive node */
+  MXML_SAX_ELEMENT_CLOSE,               /* Element closed */
+  MXML_SAX_ELEMENT_OPEN                 /* Element opened */
+} mxml_sax_event_t;
+
+typedef enum mxml_type_e                /**** The XML node type. ****/
+{
+  MXML_IGNORE = -1,                     /* Ignore/throw away node @since Mini-XML 2.3@ */
+  MXML_ELEMENT,                         /* XML element with attributes */
+  MXML_INTEGER,                         /* Integer value */
+  MXML_OPAQUE,                          /* Opaque string */
+  MXML_REAL,                            /* Real value */
+  MXML_TEXT,                            /* Text fragment */
+  MXML_CUSTOM                           /* Custom data @since Mini-XML 2.1@ */
+} mxml_type_t;
+
+typedef void (*mxml_custom_destroy_cb_t)(void *);
+                                        /**** Custom data destructor ****/
+
+typedef void (*mxml_error_cb_t)(const char *);  
+                                        /**** Error callback function ****/
+
+typedef struct mxml_attr_s              /**** An XML element attribute value. @private@ ****/
+{
+  char                  *name;          /* Attribute name */
+  char                  *value;         /* Attribute value */
+} mxml_attr_t;
+
+typedef struct mxml_element_s           /**** An XML element value. @private@ ****/
+{
+  char                  *name;          /* Name of element */
+  int                   num_attrs;      /* Number of attributes */
+  mxml_attr_t           *attrs;         /* Attributes */
+} mxml_element_t;
+
+typedef struct mxml_text_s              /**** An XML text value. @private@ ****/
+{
+  int                   whitespace;     /* Leading whitespace? */
+  char                  *string;        /* Fragment string */
+} mxml_text_t;
+
+typedef struct mxml_custom_s            /**** An XML custom value. @private@ ****/
+{
+  void                  *data;          /* Pointer to (allocated) custom data */
+  mxml_custom_destroy_cb_t destroy;     /* Pointer to destructor function */
+} mxml_custom_t;
+
+typedef union mxml_value_u              /**** An XML node value. @private@ ****/
+{
+  mxml_element_t        element;        /* Element */
+  int                   integer;        /* Integer number */
+  char                  *opaque;        /* Opaque string */
+  double                real;           /* Real number */
+  mxml_text_t           text;           /* Text fragment */
+  mxml_custom_t         custom;         /* Custom data @since Mini-XML 2.1@ */
+} mxml_value_t;
+
+struct mxml_node_s                      /**** An XML node. @private@ ****/
+{
+  mxml_type_t           type;           /* Node type */
+  struct mxml_node_s    *next;          /* Next node under same parent */
+  struct mxml_node_s    *prev;          /* Previous node under same parent */
+  struct mxml_node_s    *parent;        /* Parent node */
+  struct mxml_node_s    *child;         /* First child node */
+  struct mxml_node_s    *last_child;    /* Last child node */
+  mxml_value_t          value;          /* Node value */
+  int                   ref_count;      /* Use count */
+  void                  *user_data;     /* User data */
+};
+
+typedef struct mxml_node_s mxml_node_t; /**** An XML node. ****/
+
+struct mxml_index_s                      /**** An XML node index. @private@ ****/
+{
+  char                  *attr;          /* Attribute used for indexing or NULL */
+  int                   num_nodes;      /* Number of nodes in index */
+  int                   alloc_nodes;    /* Allocated nodes in index */
+  int                   cur_node;       /* Current node */
+  mxml_node_t           **nodes;        /* Node array */
+};
+
+typedef struct mxml_index_s mxml_index_t;
+                                        /**** An XML node index. ****/
+
+typedef int (*mxml_custom_load_cb_t)(mxml_node_t *, const char *);
+                                        /**** Custom data load callback function ****/
+
+typedef char *(*mxml_custom_save_cb_t)(mxml_node_t *);  
+                                        /**** Custom data save callback function ****/
+
+typedef int (*mxml_entity_cb_t)(const char *);
+                                        /**** Entity callback function */
+
+typedef mxml_type_t (*mxml_load_cb_t)(mxml_node_t *);
+                                        /**** Load callback function ****/
+
+typedef const char *(*mxml_save_cb_t)(mxml_node_t *, int);
+                                        /**** Save callback function ****/
+
+typedef void (*mxml_sax_cb_t)(mxml_node_t *, mxml_sax_event_t, void *);  
+                                        /**** SAX callback function ****/
+
+
+/*
+ * C++ support...
+ */
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif /* __cplusplus */
+
+/*
+ * Prototypes...
+ */
+
+extern void             mxmlAdd(mxml_node_t *parent, int where,
+                                mxml_node_t *child, mxml_node_t *node);
+extern void             mxmlDelete(mxml_node_t *node);
+extern void             mxmlElementDeleteAttr(mxml_node_t *node,
+                                              const char *name);
+extern const char       *mxmlElementGetAttr(mxml_node_t *node, const char *name);
+extern void             mxmlElementSetAttr(mxml_node_t *node, const char *name,
+                                           const char *value);
+extern void             mxmlElementSetAttrf(mxml_node_t *node, const char *name,
+                                            const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern int              mxmlEntityAddCallback(mxml_entity_cb_t cb);
+extern const char       *mxmlEntityGetName(int val);
+extern int              mxmlEntityGetValue(const char *name);
+extern void             mxmlEntityRemoveCallback(mxml_entity_cb_t cb);
+extern mxml_node_t      *mxmlFindElement(mxml_node_t *node, mxml_node_t *top,
+                                         const char *name, const char *attr,
+                                         const char *value, int descend);
+extern mxml_node_t      *mxmlFindPath(mxml_node_t *node, const char *path);
+extern const char       *mxmlGetCDATA(mxml_node_t *node);
+extern const void       *mxmlGetCustom(mxml_node_t *node);
+extern const char       *mxmlGetElement(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetFirstChild(mxml_node_t *node);
+extern int              mxmlGetInteger(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetLastChild(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetNextSibling(mxml_node_t *node);
+extern const char       *mxmlGetOpaque(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetParent(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetPrevSibling(mxml_node_t *node);
+extern double           mxmlGetReal(mxml_node_t *node);
+extern int              mxmlGetRefCount(mxml_node_t *node);
+extern const char       *mxmlGetText(mxml_node_t *node, int *whitespace);
+extern mxml_type_t      mxmlGetType(mxml_node_t *node);
+extern void             *mxmlGetUserData(mxml_node_t *node);
+extern void             mxmlIndexDelete(mxml_index_t *ind);
+extern mxml_node_t      *mxmlIndexEnum(mxml_index_t *ind);
+extern mxml_node_t      *mxmlIndexFind(mxml_index_t *ind,
+                                       const char *element,
+                                       const char *value);
+extern int              mxmlIndexGetCount(mxml_index_t *ind);
+extern mxml_index_t     *mxmlIndexNew(mxml_node_t *node, const char *element,
+                                      const char *attr);
+extern mxml_node_t      *mxmlIndexReset(mxml_index_t *ind);
+extern mxml_node_t      *mxmlLoadFd(mxml_node_t *top, int fd,
+                                    mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t      *mxmlLoadFile(mxml_node_t *top, FILE *fp,
+                                      mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t      *mxmlLoadString(mxml_node_t *top, const char *s,
+                                        mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t      *mxmlNewCDATA(mxml_node_t *parent, const char *string);
+extern mxml_node_t      *mxmlNewCustom(mxml_node_t *parent, void *data,
+                                       mxml_custom_destroy_cb_t destroy);
+extern mxml_node_t      *mxmlNewElement(mxml_node_t *parent, const char *name);
+extern mxml_node_t      *mxmlNewInteger(mxml_node_t *parent, int integer);
+extern mxml_node_t      *mxmlNewOpaque(mxml_node_t *parent, const char *opaque);
+extern mxml_node_t      *mxmlNewReal(mxml_node_t *parent, double real);
+extern mxml_node_t      *mxmlNewText(mxml_node_t *parent, int whitespace,
+                                     const char *string);
+extern mxml_node_t      *mxmlNewTextf(mxml_node_t *parent, int whitespace,
+                                      const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern mxml_node_t      *mxmlNewXML(const char *version);
+extern int              mxmlRelease(mxml_node_t *node);
+extern void             mxmlRemove(mxml_node_t *node);
+extern int              mxmlRetain(mxml_node_t *node);
+extern char             *mxmlSaveAllocString(mxml_node_t *node,
+                                             mxml_save_cb_t cb);
+extern int              mxmlSaveFd(mxml_node_t *node, int fd,
+                                   mxml_save_cb_t cb);
+extern int              mxmlSaveFile(mxml_node_t *node, FILE *fp,
+                                     mxml_save_cb_t cb);
+extern int              mxmlSaveString(mxml_node_t *node, char *buffer,
+                                       int bufsize, mxml_save_cb_t cb);
+extern mxml_node_t      *mxmlSAXLoadFd(mxml_node_t *top, int fd,
+                                       mxml_type_t (*cb)(mxml_node_t *),
+                                       mxml_sax_cb_t sax, void *sax_data);
+extern mxml_node_t      *mxmlSAXLoadFile(mxml_node_t *top, FILE *fp,
+                                         mxml_type_t (*cb)(mxml_node_t *),
+                                         mxml_sax_cb_t sax, void *sax_data);
+extern mxml_node_t      *mxmlSAXLoadString(mxml_node_t *top, const char *s,
+                                           mxml_type_t (*cb)(mxml_node_t *),
+                                           mxml_sax_cb_t sax, void *sax_data);
+extern int              mxmlSetCDATA(mxml_node_t *node, const char *data);
+extern int              mxmlSetCustom(mxml_node_t *node, void *data,
+                                      mxml_custom_destroy_cb_t destroy);
+extern void             mxmlSetCustomHandlers(mxml_custom_load_cb_t load,
+                                              mxml_custom_save_cb_t save);
+extern int              mxmlSetElement(mxml_node_t *node, const char *name);
+extern void             mxmlSetErrorCallback(mxml_error_cb_t cb);
+extern int              mxmlSetInteger(mxml_node_t *node, int integer);
+extern int              mxmlSetOpaque(mxml_node_t *node, const char *opaque);
+extern int              mxmlSetReal(mxml_node_t *node, double real);
+extern int              mxmlSetText(mxml_node_t *node, int whitespace,
+                                    const char *string);
+extern int              mxmlSetTextf(mxml_node_t *node, int whitespace,
+                                     const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern int              mxmlSetUserData(mxml_node_t *node, void *data);
+extern void             mxmlSetWrapMargin(int column);
+extern mxml_node_t      *mxmlWalkNext(mxml_node_t *node, mxml_node_t *top,
+                                      int descend);
+extern mxml_node_t      *mxmlWalkPrev(mxml_node_t *node, mxml_node_t *top,
+                                      int descend);
+
+
+/*
+ * Semi-private functions...
+ */
+
+extern void             mxml_error(const char *format, ...);
+extern mxml_type_t      mxml_ignore_cb(mxml_node_t *node);
+extern mxml_type_t      mxml_integer_cb(mxml_node_t *node);
+extern mxml_type_t      mxml_opaque_cb(mxml_node_t *node);
+extern mxml_type_t      mxml_real_cb(mxml_node_t *node);
+
+
+/*
+ * C++ support...
+ */
+
+#  ifdef __cplusplus
+}
+#  endif /* __cplusplus */
+#endif /* !_mxml_h_ */
+
+
+/*
+ * End of "$Id: mxml.h 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/pathologist/src/include/platform.h b/pathologist/src/include/platform.h
new file mode 100644
index 0000000..994a5b6
--- /dev/null
+++ b/pathologist/src/include/platform.h
@@ -0,0 +1,266 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet 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.
+
+     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file include/platform.h
+ * @brief plaform specifics
+ *
+ * @author Nils Durner
+ *
+ * This file should never be included by installed
+ * header files (thos starting with "gnunet_").
+ */
+
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+#ifndef HAVE_USED_CONFIG_H
+#define HAVE_USED_CONFIG_H
+#if HAVE_CONFIG_H
+//#include "gnunet_config.h"
+#endif
+#endif
+
+#ifdef WINDOWS
+#define BREAKPOINT asm("int $3;");
+#define GNUNET_SIGCHLD 17
+#else
+#define BREAKPOINT
+#define GNUNET_SIGCHLD SIGCHLD
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#define ALLOW_EXTRA_CHECKS GNUNET_NO
+
+/**
+ * For strptime (glibc2 needs this).
+ */
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE
+#endif
+
+#ifndef _REENTRANT
+#define _REENTRANT
+#endif
+
+/* configuration options */
+
+#define VERBOSE_STATS 0
+
+#ifdef CYGWIN
+#include <sys/reent.h>
+#endif
+
+#ifdef _MSC_VER
+#ifndef FD_SETSIZE
+#define FD_SETSIZE 1024
+#endif
+#include <Winsock2.h>
+#include <ws2tcpip.h>
+#else
+#ifndef MINGW
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#if HAVE_NETINET_IN_SYSTM_H
+#include <netinet/in_systm.h>
+#endif
+#include <netinet/ip.h>         /* superset of previous */
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <pwd.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <grp.h>
+#else
+#include "winproc.h"
+#endif
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <signal.h>
+#include <libgen.h>
+#ifdef WINDOWS
+#include <malloc.h>             /* for alloca(), on other OSes it's in stdlib.h */
+#endif
+#ifndef _MSC_VER
+#include <unistd.h>             /* KLB_FIX */
+#endif
+#include <sys/stat.h>
+#include <sys/types.h>
+#ifndef _MSC_VER
+#include <dirent.h>             /* KLB_FIX */
+#endif
+#include <fcntl.h>
+#include <math.h>
+#if HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#if 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 SOMEBSD
+#include <net/if.h>
+#endif
+#ifdef GNUNET_freeBSD
+#include <semaphore.h>
+#endif
+#ifdef DARWIN
+#include <dlfcn.h>
+#include <semaphore.h>
+#include <net/if.h>
+#endif
+#if defined(LINUX) || defined(GNU)
+#include <net/if.h>
+#endif
+#ifdef SOLARIS
+#include <sys/sockio.h>
+#include <sys/filio.h>
+#include <sys/loadavg.h>
+#include <semaphore.h>
+#endif
+#if HAVE_UCRED_H
+#include <ucred.h>
+#endif
+#ifdef CYGWIN
+#include <windows.h>
+#include <cygwin/if.h>
+#endif
+#if HAVE_IFADDRS_H
+#include <ifaddrs.h>
+#endif
+#include <errno.h>
+#include <limits.h>
+
+#if HAVE_VFORK_H
+#include <vfork.h>
+#endif
+
+#include <ctype.h>
+#if HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#if HAVE_ENDIAN_H
+#include <endian.h>
+#endif
+#if HAVE_SYS_ENDIAN_H
+#include <sys/endian.h>
+#endif
+
+#include "plibc.h"
+
+//#include <locale.h>
+//#ifndef FRAMEWORK_BUILD
+//#include "gettext.h"
+///**
+// * GNU gettext support macro.
+// */
+//#define _(String) dgettext("gnunet",String)
+//#define LIBEXTRACTOR_GETTEXT_DOMAIN "libextractor"
+//#else
+//#include "libintlemu.h"
+//#define _(String) dgettext("org.gnunet.gnunet",String)
+//#define LIBEXTRACTOR_GETTEXT_DOMAIN "org.gnunet.libextractor"
+//#endif
+
+#ifdef CYGWIN
+#define SIOCGIFCONF     _IOW('s', 100, struct ifconf)   /* get if list */
+#define SIOCGIFFLAGS    _IOW('s', 101, struct ifreq)    /* Get if flags */
+#define SIOCGIFADDR     _IOW('s', 102, struct ifreq)    /* Get if addr */
+#endif
+
+#ifndef MINGW
+#include <sys/mman.h>
+#endif
+
+#ifdef FREEBSD
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#endif
+
+#ifdef DARWIN
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+ /* not available on darwin, override configure */
+#undef HAVE_STAT64
+#undef HAVE_MREMAP
+#endif
+
+
+#if !HAVE_ATOLL
+long long
+atoll (const char *nptr);
+#endif
+
+#if ENABLE_NLS
+#include "langinfo.h"
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX ((size_t)(-1))
+#endif
+
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+/**
+ * AI_NUMERICSERV not defined in windows.  Then we just do without.
+ */
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0
+#endif
+
+
+#if defined(__sparc__)
+#define MAKE_UNALIGNED(val) ({ __typeof__((val)) __tmp; memmove(&__tmp, &(val), sizeof((val))); __tmp; })
+#else
+#define MAKE_UNALIGNED(val) val
+#endif
+
+#if WINDOWS
+#define FDTYPE HANDLE
+#define SOCKTYPE SOCKET
+#else
+#define FDTYPE int
+#define SOCKTYPE int
+#endif
+
+#endif
diff --git a/pathologist/src/include/plibc.h b/pathologist/src/include/plibc.h
new file mode 100644
index 0000000..8314f21
--- /dev/null
+++ b/pathologist/src/include/plibc.h
@@ -0,0 +1,810 @@
+/*
+     This file is part of PlibC.
+     (C) 2005, 2006, 2007, 2008, 2009, 2010 Nils Durner (and other contributing authors)
+
+           This library is free software; you can redistribute it and/or
+           modify it under the terms of the GNU Lesser General Public
+           License as published by the Free Software Foundation; either
+           version 2.1 of the License, or (at your option) any later version.
+
+           This library 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
+           Lesser General Public License for more details.
+
+           You should have received a copy of the GNU Lesser General Public
+           License along with this library; if not, write to the Free Software
+           Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/**
+ * @file include/plibc.h
+ * @brief PlibC header
+ * @attention This file is usually not installed under Unix,
+ *            so ship it with your application
+ * @version $Revision: 69 $
+ */
+
+#ifndef _PLIBC_H_
+#define _PLIBC_H_
+
+#ifndef SIGALRM
+#define SIGALRM 14
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stddef.h>
+
+#ifdef Q_OS_WIN32
+#define WINDOWS 1
+#endif
+
+#define HAVE_PLIBC_FD 0
+
+#ifdef WINDOWS
+
+#if ENABLE_NLS
+#include "langinfo.h"
+#endif
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <time.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+
+/* Conflicts with our definitions */
+#define __G_WIN32_H__
+
+/* Convert LARGE_INTEGER to double */
+#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + \
+  (double)((x).LowPart))
+
+  struct stat64
+  {
+    _dev_t st_dev;
+    _ino_t st_ino;
+    _mode_t st_mode;
+    short st_nlink;
+    short st_uid;
+    short st_gid;
+    _dev_t st_rdev;
+    __int64 st_size;
+    __time64_t st_atime;
+    __time64_t st_mtime;
+    __time64_t st_ctime;
+  };
+
+  typedef unsigned int sa_family_t;
+
+  struct sockaddr_un
+  {
+    short sun_family;           /*AF_UNIX */
+    char sun_path[108];         /*path name */
+  };
+
+#ifndef pid_t
+#define pid_t DWORD
+#endif
+
+#ifndef error_t
+#define error_t int
+#endif
+
+#ifndef WEXITSTATUS
+#define WEXITSTATUS(status) (((status) & 0xff00) >> 8)
+#endif
+
+#ifndef MSG_DONTWAIT
+#define MSG_DONTWAIT 0
+#endif
+
+  enum
+  {
+    _SC_PAGESIZE = 30,
+    _SC_PAGE_SIZE = 30
+  };
+
+/* Thanks to the Cygwin project */
+#define ENOCSI 43               /* No CSI structure available */
+#define EL2HLT 44               /* Level 2 halted */
+#ifndef  EDEADLK
+#define EDEADLK 45              /* Deadlock condition */
+#endif
+#ifndef  ENOLCK
+#define ENOLCK 46               /* No record locks available */
+#endif
+#define EBADE 50                /* Invalid exchange */
+#define EBADR 51                /* Invalid request descriptor */
+#define EXFULL 52               /* Exchange full */
+#define ENOANO 53               /* No anode */
+#define EBADRQC 54              /* Invalid request code */
+#define EBADSLT 55              /* Invalid slot */
+#ifndef  EDEADLOCK
+#define EDEADLOCK EDEADLK       /* File locking deadlock error */
+#endif
+#define EBFONT 57               /* Bad font file fmt */
+#define ENOSTR 60               /* Device not a stream */
+#define ENODATA 61              /* No data (for no delay io) */
+#define ETIME 62                /* Timer expired */
+#define ENOSR 63                /* Out of streams resources */
+#define ENONET 64               /* Machine is not on the network */
+#define ENOPKG 65               /* Package not installed */
+#define EREMOTE 66              /* The object is remote */
+#define ENOLINK 67              /* The link has been severed */
+#define EADV 68                 /* Advertise error */
+#define ESRMNT 69               /* Srmount error */
+#define ECOMM 70                /* Communication error on send */
+#define EPROTO 71               /* Protocol error */
+#define EMULTIHOP 74            /* Multihop attempted */
+#define ELBIN 75                /* Inode is remote (not really error) */
+#define EDOTDOT 76              /* Cross mount point (not really error) */
+#define EBADMSG 77              /* Trying to read unreadable message */
+#define ENOTUNIQ 80             /* Given log. name not unique */
+#define EBADFD 81               /* f.d. invalid for this operation */
+#define EREMCHG 82              /* Remote address changed */
+#define ELIBACC 83              /* Can't access a needed shared lib */
+#define ELIBBAD 84              /* Accessing a corrupted shared lib */
+#define ELIBSCN 85              /* .lib section in a.out corrupted */
+#define ELIBMAX 86              /* Attempting to link in too many libs */
+#define ELIBEXEC 87             /* Attempting to exec a shared library */
+#ifndef  ENOSYS
+#define ENOSYS 88               /* Function not implemented */
+#endif
+#define ENMFILE 89              /* No more files */
+#ifndef  ENOTEMPTY
+#define ENOTEMPTY 90            /* Directory not empty */
+#endif
+#ifndef  ENAMETOOLONG
+#define ENAMETOOLONG 91         /* File or path name too long */
+#endif
+#define ELOOP 92                /* Too many symbolic links */
+#define EOPNOTSUPP 95           /* Operation not supported on transport endpoint */
+#define EPFNOSUPPORT 96         /* Protocol family not supported */
+#define ECONNRESET 104          /* Connection reset by peer */
+#define ENOBUFS 105             /* No buffer space available */
+#define EAFNOSUPPORT 106        /* Address family not supported by protocol family */
+#define EPROTOTYPE 107          /* Protocol wrong type for socket */
+#define ENOTSOCK 108            /* Socket operation on non-socket */
+#define ENOPROTOOPT 109         /* Protocol not available */
+#define ESHUTDOWN 110           /* Can't send after socket shutdown */
+#define ECONNREFUSED 111        /* Connection refused */
+#define EADDRINUSE 112          /* Address already in use */
+#define ECONNABORTED 113        /* Connection aborted */
+#define ENETUNREACH 114         /* Network is unreachable */
+#define ENETDOWN 115            /* Network interface is not configured */
+#ifndef  ETIMEDOUT
+#define ETIMEDOUT 116           /* Connection timed out */
+#endif
+#define EHOSTDOWN 117           /* Host is down */
+#define EHOSTUNREACH 118        /* Host is unreachable */
+#define EINPROGRESS 119         /* Connection already in progress */
+#define EALREADY 120            /* Socket already connected */
+#define EDESTADDRREQ 121        /* Destination address required */
+#define EMSGSIZE 122            /* Message too long */
+#define EPROTONOSUPPORT 123     /* Unknown protocol */
+#define ESOCKTNOSUPPORT 124     /* Socket type not supported */
+#define EADDRNOTAVAIL 125       /* Address not available */
+#define ENETRESET 126           /* Connection aborted by network */
+#define EISCONN 127             /* Socket is already connected */
+#define ENOTCONN 128            /* Socket is not connected */
+#define ETOOMANYREFS 129        /* Too many references: cannot splice */
+#define EPROCLIM 130            /* Too many processes */
+#define EUSERS 131              /* Too many users */
+#define EDQUOT 132              /* Disk quota exceeded */
+#define ESTALE 133              /* Unknown error */
+#ifndef  ENOTSUP
+#define ENOTSUP 134             /* Not supported */
+#endif
+#define ENOMEDIUM 135           /* No medium (in tape drive) */
+#define ENOSHARE 136            /* No such host or network path */
+#define ECASECLASH 137          /* Filename exists with different case */
+#define EWOULDBLOCK EAGAIN      /* Operation would block */
+#define EOVERFLOW 139           /* Value too large for defined data type */
+
+#undef HOST_NOT_FOUND
+#define HOST_NOT_FOUND 1
+#undef TRY_AGAIN
+#define TRY_AGAIN 2
+#undef NO_RECOVERY
+#define NO_RECOVERY 3
+#undef NO_ADDRESS
+#define NO_ADDRESS 4
+
+#define PROT_READ   0x1
+#define PROT_WRITE  0x2
+#define MAP_SHARED  0x1
+#define MAP_PRIVATE 0x2         /* unsupported */
+#define MAP_FIXED   0x10
+#define MAP_FAILED  ((void *)-1)
+
+  struct statfs
+  {
+    long f_type;                /* type of filesystem (see below) */
+    long f_bsize;               /* optimal transfer block size */
+    long f_blocks;              /* total data blocks in file system */
+    long f_bfree;               /* free blocks in fs */
+    long f_bavail;              /* free blocks avail to non-superuser */
+    long f_files;               /* total file nodes in file system */
+    long f_ffree;               /* free file nodes in fs */
+    long f_fsid;                /* file system id */
+    long f_namelen;             /* maximum length of filenames */
+    long f_spare[6];            /* spare for later */
+  };
+
+  extern const struct in6_addr in6addr_any;     /* :: */
+  extern const struct in6_addr in6addr_loopback;        /* ::1 */
+
+/* Taken from the Wine project <http://www.winehq.org>
+    /wine/include/winternl.h */
+  enum SYSTEM_INFORMATION_CLASS
+  {
+    SystemBasicInformation = 0,
+    Unknown1,
+    SystemPerformanceInformation = 2,
+    SystemTimeOfDayInformation = 3,     /* was SystemTimeInformation */
+    Unknown4,
+    SystemProcessInformation = 5,
+    Unknown6,
+    Unknown7,
+    SystemProcessorPerformanceInformation = 8,
+    Unknown9,
+    Unknown10,
+    SystemDriverInformation,
+    Unknown12,
+    Unknown13,
+    Unknown14,
+    Unknown15,
+    SystemHandleList,
+    Unknown17,
+    Unknown18,
+    Unknown19,
+    Unknown20,
+    SystemCacheInformation,
+    Unknown22,
+    SystemInterruptInformation = 23,
+    SystemExceptionInformation = 33,
+    SystemRegistryQuotaInformation = 37,
+    SystemLookasideInformation = 45
+  };
+
+  typedef struct
+  {
+    LARGE_INTEGER IdleTime;
+    LARGE_INTEGER KernelTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER Reserved1[2];
+    ULONG Reserved2;
+  } SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
+
+#define sleep(secs) (Sleep(secs * 1000))
+
+/*********************** statfs *****************************/
+/* fake block size */
+#define FAKED_BLOCK_SIZE 512
+
+/* linux-compatible values for fs type */
+#define MSDOS_SUPER_MAGIC     0x4d44
+#define NTFS_SUPER_MAGIC      0x5346544E
+
+/*********************** End of statfs ***********************/
+
+#define SHUT_RDWR SD_BOTH
+
+/* Operations for flock() */
+#define LOCK_SH  1              /* shared lock */
+#define LOCK_EX  2              /* exclusive lock */
+#define LOCK_NB  4              /* or'd with one of the above to prevent
+                                 * blocking */
+#define LOCK_UN  8              /* remove lock */
+
+/* Not supported under MinGW */
+#define S_IRGRP 0
+#define S_IWGRP 0
+#define S_IROTH 0
+#define S_IXGRP 0
+#define S_IWOTH 0
+#define S_IXOTH 0
+#define S_ISUID 0
+#define S_ISGID 0
+#define S_ISVTX 0
+#define S_IRWXG 0
+#define S_IRWXO 0
+
+#define SHUT_WR SD_SEND
+#define SHUT_RD SD_RECEIVE
+#define SHUT_RDWR SD_BOTH
+
+#define SIGKILL 9
+#define SIGTERM 15
+
+#define SetErrnoFromWinError(e) _SetErrnoFromWinError(e, __FILE__, __LINE__)
+
+  BOOL _plibc_CreateShortcut (const char *pszSrc, const char *pszDest);
+  BOOL _plibc_DereferenceShortcut (char *pszShortcut);
+  char *plibc_ChooseDir (char *pszTitle, unsigned long ulFlags);
+  char *plibc_ChooseFile (char *pszTitle, unsigned long ulFlags);
+  long QueryRegistry (HKEY hMainKey, const char *pszKey, const char *pszSubKey,
+                      char *pszBuffer, long *pdLength);
+
+  BOOL __win_IsHandleMarkedAsBlocking (int hHandle);
+  void __win_SetHandleBlockingMode (int s, BOOL bBlocking);
+  void __win_DiscardHandleBlockingMode (int s);
+  int _win_isSocketValid (int s);
+  int plibc_conv_to_win_path (const char *pszUnix, char *pszWindows);
+  unsigned plibc_get_handle_count ();
+
+  typedef void (*TPanicProc) (int, char *);
+  void plibc_set_panic_proc (TPanicProc proc);
+
+  int flock (int fd, int operation);
+  int fsync (int fildes);
+  int inet_pton (int af, const char *src, void *dst);
+  int inet_pton4 (const char *src, u_char * dst, int pton);
+#if USE_IPV6
+  int inet_pton6 (const char *src, u_char * dst);
+#endif
+  int truncate (const char *fname, int distance);
+  int statfs (const char *path, struct statfs *buf);
+  const char *hstrerror (int err);
+  int mkstemp (char *tmplate);
+  char *strptime (const char *buf, const char *format, struct tm *tm);
+  const char *inet_ntop (int af, const void *src, char *dst, size_t size);
+
+  int plibc_init (char *pszOrg, char *pszApp);
+  void plibc_shutdown ();
+  int plibc_initialized ();
+  int plibc_conv_to_win_path_ex (const char *pszUnix, char *pszWindows,
+                                 int derefLinks);
+  void _SetErrnoFromWinError (long lWinError, char *pszCaller, int iLine);
+  void SetErrnoFromWinsockError (long lWinError);
+  void SetHErrnoFromWinError (long lWinError);
+  void SetErrnoFromHRESULT (HRESULT hRes);
+  int GetErrnoFromWinsockError (long lWinError);
+  FILE *_win_fopen (const char *filename, const char *mode);
+  DIR *_win_opendir (const char *dirname);
+  int _win_open (const char *filename, int oflag, ...);
+#ifdef ENABLE_NLS
+  char *_win_bindtextdomain (const char *domainname, const char *dirname);
+#endif
+  int _win_chdir (const char *path);
+  int _win_close (int fd);
+  int _win_creat (const char *path, mode_t mode);
+  char *_win_ctime (const time_t * clock);
+  char *_win_ctime_r (const time_t * clock, char *buf);
+  int _win_fstat (int handle, struct stat *buffer);
+  int _win_ftruncate (int fildes, off_t length);
+  void _win_gettimeofday (struct timeval *tp, void *tzp);
+  int _win_kill (pid_t pid, int sig);
+  int _win_pipe (int *phandles);
+  int _win_rmdir (const char *path);
+  int _win_access (const char *path, int mode);
+  int _win_chmod (const char *filename, int pmode);
+  char *realpath (const char *file_name, char *resolved_name);
+  long _win_random (void);
+  void _win_srandom (unsigned int seed);
+  int _win_remove (const char *path);
+  int _win_rename (const char *oldname, const char *newname);
+  int _win_stat (const char *path, struct stat *buffer);
+  int _win_stat64 (const char *path, struct stat64 *buffer);
+  long _win_sysconf (int name);
+  int _win_unlink (const char *filename);
+  int _win_write (int fildes, const void *buf, size_t nbyte);
+  int _win_read (int fildes, void *buf, size_t nbyte);
+  size_t _win_fwrite (const void *buffer, size_t size, size_t count,
+                      FILE * stream);
+  size_t _win_fread (void *buffer, size_t size, size_t count, FILE * stream);
+  int _win_symlink (const char *path1, const char *path2);
+  void *_win_mmap (void *start, size_t len, int access, int flags, int fd,
+                   unsigned long long offset);
+  int _win_munmap (void *start, size_t length);
+  int _win_lstat (const char *path, struct stat *buf);
+  int _win_lstat64 (const char *path, struct stat64 *buf);
+  int _win_readlink (const char *path, char *buf, size_t bufsize);
+  int _win_accept (int s, struct sockaddr *addr, int *addrlen);
+  int _win_printf (const char *format, ...);
+  int _win_fprintf (FILE * f, const char *format, ...);
+  int _win_vprintf (const char *format, va_list ap);
+  int _win_vfprintf (FILE * stream, const char *format, va_list arg_ptr);
+  int _win_vsprintf (char *dest, const char *format, va_list arg_ptr);
+  int _win_vsnprintf (char *str, size_t size, const char *format,
+                      va_list arg_ptr);
+  int _win_snprintf (char *str, size_t size, const char *format, ...);
+  int _win_sprintf (char *dest, const char *format, ...);
+  int _win_vsscanf (const char *str, const char *format, va_list arg_ptr);
+  int _win_sscanf (const char *str, const char *format, ...);
+  int _win_vfscanf (FILE * stream, const char *format, va_list arg_ptr);
+  int _win_vscanf (const char *format, va_list arg_ptr);
+  int _win_scanf (const char *format, ...);
+  int _win_fscanf (FILE * stream, const char *format, ...);
+  pid_t _win_waitpid (pid_t pid, int *stat_loc, int options);
+  int _win_bind (int s, const struct sockaddr *name, int namelen);
+  int _win_connect (int s, const struct sockaddr *name, int namelen);
+  int _win_getpeername (int s, struct sockaddr *name, int *namelen);
+  int _win_getsockname (int s, struct sockaddr *name, int *namelen);
+  int _win_getsockopt (int s, int level, int optname, char *optval,
+                       int *optlen);
+  int _win_listen (int s, int backlog);
+  int _win_recv (int s, char *buf, int len, int flags);
+  int _win_recvfrom (int s, void *buf, int len, int flags,
+                     struct sockaddr *from, int *fromlen);
+  int _win_select (int max_fd, fd_set * rfds, fd_set * wfds, fd_set * efds,
+                   const struct timeval *tv);
+  int _win_send (int s, const char *buf, int len, int flags);
+  int _win_sendto (int s, const char *buf, int len, int flags,
+                   const struct sockaddr *to, int tolen);
+  int _win_setsockopt (int s, int level, int optname, const void *optval,
+                       int optlen);
+  int _win_shutdown (int s, int how);
+  int _win_socket (int af, int type, int protocol);
+  struct hostent *_win_gethostbyaddr (const char *addr, int len, int type);
+  struct hostent *_win_gethostbyname (const char *name);
+  struct hostent *gethostbyname2 (const char *name, int af);
+  char *_win_strerror (int errnum);
+  int IsWinNT ();
+  char *index (const char *s, int c);
+
+#if !HAVE_STRNDUP
+  char *strndup (const char *s, size_t n);
+#endif
+#if !HAVE_STRNLEN
+  size_t strnlen (const char *str, size_t maxlen);
+#endif
+  char *stpcpy (char *dest, const char *src);
+  char *strcasestr (const char *haystack_start, const char *needle_start);
+
+#define strcasecmp(a, b) stricmp(a, b)
+#define strncasecmp(a, b, c) strnicmp(a, b, c)
+
+#endif                          /* WINDOWS */
+
+#ifndef WINDOWS
+#define DIR_SEPARATOR '/'
+#define DIR_SEPARATOR_STR "/"
+#define PATH_SEPARATOR ':'
+#define PATH_SEPARATOR_STR ":"
+#define NEWLINE "\n"
+
+#ifdef ENABLE_NLS
+#define BINDTEXTDOMAIN(d, n) bindtextdomain(d, n)
+#endif
+#define CREAT(p, m) creat(p, m)
+#define PLIBC_CTIME(c) ctime(c)
+#define CTIME_R(c, b) ctime_r(c, b)
+#undef FOPEN
+#define FOPEN(f, m) fopen(f, m)
+#define FTRUNCATE(f, l) ftruncate(f, l)
+#define OPENDIR(d) opendir(d)
+#define OPEN open
+#define CHDIR(d) chdir(d)
+#define CLOSE(f) close(f)
+#define LSEEK(f, o, w) lseek(f, o, w)
+#define RMDIR(f) rmdir(f)
+#define ACCESS(p, m) access(p, m)
+#define CHMOD(f, p) chmod(f, p)
+#define FSTAT(h, b) fstat(h, b)
+#define PLIBC_KILL(p, s) kill(p, s)
+#define PIPE(h) pipe(h)
+#define REMOVE(p) remove(p)
+#define RENAME(o, n) rename(o, n)
+#define STAT(p, b) stat(p, b)
+#define STAT64(p, b) stat64(p, b)
+#define SYSCONF(n) sysconf(n)
+#define UNLINK(f) unlink(f)
+#define WRITE(f, b, n) write(f, b, n)
+#define READ(f, b, n) read(f, b, n)
+#define GN_FREAD(b, s, c, f) fread(b, s, c, f)
+#define GN_FWRITE(b, s, c, f) fwrite(b, s, c, f)
+#define SYMLINK(a, b) symlink(a, b)
+#define MMAP(s, l, p, f, d, o) mmap(s, l, p, f, d, o)
+#define MUNMAP(s, l) munmap(s, l)
+#define STRERROR(i) strerror(i)
+#define RANDOM() random()
+#define SRANDOM(s) srandom(s)
+#define READLINK(p, b, s) readlink(p, b, s)
+#define LSTAT(p, b) lstat(p, b)
+#define LSTAT64(p, b) lstat64(p, b)
+#define PRINTF printf
+#define FPRINTF fprintf
+#define VPRINTF(f, a) vprintf(f, a)
+#define VFPRINTF(s, f, a) vfprintf(s, f, a)
+#define VSPRINTF(d, f, a) vsprintf(d, f, a)
+#define VSNPRINTF(str, size, fmt, a) vsnprintf(str, size, fmt, a)
+#define _REAL_SNPRINTF snprintf
+#define SPRINTF sprintf
+#define VSSCANF(s, f, a) vsscanf(s, f, a)
+#define SSCANF sscanf
+#define VFSCANF(s, f, a) vfscanf(s, f, a)
+#define VSCANF(f, a) vscanf(f, a)
+#define SCANF scanf
+#define FSCANF fscanf
+#define WAITPID(p, s, o) waitpid(p, s, o)
+#define ACCEPT(s, a, l) accept(s, a, l)
+#define BIND(s, n, l) bind(s, n, l)
+#define CONNECT(s, n, l) connect(s, n, l)
+#define GETPEERNAME(s, n, l) getpeername(s, n, l)
+#define GETSOCKNAME(s, n, l) getsockname(s, n, l)
+#define GETSOCKOPT(s, l, o, v, p) getsockopt(s, l, o, v, p)
+#define LISTEN(s, b) listen(s, b)
+#define RECV(s, b, l, f) recv(s, b, l, f)
+#define RECVFROM(s, b, l, f, r, o) recvfrom(s, b, l, f, r, o)
+#define SELECT(n, r, w, e, t) select(n, r, w, e, t)
+#define SEND(s, b, l, f) send(s, b, l, f)
+#define SENDTO(s, b, l, f, o, n) sendto(s, b, l, f, o, n)
+#define SETSOCKOPT(s, l, o, v, n) setsockopt(s, l, o, v, n)
+#define SHUTDOWN(s, h) shutdown(s, h)
+#define SOCKET(a, t, p) socket(a, t, p)
+#define GETHOSTBYADDR(a, l, t) gethostbyname(a, l, t)
+#define GETHOSTBYNAME(n) gethostbyname(n)
+#define GETTIMEOFDAY(t, n) gettimeofday(t, n)
+#define INSQUE(e, p) insque(e, p)
+#define REMQUE(e) remque(e)
+#define HSEARCH(i, a) hsearch(i, a)
+#define HCREATE(n) hcreate(n)
+#define HDESTROY() hdestroy()
+#define HSEARCH_R(i, a, r, h) hsearch_r(i, a, r, h)
+#define HCREATE_R(n, h) hcreate_r(n, h)
+#define HDESTROY_R(h) hdestroy_r(h)
+#define TSEARCH(k, r, c) tsearch(k, r, c)
+#define TFIND(k, r, c) tfind(k, r, c)
+#define TDELETE(k, r, c) tdelete(k, r, c)
+#define TWALK(r, a) twalk(r, a)
+#define TDESTROY(r, f) tdestroy(r, f)
+#define LFIND(k, b, n, s, c) lfind(k, b, n, s, c)
+#define LSEARCH(k, b, n, s, c) lsearch(k, b, n, s, c)
+#else
+#define DIR_SEPARATOR '\\'
+#define DIR_SEPARATOR_STR "\\"
+#define PATH_SEPARATOR ';'
+#define PATH_SEPARATOR_STR ";"
+#define NEWLINE "\r\n"
+
+#ifdef ENABLE_NLS
+#define BINDTEXTDOMAIN(d, n) _win_bindtextdomain(d, n)
+#endif
+#define CREAT(p, m) _win_creat(p, m)
+#define PLIBC_CTIME(c) _win_ctime(c)
+#define CTIME_R(c, b) _win_ctime_r(c, b)
+#define FOPEN(f, m) _win_fopen(f, m)
+#define FTRUNCATE(f, l) _win_ftruncate(f, l)
+#define OPENDIR(d) _win_opendir(d)
+#define OPEN _win_open
+#define CHDIR(d) _win_chdir(d)
+#define CLOSE(f) _win_close(f)
+#define PLIBC_KILL(p, s) _win_kill(p, s)
+#define LSEEK(f, o, w) _win_lseek(f, o, w)
+#define FSTAT(h, b) _win_fstat(h, b)
+#define RMDIR(f) _win_rmdir(f)
+#define ACCESS(p, m) _win_access(p, m)
+#define CHMOD(f, p) _win_chmod(f, p)
+#define PIPE(h) _win_pipe(h)
+#define RANDOM() _win_random()
+#define SRANDOM(s) _win_srandom(s)
+#define REMOVE(p) _win_remove(p)
+#define RENAME(o, n) _win_rename(o, n)
+#define STAT(p, b) _win_stat(p, b)
+#define STAT64(p, b) _win_stat64(p, b)
+#define SYSCONF(n) _win_sysconf(n)
+#define UNLINK(f) _win_unlink(f)
+#define WRITE(f, b, n) _win_write(f, b, n)
+#define READ(f, b, n) _win_read(f, b, n)
+#define GN_FREAD(b, s, c, f) _win_fread(b, s, c, f)
+#define GN_FWRITE(b, s, c, f) _win_fwrite(b, s, c, f)
+#define SYMLINK(a, b) _win_symlink(a, b)
+#define MMAP(s, l, p, f, d, o) _win_mmap(s, l, p, f, d, o)
+#define MUNMAP(s, l) _win_munmap(s, l)
+#define STRERROR(i) _win_strerror(i)
+#define READLINK(p, b, s) _win_readlink(p, b, s)
+#define LSTAT(p, b) _win_lstat(p, b)
+#define LSTAT64(p, b) _win_lstat64(p, b)
+#define PRINTF(f, ...) _win_printf(f , __VA_ARGS__)
+#define FPRINTF(fil, fmt, ...) _win_fprintf(fil, fmt, __VA_ARGS__)
+#define VPRINTF(f, a) _win_vprintf(f, a)
+#define VFPRINTF(s, f, a) _win_vfprintf(s, f, a)
+#define VSPRINTF(d, f, a) _win_vsprintf(d, f, a)
+#define VSNPRINTF(str, size, fmt, a) _win_vsnprintf(str, size, fmt, a)
+#define _REAL_SNPRINTF(str, size, fmt, ...) _win_snprintf(str, size, fmt, __VA_ARGS__)
+#define SPRINTF(d, f, ...) _win_sprintf(d, f, __VA_ARGS__)
+#define VSSCANF(s, f, a) _win_vsscanf(s, f, a)
+#define SSCANF(s, f, ...) _win_sscanf(s, f, __VA_ARGS__)
+#define VFSCANF(s, f, a) _win_vfscanf(s, f, a)
+#define VSCANF(f, a) _win_vscanf(f, a)
+#define SCANF(f, ...) _win_scanf(f, __VA_ARGS__)
+#define FSCANF(s, f, ...) _win_fscanf(s, f, __VA_ARGS__)
+#define WAITPID(p, s, o) _win_waitpid(p, s, o)
+#define ACCEPT(s, a, l) _win_accept(s, a, l)
+#define BIND(s, n, l) _win_bind(s, n, l)
+#define CONNECT(s, n, l) _win_connect(s, n, l)
+#define GETPEERNAME(s, n, l) _win_getpeername(s, n, l)
+#define GETSOCKNAME(s, n, l) _win_getsockname(s, n, l)
+#define GETSOCKOPT(s, l, o, v, p) _win_getsockopt(s, l, o, v, p)
+#define LISTEN(s, b) _win_listen(s, b)
+#define RECV(s, b, l, f) _win_recv(s, b, l, f)
+#define RECVFROM(s, b, l, f, r, o) _win_recvfrom(s, b, l, f, r, o)
+#define SELECT(n, r, w, e, t) _win_select(n, r, w, e, t)
+#define SEND(s, b, l, f) _win_send(s, b, l, f)
+#define SENDTO(s, b, l, f, o, n) _win_sendto(s, b, l, f, o, n)
+#define SETSOCKOPT(s, l, o, v, n) _win_setsockopt(s, l, o, v, n)
+#define SHUTDOWN(s, h) _win_shutdown(s, h)
+#define SOCKET(a, t, p) _win_socket(a, t, p)
+#define GETHOSTBYADDR(a, l, t) _win_gethostbyname(a, l, t)
+#define GETHOSTBYNAME(n) _win_gethostbyname(n)
+#define GETTIMEOFDAY(t, n) _win_gettimeofday(t, n)
+#define INSQUE(e, p) _win_insque(e, p)
+#define REMQUE(e) _win_remque(e)
+#define HSEARCH(i, a) _win_hsearch(i, a)
+#define HCREATE(n) _win_hcreate(n)
+#define HDESTROY() _win_hdestroy()
+#define HSEARCH_R(i, a, r, h) _win_hsearch_r(i, a, r, h)
+#define HCREATE_R(n, h) _win_hcreate_r(n, h)
+#define HDESTROY_R(h) _win_hdestroy_r(h)
+#define TSEARCH(k, r, c) _win_tsearch(k, r, c)
+#define TFIND(k, r, c) _win_tfind(k, r, c)
+#define TDELETE(k, r, c) _win_tdelete(k, r, c)
+#define TWALK(r, a) _win_twalk(r, a)
+#define TDESTROY(r, f) _win_tdestroy(r, f)
+#define LFIND(k, b, n, s, c) _win_lfind(k, b, n, s, c)
+#define LSEARCH(k, b, n, s, c) _win_lsearch(k, b, n, s, c)
+#endif
+
+/* search.h */
+
+/* Prototype structure for a linked-list data structure.
+   This is the type used by the `insque' and `remque' functions.  */
+
+  struct PLIBC_SEARCH_QELEM
+  {
+    struct qelem *q_forw;
+    struct qelem *q_back;
+    char q_data[1];
+  };
+
+
+/* Insert ELEM into a doubly-linked list, after PREV.  */
+  void _win_insque (void *__elem, void *__prev);
+
+/* Unlink ELEM from the doubly-linked list that it is in.  */
+  void _win_remque (void *__elem);
+
+
+/* For use with hsearch(3).  */
+  typedef int (*PLIBC_SEARCH__compar_fn_t) (__const void *, __const void *);
+
+  typedef PLIBC_SEARCH__compar_fn_t _win_comparison_fn_t;
+
+/* Action which shall be performed in the call the hsearch.  */
+  typedef enum
+  {
+    PLIBC_SEARCH_FIND,
+    PLIBC_SEARCH_ENTER
+  }
+  PLIBC_SEARCH_ACTION;
+
+  typedef struct PLIBC_SEARCH_entry
+  {
+    char *key;
+    void *data;
+  }
+  PLIBC_SEARCH_ENTRY;
+
+/* The reentrant version has no static variables to maintain the state.
+   Instead the interface of all functions is extended to take an argument
+   which describes the current status.  */
+  typedef struct _PLIBC_SEARCH_ENTRY
+  {
+    unsigned int used;
+    PLIBC_SEARCH_ENTRY entry;
+  }
+  _PLIBC_SEARCH_ENTRY;
+
+
+/* Family of hash table handling functions.  The functions also
+   have reentrant counterparts ending with _r.  The non-reentrant
+   functions all work on a signle internal hashing table.  */
+
+/* Search for entry matching ITEM.key in internal hash table.  If
+   ACTION is `FIND' return found entry or signal error by returning
+   NULL.  If ACTION is `ENTER' replace existing data (if any) with
+   ITEM.data.  */
+  PLIBC_SEARCH_ENTRY *_win_hsearch (PLIBC_SEARCH_ENTRY __item,
+                                    PLIBC_SEARCH_ACTION __action);
+
+/* Create a new hashing table which will at most contain NEL elements.  */
+  int _win_hcreate (size_t __nel);
+
+/* Destroy current internal hashing table.  */
+  void _win_hdestroy (void);
+
+/* Data type for reentrant functions.  */
+  struct PLIBC_SEARCH_hsearch_data
+  {
+    struct _PLIBC_SEARCH_ENTRY *table;
+    unsigned int size;
+    unsigned int filled;
+  };
+
+/* Reentrant versions which can handle multiple hashing tables at the
+   same time.  */
+  int _win_hsearch_r (PLIBC_SEARCH_ENTRY __item, PLIBC_SEARCH_ACTION __action,
+                      PLIBC_SEARCH_ENTRY ** __retval,
+                      struct PLIBC_SEARCH_hsearch_data *__htab);
+  int _win_hcreate_r (size_t __nel, struct PLIBC_SEARCH_hsearch_data *__htab);
+  void _win_hdestroy_r (struct PLIBC_SEARCH_hsearch_data *__htab);
+
+
+/* The tsearch routines are very interesting. They make many
+   assumptions about the compiler.  It assumes that the first field
+   in node must be the "key" field, which points to the datum.
+   Everything depends on that.  */
+/* For tsearch */
+  typedef enum
+  {
+    PLIBC_SEARCH_preorder,
+    PLIBC_SEARCH_postorder,
+    PLIBC_SEARCH_endorder,
+    PLIBC_SEARCH_leaf
+  }
+  PLIBC_SEARCH_VISIT;
+
+/* Search for an entry matching the given KEY in the tree pointed to
+   by *ROOTP and insert a new element if not found.  */
+  void *_win_tsearch (__const void *__key, void **__rootp,
+                      PLIBC_SEARCH__compar_fn_t __compar);
+
+/* Search for an entry matching the given KEY in the tree pointed to
+   by *ROOTP.  If no matching entry is available return NULL.  */
+  void *_win_tfind (__const void *__key, void *__const * __rootp,
+                    PLIBC_SEARCH__compar_fn_t __compar);
+
+/* Remove the element matching KEY from the tree pointed to by *ROOTP.  */
+  void *_win_tdelete (__const void *__restrict __key, void **__restrict __rootp,
+                      PLIBC_SEARCH__compar_fn_t __compar);
+
+  typedef void (*PLIBC_SEARCH__action_fn_t) (__const void *__nodep,
+                                             PLIBC_SEARCH_VISIT __value,
+                                             int __level);
+
+/* Walk through the whole tree and call the ACTION callback for every node
+   or leaf.  */
+  void _win_twalk (__const void *__root, PLIBC_SEARCH__action_fn_t __action);
+
+/* Callback type for function to free a tree node.  If the keys are atomic
+   data this function should do nothing.  */
+  typedef void (*PLIBC_SEARCH__free_fn_t) (void *__nodep);
+
+/* Destroy the whole tree, call FREEFCT for each node or leaf.  */
+  void _win_tdestroy (void *__root, PLIBC_SEARCH__free_fn_t __freefct);
+
+
+/* Perform linear search for KEY by comparing by COMPAR in an array
+   [BASE,BASE+NMEMB*SIZE).  */
+  void *_win_lfind (__const void *__key, __const void *__base, size_t * __nmemb,
+                    size_t __size, PLIBC_SEARCH__compar_fn_t __compar);
+
+/* Perform linear search for KEY by comparing by COMPAR function in
+   array [BASE,BASE+NMEMB*SIZE) and insert entry if not found.  */
+  void *_win_lsearch (__const void *__key, void *__base, size_t * __nmemb,
+                      size_t __size, PLIBC_SEARCH__compar_fn_t __compar);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif                          //_PLIBC_H_
+
+/* end of plibc.h */
diff --git a/pathologist/src/mi/Makefile.am b/pathologist/src/mi/Makefile.am
new file mode 100644
index 0000000..1248080
--- /dev/null
+++ b/pathologist/src/mi/Makefile.am
@@ -0,0 +1,29 @@
+INCLUDES = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+if MINGW
+ WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols 
+endif
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = libmi.la
+
+libmi_la_SOURCES = \
+         gdbmi_alloc.c \
+         gdbmi_breakpoint.c \
+         gdbmi_connect.c \
+         gdbmi_data_man.c \
+         gdbmi_error.c \
+         gdbmi_get_free_pty.c \
+         gdbmi_get_free_vt.c \
+         gdbmi_misc.c \
+         gdbmi_parse.c \
+         gdbmi_prg_control.c \
+         gdbmi_stack_man.c \
+         gdbmi_symbol_query.c \
+         gdbmi_target_man.c \
+         gdbmi_thread.c \
+         gdbmi_var_obj.c
\ No newline at end of file
diff --git a/pathologist/src/mi/gdbmi_alloc.c b/pathologist/src/mi/gdbmi_alloc.c
new file mode 100644
index 0000000..0fe6e14
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_alloc.c
@@ -0,0 +1,308 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Allocator.
+  Comments:
+  Most alloc/free routines are here. Free routines must accept NULL
+pointers. Alloc functions must set mi_error.  @<p>
+  
+***************************************************************************/
+
+#include "gdbmi.h"
+
+void *mi_calloc(size_t count, size_t sz)
+{
+ void *res=calloc(count,sz);
+ if (!res)
+    mi_error=MI_OUT_OF_MEMORY;
+ return res;
+}
+
+void *mi_calloc1(size_t sz)
+{
+ return mi_calloc(1,sz);
+}
+
+char *mi_malloc(size_t sz)
+{
+ char *res=malloc(sz);
+ if (!res)
+    mi_error=MI_OUT_OF_MEMORY;
+ return res;
+}
+
+mi_results *mi_alloc_results(void)
+{
+ return (mi_results *)mi_calloc1(sizeof(mi_results));
+}
+
+mi_output *mi_alloc_output(void)
+{
+ return (mi_output *)mi_calloc1(sizeof(mi_output));
+}
+
+mi_frames *mi_alloc_frames(void)
+{
+ return (mi_frames *)mi_calloc1(sizeof(mi_frames));
+}
+
+mi_gvar *mi_alloc_gvar(void)
+{
+ return (mi_gvar *)mi_calloc1(sizeof(mi_gvar));
+}
+
+mi_gvar_chg *mi_alloc_gvar_chg(void)
+{
+ return (mi_gvar_chg *)mi_calloc1(sizeof(mi_gvar_chg));
+}
+
+mi_bkpt *mi_alloc_bkpt(void)
+{
+ mi_bkpt *b=(mi_bkpt *)mi_calloc1(sizeof(mi_bkpt));
+ if (b)
+   {
+    b->thread=-1;
+    b->ignore=-1;
+   }
+ return b;
+}
+
+mi_wp *mi_alloc_wp(void)
+{
+ return (mi_wp *)mi_calloc1(sizeof(mi_wp));
+}
+
+mi_stop *mi_alloc_stop(void)
+{
+ return (mi_stop *)mi_calloc1(sizeof(mi_stop));
+}
+
+mi_asm_insns *mi_alloc_asm_insns(void)
+{
+ return (mi_asm_insns *)mi_calloc1(sizeof(mi_asm_insns));
+}
+
+mi_asm_insn *mi_alloc_asm_insn(void)
+{
+ return (mi_asm_insn *)mi_calloc1(sizeof(mi_asm_insn));
+}
+
+mi_chg_reg *mi_alloc_chg_reg(void)
+{
+ return (mi_chg_reg *)mi_calloc1(sizeof(mi_chg_reg));
+}
+
+/*****************************************************************************
+  Free functions
+*****************************************************************************/
+
+void mi_free_frames(mi_frames *f)
+{
+ mi_frames *aux;
+
+ while (f)
+   {
+    free(f->func);
+    free(f->file);
+    free(f->from);
+    mi_free_results(f->args);
+    aux=f->next;
+    free(f);
+    f=aux;
+   }
+}
+
+void mi_free_bkpt(mi_bkpt *b)
+{
+ mi_bkpt *aux;
+
+ while (b)
+   {
+    free(b->func);
+    free(b->file);
+    free(b->file_abs);
+    free(b->cond);
+    aux=b->next;
+    free(b);
+    b=aux;
+   }
+}
+
+void mi_free_gvar(mi_gvar *v)
+{
+ mi_gvar *aux;
+
+ while (v)
+   {
+    free(v->name);
+    free(v->type);
+    free(v->exp);
+    free(v->value);
+    if (v->numchild && v->child)
+       mi_free_gvar(v->child);
+    aux=v->next;
+    free(v);
+    v=aux;
+   }
+}
+
+void mi_free_gvar_chg(mi_gvar_chg *p)
+{
+ mi_gvar_chg *aux;
+
+ while (p)
+   {
+    free(p->name);
+    free(p->new_type);
+    aux=p->next;
+    free(p);
+    p=aux;
+   }
+}
+
+void mi_free_results_but(mi_results *r, mi_results *no)
+{
+ mi_results *aux;
+
+ while (r)
+   {
+    if (r==no)
+      {
+       aux=r->next;
+       r->next=NULL;
+       r=aux;
+      }
+    else
+      {
+       free(r->var);
+       switch (r->type)
+         {
+          case t_const:
+               free(r->v.cstr);
+               break;
+          case t_tuple:
+          case t_list:
+               mi_free_results_but(r->v.rs,no);
+               break;
+         }
+       aux=r->next;
+       free(r);
+       r=aux;
+      }
+   }
+}
+
+void mi_free_results(mi_results *r)
+{
+ mi_free_results_but(r,NULL);
+}
+
+void mi_free_output_but(mi_output *r, mi_output *no, mi_results *no_r)
+{
+ mi_output *aux;
+
+ while (r)
+   {
+    if (r==no)
+      {
+       aux=r->next;
+       r->next=NULL;
+       r=aux;
+      }
+    else
+      {
+       if (r->c)
+          mi_free_results_but(r->c,no_r);
+       aux=r->next;
+       free(r);
+       r=aux;
+      }
+   }
+}
+
+void mi_free_output(mi_output *r)
+{
+ mi_free_output_but(r,NULL,NULL);
+}
+
+void mi_free_stop(mi_stop *s)
+{
+ if (!s)
+    return;
+ mi_free_frames(s->frame);
+ mi_free_wp(s->wp);
+ free(s->wp_old);
+ free(s->wp_val);
+ free(s->gdb_result_var);
+ free(s->return_value);
+ free(s->signal_name);
+ free(s->signal_meaning);
+ free(s);
+}
+
+void mi_free_wp(mi_wp *wp)
+{
+ mi_wp *aux;
+ while (wp)
+   {
+    free(wp->exp);
+    aux=wp->next;
+    free(wp);
+    wp=aux;
+   }
+}
+
+void mi_free_asm_insns(mi_asm_insns *i)
+{
+ mi_asm_insns *aux;
+
+ while (i)
+   {
+    free(i->file);
+    mi_free_asm_insn(i->ins);
+    aux=i->next;
+    free(i);
+    i=aux;
+   }
+}
+
+void mi_free_asm_insn(mi_asm_insn *i)
+{
+ mi_asm_insn *aux;
+
+ while (i)
+   {
+    free(i->func);
+    free(i->inst);
+    aux=i->next;
+    free(i);
+    i=aux;
+   }
+}
+
+/*void mi_free_charp_list(char **l)
+{
+ char **c=l;
+ while (c)
+   {
+    free(*c);
+    c++;
+   }
+ free(l);
+}*/
+
+void mi_free_chg_reg(mi_chg_reg *r)
+{
+ mi_chg_reg *aux;
+ while (r)
+   {
+    free(r->val);
+    free(r->name);
+    aux=r->next;
+    free(r);
+    r=aux;
+   }
+}
+
diff --git a/pathologist/src/mi/gdbmi_breakpoint.c b/pathologist/src/mi/gdbmi_breakpoint.c
new file mode 100644
index 0000000..f91cc3e
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_breakpoint.c
@@ -0,0 +1,265 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Breakpoint table commands.
+  Comments:
+  GDB/MI commands for the "Breakpoint Table Commands" section.
+   @<p>
+@<pre>
+gdb command:          Implemented?
+
+-break-after          Yes
+-break-condition      Yes
+-break-delete         Yes
+-break-disable        Yes
+-break-enable         Yes
+-break-info           N.A. (info break NUMBER) (*)
+-break-insert         Yes
+-break-list           No (*)
+-break-watch          Yes
+@</pre>
+
+(*) I think the program should keep track of the breakpoints, so it will
+be implemented when I have more time.  @<p>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_break_insert_fl(mi_h *h, const char *file, int line)
+{
+ mi_send(h,"-break-insert %s:%d\n",file,line);
+}
+
+void mi_break_insert(mi_h *h, int temporary, int hard_assist,
+                     const char *cond, int count, int thread,
+                     const char *where)
+{
+ char s_count[32];
+ char s_thread[32];
+
+ if (count>=0)
+    snprintf(s_count,32,"%d",count);
+ if (thread>=0)
+    snprintf(s_thread,32,"%d",thread);
+ if (cond)
+    // Conditions may contain spaces, in fact, if they don't gdb will add
+    // them after parsing. Enclosing the expression with "" solves the
+    // problem.
+    mi_send(h,"-break-insert %s %s -c \"%s\" %s %s %s %s %s\n",
+            temporary   ? "-t" : "",
+            hard_assist ? "-h" : "",
+            cond,
+            count>=0    ? "-i" : "", count>=0  ? s_count  : "",
+            thread>=0   ? "-p" : "", thread>=0 ? s_thread : "",
+            where);
+ else
+    mi_send(h,"-break-insert %s %s %s %s %s %s %s\n",
+            temporary   ? "-t" : "",
+            hard_assist ? "-h" : "",
+            count>=0    ? "-i" : "", count>=0  ? s_count  : "",
+            thread>=0   ? "-p" : "", thread>=0 ? s_thread : "",
+            where);
+}
+
+void mi_break_insert_flf(mi_h *h, const char *file, int line, int temporary,
+                         int hard_assist, const char *cond, int count,
+                         int thread)
+{
+ char s_count[32];
+ char s_thread[32];
+
+ if (count>=0)
+    snprintf(s_count,32,"%d",count);
+ if (thread>=0)
+    snprintf(s_thread,32,"%d",thread);
+ mi_send(h,"-break-insert %s %s %s %s %s %s %s %s %s:%d\n",
+         temporary   ? "-t" : "",
+         hard_assist ? "-h" : "",
+         cond        ? "-c" : "", cond      ? cond     : "",
+         count>=0    ? "-i" : "", count>=0  ? s_count  : "",
+         thread>=0   ? "-p" : "", thread>=0 ? s_thread : "",
+         file,line);
+}
+
+void mi_break_delete(mi_h *h, int number)
+{
+ mi_send(h,"-break-delete %d\n",number);
+}
+
+void mi_break_after(mi_h *h, int number, int count)
+{
+ mi_send(h,"-break-after %d %d\n",number,count);
+}
+
+void mi_break_condition(mi_h *h, int number, const char *condition)
+{
+ mi_send(h,"-break-condition %d %s\n",number,condition);
+}
+
+void mi_break_enable(mi_h *h, int number)
+{
+ mi_send(h,"-break-enable %d\n",number);
+}
+
+void mi_break_disable(mi_h *h, int number)
+{
+ mi_send(h,"-break-disable %d\n",number);
+}
+
+void mi_break_watch(mi_h *h, enum mi_wp_mode mode, const char *exp)
+{
+ if (mode==wm_write)
+    mi_send(h,"-break-watch \"%s\"\n",exp);
+ else
+    mi_send(h,"-break-watch -%c \"%s\"\n",mode==wm_rw ? 'a' : 'r',exp);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Insert a breakpoint at file:line.
+
+  Command: -break-insert file:line
+  Return: A new mi_bkpt structure with info about the breakpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_bkpt *gmi_break_insert(mi_h *h, const char *file, int line)
+{
+ mi_break_insert_fl(h,file,line);
+ return mi_res_bkpt(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Insert a breakpoint, all available options.
+  
+  Command: -break-insert
+  Return: A new mi_bkpt structure with info about the breakpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_bkpt *gmi_break_insert_full(mi_h *h, int temporary, int hard_assist,
+                               const char *cond, int count, int thread,
+                               const char *where)
+{
+ mi_break_insert(h,temporary,hard_assist,cond,count,thread,where);
+ return mi_res_bkpt(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Insert a breakpoint, all available options.
+  
+  Command: -break-insert [ops] file:line
+  Return: A new mi_bkpt structure with info about the breakpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_bkpt *gmi_break_insert_full_fl(mi_h *h, const char *file, int line,
+                                  int temporary, int hard_assist,
+                                  const char *cond, int count, int thread)
+{
+ mi_break_insert_flf(h,file,line,temporary,hard_assist,cond,count,thread);
+ return mi_res_bkpt(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Remove a breakpoint.
+
+  Command: -break-delete
+  Return: !=0 OK. Note that gdb always says OK, but errors can be sent to the
+console.
+  
+***************************************************************************/
+
+int gmi_break_delete(mi_h *h, int number)
+{
+ mi_break_delete(h,number);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Modify the "ignore" count for a breakpoint.
+
+  Command: -break-after
+  Return: !=0 OK. Note that gdb always says OK, but errors can be sent to the
+console.
+  
+***************************************************************************/
+
+int gmi_break_set_times(mi_h *h, int number, int count)
+{
+ mi_break_after(h,number,count);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Associate a condition with the breakpoint.
+
+  Command: -break-condition
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_break_set_condition(mi_h *h, int number, const char *condition)
+{
+ mi_break_condition(h,number,condition);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Enable or disable a breakpoint.
+
+  Command: -break-enable + -break-disable
+  Return: !=0 OK. Note that gdb always says OK, but errors can be sent to the
+console.
+  
+***************************************************************************/
+
+int gmi_break_state(mi_h *h, int number, int enable)
+{
+ if (enable)
+    mi_break_enable(h,number);
+ else
+    mi_break_disable(h,number);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set a watchpoint. It doesn't work for remote targets!
+
+  Command: -break-watch
+  Return: A new mi_wp structure with info about the watchpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_wp *gmi_break_watch(mi_h *h, enum mi_wp_mode mode, const char *exp)
+{
+ mi_break_watch(h,mode,exp);
+ return mi_res_wp(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_connect.c b/pathologist/src/mi/gdbmi_connect.c
new file mode 100644
index 0000000..b9f3754
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_connect.c
@@ -0,0 +1,885 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2009 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Connect.
+  Comments:
+  This module handles the dialog with gdb, including starting and stopping
+gdb.
+  @<p>
+
+GDB Bug workaround for "file -readnow": I tried to workaround a bug using
+it but looks like this option also have bugs!!!! so I have to use the
+command line option --readnow.
+It also have a bug!!!! when the binary is changed and gdb must reload it
+this option is ignored. So it looks like we have no solution but 3 gdb bugs
+in a row.
+
+***************************************************************************/
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include "plibc.h"
+
+#include "gdbmi.h"
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#ifndef TEMP_FAILURE_RETRY
+ #define TEMP_FAILURE_RETRY(a) (a)
+#endif
+
+int mi_error=MI_OK;
+char *mi_error_from_gdb=NULL;
+static char *gdb_exe=NULL;
+static char *xterm_exe=NULL;
+static char *gdb_start=NULL;
+static char *gdb_conn=NULL;
+static char *main_func=NULL;
+static char  disable_psym_search_workaround=0;
+
+mi_h *mi_alloc_h()
+{
+ mi_h *h=(mi_h *)calloc(1,sizeof(mi_h));
+ if (!h)
+   {
+    mi_error=MI_OUT_OF_MEMORY;
+    return NULL;
+   }
+ h->to_gdb[0]=h->to_gdb[1]=h->from_gdb[0]=h->from_gdb[1]=-1;
+ h->pid=-1;
+ return h;
+}
+
+int mi_check_running_pid(pid_t pid)
+{
+ int status;
+
+ if (pid<=0)
+    return 0;
+ /* If waitpid returns the number of our child means it communicated
+    to as a termination status. */
+ if (waitpid(pid,&status,WNOHANG)==pid)
+   {
+    pid=0;
+    return 0;
+   }
+ return 1;
+}
+
+int mi_check_running(mi_h *h)
+{
+ return !h->died && mi_check_running_pid(h->pid);
+}
+
+void mi_kill_child(pid_t pid)
+{
+ kill(pid,SIGTERM);
+ usleep(100000);
+ if (mi_check_running_pid(pid))
+   {
+    int status;
+    kill(pid,SIGKILL);
+    waitpid(pid,&status,0);
+   }
+}
+
+void mi_free_h(mi_h **handle)
+{
+ mi_h *h=*handle;
+ if (h->to_gdb[0]>=0)
+    close(h->to_gdb[0]);
+ if (h->to)
+    fclose(h->to);
+ else if (h->to_gdb[1]>=0)
+    close(h->to_gdb[1]);
+ if (h->from)
+    fclose(h->from);
+ else if (h->from_gdb[0]>=0)
+    close(h->from_gdb[0]);
+ if (h->from_gdb[1]>=0)
+    close(h->from_gdb[1]);
+ if (mi_check_running(h))
+   {/* GDB is running! */
+    mi_kill_child(h->pid);
+   }
+ if (h->line)
+    free(h->line);
+ mi_free_output(h->po);
+ free(h->catched_console);
+ free(h);
+ *handle=NULL;
+}
+
+void mi_set_nonblk(int h)
+{
+ int flf;
+ flf=fcntl(h,F_GETFL,0);
+ flf=flf | O_NONBLOCK;
+ fcntl(h,F_SETFL,flf);
+}
+
+int mi_getline(mi_h *h)
+{
+ char c;
+
+ while (read(h->from_gdb[0],&c,1)==1)
+   {
+    if (h->lread>=h->llen)
+      {
+       h->llen=h->lread+128;
+       h->line=(char *)realloc(h->line,h->llen);
+       if (!h->line)
+         {
+          h->llen=0;
+          h->lread=0;
+          return -1;
+         }
+      }
+    if (c=='\n')
+      {
+       int ret=h->lread;
+       h->line[ret]=0;
+       h->lread=0;
+       return ret;
+      }
+    h->line[h->lread]=c;
+    h->lread++;
+   }
+ return 0;
+}
+
+char *get_cstr(mi_output *o)
+{
+ if (!o->c || o->c->type!=t_const)
+    return NULL;
+ return o->c->v.cstr;
+}
+
+int mi_get_response(mi_h *h)
+{
+ int l=mi_getline(h);
+ if (!l)
+    return 0;
+
+ if (h->from_gdb_echo)
+    h->from_gdb_echo(h->line,h->from_gdb_echo_data);
+ if (strncmp(h->line,"(gdb)",5)==0)
+   {/* End of response. */
+    return 1;
+   }
+ else
+   {/* Add to the response. */
+    mi_output *o;
+    int add=1, is_exit=0;
+    o=mi_parse_gdb_output(h->line);
+
+    if (!o)
+       return 0;
+    /* Tunneled streams callbacks. */
+    if (o->type==MI_T_OUT_OF_BAND && o->stype==MI_ST_STREAM)
+      {
+       char *aux;
+       add=0;
+       switch (o->sstype)
+         {
+          case MI_SST_CONSOLE:
+               aux=get_cstr(o);
+               if (h->console)
+                  h->console(aux,h->console_data);
+               if (h->catch_console && aux)
+                 {
+                  h->catch_console--;
+                  if (!h->catch_console)
+                    {
+                     free(h->catched_console);
+                     h->catched_console=strdup(aux);
+                    }
+                 }
+               break;
+          case MI_SST_TARGET:
+               /* This one seems to be useless. */
+               if (h->target)
+                  h->target(get_cstr(o),h->target_data);
+               break;
+          case MI_SST_LOG:
+               if (h->log)
+                  h->log(get_cstr(o),h->log_data);
+               break;
+         }
+      }
+    else if (o->type==MI_T_OUT_OF_BAND && o->stype==MI_ST_ASYNC)
+      {
+       if (h->async)
+          h->async(o,h->async_data);
+      }
+    else if (o->type==MI_T_RESULT_RECORD && o->tclass==MI_CL_ERROR)
+      {/* Error from gdb, record it. */
+       mi_error=MI_FROM_GDB;
+       free(mi_error_from_gdb);
+       mi_error_from_gdb=NULL;
+       if (o->c && strcmp(o->c->var,"msg")==0 && o->c->type==t_const)
+          mi_error_from_gdb=strdup(o->c->v.cstr);
+      }
+    is_exit=(o->type==MI_T_RESULT_RECORD && o->tclass==MI_CL_EXIT);
+    /* Add to the list of responses. */
+    if (add)
+      {
+       if (h->last)
+          h->last->next=o;
+       else
+          h->po=o;
+       h->last=o;
+      }
+    else
+       mi_free_output(o);
+    /* Exit RR means gdb exited, we won't get a new prompt ;-) */
+    if (is_exit)
+       return 1;
+   }
+
+ return 0;
+}
+
+mi_output *mi_retire_response(mi_h *h)
+{
+ mi_output *ret=h->po;
+ h->po=h->last=NULL;
+ return ret;
+}
+
+mi_output *mi_get_response_blk(mi_h *h)
+{
+ int r;
+ /* Sometimes gdb dies. */
+ if (!mi_check_running(h))
+   {
+    h->died=1;
+    mi_error=MI_GDB_DIED;
+    return NULL;
+   }
+ do
+   {
+   /*
+    That's a must. If we just keep trying to read and failing things
+    become really sloooowwww. Instead we try and if it fails we wait
+    until something is available.
+    TODO: Implement something with the time out, a callback to ask the
+    application is we have to wait or not could be a good thing.
+   */
+   fd_set set;
+   struct timeval timeout;
+   int ret;
+
+   r=mi_get_response(h);
+   if (r)
+      return mi_retire_response(h);
+
+   FD_ZERO(&set);
+   FD_SET(h->from_gdb[0],&set);
+   timeout.tv_sec=h->time_out;
+   timeout.tv_usec=0;
+   ret=TEMP_FAILURE_RETRY(select(FD_SETSIZE,&set,NULL,NULL,&timeout));
+   if (!ret)
+     {
+      if (!mi_check_running(h))
+        {
+         h->died=1;
+         mi_error=MI_GDB_DIED;
+         return NULL;
+        }
+      if (h->time_out_cb)
+         ret=h->time_out_cb(h->time_out_cb_data);
+      if (!ret)
+        {
+         mi_error=MI_GDB_TIME_OUT;
+         return NULL;
+        }
+     }
+   }
+ while (!r);
+
+ return NULL;
+}
+
+void mi_send_commands(mi_h *h, const char *file)
+{
+ FILE *f;
+ char b[PATH_MAX];
+
+ //printf("File: %s\n",file);
+ if (!file)
+    return;
+ f=fopen(file,"rt");
+ if (!f)
+    return;
+ while (!feof(f))
+   {
+    if (fgets(b,PATH_MAX,f))
+      {
+        //printf("Send: %s\n",b);
+        mi_send (h, "%s", b);
+        mi_res_simple_done(h);
+      }
+   }
+ fclose(f);
+}
+
+void mi_send_target_commands(mi_h *h)
+{
+ mi_send_commands(h,gdb_conn);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Connect to a local copy of gdb. Note that the mi_h structure is something
+similar to a "FILE *" for stdio.
+  
+  Return: A new mi_h structure or NULL on error.
+  
+***************************************************************************/
+
+mi_h *mi_connect_local()
+{
+ mi_h *h;
+ const char *gdb=mi_get_gdb_exe();
+
+ /* Start without error. */
+ mi_error=MI_OK;
+ /* Verify we have a GDB binary. */
+ if (access(gdb,X_OK))
+   {
+    mi_error=MI_MISSING_GDB;
+    return NULL;
+   }
+ /* Alloc the handle structure. */
+ h=mi_alloc_h();
+ if (!h)
+    return h;
+ h->time_out=MI_DEFAULT_TIME_OUT;
+ /* Create the pipes to connect with the child. */
+ if (pipe(h->to_gdb) || pipe(h->from_gdb))
+   {
+    mi_error=MI_PIPE_CREATE;
+    mi_free_h(&h);
+    return NULL;
+   }
+ mi_set_nonblk(h->to_gdb[1]);
+ mi_set_nonblk(h->from_gdb[0]);
+ /* Associate streams to the file handles. */
+ h->to=fdopen(h->to_gdb[1],"w");
+ h->from=fdopen(h->from_gdb[0],"r");
+ if (!h->to || !h->from)
+   {
+    mi_error=MI_PIPE_CREATE;
+    mi_free_h(&h);
+    return NULL;
+   }
+ /* Create the child. */
+ h->pid=fork();
+ if (h->pid==0)
+   {/* We are the child. */
+    char *argv[5];
+    /* Connect stdin/out to the pipes. */
+    dup2(h->to_gdb[0],STDIN_FILENO);
+    dup2(h->from_gdb[1],STDOUT_FILENO);
+    /* Pass the control to gdb. */
+    argv[0]=(char *)gdb; /* Is that OK? */
+    argv[1]="--interpreter=mi";
+    argv[2]="--quiet";
+    argv[3]=disable_psym_search_workaround ? 0 : "--readnow";
+    argv[4]=0;
+    execvp(argv[0],argv);
+    /* We get here only if exec failed. */
+    _exit(127);
+   }
+ /* We are the parent. */
+ if (h->pid==-1)
+   {/* Fork failed. */
+    mi_error=MI_FORK;
+    mi_free_h(&h);
+    return NULL;
+   }
+ if (!mi_check_running(h))
+   {
+    mi_error=MI_DEBUGGER_RUN;
+    mi_free_h(&h);
+    return NULL;
+   }
+ /* Wait for the prompt. */
+ mi_get_response_blk(h);
+ /* Send the start-up commands */
+ mi_send_commands(h,gdb_start);
+
+ return h;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Close connection. You should ask gdb to quit first gmi_gdb_exit.
+  
+***************************************************************************/
+
+void mi_disconnect(mi_h *h)
+{
+ mi_free_h(&h);
+ free(mi_error_from_gdb);
+ mi_error_from_gdb=NULL;
+}
+
+void mi_set_console_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->console=cb;
+ h->console_data=data;
+}
+
+void mi_set_target_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->target=cb;
+ h->target_data=data;
+}
+
+void mi_set_log_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->log=cb;
+ h->log_data=data;
+}
+
+stream_cb mi_get_console_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->console_data;
+ return h->console;
+}
+
+stream_cb mi_get_target_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->target_data;
+ return h->target;
+}
+
+stream_cb mi_get_log_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->log_data;
+ return h->log;
+}
+
+void mi_set_async_cb(mi_h *h, async_cb cb, void *data)
+{
+ h->async=cb;
+ h->async_data=data;
+}
+
+async_cb mi_get_async_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->async_data;
+ return h->async;
+}
+
+void mi_set_to_gdb_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->to_gdb_echo=cb;
+ h->to_gdb_echo_data=data;
+}
+
+void mi_set_from_gdb_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->from_gdb_echo=cb;
+ h->from_gdb_echo_data=data;
+}
+
+stream_cb mi_get_to_gdb_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->to_gdb_echo_data;
+ return h->to_gdb_echo;
+}
+
+stream_cb mi_get_from_gdb_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->from_gdb_echo_data;
+ return h->from_gdb_echo;
+}
+
+void mi_set_time_out_cb(mi_h *h, tm_cb cb, void *data)
+{
+ h->time_out_cb=cb;
+ h->time_out_cb_data=data;
+}
+
+tm_cb mi_get_time_out_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->time_out_cb_data;
+ return h->time_out_cb;
+}
+
+void mi_set_time_out(mi_h *h, int to)
+{
+ h->time_out=to;
+}
+
+int mi_get_time_out(mi_h *h)
+{
+ return h->time_out;
+}
+
+int mi_send(mi_h *h, const char *format, ...)
+{
+ int ret;
+ char *str;
+ va_list argptr;
+
+ if (h->died)
+    return 0;
+
+ va_start(argptr,format);
+ ret=vasprintf(&str,format,argptr);
+ va_end(argptr);
+ if (-1 != ret)
+   {
+     fputs(str,h->to);
+     fflush(h->to);
+     if (h->to_gdb_echo)
+       h->to_gdb_echo(str,h->to_gdb_echo_data);
+     free(str);
+   }
+ else
+   {
+     abort ();
+   }
+
+ return ret;
+}
+
+void mi_clean_up_globals()
+{
+ free(gdb_exe);
+ gdb_exe=NULL;
+ free(xterm_exe);
+ xterm_exe=NULL;
+ free(gdb_start);
+ gdb_start=NULL;
+ free(gdb_conn);
+ gdb_conn=NULL;
+ free(main_func);
+ main_func=NULL;
+}
+
+void mi_register_exit()
+{
+ static int registered=0;
+ if (!registered)
+   {
+    registered=1;
+    atexit(mi_clean_up_globals);
+   }
+}
+
+void mi_set_gdb_exe(const char *name)
+{
+ free(gdb_exe);
+ gdb_exe=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+void mi_set_gdb_start(const char *name)
+{
+ free(gdb_start);
+ gdb_start=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+void mi_set_gdb_conn(const char *name)
+{
+ free(gdb_conn);
+ gdb_conn=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+static
+char *mi_search_in_path(const char *file)
+{
+ char *path, *pt, *r;
+ char test[PATH_MAX];
+ struct stat st;
+
+ path=getenv("PATH");
+ if (!path)
+    return NULL;
+ pt=strdup(path);
+ r=strtok(pt,PATH_SEPARATOR_STR);
+ while (r)
+   {
+    strcpy(test,r);
+    strcat(test,"/");
+    strcat(test,file);
+    if (stat(test,&st)==0 && S_ISREG(st.st_mode))
+      {
+       free(pt);
+       return strdup(test);
+      }
+    r=strtok(NULL,PATH_SEPARATOR_STR);
+   }
+ free(pt);
+ return NULL;
+}
+
+const char *mi_get_gdb_exe()
+{
+ if (!gdb_exe)
+   {/* Look for gdb in path */
+    gdb_exe=mi_search_in_path("gdb");
+    if (!gdb_exe)
+       return "/usr/bin/gdb";
+   }
+ return gdb_exe;
+}
+
+const char *mi_get_gdb_start()
+{
+ return gdb_start;
+}
+
+const char *mi_get_gdb_conn()
+{
+ return gdb_conn;
+}
+
+void mi_set_xterm_exe(const char *name)
+{
+ free(xterm_exe);
+ xterm_exe=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+const char *mi_get_xterm_exe()
+{
+ if (!xterm_exe)
+   {/* Look for xterm in path */
+    xterm_exe=mi_search_in_path("xterm");
+    if (!xterm_exe)
+       return "/usr/bin/X11/xterm";
+   }
+ return xterm_exe;
+}
+
+void mi_set_main_func(const char *name)
+{
+ free(main_func);
+ main_func=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+const char *mi_get_main_func()
+{
+ if (main_func)
+    return main_func;
+ return "main";
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Opens a new xterm to be used by the child process to debug.
+  
+  Return: A new mi_aux_term structure, you can use gmi_end_aux_term to
+release it.
+  
+***************************************************************************/
+
+mi_aux_term *gmi_start_xterm()
+{
+ char nsh[14]="/tmp/shXXXXXX";
+ char ntt[14]="/tmp/ttXXXXXX";
+ const char *xterm;
+ struct stat st;
+ int hsh, htt=-1;
+ mi_aux_term *res=NULL;
+ FILE *f;
+ pid_t pid;
+ char buf[PATH_MAX];
+
+ /* Verify we have an X terminal. */
+ xterm=mi_get_xterm_exe();
+ if (access(xterm,X_OK))
+   {
+    mi_error=MI_MISSING_XTERM;
+    return NULL;
+   }
+
+ /* Create 2 temporals. */
+ hsh=mkstemp(nsh);
+ if (hsh==-1)
+   {
+    mi_error=MI_CREATE_TEMPORAL;
+    return NULL;
+   }
+ htt=mkstemp(ntt);
+ if (htt==-1)
+   {
+    close(hsh);
+    unlink(nsh);
+    mi_error=MI_CREATE_TEMPORAL;
+    return NULL;
+   }
+ close(htt);
+ /* Create the script. */
+ f=fdopen(hsh,"w");
+ if (!f)
+   {
+    close(hsh);
+    unlink(nsh);
+    unlink(ntt);
+    mi_error=MI_CREATE_TEMPORAL;
+    return NULL;
+   }
+ fprintf(f,"#!/bin/sh\n");
+ fprintf(f,"tty > %s\n",ntt);
+ fprintf(f,"rm %s\n",nsh);
+ fprintf(f,"sleep 365d\n");
+ fclose(f);
+ /* Spawn xterm. */
+ /* Create the child. */
+ pid=fork();
+ if (pid==0)
+   {/* We are the child. */
+    char *argv[5];
+    /* Pass the control to gdb. */
+    argv[0]=(char *)mi_get_xterm_exe(); /* Is that ok? */
+    argv[1]="-e";
+    argv[2]="/bin/sh";
+    argv[3]=nsh;
+    argv[4]=0;
+    execvp(argv[0],argv);
+    /* We get here only if exec failed. */
+    unlink(nsh);
+    unlink(ntt);
+    _exit(127);
+   }
+ /* We are the parent. */
+ if (pid==-1)
+   {/* Fork failed. */
+    unlink(nsh);
+    unlink(ntt);
+    mi_error=MI_FORK;
+    return NULL;
+   }
+ /* Wait until the shell is deleted. */
+ while (stat(nsh,&st)==0)
+   usleep(1000);
+ /* Try to read the tty name. */
+ f=fopen(ntt,"rt");
+ if (f)
+   {
+    if (fgets(buf,PATH_MAX,f))
+      {
+       char *s; /* Strip the \n. */
+       for (s=buf; *s && *s!='\n'; s++);
+       *s=0;
+       res=(mi_aux_term *)malloc(sizeof(mi_aux_term));
+       if (res)
+         {
+          res->pid=pid;
+          res->tty=strdup(buf);
+         }
+      }
+    fclose(f);
+   }
+ unlink(ntt);
+ return res;
+}
+
+void mi_free_aux_term(mi_aux_term *t)
+{
+ if (!t)
+    return;
+ free(t->tty);
+ free(t);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Closes the auxiliar terminal and releases the allocated memory.
+  
+***************************************************************************/
+
+void gmi_end_aux_term(mi_aux_term *t)
+{
+ if (!t)
+    return;
+ if (t->pid!=-1 && mi_check_running_pid(t->pid))
+    mi_kill_child(t->pid);
+ mi_free_aux_term(t);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Forces the MI version. Currently the library can't detect it so you must
+force it manually. GDB 5.x implemented MI v1 and 6.x v2.
+  
+***************************************************************************/
+
+void mi_force_version(mi_h *h, unsigned vMajor, unsigned vMiddle,
+                      unsigned vMinor)
+{
+ h->version=MI_VERSION2U(vMajor,vMiddle,vMinor);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Dis/Enables the workaround for a bug in gdb.
+
+***************************************************************************/
+
+void mi_set_workaround(unsigned wa, int enable)
+{
+ switch (wa)
+   {
+    case MI_PSYM_SEARCH:
+         disable_psym_search_workaround=enable ? 0 : 1;
+         break;
+   }
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Finds if the workaround for a bug in gdb is enabled.
+  
+  Return: !=0 if enabled.
+  
+***************************************************************************/
+
+int mi_get_workaround(unsigned wa)
+{
+ switch (wa)
+   {
+    case MI_PSYM_SEARCH:
+         return disable_psym_search_workaround==0;
+   }
+ return 0;
+}
+
diff --git a/pathologist/src/mi/gdbmi_data_man.c b/pathologist/src/mi/gdbmi_data_man.c
new file mode 100644
index 0000000..06e1377
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_data_man.c
@@ -0,0 +1,243 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Data manipulation.
+  Comments:
+  GDB/MI commands for the "Data manipulation" section.
+
+  @<p>
+
+@<pre>
+gdb command:                       Implemented?
+
+-data-disassemble                  Yes
+-data-evaluate-expression          Yes
+-data-list-changed-registers       No
+-data-list-register-names          Yes
+-data-list-register-values         No
+-data-read-memory                  No
+-display-delete                    N.A. (delete display)
+-display-disable                   N.A. (disable display)
+-display-enable                    N.A. (enable display)
+-display-insert                    N.A. (display)
+-display-list                      N.A. (info display)
+-environment-cd                    No
+-environment-directory             Yes, MI v1 implementation
+-environment-path                  No
+@</pre>
+
+Notes:  @<p>
+
+1) -display* aren't implemented. You can use CLI command display, but the
+results are sent to the console. So it looks like the best is to manually
+use -data-evaluate-expression to emulate it.  @<p>
+
+2) GDB bug mi/1770: Affects gdb<=6.2, when you ask for the names of the
+registers you get it plus the name of the "pseudo-registers", but if you
+try to get the value of a pseudo-register you get an error saying the
+register number is invalid. I reported to gdb-patches@sources.redhat.com
+on 2004/08/25 and as I didn't get any answer I filled a bug report on
+2004/09/02. The patch to fix this annoying bug is:
+
+Index: gdb/mi/mi-main.c
+===================================================================
+RCS file: /cvs/src/src/gdb/mi/mi-main.c,v
+retrieving revision 1.64
+diff -u -r1.64 mi-main.c
+--- gdb/mi/mi-main.c    3 Aug 2004 00:57:27 -0000       1.64
++++ gdb/mi/mi-main.c    25 Aug 2004 14:12:50 -0000
+@@ -423,7 +423,7 @@
+      case, some entries of REGISTER_NAME will change depending upon
+      the particular processor being debugged.
+
+-  numregs = NUM_REGS;
++  numregs = NUM_REGS + NUM_PSEUDO_REGS;
+
+   if (argc == 0)
+     {
+----
+
+Note I had to remove an end of comment in the patch to include it here.
+This bug forced me to create another set of functions. The only way is to
+first get the values and then the names.
+Fixed by Changelog entry:
+
+2004-09-12  Salvador E. Tropea  <set@users.sf.net>
+            Andrew Cagney  <cagney@gnu.org>
+
+        * mi/mi-main.c (mi_cmd_data_list_changed_registers)
+        (mi_cmd_data_list_register_values)
+        (mi_cmd_data_write_register_values): Include the PSEUDO_REGS in
+        the register number computation.
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_data_evaluate_expression(mi_h *h, const char *expression)
+{
+ mi_send(h,"-data-evaluate-expression \"%s\"\n",expression);
+}
+
+void mi_dir(mi_h *h, const char *path)
+{
+ if (h->version>=MI_VERSION2U(2,0,0))
+   {// MI v2
+    if (path)
+       mi_send(h,"-environment-directory \"%s\"\n",path);
+    else
+       mi_send(h,"-environment-directory -r\n");
+   }
+ else
+   {
+    mi_send(h,"-environment-directory %s\n",path ? path : "");
+   }
+}
+
+void mi_data_read_memory_hx(mi_h *h, const char *exp, unsigned ws,
+                            unsigned c, int convAddr)
+{
+ if (convAddr)
+    mi_send(h,"-data-read-memory \"&%s\" x %d 1 %d\n",exp,ws,c);
+ else
+    mi_send(h,"-data-read-memory \"%s\" x %d 1 %d\n",exp,ws,c);
+}
+
+void mi_data_disassemble_se(mi_h *h, const char *start, const char *end,
+                            int mode)
+{
+ mi_send(h,"-data-disassemble -s \"%s\" -e \"%s\" -- %d\n",start,end,mode);
+}
+
+void mi_data_disassemble_fl(mi_h *h, const char *file, int line, int lines,
+                            int mode)
+{
+ mi_send(h,"-data-disassemble -f \"%s\" -l %d -n %d -- %d\n",file,line,lines,
+         mode);
+}
+
+void mi_data_list_register_names(mi_h *h)
+{
+ mi_send(h,"-data-list-register-names\n");
+}
+
+void mi_data_list_register_names_l(mi_h *h, mi_chg_reg *l)
+{
+ mi_send(h,"-data-list-register-names ");
+ while (l)
+   {
+    mi_send(h,"%d ",l->reg);
+    l=l->next;
+   }
+ mi_send(h,"\n");
+}
+
+void mi_data_list_changed_registers(mi_h *h)
+{
+ mi_send(h,"-data-list-changed-registers\n");
+}
+
+void mi_data_list_register_values(mi_h *h, enum mi_gvar_fmt fmt, mi_chg_reg *l)
+{
+ mi_send(h,"-data-list-register-values %c ",mi_format_enum_to_char(fmt));
+ while (l)
+   {
+    mi_send(h,"%d ",l->reg);
+    l=l->next;
+   }
+ mi_send(h,"\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Evaluate an expression. Returns a parsed tree.
+
+  Command: -data-evaluate-expression
+  Return: The resulting value (as plain text) or NULL on error.
+  
+***************************************************************************/
+
+char *gmi_data_evaluate_expression(mi_h *h, const char *expression)
+{
+ mi_data_evaluate_expression(h,expression);
+ return mi_res_value(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Path for sources. You must use it to indicate where are the sources for
+the program to debug. Only the MI v1 implementation is available.
+
+  Command: -environment-directory
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_dir(mi_h *h, const char *path)
+{
+ mi_dir(h,path);
+ return mi_res_simple_done(h);
+}
+
+int gmi_read_memory(mi_h *h, const char *exp, unsigned size,
+                    unsigned char *dest, int *na, int convAddr,
+                    unsigned long *addr)
+{
+ mi_data_read_memory_hx(h,exp,1,size,convAddr);
+ return mi_get_read_memory(h,dest,1,na,addr);
+}
+
+mi_asm_insns *gmi_data_disassemble_se(mi_h *h, const char *start,
+                                      const char *end, int mode)
+{
+ mi_data_disassemble_se(h,start,end,mode);
+ return mi_get_asm_insns(h);
+}
+
+mi_asm_insns *gmi_data_disassemble_fl(mi_h *h, const char *file, int line,
+                                      int lines, int mode)
+{
+ mi_data_disassemble_fl(h,file,line,lines,mode);
+ return mi_get_asm_insns(h);
+}
+
+// Affected by gdb bug mi/1770
+mi_chg_reg *gmi_data_list_register_names(mi_h *h, int *how_many)
+{
+ mi_data_list_register_names(h);
+ return mi_get_list_registers(h,how_many);
+}
+
+int gmi_data_list_register_names_l(mi_h *h, mi_chg_reg *l)
+{
+ mi_data_list_register_names_l(h,l);
+ return mi_get_list_registers_l(h,l);
+}
+
+mi_chg_reg *gmi_data_list_changed_registers(mi_h *h)
+{
+ mi_error=MI_OK;
+ mi_data_list_changed_registers(h);
+ return mi_get_list_changed_regs(h);
+}
+
+int gmi_data_list_register_values(mi_h *h, enum mi_gvar_fmt fmt, mi_chg_reg *l)
+{
+ mi_data_list_register_values(h,fmt,l);
+ return mi_get_reg_values(h,l);
+}
+
+mi_chg_reg *gmi_data_list_all_register_values(mi_h *h, enum mi_gvar_fmt fmt, int *how_many)
+{
+ mi_data_list_register_values(h,fmt,NULL);
+ return mi_get_reg_values_l(h,how_many);
+}
+
diff --git a/pathologist/src/mi/gdbmi_error.c b/pathologist/src/mi/gdbmi_error.c
new file mode 100644
index 0000000..abb20f6
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_error.c
@@ -0,0 +1,38 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Error.
+  Comment:
+  Translates error numbers into messages.
+  
+***************************************************************************/
+
+#include "gdbmi.h"
+
+static
+const char *error_strs[]=
+{
+ "Ok",
+ "Out of memory",
+ "Pipe creation",
+ "Fork failed",
+ "GDB not running",
+ "Parser failed",
+ "Unknown asyn response",
+ "Unknown result response",
+ "Error from gdb",
+ "Time out in gdb response",
+ "GDB suddenly died",
+ "Can't execute X terminal",
+ "Failed to create temporal",
+ "Can't execute the debugger"
+};
+
+const char *mi_get_error_str()
+{
+ if (mi_error<0 || mi_error>MI_LAST_ERROR)
+    return "Unknown";
+ return error_strs[mi_error];
+}
diff --git a/pathologist/src/mi/gdbmi_get_free_pty.c b/pathologist/src/mi/gdbmi_get_free_pty.c
new file mode 100644
index 0000000..4274c78
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_get_free_pty.c
@@ -0,0 +1,132 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: pseudo terminal
+  Comments:
+  Helper to find a free pseudo terminal. Use this if you need to manage
+  input *and* output to the target process. If you just need output then
+  define a handler for target output stream records (assuming that this
+  is working for your particular version of gdb).
+  Usage:
+
+        mi_pty *pty = gmi_look_for_free_pty();
+        if (pty) gmi_target_terminal(mih, pty->slave);
+        ...
+        * reading from pty->master will get stdout from target *
+        * writing to pty->master will send to target stdin *
+        
+  Note: Contributed by Greg Watson (gwatson lanl gov)
+
+***************************************************************************/
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#include "gdbmi.h"
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable pseudo terminal. Low level, use
+  gmi_look_for_free_pty().
+  
+  Return: A file descriptor connected to the master pty and the name of the slave device, or <0 on error.
+  
+***************************************************************************/
+
+#ifdef __APPLE__
+
+#include <util.h>
+
+int mi_look_for_free_pty(int *master, char **slave)
+{
+ int fdmaster;
+ int fdslave;
+ static char name[BUFSIZ];
+
+ if (openpty(&fdmaster,&fdslave,name,NULL,NULL)<0)
+    return -1;
+
+ (void)close(fdslave); /* this will be reopened by gdb */
+ *master=fdmaster;
+ *slave =name;
+
+ return 0;
+}
+
+#elif defined(__linux__)
+
+int mi_look_for_free_pty(int *master, char **slave)
+{
+ if ((*master=open("/dev/ptmx",O_RDWR))<0)
+    return -1;
+ if (grantpt(*master)<0 || unlockpt(*master)<0)
+    return -1;
+ *slave = ptsname(*master);
+
+ return 0;
+}
+
+#else /* undefined o/s */
+
+int mi_look_for_free_pty(int *master, char **slave)
+{
+ return -1;
+}
+#endif
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable pseudo terminal to be used by the child.
+  
+  Return: A new mi_pty structure, you can use gmi_end_pty to
+release it.
+  
+***************************************************************************/
+
+mi_pty *gmi_look_for_free_pty()
+{
+ int master;
+ char *slave;
+ int pty=mi_look_for_free_pty(&master,&slave);
+ mi_pty *res;
+
+ if (pty<0)
+    return NULL;
+ res=(mi_pty *)malloc(sizeof(mi_pty));
+ if (!res)
+    return NULL;
+ res->slave=strdup(slave);
+ res->master=master;
+ return res;
+}
+
+void mi_free_pty(mi_pty *p)
+{
+ if (!p)
+    return;
+ free(p->slave);
+ free(p);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Closes the pseudo termial master and releases the allocated memory.
+  
+***************************************************************************/
+
+void gmi_end_pty(mi_pty *p)
+{
+ if (!p)
+    return;
+ close(p->master);
+ mi_free_pty(p);
+}
diff --git a/pathologist/src/mi/gdbmi_get_free_vt.c b/pathologist/src/mi/gdbmi_get_free_vt.c
new file mode 100644
index 0000000..25e5e75
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_get_free_vt.c
@@ -0,0 +1,156 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Linux VT.
+  Comments:
+  Helper to find a free VT. That's 100% Linux specific.@p
+  The code comes from "lconsole.c" from Allegro project and was originally
+created by Marek Habersack and then modified by George Foot. I addapted it
+to my needs and changed license from giftware to GPL.@p
+  
+***************************************************************************/
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#ifdef __APPLE__
+#include <util.h>
+#endif /* __APPLE__ */
+
+#include "gdbmi.h"
+
+#if !defined(__linux__)
+
+int mi_look_for_free_vt()
+{
+ return -1;
+}
+
+mi_aux_term *gmi_look_for_free_vt()
+{
+ return NULL;
+}
+
+#else
+
+#include <linux/vt.h>
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable Linux VT. Low level, use
+@x{gmi_look_for_free_vt}.
+  
+  Return: The VT number or <0 on error.
+  
+***************************************************************************/
+
+int mi_look_for_free_vt()
+{/* Code from Allegro. */
+ int tty, console_fd, fd;
+ unsigned short mask;
+ char tty_name[16];
+ struct vt_stat vts; 
+
+ /* Now we need to find a VT we can use.  It must be readable and
+  * writable by us, if we're not setuid root.  VT_OPENQRY itself
+  * isn't too useful because it'll only ever come up with one 
+  * suggestion, with no guarrantee that we actually have access 
+  * to it.
+  *
+  * At some stage I think this is a candidate for config
+  * file overriding, but for now we'll stat the first N consoles
+  * to see which ones we can write to (hopefully at least one!),
+  * so that we can use that one to do ioctls.  We used to use 
+  * /dev/console for that purpose but it looks like it's not 
+  * always writable by enough people.
+  *
+  * Having found and opened a writable device, we query the state
+  * of the first sixteen (fifteen really) consoles, and try 
+  * opening each unused one in turn.
+  */
+
+ console_fd=open("/dev/console",O_WRONLY);
+ if (console_fd<0)
+   {
+    int n;
+    /* Try some ttys instead... */
+    for (n=1; n<=24; n++)
+       {
+        snprintf(tty_name,sizeof(tty_name),"/dev/tty%d",n);
+        console_fd=open(tty_name,O_WRONLY);
+        if (console_fd>=0)
+           break;
+       }
+    if (n>24)
+       return -1;
+   }
+
+ /* Get the state of the console -- in particular, the free VT field */
+ if (ioctl(console_fd,VT_GETSTATE,&vts)) {
+         close(console_fd);
+    return -2;
+ }
+ close(console_fd);
+
+ /* We attempt to set our euid to 0; if we were run with euid 0 to
+  * start with, we'll be able to do this now.  Otherwise, we'll just
+  * ignore the error returned since it might not be a problem if the
+  * ttys we look at are owned by the user running the program. */
+ seteuid(0);
+
+ /* tty0 is not really a console, so start counting at 2. */
+ fd=-1;
+ for (tty=1, mask=2; mask; tty++, mask<<=1)
+     if (!(vts.v_state & mask))
+       {
+        snprintf(tty_name,sizeof(tty_name),"/dev/tty%d",tty);
+        fd=open(tty_name,O_RDWR);
+        if (fd!=-1)
+          {
+           close(fd);
+           break;
+          }
+       }
+
+ seteuid(getuid());
+
+ if (!mask)
+    return -3;
+
+ return tty;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable Linux VT to be used by the child.
+  
+  Return: A new mi_aux_term structure, you can use @x{gmi_end_aux_term} to
+release it.
+  
+***************************************************************************/
+
+mi_aux_term *gmi_look_for_free_vt()
+{
+ int ret;
+ int vt=mi_look_for_free_vt();
+ mi_aux_term *res;
+
+ if (vt<0)
+    return NULL;
+ res=(mi_aux_term *)malloc(sizeof(mi_aux_term));
+ if (!res)
+    return NULL;
+ res->pid=-1;
+ ret = asprintf(&res->tty,"/dev/tty%d",vt);
+ return res;
+}
+
+#endif
+
diff --git a/pathologist/src/mi/gdbmi_misc.c b/pathologist/src/mi/gdbmi_misc.c
new file mode 100644
index 0000000..51088a7
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_misc.c
@@ -0,0 +1,118 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Miscellaneous commands.
+  Comments:
+  GDB/MI commands for the "Miscellaneous Commands" section.  @<p>
+
+@<pre>
+gdb command:       Implemented?
+
+-gdb-exit          Yes
+-gdb-set           Yes
+-gdb-show          Yes
+-gdb-version       Yes
+@</pre>
+
+GDB Bug workaround for "-gdb-show architecture": gdb 6.1 and olders doesn't
+report it in "value", but they give the output of "show architecture". In
+6.4 we observed that not even a clue is reported. So now we always use
+"show architecture".
+
+***************************************************************************/
+
+#include <string.h>
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_gdb_exit(mi_h *h)
+{
+ mi_send(h,"-gdb-exit\n");
+}
+
+void mi_gdb_version(mi_h *h)
+{
+ mi_send(h,"-gdb-version\n");
+}
+
+void mi_gdb_set(mi_h *h, const char *var, const char *val)
+{
+ mi_send(h,"-gdb-set %s %s\n",var,val);
+}
+
+void mi_gdb_show(mi_h *h, const char *var)
+{
+ if (strcmp(var,"architecture")==0)
+    mi_send(h,"show %s\n",var);
+ else
+    mi_send(h,"-gdb-show %s\n",var);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Exit gdb killing the child is it is running.
+
+  Command: -gdb-exit
+
+***************************************************************************/
+
+void gmi_gdb_exit(mi_h *h)
+{
+ mi_gdb_exit(h);
+ mi_res_simple_exit(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Send the version to the console.
+
+  Command: -gdb-version
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_gdb_version(mi_h *h)
+{
+ mi_gdb_version(h);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set a gdb variable.
+
+  Command: -gdb-set
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_gdb_set(mi_h *h, const char *var, const char *val)
+{
+ mi_gdb_set(h,var,val);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Get a gdb variable.
+
+  Command: -gdb-show
+  Return: The current value of the variable or NULL on error.
+  
+***************************************************************************/
+
+char *gmi_gdb_show(mi_h *h, const char *var)
+{
+ mi_gdb_show(h,var);
+ return mi_res_value(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_parse.c b/pathologist/src/mi/gdbmi_parse.c
new file mode 100644
index 0000000..d30bd22
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_parse.c
@@ -0,0 +1,1927 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2007 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Parser.
+  Comments:
+  Parses the output of gdb. It basically converts the text from gdb into a
+tree (could be a complex one) that we can easily interpret using C code.
+  
+***************************************************************************/
+
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include "gdbmi.h"
+
+mi_results *mi_get_result(const char *str, const char **end);
+int mi_get_value(mi_results *r, const char *str, const char **end);
+
+
+/* GDB BUG!!!! I got:
+^error,msg="Problem parsing arguments: data-evaluate-expression ""1+2"""
+Afects gdb 2002-04-01-cvs and 6.1.1 for sure.
+That's an heuristical workaround.
+*/
+static inline
+int EndOfStr(const char *s)
+{
+ if (*s=='"')
+   {
+    s++;
+    return !*s || *s==',' || *s==']' || *s=='}';
+   }
+ return 0;
+}
+
+int mi_get_cstring_r(mi_results *r, const char *str, const char **end)
+{
+ const char *s;
+ char *d;
+ int len;
+
+ if (*str!='"')
+   {
+    mi_error=MI_PARSER;
+    return 0;
+   }
+ str++;
+ /* Meassure. */
+ for (s=str, len=0; *s && !EndOfStr(s); s++)
+    {
+         if (!*s) {
+                 mi_error = MI_PARSER;
+                 return 0;
+         }
+     if (*s=='\\')
+         s++;
+     len++;
+    }
+ /* Copy. */
+ r->type=t_const;
+ d=r->v.cstr=mi_malloc(len+1);
+ if (!r->v.cstr)
+    return 0;
+ for (s=str; *s && !EndOfStr(s); s++, d++)
+    {
+     if (*s=='\\')
+       {
+        s++;
+        switch (*s)
+          {
+           case 'n':
+                *d='\n';
+                break;
+           case 't':
+                *d='\t';
+                break;
+           default:
+                *d=*s;
+          }
+       }
+     else
+        *d=*s;
+    }
+ *d=0;
+ if (end)
+    *end=s+1;
+
+ return 1;
+}
+
+/* TODO: What's a valid variable name?
+   I'll assume a-zA-Z0-9_- */
+//inline
+int mi_is_var_name_char(char c)
+{
+ return isalnum(c) || c=='-' || c=='_';
+}
+
+char *mi_get_var_name(const char *str, const char **end)
+{
+ const char *s;
+ char *r;
+ int l;
+ /* Meassure. */
+ for (s=str; *s && mi_is_var_name_char(*s); s++);
+ if (*s!='=')
+   {
+    mi_error=MI_PARSER;
+    return NULL;
+   }
+ /* Allocate. */
+ l=s-str;
+ r=mi_malloc(l+1);
+ /* Copy. */
+ if (NULL != r) {
+         memcpy(r,str,l);
+         r[l]=0;
+ }
+ if (end)
+    *end=s+1;
+ return r;
+}
+
+
+int mi_get_list_res(mi_results *r, const char *str, const char **end, char closeC)
+{
+ mi_results *last_r, *rs;
+
+ last_r=NULL;
+ do
+   {
+    rs=mi_get_result(str,&str);
+    if (last_r)
+       last_r->next=rs;
+    else
+       r->v.rs=rs;
+    last_r=rs;
+    if (*str==closeC)
+      {
+       *end=str+1;
+       return 1;
+      }
+    if (*str!=',')
+       break;
+    str++;
+   }
+ while (1);
+
+ mi_error=MI_PARSER;
+ return 0;
+}
+
+#ifdef __APPLE__
+int mi_get_tuple_val(mi_results *r, const char *str, const char **end)
+{
+ mi_results *last_r, *rs;
+
+ last_r=NULL;
+ do
+   {
+    rs=mi_alloc_results();
+    if (!rs || !mi_get_value(rs,str,&str))
+      {
+       mi_free_results(rs);
+       return 0;
+      }
+    /* Note that rs->var is NULL, that indicates that's just a value and not
+       a result. */
+    if (last_r)
+       last_r->next=rs;
+    else
+       r->v.rs=rs;
+    last_r=rs;
+    if (*str=='}')
+      {
+       *end=str+1;
+       return 1;
+      }
+    if (*str!=',')
+       break;
+    str++;
+   }
+ while (1);
+
+ mi_error=MI_PARSER;
+ return 0;
+}
+#endif /* __APPLE__ */
+
+int mi_get_tuple(mi_results *r, const char *str, const char **end)
+{
+ if (*str!='{')
+   {
+    mi_error=MI_PARSER;
+    return 0;
+   }
+ r->type=t_tuple;
+ str++;
+ if (*str=='}')
+   {/* Special case: empty tuple */
+    *end=str+1;
+    return 1;
+   }
+ #ifdef __APPLE__
+ if (mi_is_var_name_char(*str))
+    return mi_get_list_res(r,str,end,'}');
+ return mi_get_tuple_val(r,str,end);
+ #else /* __APPLE__ */
+ return mi_get_list_res(r,str,end,'}');
+ #endif /* __APPLE__ */
+}
+
+int mi_get_list_val(mi_results *r, const char *str, const char **end)
+{
+ mi_results *last_r, *rs;
+
+ last_r=NULL;
+ do
+   {
+    rs=mi_alloc_results();
+    if (!rs || !mi_get_value(rs,str,&str))
+      {
+       mi_free_results(rs);
+       return 0;
+      }
+    /* Note that rs->var is NULL, that indicates that's just a value and not
+       a result. */
+    if (last_r)
+       last_r->next=rs;
+    else
+       r->v.rs=rs;
+    last_r=rs;
+    if (*str==']')
+      {
+       *end=str+1;
+       return 1;
+      }
+    if (*str!=',')
+       break;
+    str++;
+   }
+ while (1);
+
+ mi_error=MI_PARSER;
+ return 0;
+}
+
+int mi_get_list(mi_results *r, const char *str, const char **end)
+{
+ if (*str!='[')
+   {
+    mi_error=MI_PARSER;
+    return 0;
+   }
+ r->type=t_list;
+ str++;
+ if (*str==']')
+   {/* Special case: empty list */
+    *end=str+1;
+    return 1;
+   }
+ /* Comment: I think they could choose () for values. Is confusing in this way. */
+ if (mi_is_var_name_char(*str))
+    return mi_get_list_res(r,str,end,']');
+ return mi_get_list_val(r,str,end);
+}
+
+int mi_get_value(mi_results *r, const char *str, const char **end)
+{
+ switch (str[0])
+   {
+    case '"':
+         return mi_get_cstring_r(r,str,end);
+    case '{':
+         return mi_get_tuple(r,str,end);
+    case '[':
+         return mi_get_list(r,str,end);
+   }
+ mi_error=MI_PARSER;
+ return 0;
+}
+
+mi_results *mi_get_result(const char *str, const char **end)
+{
+ char *var;
+ mi_results *r;
+
+ var=mi_get_var_name(str,&str);
+ if (!var)
+    return NULL;
+
+ r=mi_alloc_results();
+ if (!r)
+   {
+    free(var);
+    return NULL;
+   }
+ r->var=var;
+
+ if (!mi_get_value(r,str,end))
+   {
+    mi_free_results(r);
+    return NULL;
+   }
+
+ return r;
+}
+
+mi_output *mi_get_results_alone(mi_output *r,const char *str)
+{
+ mi_results *last_r, *rs;
+
+ /* * results */
+ last_r=NULL;
+ do
+   {
+    if (!*str)
+       return r;
+    if (*str!=',')
+      {
+       mi_error=MI_PARSER;
+       break;
+      }
+    str++;
+    rs=mi_get_result(str,&str);
+    if (!rs)
+       break;
+    if (!last_r)
+       r->c=rs;
+    else
+       last_r->next=rs;
+    last_r=rs;
+   }
+ while (1);
+ mi_free_output(r);
+ return NULL;
+}
+
+mi_output *mi_parse_result_record(mi_output *r,const char *str)
+{
+ r->type=MI_T_RESULT_RECORD;
+
+ /* Solve the result-class. */
+ if (strncmp(str,"done",4)==0)
+   {
+    str+=4;
+    r->tclass=MI_CL_DONE;
+   }
+ else if (strncmp(str,"running",7)==0)
+   {
+    str+=7;
+    r->tclass=MI_CL_RUNNING;
+   }
+ else if (strncmp(str,"connected",9)==0)
+   {
+    str+=9;
+    r->tclass=MI_CL_CONNECTED;
+   }
+ else if (strncmp(str,"error",5)==0)
+   {
+    str+=5;
+    r->tclass=MI_CL_ERROR;
+   }
+ else if (strncmp(str,"exit",4)==0)
+   {
+    str+=4;
+    r->tclass=MI_CL_EXIT;
+   }
+ else
+   {
+    mi_error=MI_UNKNOWN_RESULT;
+    return NULL;
+   }
+
+ return mi_get_results_alone(r,str);
+}
+
+mi_output *mi_parse_asyn(mi_output *r,const char *str)
+{
+ r->type=MI_T_OUT_OF_BAND;
+ r->stype=MI_ST_ASYNC;
+ /* async-class. */
+ if (strncmp(str,"stopped",7)==0)
+   {
+    r->tclass=MI_CL_STOPPED;
+    str+=7;
+    return mi_get_results_alone(r,str);
+   }
+ if (strncmp(str,"download",8)==0)
+   {
+    r->tclass=MI_CL_DOWNLOAD;
+    str+=8;
+    return mi_get_results_alone(r,str);
+   }
+ mi_error=MI_UNKNOWN_ASYNC;
+ mi_free_output(r);
+ return NULL;
+}
+
+mi_output *mi_parse_exec_asyn(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_EXEC;
+ return mi_parse_asyn(r,str);
+}
+
+mi_output *mi_parse_status_asyn(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_STATUS;
+ return mi_parse_asyn(r,str);
+}
+
+mi_output *mi_parse_notify_asyn(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_NOTIFY;
+ return mi_parse_asyn(r,str);
+}
+
+mi_output *mi_console(mi_output *r,const char *str)
+{
+ r->type=MI_T_OUT_OF_BAND;
+ r->stype=MI_ST_STREAM;
+ r->c=mi_alloc_results();
+ if (!r->c || !mi_get_cstring_r(r->c,str,NULL))
+   {
+    mi_free_output(r);
+    return NULL;
+   }
+ return r;
+}
+
+mi_output *mi_console_stream(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_CONSOLE;
+ return mi_console(r,str);
+}
+
+mi_output *mi_target_stream(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_TARGET;
+ return mi_console(r,str);
+}
+
+mi_output *mi_log_stream(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_LOG;
+ return mi_console(r,str);
+}
+
+mi_output *mi_parse_gdb_output(const char *str)
+{
+ char type=str[0];
+
+ mi_output *r=mi_alloc_output();
+ if (!r)
+   {
+    mi_error=MI_OUT_OF_MEMORY;
+    return NULL;
+   }
+ str++;
+ switch (type)
+   {
+    case '^':
+         return mi_parse_result_record(r,str);
+    case '*':
+         return mi_parse_exec_asyn(r,str);
+    case '+':
+         return mi_parse_status_asyn(r,str);
+    case '=':
+         return mi_parse_notify_asyn(r,str);
+    case '~':
+         return mi_console_stream(r,str);
+    case '@':
+         return mi_target_stream(r,str);
+    case '&':
+         return mi_log_stream(r,str);
+   }   
+ mi_error=MI_PARSER;
+ return NULL;
+}
+
+mi_output *mi_get_rrecord(mi_output *r)
+{
+ if (!r)
+    return NULL;
+ while (r)
+   {
+    if (r->type==MI_T_RESULT_RECORD)
+       return r;
+    r=r->next;
+   }
+ return r;
+}
+
+mi_results *mi_get_var_r(mi_results *r, const char *var)
+{
+ while (r)
+   {
+    if (strcmp(r->var,var)==0)
+       return r;
+    r=r->next;
+   }
+ return NULL;
+}
+
+mi_results *mi_get_var(mi_output *res, const char *var)
+{
+ if (!res)
+    return NULL;
+ return mi_get_var_r(res->c,var);
+}
+
+int mi_get_async_stop_reason(mi_output *r, char **reason)
+{
+ int found_stopped=0;
+
+ *reason=NULL;
+ while (r)
+   {
+    if (r->type==MI_T_RESULT_RECORD && r->tclass==MI_CL_ERROR)
+      {
+       if (r->c->type==t_const)
+          *reason=r->c->v.cstr;
+       return 0;
+      }
+    if (r->type==MI_T_OUT_OF_BAND && r->stype==MI_ST_ASYNC &&
+        r->sstype==MI_SST_EXEC && r->tclass==MI_CL_STOPPED)
+      {
+       mi_results *p=r->c;
+       found_stopped=1;
+       while (p)
+         {
+          if (strcmp(p->var,"reason")==0)
+            {
+             *reason=p->v.cstr;
+             return 1;
+            }
+          p=p->next;
+         }
+      }
+    r=r->next;
+   }
+ if (*reason==NULL && found_stopped)
+   {
+    *reason=strdup("unknown (temp bkpt?)");
+    return 1;
+   }
+ return 0;
+}
+
+mi_frames *mi_get_async_frame(mi_output *r)
+{
+ while (r)
+   {
+    if (r->type==MI_T_OUT_OF_BAND && r->stype==MI_ST_ASYNC &&
+        r->sstype==MI_SST_EXEC && r->tclass==MI_CL_STOPPED)
+      {
+       mi_results *p=r->c;
+       while (p)
+         {
+          if (strcmp(p->var,"frame")==0)
+             return mi_parse_frame(p->v.rs);
+          p=p->next;
+         }
+      }
+    r=r->next;
+   }
+ return NULL;
+}
+
+int mi_res_simple(mi_h *h, int tclass, int accert_ret)
+{
+ mi_output *r, *res;
+ int ret=0;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+
+ if (res)
+    ret=res->tclass==tclass;
+ mi_free_output(r);
+
+ return ret;
+}
+
+
+int mi_res_simple_done(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_DONE,0);
+}
+
+int mi_res_simple_exit(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_EXIT,1);
+}
+
+int mi_res_simple_running(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_RUNNING,0);
+}
+
+int mi_res_simple_connected(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_CONNECTED,0);
+}
+
+mi_results *mi_res_var(mi_h *h, const char *var, int tclass)
+{
+ mi_output *r, *res;
+ mi_results *the_var=NULL;
+
+ r=mi_get_response_blk(h);
+ /* All the code that follows is "NULL" tolerant. */
+ /* Look for the result-record. */
+ res=mi_get_rrecord(r);
+ /* Look for the desired var. */
+ if (res && res->tclass==tclass)
+    the_var=mi_get_var(res,var);
+ /* Release all but the one we want. */
+ mi_free_output_but(r,NULL,the_var);
+ return the_var;
+}
+
+mi_results *mi_res_done_var(mi_h *h, const char *var)
+{
+ return mi_res_var(h,var,MI_CL_DONE);
+}
+
+mi_frames *mi_parse_frame(mi_results *c)
+{
+ mi_frames *res=mi_alloc_frames();
+ char *end;
+
+ if (res)
+   {
+    while (c)
+      {
+       if (c->type==t_const)
+         {
+          if (strcmp(c->var,"level")==0)
+             res->level=atoi(c->v.cstr);
+          else if (strcmp(c->var,"addr")==0)
+             res->addr=(void *)strtoul(c->v.cstr,&end,0);
+          else if (strcmp(c->var,"func")==0)
+            {
+             res->func=c->v.cstr;
+             c->v.cstr=NULL;
+            }
+          else if (strcmp(c->var,"file")==0)
+            {
+             res->file=c->v.cstr;
+             c->v.cstr=NULL;
+            }
+          else if (strcmp(c->var,"from")==0)
+            {
+             res->from=c->v.cstr;
+             c->v.cstr=NULL;
+            }
+          else if (strcmp(c->var,"line")==0)
+             res->line=atoi(c->v.cstr);
+         }
+       else if (c->type==t_list && strcmp(c->var,"args")==0)
+         {
+          res->args=c->v.rs;
+          c->v.rs=NULL;
+         }
+       c=c->next;
+      }
+   }
+ return res;
+}
+
+mi_frames *mi_res_frame(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"frame");
+ mi_frames *f=NULL;
+
+ if (r && r->type==t_tuple)
+    f=mi_parse_frame(r->v.rs);
+ mi_free_results(r);
+ return f;
+}
+
+mi_frames *mi_res_frames_array(mi_h *h, const char *var)
+{
+ mi_results *r=mi_res_done_var(h,var), *c;
+ mi_frames *res=NULL, *nframe, *last=NULL;
+
+ if (!r)
+    return NULL;
+#ifdef __APPLE__
+ if (r->type!=t_list && r->type!=t_tuple)
+#else
+ if (r->type!=t_list)
+#endif
+   {
+    mi_free_results(r);
+    return NULL;
+   }
+ c=r->v.rs;
+ while (c)
+   {
+    if (strcmp(c->var,"frame")==0 && c->type==t_tuple)
+      {
+       nframe=mi_parse_frame(c->v.rs);
+       if (nframe)
+         {
+          if (!last)
+             res=nframe;
+          else
+             last->next=nframe;
+          last=nframe;
+         }
+      }
+    c=c->next;
+   }
+ mi_free_results(r);
+ return res;
+}
+
+mi_frames *mi_res_frames_list(mi_h *h)
+{
+ mi_output *r, *res;
+ mi_frames *ret=NULL, *nframe, *last=NULL;
+ mi_results *c;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+   {
+    c=res->c;
+    while (c)
+      {
+       if (strcmp(c->var,"frame")==0 && c->type==t_tuple)
+         {
+          nframe=mi_parse_frame(c->v.rs);
+          if (nframe)
+            {
+             if (!last)
+                ret=nframe;
+             else
+                last->next=nframe;
+             last=nframe;
+            }
+         }
+       c=c->next;
+      }
+   }
+ mi_free_output(r);
+ return ret;
+}
+
+int mi_get_thread_ids(mi_output *res, int **list)
+{
+ mi_results *vids, *lids;
+ int ids=-1, i;
+
+ *list=NULL;
+ vids=mi_get_var(res,"number-of-threads");
+ lids=mi_get_var(res,"thread-ids");
+ if (vids && vids->type==t_const &&
+     lids && lids->type==t_tuple)
+   {
+    ids=atoi(vids->v.cstr);
+    if (ids)
+      {
+       int *lst;
+       lst=(int *)mi_calloc(ids,sizeof(int));
+       if (lst)
+         {
+          lids=lids->v.rs;
+          i=0;
+          while (lids)
+            {
+             if (strcmp(lids->var,"thread-id")==0 && lids->type==t_const)
+                lst[i++]=atoi(lids->v.cstr);
+             lids=lids->next;
+            }
+          *list=lst;
+         }
+       else
+          ids=-1;
+      }
+   }
+ return ids;
+}
+
+int mi_res_thread_ids(mi_h *h, int **list)
+{
+ mi_output *r, *res;
+ int ids=-1;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+    ids=mi_get_thread_ids(res,list);
+ mi_free_output(r);
+ return ids;
+}
+
+enum mi_gvar_lang mi_lang_str_to_enum(const char *lang)
+{
+ enum mi_gvar_lang lg=lg_unknown;
+
+ if (strcmp(lang,"C")==0)
+    lg=lg_c;
+ else if (strcmp(lang,"C++")==0)
+    lg=lg_cpp;
+ else if (strcmp(lang,"Java")==0)
+    lg=lg_java;
+
+ return lg;
+}
+
+const char *mi_lang_enum_to_str(enum mi_gvar_lang lang)
+{
+ const char *lg;
+
+ switch (lang)
+   {
+    case lg_c:
+         lg="C";
+         break;
+    case lg_cpp:
+         lg="C++";
+         break;
+    case lg_java:
+         lg="Java";
+         break;
+    /*case lg_unknown:*/
+    default:
+         lg="unknown";
+         break;
+   }
+ return lg;
+}
+
+enum mi_gvar_fmt mi_format_str_to_enum(const char *format)
+{
+ enum mi_gvar_fmt fmt=fm_natural;
+
+ if (strcmp(format,"binary")==0)
+    fmt=fm_binary;
+ else if (strcmp(format,"decimal")==0)
+    fmt=fm_decimal;
+ else if (strcmp(format,"hexadecimal")==0)
+    fmt=fm_hexadecimal;
+ else if (strcmp(format,"octal")==0)
+    fmt=fm_octal;
+
+ return fmt;
+}
+
+const char *mi_format_enum_to_str(enum mi_gvar_fmt format)
+{
+ const char *fmt;
+
+ switch (format)
+   {
+    case fm_natural:
+         fmt="natural";
+         break;
+    case fm_binary:
+         fmt="binary";
+         break;
+    case fm_decimal:
+         fmt="decimal";
+         break;
+    case fm_hexadecimal:
+         fmt="hexadecimal";
+         break;
+    case fm_octal:
+         fmt="octal";
+         break;
+    case fm_raw:
+         fmt="raw";
+         break;
+    default:
+         fmt="unknown";
+   }
+ return fmt;
+}
+
+char mi_format_enum_to_char(enum mi_gvar_fmt format)
+{
+ char fmt;
+
+ switch (format)
+   {
+    case fm_natural:
+         fmt='N';
+         break;
+    case fm_binary:
+         fmt='t';
+         break;
+    case fm_decimal:
+         fmt='d';
+         break;
+    case fm_hexadecimal:
+         fmt='x';
+         break;
+    case fm_octal:
+         fmt='o';
+         break;
+    case fm_raw:
+         fmt='r';
+         break;
+    default:
+         fmt=' ';
+   }
+ return fmt;
+}
+
+mi_gvar *mi_get_gvar(mi_output *o, mi_gvar *cur, const char *expression)
+{
+ mi_results *r;
+ mi_gvar *res=cur ? cur : mi_alloc_gvar();
+ int l;
+
+ if (!res)
+    return res;
+ r=o->c;
+ if (expression)
+    res->exp=strdup(expression);
+ while (r)
+   {
+    if (r->type==t_const)
+      {
+       if (strcmp(r->var,"name")==0)
+         {
+          free(res->name);
+          res->name=r->v.cstr;
+          r->v.cstr=NULL;
+         }
+       else if (strcmp(r->var,"numchild")==0)
+         {
+          res->numchild=atoi(r->v.cstr);
+         }
+       else if (strcmp(r->var,"type")==0)
+         {
+          free(res->type);
+          res->type=r->v.cstr;
+          r->v.cstr=NULL;
+          l=strlen(res->type);
+          if (l && res->type[l-1]=='*')
+             res->ispointer=1;
+         }
+       else if (strcmp(r->var,"lang")==0)
+         {
+          res->lang=mi_lang_str_to_enum(r->v.cstr);
+         }
+       else if (strcmp(r->var,"exp")==0)
+         {
+          free(res->exp);
+          res->exp=r->v.cstr;
+          r->v.cstr=NULL;
+         }
+       else if (strcmp(r->var,"format")==0)
+         {
+          res->format=mi_format_str_to_enum(r->v.cstr);
+         }
+       else if (strcmp(r->var,"attr")==0)
+         { /* Note: gdb 6.1.1 have only this: */
+          if (strcmp(r->v.cstr,"editable")==0)
+             res->attr=MI_ATTR_EDITABLE;
+          else /* noneditable */
+             res->attr=MI_ATTR_NONEDITABLE;
+         }
+      }
+    r=r->next;
+   }
+ return res;
+}
+
+mi_gvar *mi_res_gvar(mi_h *h, mi_gvar *cur, const char *expression)
+{
+ mi_output *r, *res;
+ mi_gvar *gvar=NULL;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+    gvar=mi_get_gvar(res,cur,expression);
+ mi_free_output(r);
+ return gvar;
+}
+
+mi_gvar_chg *mi_get_gvar_chg(mi_results *r)
+{
+ mi_gvar_chg *n;
+
+ if (r->type!=t_const)
+    return NULL;
+ n=mi_alloc_gvar_chg();
+ if (n)
+   {
+    while (r)
+      {
+       if (r->type==t_const)
+         {
+          if (strcmp(r->var,"name")==0)
+            {
+             n->name=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"in_scope")==0)
+            {
+             n->in_scope=strcmp(r->v.cstr,"true")==0;
+            }
+          else if (strcmp(r->var,"new_type")==0)
+            {
+             n->new_type=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"new_num_children")==0)
+            {
+             n->new_num_children=atoi(r->v.cstr);
+            }
+          // type_changed="false" is the default
+         }
+       r=r->next;
+      }
+   }
+ return n;
+}
+
+int mi_res_changelist(mi_h *h, mi_gvar_chg **changed)
+{
+ mi_gvar_chg *last, *n;
+ mi_results *res=mi_res_done_var(h,"changelist"), *r;
+ int count=0;
+
+ *changed=NULL;
+ if (!res)
+    return 0;
+ last=NULL;
+ count=1;
+ n=NULL;
+ r=res->v.rs;
+
+ if (res->type==t_list)
+   {// MI v2 a list of tuples
+    while (r)
+      {
+       if (r->type==t_tuple)
+         {
+          n=mi_get_gvar_chg(r->v.rs);
+          if (n)
+            {
+             if (last)
+                last->next=n;
+             else
+                *changed=n;
+             last=n;
+             count++;
+            }
+         }
+       r=r->next;
+      }
+   }
+ else if (res->type==t_tuple)
+   {// MI v1 a tuple with all together *8-P
+    while (r)
+      {
+       if (r->type==t_const) /* Just in case. */
+         {/* Get one var. */
+          if (strcmp(r->var,"name")==0)
+            {
+             if (n)
+               {/* Add to the list*/
+                if (last)
+                   last->next=n;
+                else
+                   *changed=n;
+                last=n;
+                count++;
+               }
+             n=mi_alloc_gvar_chg();
+             if (!n)
+               {
+                mi_free_gvar_chg(*changed);
+                return 0;
+               }
+             n->name=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if ((NULL != n) && (strcmp(r->var,"in_scope")==0))
+            {
+             n->in_scope=strcmp(r->v.cstr,"true")==0;
+            }
+          else if ((NULL != n) && (strcmp(r->var,"new_type")==0))
+            {
+             n->new_type=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if ((NULL != n) && (strcmp(r->var,"new_num_children")==0))
+            {
+             n->new_num_children=atoi(r->v.cstr);
+            }
+          // type_changed="false" is the default
+         }
+       r=r->next;
+      }
+    if (n)
+      {/* Add to the list*/
+       if (last)
+          last->next=n;
+       else
+          *changed=n;
+       last=n;
+       count++;
+      }
+   }
+ mi_free_results(res);
+
+ return count;
+}
+
+int mi_get_children(mi_results *ch, mi_gvar *v)
+{
+ mi_gvar *cur=NULL, *aux;
+ int i=0, count=v->numchild, l;
+
+ while (ch)
+   {
+    if (strcmp(ch->var,"child")==0 && ch->type==t_tuple && i<count)
+      {
+       mi_results *r=ch->v.rs;
+       aux=mi_alloc_gvar();
+       if (!aux)
+          return 0;
+       if (!v->child)
+          v->child=aux;
+       else if (NULL != cur)
+          cur->next=aux;
+       cur=aux;
+       cur->parent=v;
+       cur->depth=v->depth+1;
+
+       while (r)
+         {
+          if (r->type==t_const)
+            {
+             if (strcmp(r->var,"name")==0)
+               {
+                cur->name=r->v.cstr;
+                r->v.cstr=NULL;
+               }
+             else if (strcmp(r->var,"exp")==0)
+               {
+                cur->exp=r->v.cstr;
+                r->v.cstr=NULL;
+               }
+             else if (strcmp(r->var,"type")==0)
+               {
+                cur->type=r->v.cstr;
+                r->v.cstr=NULL;
+                l=strlen(cur->type);
+                if (l && cur->type[l-1]=='*')
+                   cur->ispointer=1;
+               }
+             else if (strcmp(r->var,"value")==0)
+               {
+                cur->value=r->v.cstr;
+                r->v.cstr=NULL;
+               }                     
+             else if (strcmp(r->var,"numchild")==0)
+               {
+                cur->numchild=atoi(r->v.cstr);
+               }
+            }
+          r=r->next;
+         }
+       i++;
+      }
+    ch=ch->next;
+   }
+ v->vischild=i;
+ v->opened=1;
+ return i==v->numchild;
+}
+
+int mi_res_children(mi_h *h, mi_gvar *v)
+{
+ mi_output *r, *res;
+ int ok=0;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+   {
+    mi_results *num=mi_get_var(res,"numchild");
+    if (num && num->type==t_const)
+      {
+       v->numchild=atoi(num->v.cstr);
+       if (v->child)
+         {
+          mi_free_gvar(v->child);
+          v->child=NULL;
+         }
+       if (v->numchild)
+         {
+          mi_results *ch =mi_get_var(res,"children");
+          if (ch && ch->type!=t_const) /* MI v1 tuple, MI v2 list */
+             ok=mi_get_children(ch->v.rs,v);
+         }
+       else
+          ok=1;
+      }
+   }
+ mi_free_output(r);
+ return ok;
+}
+
+mi_bkpt *mi_get_bkpt(mi_results *p)
+{
+ mi_bkpt *res;
+ char *end;
+
+ res=mi_alloc_bkpt();
+ if (!res)
+    return NULL;
+ while (p)
+   {
+    if (p->type==t_const && p->var)
+      {
+       if (strcmp(p->var,"number")==0)
+          res->number=atoi(p->v.cstr);
+       else if (strcmp(p->var,"type")==0)
+         {
+          if (strcmp(p->v.cstr,"breakpoint")==0)
+             res->type=t_breakpoint;
+          else
+             res->type=t_unknown;
+         }
+       else if (strcmp(p->var,"disp")==0)
+         {
+          if (strcmp(p->v.cstr,"keep")==0)
+             res->disp=d_keep;
+          else if (strcmp(p->v.cstr,"del")==0)
+             res->disp=d_del;
+          else
+             res->disp=d_unknown;
+         }
+       else if (strcmp(p->var,"enabled")==0)
+          res->enabled=p->v.cstr[0]=='y';
+       else if (strcmp(p->var,"addr")==0)
+          res->addr=(void *)strtoul(p->v.cstr,&end,0);
+       else if (strcmp(p->var,"func")==0)
+         {
+          res->func=p->v.cstr;
+          p->v.cstr=NULL;
+         }
+       else if (strcmp(p->var,"file")==0)
+         {
+          res->file=p->v.cstr;
+          p->v.cstr=NULL;
+         }
+       else if (strcmp(p->var,"line")==0)
+          res->line=atoi(p->v.cstr);
+       else if (strcmp(p->var,"times")==0)
+          res->times=atoi(p->v.cstr);
+       else if (strcmp(p->var,"ignore")==0)
+          res->ignore=atoi(p->v.cstr);
+       else if (strcmp(p->var,"cond")==0)
+         {
+          res->cond=p->v.cstr;
+          p->v.cstr=NULL;
+         }
+      }
+    p=p->next;
+   }
+ return res;
+}
+
+mi_bkpt *mi_res_bkpt(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"bkpt");
+ mi_bkpt *b=NULL;
+
+ if (r && r->type==t_tuple)
+    b=mi_get_bkpt(r->v.rs);
+ mi_free_results(r);
+ return b;
+}
+
+mi_wp *mi_get_wp(mi_results *p, enum mi_wp_mode m)
+{
+ mi_wp *res=mi_alloc_wp();
+
+ if (res)
+   {
+    res->mode=m;
+    while (p)
+      {
+       if (p->type==t_const && p->var)
+         {
+          if (strcmp(p->var,"number")==0)
+            {
+             res->number=atoi(p->v.cstr);
+             res->enabled=1;
+            }
+          else if (strcmp(p->var,"exp")==0)
+            {
+             res->exp=p->v.cstr;
+             p->v.cstr=NULL;
+            }
+         }
+       p=p->next;
+      }
+   }
+ return res;
+}
+
+mi_wp *mi_parse_wp_res(mi_output *r)
+{
+ mi_results *p;
+ enum mi_wp_mode m=wm_unknown;
+
+ /* The info is in a result wpt=... */
+ p=r->c;
+ while (p)
+   {
+    if (p->var)
+      {
+       if (strcmp(p->var,"wpt")==0)
+          m=wm_write;
+       else if (strcmp(p->var,"hw-rwpt")==0)
+          m=wm_read;
+       else if (strcmp(p->var,"hw-awpt")==0)
+          m=wm_rw;
+       if (m!=wm_unknown)
+          break;
+      }
+    p=p->next;
+   }
+ if (!p || p->type!=t_tuple)
+    return NULL;
+ /* Scan the values inside it. */
+ return mi_get_wp(p->v.rs,m);
+}
+
+mi_wp *mi_res_wp(mi_h *h)
+{
+ mi_output *r, *res;
+ mi_wp *ret=NULL;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+
+ if (res)
+    ret=mi_parse_wp_res(res);
+
+ mi_free_output(r);
+ return ret;
+}
+
+char *mi_res_value(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"value");
+ char *s=NULL;
+
+ if (r && r->type==t_const)
+   {
+    s=r->v.cstr;
+    r->v.rs=NULL;
+   }
+ mi_free_results(r);
+ return s;
+}
+
+mi_output *mi_get_stop_record(mi_output *r)
+{
+ while (r)
+   {
+    if (r->type==MI_T_OUT_OF_BAND && r->stype==MI_ST_ASYNC &&
+        r->sstype==MI_SST_EXEC && r->tclass==MI_CL_STOPPED)
+       return r;
+    r=r->next;
+   }
+ return r;
+}
+
+static
+char *reason_names[]=
+{
+ "breakpoint-hit",
+ "watchpoint-trigger",
+ "read-watchpoint-trigger",
+ "access-watchpoint-trigger",
+ "watchpoint-scope",
+ "function-finished",
+ "location-reached",
+ "end-stepping-range",
+ "exited-signalled",
+ "exited",
+ "exited-normally",
+ "signal-received"
+};
+
+static
+enum mi_stop_reason reason_values[]=
+{
+ sr_bkpt_hit,
+ sr_wp_trigger, sr_read_wp_trigger, sr_access_wp_trigger, sr_wp_scope,
+ sr_function_finished, sr_location_reached, sr_end_stepping_range,
+ sr_exited_signalled, sr_exited, sr_exited_normally,
+ sr_signal_received
+};
+
+static
+char *reason_expl[]=
+{
+ "Hit a breakpoint",
+ "Write watchpoint",
+ "Read watchpoint",
+ "Access watchpoint",
+ "Watchpoint out of scope",
+ "Function finished",
+ "Location reached",
+ "End of stepping",
+ "Exited signalled",
+ "Exited with error",
+ "Exited normally",
+ "Signal received"
+};
+
+enum mi_stop_reason mi_reason_str_to_enum(const char *s)
+{
+ int i;
+
+ for (i=0; i<sizeof(reason_names)/sizeof(char *); i++)
+     if (strcmp(reason_names[i],s)==0)
+        return reason_values[i];
+ return sr_unknown;
+}
+
+const char *mi_reason_enum_to_str(enum mi_stop_reason r)
+{
+ int i;
+
+ if (r==sr_unknown)
+    return "Unknown (temp bkp?)";
+ for (i=0; i<sizeof(reason_values)/sizeof(char *); i++)
+     if (reason_values[i]==r)
+        return reason_expl[i];
+ return NULL;
+}
+
+mi_stop *mi_get_stopped(mi_results *r)
+{
+ mi_stop *res=mi_alloc_stop();
+
+ if (res)
+   {
+    while (r)
+      {
+       if (r->type==t_const)
+         {
+          if (strcmp(r->var,"reason")==0)
+             res->reason=mi_reason_str_to_enum(r->v.cstr);
+          else if (!res->have_thread_id && strcmp(r->var,"thread-id")==0)
+            {
+             res->have_thread_id=1;
+             res->thread_id=atoi(r->v.cstr);
+            }
+          else if (!res->have_bkptno && strcmp(r->var,"bkptno")==0)
+            {
+             res->have_bkptno=1;
+             res->bkptno=atoi(r->v.cstr);
+            }
+          else if (!res->have_bkptno && strcmp(r->var,"wpnum")==0)
+            {
+             res->have_wpno=1;
+             res->wpno=atoi(r->v.cstr);
+            }
+          else if (strcmp(r->var,"gdb-result-var")==0)
+            {
+             res->gdb_result_var=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"return-value")==0)
+            {
+             res->return_value=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"signal-name")==0)
+            {
+             res->signal_name=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"signal-meaning")==0)
+            {
+             res->signal_meaning=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (!res->have_exit_code && strcmp(r->var,"exit-code")==0)
+            {
+             res->have_exit_code=1;
+             res->exit_code=atoi(r->v.cstr);
+            }
+         }
+       else // tuple or list
+         {
+          if (strcmp(r->var,"frame")==0)
+             res->frame=mi_parse_frame(r->v.rs);
+          else if (!res->wp && strcmp(r->var,"wpt")==0)
+             res->wp=mi_get_wp(r->v.rs,wm_write);
+          else if (!res->wp && strcmp(r->var,"hw-rwpt")==0)
+             res->wp=mi_get_wp(r->v.rs,wm_read);
+          else if (!res->wp && strcmp(r->var,"hw-awpt")==0)
+             res->wp=mi_get_wp(r->v.rs,wm_rw);
+          else if (!(res->wp_old || res->wp_val) && strcmp(r->var,"value")==0)
+             {
+              mi_results *p=r->v.rs;
+              while (p)
+                {
+                 if (strcmp(p->var,"value")==0 || strcmp(p->var,"new")==0)
+                   {
+                    res->wp_val=p->v.cstr;
+                    p->v.cstr=NULL;
+                   }
+                 else if (strcmp(p->var,"old")==0)
+                   {
+                    res->wp_old=p->v.cstr;
+                    p->v.cstr=NULL;
+                   }
+                 p=p->next;
+                }
+             }
+         }
+       r=r->next;
+      }
+   }
+ return res;
+}
+
+mi_stop *mi_res_stop(mi_h *h)
+{
+ mi_output *o=mi_retire_response(h);
+ mi_stop *stop=NULL;
+
+ if (o)
+   {
+    mi_output *sr=mi_get_stop_record(o);
+    if (sr)
+       stop=mi_get_stopped(sr->c);
+   }
+ mi_free_output(o);
+
+ return stop;
+}
+
+int mi_get_read_memory(mi_h *h, unsigned char *dest, unsigned ws, int *na,
+                       unsigned long *addr)
+{
+ char *end;
+ mi_results *res=mi_res_done_var(h,"memory"), *r;
+ int ok=0;
+
+ *na=0;
+ r=res;
+ if (r && r->type==t_list && ws==1)
+   {
+    r=r->v.rs;
+    if (r->type!=t_tuple)
+      {
+       mi_free_results(res);
+       return 0;
+      }
+    r=r->v.rs;
+    while (r)
+      {
+       if (r->type==t_list && strcmp(r->var,"data")==0)
+         {
+          mi_results *data=r->v.rs;
+          ok++;
+          if (data && data->type==t_const &&
+              strcmp(data->v.cstr,"N/A")==0)
+             *na=1;
+          else
+             while (data)
+               {
+                if (data->type==t_const)
+                   *(dest++)=strtol(data->v.cstr,&end,0);
+                data=data->next;
+               }
+         }
+       else if (r->type==t_const && strcmp(r->var,"addr")==0)
+         {
+          ok++;
+          if (addr)
+             *addr=strtoul(r->v.cstr,&end,0);
+         }
+       r=r->next;
+      }
+
+   }
+ mi_free_results(res);
+ return ok==2;
+}
+
+mi_asm_insn *mi_parse_insn(mi_results *c)
+{
+ mi_asm_insn *res=NULL, *cur=NULL;
+ mi_results *sub;
+ char *end;
+
+ while (c)
+   {
+    if (c->type==t_tuple)
+      {
+       if (!res)
+          res=cur=mi_alloc_asm_insn();
+       else
+         {
+          cur->next=mi_alloc_asm_insn();
+          cur=cur->next;
+         }
+       if (!cur)
+         {
+          mi_free_asm_insn(res);
+          return NULL;
+         }
+       sub=c->v.rs;
+       while (sub)
+         {
+          if (sub->type==t_const)
+            {
+             if (strcmp(sub->var,"address")==0)
+                cur->addr=(void *)strtoul(sub->v.cstr,&end,0);
+             else if (strcmp(sub->var,"func-name")==0)
+               {
+                cur->func=sub->v.cstr;
+                sub->v.cstr=NULL;
+               }
+             else if (strcmp(sub->var,"offset")==0)
+                cur->offset=atoi(sub->v.cstr);
+             else if (strcmp(sub->var,"inst")==0)
+               {
+                cur->inst=sub->v.cstr;
+                sub->v.cstr=NULL;
+               }
+            }
+          sub=sub->next;
+         }
+      }
+    c=c->next;
+   }
+ return res;
+}
+
+mi_asm_insns *mi_parse_insns(mi_results *c)
+{
+ mi_asm_insns *res=NULL, *cur=NULL;
+ mi_results *sub;
+
+ while (c)
+   {
+    if (c->var)
+      {
+       if (strcmp(c->var,"src_and_asm_line")==0 && c->type==t_tuple)
+         {
+          if (!res)
+             res=cur=mi_alloc_asm_insns();
+          else
+            {
+             cur->next=mi_alloc_asm_insns();
+             cur=cur->next;
+            }
+          if (!cur)
+            {
+             mi_free_asm_insns(res);
+             return NULL;
+            }
+          sub=c->v.rs;
+          while (sub)
+            {
+             if (sub->var)
+               {
+                if (sub->type==t_const)
+                  {
+                   if (strcmp(sub->var,"line")==0)
+                      cur->line=atoi(sub->v.cstr);
+                   else if (strcmp(sub->var,"file")==0)
+                     {
+                      cur->file=sub->v.cstr;
+                      sub->v.cstr=NULL;
+                     }
+                  }
+                else if (sub->type==t_list)
+                  {
+                   if (strcmp(sub->var,"line_asm_insn")==0)
+                      cur->ins=mi_parse_insn(sub->v.rs);
+                  }
+               }
+             sub=sub->next;
+            }
+         }
+      }
+    else
+      {/* No source line, just instructions */
+       res=mi_alloc_asm_insns();
+       res->ins=mi_parse_insn(c);
+       break;
+      }
+    c=c->next;
+   }
+ return res;
+}
+
+
+mi_asm_insns *mi_get_asm_insns(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"asm_insns");
+ mi_asm_insns *f=NULL;
+
+ if (r && r->type==t_list)
+    f=mi_parse_insns(r->v.rs);
+ mi_free_results(r);
+ return f;
+}
+
+mi_chg_reg *mi_parse_list_regs(mi_results *r, int *how_many)
+{
+ mi_results *c=r;
+ int cregs=0;
+ mi_chg_reg *first=NULL, *cur=NULL;
+
+ /* Create the list. */
+ while (c)
+   {
+    if (c->type==t_const && !c->var)
+      {
+       if (first)
+          cur=cur->next=mi_alloc_chg_reg();
+       else
+          first=cur=mi_alloc_chg_reg();
+       
+       if (NULL != cur) {
+               cur->name=c->v.cstr;
+               cur->reg=cregs++;
+               c->v.cstr=NULL;
+       }
+      }
+    c=c->next;
+   }
+ if (how_many)
+    *how_many=cregs;
+
+ return first;
+}
+
+mi_chg_reg *mi_get_list_registers(mi_h *h, int *how_many)
+{
+ mi_results *r=mi_res_done_var(h,"register-names");
+ mi_chg_reg *l=NULL;
+
+ if (r && r->type==t_list)
+    l=mi_parse_list_regs(r->v.rs,how_many);
+ mi_free_results(r);
+ return l;
+}
+
+mi_chg_reg *mi_parse_list_changed_regs(mi_results *r)
+{
+ mi_results *c=r;
+ mi_chg_reg *first=NULL, *cur=NULL;
+
+ /* Create the list. */
+ while (c)
+   {
+    if (c->type==t_const && !c->var)
+      {
+       if (first)
+          cur=cur->next=mi_alloc_chg_reg();
+       else
+          first=cur=mi_alloc_chg_reg();
+       cur->reg=atoi(c->v.cstr);
+      }
+    c=c->next;
+   }
+
+ return first;
+}
+
+mi_chg_reg *mi_get_list_changed_regs(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"changed-registers");
+ mi_chg_reg *changed=NULL;
+
+ if (r && r->type==t_list)
+    changed=mi_parse_list_changed_regs(r->v.rs);
+ mi_free_results(r);
+ return changed;
+}
+
+int mi_parse_reg_values(mi_results *r, mi_chg_reg *l)
+{
+ mi_results *c;
+
+ while (r && l)
+   {
+    if (r->type==t_tuple && !r->var)
+      {
+       c=r->v.rs;
+       while (c)
+         {
+          if (c->type==t_const && c->var)
+            {
+             if (strcmp(c->var,"number")==0)
+               {
+                if (atoi(c->v.cstr)!=l->reg)
+                  {
+                   mi_error=MI_PARSER;
+                   return 0;
+                  }
+               }
+             else if (strcmp(c->var,"value")==0)
+               {
+                l->val=c->v.cstr;
+                c->v.cstr=NULL;
+               }
+            }
+          c=c->next;
+         }
+      }
+    r=r->next;
+    l=l->next;
+   }
+
+ return !l && !r;
+}
+
+int mi_get_reg_values(mi_h *h, mi_chg_reg *l)
+{
+ mi_results *r=mi_res_done_var(h,"register-values");
+ int ok=0;
+
+ if (r && r->type==t_list)
+    ok=mi_parse_reg_values(r->v.rs,l);
+ mi_free_results(r);
+ return ok;
+}
+
+int mi_parse_list_regs_l(mi_results *r, mi_chg_reg *l)
+{
+ while (r && l)
+   {
+    if (r->type==t_const && !r->var)
+      {
+       free(l->name);
+       l->name=r->v.cstr;
+       r->v.cstr=NULL;
+       l=l->next;
+      }
+    r=r->next;
+   }
+
+ return !l && !r;
+}
+
+int mi_get_list_registers_l(mi_h *h, mi_chg_reg *l)
+{
+ mi_results *r=mi_res_done_var(h,"register-names");
+ int ok=0;
+
+ if (r && r->type==t_list)
+    ok=mi_parse_list_regs_l(r->v.rs,l);
+ mi_free_results(r);
+ return ok;
+}
+
+mi_chg_reg *mi_parse_reg_values_l(mi_results *r, int *how_many)
+{
+ mi_results *c;
+ mi_chg_reg *first=NULL, *cur=NULL;
+ *how_many=0;
+
+ while (r)
+   {
+    if (r->type==t_tuple && !r->var)
+      {
+       c=r->v.rs;
+       if (first)
+          cur=cur->next=mi_alloc_chg_reg();
+       else
+          first=cur=mi_alloc_chg_reg();
+       while (c)
+         {
+          if (c->type==t_const && c->var)
+            {
+             if (strcmp(c->var,"number")==0)
+               {
+                if (NULL != cur) 
+                        cur->reg=atoi(c->v.cstr);
+                (*how_many)++;
+               }
+             else if (strcmp(c->var,"value")==0)
+               {
+                if (NULL != cur)
+                         cur->val=c->v.cstr;
+                c->v.cstr=NULL;
+               }
+            }
+          c=c->next;
+         }
+      }
+    r=r->next;
+   }
+
+ return first;
+}
+
+mi_chg_reg *mi_get_reg_values_l(mi_h *h, int *how_many)
+{
+ mi_results *r=mi_res_done_var(h,"register-values");
+ mi_chg_reg *rgs=NULL;
+
+ if (r && r->type==t_list)
+    rgs=mi_parse_reg_values_l(r->v.rs,how_many);
+ mi_free_results(r);
+ return rgs;
+}
+
+
diff --git a/pathologist/src/mi/gdbmi_prg_control.c b/pathologist/src/mi/gdbmi_prg_control.c
new file mode 100644
index 0000000..80ac7af
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_prg_control.c
@@ -0,0 +1,598 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Program control.
+  Comments:
+  GDB/MI commands for the "Program Control" section.  @<p>
+
+@<pre>
+gdb command:                   Implemented?
+
+-exec-abort                    N.A. (*) (kill, but with non-interactive options)
+-exec-arguments                Yes
+-exec-continue                 Yes  ASYNC
+-exec-finish                   Yes  ASYNC
+-exec-interrupt                Yes  ASYNC
+-exec-next                     Yes  ASYNC
+-exec-next-instruction         Yes  ASYNC
+-exec-return                   Yes
+-exec-run                      Yes  ASYNC
+-exec-show-arguments           N.A. (show args) see gmi_stack_info_frame
+-exec-step                     Yes  ASYNC
+-exec-step-instruction         Yes  ASYNC
+-exec-until                    Yes  ASYNC
+-file-exec-and-symbols         Yes
+-file-exec-file                No
+-file-list-exec-sections       N.A. (info file)
+-file-list-exec-source-files   N.A.
+-file-list-shared-libraries    N.A.
+-file-list-symbol-files        N.A.
+-file-symbol-file              Yes
+@</pre>
+
+(*)  gmi_exec_kill implements it, but you should ensure that
+gmi_gdb_set("confirm","off") was called.  @<p>
+
+GDB Bug workaround for -file-exec-and-symbols and -file-symbol-file: This
+is complex, but a real bug. When you set a breakpoint you never know the
+name of the file as it appears in the debug info. So you can be specifying
+an absolute file name or a relative file name. The reference point could be
+different than the one used in the debug info. To solve all the combinations
+gdb does a search trying various combinations. GDB isn't very smart so you
+must at least specify the working directory and the directory where the
+binary is located to get a good chance (+ user options to solve the rest).
+Once you did it gdb can find the file by doing transformations to the
+"canonical" filename. This search works OK for already loaded symtabs
+(symbol tables), but it have a bug when the search is done for psymtabs
+(partial symtabs). The bug is in the use of source_full_path_of (source.c).
+This function calls openp indicating try_cwd_first. It makes the search file
+if the psymtab file name have at least one dirseparator. It means that
+psymtabs for files compiled with relative paths will fail. The search for
+symtabs uses symtab_to_filename, it calls open_source_file which finally
+calls openp without try_cwd_first.@*
+To workaround this bug we must ensure gdb loads *all* the symtabs to memory.
+And here comes another problem -file-exec-and-symbols doesn't support it
+according to docs. In real life that's a wrapper for "file", but as nobody
+can say it won't change we must use the CLI command.
+  
+***************************************************************************/
+
+#include <signal.h>
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_file_exec_and_symbols(mi_h *h, const char *file)
+{
+ if (mi_get_workaround(MI_PSYM_SEARCH))
+    mi_send(h,"file %s -readnow\n",file);
+ else
+    mi_send(h,"-file-exec-and-symbols %s\n",file);
+}
+
+void mi_set_unwind_on_signal_on(mi_h *h)
+{
+        mi_send(h, "set unwindonsignal on\n");
+}
+
+void mi_exec_arguments(mi_h *h, const char *args)
+{
+ mi_send(h,"-exec-arguments %s\n",args);
+}
+
+void mi_exec_run(mi_h *h)
+{
+ mi_send(h,"-exec-run\n");
+}
+
+void mi_exec_continue(mi_h *h)
+{
+ mi_send(h,"-exec-continue\n");
+}
+
+void mi_exec_continue_reverse(mi_h *h)
+{
+ mi_send(h, "-exec-continue --reverse\n");
+}
+
+void mi_target_terminal(mi_h *h, const char *tty_name)
+{
+ mi_send(h,"tty %s\n",tty_name);
+}
+
+void mi_file_symbol_file(mi_h *h, const char *file)
+{
+ if (mi_get_workaround(MI_PSYM_SEARCH))
+    mi_send(h,"symbol-file %s -readnow\n",file);
+ else
+    mi_send(h,"-file-symbol-file %s\n",file);
+}
+
+void mi_exec_finish(mi_h *h)
+{
+ mi_send(h,"-exec-finish\n");
+}
+
+void mi_exec_finish_reverse(mi_h * h)
+{
+ mi_send(h, "-exec-finish --reverse\n");
+}
+void mi_exec_interrupt(mi_h *h)
+{
+ mi_send(h,"-exec-interrupt\n");
+}
+
+void mi_exec_record_process(mi_h *h)
+{
+mi_send(h, "-interpreter-exec mi record\n");
+}
+
+void mi_exec_record_stop(mi_h *h)
+{
+mi_send(h, "-interpreter-exec mi record stop\n");
+}
+
+void mi_exec_next(mi_h *h, int count)
+{
+ if (count>1)
+    mi_send(h,"-exec-next %d\n",count);
+ else
+    mi_send(h,"-exec-next\n");
+}
+
+void mi_exec_next_instruction(mi_h *h)
+{
+ mi_send(h,"-exec-next-instruction\n");
+}
+
+void mi_exec_step(mi_h *h, int count)
+{
+ if (count>1)
+    mi_send(h,"-exec-step %d\n",count);
+ else
+    mi_send(h,"-exec-step\n");
+}
+
+
+void mi_exec_step_back(mi_h *h, int count)
+{
+        if (count>1)
+                mi_send(h, "-exec-step %d --reverse\n", count);
+        else
+                mi_send(h, "-exec-step --reverse\n");
+}
+
+
+void mi_exec_next_reverse(mi_h *h, int count)
+{
+        if (count>1)
+                mi_send(h, "-exec-next %d --reverse\n", count);
+        else
+                mi_send(h, "-exec-next --reverse\n");
+}
+
+
+void mi_exec_step_instruction(mi_h *h)
+{
+ mi_send(h,"-exec-step-instruction\n");
+}
+
+void mi_exec_until(mi_h *h, const char *file, int line)
+{
+ if (!file)
+    mi_send(h,"-exec-until\n");
+ else
+    mi_send(h,"-exec-until %s:%d\n",file,line);
+}
+
+void mi_exec_until_addr(mi_h *h, void *addr)
+{
+ mi_send(h,"-exec-until *%p\n",addr);
+}
+
+void mi_exec_return(mi_h *h)
+{
+ mi_send(h,"-exec-return\n");
+}
+
+void mi_exec_kill(mi_h *h)
+{
+ mi_send(h,"kill\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Specify the executable and arguments for local debug.
+
+  Command: -file-exec-and-symbols + -exec-arguments
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_set_exec(mi_h *h, const char *file, const char *args)
+{
+ mi_file_exec_and_symbols(h,file);
+ if (!mi_res_simple_done(h))
+    return 0;
+ if (!args)
+    return 1;
+ mi_exec_arguments(h,args);
+ return mi_res_simple_done(h);
+}
+
+int gmi_set_unwind_on_signal_on(mi_h * h)
+{
+        mi_set_unwind_on_signal_on(h);
+        return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Start running the executable. Remote sessions starts running.
+
+  Command: -exec-run
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_run(mi_h *h)
+{
+ mi_exec_run(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue the execution after a "stop".
+
+  Command: -exec-continue
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_continue(mi_h *h)
+{
+ mi_exec_continue(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue the execution in reverse order after a "stop".
+
+  Command: -exec-continue --reverse
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_continue_reverse(mi_h *h)
+{
+        mi_exec_continue_reverse(h);
+        return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Indicate which terminal will use the target program. For local sessions.
+
+  Command: tty
+  Return: !=0 OK
+  Example: 
+  
+***************************************************************************/
+
+int gmi_target_terminal(mi_h *h, const char *tty_name)
+{
+ mi_target_terminal(h,tty_name);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Specify what's the local copy that have debug info. For remote sessions.
+
+  Command: -file-symbol-file
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_file_symbol_file(mi_h *h, const char *file)
+{
+ mi_file_symbol_file(h,file);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue until function return, the return value is included in the async
+response.
+
+  Command: -exec-finish
+  Return: !=0 OK.
+  
+***************************************************************************/
+
+int gmi_exec_finish(mi_h *h)
+{
+ mi_exec_finish(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue backwardly until function return, the return value is included in
+  the async response.
+
+  Command: -exec-finish --reverse
+  Return: !=0 OK.
+
+***************************************************************************/
+int gmi_exec_finish_reverse(mi_h *h)
+{
+ mi_exec_finish_reverse(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Stop the program using SIGINT. The corresponding command should be
+-exec-interrupt but not even gdb 6.1.1 can do it because the "async" mode
+isn't really working.
+
+  Command: -exec-interrupt [replacement]
+  Return: Always 1
+  Example: 
+  
+***************************************************************************/
+
+int gmi_exec_interrupt(mi_h *h)
+{
+ // **** IMPORTANT!!! **** Not even gdb 6.1.1 can do it because the "async"
+ // mode isn't really working.
+ //mi_exec_interrupt(h);
+ //return mi_res_simple_running(h);
+
+ kill(h->pid,SIGINT);
+ return 1; // How can I know?
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of code.
+
+  Command: -exec-next
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_next(mi_h *h)
+{
+ mi_exec_next(h,1);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Start recording a process
+
+  Command: -interpreter-exec mi record
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_record_process(mi_h *h)
+{
+        mi_exec_record_process(h);
+        return 1;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Start recording a process
+
+  Command: -interpreter-exec mi record stop
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_record_stop(mi_h *h)
+{
+        mi_exec_record_stop(h);
+        return 1;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Skip count lines of code.
+
+  Command: -exec-next count
+  Return: !=0 OK
+
+***************************************************************************/
+
+int gmi_exec_next_cnt(mi_h *h, int count)
+{
+ mi_exec_next(h,count);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of assembler code.
+
+  Command: -exec-next-instruction
+  Return: !=0 OK
+
+***************************************************************************/
+
+int gmi_exec_next_instruction(mi_h *h)
+{
+ mi_exec_next_instruction(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of code. Get inside functions.
+
+  Command: -exec-step
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_step(mi_h *h)
+{
+ mi_exec_step(h,1);
+ return mi_res_simple_running(h);
+}
+
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Previous line of code. Get inside functions.
+
+  Command: -exec-step --reverse
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_step_back(mi_h *h)
+{
+        mi_exec_step_back(h,1);
+        return mi_res_simple_running(h);
+}
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Previous line of code (do not step into).
+
+  Command: -exec-next --reverse
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_next_reverse(mi_h *h)
+{
+        mi_exec_next_reverse(h,1);
+        return mi_res_simple_running(h);
+}
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Next count lines of code. Get inside functions.
+
+  Command: -exec-step count
+  Return: !=0 OK
+
+***************************************************************************/
+
+int gmi_exec_step_cnt(mi_h *h, int count)
+{
+ mi_exec_step(h,count);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of assembler code. Get inside calls.
+
+  Command: -exec-step-instruction
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_step_instruction(mi_h *h)
+{
+ mi_exec_step_instruction(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Execute until location is reached. If file is NULL then is until next
+line.
+
+  Command: -exec-until
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_until(mi_h *h, const char *file, int line)
+{
+ mi_exec_until(h,file,line);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Execute until location is reached.
+
+  Command: -exec-until (using *address)
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_until_addr(mi_h *h, void *addr)
+{
+ mi_exec_until_addr(h,addr);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Return to previous frame inmediatly.
+
+  Command: -exec-return
+  Return: A pointer to a new mi_frames structure indicating the current
+location. NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_exec_return(mi_h *h)
+{
+ mi_exec_return(h);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Just kill the program. That's what -exec-abort should do, but it isn't
+implemented by gdb. This implementation only works if the interactive mode
+is disabled (gmi_gdb_set("confirm","off")).
+
+  Command: -exec-abort [using kill]
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_kill(mi_h *h)
+{
+ mi_exec_kill(h);
+ return mi_res_simple_done(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_stack_man.c b/pathologist/src/mi/gdbmi_stack_man.c
new file mode 100644
index 0000000..977ea5e
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_stack_man.c
@@ -0,0 +1,222 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Stack manipulation.
+  Comments:
+  GDB/MI commands for the "Stack Manipulation" section.  @<p>
+
+@<pre>
+gdb command:              Implemented?
+
+-stack-info-frame         Yes, implemented as "frame"
+-stack-info-depth         Yes
+-stack-list-arguments     Yes
+-stack-list-frames        Yes
+-stack-list-locals        Yes
+-stack-select-frame       Yes
+@</pre>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_stack_list_frames(mi_h *h, int from, int to)
+{
+ if (from<0)
+    mi_send(h,"-stack-list-frames\n");
+ else
+    mi_send(h,"-stack-list-frames %d %d\n",from,to);
+}
+
+void mi_stack_list_arguments(mi_h *h, int show, int from, int to)
+{
+ if (from<0)
+    mi_send(h,"-stack-list-arguments %d\n",show);
+ else
+    mi_send(h,"-stack-list-arguments %d %d %d\n",show,from,to);
+}
+
+void mi_stack_info_frame(mi_h *h)
+{
+ mi_send(h,"frame\n");
+}
+
+void mi_stack_info_depth(mi_h *h, int depth)
+{
+ if (depth<0)
+    mi_send(h,"-stack-info-depth\n");
+ else
+    mi_send(h,"-stack-info-depth %d\n",depth);
+}
+
+void mi_stack_select_frame(mi_h *h, int framenum)
+{
+ mi_send(h,"-stack-select-frame %d\n",framenum);
+}
+
+void mi_stack_list_locals(mi_h *h, int show)
+{
+ mi_send(h,"-stack-list-locals %d\n",show);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  List of frames. Arguments aren't filled.
+
+  Command: -stack-list-frames
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_frames(mi_h *h)
+{
+ mi_stack_list_frames(h,-1,-1);
+ return mi_res_frames_array(h,"stack");
+}
+
+/**[txh]********************************************************************
+
+  Description: 
+  List of frames. Arguments aren't filled. Only the frames in the from
+ - to range are returned.
+  
+  Command: -stack-list-frames
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_frames_r(mi_h *h, int from, int to)
+{
+ mi_stack_list_frames(h,from,to);
+ return mi_res_frames_array(h,"stack");
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List arguments. Only level and args filled.
+  
+  Command: -stack-list-arguments
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_arguments(mi_h *h, int show)
+{
+ mi_stack_list_arguments(h,show,-1,-1);
+ return mi_res_frames_array(h,"stack-args");
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List arguments. Only level and args filled. Only for the
+frames in the from - to range.
+  
+  Command: -stack-list-arguments
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_arguments_r(mi_h *h, int show, int from, int to)
+{
+ mi_stack_list_arguments(h,show,from,to);
+ return mi_res_frames_array(h,"stack-args");
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Information about the current frame, including args.
+
+  Command: -stack-info-frame [using frame]
+  Return: A new mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_info_frame(mi_h *h)
+{
+ mi_stack_info_frame(h);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Stack info depth.
+
+  Command: -stack-info-depth
+  Return: The depth or -1 on error.
+  
+***************************************************************************/
+
+int gmi_stack_info_depth(mi_h *h, int max_depth)
+{
+ mi_results *r;
+ int ret=-1;
+
+ mi_stack_info_depth(h,max_depth);
+ r=mi_res_done_var(h,"depth");
+ if (r && r->type==t_const)
+   {
+    ret=atoi(r->v.cstr);
+    mi_free_results(r);
+   }
+ return ret;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set stack info depth.
+
+  Command: -stack-info-depth [no args]
+  Return: The depth or -1 on error.
+  Example: 
+  
+***************************************************************************/
+
+int gmi_stack_info_depth_get(mi_h *h)
+{
+ return gmi_stack_info_depth(h,-1);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Change current frame.
+
+  Command: -stack-select-frame
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_stack_select_frame(mi_h *h, int framenum)
+{
+ mi_stack_select_frame(h,framenum);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List of local vars.
+
+  Command: -stack-list-locals
+  Return: A new mi_results tree containing the variables or NULL on error.
+  
+***************************************************************************/
+
+mi_results *gmi_stack_list_locals(mi_h *h, int show)
+{
+ mi_stack_list_locals(h,show);
+ return mi_res_done_var(h,"locals");
+}
+
diff --git a/pathologist/src/mi/gdbmi_symbol_query.c b/pathologist/src/mi/gdbmi_symbol_query.c
new file mode 100644
index 0000000..8910517
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_symbol_query.c
@@ -0,0 +1,32 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Symbol query.
+  Comments:
+  GDB/MI commands for the "Symbol Query" section.@p
+
+@<pre>
+gdb command:              Implemented?
+-symbol-info-address      N.A. (info address, human readable)
+-symbol-info-file         N.A.
+-symbol-info-function     N.A.
+-symbol-info-line         N.A. (info line, human readable)
+-symbol-info-symbol       N.A. (info symbol, human readable)
+-symbol-list-functions    N.A. (info functions, human readable)
+-symbol-list-types        N.A. (info types, human readable)
+-symbol-list-variables    N.A. (info variables, human readable)
+-symbol-list-lines        No (gdb 6.x)
+-symbol-locate            N.A.
+-symbol-type              N.A. (ptype, human readable)
+@</pre>
+
+Note:@p
+
+Only one is implemented and not in gdb 5.x.@p
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
diff --git a/pathologist/src/mi/gdbmi_target_man.c b/pathologist/src/mi/gdbmi_target_man.c
new file mode 100644
index 0000000..bbb2b98
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_target_man.c
@@ -0,0 +1,119 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2007 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Target manipulation.
+  Comments:
+  GDB/MI commands for the "Target Manipulation" section.  @<p>
+
+@<pre>
+-target-attach                  Yes (implemented using attach)
+-target-compare-sections        N.A. (compare-sections)
+-target-detach                  Yes
+-target-download                Yes
+-target-exec-status             N.A.
+-target-list-available-targets  N.A. (help target)
+-target-list-current-targets    N.A. (info file among other things)
+-target-list-parameters         N.A.
+-target-select                  Yes
+@</pre>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_target_select(mi_h *h, const char *type, const char *params)
+{
+ mi_send(h,"-target-select %s %s\n",type,params);
+}
+
+/* Note: -target-attach isn't currently implemented :-( (gdb 6.1.1) */
+void mi_target_attach(mi_h *h, pid_t pid)
+{
+ mi_send(h,"attach %d\n",pid);
+}
+
+void mi_target_detach(mi_h *h)
+{
+ mi_send(h,"-target-detach\n");
+}
+
+void mi_target_download(mi_h *h)
+{
+ mi_send(h,"-target-download\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Connect to a remote gdbserver using the specified methode.
+
+  Command: -target-select
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_target_select(mi_h *h, const char *type, const char *params)
+{
+ mi_target_select(h,type,params);
+ if (!mi_res_simple_connected(h))
+    return 0;
+ mi_send_target_commands(h);
+ return 1;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Attach to an already running process.
+
+  Command: -target-attach [using attach]
+  Return: The frame of the current location, NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_target_attach(mi_h *h, pid_t pid)
+{
+ mi_target_attach(h,pid);
+ //return mi_res_simple_done(h);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Detach from an attached process.
+
+  Command: -target-detach
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_target_detach(mi_h *h)
+{
+ mi_target_detach(h);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Loads the executable onto the remote target.
+
+  Command: -target-download
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_target_download(mi_h *h)
+{
+ mi_target_download(h);
+ // TODO: this response have some data
+ return mi_res_simple_done(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_thread.c b/pathologist/src/mi/gdbmi_thread.c
new file mode 100644
index 0000000..b8fa63d
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_thread.c
@@ -0,0 +1,89 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Thread commands.
+  Comments:
+  GDB/MI commands for the "Thread Commands" section.  @<p>
+
+@<pre>
+gdb command:              Implemented?
+-thread-info              N.A.
+-thread-list-all-threads  Yes, implemented as "info threads"
+-thread-list-ids          Yes
+-thread-select            Yes
+@</pre>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_thread_list_ids(mi_h *h)
+{
+ mi_send(h,"-thread-list-ids\n");
+}
+
+void mi_thread_select(mi_h *h, int id)
+{
+ mi_send(h,"-thread-select %d\n",id);
+}
+
+void mi_thread_list_all_threads(mi_h *h)
+{
+ mi_send(h,"info threads\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  List available thread ids.
+
+  Command: -thread-list-ids
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_thread_list_ids(mi_h *h, int **list)
+{
+ mi_thread_list_ids(h);
+ return mi_res_thread_ids(h,list);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Select a thread.
+
+  Command: -thread-select
+  Return: A new mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_thread_select(mi_h *h, int id)
+{
+ mi_thread_select(h,id);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Get a list of frames for each available thread. Implemented using "info
+thread".
+
+  Command: -thread-list-all-threads
+  Return: A kist of frames, NULL on error
+  
+***************************************************************************/
+
+mi_frames *gmi_thread_list_all_threads(mi_h *h)
+{
+ mi_thread_list_all_threads(h);
+ return mi_res_frames_list(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_var_obj.c b/pathologist/src/mi/gdbmi_var_obj.c
new file mode 100644
index 0000000..435feec
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_var_obj.c
@@ -0,0 +1,371 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Variable objects.
+  Comments:
+  GDB/MI commands for the "Variable Objects" section.
+    @<p>
+
+@<pre>
+gdb command:              Imp? Description:
+-var-create               Yes  create a variable object
+-var-delete               Yes  delete the variable object and its children
+-var-set-format           Yes  set the display format of this variable
+-var-show-format          Yes  show the display format of this variable
+-var-info-num-children    Yes  tells how many children this object has
+-var-list-children        Yes* return a list of the object's children
+-var-info-type            Yes  show the type of this variable object
+-var-info-expression      Yes  print what this variable object represents
+-var-show-attributes      Yes  is this variable editable?
+-var-evaluate-expression  Yes  get the value of this variable
+-var-assign               Yes  set the value of this variable
+-var-update               Yes* update the variable and its children
+@</pre>
+
+Notes:  @<p>
+1) I suggest letting gdb to choose the names for the variables.@*
+2) -var-list-children supports an optional "show values" argument in MI v2.
+It isn't implemented.@*
+
+  @<p>
+
+* MI v1 and v2 result formats supported.  @<p>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_var_create(mi_h *h, const char *name, int frame, const char *exp)
+{
+ const char *n=name ? name : "-";
+
+ if (frame<0)
+    mi_send(h,"-var-create %s * %s\n",n,exp);
+ else
+    mi_send(h,"-var-create %s %d %s\n",n,frame,exp);
+}
+
+void mi_var_delete(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-delete %s\n",name);
+}
+
+void mi_var_set_format(mi_h *h, const char *name, const char *format)
+{
+ mi_send(h,"-var-set-format \"%s\" %s\n",name,format);
+}
+
+void mi_var_show_format(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-show-format \"%s\"\n",name);
+}
+
+void mi_var_info_num_children(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-info-num-children \"%s\"\n",name);
+}
+
+void mi_var_info_type(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-info-type \"%s\"\n",name);
+}
+
+void mi_var_info_expression(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-info-expression \"%s\"\n",name);
+}
+
+void mi_var_show_attributes(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-show-attributes \"%s\"\n",name);
+}
+
+void mi_var_update(mi_h *h, const char *name)
+{
+ if (name)
+    mi_send(h,"-var-update %s\n",name);
+ else
+    mi_send(h,"-var-update *\n");
+}
+
+void mi_var_assign(mi_h *h, const char *name, const char *expression)
+{
+ mi_send(h,"-var-assign \"%s\" \"%s\"\n",name,expression);
+}
+
+void mi_var_evaluate_expression(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-evaluate-expression \"%s\"\n",name);
+}
+
+void mi_var_list_children(mi_h *h, const char *name)
+{
+ if (h->version>=MI_VERSION2U(2,0,0))
+    mi_send(h,"-var-list-children --all-values \"%s\"\n",name);
+ else
+    mi_send(h,"-var-list-children \"%s\"\n",name);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Create a variable object. I recommend using gmi_var_create and letting
+gdb choose the names.
+
+  Command: -var-create
+  Return: A new mi_gvar strcture or NULL on error.
+  
+***************************************************************************/
+
+mi_gvar *gmi_var_create_nm(mi_h *h, const char *name, int frame, const char *exp)
+{
+ mi_var_create(h,name,frame,exp);
+ return mi_res_gvar(h,NULL,exp);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Create a variable object. The name is selected by gdb. Alternative:
+  gmi_full_var_create.
+
+  Command: -var-create [auto name]
+  Return: A new mi_gvar strcture or NULL on error.
+  
+***************************************************************************/
+
+mi_gvar *gmi_var_create(mi_h *h, int frame, const char *exp)
+{
+ return gmi_var_create_nm(h,NULL,frame,exp);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Delete a variable object. Doesn't free the mi_gvar data.
+
+  Command: -var-delete
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_delete(mi_h *h, mi_gvar *var)
+{
+ mi_var_delete(h,var->name);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set the format used to represent the result.
+
+  Command: -var-set-format
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_set_format(mi_h *h, mi_gvar *var, enum mi_gvar_fmt format)
+{
+ int ret;
+
+ mi_var_set_format(h,var->name,mi_format_enum_to_str(format));
+ ret=mi_res_simple_done(h);
+ if (ret)
+    var->format=format;
+ return ret;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the format field with info from gdb.
+
+  Command: -var-show-format
+  Return: !=0 OK.
+  
+***************************************************************************/
+
+int gmi_var_show_format(mi_h *h, mi_gvar *var)
+{
+ mi_var_show_format(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the numchild field with info from gdb.
+
+  Command: -var-info-num-children
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_info_num_children(mi_h *h, mi_gvar *var)
+{
+ mi_var_info_num_children(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the type field with info from gdb.
+
+  Command: -var-info-type
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_info_type(mi_h *h, mi_gvar *var)
+{
+ mi_var_info_type(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the expression and lang fields with info from gdb. Note that lang
+isn't filled during creation.
+
+  Command: -var-info-expression
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_info_expression(mi_h *h, mi_gvar *var)
+{
+ mi_var_info_expression(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the attr field with info from gdb. Note that attr isn't filled
+during creation.
+
+  Command: -var-show-attributes
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_show_attributes(mi_h *h, mi_gvar *var)
+{
+ mi_var_show_attributes(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Create the variable and also fill the lang and attr fields. The name is
+selected by gdb.
+
+  Command: -var-create + -var-info-expression + -var-show-attributes
+  Return: A new mi_gvar strcture or NULL on error.
+  
+***************************************************************************/
+
+mi_gvar *gmi_full_var_create(mi_h *h, int frame, const char *exp)
+{
+ mi_gvar *var=gmi_var_create_nm(h,NULL,frame,exp);
+ if (var)
+   {/* What if it fails? */
+    gmi_var_info_expression(h,var);
+    gmi_var_show_attributes(h,var);
+   }
+ return var;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Update variable. Use NULL for all. Note that *changed can be NULL if none
+updated.
+
+  Command: -var-update
+  Return: !=0 OK. The changed list contains the list of changed vars.
+  
+***************************************************************************/
+
+int gmi_var_update(mi_h *h, mi_gvar *var, mi_gvar_chg **changed)
+{
+ mi_var_update(h,var ? var->name : NULL);
+ return mi_res_changelist(h,changed);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Change variable. The new value replaces the value field.
+
+  Command: -var-assign
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_assign(mi_h *h, mi_gvar *var, const char *expression)
+{
+ char *res;
+ mi_var_assign(h,var->name,expression);
+ res=mi_res_value(h);
+ if (res)
+   {
+    free(var->value);
+    var->value=res;
+    return 1;
+   }
+ return 0;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the value field getting the current value for a variable.
+
+  Command: -var-evaluate-expression
+  Return: !=0 OK, value contains the result.
+  
+***************************************************************************/
+
+int gmi_var_evaluate_expression(mi_h *h, mi_gvar *var)
+{
+ char *s;
+
+ mi_var_evaluate_expression(h,var->name);
+ s=mi_res_value(h);
+ if (s)
+   {
+    free(var->value);
+    var->value=s;
+   }
+ return s!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List children. It ONLY returns the first level information. :-(@*
+  On success the child field contains the list of children.
+
+  Command: -var-list-children
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_list_children(mi_h *h, mi_gvar *var)
+{
+ mi_var_list_children(h,var->name);
+ return mi_res_children(h,var);
+}
+
diff --git a/pathologist/src/minixml/Makefile.am b/pathologist/src/minixml/Makefile.am
new file mode 100644
index 0000000..423fbdc
--- /dev/null
+++ b/pathologist/src/minixml/Makefile.am
@@ -0,0 +1,27 @@
+INCLUDES = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+if MINGW
+ WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols 
+endif
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = libminixml.la
+
+libminixml_la_SOURCES = \
+         mxml-attr.c \
+         mxmldoc.c \
+         mxml-entity.c \
+         mxml-file.c \
+         mxml-get.c \
+         mxml-index.c \
+         mxml-node.c \
+         mxml-private.c \
+         mxml-private.h \
+         mxml-search.c \
+         mxml-set.c \
+         mxml-string.c \
+         config.h
\ No newline at end of file
diff --git a/pathologist/src/minixml/config.h b/pathologist/src/minixml/config.h
new file mode 100644
index 0000000..8bae4bf
--- /dev/null
+++ b/pathologist/src/minixml/config.h
@@ -0,0 +1,95 @@
+/*
+ * "$Id: config.h.in 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Configuration file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+
+/*
+ * Version number...
+ */
+
+#define MXML_VERSION    ""
+
+
+/*
+ * Inline function support...
+ */
+
+#define inline
+
+
+/*
+ * Long long support...
+ */
+
+#undef HAVE_LONG_LONG
+
+
+/*
+ * Do we have the snprintf() and vsnprintf() functions?
+ */
+
+#undef HAVE_SNPRINTF
+#undef HAVE_VSNPRINTF
+
+
+/*
+ * Do we have the strXXX() functions?
+ */
+
+#undef HAVE_STRDUP
+
+
+/*
+ * Do we have threading support?
+ */
+
+#undef HAVE_PTHREAD_H
+
+
+/*
+ * Define prototypes for string functions as needed...
+ */
+
+#  ifndef HAVE_STRDUP
+extern char     *_mxml_strdup(const char *);
+#    define strdup _mxml_strdup
+#  endif /* !HAVE_STRDUP */
+
+extern char     *_mxml_strdupf(const char *, ...);
+extern char     *_mxml_vstrdupf(const char *, va_list);
+
+#  ifndef HAVE_SNPRINTF
+extern int      _mxml_snprintf(char *, size_t, const char *, ...);
+#    define snprintf _mxml_snprintf
+#  endif /* !HAVE_SNPRINTF */
+
+#  ifndef HAVE_VSNPRINTF
+extern int      _mxml_vsnprintf(char *, size_t, const char *, va_list);
+#    define vsnprintf _mxml_vsnprintf
+#  endif /* !HAVE_VSNPRINTF */
+
+/*
+ * End of "$Id: config.h.in 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-attr.c b/pathologist/src/minixml/mxml-attr.c
new file mode 100644
index 0000000..c9950f5
--- /dev/null
+++ b/pathologist/src/minixml/mxml-attr.c
@@ -0,0 +1,319 @@
+/*
+ * "$Id: mxml-attr.c 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Attribute support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlElementDeleteAttr() - Delete an attribute.
+ *   mxmlElementGetAttr()    - Get an attribute.
+ *   mxmlElementSetAttr()    - Set an attribute.
+ *   mxmlElementSetAttrf()   - Set an attribute with a formatted value.
+ *   mxml_set_attr()         - Set or add an attribute name/value pair.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static int      mxml_set_attr(mxml_node_t *node, const char *name,
+                              char *value);
+
+
+/*
+ * 'mxmlElementDeleteAttr()' - Delete an attribute.
+ *
+ * @since Mini-XML 2.4@
+ */
+
+void
+mxmlElementDeleteAttr(mxml_node_t *node,/* I - Element */
+                      const char  *name)/* I - Attribute name */
+{
+  int           i;                      /* Looping var */
+  mxml_attr_t   *attr;                  /* Cirrent attribute */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementDeleteAttr(node=%p, name=\"%s\")\n",
+          node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return;
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+  {
+#ifdef DEBUG
+    printf("    %s=\"%s\"\n", attr->name, attr->value);
+#endif /* DEBUG */
+
+    if (!strcmp(attr->name, name))
+    {
+     /*
+      * Delete this attribute...
+      */
+
+      free(attr->name);
+      free(attr->value);
+
+      i --;
+      if (i > 0)
+        memmove(attr, attr + 1, i * sizeof(mxml_attr_t));
+
+      node->value.element.num_attrs --;
+      return;
+    }
+  }
+}
+
+
+/*
+ * 'mxmlElementGetAttr()' - Get an attribute.
+ *
+ * This function returns NULL if the node is not an element or the
+ * named attribute does not exist.
+ */
+
+const char *                            /* O - Attribute value or NULL */
+mxmlElementGetAttr(mxml_node_t *node,   /* I - Element node */
+                   const char  *name)   /* I - Name of attribute */
+{
+  int           i;                      /* Looping var */
+  mxml_attr_t   *attr;                  /* Cirrent attribute */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementGetAttr(node=%p, name=\"%s\")\n",
+          node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return (NULL);
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+  {
+#ifdef DEBUG
+    printf("    %s=\"%s\"\n", attr->name, attr->value);
+#endif /* DEBUG */
+
+    if (!strcmp(attr->name, name))
+    {
+#ifdef DEBUG
+      printf("    Returning \"%s\"!\n", attr->value);
+#endif /* DEBUG */
+      return (attr->value);
+    }
+  }
+
+ /*
+  * Didn't find attribute, so return NULL...
+  */
+
+#ifdef DEBUG
+  puts("    Returning NULL!\n");
+#endif /* DEBUG */
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlElementSetAttr()' - Set an attribute.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new string value. The string value is copied
+ * into the element node. This function does nothing if the node is
+ * not an element.
+ */
+
+void
+mxmlElementSetAttr(mxml_node_t *node,   /* I - Element node */
+                   const char  *name,   /* I - Name of attribute */
+                   const char  *value)  /* I - Attribute value */
+{
+  char  *valuec;                        /* Copy of value */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementSetAttr(node=%p, name=\"%s\", value=\"%s\")\n",
+          node, name ? name : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return;
+
+  if (value)
+    valuec = strdup(value);
+  else
+    valuec = NULL;
+
+  if (mxml_set_attr(node, name, valuec))
+    free(valuec);
+}
+
+
+/*
+ * 'mxmlElementSetAttrf()' - Set an attribute with a formatted value.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new formatted string. The formatted string value is
+ * copied into the element node. This function does nothing if the node
+ * is not an element.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+void
+mxmlElementSetAttrf(mxml_node_t *node,  /* I - Element node */
+                    const char  *name,  /* I - Name of attribute */
+                    const char  *format,/* I - Printf-style attribute value */
+                    ...)                /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Argument pointer */
+  char          *value;                 /* Value */
+
+
+#ifdef DEBUG
+  fprintf(stderr,
+          "mxmlElementSetAttrf(node=%p, name=\"%s\", format=\"%s\", ...)\n",
+          node, name ? name : "(null)", format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name || !format)
+    return;
+
+ /*
+  * Format the value...
+  */
+
+  va_start(ap, format);
+  value = _mxml_vstrdupf(format, ap);
+  va_end(ap);
+
+  if (!value)
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+  else if (mxml_set_attr(node, name, value))
+    free(value);
+}
+
+
+/*
+ * 'mxml_set_attr()' - Set or add an attribute name/value pair.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_set_attr(mxml_node_t *node,        /* I - Element node */
+              const char  *name,        /* I - Attribute name */
+              char        *value)       /* I - Attribute value */
+{
+  int           i;                      /* Looping var */
+  mxml_attr_t   *attr;                  /* New attribute */
+
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+    if (!strcmp(attr->name, name))
+    {
+     /*
+      * Free the old value as needed...
+      */
+
+      if (attr->value)
+        free(attr->value);
+
+      attr->value = value;
+
+      return (0);
+    }
+
+ /*
+  * Add a new attribute...
+  */
+
+  if (node->value.element.num_attrs == 0)
+    attr = malloc(sizeof(mxml_attr_t));
+  else
+    attr = realloc(node->value.element.attrs,
+                   (node->value.element.num_attrs + 1) * sizeof(mxml_attr_t));
+
+  if (!attr)
+  {
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+    return (-1);
+  }
+
+  node->value.element.attrs = attr;
+  attr += node->value.element.num_attrs;
+
+  if ((attr->name = strdup(name)) == NULL)
+  {
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+    return (-1);
+  }
+
+  attr->value = value;
+
+  node->value.element.num_attrs ++;
+
+  return (0);
+}
+
+
+/*
+ * End of "$Id: mxml-attr.c 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-entity.c b/pathologist/src/minixml/mxml-entity.c
new file mode 100644
index 0000000..c5c9f61
--- /dev/null
+++ b/pathologist/src/minixml/mxml-entity.c
@@ -0,0 +1,460 @@
+/*
+ * "$Id: mxml-entity.c 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Character entity support code for Mini-XML, a small XML-like
+ * file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlEntityAddCallback()    - Add a callback to convert entities to
+ *                                Unicode.
+ *   mxmlEntityGetName()        - Get the name that corresponds to the
+ *                                character value.
+ *   mxmlEntityGetValue()       - Get the character corresponding to a named
+ *                                entity.
+ *   mxmlEntityRemoveCallback() - Remove a callback.
+ *   _mxml_entity_cb()          - Lookup standard (X)HTML entities.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "mxml-private.h"
+
+
+/*
+ * 'mxmlEntityAddCallback()' - Add a callback to convert entities to Unicode.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlEntityAddCallback(
+    mxml_entity_cb_t cb)                /* I - Callback function to add */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  if (global->num_entity_cbs < (int)(sizeof(global->entity_cbs) / sizeof(global->entity_cbs[0])))
+  {
+    global->entity_cbs[global->num_entity_cbs] = cb;
+    global->num_entity_cbs ++;
+
+    return (0);
+  }
+  else
+  {
+    mxml_error("Unable to add entity callback!");
+
+    return (-1);
+  }
+}
+
+
+/*
+ * 'mxmlEntityGetName()' - Get the name that corresponds to the character value.
+ *
+ * If val does not need to be represented by a named entity, NULL is returned.
+ */
+
+const char *                            /* O - Entity name or NULL */
+mxmlEntityGetName(int val)              /* I - Character value */
+{
+  switch (val)
+  {
+    case '&' :
+        return ("amp");
+
+    case '<' :
+        return ("lt");
+
+    case '>' :
+        return ("gt");
+
+    case '\"' :
+        return ("quot");
+
+    default :
+        return (NULL);
+  }
+}
+
+
+/*
+ * 'mxmlEntityGetValue()' - Get the character corresponding to a named entity.
+ *
+ * The entity name can also be a numeric constant. -1 is returned if the
+ * name is not known.
+ */
+
+int                                     /* O - Character value or -1 on error */
+mxmlEntityGetValue(const char *name)    /* I - Entity name */
+{
+  int           i;                      /* Looping var */
+  int           ch;                     /* Character value */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  for (i = 0; i < global->num_entity_cbs; i ++)
+    if ((ch = (global->entity_cbs[i])(name)) >= 0)
+      return (ch);
+
+  return (-1);
+}
+
+
+/*
+ * 'mxmlEntityRemoveCallback()' - Remove a callback.
+ */
+
+void
+mxmlEntityRemoveCallback(
+    mxml_entity_cb_t cb)                /* I - Callback function to remove */
+{
+  int           i;                      /* Looping var */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  for (i = 0; i < global->num_entity_cbs; i ++)
+    if (cb == global->entity_cbs[i])
+    {
+     /*
+      * Remove the callback...
+      */
+
+      global->num_entity_cbs --;
+
+      if (i < global->num_entity_cbs)
+        memmove(global->entity_cbs + i, global->entity_cbs + i + 1,
+                (global->num_entity_cbs - i) * sizeof(global->entity_cbs[0]));
+
+      return;
+    }
+}
+
+
+/*
+ * '_mxml_entity_cb()' - Lookup standard (X)HTML entities.
+ */
+
+int                                     /* O - Unicode value or -1 */
+_mxml_entity_cb(const char *name)       /* I - Entity name */
+{
+  int   diff,                           /* Difference between names */
+        current,                        /* Current entity in search */
+        first,                          /* First entity in search */
+        last;                           /* Last entity in search */
+  static const struct
+  {
+    const char  *name;                  /* Entity name */
+    int         val;                    /* Character value */
+  }     entities[] =
+  {
+    { "AElig",          198 },
+    { "Aacute",         193 },
+    { "Acirc",          194 },
+    { "Agrave",         192 },
+    { "Alpha",          913 },
+    { "Aring",          197 },
+    { "Atilde",         195 },
+    { "Auml",           196 },
+    { "Beta",           914 },
+    { "Ccedil",         199 },
+    { "Chi",            935 },
+    { "Dagger",         8225 },
+    { "Delta",          916 },
+    { "Dstrok",         208 },
+    { "ETH",            208 },
+    { "Eacute",         201 },
+    { "Ecirc",          202 },
+    { "Egrave",         200 },
+    { "Epsilon",        917 },
+    { "Eta",            919 },
+    { "Euml",           203 },
+    { "Gamma",          915 },
+    { "Iacute",         205 },
+    { "Icirc",          206 },
+    { "Igrave",         204 },
+    { "Iota",           921 },
+    { "Iuml",           207 },
+    { "Kappa",          922 },
+    { "Lambda",         923 },
+    { "Mu",             924 },
+    { "Ntilde",         209 },
+    { "Nu",             925 },
+    { "OElig",          338 },
+    { "Oacute",         211 },
+    { "Ocirc",          212 },
+    { "Ograve",         210 },
+    { "Omega",          937 },
+    { "Omicron",        927 },
+    { "Oslash",         216 },
+    { "Otilde",         213 },
+    { "Ouml",           214 },
+    { "Phi",            934 },
+    { "Pi",             928 },
+    { "Prime",          8243 },
+    { "Psi",            936 },
+    { "Rho",            929 },
+    { "Scaron",         352 },
+    { "Sigma",          931 },
+    { "THORN",          222 },
+    { "Tau",            932 },
+    { "Theta",          920 },
+    { "Uacute",         218 },
+    { "Ucirc",          219 },
+    { "Ugrave",         217 },
+    { "Upsilon",        933 },
+    { "Uuml",           220 },
+    { "Xi",             926 },
+    { "Yacute",         221 },
+    { "Yuml",           376 },
+    { "Zeta",           918 },
+    { "aacute",         225 },
+    { "acirc",          226 },
+    { "acute",          180 },
+    { "aelig",          230 },
+    { "agrave",         224 },
+    { "alefsym",        8501 },
+    { "alpha",          945 },
+    { "amp",            '&' },
+    { "and",            8743 },
+    { "ang",            8736 },
+    { "apos",           '\'' },
+    { "aring",          229 },
+    { "asymp",          8776 },
+    { "atilde",         227 },
+    { "auml",           228 },
+    { "bdquo",          8222 },
+    { "beta",           946 },
+    { "brkbar",         166 },
+    { "brvbar",         166 },
+    { "bull",           8226 },
+    { "cap",            8745 },
+    { "ccedil",         231 },
+    { "cedil",          184 },
+    { "cent",           162 },
+    { "chi",            967 },
+    { "circ",           710 },
+    { "clubs",          9827 },
+    { "cong",           8773 },
+    { "copy",           169 },
+    { "crarr",          8629 },
+    { "cup",            8746 },
+    { "curren",         164 },
+    { "dArr",           8659 },
+    { "dagger",         8224 },
+    { "darr",           8595 },
+    { "deg",            176 },
+    { "delta",          948 },
+    { "diams",          9830 },
+    { "die",            168 },
+    { "divide",         247 },
+    { "eacute",         233 },
+    { "ecirc",          234 },
+    { "egrave",         232 },
+    { "empty",          8709 },
+    { "emsp",           8195 },
+    { "ensp",           8194 },
+    { "epsilon",        949 },
+    { "equiv",          8801 },
+    { "eta",            951 },
+    { "eth",            240 },
+    { "euml",           235 },
+    { "euro",           8364 },
+    { "exist",          8707 },
+    { "fnof",           402 },
+    { "forall",         8704 },
+    { "frac12",         189 },
+    { "frac14",         188 },
+    { "frac34",         190 },
+    { "frasl",          8260 },
+    { "gamma",          947 },
+    { "ge",             8805 },
+    { "gt",             '>' },
+    { "hArr",           8660 },
+    { "harr",           8596 },
+    { "hearts",         9829 },
+    { "hellip",         8230 },
+    { "hibar",          175 },
+    { "iacute",         237 },
+    { "icirc",          238 },
+    { "iexcl",          161 },
+    { "igrave",         236 },
+    { "image",          8465 },
+    { "infin",          8734 },
+    { "int",            8747 },
+    { "iota",           953 },
+    { "iquest",         191 },
+    { "isin",           8712 },
+    { "iuml",           239 },
+    { "kappa",          954 },
+    { "lArr",           8656 },
+    { "lambda",         955 },
+    { "lang",           9001 },
+    { "laquo",          171 },
+    { "larr",           8592 },
+    { "lceil",          8968 },
+    { "ldquo",          8220 },
+    { "le",             8804 },
+    { "lfloor",         8970 },
+    { "lowast",         8727 },
+    { "loz",            9674 },
+    { "lrm",            8206 },
+    { "lsaquo",         8249 },
+    { "lsquo",          8216 },
+    { "lt",             '<' },
+    { "macr",           175 },
+    { "mdash",          8212 },
+    { "micro",          181 },
+    { "middot",         183 },
+    { "minus",          8722 },
+    { "mu",             956 },
+    { "nabla",          8711 },
+    { "nbsp",           160 },
+    { "ndash",          8211 },
+    { "ne",             8800 },
+    { "ni",             8715 },
+    { "not",            172 },
+    { "notin",          8713 },
+    { "nsub",           8836 },
+    { "ntilde",         241 },
+    { "nu",             957 },
+    { "oacute",         243 },
+    { "ocirc",          244 },
+    { "oelig",          339 },
+    { "ograve",         242 },
+    { "oline",          8254 },
+    { "omega",          969 },
+    { "omicron",        959 },
+    { "oplus",          8853 },
+    { "or",             8744 },
+    { "ordf",           170 },
+    { "ordm",           186 },
+    { "oslash",         248 },
+    { "otilde",         245 },
+    { "otimes",         8855 },
+    { "ouml",           246 },
+    { "para",           182 },
+    { "part",           8706 },
+    { "permil",         8240 },
+    { "perp",           8869 },
+    { "phi",            966 },
+    { "pi",             960 },
+    { "piv",            982 },
+    { "plusmn",         177 },
+    { "pound",          163 },
+    { "prime",          8242 },
+    { "prod",           8719 },
+    { "prop",           8733 },
+    { "psi",            968 },
+    { "quot",           '\"' },
+    { "rArr",           8658 },
+    { "radic",          8730 },
+    { "rang",           9002 },
+    { "raquo",          187 },
+    { "rarr",           8594 },
+    { "rceil",          8969 },
+    { "rdquo",          8221 },
+    { "real",           8476 },
+    { "reg",            174 },
+    { "rfloor",         8971 },
+    { "rho",            961 },
+    { "rlm",            8207 },
+    { "rsaquo",         8250 },
+    { "rsquo",          8217 },
+    { "sbquo",          8218 },
+    { "scaron",         353 },
+    { "sdot",           8901 },
+    { "sect",           167 },
+    { "shy",            173 },
+    { "sigma",          963 },
+    { "sigmaf",         962 },
+    { "sim",            8764 },
+    { "spades",         9824 },
+    { "sub",            8834 },
+    { "sube",           8838 },
+    { "sum",            8721 },
+    { "sup",            8835 },
+    { "sup1",           185 },
+    { "sup2",           178 },
+    { "sup3",           179 },
+    { "supe",           8839 },
+    { "szlig",          223 },
+    { "tau",            964 },
+    { "there4",         8756 },
+    { "theta",          952 },
+    { "thetasym",       977 },
+    { "thinsp",         8201 },
+    { "thorn",          254 },
+    { "tilde",          732 },
+    { "times",          215 },
+    { "trade",          8482 },
+    { "uArr",           8657 },
+    { "uacute",         250 },
+    { "uarr",           8593 },
+    { "ucirc",          251 },
+    { "ugrave",         249 },
+    { "uml",            168 },
+    { "upsih",          978 },
+    { "upsilon",        965 },
+    { "uuml",           252 },
+    { "weierp",         8472 },
+    { "xi",             958 },
+    { "yacute",         253 },
+    { "yen",            165 },
+    { "yuml",           255 },
+    { "zeta",           950 },
+    { "zwj",            8205 },
+    { "zwnj",           8204 }
+  };
+
+
+ /*
+  * Do a binary search for the named entity...
+  */
+
+  first = 0;
+  last  = (int)(sizeof(entities) / sizeof(entities[0]) - 1);
+
+  while ((last - first) > 1)
+  {
+    current = (first + last) / 2;
+
+    if ((diff = strcmp(name, entities[current].name)) == 0)
+      return (entities[current].val);
+    else if (diff < 0)
+      last = current;
+    else
+      first = current;
+  }
+
+ /*
+  * If we get here, there is a small chance that there is still
+  * a match; check first and last...
+  */
+
+  if (!strcmp(name, entities[first].name))
+    return (entities[first].val);
+  else if (!strcmp(name, entities[last].name))
+    return (entities[last].val);
+  else
+    return (-1);
+}
+
+
+/*
+ * End of "$Id: mxml-entity.c 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-file.c b/pathologist/src/minixml/mxml-file.c
new file mode 100644
index 0000000..9927040
--- /dev/null
+++ b/pathologist/src/minixml/mxml-file.c
@@ -0,0 +1,3080 @@
+/*
+ * "$Id: mxml-file.c 438 2011-03-24 05:47:51Z mike $"
+ *
+ * File loading code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlLoadFd()            - Load a file descriptor into an XML node tree.
+ *   mxmlLoadFile()          - Load a file into an XML node tree.
+ *   mxmlLoadString()        - Load a string into an XML node tree.
+ *   mxmlSaveAllocString()   - Save an XML tree to an allocated string.
+ *   mxmlSaveFd()            - Save an XML tree to a file descriptor.
+ *   mxmlSaveFile()          - Save an XML tree to a file.
+ *   mxmlSaveString()        - Save an XML node tree to a string.
+ *   mxmlSAXLoadFd()         - Load a file descriptor into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSAXLoadFile()       - Load a file into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSAXLoadString()     - Load a string into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSetCustomHandlers() - Set the handling functions for custom data.
+ *   mxmlSetErrorCallback()  - Set the error message callback.
+ *   mxmlSetWrapMargin()     - Set the wrap margin when saving XML data.
+ *   mxml_add_char()         - Add a character to a buffer, expanding as needed.
+ *   mxml_fd_getc()          - Read a character from a file descriptor.
+ *   mxml_fd_putc()          - Write a character to a file descriptor.
+ *   mxml_fd_read()          - Read a buffer of data from a file descriptor.
+ *   mxml_fd_write()         - Write a buffer of data to a file descriptor.
+ *   mxml_file_getc()        - Get a character from a file.
+ *   mxml_file_putc()        - Write a character to a file.
+ *   mxml_get_entity()       - Get the character corresponding to an entity...
+ *   mxml_load_data()        - Load data into an XML node tree.
+ *   mxml_parse_element()    - Parse an element for any attributes...
+ *   mxml_string_getc()      - Get a character from a string.
+ *   mxml_string_putc()      - Write a character to a string.
+ *   mxml_write_name()       - Write a name string.
+ *   mxml_write_node()       - Save an XML node to a file.
+ *   mxml_write_string()     - Write a string, escaping & and < as needed.
+ *   mxml_write_ws()         - Do whitespace callback...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#ifndef WIN32
+#  include <unistd.h>
+#endif /* !WIN32 */
+#include "mxml-private.h"
+
+
+/*
+ * Character encoding...
+ */
+
+#define ENCODE_UTF8     0               /* UTF-8 */
+#define ENCODE_UTF16BE  1               /* UTF-16 Big-Endian */
+#define ENCODE_UTF16LE  2               /* UTF-16 Little-Endian */
+
+
+/*
+ * Macro to test for a bad XML character...
+ */
+
+#define mxml_bad_char(ch) ((ch) < ' ' && (ch) != '\n' && (ch) != '\r' && (ch) != '\t')
+
+
+/*
+ * Types and structures...
+ */
+
+typedef int (*_mxml_getc_cb_t)(void *, int *);
+typedef int (*_mxml_putc_cb_t)(int, void *);
+
+typedef struct _mxml_fdbuf_s            /**** File descriptor buffer ****/
+{
+  int           fd;                     /* File descriptor */
+  unsigned char *current,               /* Current position in buffer */
+                *end,                   /* End of buffer */
+                buffer[8192];           /* Character buffer */
+} _mxml_fdbuf_t;
+
+
+/*
+ * Local functions...
+ */
+
+static int              mxml_add_char(int ch, char **ptr, char **buffer,
+                                      int *bufsize);
+static int              mxml_fd_getc(void *p, int *encoding);
+static int              mxml_fd_putc(int ch, void *p);
+static int              mxml_fd_read(_mxml_fdbuf_t *buf);
+static int              mxml_fd_write(_mxml_fdbuf_t *buf);
+static int              mxml_file_getc(void *p, int *encoding);
+static int              mxml_file_putc(int ch, void *p);
+static int              mxml_get_entity(mxml_node_t *parent, void *p,
+                                        int *encoding,
+                                        _mxml_getc_cb_t getc_cb);
+static inline int       mxml_isspace(int ch)
+                        {
+                          return (ch == ' ' || ch == '\t' || ch == '\r' ||
+                                  ch == '\n');
+                        }
+static mxml_node_t      *mxml_load_data(mxml_node_t *top, void *p,
+                                        mxml_load_cb_t cb,
+                                        _mxml_getc_cb_t getc_cb,
+                                        mxml_sax_cb_t sax_cb, void *sax_data);
+static int              mxml_parse_element(mxml_node_t *node, void *p,
+                                           int *encoding,
+                                           _mxml_getc_cb_t getc_cb);
+static int              mxml_string_getc(void *p, int *encoding);
+static int              mxml_string_putc(int ch, void *p);
+static int              mxml_write_name(const char *s, void *p,
+                                        _mxml_putc_cb_t putc_cb);
+static int              mxml_write_node(mxml_node_t *node, void *p,
+                                        mxml_save_cb_t cb, int col,
+                                        _mxml_putc_cb_t putc_cb,
+                                        _mxml_global_t *global);
+static int              mxml_write_string(const char *s, void *p,
+                                          _mxml_putc_cb_t putc_cb);
+static int              mxml_write_ws(mxml_node_t *node, void *p, 
+                                      mxml_save_cb_t cb, int ws,
+                                      int col, _mxml_putc_cb_t putc_cb);
+
+
+/*
+ * 'mxmlLoadFd()' - Load a file descriptor into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlLoadFd(mxml_node_t    *top,         /* I - Top node */
+           int            fd,           /* I - File descriptor to read from */
+           mxml_load_cb_t cb)           /* I - Callback function or MXML_NO_CALLBACK */
+{
+  _mxml_fdbuf_t buf;                    /* File descriptor buffer */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer;
+
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, &buf, cb, mxml_fd_getc, MXML_NO_CALLBACK, NULL));
+}
+
+
+/*
+ * 'mxmlLoadFile()' - Load a file into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlLoadFile(mxml_node_t    *top,       /* I - Top node */
+             FILE           *fp,        /* I - File to read from */
+             mxml_load_cb_t cb)         /* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, fp, cb, mxml_file_getc, MXML_NO_CALLBACK, NULL));
+}
+
+
+/*
+ * 'mxmlLoadString()' - Load a string into an XML node tree.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the string has errors. */
+mxmlLoadString(mxml_node_t    *top,     /* I - Top node */
+               const char     *s,       /* I - String to load */
+               mxml_load_cb_t cb)       /* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, (void *)&s, cb, mxml_string_getc, MXML_NO_CALLBACK,
+                         NULL));
+}
+
+
+/*
+ * 'mxmlSaveAllocString()' - Save an XML tree to an allocated string.
+ *
+ * This function returns a pointer to a string containing the textual
+ * representation of the XML node tree.  The string should be freed
+ * using the free() function when you are done with it.  NULL is returned
+ * if the node would produce an empty string or if the string cannot be
+ * allocated.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+char *                                  /* O - Allocated string or NULL */
+mxmlSaveAllocString(
+    mxml_node_t    *node,               /* I - Node to write */
+    mxml_save_cb_t cb)                  /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int   bytes;                          /* Required bytes */
+  char  buffer[8192];                   /* Temporary buffer */
+  char  *s;                             /* Allocated string */
+
+
+ /*
+  * Write the node to the temporary buffer...
+  */
+
+  bytes = mxmlSaveString(node, buffer, sizeof(buffer), cb);
+
+  if (bytes <= 0)
+    return (NULL);
+
+  if (bytes < (int)(sizeof(buffer) - 1))
+  {
+   /*
+    * Node fit inside the buffer, so just duplicate that string and
+    * return...
+    */
+
+    return (strdup(buffer));
+  }
+
+ /*
+  * Allocate a buffer of the required size and save the node to the
+  * new buffer...
+  */
+
+  if ((s = malloc(bytes + 1)) == NULL)
+    return (NULL);
+
+  mxmlSaveString(node, s, bytes + 1, cb);
+
+ /*
+  * Return the allocated string...
+  */
+
+  return (s);
+}
+
+
+/*
+ * 'mxmlSaveFd()' - Save an XML tree to a file descriptor.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int                                     /* O - 0 on success, -1 on error. */
+mxmlSaveFd(mxml_node_t    *node,        /* I - Node to write */
+           int            fd,           /* I - File descriptor to write to */
+           mxml_save_cb_t cb)           /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int           col;                    /* Final column */
+  _mxml_fdbuf_t buf;                    /* File descriptor buffer */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer + sizeof(buf.buffer);
+
+ /*
+  * Write the node...
+  */
+
+  if ((col = mxml_write_node(node, &buf, cb, 0, mxml_fd_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    if (mxml_fd_putc('\n', &buf) < 0)
+      return (-1);
+
+ /*
+  * Flush and return...
+  */
+
+  return (mxml_fd_write(&buf));
+}
+
+
+/*
+ * 'mxmlSaveFile()' - Save an XML tree to a file.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int                                     /* O - 0 on success, -1 on error. */
+mxmlSaveFile(mxml_node_t    *node,      /* I - Node to write */
+             FILE           *fp,        /* I - File to write to */
+             mxml_save_cb_t cb)         /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int   col;                            /* Final column */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Write the node...
+  */
+
+  if ((col = mxml_write_node(node, fp, cb, 0, mxml_file_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    if (putc('\n', fp) < 0)
+      return (-1);
+
+ /*
+  * Return 0 (success)...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSaveString()' - Save an XML node tree to a string.
+ *
+ * This function returns the total number of bytes that would be
+ * required for the string but only copies (bufsize - 1) characters
+ * into the specified buffer.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int                                     /* O - Size of string */
+mxmlSaveString(mxml_node_t    *node,    /* I - Node to write */
+               char           *buffer,  /* I - String buffer */
+               int            bufsize,  /* I - Size of string buffer */
+               mxml_save_cb_t cb)       /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int   col;                            /* Final column */
+  char  *ptr[2];                        /* Pointers for putc_cb */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Write the node...
+  */
+
+  ptr[0] = buffer;
+  ptr[1] = buffer + bufsize;
+
+  if ((col = mxml_write_node(node, ptr, cb, 0, mxml_string_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    mxml_string_putc('\n', ptr);
+
+ /*
+  * Nul-terminate the buffer...
+  */
+
+  if (ptr[0] >= ptr[1])
+    buffer[bufsize - 1] = '\0';
+  else
+    ptr[0][0] = '\0';
+
+ /*
+  * Return the number of characters...
+  */
+
+  return (ptr[0] - buffer);
+}
+
+
+/*
+ * 'mxmlSAXLoadFd()' - Load a file descriptor into an XML node tree
+ *                     using a SAX callback.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlSAXLoadFd(mxml_node_t    *top,      /* I - Top node */
+              int            fd,        /* I - File descriptor to read from */
+              mxml_load_cb_t cb,        /* I - Callback function or MXML_NO_CALLBACK */
+              mxml_sax_cb_t  sax_cb,    /* I - SAX callback or MXML_NO_CALLBACK */
+              void           *sax_data) /* I - SAX user data */
+{
+  _mxml_fdbuf_t buf;                    /* File descriptor buffer */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer;
+
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, &buf, cb, mxml_fd_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSAXLoadFile()' - Load a file into an XML node tree
+ *                       using a SAX callback.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlSAXLoadFile(
+    mxml_node_t    *top,                /* I - Top node */
+    FILE           *fp,                 /* I - File to read from */
+    mxml_load_cb_t cb,                  /* I - Callback function or MXML_NO_CALLBACK */
+    mxml_sax_cb_t  sax_cb,              /* I - SAX callback or MXML_NO_CALLBACK */
+    void           *sax_data)           /* I - SAX user data */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, fp, cb, mxml_file_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSAXLoadString()' - Load a string into an XML node tree
+ *                         using a SAX callback.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the string has errors. */
+mxmlSAXLoadString(
+    mxml_node_t    *top,                /* I - Top node */
+    const char     *s,                  /* I - String to load */
+    mxml_load_cb_t cb,                  /* I - Callback function or MXML_NO_CALLBACK */
+    mxml_sax_cb_t  sax_cb,              /* I - SAX callback or MXML_NO_CALLBACK */
+    void           *sax_data)           /* I - SAX user data */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, (void *)&s, cb, mxml_string_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSetCustomHandlers()' - Set the handling functions for custom data.
+ *
+ * The load function accepts a node pointer and a data string and must
+ * return 0 on success and non-zero on error.
+ *
+ * The save function accepts a node pointer and must return a malloc'd
+ * string on success and NULL on error.
+ * 
+ */
+
+void
+mxmlSetCustomHandlers(
+    mxml_custom_load_cb_t load,         /* I - Load function */
+    mxml_custom_save_cb_t save)         /* I - Save function */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  global->custom_load_cb = load;
+  global->custom_save_cb = save;
+}
+
+
+/*
+ * 'mxmlSetErrorCallback()' - Set the error message callback.
+ */
+
+void
+mxmlSetErrorCallback(mxml_error_cb_t cb)/* I - Error callback function */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  global->error_cb = cb;
+}
+
+
+/*
+ * 'mxmlSetWrapMargin()' - Set the wrap margin when saving XML data.
+ *
+ * Wrapping is disabled when "column" is 0.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+void
+mxmlSetWrapMargin(int column)           /* I - Column for wrapping, 0 to disable wrapping */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  global->wrap = column;
+}
+
+
+/*
+ * 'mxml_add_char()' - Add a character to a buffer, expanding as needed.
+ */
+
+static int                              /* O  - 0 on success, -1 on error */
+mxml_add_char(int  ch,                  /* I  - Character to add */
+              char **bufptr,            /* IO - Current position in buffer */
+              char **buffer,            /* IO - Current buffer */
+              int  *bufsize)            /* IO - Current buffer size */
+{
+  char  *newbuffer;                     /* New buffer value */
+
+
+  if (*bufptr >= (*buffer + *bufsize - 4))
+  {
+   /*
+    * Increase the size of the buffer...
+    */
+
+    if (*bufsize < 1024)
+      (*bufsize) *= 2;
+    else
+      (*bufsize) += 1024;
+
+    if ((newbuffer = realloc(*buffer, *bufsize)) == NULL)
+    {
+      free(*buffer);
+
+      mxml_error("Unable to expand string buffer to %d bytes!", *bufsize);
+
+      return (-1);
+    }
+
+    *bufptr = newbuffer + (*bufptr - *buffer);
+    *buffer = newbuffer;
+  }
+
+  if (ch < 0x80)
+  {
+   /*
+    * Single byte ASCII...
+    */
+
+    *(*bufptr)++ = ch;
+  }
+  else if (ch < 0x800)
+  {
+   /*
+    * Two-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xc0 | (ch >> 6);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+  else if (ch < 0x10000)
+  {
+   /*
+    * Three-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xe0 | (ch >> 12);
+    *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+  else
+  {
+   /*
+    * Four-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xf0 | (ch >> 18);
+    *(*bufptr)++ = 0x80 | ((ch >> 12) & 0x3f);
+    *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_getc()' - Read a character from a file descriptor.
+ */
+
+static int                              /* O  - Character or EOF */
+mxml_fd_getc(void *p,                   /* I  - File descriptor buffer */
+             int  *encoding)            /* IO - Encoding */
+{
+  _mxml_fdbuf_t *buf;                   /* File descriptor buffer */
+  int           ch,                     /* Current character */
+                temp;                   /* Temporary character */
+
+
+ /*
+  * Grab the next character in the buffer...
+  */
+
+  buf = (_mxml_fdbuf_t *)p;
+
+  if (buf->current >= buf->end)
+    if (mxml_fd_read(buf) < 0)
+      return (EOF);
+
+  ch = *(buf->current)++;
+
+  switch (*encoding)
+  {
+    case ENCODE_UTF8 :
+       /*
+        * Got a UTF-8 character; convert UTF-8 to Unicode and return...
+        */
+
+        if (!(ch & 0x80))
+        {
+#if DEBUG > 1
+          printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+
+          return (ch);
+        }
+        else if (ch == 0xfe)
+        {
+         /*
+          * UTF-16 big-endian BOM?
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          ch = *(buf->current)++;
+          
+          if (ch != 0xff)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16BE;
+
+          return (mxml_fd_getc(p, encoding));
+        }
+        else if (ch == 0xff)
+        {
+         /*
+          * UTF-16 little-endian BOM?
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          ch = *(buf->current)++;
+          
+          if (ch != 0xfe)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16LE;
+
+          return (mxml_fd_getc(p, encoding));
+        }
+        else if ((ch & 0xe0) == 0xc0)
+        {
+         /*
+          * Two-byte value...
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+          if (ch < 0x80)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+         /*
+          * Three-byte value...
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x800)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+
+         /*
+          * Ignore (strip) Byte Order Mark (BOM)...
+          */
+
+          if (ch == 0xfeff)
+            return (mxml_fd_getc(p, encoding));
+        }
+        else if ((ch & 0xf8) == 0xf0)
+        {
+         /*
+          * Four-byte value...
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x10000)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else
+          return (EOF);
+        break;
+
+    case ENCODE_UTF16BE :
+       /*
+        * Read UTF-16 big-endian char...
+        */
+
+        if (buf->current >= buf->end)
+          if (mxml_fd_read(buf) < 0)
+            return (EOF);
+
+        temp = *(buf->current)++;
+
+        ch = (ch << 8) | temp;
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          lch = *(buf->current)++;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          lch = (lch << 8) | temp;
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+
+    case ENCODE_UTF16LE :
+       /*
+        * Read UTF-16 little-endian char...
+        */
+
+        if (buf->current >= buf->end)
+          if (mxml_fd_read(buf) < 0)
+            return (EOF);
+
+        temp = *(buf->current)++;
+
+        ch |= (temp << 8);
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          lch = *(buf->current)++;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          lch |= (temp << 8);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+  }
+
+#if DEBUG > 1
+  printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_fd_putc()' - Write a character to a file descriptor.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+mxml_fd_putc(int  ch,                   /* I - Character */
+             void *p)                   /* I - File descriptor buffer */
+{
+  _mxml_fdbuf_t *buf;                   /* File descriptor buffer */
+
+
+ /*
+  * Flush the write buffer as needed...
+  */
+
+  buf = (_mxml_fdbuf_t *)p;
+
+  if (buf->current >= buf->end)
+    if (mxml_fd_write(buf) < 0)
+      return (-1);
+
+  *(buf->current)++ = ch;
+
+ /*
+  * Return successfully...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_read()' - Read a buffer of data from a file descriptor.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+mxml_fd_read(_mxml_fdbuf_t *buf)                /* I - File descriptor buffer */
+{
+  int   bytes;                          /* Bytes read... */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!buf)
+    return (-1);
+
+ /*
+  * Read from the file descriptor...
+  */
+
+  while ((bytes = read(buf->fd, buf->buffer, sizeof(buf->buffer))) < 0)
+#ifdef EINTR
+    if (errno != EAGAIN && errno != EINTR)
+#else
+    if (errno != EAGAIN)
+#endif /* EINTR */
+      return (-1);
+
+  if (bytes == 0)
+    return (-1);
+
+ /*
+  * Update the pointers and return success...
+  */
+
+  buf->current = buf->buffer;
+  buf->end     = buf->buffer + bytes;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_write()' - Write a buffer of data to a file descriptor.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+mxml_fd_write(_mxml_fdbuf_t *buf)       /* I - File descriptor buffer */
+{
+  int           bytes;                  /* Bytes written */
+  unsigned char *ptr;                   /* Pointer into buffer */
+
+
+ /*
+  * Range check...
+  */
+
+  if (!buf)
+    return (-1);
+
+ /*
+  * Return 0 if there is nothing to write...
+  */
+
+  if (buf->current == buf->buffer)
+    return (0);
+
+ /*
+  * Loop until we have written everything...
+  */
+
+  for (ptr = buf->buffer; ptr < buf->current; ptr += bytes)
+    if ((bytes = write(buf->fd, ptr, buf->current - ptr)) < 0)
+      return (-1);
+
+ /*
+  * All done, reset pointers and return success...
+  */
+
+  buf->current = buf->buffer;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_file_getc()' - Get a character from a file.
+ */
+
+static int                              /* O  - Character or EOF */
+mxml_file_getc(void *p,                 /* I  - Pointer to file */
+               int  *encoding)          /* IO - Encoding */
+{
+  int   ch,                             /* Character from file */
+        temp;                           /* Temporary character */
+  FILE  *fp;                            /* Pointer to file */
+
+
+ /*
+  * Read a character from the file and see if it is EOF or ASCII...
+  */
+
+  fp = (FILE *)p;
+  ch = getc(fp);
+
+  if (ch == EOF)
+    return (EOF);
+
+  switch (*encoding)
+  {
+    case ENCODE_UTF8 :
+       /*
+        * Got a UTF-8 character; convert UTF-8 to Unicode and return...
+        */
+
+        if (!(ch & 0x80))
+        {
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+
+#if DEBUG > 1
+          printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          return (ch);
+        }
+        else if (ch == 0xfe)
+        {
+         /*
+          * UTF-16 big-endian BOM?
+          */
+
+          ch = getc(fp);
+          if (ch != 0xff)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16BE;
+
+          return (mxml_file_getc(p, encoding));
+        }
+        else if (ch == 0xff)
+        {
+         /*
+          * UTF-16 little-endian BOM?
+          */
+
+          ch = getc(fp);
+          if (ch != 0xfe)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16LE;
+
+          return (mxml_file_getc(p, encoding));
+        }
+        else if ((ch & 0xe0) == 0xc0)
+        {
+         /*
+          * Two-byte value...
+          */
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+          if (ch < 0x80)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+         /*
+          * Three-byte value...
+          */
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x800)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+
+         /*
+          * Ignore (strip) Byte Order Mark (BOM)...
+          */
+
+          if (ch == 0xfeff)
+            return (mxml_file_getc(p, encoding));
+        }
+        else if ((ch & 0xf8) == 0xf0)
+        {
+         /*
+          * Four-byte value...
+          */
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x10000)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else
+          return (EOF);
+        break;
+
+    case ENCODE_UTF16BE :
+       /*
+        * Read UTF-16 big-endian char...
+        */
+
+        ch = (ch << 8) | getc(fp);
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch = (getc(fp) << 8) | getc(fp);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+
+    case ENCODE_UTF16LE :
+       /*
+        * Read UTF-16 little-endian char...
+        */
+
+        ch |= (getc(fp) << 8);
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch = getc(fp) | (getc(fp) << 8);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+  }
+
+#if DEBUG > 1
+  printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_file_putc()' - Write a character to a file.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_file_putc(int  ch,                 /* I - Character to write */
+               void *p)                 /* I - Pointer to file */
+{
+  return (putc(ch, (FILE *)p) == EOF ? -1 : 0);
+}
+
+
+/*
+ * 'mxml_get_entity()' - Get the character corresponding to an entity...
+ */
+
+static int                              /* O  - Character value or EOF on error */
+mxml_get_entity(mxml_node_t *parent,    /* I  - Parent node */
+                void        *p,         /* I  - Pointer to source */
+                int         *encoding,  /* IO - Character encoding */
+                int         (*getc_cb)(void *, int *))
+                                        /* I  - Get character function */
+{
+  int   ch;                             /* Current character */
+  char  entity[64],                     /* Entity string */
+        *entptr;                        /* Pointer into entity */
+
+
+  entptr = entity;
+
+  while ((ch = (*getc_cb)(p, encoding)) != EOF)
+    if (ch > 126 || (!isalnum(ch) && ch != '#'))
+      break;
+    else if (entptr < (entity + sizeof(entity) - 1))
+      *entptr++ = ch;
+    else
+    {
+      mxml_error("Entity name too long under parent <%s>!",
+                 parent ? parent->value.element.name : "null");
+      break;
+    }
+
+  *entptr = '\0';
+
+  if (ch != ';')
+  {
+    mxml_error("Character entity \"%s\" not terminated under parent <%s>!",
+               entity, parent ? parent->value.element.name : "null");
+    return (EOF);
+  }
+
+  if (entity[0] == '#')
+  {
+    if (entity[1] == 'x')
+      ch = strtol(entity + 2, NULL, 16);
+    else
+      ch = strtol(entity + 1, NULL, 10);
+  }
+  else if ((ch = mxmlEntityGetValue(entity)) < 0)
+    mxml_error("Entity name \"%s;\" not supported under parent <%s>!",
+               entity, parent ? parent->value.element.name : "null");
+
+  if (mxml_bad_char(ch))
+  {
+    mxml_error("Bad control character 0x%02x under parent <%s> not allowed by XML standard!",
+               ch, parent ? parent->value.element.name : "null");
+    return (EOF);
+  }
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_load_data()' - Load data into an XML node tree.
+ */
+
+static mxml_node_t *                    /* O - First node or NULL if the file could not be read. */
+mxml_load_data(
+    mxml_node_t     *top,               /* I - Top node */
+    void            *p,                 /* I - Pointer to data */
+    mxml_load_cb_t  cb,                 /* I - Callback function or MXML_NO_CALLBACK */
+    _mxml_getc_cb_t getc_cb,            /* I - Read function */
+    mxml_sax_cb_t   sax_cb,             /* I - SAX callback or MXML_NO_CALLBACK */
+    void            *sax_data)          /* I - SAX user data */
+{
+  mxml_node_t   *node,                  /* Current node */
+                *first,                 /* First node added */
+                *parent;                /* Current parent node */
+  int           ch,                     /* Character from file */
+                whitespace;             /* Non-zero if whitespace seen */
+  char          *buffer,                /* String buffer */
+                *bufptr;                /* Pointer into buffer */
+  int           bufsize;                /* Size of buffer */
+  mxml_type_t   type;                   /* Current node type */
+  int           encoding;               /* Character encoding */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+  static const char * const types[] =   /* Type strings... */
+                {
+                  "MXML_ELEMENT",       /* XML element with attributes */
+                  "MXML_INTEGER",       /* Integer value */
+                  "MXML_OPAQUE",        /* Opaque string */
+                  "MXML_REAL",          /* Real value */
+                  "MXML_TEXT",          /* Text fragment */
+                  "MXML_CUSTOM"         /* Custom data */
+                };
+
+
+ /*
+  * Read elements and other nodes from the file...
+  */
+
+  if ((buffer = malloc(64)) == NULL)
+  {
+    mxml_error("Unable to allocate string buffer!");
+    return (NULL);
+  }
+
+  bufsize    = 64;
+  bufptr     = buffer;
+  parent     = top;
+  first      = NULL;
+  whitespace = 0;
+  encoding   = ENCODE_UTF8;
+
+  if (cb && parent)
+    type = (*cb)(parent);
+  else
+    type = MXML_TEXT;
+
+  while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+  {
+    if ((ch == '<' ||
+         (mxml_isspace(ch) && type != MXML_OPAQUE && type != MXML_CUSTOM)) &&
+        bufptr > buffer)
+    {
+     /*
+      * Add a new value node...
+      */
+
+      *bufptr = '\0';
+
+      switch (type)
+      {
+        case MXML_INTEGER :
+            node = mxmlNewInteger(parent, strtol(buffer, &bufptr, 0));
+            break;
+
+        case MXML_OPAQUE :
+            node = mxmlNewOpaque(parent, buffer);
+            break;
+
+        case MXML_REAL :
+            node = mxmlNewReal(parent, strtod(buffer, &bufptr));
+            break;
+
+        case MXML_TEXT :
+            node = mxmlNewText(parent, whitespace, buffer);
+            break;
+
+        case MXML_CUSTOM :
+            if (global->custom_load_cb)
+            {
+             /*
+              * Use the callback to fill in the custom data...
+              */
+
+              node = mxmlNewCustom(parent, NULL, NULL);
+
+              if ((*global->custom_load_cb)(node, buffer))
+              {
+                mxml_error("Bad custom value '%s' in parent <%s>!",
+                           buffer, parent ? parent->value.element.name : "null");
+                mxmlDelete(node);
+                node = NULL;
+              }
+              break;
+            }
+
+        default : /* Ignore... */
+            node = NULL;
+            break;
+      }   
+
+      if (*bufptr)
+      {
+       /*
+        * Bad integer/real number value...
+        */
+
+        mxml_error("Bad %s value '%s' in parent <%s>!",
+                   type == MXML_INTEGER ? "integer" : "real", buffer,
+                   parent ? parent->value.element.name : "null");
+        break;
+      }
+
+      bufptr     = buffer;
+      whitespace = mxml_isspace(ch) && type == MXML_TEXT;
+
+      if (!node && type != MXML_IGNORE)
+      {
+       /*
+        * Print error and return...
+        */
+
+        mxml_error("Unable to add value node of type %s to parent <%s>!",
+                   types[type], parent ? parent->value.element.name : "null");
+        goto error;
+      }
+
+      if (sax_cb)
+      {
+        (*sax_cb)(node, MXML_SAX_DATA, sax_data);
+
+        if (!mxmlRelease(node))
+          node = NULL;
+      }
+
+      if (!first && node)
+        first = node;
+    }
+    else if (mxml_isspace(ch) && type == MXML_TEXT)
+      whitespace = 1;
+
+   /*
+    * Add lone whitespace node if we have an element and existing
+    * whitespace...
+    */
+
+    if (ch == '<' && whitespace && type == MXML_TEXT)
+    {
+      if (parent)
+      {
+        node = mxmlNewText(parent, whitespace, "");
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DATA, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (!first && node)
+          first = node;
+      }
+
+      whitespace = 0;
+    }
+
+    if (ch == '<')
+    {
+     /*
+      * Start of open/close tag...
+      */
+
+      bufptr = buffer;
+
+      while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        if (mxml_isspace(ch) || ch == '>' || (ch == '/' && bufptr > buffer))
+          break;
+        else if (ch == '<')
+        {
+          mxml_error("Bare < in element!");
+          goto error;
+        }
+        else if (ch == '&')
+        {
+          if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+            goto error;
+
+          if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+        else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+          goto error;
+        else if (((bufptr - buffer) == 1 && buffer[0] == '?') ||
+                 ((bufptr - buffer) == 3 && !strncmp(buffer, "!--", 3)) ||
+                 ((bufptr - buffer) == 8 && !strncmp(buffer, "![CDATA[", 8)))
+          break;
+
+      *bufptr = '\0';
+
+      if (!strcmp(buffer, "!--"))
+      {
+       /*
+        * Gather rest of comment...
+        */
+
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        {
+          if (ch == '>' && bufptr > (buffer + 4) &&
+              bufptr[-3] != '-' && bufptr[-2] == '-' && bufptr[-1] == '-')
+            break;
+          else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+
+       /*
+        * Error out if we didn't get the whole comment...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in comment node!");
+          goto error;
+        }
+
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Just print error for now...
+          */
+
+          mxml_error("Unable to add comment node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          break;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_COMMENT, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node && !first)
+          first = node;
+      }
+      else if (!strcmp(buffer, "![CDATA["))
+      {
+       /*
+        * Gather CDATA section...
+        */
+
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        {
+          if (ch == '>' && !strncmp(bufptr - 2, "]]", 2))
+            break;
+          else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+
+       /*
+        * Error out if we didn't get the whole comment...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in CDATA node!");
+          goto error;
+        }
+
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Unable to add CDATA node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_CDATA, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node && !first)
+          first = node;
+      }
+      else if (buffer[0] == '?')
+      {
+       /*
+        * Gather rest of processing instruction...
+        */
+
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        {
+          if (ch == '>' && bufptr > buffer && bufptr[-1] == '?')
+            break;
+          else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+
+       /*
+        * Error out if we didn't get the whole processing instruction...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in processing instruction node!");
+          goto error;
+        }
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Unable to add processing instruction node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DIRECTIVE, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node)
+        {
+          if (!first)
+            first = node;
+
+          if (!parent)
+          {
+            parent = node;
+
+            if (cb)
+              type = (*cb)(parent);
+          }
+        }
+      }
+      else if (buffer[0] == '!')
+      {
+       /*
+        * Gather rest of declaration...
+        */
+
+        do
+        {
+          if (ch == '>')
+            break;
+          else
+          {
+            if (ch == '&')
+              if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+                goto error;
+
+            if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+              goto error;
+          }
+        }
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF);
+
+       /*
+        * Error out if we didn't get the whole declaration...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in declaration node!");
+          goto error;
+        }
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Unable to add declaration node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DIRECTIVE, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node)
+        {
+          if (!first)
+            first = node;
+
+          if (!parent)
+          {
+            parent = node;
+
+            if (cb)
+              type = (*cb)(parent);
+          }
+        }
+      }
+      else if (buffer[0] == '/')
+      {
+       /*
+        * Handle close tag...
+        */
+
+        if (!parent || strcmp(buffer + 1, parent->value.element.name))
+        {
+         /*
+          * Close tag doesn't match tree; print an error for now...
+          */
+
+          mxml_error("Mismatched close tag <%s> under parent <%s>!",
+                     buffer, parent ? parent->value.element.name : "(null)");
+          goto error;
+        }
+
+       /*
+        * Keep reading until we see >...
+        */
+
+        while (ch != '>' && ch != EOF)
+          ch = (*getc_cb)(p, &encoding);
+
+        node   = parent;
+        parent = parent->parent;
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_ELEMENT_CLOSE, sax_data);
+
+          if (!mxmlRelease(node) && first == node)
+            first = NULL;
+        }
+
+       /*
+        * Ascend into the parent and set the value type as needed...
+        */
+
+        if (cb && parent)
+          type = (*cb)(parent);
+      }
+      else
+      {
+       /*
+        * Handle open tag...
+        */
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Just print error for now...
+          */
+
+          mxml_error("Unable to add element node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (mxml_isspace(ch))
+        {
+          if ((ch = mxml_parse_element(node, p, &encoding, getc_cb)) == EOF)
+            goto error;
+        }
+        else if (ch == '/')
+        {
+          if ((ch = (*getc_cb)(p, &encoding)) != '>')
+          {
+            mxml_error("Expected > but got '%c' instead for element <%s/>!",
+                       ch, buffer);
+            mxmlDelete(node);
+            goto error;
+          }
+
+          ch = '/';
+        }
+
+        if (sax_cb)
+          (*sax_cb)(node, MXML_SAX_ELEMENT_OPEN, sax_data);
+
+        if (!first)
+          first = node;
+
+        if (ch == EOF)
+          break;
+
+        if (ch != '/')
+        {
+         /*
+          * Descend into this node, setting the value type as needed...
+          */
+
+          parent = node;
+
+          if (cb && parent)
+            type = (*cb)(parent);
+        }
+        else if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_ELEMENT_CLOSE, sax_data);
+
+          if (!mxmlRelease(node) && first == node)
+            first = NULL;
+        }
+      }
+
+      bufptr  = buffer;
+    }
+    else if (ch == '&')
+    {
+     /*
+      * Add character entity to current buffer...
+      */
+
+      if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+        goto error;
+
+      if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+        goto error;
+    }
+    else if (type == MXML_OPAQUE || type == MXML_CUSTOM || !mxml_isspace(ch))
+    {
+     /*
+      * Add character to current buffer...
+      */
+
+      if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+        goto error;
+    }
+  }
+
+ /*
+  * Free the string buffer - we don't need it anymore...
+  */
+
+  free(buffer);
+
+ /*
+  * Find the top element and return it...
+  */
+
+  if (parent)
+  {
+    node = parent;
+
+    while (parent->parent != top && parent->parent)
+      parent = parent->parent;
+
+    if (node != parent)
+    {
+      mxml_error("Missing close tag </%s> under parent <%s>!",
+                 node->value.element.name,
+                 node->parent ? node->parent->value.element.name : "(null)");
+
+      mxmlDelete(first);
+
+      return (NULL);
+    }
+  }
+
+  if (parent)
+    return (parent);
+  else
+    return (first);
+
+ /*
+  * Common error return...
+  */
+
+error:
+
+  mxmlDelete(first);
+
+  free(buffer);
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxml_parse_element()' - Parse an element for any attributes...
+ */
+
+static int                              /* O  - Terminating character */
+mxml_parse_element(
+    mxml_node_t     *node,              /* I  - Element node */
+    void            *p,                 /* I  - Data to read from */
+    int             *encoding,          /* IO - Encoding */
+    _mxml_getc_cb_t getc_cb)            /* I  - Data callback */
+{
+  int   ch,                             /* Current character in file */
+        quote;                          /* Quoting character */
+  char  *name,                          /* Attribute name */
+        *value,                         /* Attribute value */
+        *ptr;                           /* Pointer into name/value */
+  int   namesize,                       /* Size of name string */
+        valsize;                        /* Size of value string */
+
+
+ /*
+  * Initialize the name and value buffers...
+  */
+
+  if ((name = malloc(64)) == NULL)
+  {
+    mxml_error("Unable to allocate memory for name!");
+    return (EOF);
+  }
+
+  namesize = 64;
+
+  if ((value = malloc(64)) == NULL)
+  {
+    free(name);
+    mxml_error("Unable to allocate memory for value!");
+    return (EOF);
+  }
+
+  valsize = 64;
+
+ /*
+  * Loop until we hit a >, /, ?, or EOF...
+  */
+
+  while ((ch = (*getc_cb)(p, encoding)) != EOF)
+  {
+#if DEBUG > 1
+    fprintf(stderr, "parse_element: ch='%c'\n", ch);
+#endif /* DEBUG > 1 */
+
+   /*
+    * Skip leading whitespace...
+    */
+
+    if (mxml_isspace(ch))
+      continue;
+
+   /*
+    * Stop at /, ?, or >...
+    */
+
+    if (ch == '/' || ch == '?')
+    {
+     /*
+      * Grab the > character and print an error if it isn't there...
+      */
+
+      quote = (*getc_cb)(p, encoding);
+
+      if (quote != '>')
+      {
+        mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+                   ch, node->value.element.name, quote);
+        goto error;
+      }
+
+      break;
+    }
+    else if (ch == '<')
+    {
+      mxml_error("Bare < in element %s!", node->value.element.name);
+      goto error;
+    }
+    else if (ch == '>')
+      break;
+
+   /*
+    * Read the attribute name...
+    */
+
+    name[0] = ch;
+    ptr     = name + 1;
+
+    if (ch == '\"' || ch == '\'')
+    {
+     /*
+      * Name is in quotes, so get a quoted string...
+      */
+
+      quote = ch;
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF)
+      {
+        if (ch == '&')
+          if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+            goto error;
+
+        if (mxml_add_char(ch, &ptr, &name, &namesize))
+          goto error;
+
+        if (ch == quote)
+          break;
+      }
+    }
+    else
+    {
+     /*
+      * Grab an normal, non-quoted name...
+      */
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF)
+        if (mxml_isspace(ch) || ch == '=' || ch == '/' || ch == '>' ||
+            ch == '?')
+          break;
+        else
+        {
+          if (ch == '&')
+            if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+              goto error;
+
+          if (mxml_add_char(ch, &ptr, &name, &namesize))
+            goto error;
+        }
+    }
+
+    *ptr = '\0';
+
+    if (mxmlElementGetAttr(node, name))
+      goto error;
+
+    while (ch != EOF && mxml_isspace(ch))
+      ch = (*getc_cb)(p, encoding);
+
+    if (ch == '=')
+    {
+     /*
+      * Read the attribute value...
+      */
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF && mxml_isspace(ch));
+
+      if (ch == EOF)
+      {
+        mxml_error("Missing value for attribute '%s' in element %s!",
+                   name, node->value.element.name);
+        goto error;
+      }
+
+      if (ch == '\'' || ch == '\"')
+      {
+       /*
+        * Read quoted value...
+        */
+
+        quote = ch;
+        ptr   = value;
+
+        while ((ch = (*getc_cb)(p, encoding)) != EOF)
+          if (ch == quote)
+            break;
+          else
+          {
+            if (ch == '&')
+              if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+                goto error;
+              
+            if (mxml_add_char(ch, &ptr, &value, &valsize))
+              goto error;
+          }
+
+        *ptr = '\0';
+      }
+      else
+      {
+       /*
+        * Read unquoted value...
+        */
+
+        value[0] = ch;
+        ptr      = value + 1;
+
+        while ((ch = (*getc_cb)(p, encoding)) != EOF)
+          if (mxml_isspace(ch) || ch == '=' || ch == '/' || ch == '>')
+            break;
+          else
+          {
+            if (ch == '&')
+              if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+                goto error;
+              
+            if (mxml_add_char(ch, &ptr, &value, &valsize))
+              goto error;
+          }
+
+        *ptr = '\0';
+      }
+
+     /*
+      * Set the attribute with the given string value...
+      */
+
+      mxmlElementSetAttr(node, name, value);
+    }
+    else
+    {
+      mxml_error("Missing value for attribute '%s' in element %s!",
+                 name, node->value.element.name);
+      goto error;
+    }
+
+   /*
+    * Check the end character...
+    */
+
+    if (ch == '/' || ch == '?')
+    {
+     /*
+      * Grab the > character and print an error if it isn't there...
+      */
+
+      quote = (*getc_cb)(p, encoding);
+
+      if (quote != '>')
+      {
+        mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+                   ch, node->value.element.name, quote);
+        ch = EOF;
+      }
+
+      break;
+    }
+    else if (ch == '>')
+      break;
+  }
+
+ /*
+  * Free the name and value buffers and return...
+  */
+
+  free(name);
+  free(value);
+
+  return (ch);
+
+ /*
+  * Common error return point...
+  */
+
+error:
+
+  free(name);
+  free(value);
+
+  return (EOF);
+}
+
+
+/*
+ * 'mxml_string_getc()' - Get a character from a string.
+ */
+
+static int                              /* O  - Character or EOF */
+mxml_string_getc(void *p,               /* I  - Pointer to file */
+                 int  *encoding)        /* IO - Encoding */
+{
+  int           ch;                     /* Character */
+  const char    **s;                    /* Pointer to string pointer */
+
+
+  s = (const char **)p;
+
+  if ((ch = (*s)[0] & 255) != 0 || *encoding == ENCODE_UTF16LE)
+  {
+   /*
+    * Got character; convert UTF-8 to integer and return...
+    */
+
+    (*s)++;
+
+    switch (*encoding)
+    {
+      case ENCODE_UTF8 :
+          if (!(ch & 0x80))
+          {
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            if (mxml_bad_char(ch))
+            {
+              mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                         ch);
+              return (EOF);
+            }
+
+            return (ch);
+          }
+          else if (ch == 0xfe)
+          {
+           /*
+            * UTF-16 big-endian BOM?
+            */
+
+            if (((*s)[0] & 255) != 0xff)
+              return (EOF);
+
+            *encoding = ENCODE_UTF16BE;
+            (*s)++;
+
+            return (mxml_string_getc(p, encoding));
+          }
+          else if (ch == 0xff)
+          {
+           /*
+            * UTF-16 little-endian BOM?
+            */
+
+            if (((*s)[0] & 255) != 0xfe)
+              return (EOF);
+
+            *encoding = ENCODE_UTF16LE;
+            (*s)++;
+
+            return (mxml_string_getc(p, encoding));
+          }
+          else if ((ch & 0xe0) == 0xc0)
+          {
+           /*
+            * Two-byte value...
+            */
+
+            if (((*s)[0] & 0xc0) != 0x80)
+              return (EOF);
+
+            ch = ((ch & 0x1f) << 6) | ((*s)[0] & 0x3f);
+
+            (*s)++;
+
+            if (ch < 0x80)
+            {
+              mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+              return (EOF);
+            }
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            return (ch);
+          }
+          else if ((ch & 0xf0) == 0xe0)
+          {
+           /*
+            * Three-byte value...
+            */
+
+            if (((*s)[0] & 0xc0) != 0x80 ||
+                ((*s)[1] & 0xc0) != 0x80)
+              return (EOF);
+
+            ch = ((((ch & 0x0f) << 6) | ((*s)[0] & 0x3f)) << 6) | ((*s)[1] & 0x3f);
+
+            (*s) += 2;
+
+            if (ch < 0x800)
+            {
+              mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+              return (EOF);
+            }
+
+           /*
+            * Ignore (strip) Byte Order Mark (BOM)...
+            */
+
+            if (ch == 0xfeff)
+              return (mxml_string_getc(p, encoding));
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            return (ch);
+          }
+          else if ((ch & 0xf8) == 0xf0)
+          {
+           /*
+            * Four-byte value...
+            */
+
+            if (((*s)[0] & 0xc0) != 0x80 ||
+                ((*s)[1] & 0xc0) != 0x80 ||
+                ((*s)[2] & 0xc0) != 0x80)
+              return (EOF);
+
+            ch = ((((((ch & 0x07) << 6) | ((*s)[0] & 0x3f)) << 6) |
+                   ((*s)[1] & 0x3f)) << 6) | ((*s)[2] & 0x3f);
+
+            (*s) += 3;
+
+            if (ch < 0x10000)
+            {
+              mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+              return (EOF);
+            }
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            return (ch);
+          }
+          else
+            return (EOF);
+
+      case ENCODE_UTF16BE :
+         /*
+          * Read UTF-16 big-endian char...
+          */
+
+          ch = (ch << 8) | ((*s)[0] & 255);
+          (*s) ++;
+
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+          else if (ch >= 0xd800 && ch <= 0xdbff)
+          {
+           /*
+            * Multi-word UTF-16 char...
+            */
+
+            int lch;                    /* Lower word */
+
+
+            if (!(*s)[0])
+              return (EOF);
+
+            lch = (((*s)[0] & 255) << 8) | ((*s)[1] & 255);
+            (*s) += 2;
+
+            if (lch < 0xdc00 || lch >= 0xdfff)
+              return (EOF);
+
+            ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+          }
+
+#if DEBUG > 1
+          printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          return (ch);
+
+      case ENCODE_UTF16LE :
+         /*
+          * Read UTF-16 little-endian char...
+          */
+
+          ch = ch | (((*s)[0] & 255) << 8);
+
+          if (!ch)
+          {
+            (*s) --;
+            return (EOF);
+          }
+
+          (*s) ++;
+
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+          else if (ch >= 0xd800 && ch <= 0xdbff)
+          {
+           /*
+            * Multi-word UTF-16 char...
+            */
+
+            int lch;                    /* Lower word */
+
+
+            if (!(*s)[1])
+              return (EOF);
+
+            lch = (((*s)[1] & 255) << 8) | ((*s)[0] & 255);
+            (*s) += 2;
+
+            if (lch < 0xdc00 || lch >= 0xdfff)
+              return (EOF);
+
+            ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+          }
+
+#if DEBUG > 1
+          printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          return (ch);
+    }
+  }
+
+  return (EOF);
+}
+
+
+/*
+ * 'mxml_string_putc()' - Write a character to a string.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_string_putc(int  ch,               /* I - Character to write */
+                 void *p)               /* I - Pointer to string pointers */
+{
+  char  **pp;                           /* Pointer to string pointers */
+
+
+  pp = (char **)p;
+
+  if (pp[0] < pp[1])
+    pp[0][0] = ch;
+
+  pp[0] ++;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_name()' - Write a name string.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_write_name(const char *s,          /* I - Name to write */
+                void       *p,          /* I - Write pointer */
+                int        (*putc_cb)(int, void *))
+                                        /* I - Write callback */
+{
+  char          quote;                  /* Quote character */
+  const char    *name;                  /* Entity name */
+
+
+  if (*s == '\"' || *s == '\'')
+  {
+   /*
+    * Write a quoted name string...
+    */
+
+    if ((*putc_cb)(*s, p) < 0)
+      return (-1);
+
+    quote = *s++;
+
+    while (*s && *s != quote)
+    {
+      if ((name = mxmlEntityGetName(*s)) != NULL)
+      {
+        if ((*putc_cb)('&', p) < 0)
+          return (-1);
+
+        while (*name)
+        {
+          if ((*putc_cb)(*name, p) < 0)
+            return (-1);
+
+          name ++;
+        }
+
+        if ((*putc_cb)(';', p) < 0)
+          return (-1);
+      }
+      else if ((*putc_cb)(*s, p) < 0)
+        return (-1);
+
+      s ++;
+    }
+
+   /*
+    * Write the end quote...
+    */
+
+    if ((*putc_cb)(quote, p) < 0)
+      return (-1);
+  }
+  else
+  {
+   /*
+    * Write a non-quoted name string...
+    */
+
+    while (*s)
+    {
+      if ((*putc_cb)(*s, p) < 0)
+        return (-1);
+
+      s ++;
+    }
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_node()' - Save an XML node to a file.
+ */
+
+static int                              /* O - Column or -1 on error */
+mxml_write_node(mxml_node_t     *node,  /* I - Node to write */
+                void            *p,     /* I - File to write to */
+                mxml_save_cb_t  cb,     /* I - Whitespace callback */
+                int             col,    /* I - Current column */
+                _mxml_putc_cb_t putc_cb,/* I - Output callback */
+                _mxml_global_t  *global)/* I - Global data */
+{
+  int           i,                      /* Looping var */
+                width;                  /* Width of attr + value */
+  mxml_attr_t   *attr;                  /* Current attribute */
+  char          s[255];                 /* Temporary string */
+
+
+ /*
+  * Print the node value...
+  */
+
+  switch (node->type)
+  {
+    case MXML_ELEMENT :
+        col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_OPEN, col, putc_cb);
+
+        if ((*putc_cb)('<', p) < 0)
+          return (-1);
+        if (node->value.element.name[0] == '?' ||
+            !strncmp(node->value.element.name, "!--", 3) ||
+            !strncmp(node->value.element.name, "![CDATA[", 8))
+        {
+         /*
+          * Comments, CDATA, and processing instructions do not
+          * use character entities.
+          */
+
+          const char    *ptr;           /* Pointer into name */
+
+
+          for (ptr = node->value.element.name; *ptr; ptr ++)
+            if ((*putc_cb)(*ptr, p) < 0)
+              return (-1);
+        }
+        else if (mxml_write_name(node->value.element.name, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(node->value.element.name) + 1;
+
+        for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+             i > 0;
+             i --, attr ++)
+        {
+          width = strlen(attr->name);
+
+          if (attr->value)
+            width += strlen(attr->value) + 3;
+
+          if (global->wrap > 0 && (col + width) > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else
+          {
+            if ((*putc_cb)(' ', p) < 0)
+              return (-1);
+
+            col ++;
+          }
+
+          if (mxml_write_name(attr->name, p, putc_cb) < 0)
+            return (-1);
+
+          if (attr->value)
+          {
+            if ((*putc_cb)('=', p) < 0)
+              return (-1);
+            if ((*putc_cb)('\"', p) < 0)
+              return (-1);
+            if (mxml_write_string(attr->value, p, putc_cb) < 0)
+              return (-1);
+            if ((*putc_cb)('\"', p) < 0)
+              return (-1);
+          }
+
+          col += width;
+        }
+
+        if (node->child)
+        {
+         /*
+          * Write children...
+          */
+
+          mxml_node_t *child;           /* Current child */
+
+
+          if ((*putc_cb)('>', p) < 0)
+            return (-1);
+          else
+            col ++;
+
+          col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+
+          for (child = node->child; child; child = child->next)
+          {
+            if ((col = mxml_write_node(child, p, cb, col, putc_cb, global)) < 0)
+              return (-1);
+          }
+
+         /*
+          * The ? and ! elements are special-cases and have no end tags...
+          */
+
+          if (node->value.element.name[0] != '!' &&
+              node->value.element.name[0] != '?')
+          {
+            col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_CLOSE, col, putc_cb);
+
+            if ((*putc_cb)('<', p) < 0)
+              return (-1);
+            if ((*putc_cb)('/', p) < 0)
+              return (-1);
+            if (mxml_write_string(node->value.element.name, p, putc_cb) < 0)
+              return (-1);
+            if ((*putc_cb)('>', p) < 0)
+              return (-1);
+
+            col += strlen(node->value.element.name) + 3;
+
+            col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_CLOSE, col, putc_cb);
+          }
+        }
+        else if (node->value.element.name[0] == '!' ||
+                 node->value.element.name[0] == '?')
+        {
+         /*
+          * The ? and ! elements are special-cases...
+          */
+
+          if ((*putc_cb)('>', p) < 0)
+            return (-1);
+          else
+            col ++;
+
+          col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+        }
+        else
+        {
+          if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          if ((*putc_cb)('/', p) < 0)
+            return (-1);
+          if ((*putc_cb)('>', p) < 0)
+            return (-1);
+
+          col += 3;
+
+          col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+        }
+        break;
+
+    case MXML_INTEGER :
+        if (node->prev)
+        {
+          if (global->wrap > 0 && col > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          else
+            col ++;
+        }
+
+        sprintf(s, "%d", node->value.integer);
+        if (mxml_write_string(s, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(s);
+        break;
+
+    case MXML_OPAQUE :
+        if (mxml_write_string(node->value.opaque, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(node->value.opaque);
+        break;
+
+    case MXML_REAL :
+        if (node->prev)
+        {
+          if (global->wrap > 0 && col > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          else
+            col ++;
+        }
+
+        sprintf(s, "%f", node->value.real);
+        if (mxml_write_string(s, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(s);
+        break;
+
+    case MXML_TEXT :
+        if (node->value.text.whitespace && col > 0)
+        {
+          if (global->wrap > 0 && col > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          else
+            col ++;
+        }
+
+        if (mxml_write_string(node->value.text.string, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(node->value.text.string);
+        break;
+
+    case MXML_CUSTOM :
+        if (global->custom_save_cb)
+        {
+          char  *data;          /* Custom data string */
+          const char    *newline;       /* Last newline in string */
+
+
+          if ((data = (*global->custom_save_cb)(node)) == NULL)
+            return (-1);
+
+          if (mxml_write_string(data, p, putc_cb) < 0)
+            return (-1);
+
+          if ((newline = strrchr(data, '\n')) == NULL)
+            col += strlen(data);
+          else
+            col = strlen(newline);
+
+          free(data);
+          break;
+        }
+
+    default : /* Should never happen */
+        return (-1);
+  }
+
+  return (col);
+}
+
+
+/*
+ * 'mxml_write_string()' - Write a string, escaping & and < as needed.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_write_string(
+    const char      *s,                 /* I - String to write */
+    void            *p,                 /* I - Write pointer */
+    _mxml_putc_cb_t putc_cb)            /* I - Write callback */
+{
+  const char    *name;                  /* Entity name, if any */
+
+
+  while (*s)
+  {
+    if ((name = mxmlEntityGetName(*s)) != NULL)
+    {
+      if ((*putc_cb)('&', p) < 0)
+        return (-1);
+
+      while (*name)
+      {
+        if ((*putc_cb)(*name, p) < 0)
+          return (-1);
+        name ++;
+      }
+
+      if ((*putc_cb)(';', p) < 0)
+        return (-1);
+    }
+    else if ((*putc_cb)(*s, p) < 0)
+      return (-1);
+
+    s ++;
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_ws()' - Do whitespace callback...
+ */
+
+static int                              /* O - New column */
+mxml_write_ws(mxml_node_t     *node,    /* I - Current node */
+              void            *p,       /* I - Write pointer */
+              mxml_save_cb_t  cb,       /* I - Callback function */
+              int             ws,       /* I - Where value */
+              int             col,      /* I - Current column */
+              _mxml_putc_cb_t putc_cb)  /* I - Write callback */
+{
+  const char    *s;                     /* Whitespace string */
+
+
+  if (cb && (s = (*cb)(node, ws)) != NULL)
+  {
+    while (*s)
+    {
+      if ((*putc_cb)(*s, p) < 0)
+        return (-1);
+      else if (*s == '\n')
+        col = 0;
+      else if (*s == '\t')
+      {
+        col += MXML_TAB;
+        col = col - (col % MXML_TAB);
+      }
+      else
+        col ++;
+
+      s ++;
+    }
+  }
+
+  return (col);
+}
+
+
+/*
+ * End of "$Id: mxml-file.c 438 2011-03-24 05:47:51Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-get.c b/pathologist/src/minixml/mxml-get.c
new file mode 100644
index 0000000..a5356d5
--- /dev/null
+++ b/pathologist/src/minixml/mxml-get.c
@@ -0,0 +1,471 @@
+/*
+ * "$Id: mxml-get.c 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Node get functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlGetCDATA()       - Get the value for a CDATA node.
+ *   mxmlGetCustom()      - Get the value for a custom node.
+ *   mxmlGetElement()     - Get the name for an element node.
+ *   mxmlGetFirstChild()  - Get the first child of an element node.
+ *   mxmlGetInteger()     - Get the integer value from the specified node or its
+ *                          first child.
+ *   mxmlGetLastChild()   - Get the last child of an element node.
+ *   mxmlGetNextSibling() - Get the next node for the current parent.
+ *   mxmlGetOpaque()      - Get an opaque string value for a node or its first
+ *                          child.
+ *   mxmlGetParent()      - Get the parent node.
+ *   mxmlGetPrevSibling() - Get the previous node for the current parent.
+ *   mxmlGetReal()        - Get the real value for a node or its first child.
+ *   mxmlGetText()        - Get the text value for a node or its first child.
+ *   mxmlGetType()        - Get the node type.
+ *   mxmlGetUserData()    - Get the user data pointer for a node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlGetCDATA()' - Get the value for a CDATA node.
+ *
+ * @code NULL@ is returned if the node is not a CDATA element.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - CDATA value or NULL */
+mxmlGetCDATA(mxml_node_t *node)         /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT ||
+      strncmp(node->value.element.name, "![CDATA[", 8))
+    return (NULL);
+
+ /*
+  * Return the text following the CDATA declaration...
+  */
+
+  return (node->value.element.name + 8);
+}
+
+
+/*
+ * 'mxmlGetCustom()' - Get the value for a custom node.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not a custom
+ * value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const void *                            /* O - Custom value or NULL */
+mxmlGetCustom(mxml_node_t *node)        /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_CUSTOM)
+    return (node->value.custom.data);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_CUSTOM)
+    return (node->child->value.custom.data);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlGetElement()' - Get the name for an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - Element name or NULL */
+mxmlGetElement(mxml_node_t *node)       /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the element name...
+  */
+
+  return (node->value.element.name);
+}
+
+
+/*
+ * 'mxmlGetFirstChild()' - Get the first child of an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node or if the node
+ * has no children.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - First child or NULL */
+mxmlGetFirstChild(mxml_node_t *node)    /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the first child node...
+  */
+
+  return (node->child);
+}
+
+
+/*
+ * 'mxmlGetInteger()' - Get the integer value from the specified node or its
+ *                      first child.
+ *
+ * 0 is returned if the node (or its first child) is not an integer value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int                                     /* O - Integer value or 0 */
+mxmlGetInteger(mxml_node_t *node)       /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_INTEGER)
+    return (node->value.integer);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_INTEGER)
+    return (node->child->value.integer);
+  else
+    return (0);
+}
+
+
+/*
+ * 'mxmlGetLastChild()' - Get the last child of an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node or if the node
+ * has no children.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Last child or NULL */
+mxmlGetLastChild(mxml_node_t *node)     /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->last_child);
+}
+
+
+/*
+ * 'mxmlGetNextSibling()' - Get the next node for the current parent.
+ *
+ * @code NULL@ is returned if this is the last child for the current parent.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *
+mxmlGetNextSibling(mxml_node_t *node)   /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->next);
+}
+
+
+/*
+ * 'mxmlGetOpaque()' - Get an opaque string value for a node or its first child.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not an opaque
+ * value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - Opaque string or NULL */
+mxmlGetOpaque(mxml_node_t *node)        /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_OPAQUE)
+    return (node->value.opaque);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_OPAQUE)
+    return (node->child->value.opaque);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlGetParent()' - Get the parent node.
+ *
+ * @code NULL@ is returned for a root node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Parent node or NULL */
+mxmlGetParent(mxml_node_t *node)        /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->parent);
+}
+
+
+/*
+ * 'mxmlGetPrevSibling()' - Get the previous node for the current parent.
+ *
+ * @code NULL@ is returned if this is the first child for the current parent.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Previous node or NULL */
+mxmlGetPrevSibling(mxml_node_t *node)   /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->prev);
+}
+
+
+/*
+ * 'mxmlGetReal()' - Get the real value for a node or its first child.
+ *
+ * 0.0 is returned if the node (or its first child) is not a real value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+double                                  /* O - Real value or 0.0 */
+mxmlGetReal(mxml_node_t *node)          /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0.0);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_REAL)
+    return (node->value.real);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_REAL)
+    return (node->child->value.real);
+  else
+    return (0.0);
+}
+
+
+/*
+ * 'mxmlGetText()' - Get the text value for a node or its first child.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not a text node.
+ * The "whitespace" argument can be NULL.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - Text string or NULL */
+mxmlGetText(mxml_node_t *node,          /* I - Node to get */
+            int         *whitespace)    /* O - 1 if string is preceded by whitespace, 0 otherwise */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+  {
+    if (whitespace)
+      *whitespace = 0;
+
+    return (NULL);
+  }
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_TEXT)
+  {
+    if (whitespace)
+      *whitespace = node->value.text.whitespace;
+
+    return (node->value.text.string);
+  }
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_TEXT)
+  {
+    if (whitespace)
+      *whitespace = node->child->value.text.whitespace;
+
+    return (node->child->value.text.string);
+  }
+  else
+  {
+    if (whitespace)
+      *whitespace = 0;
+
+    return (NULL);
+  }
+}
+
+
+/*
+ * 'mxmlGetType()' - Get the node type.
+ *
+ * @code MXML_IGNORE@ is returned if "node" is @code NULL@.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_type_t                             /* O - Type of node */
+mxmlGetType(mxml_node_t *node)          /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (MXML_IGNORE);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->type);
+}
+
+
+/*
+ * 'mxmlGetUserData()' - Get the user data pointer for a node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+void *                                  /* O - User data pointer */
+mxmlGetUserData(mxml_node_t *node)      /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the user data pointer...
+  */
+
+  return (node->user_data);
+}
+
+
+/*
+ * End of "$Id: mxml-get.c 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-index.c b/pathologist/src/minixml/mxml-index.c
new file mode 100644
index 0000000..b6efc66
--- /dev/null
+++ b/pathologist/src/minixml/mxml-index.c
@@ -0,0 +1,662 @@
+/*
+ * "$Id: mxml-index.c 426 2011-01-01 23:42:17Z mike $"
+ *
+ * Index support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Sort functions...
+ */
+
+static int      index_compare(mxml_index_t *ind, mxml_node_t *first,
+                              mxml_node_t *second);
+static int      index_find(mxml_index_t *ind, const char *element,
+                           const char *value, mxml_node_t *node);
+static void     index_sort(mxml_index_t *ind, int left, int right);
+
+
+/*
+ * 'mxmlIndexDelete()' - Delete an index.
+ */
+
+void
+mxmlIndexDelete(mxml_index_t *ind)      /* I - Index to delete */
+{
+ /*
+  * Range check input..
+  */
+
+  if (!ind)
+    return;
+
+ /*
+  * Free memory...
+  */
+
+  if (ind->attr)
+    free(ind->attr);
+
+  if (ind->alloc_nodes)
+    free(ind->nodes);
+
+  free(ind);
+}
+
+
+/*
+ * 'mxmlIndexEnum()' - Return the next node in the index.
+ *
+ * Nodes are returned in the sorted order of the index.
+ */
+
+mxml_node_t *                           /* O - Next node or NULL if there is none */
+mxmlIndexEnum(mxml_index_t *ind)        /* I - Index to enumerate */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (NULL);
+
+ /*
+  * Return the next node...
+  */
+
+  if (ind->cur_node < ind->num_nodes)
+    return (ind->nodes[ind->cur_node ++]);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexFind()' - Find the next matching node.
+ *
+ * You should call mxmlIndexReset() prior to using this function for
+ * the first time with a particular set of "element" and "value"
+ * strings. Passing NULL for both "element" and "value" is equivalent
+ * to calling mxmlIndexEnum().
+ */
+
+mxml_node_t *                           /* O - Node or NULL if none found */
+mxmlIndexFind(mxml_index_t *ind,        /* I - Index to search */
+              const char   *element,    /* I - Element name to find, if any */
+              const char   *value)      /* I - Attribute value, if any */
+{
+  int           diff,                   /* Difference between names */
+                current,                /* Current entity in search */
+                first,                  /* First entity in search */
+                last;                   /* Last entity in search */
+
+
+#ifdef DEBUG
+  printf("mxmlIndexFind(ind=%p, element=\"%s\", value=\"%s\")\n",
+         ind, element ? element : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!ind || (!ind->attr && value))
+  {
+#ifdef DEBUG
+    puts("    returning NULL...");
+    printf("    ind->attr=\"%s\"\n", ind->attr ? ind->attr : "(null)");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+
+ /*
+  * If both element and value are NULL, just enumerate the nodes in the
+  * index...
+  */
+
+  if (!element && !value)
+    return (mxmlIndexEnum(ind));
+
+ /*
+  * If there are no nodes in the index, return NULL...
+  */
+
+  if (!ind->num_nodes)
+  {
+#ifdef DEBUG
+    puts("    returning NULL...");
+    puts("    no nodes!");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+
+ /*
+  * If cur_node == 0, then find the first matching node...
+  */
+
+  if (ind->cur_node == 0)
+  {
+   /*
+    * Find the first node using a modified binary search algorithm...
+    */
+
+    first = 0;
+    last  = ind->num_nodes - 1;
+
+#ifdef DEBUG
+    printf("    find first time, num_nodes=%d...\n", ind->num_nodes);
+#endif /* DEBUG */
+
+    while ((last - first) > 1)
+    {
+      current = (first + last) / 2;
+
+#ifdef DEBUG
+      printf("    first=%d, last=%d, current=%d\n", first, last, current);
+#endif /* DEBUG */
+
+      if ((diff = index_find(ind, element, value, ind->nodes[current])) == 0)
+      {
+       /*
+        * Found a match, move back to find the first...
+        */
+
+#ifdef DEBUG
+        puts("    match!");
+#endif /* DEBUG */
+
+        while (current > 0 &&
+               !index_find(ind, element, value, ind->nodes[current - 1]))
+          current --;
+
+#ifdef DEBUG
+        printf("    returning first match=%d\n", current);
+#endif /* DEBUG */
+
+       /*
+        * Return the first match and save the index to the next...
+        */
+
+        ind->cur_node = current + 1;
+
+        return (ind->nodes[current]);
+      }
+      else if (diff < 0)
+        last = current;
+      else
+        first = current;
+
+#ifdef DEBUG
+      printf("    diff=%d\n", diff);
+#endif /* DEBUG */
+    }
+
+   /*
+    * If we get this far, then we found exactly 0 or 1 matches...
+    */
+
+    for (current = first; current <= last; current ++)
+      if (!index_find(ind, element, value, ind->nodes[current]))
+      {
+       /*
+        * Found exactly one (or possibly two) match...
+        */
+
+#ifdef DEBUG
+        printf("    returning only match %d...\n", current);
+#endif /* DEBUG */
+
+        ind->cur_node = current + 1;
+
+        return (ind->nodes[current]);
+      }
+
+   /*
+    * No matches...
+    */
+
+    ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+    puts("    returning NULL...");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+  else if (ind->cur_node < ind->num_nodes &&
+           !index_find(ind, element, value, ind->nodes[ind->cur_node]))
+  {
+   /*
+    * Return the next matching node...
+    */
+
+#ifdef DEBUG
+    printf("    returning next match %d...\n", ind->cur_node);
+#endif /* DEBUG */
+
+    return (ind->nodes[ind->cur_node ++]);
+  }
+
+ /*
+  * If we get this far, then we have no matches...
+  */
+
+  ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+  puts("    returning NULL...");
+#endif /* DEBUG */
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexGetCount()' - Get the number of nodes in an index.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int                                     /* I - Number of nodes in index */
+mxmlIndexGetCount(mxml_index_t *ind)    /* I - Index of nodes */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (0);
+
+ /*
+  * Return the number of nodes in the index...
+  */
+
+  return (ind->num_nodes);
+}
+
+
+/*
+ * 'mxmlIndexNew()' - Create a new index.
+ *
+ * The index will contain all nodes that contain the named element and/or
+ * attribute. If both "element" and "attr" are NULL, then the index will
+ * contain a sorted list of the elements in the node tree.  Nodes are
+ * sorted by element name and optionally by attribute value if the "attr"
+ * argument is not NULL.
+ */
+
+mxml_index_t *                          /* O - New index */
+mxmlIndexNew(mxml_node_t *node,         /* I - XML node tree */
+             const char  *element,      /* I - Element to index or NULL for all */
+             const char  *attr)         /* I - Attribute to index or NULL for none */
+{
+  mxml_index_t  *ind;                   /* New index */
+  mxml_node_t   *current,               /* Current node in index */
+                **temp;                 /* Temporary node pointer array */
+
+
+ /*
+  * Range check input...
+  */
+
+#ifdef DEBUG
+  printf("mxmlIndexNew(node=%p, element=\"%s\", attr=\"%s\")\n",
+         node, element ? element : "(null)", attr ? attr : "(null)");
+#endif /* DEBUG */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Create a new index...
+  */
+
+  if ((ind = calloc(1, sizeof(mxml_index_t))) == NULL)
+  {
+    mxml_error("Unable to allocate %d bytes for index - %s",
+               sizeof(mxml_index_t), strerror(errno));
+    return (NULL);
+  }
+
+  if (attr)
+    ind->attr = strdup(attr);
+
+  if (!element && !attr)
+    current = node;
+  else
+    current = mxmlFindElement(node, node, element, attr, NULL, MXML_DESCEND);
+
+  while (current)
+  {
+    if (ind->num_nodes >= ind->alloc_nodes)
+    {
+      if (!ind->alloc_nodes)
+        temp = malloc(64 * sizeof(mxml_node_t *));
+      else
+        temp = realloc(ind->nodes, (ind->alloc_nodes + 64) * sizeof(mxml_node_t *));
+
+      if (!temp)
+      {
+       /*
+        * Unable to allocate memory for the index, so abort...
+        */
+
+        mxml_error("Unable to allocate %d bytes for index: %s",
+                   (ind->alloc_nodes + 64) * sizeof(mxml_node_t *),
+                   strerror(errno));
+
+        mxmlIndexDelete(ind);
+        return (NULL);
+      }
+
+      ind->nodes       = temp;
+      ind->alloc_nodes += 64;
+    }
+
+    ind->nodes[ind->num_nodes ++] = current;
+
+    current = mxmlFindElement(current, node, element, attr, NULL, MXML_DESCEND);
+  }
+
+ /*
+  * Sort nodes based upon the search criteria...
+  */
+
+#ifdef DEBUG
+  {
+    int i;                              /* Looping var */
+
+
+    printf("%d node(s) in index.\n\n", ind->num_nodes);
+
+    if (attr)
+    {
+      printf("Node      Address   Element         %s\n", attr);
+      puts("--------  --------  --------------  ------------------------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %-14.14s  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name,
+               mxmlElementGetAttr(ind->nodes[i], attr));
+    }
+    else
+    {
+      puts("Node      Address   Element");
+      puts("--------  --------  --------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name);
+    }
+
+    putchar('\n');
+  }
+#endif /* DEBUG */
+
+  if (ind->num_nodes > 1)
+    index_sort(ind, 0, ind->num_nodes - 1);
+
+#ifdef DEBUG
+  {
+    int i;                              /* Looping var */
+
+
+    puts("After sorting:\n");
+
+    if (attr)
+    {
+      printf("Node      Address   Element         %s\n", attr);
+      puts("--------  --------  --------------  ------------------------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %-14.14s  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name,
+               mxmlElementGetAttr(ind->nodes[i], attr));
+    }
+    else
+    {
+      puts("Node      Address   Element");
+      puts("--------  --------  --------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name);
+    }
+
+    putchar('\n');
+  }
+#endif /* DEBUG */
+
+ /*
+  * Return the new index...
+  */
+
+  return (ind);
+}
+
+
+/*
+ * 'mxmlIndexReset()' - Reset the enumeration/find pointer in the index and
+ *                      return the first node in the index.
+ *
+ * This function should be called prior to using mxmlIndexEnum() or
+ * mxmlIndexFind() for the first time.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if there is none */
+mxmlIndexReset(mxml_index_t *ind)       /* I - Index to reset */
+{
+#ifdef DEBUG
+  printf("mxmlIndexReset(ind=%p)\n", ind);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (NULL);
+
+ /*
+  * Set the index to the first element...
+  */
+
+  ind->cur_node = 0;
+
+ /*
+  * Return the first node...
+  */
+
+  if (ind->num_nodes)
+    return (ind->nodes[0]);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'index_compare()' - Compare two nodes.
+ */
+
+static int                              /* O - Result of comparison */
+index_compare(mxml_index_t *ind,        /* I - Index */
+              mxml_node_t  *first,      /* I - First node */
+              mxml_node_t  *second)     /* I - Second node */
+{
+  int   diff;                           /* Difference */
+
+
+ /*
+  * Check the element name...
+  */
+
+  if ((diff = strcmp(first->value.element.name,
+                     second->value.element.name)) != 0)
+    return (diff);
+
+ /*
+  * Check the attribute value...
+  */
+
+  if (ind->attr)
+  {
+    if ((diff = strcmp(mxmlElementGetAttr(first, ind->attr),
+                       mxmlElementGetAttr(second, ind->attr))) != 0)
+      return (diff);
+  }
+
+ /*
+  * No difference, return 0...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'index_find()' - Compare a node with index values.
+ */
+
+static int                              /* O - Result of comparison */
+index_find(mxml_index_t *ind,           /* I - Index */
+           const char   *element,       /* I - Element name or NULL */
+           const char   *value,         /* I - Attribute value or NULL */
+           mxml_node_t  *node)          /* I - Node */
+{
+  int   diff;                           /* Difference */
+
+
+ /*
+  * Check the element name...
+  */
+
+  if (element)
+  {
+    if ((diff = strcmp(element, node->value.element.name)) != 0)
+      return (diff);
+  }
+
+ /*
+  * Check the attribute value...
+  */
+
+  if (value)
+  {
+    if ((diff = strcmp(value, mxmlElementGetAttr(node, ind->attr))) != 0)
+      return (diff);
+  }
+
+ /*
+  * No difference, return 0...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'index_sort()' - Sort the nodes in the index...
+ *
+ * This function implements the classic quicksort algorithm...
+ */
+
+static void
+index_sort(mxml_index_t *ind,           /* I - Index to sort */
+           int          left,           /* I - Left node in partition */
+           int          right)          /* I - Right node in partition */
+{
+  mxml_node_t   *pivot,                 /* Pivot node */
+                *temp;                  /* Swap node */
+  int           templ,                  /* Temporary left node */
+                tempr;                  /* Temporary right node */
+
+
+ /*
+  * Loop until we have sorted all the way to the right...
+  */
+
+  do
+  {
+   /*
+    * Sort the pivot in the current partition...
+    */
+
+    pivot = ind->nodes[left];
+
+    for (templ = left, tempr = right; templ < tempr;)
+    {
+     /*
+      * Move left while left node <= pivot node...
+      */
+
+      while ((templ < right) &&
+             index_compare(ind, ind->nodes[templ], pivot) <= 0)
+        templ ++;
+
+     /*
+      * Move right while right node > pivot node...
+      */
+
+      while ((tempr > left) &&
+             index_compare(ind, ind->nodes[tempr], pivot) > 0)
+        tempr --;
+
+     /*
+      * Swap nodes if needed...
+      */
+
+      if (templ < tempr)
+      {
+        temp              = ind->nodes[templ];
+        ind->nodes[templ] = ind->nodes[tempr];
+        ind->nodes[tempr] = temp;
+      }
+    }
+
+   /*
+    * When we get here, the right (tempr) node is the new position for the
+    * pivot node...
+    */
+
+    if (index_compare(ind, pivot, ind->nodes[tempr]) > 0)
+    {
+      ind->nodes[left]  = ind->nodes[tempr];
+      ind->nodes[tempr] = pivot;
+    }
+
+   /*
+    * Recursively sort the left partition as needed...
+    */
+
+    if (left < (tempr - 1))
+      index_sort(ind, left, tempr - 1);
+  }
+  while (right > (left = tempr + 1));
+}
+
+
+/*
+ * End of "$Id: mxml-index.c 426 2011-01-01 23:42:17Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-node.c b/pathologist/src/minixml/mxml-node.c
new file mode 100644
index 0000000..44af759
--- /dev/null
+++ b/pathologist/src/minixml/mxml-node.c
@@ -0,0 +1,807 @@
+/*
+ * "$Id: mxml-node.c 436 2011-01-22 01:02:05Z mike $"
+ *
+ * Node support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlAdd()         - Add a node to a tree.
+ *   mxmlDelete()      - Delete a node and all of its children.
+ *   mxmlGetRefCount() - Get the current reference (use) count for a node.
+ *   mxmlNewCDATA()    - Create a new CDATA node.
+ *   mxmlNewCustom()   - Create a new custom data node.
+ *   mxmlNewElement()  - Create a new element node.
+ *   mxmlNewInteger()  - Create a new integer node.
+ *   mxmlNewOpaque()   - Create a new opaque string.
+ *   mxmlNewReal()     - Create a new real number node.
+ *   mxmlNewText()     - Create a new text fragment node.
+ *   mxmlNewTextf()    - Create a new formatted text fragment node.
+ *   mxmlRemove()      - Remove a node from its parent.
+ *   mxmlNewXML()      - Create a new XML document tree.
+ *   mxmlRelease()     - Release a node.
+ *   mxmlRetain()      - Retain a node.
+ *   mxml_new()        - Create a new node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t      *mxml_new(mxml_node_t *parent, mxml_type_t type);
+
+
+/*
+ * 'mxmlAdd()' - Add a node to a tree.
+ *
+ * Adds the specified node to the parent. If the child argument is not
+ * NULL, puts the new node before or after the specified child depending
+ * on the value of the where argument. If the child argument is NULL,
+ * puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
+ * or at the end of the child list (MXML_ADD_AFTER). The constant
+ * MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.
+ */
+
+void
+mxmlAdd(mxml_node_t *parent,            /* I - Parent node */
+        int         where,              /* I - Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER */
+        mxml_node_t *child,             /* I - Child node for where or MXML_ADD_TO_PARENT */
+        mxml_node_t *node)              /* I - Node to add */
+{
+#ifdef DEBUG
+  fprintf(stderr, "mxmlAdd(parent=%p, where=%d, child=%p, node=%p)\n", parent,
+          where, child, node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!parent || !node)
+    return;
+
+#if DEBUG > 1
+  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);
+  if (parent)
+  {
+    fprintf(stderr, "    BEFORE: parent->child=%p\n", parent->child);
+    fprintf(stderr, "    BEFORE: parent->last_child=%p\n", parent->last_child);
+    fprintf(stderr, "    BEFORE: parent->prev=%p\n", parent->prev);
+    fprintf(stderr, "    BEFORE: parent->next=%p\n", parent->next);
+  }
+#endif /* DEBUG > 1 */
+
+ /*
+  * Remove the node from any existing parent...
+  */
+
+  if (node->parent)
+    mxmlRemove(node);
+
+ /*
+  * Reset pointers...
+  */
+
+  node->parent = parent;
+
+  switch (where)
+  {
+    case MXML_ADD_BEFORE :
+        if (!child || child == parent->child || child->parent != parent)
+        {
+         /*
+          * Insert as first node under parent...
+          */
+
+          node->next = parent->child;
+
+          if (parent->child)
+            parent->child->prev = node;
+          else
+            parent->last_child = node;
+
+          parent->child = node;
+        }
+        else
+        {
+         /*
+          * Insert node before this child...
+          */
+
+          node->next = child;
+          node->prev = child->prev;
+
+          if (child->prev)
+            child->prev->next = node;
+          else
+            parent->child = node;
+
+          child->prev = node;
+        }
+        break;
+
+    case MXML_ADD_AFTER :
+        if (!child || child == parent->last_child || child->parent != parent)
+        {
+         /*
+          * Insert as last node under parent...
+          */
+
+          node->parent = parent;
+          node->prev   = parent->last_child;
+
+          if (parent->last_child)
+            parent->last_child->next = node;
+          else
+            parent->child = node;
+
+          parent->last_child = node;
+        }
+        else
+        {
+         /*
+          * Insert node after this child...
+          */
+
+          node->prev = child;
+          node->next = child->next;
+
+          if (child->next)
+            child->next->prev = node;
+          else
+            parent->last_child = node;
+
+          child->next = node;
+        }
+        break;
+  }
+
+#if DEBUG > 1
+  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);
+  if (parent)
+  {
+    fprintf(stderr, "    AFTER: parent->child=%p\n", parent->child);
+    fprintf(stderr, "    AFTER: parent->last_child=%p\n", parent->last_child);
+    fprintf(stderr, "    AFTER: parent->prev=%p\n", parent->prev);
+    fprintf(stderr, "    AFTER: parent->next=%p\n", parent->next);
+  }
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlDelete()' - Delete a node and all of its children.
+ *
+ * If the specified node has a parent, this function first removes the
+ * node from its parent using the mxmlRemove() function.
+ */
+
+void
+mxmlDelete(mxml_node_t *node)           /* I - Node to delete */
+{
+  int   i;                              /* Looping var */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlDelete(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return;
+
+ /*
+  * Remove the node from its parent, if any...
+  */
+
+  mxmlRemove(node);
+
+ /*
+  * Delete children...
+  */
+
+  while (node->child)
+    mxmlDelete(node->child);
+
+ /*
+  * Now delete any node data...
+  */
+
+  switch (node->type)
+  {
+    case MXML_ELEMENT :
+        if (node->value.element.name)
+          free(node->value.element.name);
+
+        if (node->value.element.num_attrs)
+        {
+          for (i = 0; i < node->value.element.num_attrs; i ++)
+          {
+            if (node->value.element.attrs[i].name)
+              free(node->value.element.attrs[i].name);
+            if (node->value.element.attrs[i].value)
+              free(node->value.element.attrs[i].value);
+          }
+
+          free(node->value.element.attrs);
+        }
+        break;
+    case MXML_INTEGER :
+       /* Nothing to do */
+        break;
+    case MXML_OPAQUE :
+        if (node->value.opaque)
+          free(node->value.opaque);
+        break;
+    case MXML_REAL :
+       /* Nothing to do */
+        break;
+    case MXML_TEXT :
+        if (node->value.text.string)
+          free(node->value.text.string);
+        break;
+    case MXML_CUSTOM :
+        if (node->value.custom.data &&
+            node->value.custom.destroy)
+          (*(node->value.custom.destroy))(node->value.custom.data);
+        break;
+    default :
+        break;
+  }
+
+ /*
+  * Free this node...
+  */
+
+  free(node);
+}
+
+
+/*
+ * 'mxmlGetRefCount()' - Get the current reference (use) count for a node.
+ *
+ * The initial reference count of new nodes is 1. Use the @link mxmlRetain@
+ * and @link mxmlRelease@ functions to increment and decrement a node's
+ * reference count.
+ *
+ * @since Mini-XML 2.7@.
+ */
+
+int                                     /* O - Reference count */
+mxmlGetRefCount(mxml_node_t *node)      /* I - Node */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0);
+
+ /*
+  * Return the reference count...
+  */
+
+  return (node->ref_count);
+}
+
+
+/*
+ * 'mxmlNewCDATA()' - Create a new CDATA node.
+ *
+ * The new CDATA node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * CDATA node has no parent. The data string must be nul-terminated and
+ * is copied into the new node. CDATA nodes use the MXML_ELEMENT type.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewCDATA(mxml_node_t *parent,       /* I - Parent node or MXML_NO_PARENT */
+             const char  *data)         /* I - Data string */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewCDATA(parent=%p, data=\"%s\")\n",
+          parent, data ? data : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!data)
+    return (NULL);
+
+ /*
+  * Create the node and set the name value...
+  */
+
+  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+    node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewCustom()' - Create a new custom data node.
+ *
+ * The new custom node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent. NULL can be passed when the data in the
+ * node is not dynamically allocated or is separately managed.
+ *
+ * @since Mini-XML 2.1@
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewCustom(
+    mxml_node_t              *parent,   /* I - Parent node or MXML_NO_PARENT */
+    void                     *data,     /* I - Pointer to data */
+    mxml_custom_destroy_cb_t destroy)   /* I - Function to destroy data */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewCustom(parent=%p, data=%p, destroy=%p)\n", parent,
+          data, destroy);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the value...
+  */
+
+  if ((node = mxml_new(parent, MXML_CUSTOM)) != NULL)
+  {
+    node->value.custom.data    = data;
+    node->value.custom.destroy = destroy;
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewElement()' - Create a new element node.
+ *
+ * The new element node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewElement(mxml_node_t *parent,     /* I - Parent node or MXML_NO_PARENT */
+               const char  *name)       /* I - Name of element */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewElement(parent=%p, name=\"%s\")\n", parent,
+          name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!name)
+    return (NULL);
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+    node->value.element.name = strdup(name);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewInteger()' - Create a new integer node.
+ *
+ * The new integer node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * integer node has no parent.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewInteger(mxml_node_t *parent,     /* I - Parent node or MXML_NO_PARENT */
+               int         integer)     /* I - Integer value */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewInteger(parent=%p, integer=%d)\n", parent, integer);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_INTEGER)) != NULL)
+    node->value.integer = integer;
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewOpaque()' - Create a new opaque string.
+ *
+ * The new opaque node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * opaque node has no parent. The opaque string must be nul-terminated and
+ * is copied into the new node.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewOpaque(mxml_node_t *parent,      /* I - Parent node or MXML_NO_PARENT */
+              const char  *opaque)      /* I - Opaque string */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewOpaque(parent=%p, opaque=\"%s\")\n", parent,
+          opaque ? opaque : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!opaque)
+    return (NULL);
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_OPAQUE)) != NULL)
+    node->value.opaque = strdup(opaque);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewReal()' - Create a new real number node.
+ *
+ * The new real number node is added to the end of the specified parent's
+ * child list. The constant MXML_NO_PARENT can be used to specify that
+ * the new real number node has no parent.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewReal(mxml_node_t *parent,        /* I - Parent node or MXML_NO_PARENT */
+            double      real)           /* I - Real number value */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewReal(parent=%p, real=%g)\n", parent, real);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_REAL)) != NULL)
+    node->value.real = real;
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewText()' - Create a new text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The text
+ * string must be nul-terminated and is copied into the new node.  
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewText(mxml_node_t *parent,        /* I - Parent node or MXML_NO_PARENT */
+            int         whitespace,     /* I - 1 = leading whitespace, 0 = no whitespace */
+            const char  *string)        /* I - String */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewText(parent=%p, whitespace=%d, string=\"%s\")\n",
+          parent, whitespace, string ? string : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!string)
+    return (NULL);
+
+ /*
+  * Create the node and set the text value...
+  */
+
+  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+  {
+    node->value.text.whitespace = whitespace;
+    node->value.text.string     = strdup(string);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewTextf()' - Create a new formatted text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The format
+ * string must be nul-terminated and is formatted into the new node.  
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewTextf(mxml_node_t *parent,       /* I - Parent node or MXML_NO_PARENT */
+             int         whitespace,    /* I - 1 = leading whitespace, 0 = no whitespace */
+             const char  *format,       /* I - Printf-style frmat string */
+             ...)                       /* I - Additional args as needed */
+{
+  mxml_node_t   *node;                  /* New node */
+  va_list       ap;                     /* Pointer to arguments */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewTextf(parent=%p, whitespace=%d, format=\"%s\", ...)\n",
+          parent, whitespace, format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!format)
+    return (NULL);
+
+ /*
+  * Create the node and set the text value...
+  */
+
+  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+  {
+    va_start(ap, format);
+
+    node->value.text.whitespace = whitespace;
+    node->value.text.string     = _mxml_vstrdupf(format, ap);
+
+    va_end(ap);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlRemove()' - Remove a node from its parent.
+ *
+ * Does not free memory used by the node - use mxmlDelete() for that.
+ * This function does nothing if the node has no parent.
+ */
+
+void
+mxmlRemove(mxml_node_t *node)           /* I - Node to remove */
+{
+#ifdef DEBUG
+  fprintf(stderr, "mxmlRemove(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || !node->parent)
+    return;
+
+ /*
+  * Remove from parent...
+  */
+
+#if DEBUG > 1
+  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);
+  if (node->parent)
+  {
+    fprintf(stderr, "    BEFORE: node->parent->child=%p\n", node->parent->child);
+    fprintf(stderr, "    BEFORE: node->parent->last_child=%p\n", node->parent->last_child);
+  }
+  fprintf(stderr, "    BEFORE: node->child=%p\n", node->child);
+  fprintf(stderr, "    BEFORE: node->last_child=%p\n", node->last_child);
+  fprintf(stderr, "    BEFORE: node->prev=%p\n", node->prev);
+  fprintf(stderr, "    BEFORE: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+
+  if (node->prev)
+    node->prev->next = node->next;
+  else
+    node->parent->child = node->next;
+
+  if (node->next)
+    node->next->prev = node->prev;
+  else
+    node->parent->last_child = node->prev;
+
+  node->parent = NULL;
+  node->prev   = NULL;
+  node->next   = NULL;
+
+#if DEBUG > 1
+  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);
+  if (node->parent)
+  {
+    fprintf(stderr, "    AFTER: node->parent->child=%p\n", node->parent->child);
+    fprintf(stderr, "    AFTER: node->parent->last_child=%p\n", node->parent->last_child);
+  }
+  fprintf(stderr, "    AFTER: node->child=%p\n", node->child);
+  fprintf(stderr, "    AFTER: node->last_child=%p\n", node->last_child);
+  fprintf(stderr, "    AFTER: node->prev=%p\n", node->prev);
+  fprintf(stderr, "    AFTER: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlNewXML()' - Create a new XML document tree.
+ *
+ * The "version" argument specifies the version number to put in the
+ * ?xml element node. If NULL, version 1.0 is assumed.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - New ?xml node */
+mxmlNewXML(const char *version)         /* I - Version number to use */
+{
+  char  element[1024];                  /* Element text */
+
+
+  snprintf(element, sizeof(element), "?xml version=\"%s\" encoding=\"utf-8\"?",
+           version ? version : "1.0");
+
+  return (mxmlNewElement(NULL, element));
+}
+
+
+/*
+ * 'mxmlRelease()' - Release a node.
+ *
+ * When the reference count reaches zero, the node (and any children)
+ * is deleted via mxmlDelete().
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int                                     /* O - New reference count */
+mxmlRelease(mxml_node_t *node)          /* I - Node */
+{
+  if (node)
+  {
+    if ((-- node->ref_count) <= 0)
+    {
+      mxmlDelete(node);
+      return (0);
+    }
+    else
+      return (node->ref_count);
+  }
+  else
+    return (-1);
+}
+
+
+/*
+ * 'mxmlRetain()' - Retain a node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int                                     /* O - New reference count */
+mxmlRetain(mxml_node_t *node)           /* I - Node */
+{
+  if (node)
+    return (++ node->ref_count);
+  else
+    return (-1);
+}
+
+
+/*
+ * 'mxml_new()' - Create a new node.
+ */
+
+static mxml_node_t *                    /* O - New node */
+mxml_new(mxml_node_t *parent,           /* I - Parent node */
+         mxml_type_t type)              /* I - Node type */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#if DEBUG > 1
+  fprintf(stderr, "mxml_new(parent=%p, type=%d)\n", parent, type);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Allocate memory for the node...
+  */
+
+  if ((node = calloc(1, sizeof(mxml_node_t))) == NULL)
+  {
+#if DEBUG > 1
+    fputs("    returning NULL\n", stderr);
+#endif /* DEBUG > 1 */
+
+    return (NULL);
+  }
+
+#if DEBUG > 1
+  fprintf(stderr, "    returning %p\n", node);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Set the node type...
+  */
+
+  node->type      = type;
+  node->ref_count = 1;
+
+ /*
+  * Add to the parent if present...
+  */
+
+  if (parent)
+    mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+
+ /*
+  * Return the new node...
+  */
+
+  return (node);
+}
+
+
+/*
+ * End of "$Id: mxml-node.c 436 2011-01-22 01:02:05Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-private.c b/pathologist/src/minixml/mxml-private.c
new file mode 100644
index 0000000..72f3e23
--- /dev/null
+++ b/pathologist/src/minixml/mxml-private.c
@@ -0,0 +1,331 @@
+/*
+ * "$Id: mxml-private.c 422 2010-11-07 22:55:11Z mike $"
+ *
+ * Private functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxml_error()      - Display an error message.
+ *   mxml_integer_cb() - Default callback for integer values.
+ *   mxml_opaque_cb()  - Default callback for opaque values.
+ *   mxml_real_cb()    - Default callback for real number values.
+ *   _mxml_global()    - Get global data.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "mxml-private.h"
+
+
+/*
+ * Some crazy people think that unloading a shared object is a good or safe
+ * thing to do.  Unfortunately, most objects are simply *not* safe to unload
+ * and bad things *will* happen.
+ *
+ * The following mess of conditional code allows us to provide a destructor
+ * function in Mini-XML for our thread-global storage so that it can possibly
+ * be unloaded safely, although since there is no standard way to do so I
+ * can't even provide any guarantees that you can do it safely on all platforms.
+ *
+ * This code currently supports AIX, HP-UX, Linux, Mac OS X, Solaris, and
+ * Windows.  It might work on the BSDs and IRIX, but I haven't tested that.
+ */
+
+#if defined(__sun) || defined(_AIX)
+#  pragma fini(_mxml_fini)
+#  define _MXML_FINI _mxml_fini
+#elif defined(__hpux)
+#  pragma FINI _mxml_fini
+#  define _MXML_FINI _mxml_fini
+#elif defined(__GNUC__) /* Linux and Mac OS X */
+#  define _MXML_FINI __attribute((destructor)) _mxml_fini
+#else
+#  define _MXML_FINI _fini
+#endif /* __sun */
+
+
+/*
+ * 'mxml_error()' - Display an error message.
+ */
+
+void
+mxml_error(const char *format,          /* I - Printf-style format string */
+           ...)                         /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Pointer to arguments */
+  char          s[1024];                /* Message string */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!format)
+    return;
+
+ /*
+  * Format the error message string...
+  */
+
+  va_start(ap, format);
+
+  vsnprintf(s, sizeof(s), format, ap);
+
+  va_end(ap);
+
+ /*
+  * And then display the error message...
+  */
+
+  if (global->error_cb)
+    (*global->error_cb)(s);
+  else
+    fprintf(stderr, "mxml: %s\n", s);
+}
+
+
+/*
+ * 'mxml_ignore_cb()' - Default callback for ignored values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_ignore_cb(mxml_node_t *node)       /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_IGNORE);
+}
+
+
+/*
+ * 'mxml_integer_cb()' - Default callback for integer values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_integer_cb(mxml_node_t *node)      /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_INTEGER);
+}
+
+
+/*
+ * 'mxml_opaque_cb()' - Default callback for opaque values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_opaque_cb(mxml_node_t *node)       /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_OPAQUE);
+}
+
+
+/*
+ * 'mxml_real_cb()' - Default callback for real number values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_real_cb(mxml_node_t *node)         /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_REAL);
+}
+
+
+#ifdef HAVE_PTHREAD_H                   /**** POSIX threading ****/
+#  include <pthread.h>
+
+static pthread_key_t    _mxml_key = -1; /* Thread local storage key */
+static pthread_once_t   _mxml_key_once = PTHREAD_ONCE_INIT;
+                                        /* One-time initialization object */
+static void             _mxml_init(void);
+static void             _mxml_destructor(void *g);
+
+
+/*
+ * '_mxml_destructor()' - Free memory used for globals...
+ */
+
+static void
+_mxml_destructor(void *g)               /* I - Global data */
+{
+  free(g);
+}
+
+
+/*
+ * '_mxml_fini()' - Clean up when unloaded.
+ */
+
+static void
+_MXML_FINI(void)
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  if (_mxml_key != -1)
+  {
+    if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) != NULL)
+      _mxml_destructor(global);
+
+    pthread_key_delete(_mxml_key);
+    _mxml_key = -1;
+  }
+}
+
+
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *                        /* O - Global data */
+_mxml_global(void)
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  pthread_once(&_mxml_key_once, _mxml_init);
+
+  if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) == NULL)
+  {
+    global = (_mxml_global_t *)calloc(1, sizeof(_mxml_global_t));
+    pthread_setspecific(_mxml_key, global);
+
+    global->num_entity_cbs = 1;
+    global->entity_cbs[0]  = _mxml_entity_cb;
+    global->wrap           = 72;
+  }
+
+  return (global);
+}
+
+
+/*
+ * '_mxml_init()' - Initialize global data...
+ */
+
+static void
+_mxml_init(void)
+{
+  pthread_key_create(&_mxml_key, _mxml_destructor);
+}
+
+
+#elif defined(WIN32) && defined(MXML1_EXPORTS) /**** WIN32 threading ****/
+#  include <windows.h>
+
+static DWORD _mxml_tls_index;           /* Index for global storage */
+
+
+/*
+ * 'DllMain()' - Main entry for library.
+ */
+ 
+BOOL WINAPI                             /* O - Success/failure */
+DllMain(HINSTANCE hinst,                /* I - DLL module handle */
+        DWORD     reason,               /* I - Reason */
+        LPVOID    reserved)             /* I - Unused */
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  (void)hinst;
+  (void)reserved;
+
+  switch (reason) 
+  { 
+    case DLL_PROCESS_ATTACH :           /* Called on library initialization */
+        if ((_mxml_tls_index = TlsAlloc()) == TLS_OUT_OF_INDEXES) 
+          return (FALSE); 
+        break; 
+
+    case DLL_THREAD_DETACH :            /* Called when a thread terminates */
+        if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) != NULL)
+          free(global);
+        break; 
+
+    case DLL_PROCESS_DETACH :           /* Called when library is unloaded */
+        if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) != NULL)
+          free(global);
+
+        TlsFree(_mxml_tls_index); 
+        break; 
+
+    default: 
+        break; 
+  } 
+
+  return (TRUE);
+}
+
+
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *                        /* O - Global data */
+_mxml_global(void)
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) == NULL)
+  {
+    global = (_mxml_global_t *)calloc(1, sizeof(_mxml_global_t));
+
+    global->num_entity_cbs = 1;
+    global->entity_cbs[0]  = _mxml_entity_cb;
+    global->wrap           = 72;
+
+    TlsSetValue(_mxml_tls_index, (LPVOID)global); 
+  }
+
+  return (global);
+}
+
+
+#else                                   /**** No threading ****/
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *                        /* O - Global data */
+_mxml_global(void)
+{
+  static _mxml_global_t global =        /* Global data */
+  {
+    NULL,                               /* error_cb */
+    1,                                  /* num_entity_cbs */
+    { _mxml_entity_cb },                /* entity_cbs */
+    72,                                 /* wrap */
+    NULL,                               /* custom_load_cb */
+    NULL                                /* custom_save_cb */
+  };
+
+
+  return (&global);
+}
+#endif /* HAVE_PTHREAD_H */
+
+
+/*
+ * End of "$Id: mxml-private.c 422 2010-11-07 22:55:11Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-private.h b/pathologist/src/minixml/mxml-private.h
new file mode 100644
index 0000000..8789e6c
--- /dev/null
+++ b/pathologist/src/minixml/mxml-private.h
@@ -0,0 +1,50 @@
+/*
+ * "$Id: mxml-private.h 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Private definitions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Global, per-thread data...
+ */
+
+typedef struct _mxml_global_s
+{
+  void  (*error_cb)(const char *);
+  int   num_entity_cbs;
+  int   (*entity_cbs[100])(const char *name);
+  int   wrap;
+  mxml_custom_load_cb_t custom_load_cb;
+  mxml_custom_save_cb_t custom_save_cb;
+} _mxml_global_t;
+
+
+/*
+ * Functions...
+ */
+
+extern _mxml_global_t   *_mxml_global(void);
+extern int              _mxml_entity_cb(const char *name);
+
+
+/*
+ * End of "$Id: mxml-private.h 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-search.c b/pathologist/src/minixml/mxml-search.c
new file mode 100644
index 0000000..f975af1
--- /dev/null
+++ b/pathologist/src/minixml/mxml-search.c
@@ -0,0 +1,287 @@
+/*
+ * "$Id: mxml-search.c 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Search/navigation functions for Mini-XML, a small XML-like file
+ * parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlFindElement() - Find the named element.
+ *   mxmlFindValue()   - Find a value with the given path.
+ *   mxmlWalkNext()    - Walk to the next logical node in the tree.
+ *   mxmlWalkPrev()    - Walk to the previous logical node in the tree.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlFindElement()' - Find the named element.
+ *
+ * The search is constrained by the name, attribute name, and value; any
+ * NULL names or values are treated as wildcards, so different kinds of
+ * searches can be implemented by looking for all elements of a given name
+ * or all elements with a specific attribute. The descend argument determines
+ * whether the search descends into child nodes; normally you will use
+ * MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
+ * additional direct descendents of the node. The top node argument
+ * constrains the search to a particular node's children.
+ */
+
+mxml_node_t *                           /* O - Element node or NULL */
+mxmlFindElement(mxml_node_t *node,      /* I - Current node */
+                mxml_node_t *top,       /* I - Top node */
+                const char  *name,      /* I - Element name or NULL for any */
+                const char  *attr,      /* I - Attribute name, or NULL for none */
+                const char  *value,     /* I - Attribute value, or NULL for any */
+                int         descend)    /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  const char    *temp;                  /* Current attribute value */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || !top || (!attr && value))
+    return (NULL);
+
+ /*
+  * Start with the next node...
+  */
+
+  node = mxmlWalkNext(node, top, descend);
+
+ /*
+  * Loop until we find a matching element...
+  */
+
+  while (node != NULL)
+  {
+   /*
+    * See if this node matches...
+    */
+
+    if (node->type == MXML_ELEMENT &&
+        node->value.element.name &&
+        (!name || !strcmp(node->value.element.name, name)))
+    {
+     /*
+      * See if we need to check for an attribute...
+      */
+
+      if (!attr)
+        return (node);                  /* No attribute search, return it... */
+
+     /*
+      * Check for the attribute...
+      */
+
+      if ((temp = mxmlElementGetAttr(node, attr)) != NULL)
+      {
+       /*
+        * OK, we have the attribute, does it match?
+        */
+
+        if (!value || !strcmp(value, temp))
+          return (node);                /* Yes, return it... */
+      }
+    }
+
+   /*
+    * No match, move on to the next node...
+    */
+
+    if (descend == MXML_DESCEND)
+      node = mxmlWalkNext(node, top, MXML_DESCEND);
+    else
+      node = node->next;
+  }
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlFindPath()' - Find a node with the given path.
+ *
+ * The "path" is a slash-separated list of element names. The name "*" is
+ * considered a wildcard for one or more levels of elements.  For example,
+ * "foo/one/two", "bar/two/one", "*\/one", and so forth.
+ *
+ * The first child node of the found node is returned if the given node has
+ * children and the first child is a value node.
+ * 
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Found node or NULL */
+mxmlFindPath(mxml_node_t *top,          /* I - Top node */
+             const char  *path)         /* I - Path to element */
+{
+  mxml_node_t   *node;                  /* Current node */
+  char          element[256];           /* Current element name */
+  const char    *pathsep;               /* Separator in path */
+  int           descend;                /* mxmlFindElement option */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!top || !path || !*path)
+    return (NULL);
+
+ /*
+  * Search each element in the path...
+  */
+
+  node = top;
+  while (*path)
+  {
+   /*
+    * Handle wildcards...
+    */
+
+    if (!strncmp(path, "*/", 2))
+    {
+      path += 2;
+      descend = MXML_DESCEND;
+    }
+    else
+      descend = MXML_DESCEND_FIRST;
+
+   /*
+    * Get the next element in the path...
+    */
+
+    if ((pathsep = strchr(path, '/')) == NULL)
+      pathsep = path + strlen(path);
+
+    if (pathsep == path || (pathsep - path) >= sizeof(element))
+      return (NULL);
+
+    memcpy(element, path, pathsep - path);
+    element[pathsep - path] = '\0';
+
+    if (*pathsep)
+      path = pathsep + 1;
+    else
+      path = pathsep;
+
+   /*
+    * Search for the element...
+    */
+
+    if ((node = mxmlFindElement(node, node, element, NULL, NULL,
+                                descend)) == NULL)
+      return (NULL);
+  }
+
+ /*
+  * If we get this far, return the node or its first child...
+  */
+
+  if (node->child && node->child->type != MXML_ELEMENT)
+    return (node->child);
+  else
+    return (node);
+}
+
+
+/*
+ * 'mxmlWalkNext()' - Walk to the next logical node in the tree.
+ *
+ * The descend argument controls whether the first child is considered
+ * to be the next node. The top node argument constrains the walk to
+ * the node's children.
+ */
+
+mxml_node_t *                           /* O - Next node or NULL */
+mxmlWalkNext(mxml_node_t *node,         /* I - Current node */
+             mxml_node_t *top,          /* I - Top node */
+             int         descend)       /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  if (!node)
+    return (NULL);
+  else if (node->child && descend)
+    return (node->child);
+  else if (node == top)
+    return (NULL);
+  else if (node->next)
+    return (node->next);
+  else if (node->parent && node->parent != top)
+  {
+    node = node->parent;
+
+    while (!node->next)
+      if (node->parent == top || !node->parent)
+        return (NULL);
+      else
+        node = node->parent;
+
+    return (node->next);
+  }
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlWalkPrev()' - Walk to the previous logical node in the tree.
+ *
+ * The descend argument controls whether the previous node's last child
+ * is considered to be the previous node. The top node argument constrains
+ * the walk to the node's children.
+ */
+
+mxml_node_t *                           /* O - Previous node or NULL */
+mxmlWalkPrev(mxml_node_t *node,         /* I - Current node */
+             mxml_node_t *top,          /* I - Top node */
+             int         descend)       /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  if (!node || node == top)
+    return (NULL);
+  else if (node->prev)
+  {
+    if (node->prev->last_child && descend)
+    {
+     /*
+      * Find the last child under the previous node...
+      */
+
+      node = node->prev->last_child;
+
+      while (node->last_child)
+        node = node->last_child;
+
+      return (node);
+    }
+    else
+      return (node->prev);
+  }
+  else if (node->parent != top)
+    return (node->parent);
+  else
+    return (NULL);
+}
+
+
+/*
+ * End of "$Id: mxml-search.c 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-set.c b/pathologist/src/minixml/mxml-set.c
new file mode 100644
index 0000000..b0bd527
--- /dev/null
+++ b/pathologist/src/minixml/mxml-set.c
@@ -0,0 +1,349 @@
+/*
+ * "$Id: mxml-set.c 441 2011-12-09 23:49:00Z mike $"
+ *
+ * Node set functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlSetCDATA()    - Set the element name of a CDATA node.
+ *   mxmlSetCustom()   - Set the data and destructor of a custom data node.
+ *   mxmlSetElement()  - Set the name of an element node.
+ *   mxmlSetInteger()  - Set the value of an integer node.
+ *   mxmlSetOpaque()   - Set the value of an opaque node.
+ *   mxmlSetReal()     - Set the value of a real number node.
+ *   mxmlSetText()     - Set the value of a text node.
+ *   mxmlSetTextf()    - Set the value of a text node to a formatted string.
+ *   mxmlSetUserData() - Set the user data pointer for a node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlSetCDATA()' - Set the element name of a CDATA node.
+ *
+ * The node is not changed if it (or its first child) is not a CDATA element node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetCDATA(mxml_node_t *node,         /* I - Node to set */
+             const char  *data)         /* I - New data string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      strncmp(node->value.element.name, "![CDATA[", 8) &&
+      node->child && node->child->type == MXML_ELEMENT &&
+      !strncmp(node->child->value.element.name, "![CDATA[", 8))
+    node = node->child;
+
+  if (!node || node->type != MXML_ELEMENT || !data ||
+      strncmp(node->value.element.name, "![CDATA[", 8))
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.element.name)
+    free(node->value.element.name);
+
+  node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetCustom()' - Set the data and destructor of a custom data node.
+ *
+ * The node is not changed if it (or its first child) is not a custom node.
+ *
+ * @since Mini-XML 2.1@
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetCustom(
+    mxml_node_t              *node,     /* I - Node to set */
+    void                     *data,     /* I - New data pointer */
+    mxml_custom_destroy_cb_t destroy)   /* I - New destructor function */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_CUSTOM)
+    node = node->child;
+
+  if (!node || node->type != MXML_CUSTOM)
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.custom.data && node->value.custom.destroy)
+    (*(node->value.custom.destroy))(node->value.custom.data);
+
+  node->value.custom.data    = data;
+  node->value.custom.destroy = destroy;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetElement()' - Set the name of an element node.
+ *
+ * The node is not changed if it is not an element node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetElement(mxml_node_t *node,       /* I - Node to set */
+               const char  *name)       /* I - New name string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.element.name)
+    free(node->value.element.name);
+
+  node->value.element.name = strdup(name);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetInteger()' - Set the value of an integer node.
+ *
+ * The node is not changed if it (or its first child) is not an integer node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetInteger(mxml_node_t *node,       /* I - Node to set */
+               int         integer)     /* I - Integer value */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_INTEGER)
+    node = node->child;
+
+  if (!node || node->type != MXML_INTEGER)
+    return (-1);
+
+ /*
+  * Set the new value and return...
+  */
+
+  node->value.integer = integer;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetOpaque()' - Set the value of an opaque node.
+ *
+ * The node is not changed if it (or its first child) is not an opaque node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetOpaque(mxml_node_t *node,        /* I - Node to set */
+              const char  *opaque)      /* I - Opaque string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_OPAQUE)
+    node = node->child;
+
+  if (!node || node->type != MXML_OPAQUE || !opaque)
+    return (-1);
+
+ /*
+  * Free any old opaque value and set the new value...
+  */
+
+  if (node->value.opaque)
+    free(node->value.opaque);
+
+  node->value.opaque = strdup(opaque);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetReal()' - Set the value of a real number node.
+ *
+ * The node is not changed if it (or its first child) is not a real number node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetReal(mxml_node_t *node,          /* I - Node to set */
+            double      real)           /* I - Real number value */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_REAL)
+    node = node->child;
+
+  if (!node || node->type != MXML_REAL)
+    return (-1);
+
+ /*
+  * Set the new value and return...
+  */
+
+  node->value.real = real;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetText()' - Set the value of a text node.
+ *
+ * The node is not changed if it (or its first child) is not a text node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetText(mxml_node_t *node,          /* I - Node to set */
+            int         whitespace,     /* I - 1 = leading whitespace, 0 = no whitespace */
+            const char  *string)        /* I - String */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_TEXT)
+    node = node->child;
+
+  if (!node || node->type != MXML_TEXT || !string)
+    return (-1);
+
+ /*
+  * Free any old string value and set the new value...
+  */
+
+  if (node->value.text.string)
+    free(node->value.text.string);
+
+  node->value.text.whitespace = whitespace;
+  node->value.text.string     = strdup(string);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetTextf()' - Set the value of a text node to a formatted string.
+ *
+ * The node is not changed if it (or its first child) is not a text node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetTextf(mxml_node_t *node,         /* I - Node to set */
+             int         whitespace,    /* I - 1 = leading whitespace, 0 = no whitespace */
+             const char  *format,       /* I - Printf-style format string */
+             ...)                       /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Pointer to arguments */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_TEXT)
+    node = node->child;
+
+  if (!node || node->type != MXML_TEXT || !format)
+    return (-1);
+
+ /*
+  * Free any old string value and set the new value...
+  */
+
+  if (node->value.text.string)
+    free(node->value.text.string);
+
+  va_start(ap, format);
+
+  node->value.text.whitespace = whitespace;
+  node->value.text.string     = _mxml_strdupf(format, ap);
+
+  va_end(ap);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetUserData()' - Set the user data pointer for a node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetUserData(mxml_node_t *node,      /* I - Node to set */
+                void        *data)      /* I - User data pointer */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (-1);
+
+ /*
+  * Set the user data pointer and return...
+  */
+
+  node->user_data = data;
+  return (0);
+}
+
+
+/*
+ * End of "$Id: mxml-set.c 441 2011-12-09 23:49:00Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-string.c b/pathologist/src/minixml/mxml-string.c
new file mode 100644
index 0000000..6be4252
--- /dev/null
+++ b/pathologist/src/minixml/mxml-string.c
@@ -0,0 +1,476 @@
+/*
+ * "$Id: mxml-string.c 424 2010-12-25 16:21:50Z mike $"
+ *
+ * String functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   _mxml_snprintf()  - Format a string.
+ *   _mxml_strdup()    - Duplicate a string.
+ *   _mxml_strdupf()   - Format and duplicate a string.
+ *   _mxml_vsnprintf() - Format a string into a fixed size buffer.
+ *   _mxml_vstrdupf()  - Format and duplicate a string.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+
+
+/*
+ * The va_copy macro is part of C99, but many compilers don't implement it.
+ * Provide a "direct assignment" implmentation when va_copy isn't defined...
+ */
+
+#ifndef va_copy
+#  ifdef __va_copy
+#    define va_copy(dst,src) __va_copy(dst,src)
+#  else
+#    define va_copy(dst,src) memcpy(&dst, &src, sizeof(va_list))
+#  endif /* __va_copy */
+#endif /* va_copy */
+
+
+#ifndef HAVE_SNPRINTF
+/*
+ * '_mxml_snprintf()' - Format a string.
+ */
+
+int                                     /* O - Number of bytes formatted */
+_mxml_snprintf(char       *buffer,      /* I - Output buffer */
+               size_t     bufsize,      /* I - Size of output buffer */
+               const char *format,      /* I - Printf-style format string */
+               ...)                     /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Argument list */
+  int           bytes;                  /* Number of bytes formatted */
+
+
+  va_start(ap, format);
+  bytes = vsnprintf(buffer, bufsize, format, ap);
+  va_end(ap);
+
+  return (bytes);
+}
+#endif /* !HAVE_SNPRINTF */
+
+
+/*
+ * '_mxml_strdup()' - Duplicate a string.
+ */
+
+#ifndef HAVE_STRDUP
+char *                                  /* O - New string pointer */
+_mxml_strdup(const char *s)             /* I - String to duplicate */
+{
+  char  *t;                             /* New string pointer */
+
+
+  if (s == NULL)
+    return (NULL);
+
+  if ((t = malloc(strlen(s) + 1)) == NULL)
+    return (NULL);
+
+  return (strcpy(t, s));
+}
+#endif /* !HAVE_STRDUP */
+
+
+/*
+ * '_mxml_strdupf()' - Format and duplicate a string.
+ */
+
+char *                                  /* O - New string pointer */
+_mxml_strdupf(const char *format,       /* I - Printf-style format string */
+              ...)                      /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Pointer to additional arguments */
+  char          *s;                     /* Pointer to formatted string */
+
+
+ /*
+  * Get a pointer to the additional arguments, format the string,
+  * and return it...
+  */
+
+  va_start(ap, format);
+  s = _mxml_vstrdupf(format, ap);
+  va_end(ap);
+
+  return (s);
+}
+
+
+#ifndef HAVE_VSNPRINTF
+/*
+ * '_mxml_vsnprintf()' - Format a string into a fixed size buffer.
+ */
+
+int                                     /* O - Number of bytes formatted */
+_mxml_vsnprintf(char       *buffer,     /* O - Output buffer */
+                size_t     bufsize,     /* O - Size of output buffer */
+                const char *format,     /* I - Printf-style format string */
+                va_list    ap)          /* I - Pointer to additional arguments */
+{
+  char          *bufptr,                /* Pointer to position in buffer */
+                *bufend,                /* Pointer to end of buffer */
+                sign,                   /* Sign of format width */
+                size,                   /* Size character (h, l, L) */
+                type;                   /* Format type character */
+  int           width,                  /* Width of field */
+                prec;                   /* Number of characters of precision */
+  char          tformat[100],           /* Temporary format string for sprintf() */
+                *tptr,                  /* Pointer into temporary format */
+                temp[1024];             /* Buffer for formatted numbers */
+  char          *s;                     /* Pointer to string */
+  int           slen;                   /* Length of string */
+  int           bytes;                  /* Total number of bytes needed */
+
+
+ /*
+  * Loop through the format string, formatting as needed...
+  */
+
+  bufptr = buffer;
+  bufend = buffer + bufsize - 1;
+  bytes  = 0;
+
+  while (*format)
+  {
+    if (*format == '%')
+    {
+      tptr = tformat;
+      *tptr++ = *format++;
+
+      if (*format == '%')
+      {
+        if (bufptr && bufptr < bufend) *bufptr++ = *format;
+        bytes ++;
+        format ++;
+        continue;
+      }
+      else if (strchr(" -+#\'", *format))
+      {
+        *tptr++ = *format;
+        sign = *format++;
+      }
+      else
+        sign = 0;
+
+      if (*format == '*')
+      {
+       /*
+        * Get width from argument...
+        */
+
+        format ++;
+        width = va_arg(ap, int);
+
+        snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", width);
+        tptr += strlen(tptr);
+      }
+      else
+      {
+        width = 0;
+
+        while (isdigit(*format & 255))
+        {
+          if (tptr < (tformat + sizeof(tformat) - 1))
+            *tptr++ = *format;
+
+          width = width * 10 + *format++ - '0';
+        }
+      }
+
+      if (*format == '.')
+      {
+        if (tptr < (tformat + sizeof(tformat) - 1))
+          *tptr++ = *format;
+
+        format ++;
+
+        if (*format == '*')
+        {
+         /*
+          * Get precision from argument...
+          */
+
+          format ++;
+          prec = va_arg(ap, int);
+
+          snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", prec);
+          tptr += strlen(tptr);
+        }
+        else
+        {
+          prec = 0;
+
+          while (isdigit(*format & 255))
+          {
+            if (tptr < (tformat + sizeof(tformat) - 1))
+              *tptr++ = *format;
+
+            prec = prec * 10 + *format++ - '0';
+          }
+        }
+      }
+      else
+        prec = -1;
+
+      if (*format == 'l' && format[1] == 'l')
+      {
+        size = 'L';
+
+        if (tptr < (tformat + sizeof(tformat) - 2))
+        {
+          *tptr++ = 'l';
+          *tptr++ = 'l';
+        }
+
+        format += 2;
+      }
+      else if (*format == 'h' || *format == 'l' || *format == 'L')
+      {
+        if (tptr < (tformat + sizeof(tformat) - 1))
+          *tptr++ = *format;
+
+        size = *format++;
+      }
+
+      if (!*format)
+        break;
+
+      if (tptr < (tformat + sizeof(tformat) - 1))
+        *tptr++ = *format;
+
+      type  = *format++;
+      *tptr = '\0';
+
+      switch (type)
+      {
+        case 'E' : /* Floating point formats */
+        case 'G' :
+        case 'e' :
+        case 'f' :
+        case 'g' :
+            if ((width + 2) > sizeof(temp))
+              break;
+
+            sprintf(temp, tformat, va_arg(ap, double));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+            {
+              if ((bufptr + strlen(temp)) > bufend)
+              {
+                strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+                bufptr = bufend;
+              }
+              else
+              {
+                strcpy(bufptr, temp);
+                bufptr += strlen(temp);
+              }
+            }
+            break;
+
+        case 'B' : /* Integer formats */
+        case 'X' :
+        case 'b' :
+        case 'd' :
+        case 'i' :
+        case 'o' :
+        case 'u' :
+        case 'x' :
+            if ((width + 2) > sizeof(temp))
+              break;
+
+#ifdef HAVE_LONG_LONG
+            if (size == 'L')
+              sprintf(temp, tformat, va_arg(ap, long long));
+            else
+#endif /* HAVE_LONG_LONG */
+            sprintf(temp, tformat, va_arg(ap, int));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+            {
+              if ((bufptr + strlen(temp)) > bufend)
+              {
+                strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+                bufptr = bufend;
+              }
+              else
+              {
+                strcpy(bufptr, temp);
+                bufptr += strlen(temp);
+              }
+            }
+            break;
+
+        case 'p' : /* Pointer value */
+            if ((width + 2) > sizeof(temp))
+              break;
+
+            sprintf(temp, tformat, va_arg(ap, void *));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+            {
+              if ((bufptr + strlen(temp)) > bufend)
+              {
+                strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+                bufptr = bufend;
+              }
+              else
+              {
+                strcpy(bufptr, temp);
+                bufptr += strlen(temp);
+              }
+            }
+            break;
+
+        case 'c' : /* Character or character array */
+            bytes += width;
+
+            if (bufptr)
+            {
+              if (width <= 1)
+                *bufptr++ = va_arg(ap, int);
+              else
+              {
+                if ((bufptr + width) > bufend)
+                  width = bufend - bufptr;
+
+                memcpy(bufptr, va_arg(ap, char *), (size_t)width);
+                bufptr += width;
+              }
+            }
+            break;
+
+        case 's' : /* String */
+            if ((s = va_arg(ap, char *)) == NULL)
+              s = "(null)";
+
+            slen = strlen(s);
+            if (slen > width && prec != width)
+              width = slen;
+
+            bytes += width;
+
+            if (bufptr)
+            {
+              if ((bufptr + width) > bufend)
+                width = bufend - bufptr;
+
+              if (slen > width)
+                slen = width;
+
+              if (sign == '-')
+              {
+                strncpy(bufptr, s, (size_t)slen);
+                memset(bufptr + slen, ' ', (size_t)(width - slen));
+              }
+              else
+              {
+                memset(bufptr, ' ', (size_t)(width - slen));
+                strncpy(bufptr + width - slen, s, (size_t)slen);
+              }
+
+              bufptr += width;
+            }
+            break;
+
+        case 'n' : /* Output number of chars so far */
+            *(va_arg(ap, int *)) = bytes;
+            break;
+      }
+    }
+    else
+    {
+      bytes ++;
+
+      if (bufptr && bufptr < bufend)
+        *bufptr++ = *format;
+
+      format ++;
+    }
+  }
+
+ /*
+  * Nul-terminate the string and return the number of characters needed.
+  */
+
+  *bufptr = '\0';
+
+  return (bytes);
+}
+#endif /* !HAVE_VSNPRINTF */
+
+
+/*
+ * '_mxml_vstrdupf()' - Format and duplicate a string.
+ */
+
+char *                                  /* O - New string pointer */
+_mxml_vstrdupf(const char *format,      /* I - Printf-style format string */
+               va_list    ap)           /* I - Pointer to additional arguments */
+{
+  int           bytes;                  /* Number of bytes required */
+  char          *buffer,                /* String buffer */
+                temp[256];              /* Small buffer for first vsnprintf */
+  va_list       apcopy;                 /* Copy of argument list */
+
+
+ /*
+  * First format with a tiny buffer; this will tell us how many bytes are
+  * needed...
+  */
+
+  va_copy(apcopy, ap);
+  bytes = vsnprintf(temp, sizeof(temp), format, apcopy);
+
+  if (bytes < sizeof(temp))
+  {
+   /*
+    * Hey, the formatted string fits in the tiny buffer, so just dup that...
+    */
+
+    return (strdup(temp));
+  }
+
+ /*
+  * Allocate memory for the whole thing and reformat to the new, larger
+  * buffer...
+  */
+
+  if ((buffer = calloc(1, bytes + 1)) != NULL)
+    vsnprintf(buffer, bytes + 1, format, ap);
+
+ /*
+  * Return the new string...
+  */
+
+  return (buffer);
+}
+
+
+/*
+ * End of "$Id: mxml-string.c 424 2010-12-25 16:21:50Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxmldoc.c b/pathologist/src/minixml/mxmldoc.c
new file mode 100644
index 0000000..28316ee
--- /dev/null
+++ b/pathologist/src/minixml/mxmldoc.c
@@ -0,0 +1,5809 @@
+/*#define DEBUG 1*/
+/*
+ * "$Id: mxmldoc.c 440 2011-08-11 18:51:26Z mike $"
+ *
+ * Documentation generator using Mini-XML, a small XML-like file parsing
+ * library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   main()              - Main entry for test program.
+ *   add_variable()      - Add a variable or argument.
+ *   find_public()       - Find a public function, type, etc.
+ *   get_comment_info()  - Get info from comment.
+ *   get_text()          - Get the text for a node.
+ *   load_cb()           - Set the type of child nodes.
+ *   new_documentation() - Create a new documentation tree.
+ *   remove_directory()  - Remove a directory.
+ *   safe_strcpy()       - Copy a string allowing for overlapping strings.
+ *   scan_file()         - Scan a source file.
+ *   sort_node()         - Insert a node sorted into a tree.
+ *   update_comment()    - Update a comment node.
+ *   usage()             - Show program usage...
+ *   write_description() - Write the description text.
+ *   write_element()     - Write an element's text nodes.
+ *   write_file()        - Copy a file to the output.
+ *   write_function()    - Write documentation for a function.
+ *   write_html()        - Write HTML documentation.
+ *   write_html_head()   - Write the standard HTML header.
+ *   write_man()         - Write manpage documentation.
+ *   write_scu()         - Write a structure, class, or union.
+ *   write_string()      - Write a string, quoting HTML special chars as needed.
+ *   write_toc()         - Write a table-of-contents.
+ *   write_tokens()      - Write <Token> nodes for all APIs.
+ *   ws_cb()             - Whitespace callback for saving.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+#include <time.h>
+#include <sys/stat.h>
+#ifndef WIN32
+#  include <dirent.h>
+#  include <unistd.h>
+#endif /* !WIN32 */
+#ifdef __APPLE__
+#  include <spawn.h>
+#  include <sys/wait.h>
+extern char **environ;
+#endif /* __APPLE__ */
+
+
+/*
+ * This program scans source and header files and produces public API
+ * documentation for code that conforms to the CUPS Configuration
+ * Management Plan (CMP) coding standards.  Please see the following web
+ * page for details:
+ *
+ *     http://www.cups.org/cmp.html
+ *
+ * Using Mini-XML, this program creates and maintains an XML representation
+ * of the public API code documentation which can then be converted to HTML
+ * as desired.  The following is a poor-man's schema:
+ *
+ * <?xml version="1.0"?>
+ * <mxmldoc xmlns="http://www.easysw.com"
+ *  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ *  xsi:schemaLocation="http://www.minixml.org/mxmldoc.xsd">
+ *
+ *   <namespace name="">                        [optional...]
+ *     <constant name="">
+ *       <description>descriptive text</description>
+ *     </constant>
+ *
+ *     <enumeration name="">
+ *       <description>descriptive text</description>
+ *       <constant name="">...</constant>
+ *     </enumeration>
+ *
+ *     <typedef name="">
+ *       <description>descriptive text</description>
+ *       <type>type string</type>
+ *     </typedef>
+ *
+ *     <function name="" scope="">
+ *       <description>descriptive text</description>
+ *       <argument name="" direction="I|O|IO" default="">
+ *         <description>descriptive text</description>
+ *         <type>type string</type>
+ *       </argument>
+ *       <returnvalue>
+ *         <description>descriptive text</description>
+ *         <type>type string</type>
+ *       </returnvalue>
+ *       <seealso>function names separated by spaces</seealso>
+ *     </function>
+ *
+ *     <variable name="" scope="">
+ *       <description>descriptive text</description>
+ *       <type>type string</type>
+ *     </variable>
+ *
+ *     <struct name="">
+ *       <description>descriptive text</description>
+ *       <variable name="">...</variable>
+ *       <function name="">...</function>
+ *     </struct>
+ *
+ *     <union name="">
+ *       <description>descriptive text</description>
+ *       <variable name="">...</variable>
+ *     </union>
+ *
+ *     <class name="" parent="">
+ *       <description>descriptive text</description>
+ *       <class name="">...</class>
+ *       <enumeration name="">...</enumeration>
+ *       <function name="">...</function>
+ *       <struct name="">...</struct>
+ *       <variable name="">...</variable>
+ *     </class>
+ *   </namespace>
+ * </mxmldoc>
+ */
+
+
+/*
+ * Basic states for file parser...
+ */
+
+#define STATE_NONE              0       /* No state - whitespace, etc. */
+#define STATE_PREPROCESSOR      1       /* Preprocessor directive */
+#define STATE_C_COMMENT         2       /* Inside a C comment */
+#define STATE_CXX_COMMENT       3       /* Inside a C++ comment */
+#define STATE_STRING            4       /* Inside a string constant */
+#define STATE_CHARACTER         5       /* Inside a character constant */
+#define STATE_IDENTIFIER        6       /* Inside a keyword/identifier */
+
+
+/*
+ * Output modes...
+ */
+
+#define OUTPUT_NONE             0       /* No output */
+#define OUTPUT_HTML             1       /* Output HTML */
+#define OUTPUT_XML              2       /* Output XML */
+#define OUTPUT_MAN              3       /* Output nroff/man */
+#define OUTPUT_TOKENS           4       /* Output docset Tokens.xml file */
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t      *add_variable(mxml_node_t *parent, const char *name,
+                                      mxml_node_t *type);
+static mxml_node_t      *find_public(mxml_node_t *node, mxml_node_t *top,
+                                     const char *name);
+static char             *get_comment_info(mxml_node_t *description);
+static char             *get_text(mxml_node_t *node, char *buffer, int buflen);
+static mxml_type_t      load_cb(mxml_node_t *node);
+static mxml_node_t      *new_documentation(mxml_node_t **mxmldoc);
+static int              remove_directory(const char *path);
+static void             safe_strcpy(char *dst, const char *src);
+static int              scan_file(const char *filename, FILE *fp,
+                                  mxml_node_t *doc);
+static void             sort_node(mxml_node_t *tree, mxml_node_t *func);
+static void             update_comment(mxml_node_t *parent,
+                                       mxml_node_t *comment);
+static void             usage(const char *option);
+static void             write_description(FILE *out, mxml_node_t *description,
+                                          const char *element, int summary);
+static void             write_element(FILE *out, mxml_node_t *doc,
+                                      mxml_node_t *element, int mode);
+static void             write_file(FILE *out, const char *file);
+static void             write_function(FILE *out, mxml_node_t *doc,
+                                       mxml_node_t *function, int level);
+static void             write_html(const char *section, const char *title,
+                                   const char *footerfile,
+                                   const char *headerfile,
+                                   const char *introfile, const char *cssfile,
+                                   const char *framefile,
+                                   const char *docset, const char *docversion,
+                                   const char *feedname, const char *feedurl,
+                                   mxml_node_t *doc);
+static void             write_html_head(FILE *out, const char *section,
+                                        const char *title, const char *cssfile);
+static void             write_man(const char *man_name, const char *section,
+                                  const char *title, const char *headerfile,
+                                  const char *footerfile, const char *introfile,
+                                  mxml_node_t *doc);
+static void             write_scu(FILE *out, mxml_node_t *doc,
+                                  mxml_node_t *scut);
+static void             write_string(FILE *out, const char *s, int mode);
+static void             write_toc(FILE *out, mxml_node_t *doc,
+                                  const char *introfile, const char *target,
+                                  int xml);
+static void             write_tokens(FILE *out, mxml_node_t *doc,
+                                     const char *path);
+static const char       *ws_cb(mxml_node_t *node, int where);
+
+
+/*
+ * 'main()' - Main entry for test program.
+ */
+
+int                                     /* O - Exit status */
+main(int  argc,                         /* I - Number of command-line args */
+     char *argv[])                      /* I - Command-line args */
+{
+  int           i;                      /* Looping var */
+  int           len;                    /* Length of argument */
+  FILE          *fp;                    /* File to read */
+  mxml_node_t   *doc;                   /* XML documentation tree */
+  mxml_node_t   *mxmldoc;               /* mxmldoc node */
+  const char    *cssfile,               /* CSS stylesheet file */
+                *docset,                /* Documentation set directory */
+                *docversion,            /* Documentation set version */
+                *feedname,              /* Feed name for documentation set */
+                *feedurl,               /* Feed URL for documentation set */
+                *footerfile,            /* Footer file */
+                *framefile,             /* Framed HTML basename */
+                *headerfile,            /* Header file */
+                *introfile,             /* Introduction file */
+                *name,                  /* Name of manpage */
+                *path,                  /* Path to help file for tokens */
+                *section,               /* Section/keywords of documentation */
+                *title,                 /* Title of documentation */
+                *xmlfile;               /* XML file */
+  int           mode,                   /* Output mode */
+                update;                 /* Updated XML file */
+
+
+ /*
+  * Check arguments...
+  */
+
+  cssfile     = NULL;
+  doc         = NULL;
+  docset      = NULL;
+  docversion  = NULL;
+  feedname    = NULL;
+  feedurl     = NULL;
+  footerfile  = NULL;
+  framefile   = NULL;
+  headerfile  = NULL;
+  introfile   = NULL;
+  mode        = OUTPUT_HTML;
+  mxmldoc     = NULL;
+  name        = NULL;
+  path        = NULL;
+  section     = NULL;
+  title       = NULL;
+  update      = 0;
+  xmlfile     = NULL;
+
+  for (i = 1; i < argc; i ++)
+    if (!strcmp(argv[i], "--help"))
+    {
+     /*
+      * Show help...
+      */
+
+      usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--version"))
+    {
+     /*
+      * Show version...
+      */
+
+      puts(MXML_VERSION + 10);
+      return (0);
+    }
+    else if (!strcmp(argv[i], "--css") && !cssfile)
+    {
+     /*
+      * Set CSS stylesheet file...
+      */
+
+      i ++;
+      if (i < argc)
+        cssfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--docset") && !docset)
+    {
+     /*
+      * Set documentation set directory...
+      */
+
+      i ++;
+      if (i < argc)
+        docset = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--docversion") && !docversion)
+    {
+     /*
+      * Set documentation set directory...
+      */
+
+      i ++;
+      if (i < argc)
+        docversion = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--footer") && !footerfile)
+    {
+     /*
+      * Set footer file...
+      */
+
+      i ++;
+      if (i < argc)
+        footerfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--feedname") && !feedname)
+    {
+     /*
+      * Set documentation set feed name...
+      */
+
+      i ++;
+      if (i < argc)
+        feedname = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--feedurl") && !feedurl)
+    {
+     /*
+      * Set documentation set feed name...
+      */
+
+      i ++;
+      if (i < argc)
+        feedurl = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--framed") && !framefile)
+    {
+     /*
+      * Set base filename for framed HTML output...
+      */
+
+      i ++;
+      if (i < argc)
+        framefile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--header") && !headerfile)
+    {
+     /*
+      * Set header file...
+      */
+
+      i ++;
+      if (i < argc)
+        headerfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--intro") && !introfile)
+    {
+     /*
+      * Set intro file...
+      */
+
+      i ++;
+      if (i < argc)
+        introfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--man") && !name)
+    {
+     /*
+      * Output manpage...
+      */
+
+      i ++;
+      if (i < argc)
+      {
+        mode = OUTPUT_MAN;
+        name = argv[i];
+      }
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--no-output"))
+      mode = OUTPUT_NONE;
+    else if (!strcmp(argv[i], "--section") && !section)
+    {
+     /*
+      * Set section/keywords...
+      */
+
+      i ++;
+      if (i < argc)
+        section = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--title") && !title)
+    {
+     /*
+      * Set title...
+      */
+
+      i ++;
+      if (i < argc)
+        title = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--tokens"))
+    {
+     /*
+      * Output Tokens.xml file...
+      */
+
+      mode = OUTPUT_TOKENS;
+
+      i ++;
+      if (i < argc)
+        path = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (argv[i][0] == '-')
+    {
+     /*
+      * Unknown/bad option...
+      */
+
+      usage(argv[i]);
+    }
+    else
+    {
+     /*
+      * Process XML or source file...
+      */
+
+      len = (int)strlen(argv[i]);
+      if (len > 4 && !strcmp(argv[i] + len - 4, ".xml"))
+      {
+       /*
+        * Set XML file...
+        */
+
+        if (xmlfile)
+          usage(NULL);
+
+        xmlfile = argv[i];
+
+        if (!doc)
+        {
+          if ((fp = fopen(argv[i], "r")) != NULL)
+          {
+           /*
+            * Read the existing XML file...
+            */
+
+            doc = mxmlLoadFile(NULL, fp, load_cb);
+
+            fclose(fp);
+
+            if (!doc)
+            {
+              mxmldoc = NULL;
+
+              fprintf(stderr,
+                      "mxmldoc: Unable to read the XML documentation file "
+                      "\"%s\"!\n", argv[i]);
+            }
+            else if ((mxmldoc = mxmlFindElement(doc, doc, "mxmldoc", NULL,
+                                                NULL, MXML_DESCEND)) == NULL)
+            {
+              fprintf(stderr,
+                      "mxmldoc: XML documentation file \"%s\" is missing "
+                      "<mxmldoc> node!!\n", argv[i]);
+
+              mxmlDelete(doc);
+              doc = NULL;
+            }
+          }
+          else
+          {
+            doc     = NULL;
+            mxmldoc = NULL;
+          }
+
+          if (!doc)
+            doc = new_documentation(&mxmldoc);
+        }
+      }
+      else
+      {
+       /*
+        * Load source file...
+        */
+
+        update = 1;
+
+        if (!doc)
+          doc = new_documentation(&mxmldoc);
+
+        if ((fp = fopen(argv[i], "r")) == NULL)
+        {
+          fprintf(stderr, "mxmldoc: Unable to open source file \"%s\": %s\n",
+                  argv[i], strerror(errno));
+          mxmlDelete(doc);
+          return (1);
+        }
+        else if (scan_file(argv[i], fp, mxmldoc))
+        {
+          fclose(fp);
+          mxmlDelete(doc);
+          return (1);
+        }
+        else
+          fclose(fp);
+      }
+    }
+
+  if (update && xmlfile)
+  {
+   /*
+    * Save the updated XML documentation file...
+    */
+
+    if ((fp = fopen(xmlfile, "w")) != NULL)
+    {
+     /*
+      * Write over the existing XML file...
+      */
+
+      mxmlSetWrapMargin(0);
+
+      if (mxmlSaveFile(doc, fp, ws_cb))
+      {
+        fprintf(stderr,
+                "mxmldoc: Unable to write the XML documentation file \"%s\": "
+                "%s!\n", xmlfile, strerror(errno));
+        fclose(fp);
+        mxmlDelete(doc);
+        return (1);
+      }
+
+      fclose(fp);
+    }
+    else
+    {
+      fprintf(stderr,
+              "mxmldoc: Unable to create the XML documentation file \"%s\": "
+              "%s!\n", xmlfile, strerror(errno));
+      mxmlDelete(doc);
+      return (1);
+    }
+  }
+
+  switch (mode)
+  {
+    case OUTPUT_HTML :
+       /*
+        * Write HTML documentation...
+        */
+
+        write_html(section, title ? title : "Documentation", footerfile,
+                   headerfile, introfile, cssfile, framefile, docset,
+                   docversion, feedname, feedurl, mxmldoc);
+        break;
+
+    case OUTPUT_MAN :
+       /*
+        * Write manpage documentation...
+        */
+
+        write_man(name, section, title, footerfile, headerfile, introfile,
+                  mxmldoc);
+        break;
+
+    case OUTPUT_TOKENS :
+        fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+              "<Tokens version=\"1.0\">\n", stdout);
+
+        write_tokens(stdout, mxmldoc, path);
+
+        fputs("</Tokens>\n", stdout);
+        break;
+  }
+
+ /*
+  * Delete the tree and return...
+  */
+
+  mxmlDelete(doc);
+
+  return (0);
+}
+
+
+/*
+ * 'add_variable()' - Add a variable or argument.
+ */
+
+static mxml_node_t *                    /* O - New variable/argument */
+add_variable(mxml_node_t *parent,       /* I - Parent node */
+             const char  *name,         /* I - "argument" or "variable" */
+             mxml_node_t *type)         /* I - Type nodes */
+{
+  mxml_node_t   *variable,              /* New variable */
+                *node,                  /* Current node */
+                *next;                  /* Next node */
+  char          buffer[16384],          /* String buffer */
+                *bufptr;                /* Pointer into buffer */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "add_variable(parent=%p, name=\"%s\", type=%p)\n",
+          parent, name, type);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!type || !type->child)
+    return (NULL);
+
+ /*
+  * Create the variable/argument node...
+  */
+
+  variable = mxmlNewElement(parent, name);
+
+ /*
+  * Check for a default value...
+  */
+
+  for (node = type->child; node; node = node->next)
+    if (!strcmp(node->value.text.string, "="))
+      break;
+
+  if (node)
+  {
+   /*
+    * Default value found, copy it and add as a "default" attribute...
+    */
+
+    for (bufptr = buffer; node; bufptr += strlen(bufptr))
+    {
+      if (node->value.text.whitespace && bufptr > buffer)
+        *bufptr++ = ' ';
+
+      strcpy(bufptr, node->value.text.string);
+
+      next = node->next;
+      mxmlDelete(node);
+      node = next;
+    }
+
+    mxmlElementSetAttr(variable, "default", buffer);
+  }
+
+ /*
+  * Extract the argument/variable name...
+  */
+
+  if (type->last_child->value.text.string[0] == ')')
+  {
+   /*
+    * Handle "type (*name)(args)"...
+    */
+
+    for (node = type->child; node; node = node->next)
+      if (node->value.text.string[0] == '(')
+        break;
+
+    for (bufptr = buffer; node; bufptr += strlen(bufptr))
+    {
+      if (node->value.text.whitespace && bufptr > buffer)
+        *bufptr++ = ' ';
+
+      strcpy(bufptr, node->value.text.string);
+
+      next = node->next;
+      mxmlDelete(node);
+      node = next;
+    }
+  }
+  else
+  {
+   /*
+    * Handle "type name"...
+    */
+
+    strcpy(buffer, type->last_child->value.text.string);
+    mxmlDelete(type->last_child);
+  }
+
+ /*
+  * Set the name...
+  */
+
+  mxmlElementSetAttr(variable, "name", buffer);
+
+ /*
+  * Add the remaining type information to the variable node...
+  */
+
+  mxmlAdd(variable, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+ /*
+  * Add new new variable node...
+  */
+
+  return (variable);
+}
+
+
+/*
+ * 'find_public()' - Find a public function, type, etc.
+ */
+
+static mxml_node_t *                    /* I - Found node or NULL */
+find_public(mxml_node_t *node,          /* I - Current node */
+            mxml_node_t *top,           /* I - Top node */
+            const char  *name)          /* I - Name of element */
+{
+  mxml_node_t   *description,           /* Description node */
+                *comment;               /* Comment node */
+
+
+  for (node = mxmlFindElement(node, top, name, NULL, NULL,
+                              node == top ? MXML_DESCEND_FIRST :
+                                            MXML_NO_DESCEND);
+       node;
+       node = mxmlFindElement(node, top, name, NULL, NULL, MXML_NO_DESCEND))
+  {
+   /*
+    * Get the description for this node...
+    */
+
+    description = mxmlFindElement(node, node, "description", NULL, NULL,
+                                  MXML_DESCEND_FIRST);
+
+   /*
+    * A missing or empty description signals a private node...
+    */
+
+    if (!description)
+      continue;
+
+   /*
+    * Look for @private@ in the comment text...
+    */
+
+    for (comment = description->child; comment; comment = comment->next)
+      if ((comment->type == MXML_TEXT &&
+           strstr(comment->value.text.string, "@private@")) ||
+          (comment->type == MXML_OPAQUE &&
+           strstr(comment->value.opaque, "@private@")))
+        break;
+
+    if (!comment)
+    {
+     /*
+      * No @private@, so return this node...
+      */
+
+      return (node);
+    }
+  }
+
+ /*
+  * If we get here, there are no (more) public nodes...
+  */
+
+  return (NULL);
+}
+
+
+/*
+ * 'get_comment_info()' - Get info from comment.
+ */
+
+static char *                           /* O - Info from comment */
+get_comment_info(
+    mxml_node_t *description)           /* I - Description node */
+{
+  char          text[10240],            /* Description text */
+                since[255],             /* @since value */
+                *ptr;                   /* Pointer into text */
+  static char   info[1024];             /* Info string */
+
+
+  if (!description)
+    return ("");
+
+  get_text(description, text, sizeof(text));
+
+  for (ptr = strchr(text, '@'); ptr; ptr = strchr(ptr + 1, '@'))
+  {
+    if (!strncmp(ptr, "@deprecated@", 12))
+      return ("<span class=\"info\">&nbsp;DEPRECATED&nbsp;</span>");
+    else if (!strncmp(ptr, "@since ", 7))
+    {
+      strncpy(since, ptr + 7, sizeof(since) - 1);
+      since[sizeof(since) - 1] = '\0';
+
+      if ((ptr = strchr(since, '@')) != NULL)
+        *ptr = '\0';
+
+      snprintf(info, sizeof(info), "<span class=\"info\">&nbsp;%s&nbsp;</span>", since);
+      return (info);
+    }
+  }
+
+  return ("");
+}
+
+
+/*
+ * 'get_text()' - Get the text for a node.
+ */
+
+static char *                           /* O - Text in node */
+get_text(mxml_node_t *node,             /* I - Node to get */
+         char        *buffer,           /* I - Buffer */
+         int         buflen)            /* I - Size of buffer */
+{
+  char          *ptr,                   /* Pointer into buffer */
+                *end;                   /* End of buffer */
+  int           len;                    /* Length of node */
+  mxml_node_t   *current;               /* Current node */
+
+
+  ptr = buffer;
+  end = buffer + buflen - 1;
+
+  for (current = node->child; current && ptr < end; current = current->next)
+  {
+    if (current->type == MXML_TEXT)
+    {
+      if (current->value.text.whitespace)
+        *ptr++ = ' ';
+
+      len = (int)strlen(current->value.text.string);
+      if (len > (int)(end - ptr))
+        len = (int)(end - ptr);
+
+      memcpy(ptr, current->value.text.string, len);
+      ptr += len;
+    }
+    else if (current->type == MXML_OPAQUE)
+    {
+      len = (int)strlen(current->value.opaque);
+      if (len > (int)(end - ptr))
+        len = (int)(end - ptr);
+
+      memcpy(ptr, current->value.opaque, len);
+      ptr += len;
+    }
+  }
+
+  *ptr = '\0';
+
+  return (buffer);
+}
+
+
+/*
+ * 'load_cb()' - Set the type of child nodes.
+ */
+
+static mxml_type_t                      /* O - Node type */
+load_cb(mxml_node_t *node)              /* I - Node */
+{
+  if (!strcmp(node->value.element.name, "description"))
+    return (MXML_OPAQUE);
+  else
+    return (MXML_TEXT);
+}
+
+
+/*
+ * 'new_documentation()' - Create a new documentation tree.
+ */
+
+static mxml_node_t *                    /* O - New documentation */
+new_documentation(mxml_node_t **mxmldoc)/* O - mxmldoc node */
+{
+  mxml_node_t   *doc;                   /* New documentation */
+
+
+ /*
+  * Create an empty XML documentation file...
+  */
+
+  doc = mxmlNewXML(NULL);
+
+  *mxmldoc = mxmlNewElement(doc, "mxmldoc");
+
+  mxmlElementSetAttr(*mxmldoc, "xmlns", "http://www.easysw.com");
+  mxmlElementSetAttr(*mxmldoc, "xmlns:xsi",
+                     "http://www.w3.org/2001/XMLSchema-instance");
+  mxmlElementSetAttr(*mxmldoc, "xsi:schemaLocation",
+                     "http://www.minixml.org/mxmldoc.xsd");
+
+  return (doc);
+}
+
+
+/*
+ * 'remove_directory()' - Remove a directory.
+ */
+
+static int                              /* O - 1 on success, 0 on failure */
+remove_directory(const char *path)      /* I - Directory to remove */
+{
+#ifdef WIN32
+  /* TODO: Add Windows directory removal code */
+
+#else
+  DIR           *dir;                   /* Directory */
+  struct dirent *dent;                  /* Current directory entry */
+  char          filename[1024];         /* Current filename */
+  struct stat   fileinfo;               /* File information */
+
+
+  if ((dir = opendir(path)) == NULL)
+  {
+    fprintf(stderr, "mxmldoc: Unable to open directory \"%s\": %s\n", path,
+            strerror(errno));
+    return (0);
+  }
+
+  while ((dent = readdir(dir)) != NULL)
+  {
+   /*
+    * Skip "." and ".."...
+    */
+
+    if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
+      continue;
+
+   /*
+    * See if we have a file or directory...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/%s", path, dent->d_name);
+
+    if (stat(filename, &fileinfo))
+    {
+      fprintf(stderr, "mxmldoc: Unable to stat \"%s\": %s\n", filename,
+              strerror(errno));
+      closedir(dir);
+      return (0);
+    }
+
+    if (S_ISDIR(fileinfo.st_mode))
+    {
+      if (!remove_directory(filename))
+      {
+        closedir(dir);
+        return (0);
+      }
+    }
+    else if (unlink(filename))
+    {
+      fprintf(stderr, "mxmldoc: Unable to remove \"%s\": %s\n", filename,
+              strerror(errno));
+      closedir(dir);
+      return (0);
+    }
+  }
+
+  closedir(dir);
+
+  if (rmdir(path))
+  {
+    fprintf(stderr, "mxmldoc: Unable to remove directory \"%s\": %s\n", path,
+            strerror(errno));
+    return (0);
+  }
+#endif /* WIN32 */
+
+  return (1);
+}
+
+
+/*
+ * 'safe_strcpy()' - Copy a string allowing for overlapping strings.
+ */
+
+static void
+safe_strcpy(char       *dst,            /* I - Destination string */
+            const char *src)            /* I - Source string */
+{
+  while (*src)
+    *dst++ = *src++;
+
+  *dst = '\0';
+}
+
+
+/*
+ * 'scan_file()' - Scan a source file.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+scan_file(const char  *filename,        /* I - Filename */
+          FILE        *fp,              /* I - File to scan */
+          mxml_node_t *tree)            /* I - Function tree */
+{
+  int           state,                  /* Current parser state */
+                braces,                 /* Number of braces active */
+                parens;                 /* Number of active parenthesis */
+  int           ch;                     /* Current character */
+  char          buffer[65536],          /* String buffer */
+                *bufptr;                /* Pointer into buffer */
+  const char    *scope;                 /* Current variable/function scope */
+  mxml_node_t   *comment,               /* <comment> node */
+                *constant,              /* <constant> node */
+                *enumeration,           /* <enumeration> node */
+                *function,              /* <function> node */
+                *fstructclass,          /* function struct/class node */
+                *structclass,           /* <struct> or <class> node */
+                *typedefnode,           /* <typedef> node */
+                *variable,              /* <variable> or <argument> node */
+                *returnvalue,           /* <returnvalue> node */
+                *type,                  /* <type> node */
+                *description,           /* <description> node */
+                *node,                  /* Current node */
+                *next;                  /* Next node */
+#if DEBUG > 1
+  mxml_node_t   *temp;                  /* Temporary node */
+  int           oldstate,               /* Previous state */
+                oldch;                  /* Old character */
+  static const char *states[] =         /* State strings */
+                {
+                  "STATE_NONE",
+                  "STATE_PREPROCESSOR",
+                  "STATE_C_COMMENT",
+                  "STATE_CXX_COMMENT",
+                  "STATE_STRING",
+                  "STATE_CHARACTER",
+                  "STATE_IDENTIFIER"
+                };
+#endif /* DEBUG > 1 */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "scan_file(filename=\"%s\", fp=%p, tree=%p)\n", filename,
+          fp, tree);
+#endif /* DEBUG */
+
+ /*
+  * Initialize the finite state machine...
+  */
+
+  state        = STATE_NONE;
+  braces       = 0;
+  parens       = 0;
+  bufptr       = buffer;
+
+  comment      = mxmlNewElement(MXML_NO_PARENT, "temp");
+  constant     = NULL;
+  enumeration  = NULL;
+  function     = NULL;
+  variable     = NULL;
+  returnvalue  = NULL;
+  type         = NULL;
+  description  = NULL;
+  typedefnode  = NULL;
+  structclass  = NULL;
+  fstructclass = NULL;
+
+  if (!strcmp(tree->value.element.name, "class"))
+    scope = "private";
+  else
+    scope = NULL;
+
+ /*
+  * Read until end-of-file...
+  */
+
+  while ((ch = getc(fp)) != EOF)
+  {
+#if DEBUG > 1
+    oldstate = state;
+    oldch    = ch;
+#endif /* DEBUG > 1 */
+
+    switch (state)
+    {
+      case STATE_NONE :                 /* No state - whitespace, etc. */
+          switch (ch)
+          {
+            case '/' :                  /* Possible C/C++ comment */
+                ch     = getc(fp);
+                bufptr = buffer;
+
+                if (ch == '*')
+                  state = STATE_C_COMMENT;
+                else if (ch == '/')
+                  state = STATE_CXX_COMMENT;
+                else
+                {
+                  ungetc(ch, fp);
+
+                  if (type)
+                  {
+#ifdef DEBUG
+                    fputs("Identifier: <<<< / >>>\n", stderr);
+#endif /* DEBUG */
+                    ch = type->last_child->value.text.string[0];
+                    mxmlNewText(type, isalnum(ch) || ch == '_', "/");
+                  }
+                }
+                break;
+
+            case '#' :                  /* Preprocessor */
+#ifdef DEBUG
+                fputs("    #preprocessor...\n", stderr);
+#endif /* DEBUG */
+                state = STATE_PREPROCESSOR;
+                break;
+
+            case '\'' :                 /* Character constant */
+                state = STATE_CHARACTER;
+                bufptr = buffer;
+                *bufptr++ = ch;
+                break;
+
+            case '\"' :                 /* String constant */
+                state = STATE_STRING;
+                bufptr = buffer;
+                *bufptr++ = ch;
+                break;
+
+            case '{' :
+#ifdef DEBUG
+                fprintf(stderr, "    open brace, function=%p, type=%p...\n",
+                        function, type);
+                if (type)
+                  fprintf(stderr, "    type->child=\"%s\"...\n",
+                          type->child->value.text.string);
+#endif /* DEBUG */
+
+                if (function)
+                {
+                  if (fstructclass)
+                  {
+                    sort_node(fstructclass, function);
+                    fstructclass = NULL;
+                  }
+                  else
+                    sort_node(tree, function);
+
+                  function = NULL;
+                }
+                else if (type && type->child &&
+                         ((!strcmp(type->child->value.text.string, "typedef") &&
+                           type->child->next &&
+                           (!strcmp(type->child->next->value.text.string, "struct") ||
+                            !strcmp(type->child->next->value.text.string, "union") ||
+                            !strcmp(type->child->next->value.text.string, "class"))) ||
+                          !strcmp(type->child->value.text.string, "union") ||
+                          !strcmp(type->child->value.text.string, "struct") ||
+                          !strcmp(type->child->value.text.string, "class")))
+                {
+                 /*
+                  * Start of a class or structure...
+                  */
+
+                  if (!strcmp(type->child->value.text.string, "typedef"))
+                  {
+#ifdef DEBUG
+                    fputs("    starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+                    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+                    mxmlDelete(type->child);
+                  }
+                  else
+                    typedefnode = NULL;
+
+                  structclass = mxmlNewElement(MXML_NO_PARENT,
+                                               type->child->value.text.string);
+
+#ifdef DEBUG
+                  fprintf(stderr, "%c%s: <<<< %s >>>\n",
+                          toupper(type->child->value.text.string[0]),
+                          type->child->value.text.string + 1,
+                          type->child->next ?
+                              type->child->next->value.text.string : "(noname)");
+
+                  fputs("    type =", stderr);
+                  for (node = type->child; node; node = node->next)
+                    fprintf(stderr, " \"%s\"", node->value.text.string);
+                  putc('\n', stderr);
+
+                  fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+                  if (type->child->next)
+                  {
+                    mxmlElementSetAttr(structclass, "name",
+                                       type->child->next->value.text.string);
+                    sort_node(tree, structclass);
+                  }
+
+                  if (typedefnode && type->child)
+                    type->child->value.text.whitespace = 0;
+                  else if (structclass && type->child &&
+                           type->child->next && type->child->next->next)
+                  {
+                    for (bufptr = buffer, node = type->child->next->next;
+                         node;
+                         bufptr += strlen(bufptr))
+                    {
+                      if (node->value.text.whitespace && bufptr > buffer)
+                        *bufptr++ = ' ';
+
+                      strcpy(bufptr, node->value.text.string);
+
+                      next = node->next;
+                      mxmlDelete(node);
+                      node = next;
+                    }
+
+                    mxmlElementSetAttr(structclass, "parent", buffer);
+
+                    mxmlDelete(type);
+                    type = NULL;
+                  }
+                  else
+                  {
+                    mxmlDelete(type);
+                    type = NULL;
+                  }
+
+                  if (typedefnode && comment->last_child)
+                  {
+                   /*
+                    * Copy comment for typedef as well as class/struct/union...
+                    */
+
+                    mxmlNewText(comment, 0,
+                                comment->last_child->value.text.string);
+                    description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "    duplicating comment %p/%p for typedef...\n",
+                            comment->last_child, comment->child);
+#endif /* DEBUG */
+                    update_comment(typedefnode, comment->last_child);
+                    mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                            comment->last_child);
+                  }
+
+                  description = mxmlNewElement(structclass, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to %s...\n",
+                          comment->last_child, comment->child,
+                          structclass->value.element.name);
+#endif /* DEBUG */
+                  update_comment(structclass, comment->last_child);
+                  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                          comment->last_child);
+
+                  if (scan_file(filename, fp, structclass))
+                  {
+                    mxmlDelete(comment);
+                    return (-1);
+                  }
+
+#ifdef DEBUG
+                  fputs("    ended typedef...\n", stderr);
+#endif /* DEBUG */
+                  structclass = NULL;
+                  break;
+                }
+                else if (type && type->child && type->child->next &&
+                         (!strcmp(type->child->value.text.string, "enum") ||
+                          (!strcmp(type->child->value.text.string, "typedef") &&
+                           !strcmp(type->child->next->value.text.string, "enum"))))
+                {
+                 /*
+                  * Enumeration type...
+                  */
+
+                  if (!strcmp(type->child->value.text.string, "typedef"))
+                  {
+#ifdef DEBUG
+                    fputs("    starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+                    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+                    mxmlDelete(type->child);
+                  }
+                  else
+                    typedefnode = NULL;
+
+                  enumeration = mxmlNewElement(MXML_NO_PARENT, "enumeration");
+
+#ifdef DEBUG
+                  fprintf(stderr, "Enumeration: <<<< %s >>>\n",
+                          type->child->next ?
+                              type->child->next->value.text.string : "(noname)");
+#endif /* DEBUG */
+
+                  if (type->child->next)
+                  {
+                    mxmlElementSetAttr(enumeration, "name",
+                                       type->child->next->value.text.string);
+                    sort_node(tree, enumeration);
+                  }
+
+                  if (typedefnode && type->child)
+                    type->child->value.text.whitespace = 0;
+                  else
+                  {
+                    mxmlDelete(type);
+                    type = NULL;
+                  }
+
+                  if (typedefnode && comment->last_child)
+                  {
+                   /*
+                    * Copy comment for typedef as well as class/struct/union...
+                    */
+
+                    mxmlNewText(comment, 0,
+                                comment->last_child->value.text.string);
+                    description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "    duplicating comment %p/%p for typedef...\n",
+                            comment->last_child, comment->child);
+#endif /* DEBUG */
+                    update_comment(typedefnode, comment->last_child);
+                    mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                            comment->last_child);
+                  }
+
+                  description = mxmlNewElement(enumeration, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to enumeration...\n",
+                          comment->last_child, comment->child);
+#endif /* DEBUG */
+                  update_comment(enumeration, comment->last_child);
+                  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                          comment->last_child);
+                }
+                else if (type && type->child &&
+                         !strcmp(type->child->value.text.string, "extern"))
+                {
+                  if (scan_file(filename, fp, tree))
+                  {
+                    mxmlDelete(comment);
+                    return (-1);
+                  }
+                }
+                else if (type)
+                {
+                  mxmlDelete(type);
+                  type = NULL;
+                }
+
+                braces ++;
+                function = NULL;
+                variable = NULL;
+                break;
+
+            case '}' :
+#ifdef DEBUG
+                fputs("    close brace...\n", stderr);
+#endif /* DEBUG */
+
+                if (structclass)
+                  scope = NULL;
+
+                if (!typedefnode)
+                  enumeration = NULL;
+
+                constant    = NULL;
+                structclass = NULL;
+
+                if (braces > 0)
+                  braces --;
+                else
+                {
+                  mxmlDelete(comment);
+                  return (0);
+                }
+                break;
+
+            case '(' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< ( >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 0, "(");
+                }
+
+                parens ++;
+                break;
+
+            case ')' :
+                if (type && parens)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< ) >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 0, ")");
+                }
+
+                if (function && type && !parens)
+                {
+                 /*
+                  * Check for "void" argument...
+                  */
+
+                  if (type->child && type->child->next)
+                    variable = add_variable(function, "argument", type);
+                  else
+                    mxmlDelete(type);
+
+                  type = NULL;
+                }
+
+                if (parens > 0)
+                  parens --;
+                break;
+
+            case ';' :
+#ifdef DEBUG
+                fputs("Identifier: <<<< ; >>>\n", stderr);
+                fprintf(stderr, "    enumeration=%p, function=%p, type=%p, type->child=%p, typedefnode=%p\n",
+                        enumeration, function, type, type ? type->child : NULL, typedefnode);
+#endif /* DEBUG */
+
+                if (function)
+                {
+                  if (!strcmp(tree->value.element.name, "class"))
+                  {
+#ifdef DEBUG
+                    fputs("    ADDING FUNCTION TO CLASS\n", stderr);
+#endif /* DEBUG */
+                    sort_node(tree, function);
+                  }
+                  else
+                    mxmlDelete(function);
+
+                  function = NULL;
+                  variable = NULL;
+                }
+
+                if (type)
+                {
+                 /*
+                  * See if we have a typedef...
+                  */
+
+                  if (type->child &&
+                      !strcmp(type->child->value.text.string, "typedef"))
+                  {
+                   /*
+                    * Yes, add it!
+                    */
+
+                    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+
+                    for (node = type->child->next; node; node = node->next)
+                      if (!strcmp(node->value.text.string, "("))
+                        break;
+
+                    if (node)
+                    {
+                      for (node = node->next; node; node = node->next)
+                        if (strcmp(node->value.text.string, "*"))
+                          break;
+                    }
+
+                    if (!node)
+                      node = type->last_child;
+
+#ifdef DEBUG
+                    fprintf(stderr, "    ADDING TYPEDEF FOR %p(%s)...\n",
+                            node, node->value.text.string);
+#endif /* DEBUG */
+
+                    mxmlElementSetAttr(typedefnode, "name",
+                                       node->value.text.string);
+                    sort_node(tree, typedefnode);
+
+                    if (type->child != node)
+                      mxmlDelete(type->child);
+
+                    mxmlDelete(node);
+
+                    if (type->child)
+                      type->child->value.text.whitespace = 0;
+
+                    mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                            type);
+                    type = NULL;
+                    break;
+                  }
+                  else if (typedefnode && enumeration)
+                  {
+                   /*
+                    * Add enum typedef...
+                    */
+
+                    node = type->child;
+
+#ifdef DEBUG
+                    fprintf(stderr, "    ADDING TYPEDEF FOR %p(%s)...\n",
+                            node, node->value.text.string);
+#endif /* DEBUG */
+
+                    mxmlElementSetAttr(typedefnode, "name",
+                                       node->value.text.string);
+                    sort_node(tree, typedefnode);
+                    mxmlDelete(type);
+
+                    type = mxmlNewElement(typedefnode, "type");
+                    mxmlNewText(type, 0, "enum");
+                    mxmlNewText(type, 1,
+                                mxmlElementGetAttr(enumeration, "name"));
+                    enumeration = NULL;
+                    type = NULL;
+                    break;
+                  }
+
+                  mxmlDelete(type);
+                  type = NULL;
+                }
+                break;
+
+            case ':' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< : >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 1, ":");
+                }
+                break;
+
+            case '*' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< * >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "*");
+                }
+                break;
+
+            case ',' :
+                if (type && !enumeration)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< , >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 0, ",");
+                }
+                break;
+
+            case '&' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< & >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 1, "&");
+                }
+                break;
+
+            case '+' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< + >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "+");
+                }
+                break;
+
+            case '-' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< - >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "-");
+                }
+                break;
+
+            case '=' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< = >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "=");
+                }
+                break;
+
+            default :                   /* Other */
+                if (isalnum(ch) || ch == '_' || ch == '.' || ch == ':' || ch == '~')
+                {
+                  state     = STATE_IDENTIFIER;
+                  bufptr    = buffer;
+                  *bufptr++ = ch;
+                }
+                break;
+          }
+          break;
+
+      case STATE_PREPROCESSOR :         /* Preprocessor directive */
+          if (ch == '\n')
+            state = STATE_NONE;
+          else if (ch == '\\')
+            getc(fp);
+          break;
+
+      case STATE_C_COMMENT :            /* Inside a C comment */
+          switch (ch)
+          {
+            case '\n' :
+                while ((ch = getc(fp)) != EOF)
+                  if (ch == '*')
+                  {
+                    ch = getc(fp);
+
+                    if (ch == '/')
+                    {
+                      *bufptr = '\0';
+
+                      if (comment->child != comment->last_child)
+                      {
+#ifdef DEBUG
+                        fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+                                comment->child,
+                                comment->child ? comment->child->value.text.string : "",
+                                comment->last_child,
+                                comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+                        mxmlDelete(comment->child);
+#ifdef DEBUG
+                        fprintf(stderr, "    new comment %p, last comment %p...\n",
+                                comment->child, comment->last_child);
+#endif /* DEBUG */
+                      }
+
+#ifdef DEBUG
+                      fprintf(stderr,
+                              "    processing comment, variable=%p, "
+                              "constant=%p, typedefnode=%p, tree=\"%s\"\n",
+                              variable, constant, typedefnode,
+                              tree->value.element.name);
+#endif /* DEBUG */
+
+                      if (variable)
+                      {
+                        if (strstr(buffer, "@private@"))
+                        {
+                         /*
+                          * Delete private variables...
+                          */
+
+                          mxmlDelete(variable);
+                        }
+                        else
+                        {
+                          description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+                          fprintf(stderr,
+                                  "    adding comment %p/%p to variable...\n",
+                                  comment->last_child, comment->child);
+#endif /* DEBUG */
+                          mxmlNewText(comment, 0, buffer);
+                          update_comment(variable,
+                                         mxmlNewText(description, 0, buffer));
+                        }
+
+                        variable = NULL;
+                      }
+                      else if (constant)
+                      {
+                        if (strstr(buffer, "@private@"))
+                        {
+                         /*
+                          * Delete private constants...
+                          */
+
+                          mxmlDelete(constant);
+                        }
+                        else
+                        {
+                          description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+                          fprintf(stderr,
+                                  "    adding comment %p/%p to constant...\n",
+                                  comment->last_child, comment->child);
+#endif /* DEBUG */
+                          mxmlNewText(comment, 0, buffer);
+                          update_comment(constant,
+                                         mxmlNewText(description, 0, buffer));
+                        }
+
+                        constant = NULL;
+                      }
+                      else if (typedefnode)
+                      {
+                        if (strstr(buffer, "@private@"))
+                        {
+                         /*
+                          * Delete private typedefs...
+                          */
+
+                          mxmlDelete(typedefnode);
+
+                          if (structclass)
+                          {
+                            mxmlDelete(structclass);
+                            structclass = NULL;
+                          }
+
+                          if (enumeration)
+                          {
+                            mxmlDelete(enumeration);
+                            enumeration = NULL;
+                          }
+                        }
+                        else
+                        {
+                          description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                          fprintf(stderr,
+                                  "    adding comment %p/%p to typedef %s...\n",
+                                  comment->last_child, comment->child,
+                                  mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+                          mxmlNewText(comment, 0, buffer);
+                          update_comment(typedefnode,
+                                         mxmlNewText(description, 0, buffer));
+
+                          if (structclass)
+                          {
+                            description = mxmlNewElement(structclass, "description");
+                            update_comment(structclass,
+                                           mxmlNewText(description, 0, buffer));
+                          }
+                          else if (enumeration)
+                          {
+                            description = mxmlNewElement(enumeration, "description");
+                            update_comment(enumeration,
+                                           mxmlNewText(description, 0, buffer));
+                          }
+                        }
+
+                        typedefnode = NULL;
+                      }
+                      else if (strcmp(tree->value.element.name, "mxmldoc") &&
+                               !mxmlFindElement(tree, tree, "description",
+                                                NULL, NULL, MXML_DESCEND_FIRST))
+                      {
+                        description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+                        fprintf(stderr, "    adding comment %p/%p to parent...\n",
+                                comment->last_child, comment->child);
+#endif /* DEBUG */
+                        mxmlNewText(comment, 0, buffer);
+                        update_comment(tree,
+                                       mxmlNewText(description, 0, buffer));
+                      }
+                      else
+                      {
+#ifdef DEBUG
+                        fprintf(stderr, "    before adding comment, child=%p, last_child=%p\n",
+                                comment->child, comment->last_child);
+#endif /* DEBUG */
+                        mxmlNewText(comment, 0, buffer);
+#ifdef DEBUG
+                        fprintf(stderr, "    after adding comment, child=%p, last_child=%p\n",
+                                comment->child, comment->last_child);
+#endif /* DEBUG */
+                      }
+#ifdef DEBUG
+                      fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                      state = STATE_NONE;
+                      break;
+                    }
+                    else
+                      ungetc(ch, fp);
+                  }
+                  else if (ch == '\n' && bufptr > buffer &&
+                           bufptr < (buffer + sizeof(buffer) - 1))
+                    *bufptr++ = ch;
+                  else if (!isspace(ch))
+                    break;
+
+                if (ch != EOF)
+                  ungetc(ch, fp);
+
+                if (bufptr > buffer && bufptr < (buffer + sizeof(buffer) - 1))
+                  *bufptr++ = '\n';
+                break;
+
+            case '/' :
+                if (ch == '/' && bufptr > buffer && bufptr[-1] == '*')
+                {
+                  while (bufptr > buffer &&
+                         (bufptr[-1] == '*' || isspace(bufptr[-1] & 255)))
+                    bufptr --;
+                  *bufptr = '\0';
+
+                  if (comment->child != comment->last_child)
+                  {
+#ifdef DEBUG
+                    fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+                            comment->child,
+                            comment->child ? comment->child->value.text.string : "",
+                            comment->last_child,
+                            comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+                    mxmlDelete(comment->child);
+#ifdef DEBUG
+                    fprintf(stderr, "    new comment %p, last comment %p...\n",
+                            comment->child, comment->last_child);
+#endif /* DEBUG */
+                  }
+
+#ifdef DEBUG
+                  fprintf(stderr,
+                          "    processing comment, variable=%p, "
+                          "constant=%p, typedefnode=%p, tree=\"%s\"\n",
+                          variable, constant, typedefnode,
+                          tree->value.element.name);
+#endif /* DEBUG */
+
+                  if (variable)
+                  {
+                    if (strstr(buffer, "@private@"))
+                    {
+                     /*
+                      * Delete private variables...
+                      */
+
+                      mxmlDelete(variable);
+                    }
+                    else
+                    {
+                      description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+                      fprintf(stderr, "    adding comment %p/%p to variable...\n",
+                              comment->last_child, comment->child);
+#endif /* DEBUG */
+                      mxmlNewText(comment, 0, buffer);
+                      update_comment(variable,
+                                     mxmlNewText(description, 0, buffer));
+                    }
+
+                    variable = NULL;
+                  }
+                  else if (constant)
+                  {
+                    if (strstr(buffer, "@private@"))
+                    {
+                     /*
+                      * Delete private constants...
+                      */
+
+                      mxmlDelete(constant);
+                    }
+                    else
+                    {
+                      description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+                      fprintf(stderr, "    adding comment %p/%p to constant...\n",
+                              comment->last_child, comment->child);
+#endif /* DEBUG */
+                      mxmlNewText(comment, 0, buffer);
+                      update_comment(constant,
+                                     mxmlNewText(description, 0, buffer));
+                    }
+
+                    constant = NULL;
+                  }
+                  else if (typedefnode)
+                  {
+                    if (strstr(buffer, "@private@"))
+                    {
+                     /*
+                      * Delete private typedefs...
+                      */
+
+                      mxmlDelete(typedefnode);
+
+                      if (structclass)
+                      {
+                        mxmlDelete(structclass);
+                        structclass = NULL;
+                      }
+
+                      if (enumeration)
+                      {
+                        mxmlDelete(enumeration);
+                        enumeration = NULL;
+                      }
+                    }
+                    else
+                    {
+                      description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                      fprintf(stderr,
+                              "    adding comment %p/%p to typedef %s...\n",
+                              comment->last_child, comment->child,
+                              mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+                      mxmlNewText(comment, 0, buffer);
+                      update_comment(typedefnode,
+                                     mxmlNewText(description, 0, buffer));
+
+                      if (structclass)
+                      {
+                        description = mxmlNewElement(structclass, "description");
+                        update_comment(structclass,
+                                       mxmlNewText(description, 0, buffer));
+                      }
+                      else if (enumeration)
+                      {
+                        description = mxmlNewElement(enumeration, "description");
+                        update_comment(enumeration,
+                                       mxmlNewText(description, 0, buffer));
+                      }
+                    }
+
+                    typedefnode = NULL;
+                  }
+                  else if (strcmp(tree->value.element.name, "mxmldoc") &&
+                           !mxmlFindElement(tree, tree, "description",
+                                            NULL, NULL, MXML_DESCEND_FIRST))
+                  {
+                    description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+                    fprintf(stderr, "    adding comment %p/%p to parent...\n",
+                            comment->last_child, comment->child);
+#endif /* DEBUG */
+                    mxmlNewText(comment, 0, buffer);
+                    update_comment(tree,
+                                   mxmlNewText(description, 0, buffer));
+                  }
+                  else
+                    mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                  state = STATE_NONE;
+                  break;
+                }
+
+            default :
+                if (ch == ' ' && bufptr == buffer)
+                  break;
+
+                if (bufptr < (buffer + sizeof(buffer) - 1))
+                  *bufptr++ = ch;
+                break;
+          }
+          break;
+
+      case STATE_CXX_COMMENT :          /* Inside a C++ comment */
+          if (ch == '\n')
+          {
+            state = STATE_NONE;
+            *bufptr = '\0';
+
+            if (comment->child != comment->last_child)
+            {
+#ifdef DEBUG
+              fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+                      comment->child,
+                      comment->child ? comment->child->value.text.string : "",
+                      comment->last_child,
+                      comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+              mxmlDelete(comment->child);
+#ifdef DEBUG
+              fprintf(stderr, "    new comment %p, last comment %p...\n",
+                      comment->child, comment->last_child);
+#endif /* DEBUG */
+            }
+
+            if (variable)
+            {
+              if (strstr(buffer, "@private@"))
+              {
+               /*
+                * Delete private variables...
+                */
+
+                mxmlDelete(variable);
+              }
+              else
+              {
+                description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+                fprintf(stderr, "    adding comment %p/%p to variable...\n",
+                        comment->last_child, comment->child);
+#endif /* DEBUG */
+                mxmlNewText(comment, 0, buffer);
+                update_comment(variable,
+                               mxmlNewText(description, 0, buffer));
+              }
+
+              variable = NULL;
+            }
+            else if (constant)
+            {
+              if (strstr(buffer, "@private@"))
+              {
+               /*
+                * Delete private constants...
+                */
+
+                mxmlDelete(constant);
+              }
+              else
+              {
+                description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+                fprintf(stderr, "    adding comment %p/%p to constant...\n",
+                        comment->last_child, comment->child);
+#endif /* DEBUG */
+                mxmlNewText(comment, 0, buffer);
+                update_comment(constant,
+                               mxmlNewText(description, 0, buffer));
+              }
+
+              constant = NULL;
+            }
+            else if (typedefnode)
+            {
+              if (strstr(buffer, "@private@"))
+              {
+               /*
+                * Delete private typedefs...
+                */
+
+                mxmlDelete(typedefnode);
+                typedefnode = NULL;
+
+                if (structclass)
+                {
+                  mxmlDelete(structclass);
+                  structclass = NULL;
+                }
+
+                if (enumeration)
+                {
+                  mxmlDelete(enumeration);
+                  enumeration = NULL;
+                }
+              }
+              else
+              {
+                description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                fprintf(stderr, "    adding comment %p/%p to typedef %s...\n",
+                        comment->last_child, comment->child,
+                        mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+                mxmlNewText(comment, 0, buffer);
+                update_comment(typedefnode,
+                               mxmlNewText(description, 0, buffer));
+
+                if (structclass)
+                {
+                  description = mxmlNewElement(structclass, "description");
+                  update_comment(structclass,
+                                 mxmlNewText(description, 0, buffer));
+                }
+                else if (enumeration)
+                {
+                  description = mxmlNewElement(enumeration, "description");
+                  update_comment(enumeration,
+                                 mxmlNewText(description, 0, buffer));
+                }
+              }
+            }
+            else if (strcmp(tree->value.element.name, "mxmldoc") &&
+                     !mxmlFindElement(tree, tree, "description",
+                                      NULL, NULL, MXML_DESCEND_FIRST))
+            {
+              description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+              fprintf(stderr, "    adding comment %p/%p to parent...\n",
+                      comment->last_child, comment->child);
+#endif /* DEBUG */
+              mxmlNewText(comment, 0, buffer);
+              update_comment(tree,
+                             mxmlNewText(description, 0, buffer));
+            }
+            else
+              mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+            fprintf(stderr, "C++ comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+          }
+          else if (ch == ' ' && bufptr == buffer)
+            break;
+          else if (bufptr < (buffer + sizeof(buffer) - 1))
+            *bufptr++ = ch;
+          break;
+
+      case STATE_STRING :               /* Inside a string constant */
+          *bufptr++ = ch;
+
+          if (ch == '\\')
+            *bufptr++ = getc(fp);
+          else if (ch == '\"')
+          {
+            *bufptr = '\0';
+
+            if (type)
+              mxmlNewText(type, type->child != NULL, buffer);
+
+            state = STATE_NONE;
+          }
+          break;
+
+      case STATE_CHARACTER :            /* Inside a character constant */
+          *bufptr++ = ch;
+
+          if (ch == '\\')
+            *bufptr++ = getc(fp);
+          else if (ch == '\'')
+          {
+            *bufptr = '\0';
+
+            if (type)
+              mxmlNewText(type, type->child != NULL, buffer);
+
+            state = STATE_NONE;
+          }
+          break;
+
+      case STATE_IDENTIFIER :           /* Inside a keyword or identifier */
+          if (isalnum(ch) || ch == '_' || ch == '[' || ch == ']' ||
+              (ch == ',' && (parens > 1 || (type && !enumeration && !function))) ||
+              ch == ':' || ch == '.' || ch == '~')
+          {
+            if (bufptr < (buffer + sizeof(buffer) - 1))
+              *bufptr++ = ch;
+          }
+          else
+          {
+            ungetc(ch, fp);
+            *bufptr = '\0';
+            state   = STATE_NONE;
+
+#ifdef DEBUG
+            fprintf(stderr, "    braces=%d, type=%p, type->child=%p, buffer=\"%s\"\n",
+                    braces, type, type ? type->child : NULL, buffer);
+#endif /* DEBUG */
+
+            if (!braces)
+            {
+              if (!type || !type->child)
+              {
+                if (!strcmp(tree->value.element.name, "class"))
+                {
+                  if (!strcmp(buffer, "public") ||
+                      !strcmp(buffer, "public:"))
+                  {
+                    scope = "public";
+#ifdef DEBUG
+                    fputs("    scope = public\n", stderr);
+#endif /* DEBUG */
+                    break;
+                  }
+                  else if (!strcmp(buffer, "private") ||
+                           !strcmp(buffer, "private:"))
+                  {
+                    scope = "private";
+#ifdef DEBUG
+                    fputs("    scope = private\n", stderr);
+#endif /* DEBUG */
+                    break;
+                  }
+                  else if (!strcmp(buffer, "protected") ||
+                           !strcmp(buffer, "protected:"))
+                  {
+                    scope = "protected";
+#ifdef DEBUG
+                    fputs("    scope = protected\n", stderr);
+#endif /* DEBUG */
+                    break;
+                  }
+                }
+              }
+
+              if (!type)
+                type = mxmlNewElement(MXML_NO_PARENT, "type");
+
+#ifdef DEBUG
+              fprintf(stderr, "    function=%p (%s), type->child=%p, ch='%c', parens=%d\n",
+                      function,
+                      function ? mxmlElementGetAttr(function, "name") : "null",
+                      type->child, ch, parens);
+#endif /* DEBUG */
+
+              if (!function && ch == '(')
+              {
+                if (type->child &&
+                    !strcmp(type->child->value.text.string, "extern"))
+                {
+                 /*
+                  * Remove external declarations...
+                  */
+
+                  mxmlDelete(type);
+                  type = NULL;
+                  break;
+                }
+
+                if (type->child &&
+                    !strcmp(type->child->value.text.string, "static") &&
+                    !strcmp(tree->value.element.name, "mxmldoc"))
+                {
+                 /*
+                  * Remove static functions...
+                  */
+
+                  mxmlDelete(type);
+                  type = NULL;
+                  break;
+                }
+
+                function = mxmlNewElement(MXML_NO_PARENT, "function");
+                if ((bufptr = strchr(buffer, ':')) != NULL && bufptr[1] == ':')
+                {
+                  *bufptr = '\0';
+                  bufptr += 2;
+
+                  if ((fstructclass =
+                           mxmlFindElement(tree, tree, "class", "name", buffer,
+                                           MXML_DESCEND_FIRST)) == NULL)
+                    fstructclass =
+                        mxmlFindElement(tree, tree, "struct", "name", buffer,
+                                        MXML_DESCEND_FIRST);
+                }
+                else
+                  bufptr = buffer;
+
+                mxmlElementSetAttr(function, "name", bufptr);
+
+                if (scope)
+                  mxmlElementSetAttr(function, "scope", scope);
+
+#ifdef DEBUG
+                fprintf(stderr, "function: %s\n", buffer);
+                fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+                fprintf(stderr, "    comment = %p\n", comment);
+                fprintf(stderr, "    child = (%p) %s\n",
+                        comment->child,
+                        comment->child ?
+                            comment->child->value.text.string : "(null)");
+                fprintf(stderr, "    last_child = (%p) %s\n",
+                        comment->last_child,
+                        comment->last_child ?
+                            comment->last_child->value.text.string : "(null)");
+#endif /* DEBUG */
+
+                if (type->last_child &&
+                    strcmp(type->last_child->value.text.string, "void"))
+                {
+                  returnvalue = mxmlNewElement(function, "returnvalue");
+
+                  mxmlAdd(returnvalue, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+                  description = mxmlNewElement(returnvalue, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to returnvalue...\n",
+                          comment->last_child, comment->child);
+#endif /* DEBUG */
+                  update_comment(returnvalue, comment->last_child);
+                  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                          comment->last_child);
+                }
+                else
+                  mxmlDelete(type);
+
+                description = mxmlNewElement(function, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to function...\n",
+                          comment->last_child, comment->child);
+#endif /* DEBUG */
+                update_comment(function, comment->last_child);
+                mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                        comment->last_child);
+
+                type = NULL;
+              }
+              else if (function && ((ch == ')' && parens == 1) || ch == ','))
+              {
+               /*
+                * Argument definition...
+                */
+
+                if (strcmp(buffer, "void"))
+                {
+                  mxmlNewText(type, type->child != NULL &&
+                                    type->last_child->value.text.string[0] != '(' &&
+                                    type->last_child->value.text.string[0] != '*',
+                              buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "Argument: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                  variable = add_variable(function, "argument", type);
+                }
+                else
+                  mxmlDelete(type);
+
+                type = NULL;
+              }
+              else if (type->child && !function && (ch == ';' || ch == ','))
+              {
+#ifdef DEBUG
+                fprintf(stderr, "    got semicolon, typedefnode=%p, structclass=%p\n",
+                        typedefnode, structclass);
+#endif /* DEBUG */
+
+                if (typedefnode || structclass)
+                {
+#ifdef DEBUG
+                  fprintf(stderr, "Typedef/struct/class: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+                  if (typedefnode)
+                  {
+                    mxmlElementSetAttr(typedefnode, "name", buffer);
+
+                    sort_node(tree, typedefnode);
+                  }
+
+                  if (structclass && !mxmlElementGetAttr(structclass, "name"))
+                  {
+#ifdef DEBUG
+                    fprintf(stderr, "setting struct/class name to %s!\n",
+                            type->last_child->value.text.string);
+#endif /* DEBUG */
+                    mxmlElementSetAttr(structclass, "name", buffer);
+
+                    sort_node(tree, structclass);
+                    structclass = NULL;
+                  }
+
+                  if (typedefnode)
+                    mxmlAdd(typedefnode, MXML_ADD_BEFORE, MXML_ADD_TO_PARENT,
+                            type);
+                  else
+                    mxmlDelete(type);
+
+                  type        = NULL;
+                  typedefnode = NULL;
+                }
+                else if (type->child &&
+                         !strcmp(type->child->value.text.string, "typedef"))
+                {
+                 /*
+                  * Simple typedef...
+                  */
+
+#ifdef DEBUG
+                  fprintf(stderr, "Typedef: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                  typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+                  mxmlElementSetAttr(typedefnode, "name", buffer);
+                  mxmlDelete(type->child);
+
+                  sort_node(tree, typedefnode);
+
+                  if (type->child)
+                    type->child->value.text.whitespace = 0;
+
+                  mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+                  type = NULL;
+                }
+                else if (!parens)
+                {
+                 /*
+                  * Variable definition...
+                  */
+
+                  if (type->child &&
+                      !strcmp(type->child->value.text.string, "static") &&
+                      !strcmp(tree->value.element.name, "mxmldoc"))
+                  {
+                   /*
+                    * Remove static functions...
+                    */
+
+                    mxmlDelete(type);
+                    type = NULL;
+                    break;
+                  }
+
+                  mxmlNewText(type, type->child != NULL &&
+                                    type->last_child->value.text.string[0] != '(' &&
+                                    type->last_child->value.text.string[0] != '*',
+                              buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "Variable: <<<< %s >>>>\n", buffer);
+                  fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+                  variable = add_variable(MXML_NO_PARENT, "variable", type);
+                  type     = NULL;
+
+                  sort_node(tree, variable);
+
+                  if (scope)
+                    mxmlElementSetAttr(variable, "scope", scope);
+                }
+              }
+              else
+              {
+#ifdef DEBUG
+                fprintf(stderr, "Identifier: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+                mxmlNewText(type, type->child != NULL &&
+                                  type->last_child->value.text.string[0] != '(' &&
+                                  type->last_child->value.text.string[0] != '*',
+                            buffer);
+              }
+            }
+            else if (enumeration && !isdigit(buffer[0] & 255))
+            {
+#ifdef DEBUG
+              fprintf(stderr, "Constant: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+              constant = mxmlNewElement(MXML_NO_PARENT, "constant");
+              mxmlElementSetAttr(constant, "name", buffer);
+              sort_node(enumeration, constant);
+            }
+            else if (type)
+            {
+              mxmlDelete(type);
+              type = NULL;
+            }
+          }
+          break;
+    }
+
+#if DEBUG > 1
+    if (state != oldstate)
+    {
+      fprintf(stderr, "    changed states from %s to %s on receipt of character '%c'...\n",
+              states[oldstate], states[state], oldch);
+      fprintf(stderr, "    variable = %p\n", variable);
+      if (type)
+      {
+        fputs("    type =", stderr);
+        for (temp = type->child; temp; temp = temp->next)
+          fprintf(stderr, " \"%s\"", temp->value.text.string);
+        fputs("\n", stderr);
+      }
+    }
+#endif /* DEBUG > 1 */
+  }
+
+  mxmlDelete(comment);
+
+ /*
+  * All done, return with no errors...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'sort_node()' - Insert a node sorted into a tree.
+ */
+
+static void
+sort_node(mxml_node_t *tree,            /* I - Tree to sort into */
+          mxml_node_t *node)            /* I - Node to add */
+{
+  mxml_node_t   *temp;                  /* Current node */
+  const char    *tempname,              /* Name of current node */
+                *nodename,              /* Name of node */
+                *scope;                 /* Scope */
+
+
+#if DEBUG > 1
+  fprintf(stderr, "    sort_node(tree=%p, node=%p)\n", tree, node);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Range check input...
+  */
+
+  if (!tree || !node || node->parent == tree)
+    return;
+
+ /*
+  * Get the node name...
+  */
+
+  if ((nodename = mxmlElementGetAttr(node, "name")) == NULL)
+    return;
+
+  if (nodename[0] == '_')
+    return;                             /* Hide private names */
+
+#if DEBUG > 1
+  fprintf(stderr, "        nodename=%p (\"%s\")\n", nodename, nodename);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Delete any existing definition at this level, if one exists...
+  */
+
+  if ((temp = mxmlFindElement(tree, tree, node->value.element.name,
+                              "name", nodename, MXML_DESCEND_FIRST)) != NULL)
+  {
+   /*
+    * Copy the scope if needed...
+    */
+
+    if ((scope = mxmlElementGetAttr(temp, "scope")) != NULL &&
+        mxmlElementGetAttr(node, "scope") == NULL)
+    {
+#ifdef DEBUG
+      fprintf(stderr, "    copying scope %s for %s\n", scope, nodename);
+#endif /* DEBUG */
+
+      mxmlElementSetAttr(node, "scope", scope);
+    }
+
+    mxmlDelete(temp);
+  }
+
+ /*
+  * Add the node into the tree at the proper place...
+  */
+
+  for (temp = tree->child; temp; temp = temp->next)
+  {
+#if DEBUG > 1
+    fprintf(stderr, "        temp=%p\n", temp);
+#endif /* DEBUG > 1 */
+
+    if ((tempname = mxmlElementGetAttr(temp, "name")) == NULL)
+      continue;
+
+#if DEBUG > 1
+    fprintf(stderr, "        tempname=%p (\"%s\")\n", tempname, tempname);
+#endif /* DEBUG > 1 */
+
+    if (strcmp(nodename, tempname) < 0)
+      break;
+  }
+
+  if (temp)
+    mxmlAdd(tree, MXML_ADD_BEFORE, temp, node);
+  else
+    mxmlAdd(tree, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+}
+
+
+/*
+ * 'update_comment()' - Update a comment node.
+ */
+
+static void
+update_comment(mxml_node_t *parent,     /* I - Parent node */
+               mxml_node_t *comment)    /* I - Comment node */
+{
+  char  *ptr;                           /* Pointer into comment */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "update_comment(parent=%p, comment=%p)\n",
+          parent, comment);
+#endif /* DEBUG */
+
+ /*
+  * Range check the input...
+  */
+
+  if (!parent || !comment)
+    return;
+
+ /*
+  * Convert "\/" to "/"...
+  */
+
+  for (ptr = strstr(comment->value.text.string, "\\/");
+       ptr;
+       ptr = strstr(ptr, "\\/"))
+    safe_strcpy(ptr, ptr + 1);
+
+ /*
+  * Update the comment...
+  */
+
+  ptr = comment->value.text.string;
+
+  if (*ptr == '\'')
+  {
+   /*
+    * Convert "'name()' - description" to "description".
+    */
+
+    for (ptr ++; *ptr && *ptr != '\''; ptr ++);
+
+    if (*ptr == '\'')
+    {
+      ptr ++;
+      while (isspace(*ptr & 255))
+        ptr ++;
+
+      if (*ptr == '-')
+        ptr ++;
+
+      while (isspace(*ptr & 255))
+        ptr ++;
+
+      safe_strcpy(comment->value.text.string, ptr);
+    }
+  }
+  else if (!strncmp(ptr, "I ", 2) || !strncmp(ptr, "O ", 2) ||
+           !strncmp(ptr, "IO ", 3))
+  {
+   /*
+    * 'Convert "I - description", "IO - description", or "O - description"
+    * to description + direction attribute.
+    */
+
+    ptr = strchr(ptr, ' ');
+    *ptr++ = '\0';
+
+    if (!strcmp(parent->value.element.name, "argument"))
+      mxmlElementSetAttr(parent, "direction", comment->value.text.string);
+
+    while (isspace(*ptr & 255))
+      ptr ++;
+
+    if (*ptr == '-')
+      ptr ++;
+
+    while (isspace(*ptr & 255))
+      ptr ++;
+
+    safe_strcpy(comment->value.text.string, ptr);
+  }
+
+ /*
+  * Eliminate leading and trailing *'s...
+  */
+
+  for (ptr = comment->value.text.string; *ptr == '*'; ptr ++);
+  for (; isspace(*ptr & 255); ptr ++);
+  if (ptr > comment->value.text.string)
+    safe_strcpy(comment->value.text.string, ptr);
+
+  for (ptr = comment->value.text.string + strlen(comment->value.text.string) - 1;
+       ptr > comment->value.text.string && *ptr == '*';
+       ptr --)
+    *ptr = '\0';
+  for (; ptr > comment->value.text.string && isspace(*ptr & 255); ptr --)
+    *ptr = '\0';
+
+#ifdef DEBUG
+  fprintf(stderr, "    updated comment = %s\n", comment->value.text.string);
+#endif /* DEBUG */
+}
+
+
+/*
+ * 'usage()' - Show program usage...
+ */
+
+static void
+usage(const char *option)               /* I - Unknown option */
+{
+  if (option)
+    printf("mxmldoc: Bad option \"%s\"!\n\n", option);
+
+  puts("Usage: mxmldoc [options] [filename.xml] [source files] >filename.html");
+  puts("Options:");
+  puts("    --css filename.css         Set CSS stylesheet file");
+  puts("    --docset bundleid.docset   Generate documentation set");
+  puts("    --docversion version       Set documentation version");
+  puts("    --feedname name            Set documentation set feed name");
+  puts("    --feedurl url              Set documentation set feed URL");
+  puts("    --footer footerfile        Set footer file");
+  puts("    --framed basename          Generate framed HTML to basename*.html");
+  puts("    --header headerfile        Set header file");
+  puts("    --intro introfile          Set introduction file");
+  puts("    --man name                 Generate man page");
+  puts("    --no-output                Do no generate documentation file");
+  puts("    --section section          Set section name");
+  puts("    --title title              Set documentation title");
+  puts("    --tokens path              Generate Xcode docset Tokens.xml file");
+  puts("    --version                  Show mxmldoc/Mini-XML version");
+
+  exit(1);
+}
+
+
+/*
+ * 'write_description()' - Write the description text.
+ */
+
+static void
+write_description(
+    FILE        *out,                   /* I - Output file */
+    mxml_node_t *description,           /* I - Description node */
+    const char  *element,               /* I - HTML element, if any */
+    int         summary)                /* I - Show summary */
+{
+  char  text[10240],                    /* Text for description */
+        *start,                         /* Start of code/link */
+        *ptr;                           /* Pointer into text */
+  int   col;                            /* Current column */
+
+
+  if (!description)
+    return;
+
+  get_text(description, text, sizeof(text));
+
+  ptr = strstr(text, "\n\n");
+
+  if (summary)
+  {
+    if (ptr)
+      *ptr = '\0';
+
+    ptr = text;
+  }
+  else if (!ptr || !ptr[2])
+    return;
+  else
+    ptr += 2;
+
+  if (element && *element)
+    fprintf(out, "<%s class=\"%s\">", element,
+            summary ? "description" : "discussion");
+  else if (!summary)
+    fputs(".PP\n", out);
+
+  for (col = 0; *ptr; ptr ++)
+  {
+    if (*ptr == '@' &&
+        (!strncmp(ptr + 1, "deprecated@", 11) ||
+         !strncmp(ptr + 1, "since ", 6)))
+    {
+      ptr ++;
+      while (*ptr && *ptr != '@')
+        ptr ++;
+
+      if (!*ptr)
+        return;
+    }
+    else if (!strncmp(ptr, "@code ", 6))
+    {
+      for (ptr += 6; isspace(*ptr & 255); ptr ++);
+
+      for (start = ptr, ptr ++; *ptr && *ptr != '@'; ptr ++);
+
+      if (*ptr)
+        *ptr = '\0';
+      else
+        ptr --;
+
+      if (element && *element)
+        fprintf(out, "<code>%s</code>", start);
+      else if (element)
+        fputs(start, out);
+      else
+        fprintf(out, "\\fB%s\\fR", start);
+    }
+    else if (!strncmp(ptr, "@link ", 6))
+    {
+      for (ptr += 6; isspace(*ptr & 255); ptr ++);
+
+      for (start = ptr, ptr ++; *ptr && *ptr != '@'; ptr ++);
+
+      if (*ptr)
+        *ptr = '\0';
+      else
+        ptr --;
+
+      if (element && *element)
+        fprintf(out, "<a href=\"#%s\"><code>%s</code></a>", start, start);
+      else if (element)
+        fputs(start, out);
+      else
+        fprintf(out, "\\fI%s\\fR", start);
+    }
+    else if (element)
+    {
+      if (*ptr == '&')
+        fputs("&amp;", out);
+      else if (*ptr == '<')
+        fputs("&lt;", out);
+      else if (*ptr == '>')
+        fputs("&gt;", out);
+      else if (*ptr == '\"')
+        fputs("&quot;", out);
+      else if (*ptr & 128)
+      {
+       /*
+        * Convert UTF-8 to Unicode constant...
+        */
+
+        int     ch;                     /* Unicode character */
+
+
+        ch = *ptr & 255;
+
+        if ((ch & 0xe0) == 0xc0)
+        {
+          ch = ((ch & 0x1f) << 6) | (ptr[1] & 0x3f);
+          ptr ++;
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+          ch = ((((ch * 0x0f) << 6) | (ptr[1] & 0x3f)) << 6) | (ptr[2] & 0x3f);
+          ptr += 2;
+        }
+
+        if (ch == 0xa0)
+        {
+         /*
+          * Handle non-breaking space as-is...
+          */
+
+          fputs("&nbsp;", out);
+        }
+        else
+          fprintf(out, "&#x%x;", ch);
+      }
+      else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@')
+      {
+        fputs("<br>\n<br>\n", out);
+        ptr ++;
+      }
+      else
+        putc(*ptr, out);
+    }
+    else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@')
+    {
+      fputs("\n.PP\n", out);
+      ptr ++;
+    }
+    else
+    {
+      if (*ptr == '\\' || (*ptr == '.' && col == 0))
+        putc('\\', out);
+
+      putc(*ptr, out);
+
+      if (*ptr == '\n')
+        col = 0;
+      else
+        col ++;
+    }
+  }
+
+  if (element && *element)
+    fprintf(out, "</%s>\n", element);
+  else if (!element)
+    putc('\n', out);
+}
+
+
+/*
+ * 'write_element()' - Write an element's text nodes.
+ */
+
+static void
+write_element(FILE        *out,         /* I - Output file */
+              mxml_node_t *doc,         /* I - Document tree */
+              mxml_node_t *element,     /* I - Element to write */
+              int         mode)         /* I - Output mode */
+{
+  mxml_node_t   *node;                  /* Current node */
+
+
+  if (!element)
+    return;
+
+  for (node = element->child;
+       node;
+       node = mxmlWalkNext(node, element, MXML_NO_DESCEND))
+    if (node->type == MXML_TEXT)
+    {
+      if (node->value.text.whitespace)
+        putc(' ', out);
+
+      if (mode == OUTPUT_HTML &&
+          (mxmlFindElement(doc, doc, "class", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "enumeration", "name",
+                           node->value.text.string, MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "struct", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "typedef", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "union", "name", node->value.text.string,
+                           MXML_DESCEND)))
+      {
+        fputs("<a href=\"#", out);
+        write_string(out, node->value.text.string, mode);
+        fputs("\">", out);
+        write_string(out, node->value.text.string, mode);
+        fputs("</a>", out);
+      }
+      else
+        write_string(out, node->value.text.string, mode);
+    }
+
+  if (!strcmp(element->value.element.name, "type") &&
+      element->last_child->value.text.string[0] != '*')
+    putc(' ', out);
+}
+
+
+/*
+ * 'write_file()' - Copy a file to the output.
+ */
+
+static void
+write_file(FILE       *out,             /* I - Output file */
+           const char *file)            /* I - File to copy */
+{
+  FILE          *fp;                    /* Copy file */
+  char          line[8192];             /* Line from file */
+
+
+  if ((fp = fopen(file, "r")) == NULL)
+  {
+    fprintf(stderr, "mxmldoc: Unable to open \"%s\": %s\n", file,
+            strerror(errno));
+    return;
+  }
+
+  while (fgets(line, sizeof(line), fp))
+    fputs(line, out);
+
+  fclose(fp);
+}
+
+
+/*
+ * 'write_function()' - Write documentation for a function.
+ */
+
+static void
+write_function(FILE        *out,        /* I - Output file */
+               mxml_node_t *doc,        /* I - Document */
+               mxml_node_t *function,   /* I - Function */
+               int         level)       /* I - Base heading level */
+{
+  mxml_node_t   *arg,                   /* Current argument */
+                *adesc,                 /* Description of argument */
+                *description,           /* Description of function */
+                *type,                  /* Type for argument */
+                *node;                  /* Node in description */
+  const char    *name,                  /* Name of function/type */
+                *defval;                /* Default value */
+  char          prefix;                 /* Prefix character */
+  char          *sep;                   /* Newline separator */
+
+
+  name        = mxmlElementGetAttr(function, "name");
+  description = mxmlFindElement(function, function, "description", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+  fprintf(out, "<h%d class=\"%s\">%s<a name=\"%s\">%s</a></h%d>\n",
+          level, level == 3 ? "function" : "method",
+          get_comment_info(description), name, name, level);
+
+  if (description)
+    write_description(out, description, "p", 1);
+
+  fputs("<p class=\"code\">\n", out);
+
+  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                        NULL, MXML_DESCEND_FIRST);
+
+  if (arg)
+    write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                            NULL, MXML_DESCEND_FIRST),
+                  OUTPUT_HTML);
+  else
+    fputs("void ", out);
+
+  fprintf(out, "%s ", name);
+  for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                             MXML_DESCEND_FIRST), prefix = '(';
+       arg;
+       arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                             MXML_NO_DESCEND), prefix = ',')
+  {
+    type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                           MXML_DESCEND_FIRST);
+
+    fprintf(out, "%c<br>\n&nbsp;&nbsp;&nbsp;&nbsp;", prefix);
+    if (type->child)
+      write_element(out, doc, type, OUTPUT_HTML);
+
+    fputs(mxmlElementGetAttr(arg, "name"), out);
+    if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+      fprintf(out, " %s", defval);
+  }
+
+  if (prefix == '(')
+    fputs("(void);</p>\n", out);
+  else
+  {
+    fprintf(out,
+            "<br>\n);</p>\n"
+            "<h%d class=\"parameters\">Parameters</h%d>\n"
+            "<dl>\n", level + 1, level + 1);
+
+    for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+         arg;
+         arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                               MXML_NO_DESCEND))
+    {
+      fprintf(out, "<dt>%s</dt>\n", mxmlElementGetAttr(arg, "name"));
+
+      adesc = mxmlFindElement(arg, arg, "description", NULL, NULL,
+                              MXML_DESCEND_FIRST);
+
+      write_description(out, adesc, "dd", 1);
+      write_description(out, adesc, "dd", 0);
+    }
+
+    fputs("</dl>\n", out);
+  }
+
+  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                        NULL, MXML_DESCEND_FIRST);
+
+  if (arg)
+  {
+    fprintf(out, "<h%d class=\"returnvalue\">Return Value</h%d>\n", level + 1,
+            level + 1);
+
+    adesc = mxmlFindElement(arg, arg, "description", NULL, NULL,
+                            MXML_DESCEND_FIRST);
+
+    write_description(out, adesc, "p", 1);
+    write_description(out, adesc, "p", 0);
+  }
+
+  if (description)
+  {
+    for (node = description->child; node; node = node->next)
+      if (node->value.text.string &&
+          (sep = strstr(node->value.text.string, "\n\n")) != NULL)
+      {
+        sep += 2;
+        if (*sep && strncmp(sep, "@since ", 7) &&
+            strncmp(sep, "@deprecated@", 12))
+          break;
+      }
+
+    if (node)
+    {
+      fprintf(out, "<h%d class=\"discussion\">Discussion</h%d>\n", level + 1,
+              level + 1);
+      write_description(out, description, "p", 0);
+    }
+  }
+}
+
+
+/*
+ * 'write_html()' - Write HTML documentation.
+ */
+
+static void
+write_html(const char  *section,        /* I - Section */
+           const char  *title,          /* I - Title */
+           const char  *footerfile,     /* I - Footer file */
+           const char  *headerfile,     /* I - Header file */
+           const char  *introfile,      /* I - Intro file */
+           const char  *cssfile,        /* I - Stylesheet file */
+           const char  *framefile,      /* I - Framed HTML basename */
+           const char  *docset,         /* I - Documentation set directory */
+           const char  *docversion,     /* I - Documentation set version */
+           const char  *feedname,       /* I - Feed name for doc set */
+           const char  *feedurl,        /* I - Feed URL for doc set */
+           mxml_node_t *doc)            /* I - XML documentation */
+{
+  FILE          *out;                   /* Output file */
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type;                  /* Type for argument */
+  const char    *name,                  /* Name of function/type */
+                *defval,                /* Default value */
+                *basename;              /* Base filename for framed output */
+  char          filename[1024];         /* Current output filename */
+
+
+  if (framefile)
+  {
+   /*
+    * Get the basename of the frame file...
+    */
+
+    if ((basename = strrchr(framefile, '/')) != NULL)
+      basename ++;
+    else
+      basename = framefile;
+
+    if (strstr(basename, ".html"))
+      fputs("mxmldoc: Frame base name should not contain .html extension!\n",
+            stderr);
+
+   /*
+    * Create the container HTML file for the frames...
+    */
+
+    snprintf(filename, sizeof(filename), "%s.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" "
+          "\"http://www.w3.org/TR/html4/frameset.dtd\">\n"
+          "<html>\n"
+          "<head>\n"
+          "\t<title>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</title>\n", out);
+
+    if (section)
+      fprintf(out, "\t<meta name=\"keywords\" content=\"%s\">\n", section);
+
+    fputs("\t<meta http-equiv=\"Content-Type\" "
+          "content=\"text/html;charset=utf-8\">\n"
+          "\t<meta name=\"creator\" content=\"" MXML_VERSION "\">\n"
+          "</head>\n", out);
+
+    fputs("<frameset cols=\"250,*\">\n", out);
+    fprintf(out, "<frame src=\"%s-toc.html\">\n", basename);
+    fprintf(out, "<frame name=\"body\" src=\"%s-body.html\">\n", basename);
+    fputs("</frameset>\n"
+          "<noframes>\n"
+          "<h1>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fprintf(out,
+            "</h1>\n"
+            "<ul>\n"
+            "\t<li><a href=\"%s-toc.html\">Table of Contents</a></li>\n"
+            "\t<li><a href=\"%s-body.html\">Body</a></li>\n"
+            "</ul>\n", basename, basename);
+    fputs("</noframes>\n"
+          "</html>\n", out);
+    fclose(out);
+
+   /*
+    * Write the table-of-contents file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s-toc.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    write_html_head(out, section, title, cssfile);
+
+    snprintf(filename, sizeof(filename), "%s-body.html", basename);
+
+    fputs("<div class=\"contents\">\n", out);
+    fprintf(out, "<h1 class=\"title\"><a href=\"%s\" target=\"body\">",
+            filename);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</a></h1>\n", out);
+
+    write_toc(out, doc, introfile, filename, 0);
+
+    fputs("</div>\n"
+          "</body>\n"
+          "</html>\n", out);
+    fclose(out);
+
+   /*
+    * Finally, open the body file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s-body.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+  }
+  else if (docset)
+  {
+   /*
+    * Create an Xcode documentation set - start by removing any existing
+    * output directory...
+    */
+
+#ifdef __APPLE__
+    const char  *id;                    /* Identifier */
+
+
+    if (!access(docset, 0) && !remove_directory(docset))
+      return;
+
+   /*
+    * Then make the Apple standard bundle directory structure...
+    */
+
+    if (mkdir(docset, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", docset,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents", docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources", docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Documentation",
+             docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+   /*
+    * The Info.plist file, which describes the documentation set...
+    */
+
+    if ((id = strrchr(docset, '/')) != NULL)
+      id ++;
+    else
+      id = docset;
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Info.plist", docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+          "<plist version=\"1.0\">\n"
+          "<dict>\n"
+          "\t<key>CFBundleIdentifier</key>\n"
+          "\t<string>", out);
+    write_string(out, id, OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleName</key>\n"
+          "\t<string>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleVersion</key>\n"
+          "\t<string>", out);
+    write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleShortVersionString</key>\n"
+          "\t<string>", out);
+    write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML);
+    fputs("</string>\n", out);
+
+    if (feedname)
+    {
+      fputs("\t<key>DocSetFeedName</key>\n"
+            "\t<string>", out);
+      write_string(out, feedname ? feedname : title, OUTPUT_HTML);
+      fputs("</string>\n", out);
+    }
+
+    if (feedurl)
+    {
+      fputs("\t<key>DocSetFeedURL</key>\n"
+            "\t<string>", out);
+      write_string(out, feedurl, OUTPUT_HTML);
+      fputs("</string>\n", out);
+    }
+
+    fputs("</dict>\n"
+          "</plist>\n", out);
+
+    fclose(out);
+
+   /*
+    * Next the Nodes.xml file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Nodes.xml",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<DocSetNodes version=\"1.0\">\n"
+          "<TOC>\n"
+          "<Node id=\"0\">\n"
+          "<Name>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</Name>\n"
+          "<Path>Documentation/index.html</Path>\n"
+          "<Subnodes>\n", out);
+
+    write_toc(out, doc, introfile, NULL, 1);
+
+    fputs("</Subnodes>\n"
+          "</Node>\n"
+          "</TOC>\n"
+          "</DocSetNodes>\n", out);
+
+    fclose(out);
+
+   /*
+    * Then the Tokens.xml file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Tokens.xml",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<Tokens version=\"1.0\">\n", out);
+
+    write_tokens(out, doc, "index.html");
+
+    fputs("</Tokens>\n", out);
+
+    fclose(out);
+
+   /*
+    * Finally the HTML file...
+    */
+
+    snprintf(filename, sizeof(filename),
+             "%s/Contents/Resources/Documentation/index.html",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+#else
+    fputs("mxmldoc: Xcode documentation sets can only be created on "
+          "Mac OS X.\n", stderr);
+    return;
+#endif /* __APPLE__ */
+  }
+  else
+    out = stdout;
+
+ /*
+  * Standard header...
+  */
+
+  write_html_head(out, section, title, cssfile);
+
+  fputs("<div class='body'>\n", out);
+
+ /*
+  * Header...
+  */
+
+  if (headerfile)
+  {
+   /*
+    * Use custom header...
+    */
+
+    write_file(out, headerfile);
+  }
+  else
+  {
+   /*
+    * Use standard header...
+    */
+
+    fputs("<h1 class=\"title\">", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</h1>\n", out);
+  }
+
+ /*
+  * Table of contents...
+  */
+
+  if (!framefile)
+    write_toc(out, doc, introfile, NULL, 0);
+
+ /*
+  * Intro...
+  */
+
+  if (introfile)
+    write_file(out, introfile);
+
+ /*
+  * List of classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"CLASSES\">Classes</a></h2>\n", out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "class");
+    }
+  }
+
+ /*
+  * List of functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"FUNCTIONS\">Functions</a></h2>\n", out);
+
+    while (function)
+    {
+      write_function(out, doc, function, 3);
+
+      function = find_public(function, doc, "function");
+    }
+  }
+
+ /*
+  * List of types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"TYPES\">Data Types</a></h2>\n", out);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"typedef\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+        write_description(out, description, "p", 1);
+
+      fputs("<p class=\"code\">\n"
+            "typedef ", out);
+
+      type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+
+      for (type = type->child; type; type = type->next)
+        if (!strcmp(type->value.text.string, "("))
+          break;
+        else
+        {
+          if (type->value.text.whitespace)
+            putc(' ', out);
+
+          if (mxmlFindElement(doc, doc, "class", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "enumeration", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "struct", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "typedef", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "union", "name",
+                              type->value.text.string, MXML_DESCEND))
+          {
+            fputs("<a href=\"#", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("\">", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("</a>", out);
+          }
+          else
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+        }
+
+      if (type)
+      {
+       /*
+        * Output function type...
+        */
+
+        if (type->prev && type->prev->value.text.string[0] != '*')
+          putc(' ', out);
+
+        fprintf(out, "(*%s", name);
+
+        for (type = type->next->next; type; type = type->next)
+        {
+          if (type->value.text.whitespace)
+            putc(' ', out);
+
+          if (mxmlFindElement(doc, doc, "class", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "enumeration", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "struct", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "typedef", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "union", "name",
+                              type->value.text.string, MXML_DESCEND))
+          {
+            fputs("<a href=\"#", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("\">", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("</a>", out);
+          }
+          else
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+        }
+
+        fputs(";\n", out);
+      }
+      else
+      {
+        type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+        if (type->last_child->value.text.string[0] != '*')
+          putc(' ', out);
+
+        fprintf(out, "%s;\n", name);
+      }
+
+      fputs("</p>\n", out);
+
+      scut = find_public(scut, doc, "typedef");
+    }
+  }
+
+ /*
+  * List of structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"STRUCTURES\">Structures</a></h2>\n",
+          out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "struct");
+    }
+  }
+
+ /*
+  * List of unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"UNIONS\">Unions</a></h2>\n", out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "union");
+    }
+  }
+
+ /*
+  * Variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"VARIABLES\">Variables</a></h2>\n",
+          out);
+
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"variable\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+        write_description(out, description, "p", 1);
+
+      fputs("<p class=\"code\">", out);
+
+      write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                              NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_HTML);
+      fputs(mxmlElementGetAttr(arg, "name"), out);
+      if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+        fprintf(out, " %s", defval);
+      fputs(";</p>\n", out);
+
+      arg = find_public(arg, doc, "variable");
+    }
+  }
+
+ /*
+  * List of enumerations...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"ENUMERATIONS\">Constants</a></h2>\n",
+          out);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"enumeration\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+        write_description(out, description, "p", 1);
+
+      fputs("<h4 class=\"constants\">Constants</h4>\n"
+            "<dl>\n", out);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+        fprintf(out, "<dt>%s %s</dt>\n",
+                mxmlElementGetAttr(arg, "name"), get_comment_info(description));
+
+        write_description(out, description, "dd", 1);
+        write_description(out, description, "dd", 0);
+      }
+
+      fputs("</dl>\n", out);
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+  }
+
+ /*
+  * Footer...
+  */
+
+  if (footerfile)
+  {
+   /*
+    * Use custom footer...
+    */
+
+    write_file(out, footerfile);
+  }
+
+  fputs("</div>\n"
+        "</body>\n"
+        "</html>\n", out);
+
+ /*
+  * Close output file as needed...
+  */
+
+  if (out != stdout)
+    fclose(out);
+
+#ifdef __APPLE__
+ /*
+  * When generating document sets, run the docsetutil program to index it...
+  */
+
+  if (docset)
+  {
+    const char  *args[4];               /* Argument array */
+    pid_t       pid;                    /* Process ID */
+    int         status;                 /* Exit status */
+
+
+    args[0] = "/Developer/usr/bin/docsetutil";
+    args[1] = "index";
+    args[2] = docset;
+    args[3] = NULL;
+
+    if (posix_spawn(&pid, args[0], NULL, NULL, (char **)args, environ))
+    {
+      fprintf(stderr, "mxmldoc: Unable to index documentation set \"%s\": %s\n",
+              docset, strerror(errno));
+    }
+    else
+    {
+      while (wait(&status) != pid);
+
+      if (status)
+      {
+        if (WIFEXITED(status))
+          fprintf(stderr, "mxmldoc: docsetutil exited with status %d\n",
+                  WEXITSTATUS(status));
+        else
+          fprintf(stderr, "mxmldoc: docsetutil crashed with signal %d\n",
+                  WTERMSIG(status));
+      }
+      else
+      {
+       /*
+        * Remove unneeded temporary XML files...
+        */
+
+        snprintf(filename, sizeof(filename), "%s/Contents/Resources/Nodes.xml",
+                 docset);
+        unlink(filename);
+
+        snprintf(filename, sizeof(filename), "%s/Contents/Resources/Tokens.xml",
+                 docset);
+        unlink(filename);
+      }
+    }
+  }
+#endif /* __APPLE__ */
+}
+
+
+/*
+ * 'write_html_head()' - Write the standard HTML header.
+ */
+
+static void
+write_html_head(FILE       *out,        /* I - Output file */
+                const char *section,    /* I - Section */
+                const char *title,      /* I - Title */
+                const char *cssfile)    /* I - Stylesheet */
+{
+  fputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" "
+        "\"http://www.w3.org/TR/html4/loose.dtd\">\n"
+        "<html>\n", out);
+
+  if (section)
+    fprintf(out, "<!-- SECTION: %s -->\n", section);
+
+  fputs("<head>\n"
+        "\t<title>", out);
+  write_string(out, title, OUTPUT_HTML);
+  fputs("\t</title>\n", out);
+
+  if (section)
+    fprintf(out, "\t<meta name=\"keywords\" content=\"%s\">\n", section);
+
+  fputs("\t<meta http-equiv=\"Content-Type\" "
+        "content=\"text/html;charset=utf-8\">\n"
+        "\t<meta name=\"creator\" content=\"" MXML_VERSION "\">\n"
+        "<style type=\"text/css\"><!--\n", out);
+
+  if (cssfile)
+  {
+   /*
+    * Use custom stylesheet file...
+    */
+
+    write_file(out, cssfile);
+  }
+  else
+  {
+   /*
+    * Use standard stylesheet...
+    */
+
+    fputs("body, p, h1, h2, h3, h4 {\n"
+          "  font-family: \"lucida grande\", geneva, helvetica, arial, "
+          "sans-serif;\n"
+          "}\n"
+          "div.body h1 {\n"
+          "  font-size: 250%;\n"
+          "  font-weight: bold;\n"
+          "  margin: 0;\n"
+          "}\n"
+          "div.body h2 {\n"
+          "  font-size: 250%;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.body h3 {\n"
+          "  font-size: 150%;\n"
+          "  margin-bottom: 0.5em;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.body h4 {\n"
+          "  font-size: 110%;\n"
+          "  margin-bottom: 0.5em;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.body h5 {\n"
+          "  font-size: 100%;\n"
+          "  margin-bottom: 0.5em;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.contents {\n"
+          "  background: #e8e8e8;\n"
+          "  border: solid thin black;\n"
+          "  padding: 10px;\n"
+          "}\n"
+          "div.contents h1 {\n"
+          "  font-size: 110%;\n"
+          "}\n"
+          "div.contents h2 {\n"
+          "  font-size: 100%;\n"
+          "}\n"
+          "div.contents ul.contents {\n"
+          "  font-size: 80%;\n"
+          "}\n"
+          ".class {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".constants {\n"
+          "}\n"
+          ".description {\n"
+          "  margin-top: 0.5em;\n"
+          "}\n"
+          ".discussion {\n"
+          "}\n"
+          ".enumeration {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".function {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "  margin-bottom: 0;\n"
+          "}\n"
+          ".members {\n"
+          "}\n"
+          ".method {\n"
+          "}\n"
+          ".parameters {\n"
+          "}\n"
+          ".returnvalue {\n"
+          "}\n"
+          ".struct {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".typedef {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".union {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".variable {\n"
+          "}\n"
+          "code, p.code, pre, ul.code li {\n"
+          "  font-family: monaco, courier, monospace;\n"
+          "  font-size: 90%;\n"
+          "}\n"
+          "a:link, a:visited {\n"
+          "  text-decoration: none;\n"
+          "}\n"
+          "span.info {\n"
+          "  background: black;\n"
+          "  border: solid thin black;\n"
+          "  color: white;\n"
+          "  font-size: 80%;\n"
+          "  font-style: italic;\n"
+          "  font-weight: bold;\n"
+          "  white-space: nowrap;\n"
+          "}\n"
+          "h3 span.info, h4 span.info {\n"
+          "  float: right;\n"
+          "  font-size: 100%;\n"
+          "}\n"
+          "ul.code, ul.contents, ul.subcontents {\n"
+          "  list-style-type: none;\n"
+          "  margin: 0;\n"
+          "  padding-left: 0;\n"
+          "}\n"
+          "ul.code li {\n"
+          "  margin: 0;\n"
+          "}\n"
+          "ul.contents > li {\n"
+          "  margin-top: 1em;\n"
+          "}\n"
+          "ul.contents li ul.code, ul.contents li ul.subcontents {\n"
+          "  padding-left: 2em;\n"
+          "}\n"
+          "div.body dl {\n"
+          "  margin-top: 0;\n"
+          "}\n"
+          "div.body dt {\n"
+          "  font-style: italic;\n"
+          "  margin-top: 0;\n"
+          "}\n"
+          "div.body dd {\n"
+          "  margin-bottom: 0.5em;\n"
+          "}\n"
+          "h1.title {\n"
+          "}\n"
+          "h2.title {\n"
+          "  border-bottom: solid 2px black;\n"
+          "}\n"
+          "h3.title {\n"
+          "  border-bottom: solid 2px black;\n"
+          "}\n", out);
+  }
+
+  fputs("--></style>\n"
+        "</head>\n"
+        "<body>\n", out);
+}
+
+
+/*
+ * 'write_man()' - Write manpage documentation.
+ */
+
+static void
+write_man(const char  *man_name,        /* I - Name of manpage */
+          const char  *section,         /* I - Section */
+          const char  *title,           /* I - Title */
+          const char  *footerfile,      /* I - Footer file */
+          const char  *headerfile,      /* I - Header file */
+          const char  *introfile,       /* I - Intro file */
+          mxml_node_t *doc)             /* I - XML documentation */
+{
+  int           i;                      /* Looping var */
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type;                  /* Type for argument */
+  const char    *name,                  /* Name of function/type */
+                *cname,                 /* Class name */
+                *defval,                /* Default value */
+                *parent;                /* Parent class */
+  int           inscope;                /* Variable/method scope */
+  char          prefix;                 /* Prefix character */
+  time_t        curtime;                /* Current time */
+  struct tm     *curdate;               /* Current date */
+  char          buffer[1024];           /* String buffer */
+  static const char * const scopes[] =  /* Scope strings */
+                {
+                  "private",
+                  "protected",
+                  "public"
+                };
+
+
+ /*
+  * Standard man page...
+  */
+
+  curtime = time(NULL);
+  curdate = localtime(&curtime);
+  strftime(buffer, sizeof(buffer), "%x", curdate);
+
+  printf(".TH %s %s \"%s\" \"%s\" \"%s\"\n", man_name, section ? section : "3",
+         title ? title : "", buffer, title ? title : "");
+
+ /*
+  * Header...
+  */
+
+  if (headerfile)
+  {
+   /*
+    * Use custom header...
+    */
+
+    write_file(stdout, headerfile);
+  }
+  else
+  {
+   /*
+    * Use standard header...
+    */
+
+    puts(".SH NAME");
+    printf("%s \\- %s\n", man_name, title ? title : man_name);
+  }
+
+ /*
+  * Intro...
+  */
+
+  if (introfile)
+    write_file(stdout, introfile);
+
+ /*
+  * List of classes...
+  */
+
+  if (find_public(doc, doc, "class"))
+  {
+    puts(".SH CLASSES");
+
+    for (scut = find_public(doc, doc, "class");
+         scut;
+         scut = find_public(scut, doc, "class"))
+    {
+      cname       = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", cname);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "class %s", cname);
+      if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+        printf(" %s", parent);
+      puts("\n{");
+
+      for (i = 0; i < 3; i ++)
+      {
+        inscope = 0;
+
+        for (arg = mxmlFindElement(scut, scut, "variable", "scope", scopes[i],
+                                   MXML_DESCEND_FIRST);
+             arg;
+             arg = mxmlFindElement(arg, scut, "variable", "scope", scopes[i],
+                                   MXML_NO_DESCEND))
+        {
+          if (!inscope)
+          {
+            inscope = 1;
+            printf("  %s:\n", scopes[i]);
+          }
+
+          printf("    ");
+          write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                     NULL, MXML_DESCEND_FIRST),
+                        OUTPUT_MAN);
+          printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+        }
+
+        for (function = mxmlFindElement(scut, scut, "function", "scope",
+                                        scopes[i], MXML_DESCEND_FIRST);
+             function;
+             function = mxmlFindElement(function, scut, "function", "scope",
+                                        scopes[i], MXML_NO_DESCEND))
+        {
+          if (!inscope)
+          {
+            inscope = 1;
+            printf("  %s:\n", scopes[i]);
+          }
+
+          name = mxmlElementGetAttr(function, "name");
+
+          printf("    ");
+
+          arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+          if (arg)
+            write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                       NULL, MXML_DESCEND_FIRST),
+                          OUTPUT_MAN);
+          else if (strcmp(cname, name) && strcmp(cname, name + 1))
+            fputs("void ", stdout);
+
+          printf("%s", name);
+
+          for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                     MXML_DESCEND_FIRST), prefix = '(';
+               arg;
+               arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                     MXML_NO_DESCEND), prefix = ',')
+          {
+            type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                   MXML_DESCEND_FIRST);
+
+            putchar(prefix);
+            if (prefix == ',')
+              putchar(' ');
+
+            if (type->child)
+              write_element(stdout, doc, type, OUTPUT_MAN);
+            fputs(mxmlElementGetAttr(arg, "name"), stdout);
+            if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+              printf(" %s", defval);
+          }
+
+          if (prefix == '(')
+            puts("(void);");
+          else
+            puts(");");
+        }
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of enumerations...
+  */
+
+  if (find_public(doc, doc, "enumeration"))
+  {
+    puts(".SH ENUMERATIONS");
+
+    for (scut = find_public(doc, doc, "enumeration");
+         scut;
+         scut = find_public(scut, doc, "enumeration"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+      write_description(stdout, description, NULL, 0);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+        printf(".TP 5\n%s\n.br\n", mxmlElementGetAttr(arg, "name"));
+        write_description(stdout, description, NULL, 1);
+      }
+    }
+  }
+
+ /*
+  * List of functions...
+  */
+
+  if (find_public(doc, doc, "function"))
+  {
+    puts(".SH FUNCTIONS");
+
+    for (function = find_public(doc, doc, "function");
+         function;
+         function = find_public(function, doc, "function"))
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      puts(".PP\n"
+           ".nf");
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+        write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+      else
+        fputs("void", stdout);
+
+      printf(" %s ", name);
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                 MXML_DESCEND_FIRST), prefix = '(';
+           arg;
+           arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+
+        printf("%c\n    ", prefix);
+        if (type->child)
+          write_element(stdout, doc, type, OUTPUT_MAN);
+        fputs(mxmlElementGetAttr(arg, "name"), stdout);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+          printf(" %s", defval);
+      }
+
+      if (prefix == '(')
+        puts("(void);");
+      else
+        puts("\n);");
+
+      puts(".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of structures...
+  */
+
+  if (find_public(doc, doc, "struct"))
+  {
+    puts(".SH STRUCTURES");
+
+    for (scut = find_public(doc, doc, "struct");
+         scut;
+         scut = find_public(scut, doc, "struct"))
+    {
+      cname       = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", cname);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "struct %s\n{\n", cname);
+      for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        printf("  ");
+        write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+        printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+      }
+
+      for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                      MXML_DESCEND_FIRST);
+           function;
+           function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                      MXML_NO_DESCEND))
+      {
+        name = mxmlElementGetAttr(function, "name");
+
+        printf("  ");
+
+        arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                              NULL, MXML_DESCEND_FIRST);
+
+        if (arg)
+          write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                     NULL, MXML_DESCEND_FIRST),
+                        OUTPUT_MAN);
+        else if (strcmp(cname, name) && strcmp(cname, name + 1))
+          fputs("void ", stdout);
+
+        fputs(name, stdout);
+
+        for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                   MXML_DESCEND_FIRST), prefix = '(';
+             arg;
+             arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                   MXML_NO_DESCEND), prefix = ',')
+        {
+          type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+
+          putchar(prefix);
+          if (prefix == ',')
+            putchar(' ');
+
+          if (type->child)
+            write_element(stdout, doc, type, OUTPUT_MAN);
+          fputs(mxmlElementGetAttr(arg, "name"), stdout);
+          if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+            printf(" %s", defval);
+        }
+
+        if (prefix == '(')
+          puts("(void);");
+        else
+          puts(");");
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of types...
+  */
+
+  if (find_public(doc, doc, "typedef"))
+  {
+    puts(".SH TYPES");
+
+    for (scut = find_public(doc, doc, "typedef");
+         scut;
+         scut = find_public(scut, doc, "typedef"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      fputs(".PP\n"
+            ".nf\n"
+            "typedef ", stdout);
+
+      type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+
+      for (type = type->child; type; type = type->next)
+        if (!strcmp(type->value.text.string, "("))
+          break;
+        else
+        {
+          if (type->value.text.whitespace)
+            putchar(' ');
+
+          write_string(stdout, type->value.text.string, OUTPUT_MAN);
+        }
+
+      if (type)
+      {
+       /*
+        * Output function type...
+        */
+
+        printf(" (*%s", name);
+
+        for (type = type->next->next; type; type = type->next)
+        {
+          if (type->value.text.whitespace)
+            putchar(' ');
+
+          write_string(stdout, type->value.text.string, OUTPUT_MAN);
+        }
+
+        puts(";");
+      }
+      else
+        printf(" %s;\n", name);
+
+      puts(".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of unions...
+  */
+
+  if (find_public(doc, doc, "union"))
+  {
+    puts(".SH UNIONS");
+
+    for (scut = find_public(doc, doc, "union");
+         scut;
+         scut = find_public(scut, doc, "union"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "union %s\n{\n", name);
+      for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        printf("  ");
+        write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+        printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * Variables...
+  */
+
+  if (find_public(doc, doc, "variable"))
+  {
+    puts(".SH VARIABLES");
+
+    for (arg = find_public(doc, doc, "variable");
+         arg;
+         arg = find_public(arg, doc, "variable"))
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      puts(".PP\n"
+           ".nf");
+
+      write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                 NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_MAN);
+      fputs(mxmlElementGetAttr(arg, "name"), stdout);
+      if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+        printf(" %s", defval);
+      puts(";\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+  if (footerfile)
+  {
+   /*
+    * Use custom footer...
+    */
+
+    write_file(stdout, footerfile);
+  }
+}
+
+
+/*
+ * 'write_scu()' - Write a structure, class, or union.
+ */
+
+static void
+write_scu(FILE        *out,     /* I - Output file */
+          mxml_node_t *doc,     /* I - Document */
+          mxml_node_t *scut)    /* I - Structure, class, or union */
+{
+  int           i;                      /* Looping var */
+  mxml_node_t   *function,              /* Current function */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type;                  /* Type for argument */
+  const char    *name,                  /* Name of function/type */
+                *cname,                 /* Class name */
+                *defval,                /* Default value */
+                *parent,                /* Parent class */
+                *scope;                 /* Scope for variable/function */
+  int           inscope,                /* Variable/method scope */
+                maxscope;               /* Maximum scope */
+  char          prefix;                 /* Prefix character */
+  static const char * const scopes[] =  /* Scope strings */
+                {
+                  "private",
+                  "protected",
+                  "public"
+                };
+
+
+  cname       = mxmlElementGetAttr(scut, "name");
+  description = mxmlFindElement(scut, scut, "description", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+  fprintf(out, "<h3 class=\"%s\">%s<a name=\"%s\">%s</a></h3>\n",
+          scut->value.element.name, get_comment_info(description), cname,
+          cname);
+
+  if (description)
+    write_description(out, description, "p", 1);
+
+  fprintf(out, "<p class=\"code\">%s %s", scut->value.element.name, cname);
+  if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+    fprintf(out, " %s", parent);
+  fputs(" {<br>\n", out);
+
+  maxscope = !strcmp(scut->value.element.name, "class") ? 3 : 1;
+
+  for (i = 0; i < maxscope; i ++)
+  {
+    inscope = maxscope == 1;
+
+    for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+         arg;
+         arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                               MXML_NO_DESCEND))
+    {
+      if (maxscope > 1 &&
+          ((scope = mxmlElementGetAttr(arg, "scope")) == NULL ||
+           strcmp(scope, scopes[i])))
+        continue;
+
+      if (!inscope)
+      {
+        inscope = 1;
+        fprintf(out, "&nbsp;&nbsp;%s:<br>\n", scopes[i]);
+      }
+
+      fputs("&nbsp;&nbsp;&nbsp;&nbsp;", out);
+      write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                              NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_HTML);
+      fprintf(out, "%s;<br>\n", mxmlElementGetAttr(arg, "name"));
+    }
+
+    for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                    MXML_DESCEND_FIRST);
+         function;
+         function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                    MXML_NO_DESCEND))
+    {
+      if (maxscope > 1 &&
+          ((scope = mxmlElementGetAttr(arg, "scope")) == NULL ||
+           strcmp(scope, scopes[i])))
+        continue;
+
+      if (!inscope)
+      {
+        inscope = 1;
+        fprintf(out, "&nbsp;&nbsp;%s:<br>\n", scopes[i]);
+      }
+
+      name = mxmlElementGetAttr(function, "name");
+
+      fputs("&nbsp;&nbsp;&nbsp;&nbsp;", out);
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+        write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_HTML);
+      else if (strcmp(cname, name) && strcmp(cname, name + 1))
+        fputs("void ", out);
+
+      fprintf(out, "<a href=\"#%s.%s\">%s</a>", cname, name, name);
+
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                 MXML_DESCEND_FIRST), prefix = '(';
+           arg;
+           arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+
+        putc(prefix, out);
+        if (prefix == ',')
+          putc(' ', out);
+
+        if (type->child)
+          write_element(out, doc, type, OUTPUT_HTML);
+
+        fputs(mxmlElementGetAttr(arg, "name"), out);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+          fprintf(out, " %s", defval);
+      }
+
+      if (prefix == '(')
+        fputs("(void);<br>\n", out);
+      else
+        fputs(");<br>\n", out);
+    }
+  }
+
+  fputs("};</p>\n"
+        "<h4 class=\"members\">Members</h4>\n"
+        "<dl>\n", out);
+
+  for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+       arg;
+       arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                             MXML_NO_DESCEND))
+  {
+    description = mxmlFindElement(arg, arg, "description", NULL,
+                                  NULL, MXML_DESCEND_FIRST);
+
+    fprintf(out, "<dt>%s %s</dt>\n",
+            mxmlElementGetAttr(arg, "name"), get_comment_info(description));
+
+    write_description(out, description, "dd", 1);
+    write_description(out, description, "dd", 0);
+  }
+
+  fputs("</dl>\n", out);
+
+  for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                  MXML_DESCEND_FIRST);
+       function;
+       function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                  MXML_NO_DESCEND))
+  {
+    write_function(out, doc, function, 4);
+  }
+}
+
+
+/*
+ * 'write_string()' - Write a string, quoting HTML special chars as needed.
+ */
+
+static void
+write_string(FILE       *out,           /* I - Output file */
+             const char *s,             /* I - String to write */
+             int        mode)           /* I - Output mode */
+{
+  switch (mode)
+  {
+    case OUTPUT_HTML :
+    case OUTPUT_XML :
+        while (*s)
+        {
+          if (*s == '&')
+            fputs("&amp;", out);
+          else if (*s == '<')
+            fputs("&lt;", out);
+          else if (*s == '>')
+            fputs("&gt;", out);
+          else if (*s == '\"')
+            fputs("&quot;", out);
+          else if (*s & 128)
+          {
+           /*
+            * Convert UTF-8 to Unicode constant...
+            */
+
+            int ch;                     /* Unicode character */
+
+
+            ch = *s & 255;
+
+            if ((ch & 0xe0) == 0xc0)
+            {
+              ch = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
+              s ++;
+            }
+            else if ((ch & 0xf0) == 0xe0)
+            {
+              ch = ((((ch * 0x0f) << 6) | (s[1] & 0x3f)) << 6) | (s[2] & 0x3f);
+              s += 2;
+            }
+
+            if (ch == 0xa0)
+            {
+             /*
+              * Handle non-breaking space as-is...
+              */
+
+              fputs("&nbsp;", out);
+            }
+            else
+              fprintf(out, "&#x%x;", ch);
+          }
+          else
+            putc(*s, out);
+
+          s ++;
+        }
+        break;
+
+    case OUTPUT_MAN :
+        while (*s)
+        {
+          if (*s == '\\' || *s == '-')
+            putc('\\', out);
+
+          putc(*s++, out);
+        }
+        break;
+  }
+}
+
+
+/*
+ * 'write_toc()' - Write a table-of-contents.
+ */
+
+static void
+write_toc(FILE        *out,             /* I - Output file */
+          mxml_node_t *doc,             /* I - Document */
+          const char  *introfile,       /* I - Introduction file */
+          const char  *target,          /* I - Target name */
+          int         xml)              /* I - Write XML nodes? */
+{
+  FILE          *fp;                    /* Intro file */
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description;           /* Description of function/var */
+  const char    *name,                  /* Name of function/type */
+                *targetattr;            /* Target attribute, if any */
+  int           xmlid = 1;              /* Current XML node ID */
+
+
+ /*
+  * If target is set, it is the frame file that contains the body.
+  * Otherwise, we are creating a single-file...
+  */
+
+  if (target)
+    targetattr = " target=\"body\"";
+  else
+    targetattr = "";
+
+ /*
+  * The table-of-contents is a nested unordered list.  Start by
+  * reading any intro file to see if there are any headings there.
+  */
+
+  if (!xml)
+    fputs("<h2 class=\"title\">Contents</h2>\n"
+          "<ul class=\"contents\">\n", out);
+
+  if (introfile && (fp = fopen(introfile, "r")) != NULL)
+  {
+    char        line[8192],             /* Line from file */
+                *ptr,                   /* Pointer in line */
+                *end,                   /* End of line */
+                *anchor,                /* Anchor name */
+                quote,                  /* Quote character for value */
+                level = '2',            /* Current heading level */
+                newlevel;               /* New heading level */
+    int         inelement;              /* In an element? */
+
+
+    while (fgets(line, sizeof(line), fp))
+    {
+     /*
+      * See if this line has a heading...
+      */
+
+      if ((ptr = strstr(line, "<h")) == NULL &&
+          (ptr = strstr(line, "<H")) == NULL)
+        continue;
+
+      if (ptr[2] != '2' && ptr[2] != '3')
+        continue;
+
+      newlevel = ptr[2];
+
+     /*
+      * Make sure we have the whole heading...
+      */
+
+      while (!strstr(line, "</h") && !strstr(line, "</H"))
+      {
+        end = line + strlen(line);
+
+        if (end == (line + sizeof(line) - 1) ||
+            !fgets(end, (int)(sizeof(line) - (end - line)), fp))
+          break;
+      }
+
+     /*
+      * Convert newlines and tabs to spaces...
+      */
+
+      for (ptr = line; *ptr; ptr ++)
+        if (isspace(*ptr & 255))
+          *ptr = ' ';
+
+     /*
+      * Find the anchor and text...
+      */
+
+      for (ptr = strchr(line, '<'); ptr; ptr = strchr(ptr + 1, '<'))
+        if (!strncmp(ptr, "<A NAME=", 8) || !strncmp(ptr, "<a name=", 8))
+          break;
+
+      if (!ptr)
+        continue;
+
+      ptr += 8;
+      inelement = 1;
+
+      if (*ptr == '\'' || *ptr == '\"')
+      {
+       /*
+        * Quoted anchor...
+        */
+
+        quote  = *ptr++;
+        anchor = ptr;
+
+        while (*ptr && *ptr != quote)
+          ptr ++;
+
+        if (!*ptr)
+          continue;
+
+        *ptr++ = '\0';
+      }
+      else
+      {
+       /*
+        * Non-quoted anchor...
+        */
+
+        anchor = ptr;
+
+        while (*ptr && *ptr != '>' && !isspace(*ptr & 255))
+          ptr ++;
+
+        if (!*ptr)
+          continue;
+
+        if (*ptr == '>')
+          inelement = 0;
+
+        *ptr++ = '\0';
+      }
+
+     /*
+      * Write text until we see "</A>"...
+      */
+
+      if (xml)
+      {
+        if (newlevel < level)
+          fputs("</Node>\n"
+                "</Subnodes></Node>\n", out);
+        else if (newlevel > level && newlevel == '3')
+          fputs("<Subnodes>\n", out);
+        else if (xmlid > 1)
+          fputs("</Node>\n", out);
+
+        level = newlevel;
+
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>", xmlid ++, anchor);
+
+        quote = 0;
+
+        while (*ptr)
+        {
+          if (inelement)
+          {
+            if (*ptr == quote)
+              quote = 0;
+            else if (*ptr == '>')
+              inelement = 0;
+            else if (*ptr == '\'' || *ptr == '\"')
+              quote = *ptr;
+          }
+          else if (*ptr == '<')
+          {
+            if (!strncmp(ptr, "</A>", 4) || !strncmp(ptr, "</a>", 4))
+              break;
+
+            inelement = 1;
+          }
+          else
+            putc(*ptr, out);
+
+          ptr ++;
+        }
+
+        fputs("</Name>\n", out);
+      }
+      else
+      {
+        if (newlevel < level)
+          fputs("</li>\n"
+                "</ul></li>\n", out);
+        else if (newlevel > level)
+          fputs("<ul class=\"subcontents\">\n", out);
+        else if (xmlid > 1)
+          fputs("</li>\n", out);
+
+        level = newlevel;
+        xmlid ++;
+
+        fprintf(out, "%s<li><a href=\"%s#%s\"%s>", level > '2' ? "\t" : "",
+                target ? target : "", anchor, targetattr);
+
+        quote = 0;
+
+        while (*ptr)
+        {
+          if (inelement)
+          {
+            if (*ptr == quote)
+              quote = 0;
+            else if (*ptr == '>')
+              inelement = 0;
+            else if (*ptr == '\'' || *ptr == '\"')
+              quote = *ptr;
+          }
+          else if (*ptr == '<')
+          {
+            if (!strncmp(ptr, "</A>", 4) || !strncmp(ptr, "</a>", 4))
+              break;
+
+            inelement = 1;
+          }
+          else
+            putc(*ptr, out);
+
+          ptr ++;
+        }
+
+        fputs("</a>", out);
+      }
+    }
+
+    if (level > '1')
+    {
+      if (xml)
+      {
+        fputs("</Node>\n", out);
+
+        if (level == '3')
+          fputs("</Subnodes></Node>\n", out);
+      }
+      else
+      {
+        fputs("</li>\n", out);
+
+        if (level == '3')
+          fputs("</ul></li>\n", out);
+      }
+    }
+
+    fclose(fp);
+  }
+
+ /*
+  * Next the classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>CLASSES</Anchor>\n"
+                   "<Name>Classes</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#CLASSES\"%s>Classes</a>"
+                   "<ul class=\"code\">\n",
+              target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "class");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>FUNCTIONS</Anchor>\n"
+                   "<Name>Functions</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#FUNCTIONS\"%s>Functions</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (function)
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      function = find_public(function, doc, "function");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Data types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>TYPES</Anchor>\n"
+                   "<Name>Data Types</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#TYPES\"%s>Data Types</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "typedef");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>STRUCTURES</Anchor>\n"
+                   "<Name>Structures</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#STRUCTURES\"%s>Structures</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "struct");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>UNIONS</Anchor>\n"
+                   "<Name>Unions</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out,
+              "<li><a href=\"%s#UNIONS\"%s>Unions</a><ul class=\"code\">\n",
+              target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "union");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Globals variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>VARIABLES</Anchor>\n"
+                   "<Name>Variables</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#VARIABLES\"%s>Variables</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      arg = find_public(arg, doc, "variable");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Enumerations/constants...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>ENUMERATIONS</Anchor>\n"
+                   "<Name>Constants</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#ENUMERATIONS\"%s>Constants</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Close out the HTML table-of-contents list as needed...
+  */
+
+  if (!xml)
+    fputs("</ul>\n", out);
+}
+
+
+/*
+ * 'write_tokens()' - Write <Token> nodes for all APIs.
+ */
+
+static void
+write_tokens(FILE        *out,          /* I - Output file */
+             mxml_node_t *doc,          /* I - Document */
+             const char  *path)         /* I - Path to help file */
+{
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type,                  /* Type node */
+                *node;                  /* Current child node */
+  const char    *name,                  /* Name of function/type */
+                *cename,                /* Current class/enum name */
+                *defval;                /* Default value for argument */
+  char          prefix;                 /* Prefix for declarations */
+
+
+ /*
+  * Classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    while (scut)
+    {
+      cename      = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/cpp/cl/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, cename, cename);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      if ((function = find_public(scut, scut, "function")) != NULL)
+      {
+        while (function)
+        {
+          name        = mxmlElementGetAttr(function, "name");
+          description = mxmlFindElement(function, function, "description",
+                                        NULL, NULL, MXML_DESCEND_FIRST);
+
+          fprintf(out, "<Token>\n"
+                       "<Path>Documentation/%s</Path>\n"
+                       "<Anchor>%s.%s</Anchor>\n"
+                       "<TokenIdentifier>//apple_ref/cpp/clm/%s/%s", path,
+                  cename, name, cename, name);
+
+          arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+          if (arg && (type = mxmlFindElement(arg, arg, "type", NULL,
+                                             NULL, MXML_DESCEND_FIRST)) != NULL)
+          {
+            for (node = type->child; node; node = node->next)
+              fputs(node->value.text.string, out);
+          }
+          else if (strcmp(cename, name) && strcmp(cename, name + 1))
+            fputs("void", out);
+
+          fputs("/", out);
+
+          for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                     MXML_DESCEND_FIRST), prefix = '(';
+               arg;
+               arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                     MXML_NO_DESCEND), prefix = ',')
+          {
+            type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                   MXML_DESCEND_FIRST);
+
+            putc(prefix, out);
+
+            for (node = type->child; node; node = node->next)
+              fputs(node->value.text.string, out);
+
+            fputs(mxmlElementGetAttr(arg, "name"), out);
+          }
+
+          if (prefix == '(')
+            fputs("(void", out);
+
+          fputs(")</TokenIdentifier>\n"
+                "<Abstract>", out);
+          write_description(out, description, "", 1);
+          fputs("</Abstract>\n"
+                "<Declaration>", out);
+
+          arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+          if (arg)
+            write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                    NULL, MXML_DESCEND_FIRST),
+                          OUTPUT_XML);
+          else if (strcmp(cename, name) && strcmp(cename, name + 1))
+            fputs("void ", out);
+
+          fputs(name, out);
+
+          for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                     MXML_DESCEND_FIRST), prefix = '(';
+               arg;
+               arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                     MXML_NO_DESCEND), prefix = ',')
+          {
+            type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                   MXML_DESCEND_FIRST);
+
+            putc(prefix, out);
+            if (prefix == ',')
+              putc(' ', out);
+
+            if (type->child)
+              write_element(out, doc, type, OUTPUT_XML);
+
+            fputs(mxmlElementGetAttr(arg, "name"), out);
+            if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+              fprintf(out, " %s", defval);
+          }
+
+          if (prefix == '(')
+            fputs("(void);", out);
+          else
+            fputs(");", out);
+
+          fputs("</Declaration>\n"
+                "</Token>\n", out);
+
+          function = find_public(function, doc, "function");
+        }
+      }
+      scut = find_public(scut, doc, "class");
+    }
+  }
+
+ /*
+  * Functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    while (function)
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/func/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "<Declaration>", out);
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+        write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_XML);
+      else // if (strcmp(cname, name) && strcmp(cname, name + 1))
+        fputs("void ", out);
+
+      fputs(name, out);
+
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                 MXML_DESCEND_FIRST), prefix = '(';
+           arg;
+           arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+
+        putc(prefix, out);
+        if (prefix == ',')
+          putc(' ', out);
+
+        if (type->child)
+          write_element(out, doc, type, OUTPUT_XML);
+
+        fputs(mxmlElementGetAttr(arg, "name"), out);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+          fprintf(out, " %s", defval);
+      }
+
+      if (prefix == '(')
+        fputs("(void);", out);
+      else
+        fputs(");", out);
+
+      fputs("</Declaration>\n"
+            "</Token>\n", out);
+
+      function = find_public(function, doc, "function");
+    }
+  }
+
+ /*
+  * Data types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tdef/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "typedef");
+    }
+  }
+
+ /*
+  * Structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "struct");
+    }
+  }
+
+ /*
+  * Unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "union");
+    }
+  }
+
+ /*
+  * Globals variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/data/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      arg = find_public(arg, doc, "variable");
+    }
+  }
+
+ /*
+  * Enumerations/constants...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    while (scut)
+    {
+      cename      = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, cename, cename);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        name        = mxmlElementGetAttr(arg, "name");
+        description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+        fprintf(out, "<Token>\n"
+                     "<Path>Documentation/%s</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<TokenIdentifier>//apple_ref/c/econst/%s</TokenIdentifier>\n"
+                     "<Abstract>", path, cename, name);
+        write_description(out, description, "", 1);
+        fputs("</Abstract>\n"
+              "</Token>\n", out);
+      }
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+  }
+}
+
+
+/*
+ * 'ws_cb()' - Whitespace callback for saving.
+ */
+
+static const char *                     /* O - Whitespace string or NULL for none */
+ws_cb(mxml_node_t *node,                /* I - Element node */
+      int         where)                /* I - Where value */
+{
+  const char *name;                     /* Name of element */
+  int   depth;                          /* Depth of node */
+  static const char *spaces = "                                        ";
+                                        /* Whitespace (40 spaces) for indent */
+
+
+  name = node->value.element.name;
+
+  switch (where)
+  {
+    case MXML_WS_BEFORE_CLOSE :
+        if (strcmp(name, "argument") &&
+            strcmp(name, "class") &&
+            strcmp(name, "constant") &&
+            strcmp(name, "enumeration") &&
+            strcmp(name, "function") &&
+            strcmp(name, "mxmldoc") &&
+            strcmp(name, "namespace") &&
+            strcmp(name, "returnvalue") &&
+            strcmp(name, "struct") &&
+            strcmp(name, "typedef") &&
+            strcmp(name, "union") &&
+            strcmp(name, "variable"))
+          return (NULL);
+
+        for (depth = -4; node; node = node->parent, depth += 2);
+        if (depth > 40)
+          return (spaces);
+        else if (depth < 2)
+          return (NULL);
+        else
+          return (spaces + 40 - depth);
+
+    case MXML_WS_AFTER_CLOSE :
+        return ("\n");
+
+    case MXML_WS_BEFORE_OPEN :
+        for (depth = -4; node; node = node->parent, depth += 2);
+        if (depth > 40)
+          return (spaces);
+        else if (depth < 2)
+          return (NULL);
+        else
+          return (spaces + 40 - depth);
+
+    default :
+    case MXML_WS_AFTER_OPEN :
+        if (strcmp(name, "argument") &&
+            strcmp(name, "class") &&
+            strcmp(name, "constant") &&
+            strcmp(name, "enumeration") &&
+            strcmp(name, "function") &&
+            strcmp(name, "mxmldoc") &&
+            strcmp(name, "namespace") &&
+            strcmp(name, "returnvalue") &&
+            strcmp(name, "struct") &&
+            strcmp(name, "typedef") &&
+            strcmp(name, "union") &&
+            strcmp(name, "variable") &&
+            strncmp(name, "?xml", 4))
+          return (NULL);
+        else
+          return ("\n");
+  }
+}
+
+
+/*
+ * End of "$Id: mxmldoc.c 440 2011-08-11 18:51:26Z mike $".
+ */
diff --git a/pathologist/src/pathologist/Makefile.am b/pathologist/src/pathologist/Makefile.am
new file mode 100644
index 0000000..215d892
--- /dev/null
+++ b/pathologist/src/pathologist/Makefile.am
@@ -0,0 +1,58 @@
+INCLUDES = -I$(top_srcdir)/src/include
+
+if MINGW
+        WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols 
+endif
+
+if USE_COVERAGE
+        AM_CFLAGS = --coverage -O0
+        XLIB = -lgcov
+endif
+
+
+if !MINGW
+if HAVE_ESMTP
+if HAVE_OPENSSL
+
+bin_PROGRAMS = \
+        pathologist
+
+pathologist_SOURCES = \
+        pathologist.c \
+        getopt.c \
+        getopt_helpers.c \
+        mail_sender.c \
+        action.c \
+        xml_writer.c \
+        edb_api.c
+
+pathologist_LDADD = \
+        $(top_builddir)/src/mi/libmi.la \
+        $(top_builddir)/src/util/libpathologistutil.la \
+        -lesmtp \
+        -lsqlite3 \
+        $(XLIB) \
+        $(GN_LIBINTL)
+
+if ENABLE_TEST_RUN
+if SEASPIDER
+TESTS = $(check_PROGRAMS)
+endif
+endif
+
+check_PROGRAMS = \
+        test_pathologist        
+
+test_pathologist_SOURCES = \
+        test_pathologist.c
+
+test_pathologist_LDADD = \
+        $(top_builddir)/src/minixml/libminixml.la
+
+EXTRA_DIST = \
+        ../../refs  
+
+
+endif
+endif
+endif
diff --git a/pathologist/src/pathologist/action.c b/pathologist/src/pathologist/action.c
new file mode 100644
index 0000000..dcd1872
--- /dev/null
+++ b/pathologist/src/pathologist/action.c
@@ -0,0 +1,1124 @@
+
+#include "monkey_common.h"
+#include "action.h"
+#include "pathologist_edb.h"
+#include "pathologist_xml_writer.h"
+#include <libesmtp.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+extern void sendMail(const char *messageContents, const char *reportFileName,
+                     const char *emailAddress);
+
+static int crashExpressionFoundInEDB = MONKEY_YES;
+static int async_c = 0;
+static int stoppedInSharedLib = MONKEY_NO;
+static int failureFunctionStartLine = 0;        // start line number of the function in which the failure occurs
+static struct WatchInfo *watchInfoListHead = NULL;
+static struct WatchInfo *watchInfoListTail = NULL;
+static struct FileName *fileNameListHead = NULL;
+static struct FileName *fileNameListTail = NULL;
+static struct ScopeEnd *scopeEndListHead = NULL;
+static struct ScopeEnd *scopeEndListTail = NULL;
+
+
+struct ScopeEnd {
+    struct ScopeEnd *next;
+    struct ScopeEnd *prev;
+
+    int lineNo;
+};
+
+
+struct FileName {
+    struct FileName *next;
+    struct FileName *prev;
+
+    const char *name;
+};
+
+
+struct Expression {
+    struct Expression *next;
+    struct Expression *prev;
+    const char *expressionSyntax;
+    const char *expressionValue;
+    int isCall;
+};
+
+
+struct Function {
+    struct Function *next;
+    struct Function *prev;
+    const char *name;
+    const char *file;
+    int line;
+    int depth;
+    struct Expression *expressionListHead;
+    struct Expression *expressionListTail;
+};
+
+struct Trace {
+    struct Trace *next;
+    struct Trace *prev;
+    struct Function *functionListHead;
+    struct Function *functionListTail;
+        struct Expression *globalsListHead;
+        struct Expression *globalsListTail;
+};
+
+
+struct Epoch {
+    struct Trace *traceListHead;
+    struct Trace *traceListTail;
+} *epoch;
+
+struct WatchInfo {
+    struct WatchInfo *next;
+    struct WatchInfo *prev;
+    int hitNumber;
+    const char *value;
+};
+
+
+static void cb_console(const char *str, void *data)
+{
+    printf("CONSOLE> %s\n", str);
+}
+
+
+/* Note that unlike what's documented in gdb docs it isn't usable. */
+static void cb_target(const char *str, void *data)
+{
+    printf("TARGET> %s\n", str);
+}
+
+
+static void cb_log(const char *str, void *data)
+{
+    printf("LOG> %s\n", str);
+}
+
+
+static void cb_to(const char *str, void *data)
+{
+    printf(">> %s", str);
+}
+
+
+static void cb_from(const char *str, void *data)
+{
+    printf("<< %s\n", str);
+}
+
+
+static void cb_async(mi_output * o, void *data)
+{
+    printf("ASYNC\n");
+    async_c++;
+}
+
+static int isInCodeBase(const char *name)
+{
+        struct FileName *fileName = fileNameListHead;
+        while (fileName) {
+                if (strstr(name, fileName->name))
+                        return MONKEY_YES;
+                fileName = fileName->next;
+        }
+        return MONKEY_NO;
+}
+
+
+static int wait_for_stop(struct MONKEY_ACTION_Context *cntxt)
+{
+    static int safetyCount = 0;
+
+    while (!mi_get_response(cntxt->gdb_handle))
+                usleep(GDB_MI_ASYNC_WAIT);
+    /* The end of the async. */
+
+    cntxt->gdb_stop_reason = mi_res_stop(cntxt->gdb_handle);
+
+    if (cntxt->gdb_stop_reason) {
+                safetyCount = 0;        // reset the Safety Count whenever you stop for a meaningful reason
+
+                switch (cntxt->gdb_stop_reason->reason) {
+                case sr_exited_normally:
+                        return GDB_STATE_EXIT_NORMALLY;
+                case sr_signal_received:
+                        //gmi_set_unwind_on_signal_on(cntxt->gdb_handle);       // Program crashed. From now on preserve stack on any further received signals
+                        break;
+                case sr_bkpt_hit:
+                        {
+                        /* continue execution */
+                        gmi_exec_continue(cntxt->gdb_handle);
+                        return wait_for_stop(cntxt);
+                        }
+                case sr_wp_trigger:
+                        {
+                        /* Execution stopped because of hitting a watch point */
+                        static int watchPointHitNumber = 0;
+                        struct WatchInfo *watchInfo =
+                                MONKEY_malloc(sizeof(struct WatchInfo));
+                        watchInfo->hitNumber = ++watchPointHitNumber;
+                        watchInfo->value = cntxt->gdb_stop_reason->wp_val;
+                        MONKEY_CONTAINER_DLL_insert(watchInfoListHead,
+                                                        watchInfoListTail, watchInfo);
+                        if (watchPointHitNumber == 1023)
+                                printf("HEY! 1023! WE ARE GETTING OUT OF THE LOOP!\n");
+                        gmi_exec_continue(cntxt->gdb_handle);
+                        return wait_for_stop(cntxt);
+                        }
+                case sr_wp_scope:
+                        gmi_exec_continue(cntxt->gdb_handle);
+                        return wait_for_stop(cntxt);
+                default:
+                        break;
+                }
+
+                /* Reaching this line means that the program has stopped abnormally
+                 * OR we are in backtracking mode, and it's a step backward */
+                cntxt->gdb_frames = gmi_stack_list_frames(cntxt->gdb_handle);
+                while(cntxt->gdb_frames && !cntxt->gdb_frames->file) {
+                        cntxt->gdb_frames = cntxt->gdb_frames->next;
+                }
+
+                if(cntxt->gdb_frames && !isInCodeBase(cntxt->gdb_frames->file)) {
+                        struct FileName* filen;
+                        for(filen=fileNameListHead; filen; filen = filen->next)
+                                if(filen->name) printf("%s\n", filen->name);
+                        while(cntxt->gdb_frames) {
+                                if(cntxt->gdb_frames->file)
+                                        printf("file: %s\nisInCodeBase: %d\n", cntxt->gdb_frames->file, isInCodeBase(cntxt->gdb_frames->file));
+                                if(cntxt->gdb_frames->file && isInCodeBase(cntxt->gdb_frames->file)) {
+                                        break;
+                                }
+                                cntxt->gdb_frames = cntxt->gdb_frames->next;
+                        }
+
+                        if (cntxt->gdb_frames && cntxt->run_reverse) {
+                                /* We are in backtracking mode, we need to move GDB from the shared library to our source code */
+                                stoppedInSharedLib = MONKEY_YES;
+                                gmi_break_insert(cntxt->gdb_handle, cntxt->gdb_frames->file,
+                                                 cntxt->gdb_frames->line);
+                                gmi_exec_continue_reverse(cntxt->gdb_handle);
+                                while (!mi_get_response(cntxt->gdb_handle))
+                                        usleep(GDB_MI_ASYNC_WAIT);
+                                cntxt->gdb_frames = gmi_stack_list_frames(cntxt->gdb_handle);
+                        }
+                }
+
+                if (NULL == cntxt->gdb_frames) {
+                        fprintf(stderr, "Cannot get stack frames from gdb. You might be debugging the wrong program.\n"); // Something really bad happened. Abort!
+                        return GDB_STATE_ERROR;
+                }
+
+                /* Change current GDB frame to the one containing source code */
+                gmi_stack_select_frame(cntxt->gdb_handle,
+                                           cntxt->gdb_frames->level);
+
+                return GDB_STATE_STOPPED;
+    }
+    else if ((MONKEY_YES == cntxt->run_reverse) && (safetyCount < GDB_SAFETY_COUNT)) {  // GDB_SAFETY_COUNT prevents infinite analysis
+        /* If the stop reason is NULL, don't bail out immediately, wait for stop again.
+         * It happens when a breakpoint is placed (for backtracking) that the program stops for an unknown reason,
+         * resulting in a NULL stop reason which causes Monkey to bail out before finishing its analysis. This else if
+         * clause prevents premature bail out
+         */
+        safetyCount++;
+        return wait_for_stop(cntxt);
+    }
+
+    return GDB_STATE_ERROR;
+}
+
+
+int
+MONKEY_ACTION_report_file(struct MONKEY_ACTION_Context *cntxt,
+                          const char *dumpFileName, int isXML)
+{
+        FILE *f;
+        f = MONKEY_XML_WRITER_create_document(dumpFileName);
+        if (NULL == f) {
+                fprintf(stderr, "Error: pathologist was not able to create report file.\n");
+                return MONKEY_NO;
+        }
+        MONKEY_XML_WRITER_write_document(f, cntxt->xml_report_node);
+        if (0 != fclose(f)) {
+                fprintf(stderr, "Error: pathologist could not close report file.\n");
+                return MONKEY_NO;
+        }
+    return MONKEY_OK;
+}
+
+
+int MONKEY_ACTION_report_email(struct MONKEY_ACTION_Context *cntxt, const char * dumpFileName)
+{
+        FILE *f;
+        MONKEY_ACTION_format_report_xml(cntxt);
+        f = MONKEY_XML_WRITER_create_document(dumpFileName);
+        MONKEY_XML_WRITER_write_document(f, cntxt->xml_report_node);
+        fclose(f);
+        sendMail(NULL, dumpFileName, cntxt->email_address);
+    return MONKEY_OK;
+}
+
+
+static int
+iterateFileNames(void *cls, int numColumns, char **colValues,
+                 char **colNames)
+{
+    struct FileName *fileName;
+    char *token;
+
+    if (NULL == colValues[0])
+        return 1;               /* Error */
+
+    // This is done to extract the only the file name from the full path coming from the Database
+    token = strrchr(colValues[0], '/');
+    if (NULL == token) {
+        token = colValues[0];
+    } else {
+        token++;
+    }
+    fileName = MONKEY_malloc(sizeof(struct FileName));
+    fileName->prev = NULL;
+    fileName->next = NULL;
+    fileName->name = MONKEY_strdup(token);
+    MONKEY_CONTAINER_DLL_insert(fileNameListHead, fileNameListTail, fileName);
+    return 0; /* OK */
+}
+
+
+static int
+outerScopesCallback(void *cls, int numColumns, char **colValues,
+                    char **colNames)
+{
+    if (NULL == colValues[0])
+        return 1;               /* Error */
+
+    struct ScopeEnd *scopeEnd = MONKEY_malloc(sizeof(struct ScopeEnd));
+    scopeEnd->lineNo = atoi(colValues[0]);
+    MONKEY_CONTAINER_DLL_insert(scopeEndListHead, scopeEndListTail,
+                                scopeEnd);
+    return 0;                   /* OK */
+}
+
+
+static int
+iterateExpressions(void *cls, int numColumns, char **colValues,
+                   char **colNames)
+{
+    struct Expression *expression;
+    struct Function *function = (struct Function *) cls;
+
+    if (NULL == colValues[0] || NULL == colValues[1])
+                return 1;               /* Error */
+
+    expression = MONKEY_malloc(sizeof(struct Expression));
+    expression->expressionSyntax = MONKEY_strdup(colValues[0]);
+    expression->isCall = atoi(colValues[1]);
+    expression->expressionValue = NULL;
+    expression->next = NULL;
+    expression->prev = NULL;
+
+    MONKEY_CONTAINER_DLL_insert(function->expressionListHead,
+                                function->expressionListTail, expression);
+
+    return 0;                   /* OK */
+}
+
+
+static int
+iterateGlobals(void *cls, int numColumns, char **colValues,
+                   char **colNames)
+{
+    struct Expression *expression;
+    struct Trace *trace = (struct Trace *) cls;
+
+    if (NULL == colValues[0] || NULL == colValues[1])
+                return 1;               /* Error */
+
+    expression = MONKEY_malloc(sizeof(struct Expression));
+    expression->expressionSyntax = MONKEY_strdup(colValues[0]);
+    expression->isCall = atoi(colValues[1]);
+    expression->expressionValue = NULL;
+    expression->next = NULL;
+    expression->prev = NULL;
+
+    MONKEY_CONTAINER_DLL_insert(trace->globalsListHead,
+                                trace->globalsListTail, expression);
+
+    return 0;                   /* OK */
+}
+
+
+static int
+scopeEndCallback(void *cls, int numColumns, char **colValues,
+                 char **colNames)
+{
+    int *scopeEnd = (int *) cls;
+
+    *scopeEnd = atoi(colValues[0]);
+    if (*scopeEnd < 0)
+        return 1;               /* Error */
+    return 0;
+}
+
+
+static int isAssignment(const char *expressionSyntax)
+{
+    return (NULL != strstr(expressionSyntax, "=")) ? MONKEY_YES : MONKEY_NO;
+}
+
+
+static struct Expression*
+analyzeExpressionValue( struct MONKEY_ACTION_Context *cntxt,
+                                        struct Expression *expr,
+                                        struct Expression **expressionListHead,
+                                        struct Expression **expressionListTail)
+{
+        MONKEY_assert(expr);
+        struct Expression *next = expr->next;
+        struct Expression *removedExpression = expr;
+
+        // We will not evaluate function calls (because GDB will evaluate by calling the function)
+        if( expr->isCall )
+                goto remove;
+
+        // We should NOT evaluate assignments, otherwise subsequent expression evaluations will be spoiled
+        else if( isAssignment(expr->expressionSyntax) )
+                goto remove;
+
+        // NULL Pointer are also ignored (cause theire NULL)
+        if (strcmp(expr->expressionSyntax, "NULL") == 0 ||
+                strcmp(expr->expressionSyntax, "0x0") == 0 ||
+                strcmp(expr->expressionSyntax, "((void*)0)") == 0)
+                goto remove;
+
+        expr->expressionValue =
+        gmi_data_evaluate_expression(   cntxt->gdb_handle,
+                                                                        expr->expressionSyntax);
+
+        // ignore trivial report entries (constants for that matter)
+        if (expr->expressionValue && strcmp(expr->expressionSyntax, expr->expressionValue) == 0)
+                goto remove;
+
+        // ignore functionpointers with their default names
+        size_t value_len; //= strlen(expr->expressionValue);
+        size_t syntax_len; //= strlen(expr->expressionSyntax);
+        if (expr->expressionValue &&
+                (value_len = strlen(expr->expressionValue)) > (syntax_len = strlen(expr->expressionSyntax)) + 2 &&
+                !strncmp(expr->expressionValue + value_len - 1, ">", 1) &&
+                !strncmp(expr->expressionValue + value_len - syntax_len - 2, "<", 1) &&
+                !strncmp(expr->expressionValue + value_len - syntax_len - 1, expr->expressionSyntax, syntax_len))
+                goto remove;
+        
+        if (NULL != expr->expressionValue
+        && (strcmp(expr->expressionValue, "0x0") == 0
+                || strcmp(expr->expressionValue, "NULL") == 0))
+        {
+                expr->expressionValue = "NULL";
+                cntxt->gdb_null_variable = expr->expressionSyntax;
+                cntxt->has_null = MONKEY_YES;
+        }
+
+        return next;
+
+remove:
+        MONKEY_CONTAINER_DLL_remove(*expressionListHead,
+                                                                *expressionListTail,
+                                                                removedExpression);
+        return next;
+}
+
+
+static int
+analyzeExpressionValues(struct Function *function,
+                         struct MONKEY_ACTION_Context *cntxt)
+{
+    struct Expression *tmp;
+
+        tmp = function->expressionListHead;
+        while (NULL != tmp) {
+                tmp = analyzeExpressionValue(cntxt, tmp, &(function->expressionListHead), &(function->expressionListTail));
+        }
+
+    return MONKEY_OK;
+}
+
+
+static int
+analyzeGlobalsValues(struct Trace *trace,
+                         struct MONKEY_ACTION_Context *cntxt)
+{
+    struct Expression *tmp;
+
+        tmp = trace->globalsListHead;
+        while (NULL != tmp) {
+                tmp = analyzeExpressionValue(cntxt, tmp, &(trace->globalsListHead), &(trace->globalsListTail));
+        }
+
+    return MONKEY_OK;
+}
+
+
+static int flushTrace(struct Trace *trace)
+{
+    struct Function *functionPtr = NULL;
+    struct Expression *expressionPtr = NULL;
+
+    while (NULL != trace->functionListHead) {
+        functionPtr = trace->functionListHead;
+        trace->functionListHead = trace->functionListHead->next;
+
+        while (NULL != functionPtr->expressionListHead) {
+            expressionPtr = functionPtr->expressionListHead;
+            functionPtr->expressionListHead =
+                functionPtr->expressionListHead->next;
+
+            MONKEY_free((char *) expressionPtr->expressionSyntax);
+            MONKEY_free(expressionPtr);
+        }
+        MONKEY_free(functionPtr);
+    }
+    return MONKEY_OK;
+}
+
+static void printTrace()
+{
+    int i = 0;
+    struct Function *functionPtr;
+    struct Expression *expressionPtr;
+    struct Trace *tracePtr = epoch->traceListHead;
+    while (NULL != tracePtr) {
+        printf("Program Stack Trace: Epoch Step %d\n", i++);
+        functionPtr = tracePtr->functionListHead;
+        while (NULL != functionPtr) {
+            printf("Function: %s, file: %s, line: %d\n", functionPtr->name,
+                   functionPtr->file, functionPtr->line);
+            printf
+                ("--------------------------------------------------------------------------------------------------\n");
+            printf("Expressions:\n");
+
+            expressionPtr = functionPtr->expressionListHead;
+            while (NULL != expressionPtr) {
+                printf("%s = %s\n",
+                       expressionPtr->expressionSyntax,
+                       (NULL ==
+                        expressionPtr->
+                        expressionValue) ? "No Value" : expressionPtr->
+                       expressionValue);
+                expressionPtr = expressionPtr->next;
+            }
+
+            functionPtr = functionPtr->next;
+        }
+        printf
+            ("############################## End Stack Trace ######################################################\n\n");
+        tracePtr = tracePtr->next;
+    }
+}
+
+static void flushScopeEndList()
+{
+        struct ScopeEnd* scopeEndPtr;
+        while (NULL != scopeEndListHead) {
+                scopeEndPtr = scopeEndListHead;
+                scopeEndListHead = scopeEndPtr->next;
+                MONKEY_free(scopeEndPtr);
+        }
+
+        scopeEndListHead = NULL;
+        scopeEndListTail = NULL;
+}
+
+int MONKEY_ACTION_inspect_expression_database(struct MONKEY_ACTION_Context *cntxt)
+{
+    int ret = MONKEY_OK;
+    int stackDepth = 0;
+        char* file_names = NULL;
+    struct Function *function = NULL;
+    struct Trace *trace = NULL;
+
+    /* Variables used across recursive calls */
+    static struct MONKEY_EDB_Context *edbCntxt;
+
+    if (NULL == epoch) {
+                epoch = MONKEY_malloc(sizeof(struct Epoch));
+                epoch->traceListHead = NULL;
+                epoch->traceListTail = NULL;
+    }
+
+        // Initialize the trace structure for this particular epoch step
+        trace = MONKEY_malloc(sizeof(struct Trace));
+        trace->globalsListHead = NULL;
+        trace->globalsListTail = NULL;
+        MONKEY_CONTAINER_DLL_insert_tail(epoch->traceListHead,
+                                         epoch->traceListTail, trace);
+
+
+        // Create a connection to the Expression Database
+        edbCntxt = MONKEY_EDB_connect(cntxt->expression_database_path);
+        if (NULL == edbCntxt) {
+                fprintf(stderr, "Unable to connect to Expression Database file!\n");
+                ret = MONKEY_NO;
+                goto cleanup;
+        }
+
+        while( cntxt->gdb_frames && stackDepth <= cntxt->scope_depth) {
+                gmi_stack_select_frame(cntxt->gdb_handle, cntxt->gdb_frames->level);
+        gmi_stack_info_frame(cntxt->gdb_handle);
+
+                // build the function struct
+                function = MONKEY_malloc(sizeof(struct Function));
+                function->depth = stackDepth++;
+                function->line = cntxt->gdb_frames->line;
+                function->name = cntxt->gdb_frames->func;
+                function->file = cntxt->gdb_frames->file;
+                function->expressionListHead = NULL;
+                function->expressionListTail = NULL;
+                function->next = NULL;
+                function->prev = NULL;
+                MONKEY_CONTAINER_DLL_insert_tail(trace->functionListHead,
+                                                 trace->functionListTail, function);
+
+                // Retrieve scope expressions from the database
+                MONKEY_EDB_get_expressions(edbCntxt,
+                                                                   cntxt->gdb_frames->file,
+                                                                   cntxt->gdb_frames->line,
+                                                                   &iterateExpressions, function);
+
+                // Do value analysis for relevant expressions
+                analyzeExpressionValues(function, cntxt);
+
+                // add current filename to the list
+                char* tmp = file_names;
+                MONKEY_asprintf(&file_names,
+                                                "%s OR file_name LIKE \'%%%s\'",
+                                                file_names,
+                                                cntxt->gdb_frames->file);
+                MONKEY_free_non_null(tmp);
+
+                /* Now, dive deeper into the stack trace */
+                cntxt->gdb_frames = cntxt->gdb_frames->next;
+        }
+
+
+        // Retrieve globals from the database
+        file_names += 10;  // cut the first 10 chars "(null) OR "
+        MONKEY_EDB_get_globals( edbCntxt,
+                                                        file_names,
+                                                        &iterateGlobals, trace);
+        file_names -= 10;
+
+        // Do value analysis for globals
+        analyzeGlobalsValues(trace, cntxt);
+        
+cleanup:
+        MONKEY_EDB_disconnect(edbCntxt);
+        MONKEY_free_non_null(file_names);
+    return ret;
+}
+
+
+int MONKEY_ACTION_start_reverse_execution(struct MONKEY_ACTION_Context
+                                          *cntxt)
+{
+    const char *failureFile = epoch->traceListHead->functionListHead->file;
+    const char *failureFunction =
+        epoch->traceListHead->functionListHead->name;
+    struct Trace *tracePtr = epoch->traceListHead;
+    int oldLine;
+
+    /*
+     * We execute one step back operation before starting analysis. We do that to go to the expression before the one where the crash occurred.
+     * Because we already have the expression where the crash happened in our stack structure from the previous epoch step (the initial epoch)
+     */
+    if (MONKEY_NO == stoppedInSharedLib) {
+                if (MONKEY_NO != gmi_exec_next_reverse(cntxt->gdb_handle)) {
+                        while (!mi_get_response(cntxt->gdb_handle))
+                                usleep(GDB_MI_ASYNC_WAIT);
+                } else {
+                        fprintf(stderr, "Error: Reverse Execution has failed! Backtracking might not be supported for the current architecture.\n");
+                        if (MONKEY_YES == cntxt->gdb_connected) {
+                                mi_disconnect(cntxt->gdb_handle);       // No need for gdb mi at this point!
+                                cntxt->gdb_connected = MONKEY_NO;
+                        }
+                        return MONKEY_NO;
+                }
+    }
+
+    /* Do reverse execution for all expressions in the function in which the failure occurred */
+    do {
+        oldLine = tracePtr->functionListHead->line;
+                if (MONKEY_NO != gmi_exec_next_reverse(cntxt->gdb_handle)) {
+                        if (GDB_STATE_ERROR == wait_for_stop(cntxt)) {
+                                fprintf(stderr, "Error: Analysis during Reverse Execution has failed!\n");
+                                return MONKEY_NO;
+                        }
+                        if (oldLine == cntxt->gdb_frames->line)
+                                break;// We reached the end of record history TODO: DIRTY SOLUTION! WILL FAIL IF TWO EXPRESSIONS ON THE SAME LINE
+                        MONKEY_ACTION_inspect_expression_database(cntxt);
+                } else {
+                        fprintf(stderr, "Error: Reverse Execution has failed!\n");
+                        return MONKEY_NO;
+                }
+
+        tracePtr = tracePtr->next; // tracePtr will have the new trace added after examining the expression database for this reverse execution step
+    } while ((NULL != tracePtr)
+             && (strcmp(failureFile, tracePtr->functionListHead->file) ==
+                 0)
+             && (strcmp(failureFunction, tracePtr->functionListHead->name)
+                 == 0));
+
+    // stop recording and return
+    gmi_exec_record_stop(cntxt->gdb_handle);
+    return MONKEY_OK;
+}
+
+int MONKEY_ACTION_rerun_with_valgrind(struct MONKEY_ACTION_Context
+                                      *cntxt)
+{
+    char *valgrindCommand;
+    FILE *valgrindPipe;
+    const char *valgrindPath = cntxt->valgrind_binary_path;
+    struct stat buf;
+
+    if (NULL == valgrindPath)
+        valgrindPath = "/usr/bin/valgrind";     /* Assumption for valgrind installation */
+
+    /* Check if Valgrind is installed */
+    if (stat(valgrindPath, &buf) != 0 && errno == ENOENT ) {
+        fprintf(stderr,
+                "Warning: Valgrind is not installed. Memory check aborted!\n");
+        return MONKEY_NO;
+    }
+
+    MONKEY_asprintf(&cntxt->valgrind_output_tmp_file_name, "%d", rand());
+    cntxt->debug_mode = DEBUG_MODE_VALGRIND;
+    MONKEY_asprintf(&valgrindCommand,
+                    "%s --leak-check=yes --log-file=%s %s", valgrindPath,
+                    cntxt->valgrind_output_tmp_file_name,
+                    cntxt->binary_name);
+    valgrindPipe = popen(valgrindCommand, "r");
+    if (NULL == valgrindPipe) {
+        fprintf(stderr, "Error in running Valgrind! Memory check aborted!\n");
+        MONKEY_free(valgrindCommand);
+        return MONKEY_NO;
+    }
+
+    pclose(valgrindPipe);
+    MONKEY_free(valgrindCommand);
+    return MONKEY_OK;
+}
+
+
+int MONKEY_ACTION_rerun_with_gdb(struct MONKEY_ACTION_Context
+                                 *cntxt)
+{
+    struct MONKEY_EDB_Context *edbCntxt;
+    struct stat buf;
+
+    /* Check if gdb is installed */
+    if (NULL == cntxt->gdb_binary_path) {
+        cntxt->gdb_binary_path = "/usr/bin/gdb"; /* Assumption for gdb default installation */
+    }
+        if (stat(cntxt->gdb_binary_path, &buf) != 0 && errno == ENOENT ) {
+                fprintf(stderr,
+                        "Error: gdb is not installed!\n");
+                return MONKEY_NO;
+        }
+
+    epoch = NULL;               /* Initializing epoch Data Structure */
+    cntxt->debug_mode = DEBUG_MODE_GDB;
+    /* This is like a file-handle for fopen.
+       Here we have all the state of gdb "connection". */
+    if (NULL != cntxt->gdb_binary_path)
+        mi_set_gdb_exe(cntxt->gdb_binary_path);
+    int ret;
+
+    /* Connect to gdb child. */
+    cntxt->gdb_handle = mi_connect_local();
+    if (!cntxt->gdb_handle) {
+        fprintf(stderr, "Error: failed to connect to gdb!\n");
+        return MONKEY_NO;
+    }
+    fprintf(stderr, "Info: Connected to gdb!\n");
+    cntxt->gdb_connected = MONKEY_YES;
+
+    /* Set all callbacks. */
+    mi_set_console_cb(cntxt->gdb_handle, cb_console, NULL);
+    mi_set_target_cb(cntxt->gdb_handle, cb_target, NULL);
+    mi_set_log_cb(cntxt->gdb_handle, cb_log, NULL);
+    mi_set_async_cb(cntxt->gdb_handle, cb_async, NULL);
+    mi_set_to_gdb_cb(cntxt->gdb_handle, cb_to, NULL);
+    mi_set_from_gdb_cb(cntxt->gdb_handle, cb_from, NULL);
+
+    /* Set the name of the child and the command line arguments. */
+    if (!gmi_set_exec(cntxt->gdb_handle, cntxt->binary_name, cntxt->binaryArgs)) {
+                fprintf(stderr, "Error: could not set gdb exec y args\n");
+                goto fail;
+    }
+
+    /* Tell gdb to attach the child to a terminal. */
+    if (!gmi_target_terminal(cntxt->gdb_handle, ttyname(STDIN_FILENO))) {
+                fprintf(stderr, "Error: could not select gdb target terminal\n");
+                goto fail;
+    }
+
+
+    if (MONKEY_YES == cntxt->run_reverse) {
+                /* If Backtracking is enabled, we must set a breakpoint at the main function, starting the program, then starting recording */
+                mi_bkpt *bp = gmi_break_insert_full(cntxt->gdb_handle, 0, 0, NULL, -1, -1, "main");
+                if (NULL == bp) {
+                        fprintf(stderr, "Error: gdb could not set a breakpoint at function:%s\n",
+                           cntxt->inspect_function);
+                        goto fail;
+                }
+                mi_free_bkpt(bp);
+    }
+
+
+    if ((NULL != cntxt->inspect_expression) && (NULL != cntxt->inspect_function)) {
+                /* Setting a breakpoint at the function containing the expression to inspect */
+                mi_bkpt *bp = gmi_break_insert_full(cntxt->gdb_handle, 0, 0, NULL, -1, -1, cntxt->inspect_function);
+                if (NULL == bp) {
+                        fprintf(stderr, "Error: gdb could not set a breakpoint at function:%s\n", cntxt->inspect_function);
+                        goto fail;
+                }
+                mi_free_bkpt(bp);
+    }
+
+    /* Prepare a list of the file names for the source files we are analyzing */
+    edbCntxt = MONKEY_EDB_connect(cntxt->expression_database_path);
+    if (NULL == edbCntxt) {
+                fprintf(stderr,
+                        "Unable to connect to Expression Database file!\n");
+                goto fail;
+    }
+
+    if (MONKEY_OK != MONKEY_EDB_get_file_names(edbCntxt, &iterateFileNames, NULL)) {
+        fprintf(stderr, "Error: Pathologist could not retrieve source file names from expression database!\n");
+                goto fail;
+    }
+    MONKEY_EDB_disconnect(edbCntxt);
+
+
+    /* Run the program. */
+    if (!gmi_exec_run(cntxt->gdb_handle)) {
+                fprintf(stderr, "Error: gdb could not run the target program!\n");
+                goto fail;
+    }
+
+    /* Backtracking is issued after running the program */
+    if (MONKEY_YES == cntxt->run_reverse) {
+                gmi_exec_record_process(cntxt->gdb_handle);
+    }
+
+    /* Here we should be stopped when the program crashes */
+    ret = wait_for_stop(cntxt);
+    if (ret == GDB_STATE_ERROR || ret == GDB_STATE_EXIT_NORMALLY) {
+                if (MONKEY_YES == cntxt->gdb_connected) {
+                        mi_disconnect(cntxt->gdb_handle);
+                        cntxt->gdb_connected = MONKEY_NO;
+                }
+    }
+
+    return ret;
+
+        // cleanup and abort
+fail:
+        if (MONKEY_YES == cntxt->gdb_connected) {
+                mi_disconnect(cntxt->gdb_handle);
+                cntxt->gdb_connected = MONKEY_NO;
+        }
+        return MONKEY_NO;
+}
+
+
+static const char *expressionListToString(struct Expression *head)
+{
+    char *string = MONKEY_strdup("");
+    char *strTmp;
+    struct Expression *tmp;
+
+    for (tmp = head; NULL != tmp; tmp = tmp->next) {
+        MONKEY_asprintf(&strTmp,
+                        "%s%s => %s\n",
+                        string,
+                        tmp->expressionSyntax,
+                        NULL ==
+                        tmp->
+                        expressionValue ? "Not evaluated" :
+                        tmp->expressionValue);
+        MONKEY_free(string);
+        string = strTmp;
+    }
+    return string;
+}
+
+#if 0
+static int getWatchInfoListSize(struct WatchInfo *head)
+{
+    int count = 0;
+    int largestStr = 0;
+    struct WatchInfo *tmp = head;
+
+    while (NULL != tmp) {
+        if (largestStr < strlen(tmp->value))
+            largestStr = strlen(tmp->value);
+        tmp = tmp->next;
+        count++;
+    }
+
+    return count * largestStr;
+}
+
+static const char *watchInfoListToString(struct WatchInfo *head)
+{
+    char *string = MONKEY_malloc(getWatchInfoListSize(head));
+    char *strTmp;
+    struct WatchInfo *tmp = head;
+
+    MONKEY_asprintf(&strTmp, "%s\t \t%s\n", tmp->hitNumber, tmp->value);
+    strcpy(string, strTmp);
+    MONKEY_free(strTmp);
+    tmp = tmp->next;
+
+    while (NULL != tmp) {
+        MONKEY_asprintf(&strTmp, "%s\t \t%s\n", tmp->hitNumber,
+                        tmp->value);
+        strcat(string, strTmp);
+        MONKEY_free(strTmp);
+        tmp = tmp->next;
+    }
+
+    return string;
+}
+#endif
+
+static const char *getValgrindOutput(struct MONKEY_ACTION_Context *cntxt)
+{
+    char *valgrindOutput;
+    int size;
+    FILE *valgrindFile = fopen(cntxt->valgrind_output_tmp_file_name, "r");
+    fseek(valgrindFile, 0L, SEEK_END);
+    size = ftell(valgrindFile);
+    fseek(valgrindFile, 0L, SEEK_SET);
+
+    valgrindOutput = MONKEY_malloc(size);
+    fread(valgrindOutput, size - 1, 1, valgrindFile);
+    fclose(valgrindFile);
+    return valgrindOutput;
+}
+
+
+static struct MONKEY_XML_Node *createXmlSimpleNode(const char *nodeName,
+                                                   const char
+                                                   *nodeInnerText)
+{
+    struct MONKEY_XML_Node *node =
+        MONKEY_XML_WRITER_new_node(nodeName, nodeInnerText);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlCrashNode(const char *category,
+                                                  const char *function,
+                                                  int line,
+                                                  const char *file)
+{
+    struct MONKEY_XML_Node *node;
+    char *lineStr;
+
+    MONKEY_asprintf(&lineStr, "%d", line);
+    node = MONKEY_XML_WRITER_new_node("crash", NULL);
+    MONKEY_XML_WRITER_add_attribute(node, "category", category);
+    MONKEY_XML_WRITER_add_attribute(node, "function", function);
+    MONKEY_XML_WRITER_add_attribute(node, "line", lineStr);
+    MONKEY_XML_WRITER_add_attribute(node, "file", file);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlEpochStep(int step)
+{
+    struct MONKEY_XML_Node *node;
+    char *stepStr;
+    MONKEY_asprintf(&stepStr, "%d", step);
+    node = MONKEY_XML_WRITER_new_node("epoch", NULL);
+    MONKEY_XML_WRITER_add_attribute(node, "step", stepStr);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlFunctionNode(const char *name,
+                                                     int line,
+                                                     const char *file,
+                                                     int depth)
+{
+    struct MONKEY_XML_Node *node;
+    char *lineStr;
+    char *depthStr;
+
+    MONKEY_asprintf(&lineStr, "%d", line);
+    MONKEY_asprintf(&depthStr, "%d", depth);
+    node = MONKEY_XML_WRITER_new_node("function", NULL);
+    MONKEY_XML_WRITER_add_attribute(node, "name", name);
+    MONKEY_XML_WRITER_add_attribute(node, "line", lineStr);
+    MONKEY_XML_WRITER_add_attribute(node, "file", file);
+    MONKEY_XML_WRITER_add_attribute(node, "depth", depthStr);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlExpressionNode(const char *name,
+                                                       const char *value)
+{
+    struct MONKEY_XML_Node *node;
+
+    node = MONKEY_XML_WRITER_new_node("expression", value);
+    MONKEY_XML_WRITER_add_attribute(node, "name", name);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlGlobalExpressionNode(const char *name,
+                                                        const char *value)
+{
+    struct MONKEY_XML_Node *node;
+
+    node = MONKEY_XML_WRITER_new_node("expression", value);
+    MONKEY_XML_WRITER_add_attribute(node, "name", name);
+    return node;
+}
+
+
+int MONKEY_ACTION_is_Nullpointer(struct MONKEY_ACTION_Context* cntxt)
+{
+        mi_asm_insns* disassembled_code = gmi_data_disassemble_se(cntxt->gdb_handle, "$pc", "$pc+1", 0);
+        char* reg;
+        while(reg = strstr(disassembled_code->ins->inst, "(%")) {
+                //printf("%s\n", reg);
+                reg++;
+                size_t len = strcspn(reg, "),");
+                reg[0]='$';
+                reg[len]='\0';
+                char* val = gmi_data_evaluate_expression(cntxt->gdb_handle, reg);
+                //printf("%s\n", val);
+                if( !strcmp(val, "0") ) return 1;
+        }
+        return 0;
+}
+
+
+int MONKEY_ACTION_format_report_xml(struct MONKEY_ACTION_Context
+                                    *cntxt)
+{
+    int i = 0;
+    struct MONKEY_XML_Node *node;
+    struct MONKEY_XML_Node *historyNode;
+    struct MONKEY_XML_Node *traceNode;
+    struct MONKEY_XML_Node *globalsNode;
+    struct Trace *tracePtr = epoch->traceListHead;
+    struct Function *functionPtr = tracePtr->functionListHead;
+    struct Expression *expressionPtr;
+
+
+    switch (cntxt->bug_detected) {
+        case BUG_NULL_POINTER:
+                cntxt->xml_report_node = createXmlCrashNode("npe", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    case BUG_BAD_MEM_ACCESS:
+                cntxt->xml_report_node = createXmlCrashNode("Bad memory access", functionPtr->name, functionPtr->line, functionPtr->file);
+                node = MONKEY_XML_WRITER_add_child(cntxt->xml_report_node, createXmlSimpleNode("valgrind", getValgrindOutput(cntxt)));
+                break;
+    case BUG_ABORT:
+                cntxt->xml_report_node = createXmlCrashNode("Assertion Failure", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    case BUG_ARITHMETIC:
+                cntxt->xml_report_node = createXmlCrashNode("Division By Zero", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    case BUG_SIG_BUS:
+        cntxt->xml_report_node = createXmlCrashNode("Bus Error", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    default:
+        cntxt->xml_report_node = createXmlCrashNode("Unknown", functionPtr->name, functionPtr->line, functionPtr->file);
+        break;
+    }
+
+    historyNode = MONKEY_XML_WRITER_add_child(cntxt->xml_report_node, createXmlSimpleNode("history", NULL));
+
+    /* Adding Stack Trace Nodes to XML Report */
+    while (NULL != tracePtr) {
+                node = MONKEY_XML_WRITER_add_child(historyNode, createXmlEpochStep(i));
+                traceNode = MONKEY_XML_WRITER_add_child(node, createXmlSimpleNode("trace", NULL));
+                globalsNode = MONKEY_XML_WRITER_add_child(node, createXmlSimpleNode("globals", NULL));
+
+                functionPtr = tracePtr->functionListHead;
+                while (NULL != functionPtr) {
+                        node = MONKEY_XML_WRITER_add_child(traceNode, createXmlFunctionNode(functionPtr->name,
+                                                                                                                                                                functionPtr->line,
+                                                                                                                                                                functionPtr->file,
+                                                                                                                                                                functionPtr->depth));
+                        node = MONKEY_XML_WRITER_add_child(node, createXmlSimpleNode("expressions", NULL));
+
+                        expressionPtr = functionPtr->expressionListHead;
+                        while (NULL != expressionPtr) {
+                                // ignore non helpful expressions
+                                if( expressionPtr->expressionValue )
+                                        MONKEY_XML_WRITER_add_child(node, createXmlExpressionNode(expressionPtr->expressionSyntax, expressionPtr->expressionValue));
+                                expressionPtr = expressionPtr->next;
+                        }
+
+                        functionPtr = functionPtr->next;
+                }
+
+                expressionPtr = tracePtr->globalsListHead;
+                while( expressionPtr ) {
+                        if( expressionPtr->expressionValue )
+                                MONKEY_XML_WRITER_add_child(globalsNode, createXmlGlobalExpressionNode(expressionPtr->expressionSyntax, expressionPtr->expressionValue));
+                        expressionPtr = expressionPtr->next;
+                }
+                
+
+                tracePtr = tracePtr->next;
+                i++;
+    }
+    return MONKEY_OK;
+}
+
+
+
+
+int MONKEY_ACTION_delete_context(struct MONKEY_ACTION_Context
+                                 *cntxt)
+{
+        if (MONKEY_YES == cntxt->gdb_connected) {
+                mi_disconnect(cntxt->gdb_handle);
+                cntxt->gdb_connected = MONKEY_NO;
+        }
+    if (NULL != cntxt->debug_report)
+        MONKEY_free(cntxt->debug_report);
+    if (NULL != cntxt->valgrind_output_tmp_file_name) {
+        remove(cntxt->valgrind_output_tmp_file_name);
+        MONKEY_free(cntxt->valgrind_output_tmp_file_name);
+    }
+    if (NULL != cntxt->xml_report_node)
+        MONKEY_XML_WRITER_delete_tree(cntxt->xml_report_node);
+    if (NULL != cntxt->binaryArgs)
+        MONKEY_free(cntxt->binaryArgs);
+
+    MONKEY_free(cntxt);
+    return MONKEY_OK;
+}
+
+
+int MONKEY_ACTION_check_bug_redundancy()
+{
+    return MONKEY_OK;
+}
diff --git a/pathologist/src/pathologist/action.h b/pathologist/src/pathologist/action.h
new file mode 100644
index 0000000..57b748b
--- /dev/null
+++ b/pathologist/src/pathologist/action.h
@@ -0,0 +1,100 @@
+/**
+ * @file monkey/MONKEY_action.h
+ * @brief Monkey API for actions taken by Monkey while debugging
+ */
+
+#ifndef MONKEY_ACTION_H
+#define MONKEY_ACTION_H
+
+#include "gdbmi.h"
+#include "pathologist_xml_writer.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/* Debug constants */
+#define DEBUG_MODE_GDB 0
+#define GDB_STATE_STOPPED 1
+#define GDB_STATE_EXIT_NORMALLY 2
+#define GDB_STATE_ERROR 3
+#define GDB_SAFETY_COUNT 2
+#define DEBUG_MODE_VALGRIND 4
+#define DEBUG_MODE_REPORT_READY 5
+#define NO_BUG_DETECTED -1
+#define BUG_NULL_POINTER 6
+#define BUG_ABORT 7
+#define BUG_ARITHMETIC 8
+#define BUG_BAD_MEM_ACCESS 9
+#define BUG_SIG_BUS 10
+#define GDB_MI_ASYNC_WAIT 5
+
+/**
+ * Context for the Action API
+ */
+struct MONKEY_ACTION_Context
+{
+  const char *binary_name;
+  char *binaryArgs;
+  const char *email_address;
+  const char *expression_database_path;
+  const char *gdb_binary_path;
+  const char *valgrind_binary_path;
+  const char *inspect_expression;
+  const char *inspect_function;
+  int debug_mode;
+  int bug_detected;
+  int has_null;
+  char *debug_report;
+  struct MONKEY_XML_Node *xml_report_node;
+
+  /* gdb debugging attributes */
+  int run_reverse;
+  int scope_depth;
+  mi_h *gdb_handle;
+  int gdb_connected;
+  const char *gdb_in_use;
+  mi_stop *gdb_stop_reason;
+  mi_frames *gdb_frames;
+  const char *gdb_null_variable;
+
+  /* Valgrind memcheck attributes */
+  char* valgrind_output_tmp_file_name;
+};
+
+
+int MONKEY_ACTION_report_file (struct MONKEY_ACTION_Context
+                                      *cntxt, const char *dumpFileName, int isXML);
+int MONKEY_ACTION_report_email (struct MONKEY_ACTION_Context
+                                       *cntxt, const char *dumpFileName);
+int MONKEY_ACTION_inspect_expression_database (struct
+                                                      MONKEY_ACTION_Context
+                                                      *cntxt);
+int MONKEY_ACTION_rerun_with_gdb (struct MONKEY_ACTION_Context
+                                         *cntxt);
+int MONKEY_ACTION_start_reverse_execution(struct MONKEY_ACTION_Context * cntxt);
+int MONKEY_ACTION_rerun_with_valgrind (struct
+                                              MONKEY_ACTION_Context
+                                              *cntxt);
+int MONKEY_ACTION_format_report (struct MONKEY_ACTION_Context
+                                        *cntxt);
+int
+MONKEY_ACTION_format_report_xml (struct MONKEY_ACTION_Context
+                                        *cntxt);
+int MONKEY_ACTION_delete_context(struct MONKEY_ACTION_Context *cntxt);
+
+int MONKEY_ACTION_check_bug_redundancy (void);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/pathologist/src/pathologist/edb_api.c b/pathologist/src/pathologist/edb_api.c
new file mode 100644
index 0000000..5af26de
--- /dev/null
+++ b/pathologist/src/pathologist/edb_api.c
@@ -0,0 +1,368 @@
+/**
+ * @file monkey/edb_api.c
+ * @brief Monkey API for accessing the Expression Database (edb)
+ */
+
+#include "monkey_common.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <sqlite3.h>
+#include "pathologist_edb.h"
+
+
+/**
+ * Context for Database connection and Expressions
+ */
+struct MONKEY_EDB_Context
+{
+  /**
+   *  Database connection 
+   */
+  sqlite3 *db_handle;
+};
+
+
+/**
+ * Establish a connection to the Expression Database
+ *
+ * @param db_file_name path the Expression Database file
+ * @return context to use for Accessing the Expression Database, NULL on error
+ */
+struct MONKEY_EDB_Context *
+MONKEY_EDB_connect (const char *db_file_name)
+{
+  int err;
+  struct MONKEY_EDB_Context *ctxt =
+    MONKEY_malloc (sizeof (struct MONKEY_EDB_Context));
+
+  err = sqlite3_open (db_file_name, &ctxt->db_handle);
+  if (err)
+    {
+      fprintf(stderr,
+                  "Cannot open Expression Database. `%s'\n",
+                  sqlite3_errmsg (ctxt->db_handle));
+      return NULL;
+    }
+  return ctxt;
+}
+
+
+/**
+ * Disconnect from Database, and cleanup resources
+ *
+ * @param context context containing the Expression Database handle
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_disconnect (struct MONKEY_EDB_Context *cntxt)
+{
+  sqlite3_close (cntxt->db_handle);
+  MONKEY_free (cntxt);
+  return MONKEY_OK;
+}
+
+
+
+int
+MONKEY_EDB_get_file_names (struct MONKEY_EDB_Context *cntxt,
+                                  MONKEY_FileIterator iter,
+                                  void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+
+  if (MONKEY_asprintf (&query, "select distinct file_name from Expression") == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred during creating database query!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+
+int
+MONKEY_EDB_get_all_outer_scopes(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int function_beginning,
+                int scope_in_question_start,
+                int scope_in_question_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls)
+{
+          int err;
+          char *errMsg;
+          char *query;
+
+          if (MONKEY_asprintf
+                  (&query,
+                   "select distinct end_lineno from Expression where file_name LIKE \'%%%s\' and start_lineno >= %d and start_lineno < %d and end_lineno > %d order by end_lineno",
+                   file_name, function_beginning, scope_in_question_start, scope_in_question_end) == -1)
+                {
+                  fprintf(stderr,
+                          "Memory allocation problem occurred during creating database query!\n");
+                  return MONKEY_NO;
+                }
+
+          err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+          if (err)
+                {
+                  fprintf(stderr,
+                          "Error occurred while executing Database query. `%s'",
+                          errMsg);
+                  return MONKEY_NO;
+                }
+          return MONKEY_OK;
+}
+
+int
+MONKEY_EDB_expression_function_end_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int start_lineno,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls)
+{
+          int err;
+          char *errMsg;
+          char *query;
+
+          if (MONKEY_asprintf
+              (&query,
+               "select MAX(end_lineno) from Expression where file_name LIKE \'%%%s\' and start_lineno < %d and end_lineno != 32767",
+               file_name, start_lineno) == -1)
+            {
+              fprintf(stderr,
+                          "Memory allocation problem occurred during creating database query!\n");
+              return MONKEY_NO;
+            }
+
+          err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+          if (err)
+            {
+              fprintf(stderr,
+                          "Error occurred while executing Database query. `%s'",
+                          errMsg);
+              return MONKEY_NO;
+            }
+          return MONKEY_OK;
+}
+
+int
+MONKEY_EDB_function_start_line_for_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int scope_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls)
+{
+          int err;
+          char *errMsg;
+          char *query;
+
+          if (MONKEY_asprintf
+              (&query,
+               "select MIN(start_lineno) from Expression where file_name LIKE \'%%%s\' and end_lineno >= %d",
+               file_name, scope_end) == -1)
+            {
+              fprintf(stderr,
+                          "Memory allocation problem occurred during creating database query!\n");
+              return MONKEY_NO;
+            }
+
+          err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+          if (err)
+            {
+              fprintf(stderr,
+                          "Error occurred while executing Database query. `%s'",
+                          errMsg);
+              return MONKEY_NO;
+            }
+          return MONKEY_OK;
+}
+
+
+/**
+ * Return the line number of the end-of-scope for the expression indicated by start_line_no
+ *
+ * @param cntxt context containing the Expression Database handle
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression's line
+ * @param iter callback function, iterator for values returned from the Database
+ * @param iter_cls closure for the expression iterator, will contain the scope-end line number
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_get_expression_scope_end (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            int start_line_no,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+
+  if (MONKEY_asprintf
+      (&query,
+       "select min(end_lineno) from Expression where file_name LIKE \'%%%s\' and start_lineno = %d",
+       file_name, start_line_no) == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred during creating database query!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  MONKEY_free (query);
+
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+int
+MONKEY_EDB_get_expression_scope_end_for_expression (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            const char * expr_syntax,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+
+  if (MONKEY_asprintf
+      (&query,
+       "select end_lineno from Expression where file_name LIKE \'%%%s\' and expr_syntax = %s",
+       file_name, expr_syntax) == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred during creating database query!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  MONKEY_free (query);
+
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+int
+MONKEY_EDB_get_globals( struct MONKEY_EDB_Context *cntxt,
+                                                const char *file_names,
+                                                MONKEY_ExpressionIterator iter,
+                                                void *iter_cls) {
+        int ret = MONKEY_OK;
+        char *errMsg;
+        char *query;
+        if( MONKEY_asprintf(&query,
+                                                "SELECT DISTINCT expr_syntax, is_call FROM Expression WHERE (%s) AND start_lineno = 0 AND end_lineno = 32767",
+                                                file_names) == -1 ) {
+                fprintf(stderr, "Memory allocation problem occurred!\n");
+                ret = MONKEY_NO;
+                goto fin;
+        }
+
+        if( sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg) )   {
+                fprintf(stderr, "Error occurred while executing Database query. `%s'", errMsg);
+                ret = MONKEY_NO;
+                goto fin;
+        }
+fin:
+        MONKEY_free_non_null(query);
+        return MONKEY_NO;
+}
+
+/**
+ * Run an SQLite query to retrieve those expressions that are previous to
+ * given expression and are in the same function of the given expression
+ * 
+ * @param cntxt context containing the Expression Database handle
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression beginning line
+ * @param iter callback function, iterator for expressions returned from the Database
+ * @param iter_cls closure for the expression iterator
+ * @return MONKEY_OK success, MONKEY_NO failure
+ */
+int
+MONKEY_EDB_get_expressions (struct MONKEY_EDB_Context *cntxt,
+                                   const char *file_name, int start_line_no,
+                                   MONKEY_ExpressionIterator iter,
+                                   void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+  if (MONKEY_asprintf
+      (&query,
+       "select distinct expr_syntax, is_call from Expression where file_name LIKE \'%%%s\' and start_lineno <= %d and end_lineno >= %d and end_lineno != 32767",
+       file_name, start_line_no, start_line_no) == -1)
+    {
+      fprintf(stderr, "Memory allocation problem occurred!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  if (err)
+    {
+      fprintf(stderr, "Error occurred while executing Database query. `%s'\n", errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+int
+MONKEY_EDB_get_sub_expressions (struct MONKEY_EDB_Context
+                                       *cntxt, const char *file_name,
+                                       int start_line_no, int end_line_no,
+                                       MONKEY_ExpressionIterator iter,
+                                       void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+  if (MONKEY_asprintf
+      (&query,
+       "select expr_syntax, start_lineno, is_call from Expression where file_name LIKE \'%%%s\' and start_lineno = %d and end_lineno = %d",
+       file_name, start_line_no, end_line_no) == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
diff --git a/pathologist/src/pathologist/getopt.c b/pathologist/src/pathologist/getopt.c
new file mode 100644
index 0000000..d7a037c
--- /dev/null
+++ b/pathologist/src/pathologist/getopt.c
@@ -0,0 +1,1047 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
+     Free Software Foundation, Inc.
+
+NOTE: The canonical source of this file is maintained with the GNU C Library.
+Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+
+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, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+USA.
+
+
+This code was heavily modified for GNUnet.
+Copyright (C) 2006 Christian Grothoff
+*/
+
+/**
+ * @file util/getopt.c
+ * @brief GNU style option parsing
+ *
+ * TODO: get rid of statics (make reentrant) and
+ * replace main GNU getopt parser with one that
+ * actually fits our API.
+ */
+
+#include "platform.h"
+#include "monkey_common.h"
+#include "monkey_getopt_lib.h"
+
+#ifdef VMS
+#include <unixlib.h>
+#if HAVE_STRING_H - 0
+#include <string.h>
+#endif
+#endif
+
+#define LOG(kind,...) MONKEY_log_from (kind, "util", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) MONKEY_log_from_strerror (kind, "util", syscall)
+
+#if defined (WIN32) && !defined (__CYGWIN32__)
+/* It's not Unix, really.  See?  Capital letters.  */
+#include <windows.h>
+#define getpid() GetCurrentProcessId()
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.
+   When compiling libc, the _ macro is predefined.  */
+#ifdef HAVE_LIBINTL_H
+#include <libintl.h>
+#define _(msgid)  gettext (msgid)
+#else
+#define _(msgid)  (msgid)
+#endif
+#endif
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct GNoption' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument          (or 0) if the option does not take an argument,
+   required_argument  (or 1) if the option requires an argument,
+   optional_argument   (or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `GNoptarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct GNoption
+{
+  const char *name;
+  /* has_arg can't be an enum because some compilers complain about
+   * type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+static char *GNoptarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `GNoptind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* 1003.2 says this must be 1 before any call.  */
+static int GNoptind = 1;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We MONKEY_CRYPTO_random_permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect GNoptions and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return -1 with `GNoptind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef  __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define  my_index       strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *
+getenv ();
+
+static char *
+my_index (const char *str,
+          int chr)
+{
+  while (*str)
+  {
+    if (*str == chr)
+      return (char *) str;
+    str++;
+  }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#if !defined (__STDC__) || !__STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int
+strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Bash 2.0 gives us an environment variable containing flags
+   indicating ARGV elements that should not be considered arguments.  */
+
+/* Defined in getopt_init.c  */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+
+static int original_argc;
+static char *const *original_argv;
+
+extern pid_t __libc_pid;
+
+/* Make sure the environment variable bash 2.0 puts in the environment
+   is valid for the getopt call we must make sure that the ARGV passed
+   to getopt is that one passed to the process.  */
+static void MONKEY_UNUSED
+store_args_and_env (int argc, char *const *argv)
+{
+  /* XXX This is no good solution.  We should rather copy the args so
+   * that we can compare them later.  But we must not use malloc(3).  */
+  original_argc = argc;
+  original_argv = argv;
+}
+
+text_set_element (__libc_subinit, store_args_and_env);
+
+#define SWAP_FLAGS(ch1, ch2) \
+  if (nonoption_flags_len > 0)                                                \
+    {                                                                 \
+      char __tmp = __getopt_nonoption_flags[ch1];                     \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];        \
+      __getopt_nonoption_flags[ch2] = __tmp;                          \
+    }
+#else /* !_LIBC */
+#define SWAP_FLAGS(ch1, ch2)
+#endif /* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,GNoptind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+#if defined (__STDC__) && __STDC__
+static void
+exchange (char **);
+#endif
+
+static void
+exchange (char **argv)
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = GNoptind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+   * That puts the shorter segment into the right place.
+   * It leaves the longer segment in the right place overall,
+   * but it consists of two parts that need to be swapped next.  */
+
+#ifdef _LIBC
+  /* First make sure the handling of the `__getopt_nonoption_flags'
+   * string can work normally.  Our top argument must be in the range
+   * of the string.  */
+  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+  {
+    /* We must extend the array.  The user plays games with us and
+     * presents new arguments.  */
+    char *new_str = malloc (top + 1);
+
+    if (new_str == NULL)
+      nonoption_flags_len = nonoption_flags_max_len = 0;
+    else
+    {
+      memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
+      memset (&new_str[nonoption_flags_max_len], '\0',
+              top + 1 - nonoption_flags_max_len);
+      nonoption_flags_max_len = top + 1;
+      __getopt_nonoption_flags = new_str;
+    }
+  }
+#endif
+
+  while (top > middle && middle > bottom)
+  {
+    if (top - middle > middle - bottom)
+    {
+      /* Bottom segment is the short one.  */
+      int len = middle - bottom;
+      register int i;
+
+      /* Swap it with the top part of the top segment.  */
+      for (i = 0; i < len; i++)
+      {
+        tem = argv[bottom + i];
+        argv[bottom + i] = argv[top - (middle - bottom) + i];
+        argv[top - (middle - bottom) + i] = tem;
+        SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+      }
+      /* Exclude the moved bottom segment from further swapping.  */
+      top -= len;
+    }
+    else
+    {
+      /* Top segment is the short one.  */
+      int len = top - middle;
+      register int i;
+
+      /* Swap it with the bottom part of the bottom segment.  */
+      for (i = 0; i < len; i++)
+      {
+        tem = argv[bottom + i];
+        argv[bottom + i] = argv[middle + i];
+        argv[middle + i] = tem;
+        SWAP_FLAGS (bottom + i, middle + i);
+      }
+      /* Exclude the moved top segment from further swapping.  */
+      bottom += len;
+    }
+  }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (GNoptind - last_nonopt);
+  last_nonopt = GNoptind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+#if defined (__STDC__) && __STDC__
+static const char *
+_getopt_initialize (int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize (int argc,
+                    char *const *argv,
+                    const char *optstring)
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+   * is the program name); the sequence of previously skipped
+   * non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = GNoptind;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+  {
+    ordering = RETURN_IN_ORDER;
+    ++optstring;
+  }
+  else if (optstring[0] == '+')
+  {
+    ordering = REQUIRE_ORDER;
+    ++optstring;
+  }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+#ifdef _LIBC
+  if (posixly_correct == NULL && argc == original_argc && argv == original_argv)
+  {
+    if (nonoption_flags_max_len == 0)
+    {
+      if (__getopt_nonoption_flags == NULL ||
+          __getopt_nonoption_flags[0] == '\0')
+        nonoption_flags_max_len = -1;
+      else
+      {
+        const char *orig_str = __getopt_nonoption_flags;
+        int len = nonoption_flags_max_len = strlen (orig_str);
+
+        if (nonoption_flags_max_len < argc)
+          nonoption_flags_max_len = argc;
+        __getopt_nonoption_flags = (char *) malloc (nonoption_flags_max_len);
+        if (__getopt_nonoption_flags == NULL)
+          nonoption_flags_max_len = -1;
+        else
+        {
+          memcpy (__getopt_nonoption_flags, orig_str, len);
+          memset (&__getopt_nonoption_flags[len], '\0',
+                  nonoption_flags_max_len - len);
+        }
+      }
+    }
+    nonoption_flags_len = nonoption_flags_max_len;
+  }
+  else
+    nonoption_flags_len = 0;
+#endif
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `GNoptind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns -1.
+   Then `GNoptind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `GNopterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `GNoptarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `GNoptarg', otherwise `GNoptarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we MONKEY_CRYPTO_random_permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct GNoption' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+static int
+GN_getopt_internal (int argc, char *const *argv, const char *optstring,
+                    const struct GNoption *longopts, int *longind,
+                    int long_only)
+{
+  static int __getopt_initialized = 0;
+  static int GNopterr = 1;
+
+  GNoptarg = NULL;
+
+  if (GNoptind == 0 || !__getopt_initialized)
+  {
+    if (GNoptind == 0)
+      GNoptind = 1;             /* Don't scan ARGV[0], the program name.  */
+    optstring = _getopt_initialize (argc, argv, optstring);
+    __getopt_initialized = 1;
+  }
+
+  /* Test whether ARGV[GNoptind] points to a non-option argument.
+   * Either it does not have option syntax, or there is an environment flag
+   * from the shell indicating it is not an option.  The later information
+   * is only used when the used in the GNU libc.  */
+#ifdef _LIBC
+#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0'        \
+             || (GNoptind < nonoption_flags_len                       \
+                 && __getopt_nonoption_flags[GNoptind] == '1'))
+#else
+#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')
+#endif
+
+  if (nextchar == NULL || *nextchar == '\0')
+  {
+    /* Advance to the next ARGV-element.  */
+
+    /* Give FIRST_NONOPT & LAST_NONOPT rational values if GNoptind has been
+     * moved back by the user (who may also have changed the arguments).  */
+    if (last_nonopt > GNoptind)
+      last_nonopt = GNoptind;
+    if (first_nonopt > GNoptind)
+      first_nonopt = GNoptind;
+
+    if (ordering == PERMUTE)
+    {
+      /* If we have just processed some options following some non-options,
+       * exchange them so that the options come first.  */
+
+      if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+        exchange ((char **) argv);
+      else if (last_nonopt != GNoptind)
+        first_nonopt = GNoptind;
+
+      /* Skip any additional non-options
+       * and extend the range of non-options previously skipped.  */
+
+      while (GNoptind < argc && NONOPTION_P)
+        GNoptind++;
+      last_nonopt = GNoptind;
+    }
+
+    /* The special ARGV-element `--' means premature end of options.
+     * Skip it like a null option,
+     * then exchange with previous non-options as if it were an option,
+     * then skip everything else like a non-option.  */
+    if (GNoptind != argc && !strcmp (argv[GNoptind], "--"))
+    {
+      GNoptind++;
+
+      if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+        exchange ((char **) argv);
+      else if (first_nonopt == last_nonopt)
+        first_nonopt = GNoptind;
+      last_nonopt = argc;
+
+      GNoptind = argc;
+    }
+
+    /* If we have done all the ARGV-elements, stop the scan
+     * and back over any non-options that we skipped and permuted.  */
+
+    if (GNoptind == argc)
+    {
+      /* Set the next-arg-index to point at the non-options
+       * that we previously skipped, so the caller will digest them.  */
+      if (first_nonopt != last_nonopt)
+        GNoptind = first_nonopt;
+      return -1;
+    }
+
+    /* If we have come to a non-option and did not permute it,
+     * either stop the scan or describe it to the caller and pass it by.  */
+
+    if (NONOPTION_P)
+    {
+      if (ordering == REQUIRE_ORDER)
+        return -1;
+      GNoptarg = argv[GNoptind++];
+      return 1;
+    }
+
+    /* We have found another option-ARGV-element.
+     * Skip the initial punctuation.  */
+
+    nextchar =
+        (argv[GNoptind] + 1 + (longopts != NULL && argv[GNoptind][1] == '-'));
+  }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+   *
+   * If long_only and the ARGV-element has the form "-f", where f is
+   * a valid short option, don't consider it an abbreviated form of
+   * a long option that starts with f.  Otherwise there would be no
+   * way to give the -f short option.
+   *
+   * On the other hand, if there's a long option "fubar" and
+   * the ARGV-element is "-fu", do consider that an abbreviation of
+   * the long option, just like "--fu", and not "-f" with arg "u".
+   *
+   * This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL &&
+      (argv[GNoptind][1] == '-' ||
+       (long_only &&
+        (argv[GNoptind][2] || !my_index (optstring, argv[GNoptind][1])))))
+  {
+    char *nameend;
+    const struct GNoption *p;
+    const struct GNoption *pfound = NULL;
+    int exact = 0;
+    int ambig = 0;
+    int indfound = -1;
+    int option_index;
+
+    for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+      /* Do nothing.  */ ;
+
+    /* Test all long options for either exact match
+     * or abbreviated matches.  */
+    for (p = longopts, option_index = 0; p->name; p++, option_index++)
+      if (!strncmp (p->name, nextchar, nameend - nextchar))
+      {
+        if ((unsigned int) (nameend - nextchar) ==
+            (unsigned int) strlen (p->name))
+        {
+          /* Exact match found.  */
+          pfound = p;
+          indfound = option_index;
+          exact = 1;
+          break;
+        }
+        else if (pfound == NULL)
+        {
+          /* First nonexact match found.  */
+          pfound = p;
+          indfound = option_index;
+        }
+        else
+          /* Second or later nonexact match found.  */
+          ambig = 1;
+      }
+
+    if (ambig && !exact)
+    {
+      if (GNopterr)
+        FPRINTF (stderr, _("%s: option `%s' is ambiguous\n"), argv[0],
+                 argv[GNoptind]);
+      nextchar += strlen (nextchar);
+      GNoptind++;
+      return '?';
+    }
+
+    if (pfound != NULL)
+    {
+      option_index = indfound;
+      GNoptind++;
+      if (*nameend)
+      {
+        /* Don't test has_arg with >, because some C compilers don't
+         * allow it to be used on enums.  */
+        if (pfound->has_arg)
+          GNoptarg = nameend + 1;
+        else
+        {
+          if (GNopterr)
+          {
+            if (argv[GNoptind - 1][1] == '-')
+              /* --option */
+              FPRINTF (stderr,
+                       _("%s: option `--%s' does not allow an argument\n"),
+                       argv[0], pfound->name);
+            else
+              /* +option or -option */
+              FPRINTF (stderr,
+                       _("%s: option `%c%s' does not allow an argument\n"),
+                       argv[0], argv[GNoptind - 1][0], pfound->name);
+          }
+          nextchar += strlen (nextchar);
+          return '?';
+        }
+      }
+      else if (pfound->has_arg == 1)
+      {
+        if (GNoptind < argc)
+        {
+          GNoptarg = argv[GNoptind++];
+        }
+        else
+        {
+          if (GNopterr)
+          {
+            FPRINTF (stderr, _("%s: option `%s' requires an argument\n"),
+                     argv[0], argv[GNoptind - 1]);
+          }
+          nextchar += strlen (nextchar);
+          return (optstring[0] == ':') ? ':' : '?';
+        }
+      }
+      nextchar += strlen (nextchar);
+      if (longind != NULL)
+        *longind = option_index;
+      if (pfound->flag)
+      {
+        *(pfound->flag) = pfound->val;
+        return 0;
+      }
+      return pfound->val;
+    }
+
+    /* Can't find it as a long option.  If this is not getopt_long_only,
+     * or the option starts with '--' or is not a valid short
+     * option, then it's an error.
+     * Otherwise interpret it as a short option.  */
+    if (!long_only || argv[GNoptind][1] == '-' ||
+        my_index (optstring, *nextchar) == NULL)
+    {
+      if (GNopterr)
+      {
+        if (argv[GNoptind][1] == '-')
+          /* --option */
+          FPRINTF (stderr, _("%s: unrecognized option `--%s'\n"), argv[0],
+                   nextchar);
+        else
+          /* +option or -option */
+          FPRINTF (stderr, _("%s: unrecognized option `%c%s'\n"), argv[0],
+                   argv[GNoptind][0], nextchar);
+      }
+      nextchar = (char *) "";
+      GNoptind++;
+      return '?';
+    }
+  }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `GNoptind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++GNoptind;
+
+    if (temp == NULL || c == ':')
+    {
+      if (GNopterr)
+      {
+        if (posixly_correct)
+          /* 1003.2 specifies the format of this message.  */
+          FPRINTF (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
+        else
+          FPRINTF (stderr, _("%s: invalid option -- %c\n"), argv[0], c);
+      }
+      return '?';
+    }
+    /* Convenience. Treat POSIX -W foo same as long option --foo */
+    if (temp[0] == 'W' && temp[1] == ';')
+    {
+      char *nameend;
+      const struct GNoption *p;
+      const struct GNoption *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = 0;
+      int option_index;
+
+      /* This is an option that requires an argument.  */
+      if (*nextchar != '\0')
+      {
+        GNoptarg = nextchar;
+        /* If we end this ARGV-element by taking the rest as an arg,
+         * we must advance to the next element now.  */
+        GNoptind++;
+      }
+      else if (GNoptind == argc)
+      {
+        if (GNopterr)
+        {
+          /* 1003.2 specifies the format of this message.  */
+          FPRINTF (stderr, _("%s: option requires an argument -- %c\n"),
+                   argv[0], c);
+        }
+        if (optstring[0] == ':')
+          c = ':';
+        else
+          c = '?';
+        return c;
+      }
+      else
+        /* We already incremented `GNoptind' once;
+         * increment it again when taking next ARGV-elt as argument.  */
+        GNoptarg = argv[GNoptind++];
+
+      /* GNoptarg is now the argument, see if it's in the
+       * table of longopts.  */
+
+      for (nextchar = nameend = GNoptarg; *nameend && *nameend != '=';
+           nameend++)
+        /* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+       * or abbreviated matches.  */
+      if (longopts != NULL)
+        for (p = longopts, option_index = 0; p->name; p++, option_index++)
+          if (!strncmp (p->name, nextchar, nameend - nextchar))
+          {
+            if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+            {
+              /* Exact match found.  */
+              pfound = p;
+              indfound = option_index;
+              exact = 1;
+              break;
+            }
+            else if (pfound == NULL)
+            {
+              /* First nonexact match found.  */
+              pfound = p;
+              indfound = option_index;
+            }
+            else
+              /* Second or later nonexact match found.  */
+              ambig = 1;
+          }
+      if (ambig && !exact)
+      {
+        if (GNopterr)
+          FPRINTF (stderr, _("%s: option `-W %s' is ambiguous\n"), argv[0],
+                   argv[GNoptind]);
+        nextchar += strlen (nextchar);
+        GNoptind++;
+        return '?';
+      }
+      if (pfound != NULL)
+      {
+        option_index = indfound;
+        if (*nameend)
+        {
+          /* Don't test has_arg with >, because some C compilers don't
+           * allow it to be used on enums.  */
+          if (pfound->has_arg)
+            GNoptarg = nameend + 1;
+          else
+          {
+            if (GNopterr)
+              FPRINTF (stderr, _("\
+%s: option `-W %s' does not allow an argument\n"), argv[0], pfound->name);
+
+            nextchar += strlen (nextchar);
+            return '?';
+          }
+        }
+        else if (pfound->has_arg == 1)
+        {
+          if (GNoptind < argc)
+            GNoptarg = argv[GNoptind++];
+          else
+          {
+            if (GNopterr)
+              FPRINTF (stderr, _("%s: option `%s' requires an argument\n"),
+                       argv[0], argv[GNoptind - 1]);
+            nextchar += strlen (nextchar);
+            return optstring[0] == ':' ? ':' : '?';
+          }
+        }
+        nextchar += strlen (nextchar);
+        if (longind != NULL)
+          *longind = option_index;
+        if (pfound->flag)
+        {
+          *(pfound->flag) = pfound->val;
+          return 0;
+        }
+        return pfound->val;
+      }
+      nextchar = NULL;
+      return 'W';               /* Let the application handle it.   */
+    }
+    if (temp[1] == ':')
+    {
+      if (temp[2] == ':')
+      {
+        /* This is an option that accepts an argument optionally.  */
+        if (*nextchar != '\0')
+        {
+          GNoptarg = nextchar;
+          GNoptind++;
+        }
+        else
+          GNoptarg = NULL;
+        nextchar = NULL;
+      }
+      else
+      {
+        /* This is an option that requires an argument.  */
+        if (*nextchar != '\0')
+        {
+          GNoptarg = nextchar;
+          /* If we end this ARGV-element by taking the rest as an arg,
+           * we must advance to the next element now.  */
+          GNoptind++;
+        }
+        else if (GNoptind == argc)
+        {
+          if (GNopterr)
+          {
+            /* 1003.2 specifies the format of this message.  */
+            FPRINTF (stderr, _("%s: option requires an argument -- %c\n"),
+                     argv[0], c);
+          }
+          if (optstring[0] == ':')
+            c = ':';
+          else
+            c = '?';
+        }
+        else
+          /* We already incremented `GNoptind' once;
+           * increment it again when taking next ARGV-elt as argument.  */
+          GNoptarg = argv[GNoptind++];
+        nextchar = NULL;
+      }
+    }
+    return c;
+  }
+}
+
+static int
+GNgetopt_long (int argc, char *const *argv, const char *options,
+               const struct GNoption *long_options, int *opt_index)
+{
+  return GN_getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* ******************** now the GNUnet specific modifications... ********************* */
+
+/**
+ * Parse the command line.
+ *
+ * @param binaryOptions Name of application with option summary
+ * @param allOptions defined options and handlers
+ * @param argc number of arguments
+ * @param argv actual arguments
+ * @return index into argv with first non-option
+ *   argument, or -1 on error
+ */
+int
+MONKEY_GETOPT_run (const char *binaryOptions,
+                   const struct MONKEY_GETOPT_CommandLineOption *allOptions,
+                   unsigned int argc, char *const *argv)
+{
+  struct GNoption *long_options;
+  struct MONKEY_GETOPT_CommandLineProcessorContext clpc;
+  int count;
+  int i;
+  char *shorts;
+  int spos;
+  int cont;
+  int c;
+
+//  MONKEY_assert (argc > 0);
+  GNoptind = 0;
+  clpc.binaryName = argv[0];
+  clpc.binaryOptions = binaryOptions;
+  clpc.allOptions = allOptions;
+  clpc.argv = argv;
+  clpc.argc = argc;
+  count = 0;
+  while (allOptions[count].name != NULL)
+    count++;
+  long_options = malloc (sizeof (struct GNoption) * (count + 1));
+  shorts = malloc (count * 2 + 1);
+  spos = 0;
+  for (i = 0; i < count; i++)
+  {
+    long_options[i].name = allOptions[i].name;
+    long_options[i].has_arg = allOptions[i].require_argument;
+    long_options[i].flag = NULL;
+    long_options[i].val = allOptions[i].shortName;
+    shorts[spos++] = allOptions[i].shortName;
+    if (allOptions[i].require_argument != 0)
+      shorts[spos++] = ':';
+  }
+  long_options[count].name = NULL;
+  long_options[count].has_arg = 0;
+  long_options[count].flag = NULL;
+  long_options[count].val = '\0';
+  shorts[spos] = '\0';
+  cont = MONKEY_OK;
+  /* main getopt loop */
+  while (cont == MONKEY_OK)
+  {
+    int option_index = 0;
+
+    c = GNgetopt_long (argc, argv, shorts, long_options, &option_index);
+
+    if (c == MONKEY_SYSERR)
+      break;                    /* No more flags to process */
+
+    for (i = 0; i < count; i++)
+    {
+      clpc.currentArgument = GNoptind - 1;
+      if ((char) c == allOptions[i].shortName)
+      {
+        cont =
+            allOptions[i].processor (&clpc, allOptions[i].scls,
+                                     allOptions[i].name, GNoptarg);
+        break;
+      }
+    }
+    if (i == count)
+    {
+      FPRINTF (stderr, _("Use %s to get a list of options.\n"), "--help");
+      cont = MONKEY_SYSERR;
+    }
+  }
+
+  free (shorts);
+  free (long_options);
+  if (cont == MONKEY_SYSERR)
+    return MONKEY_SYSERR;
+  return GNoptind;
+}
+
+/* end of getopt.c */
diff --git a/pathologist/src/pathologist/getopt_helpers.c b/pathologist/src/pathologist/getopt_helpers.c
new file mode 100644
index 0000000..50d02d8
--- /dev/null
+++ b/pathologist/src/pathologist/getopt_helpers.c
@@ -0,0 +1,294 @@
+/*
+     This file is part of GNUnet
+     (C) 2006, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet 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.
+
+     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/util/getopt_helpers.c
+ * @brief implements command line that sets option
+ * @author Christian Grothoff
+ */
+
+#include <string.h>
+#include "platform.h"
+#include "monkey_common.h"
+#include "monkey_getopt_lib.h"
+
+#define LOG(kind,...) MONKEY_log_from (kind, "util", __VA_ARGS__)
+
+
+/**
+ * Print out program version (implements --version).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to version string)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_print_version_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                              *ctx, void *scls, const char *option,
+                              const char *value)
+{
+  const char *version = scls;
+
+  printf ("%s v%s\n", ctx->binaryName, version);
+  return MONKEY_SYSERR;
+}
+
+
+
+#define BORDER 29
+
+/**
+ * Print out details on command line options (implements --help).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to about text)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_format_help_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                            *ctx, void *scls, const char *option,
+                            const char *value)
+{
+  const char *about = scls;
+  size_t slen;
+  unsigned int i;
+  int j;
+  size_t ml;
+  size_t p;
+  char *scp;
+  const char *trans;
+  const struct MONKEY_GETOPT_CommandLineOption *opt;
+
+  if (NULL != about)
+  {
+    printf ("%s\n%s\n", ctx->binaryOptions, about);
+    printf ("Arguments mandatory for long options are also mandatory for short options.\n");
+  }
+  i = 0;
+  opt = ctx->allOptions;
+  while (opt[i].description != NULL)
+  {
+    if (opt[i].shortName == '\0')
+      printf ("      ");
+    else
+      printf ("  -%c, ", opt[i].shortName);
+    printf ("--%s", opt[i].name);
+    slen = 8 + strlen (opt[i].name);
+    if (opt[i].argumentHelp != NULL)
+    {
+      printf ("=%s", opt[i].argumentHelp);
+      slen += 1 + strlen (opt[i].argumentHelp);
+    }
+    if (slen > BORDER)
+    {
+      printf ("\n%*s", BORDER, "");
+      slen = BORDER;
+    }
+    if (slen < BORDER)
+    {
+      printf ("%*s", (int) (BORDER - slen), "");
+      slen = BORDER;
+    }
+    if (0 < strlen (opt[i].description))
+      trans = opt[i].description;
+    else
+      trans = "";
+    ml = strlen (trans);
+    p = 0;
+OUTER:
+    while (ml - p > 78 - slen)
+    {
+      for (j = p + 78 - slen; j > p; j--)
+      {
+        if (isspace ((unsigned char) trans[j]))
+        {
+          scp = malloc (j - p + 1);
+          memcpy (scp, &trans[p], j - p);
+          scp[j - p] = '\0';
+          printf ("%s\n%*s", scp, BORDER + 2, "");
+          free (scp);
+          p = j + 1;
+          slen = BORDER + 2;
+          goto OUTER;
+        }
+      }
+      /* could not find space to break line */
+      scp = malloc (78 - slen + 1);
+      memcpy (scp, &trans[p], 78 - slen);
+      scp[78 - slen] = '\0';
+      printf ("%s\n%*s", scp, BORDER + 2, "");
+      free (scp);
+      slen = BORDER + 2;
+      p = p + 78 - slen;
+    }
+    /* print rest */
+    if (p < ml)
+      printf ("%s\n", &trans[p]);
+    if (strlen (trans) == 0)
+      printf ("\n");
+    i++;
+  }
+  printf ("Report bugs to gnunet-developers@gnu.org.\n"
+          "GNUnet home page: http://www.gnu.org/software/gnunet/\n"
+          "General help using GNU software: http://www.gnu.org/gethelp/\n");
+  return MONKEY_SYSERR;
+}
+
+
+/**
+ * Set an option of type 'unsigned int' from the command line. Each
+ * time the option flag is given, the value is incremented by one.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_increment_value (struct MONKEY_GETOPT_CommandLineProcessorContext
+                               *ctx, void *scls, const char *option,
+                               const char *value)
+{
+  int *val = scls;
+
+  (*val)++;
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'int' from the command line to 1 if the
+ * given option is present.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_one (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                       void *scls, const char *option, const char *value)
+{
+  int *val = scls;
+
+  *val = 1;
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'char *' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'char *'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'char *',
+ *             which will be allocated)
+ * @param option name of the option
+ * @param value actual value of the option (a string)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_string (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                          void *scls, const char *option, const char *value)
+{
+  char **val = scls;
+
+//  MONKEY_assert (value != NULL);
+//  MONKEY_free_non_null (*val);
+  if(*val != NULL) free(*val);
+  *val = strdup (value);
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'unsigned long long' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned long long'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned long long')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_ulong (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                         void *scls, const char *option, const char *value)
+{
+  unsigned long long *val = scls;
+
+  if (1 != SSCANF (value, "%llu", val))
+  {
+    FPRINTF (stderr, "You must pass a number to the `%s' option.\n", option);
+    return MONKEY_SYSERR;
+  }
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'unsigned int' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned int')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_uint (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                        void *scls, const char *option, const char *value)
+{
+  unsigned int *val = scls;
+
+  if (1 != SSCANF (value, "%u", val))
+  {
+    FPRINTF (stderr, "You must pass a number to the `%s' option.\n", option);
+    return MONKEY_SYSERR;
+  }
+  return MONKEY_OK;
+}
+
+
+/* end of getopt_helpers.c */
diff --git a/pathologist/src/pathologist/mail_sender.c b/pathologist/src/pathologist/mail_sender.c
new file mode 100644
index 0000000..98edf84
--- /dev/null
+++ b/pathologist/src/pathologist/mail_sender.c
@@ -0,0 +1,231 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#include <openssl/ssl.h>
+#include <auth-client.h>
+#include <libesmtp.h>
+
+#if !defined (__GNUC__) || __GNUC__ < 2
+# define __attribute__(x)
+#endif
+
+
+int
+handle_invalid_peer_certificate(long vfy_result)
+{
+  const char *k ="rare error";
+  switch(vfy_result) {
+  case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
+    k="X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT"; break;
+  case X509_V_ERR_UNABLE_TO_GET_CRL:
+    k="X509_V_ERR_UNABLE_TO_GET_CRL"; break;
+  case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
+    k="X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE"; break;
+  case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
+    k="X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE"; break;
+  case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
+    k="X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY"; break;
+  case X509_V_ERR_CERT_SIGNATURE_FAILURE:
+    k="X509_V_ERR_CERT_SIGNATURE_FAILURE"; break;
+  case X509_V_ERR_CRL_SIGNATURE_FAILURE:
+    k="X509_V_ERR_CRL_SIGNATURE_FAILURE"; break;
+  case X509_V_ERR_CERT_NOT_YET_VALID:
+    k="X509_V_ERR_CERT_NOT_YET_VALID"; break;
+  case X509_V_ERR_CERT_HAS_EXPIRED:
+    k="X509_V_ERR_CERT_HAS_EXPIRED"; break;
+  case X509_V_ERR_CRL_NOT_YET_VALID:
+    k="X509_V_ERR_CRL_NOT_YET_VALID"; break;
+  case X509_V_ERR_CRL_HAS_EXPIRED:
+    k="X509_V_ERR_CRL_HAS_EXPIRED"; break;
+  case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
+    k="X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD"; break;
+  case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
+    k="X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD"; break;
+  case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
+    k="X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD"; break;
+  case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
+    k="X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD"; break;
+  case X509_V_ERR_OUT_OF_MEM:
+    k="X509_V_ERR_OUT_OF_MEM"; break;
+  case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
+    k="X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT"; break;
+  case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
+    k="X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN"; break;
+  case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
+    k="X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY"; break;
+  case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
+    k="X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE"; break;
+  case X509_V_ERR_CERT_CHAIN_TOO_LONG:
+    k="X509_V_ERR_CERT_CHAIN_TOO_LONG"; break;
+  case X509_V_ERR_CERT_REVOKED:
+    k="X509_V_ERR_CERT_REVOKED"; break;
+  case X509_V_ERR_INVALID_CA:
+    k="X509_V_ERR_INVALID_CA"; break;
+  case X509_V_ERR_PATH_LENGTH_EXCEEDED:
+    k="X509_V_ERR_PATH_LENGTH_EXCEEDED"; break;
+  case X509_V_ERR_INVALID_PURPOSE:
+    k="X509_V_ERR_INVALID_PURPOSE"; break;
+  case X509_V_ERR_CERT_UNTRUSTED:
+    k="X509_V_ERR_CERT_UNTRUSTED"; break;
+  case X509_V_ERR_CERT_REJECTED:
+    k="X509_V_ERR_CERT_REJECTED"; break;
+  }
+  printf("SMTP_EV_INVALID_PEER_CERTIFICATE: %ld: %s\n", vfy_result, k);
+  return 1; /* Accept the problem */
+}
+
+
+void event_cb (smtp_session_t session, int event_no, void *arg,...)
+{
+  va_list alist;
+  int *ok;
+
+  va_start(alist, arg);
+  switch(event_no) {
+  case SMTP_EV_CONNECT: 
+  case SMTP_EV_MAILSTATUS:
+  case SMTP_EV_RCPTSTATUS:
+  case SMTP_EV_MESSAGEDATA:
+  case SMTP_EV_MESSAGESENT:
+  case SMTP_EV_DISCONNECT: break;
+  case SMTP_EV_WEAK_CIPHER: {
+    int bits;
+    bits = va_arg(alist, long); ok = va_arg(alist, int*);
+    printf("SMTP_EV_WEAK_CIPHER, bits=%d - accepted.\n", bits);
+    *ok = 1; break;
+  }
+  case SMTP_EV_STARTTLS_OK:
+    puts("SMTP_EV_STARTTLS_OK - TLS started here."); break;
+  case SMTP_EV_INVALID_PEER_CERTIFICATE: {
+    long vfy_result;
+    vfy_result = va_arg(alist, long); ok = va_arg(alist, int*);
+    *ok = handle_invalid_peer_certificate(vfy_result);
+    break;
+  }
+  case SMTP_EV_NO_PEER_CERTIFICATE: {
+    ok = va_arg(alist, int*); 
+    puts("SMTP_EV_NO_PEER_CERTIFICATE - accepted.");
+    *ok = 1; break;
+  }
+  case SMTP_EV_WRONG_PEER_CERTIFICATE: {
+    ok = va_arg(alist, int*);
+    puts("SMTP_EV_WRONG_PEER_CERTIFICATE - accepted.");
+    *ok = 1; break;
+  }
+  case SMTP_EV_NO_CLIENT_CERTIFICATE: {
+    ok = va_arg(alist, int*); 
+    puts("SMTP_EV_NO_CLIENT_CERTIFICATE - accepted.");
+    *ok = 1; break;
+  }
+  default:
+    printf("Got event: %d - ignored.\n", event_no);
+  }
+  va_end(alist);
+}
+
+
+/* Callback to prnt the recipient status */
+void
+print_recipient_status (smtp_recipient_t recipient,
+                        const char *mailbox, void *arg)
+{
+  const smtp_status_t *status;
+
+  status = smtp_recipient_status (recipient);
+  printf ("%s: %d %s", mailbox, status->code, status->text);
+}
+
+
+void sendMail(const char *messageContents, const char* reportFileName, const char *emailAddress)
+{
+        smtp_session_t session;
+        smtp_message_t message;
+        smtp_recipient_t recipient;
+        const smtp_status_t *status;
+        struct sigaction sa;
+        char *host = "localhost:25";
+        char *from = "monkey@gnunet.org";
+        char *subject = "Monkey bug report";
+        const char *recipient_address = emailAddress;
+        char tempFileName[1000];
+        int tempFd;
+        FILE *fp;
+        enum notify_flags notify = Notify_SUCCESS | Notify_FAILURE;
+
+        auth_client_init();
+        session = smtp_create_session();
+        message = smtp_add_message(session);
+        
+        /* Ignore sigpipe */
+        sa.sa_handler = SIG_IGN;
+        sigemptyset(&sa.sa_mask);
+        sa.sa_flags = 0;
+        sigaction(SIGPIPE, &sa, NULL);
+        
+        
+        smtp_set_server(session, host);
+        smtp_set_eventcb(session, event_cb, NULL);
+
+        /* Set the reverse path for the mail envelope.  (NULL is ok)
+         */
+        smtp_set_reverse_path(message, from);
+
+        /* Set the Subject: header.  For no reason, we want the supplied subject
+         to override any subject line in the message headers. */
+        if (subject != NULL) {
+                smtp_set_header(message, "Subject", subject);
+                smtp_set_header_option(message, "Subject", Hdr_OVERRIDE, 1);
+        }
+
+        
+        /* Prepare message */
+        if (NULL == reportFileName) {
+                memset(tempFileName, 0, sizeof(tempFileName));
+                sprintf(tempFileName, "/tmp/messageXXXXXX");
+                tempFd = mkstemp(tempFileName);
+                fp = fdopen(tempFd, "w");
+                fprintf(fp, "%s", messageContents);
+                fclose(fp);
+                fp = fopen(tempFileName, "r");
+                smtp_set_message_fp(message, fp);
+        } else {
+                fp = fopen(reportFileName, "r");
+                smtp_set_message_fp(message, fp);
+        }
+
+        
+        recipient = smtp_add_recipient(message, recipient_address);
+
+        smtp_dsn_set_notify (recipient, notify);
+        
+        /* Initiate a connection to the SMTP server and transfer the
+         message. */
+        if (!smtp_start_session(session)) {
+                char buf[128];
+
+                fprintf(stderr, "SMTP server problem %s\n", smtp_strerror(smtp_errno(),
+                                buf, sizeof buf));
+        } else {
+                /* Report on the success or otherwise of the mail transfer.
+                 */
+                status = smtp_message_transfer_status(message);
+                printf("%d %s", status->code, (status->text != NULL) ? status->text
+                                : "\n");
+                smtp_enumerate_recipients(message, print_recipient_status, NULL);
+        }
+
+        /* Free resources consumed by the program.
+         */
+        smtp_destroy_session(session);
+        fclose(fp);
+        auth_client_exit();
+}
+
diff --git a/pathologist/src/pathologist/pathologist.c b/pathologist/src/pathologist/pathologist.c
new file mode 100644
index 0000000..305c3ce
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist.c
@@ -0,0 +1,357 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet 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 3, or (at your
+     option) any later version.
+
+     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file pathologist/pathologist.c
+ * @brief Monkey Pathologist: automated debugging tool
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "monkey_common.h"
+#include "action.h"
+#include "monkey_getopt_lib.h"
+
+static char *dumpFileName;
+static char *binaryName;
+static char *command;
+static char *binaryArgs;
+static char *emailAddress;
+static char *edbFilePath;
+static char *gdbBinaryPath;
+static char *valgrindBinaryPath;
+static char *inspectExpression;
+static char *inspectFunction;
+static int scopeDepth;
+static int reverseExecutionAllowed = MONKEY_NO;
+static int ret = 0;
+
+static int checkFileExistence(const char *filePath) {
+        struct stat statBuff;
+        if (0 == stat(filePath, &statBuff)) {
+                return MONKEY_YES;
+        }
+        return MONKEY_NO;
+}
+
+
+static int checkELF(const char *binaryPath) {
+        int ch;
+        const char ELF[5] = {0x7f, 'E', 'L', 'F', '\0'}; // ELF magic number
+        char inputArr[5];
+        FILE *filePtr;
+        filePtr = fopen(binaryPath, "r");
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                ch = fgetc(filePtr);
+                if (EOF == ch) {
+                        return MONKEY_NO;
+                }
+                inputArr[i] = ch;
+        }
+        inputArr[4] = '\0';
+        if (strcmp(ELF, inputArr) == 0) {
+                return MONKEY_YES;
+        }
+        return MONKEY_NO;
+}
+/**
+ * Main function that will launch Pathologist's action api.
+*/
+static void run()
+{
+        int result;
+        struct MONKEY_ACTION_Context *cntxt;
+
+        /* Check files existence */
+        if (MONKEY_NO == checkFileExistence(binaryName)) {
+                fprintf(stderr, "Error: Target binary file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        if (MONKEY_NO == checkFileExistence(edbFilePath)) {
+                fprintf(stderr, "Error: Expression database file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        if (NULL != gdbBinaryPath &&
+                MONKEY_NO == checkFileExistence(gdbBinaryPath))
+        {
+                fprintf(stderr, "Error: gdb binary file does not exist.\n");
+                ret = 1;
+                return;
+                
+        }
+
+        if (NULL != valgrindBinaryPath &&
+                MONKEY_NO == checkFileExistence(valgrindBinaryPath))
+        {
+                fprintf(stderr, "Error: valgrind binary file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        /* Check if the target program is and ELF binary */
+        if (MONKEY_NO == checkELF(binaryName)) {
+                FILE* targetProgramPipe;
+                char buffer[128];
+                ret = 1;
+
+                fprintf(stderr, "Target program is not an ELF. Pathologist will not debug the program.\n");
+                fprintf(stderr, "Pathologist will attempt to run the program normally.\n");
+
+                targetProgramPipe = popen(command, "r");
+                if (NULL == targetProgramPipe) {
+                        fprintf(stderr, "Target is not a binary.\n");
+                        return;
+                }
+                while(!feof(targetProgramPipe)) {
+                        if (NULL != fgets(buffer, 128, targetProgramPipe)) {
+                                fputs(buffer, stderr);
+                        }
+                }
+                pclose(targetProgramPipe);
+                return;
+        }
+
+        if (NULL == edbFilePath)
+        {
+                /* lookup a file named test.db in the working directory */
+                struct stat buf;
+                if (0 != stat ("test.db", &buf))
+                {
+                        fprintf( stderr,
+                        "Expression Database file was not provided as and argument, "
+                        "and there is no file named test.db in pathologist's working directory!\n");
+                        MONKEY_break (0);
+                        ret = 1;
+                        return;
+                }
+        }
+
+        if (NULL == dumpFileName)
+        {
+                /* if no file name provided for the output report, the default report name will be binaryName_PIDpid */
+                const char *bn = strrchr(binaryName, '/');
+                if (NULL == bn) {
+                        bn = binaryName;
+                } else {
+                        bn++;
+                }
+                MONKEY_asprintf(&dumpFileName, "%s_PID%d", bn, getpid());
+        }
+
+        /* Initialize context for the Action API */
+        cntxt = MONKEY_malloc (sizeof (struct MONKEY_ACTION_Context));
+        cntxt->email_address = emailAddress;
+        cntxt->binary_name = binaryName;
+        cntxt->binaryArgs = binaryArgs;
+        cntxt->expression_database_path = edbFilePath;
+        cntxt->gdb_binary_path = gdbBinaryPath;
+        cntxt->valgrind_binary_path = valgrindBinaryPath;
+        cntxt->inspect_expression = inspectExpression;
+        cntxt->inspect_function = inspectFunction;
+        cntxt->scope_depth = scopeDepth;
+        cntxt->bug_detected = NO_BUG_DETECTED;
+        cntxt->has_null = MONKEY_NO;
+        cntxt->xml_report_node = NULL;
+        cntxt->run_reverse = reverseExecutionAllowed;
+        cntxt->gdb_connected = MONKEY_NO;
+
+        result = MONKEY_ACTION_rerun_with_gdb (cntxt);
+        int retVal;
+        switch (result)
+        {
+        case MONKEY_NO:
+        case GDB_STATE_ERROR:
+                fprintf (stderr, "Error in using gdb. Pathologist will exit now!\n");
+                ret = 1;
+                break;
+        case GDB_STATE_EXIT_NORMALLY:
+                fprintf (stderr, "Debug with gdb, program exited normally!\n");
+                break;
+        case GDB_STATE_STOPPED:
+                //categorize bug
+                if ((strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Segmentation fault") == 0)
+                 || (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Signal 0") == 0))
+                        cntxt->bug_detected = MONKEY_ACTION_is_Nullpointer(cntxt) ? BUG_NULL_POINTER : BUG_BAD_MEM_ACCESS;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Aborted") == 0)
+                        cntxt->bug_detected = BUG_ABORT;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Arithmetic exception") == 0)
+                        cntxt->bug_detected = BUG_ARITHMETIC;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_name, "SIGBUS") == 0)
+                        cntxt->bug_detected = BUG_SIG_BUS;
+
+                // get relevant expressions
+                retVal = MONKEY_ACTION_inspect_expression_database (cntxt);
+
+                if (MONKEY_NO == retVal)
+                {
+                        fprintf( stderr,
+                        "Error in using the expression database. Pathologist will exit now!\n");
+                        ret = 1;
+                        break;
+                }
+                else if (BUG_BAD_MEM_ACCESS == cntxt->bug_detected
+                || BUG_SIG_BUS == cntxt->bug_detected)
+                {
+                        /* launch valgrind */
+                        retVal = MONKEY_ACTION_rerun_with_valgrind (cntxt);
+                        if (MONKEY_NO == retVal)
+                                fprintf( stderr, "Error using Valgrind! Pathologist will continue debugging!\n");
+                }
+
+                /* Start backtracking if enabled by user */
+                if (cntxt->run_reverse) {
+                        retVal = MONKEY_ACTION_start_reverse_execution(cntxt);
+                        if (MONKEY_NO == retVal)
+                                fprintf(stderr, "Error during Backtracking! Pathologist will continue debugging with backtracking.\n");
+                }
+
+
+                //                              REPORTING
+                if (MONKEY_OK != MONKEY_ACTION_format_report_xml (cntxt))
+                {
+                        fprintf( stderr,
+                        "Error in generating debug report!\n");
+                        ret = 1;
+                }
+                if (emailAddress != NULL)
+                {
+                        if (MONKEY_OK != MONKEY_ACTION_report_email (cntxt, dumpFileName))
+                        {
+                                fprintf( stderr, "Error sending email!\n");
+                                ret = 1;
+                        }
+                }
+                if (dumpFileName != NULL)
+                {
+                        if (MONKEY_OK !=
+                        MONKEY_ACTION_report_file (cntxt, dumpFileName, MONKEY_YES))
+                        {
+                                fprintf( stderr,
+                                "Error in saving debug file!\n");
+                                ret = 1;
+                        }
+                }
+                break;
+        default:
+                break;
+        }
+
+MONKEY_ACTION_delete_context (cntxt);
+}
+
+
+int freePathologistArgs()
+{
+        if (NULL != dumpFileName)
+                MONKEY_free(dumpFileName);
+        if (NULL != emailAddress)
+                MONKEY_free(emailAddress);
+        if (NULL != edbFilePath)
+                MONKEY_free(edbFilePath);
+        if (NULL != gdbBinaryPath)
+                MONKEY_free(gdbBinaryPath);
+        if (NULL != valgrindBinaryPath)
+                MONKEY_free(valgrindBinaryPath);
+        if (NULL != inspectExpression)
+                MONKEY_free(inspectExpression);
+        if (NULL != inspectFunction)
+                MONKEY_free(inspectFunction);
+
+        return MONKEY_OK;
+}
+
+
+
+const char * buildBinaryArgs(int argc, char **argv) {
+        char * res = MONKEY_strdup("");
+        char * tmp;
+        int i;
+        for (i = 0; i < argc; i++) {
+                MONKEY_asprintf(&tmp, "%s %s", res, argv[i]);
+                MONKEY_free(res);
+                res = tmp;
+        }
+
+        return res;
+}
+
+int
+main (int argc, char *argv[])
+{
+        static const struct MONKEY_GETOPT_CommandLineOption options[] = {
+                {'d', "database", "FILENAME", "the expression database to use, generated by seaspider",
+                        1, &MONKEY_GETOPT_set_string, &edbFilePath},
+                {'f', "function", "FUNCTIONNAME", "the name of the function, in which pathologist will set a breakpoint",
+                        1, &MONKEY_GETOPT_set_string, &inspectFunction},
+                {'g', "gdb", "FILENAME", "path to gdb binary to use. If not passed, pathologist will set it to /usr/bin/gdb",
+                        1, &MONKEY_GETOPT_set_string, &gdbBinaryPath},
+                {'h', "help", NULL, "shows this help",
+                        0, &MONKEY_GETOPT_format_help_, "Monkey Pathologist: Automatically debug a service"},
+                {'i', "inspect", "EXPRESSIONNAME", "expression to inspect in the function specified after argument f",
+                        1, &MONKEY_GETOPT_set_string, &inspectExpression},
+                {'l', "valgrind", "FILENAME", "path to valgrind binary. If not passed, pathologist will set it to /usr/bin/valgrind",
+                        1, &MONKEY_GETOPT_set_string, &valgrindBinaryPath},
+                {'m', "mail", "MAILADDRESS", "if specified, pathologist will send the bugreport to the given address",
+                        1, &MONKEY_GETOPT_set_string, &emailAddress},
+                {'o', "report", "FILENAME", "saves the xml formated report to the given file",
+                        1, &MONKEY_GETOPT_set_string, &dumpFileName},
+                {'p', "depth", "UINT", "scope depth. How many scopes should pathologist lookup expression values outer than the scope in which the problem occurs. Default is 0 which means, pathologist is restricted to the scope of the expression in which the debugged program stopped" ,
+                        1, &MONKEY_GETOPT_set_uint, &scopeDepth},
+                {'r', "reverse", NULL, "enables reverse execution",
+                        0, &MONKEY_GETOPT_set_one, &reverseExecutionAllowed},
+                {'v', "version", NULL, "print the version number",
+                        0, &MONKEY_GETOPT_print_version_, "0.1 alpha"},
+                MONKEY_GETOPT_OPTION_END
+        };
+
+        if (-1 == (ret = MONKEY_GETOPT_run ("pathologist -d DATABASEFILE [options] [--] BINARY", options, (unsigned int) argc, argv)))
+                return -1;
+
+        // Check for required arguments
+        if (argc <= ret)
+                printf("Error: missing argument: path to the binary file.\n");
+        if (NULL == edbFilePath)
+                printf("Error: missing argument: path to expression database file.\n");
+        if (argc <= ret || NULL == edbFilePath)
+                exit(EXIT_FAILURE);
+
+        /* All remaining args are considered program arguments */
+        binaryName = argv[ret];
+        command    = (char *)buildBinaryArgs(argc - ret, &argv[ret]) + 1;
+        binaryArgs = (char *)buildBinaryArgs(argc - ret - 1, &argv[ret + 1]);
+
+        printf("\n%s\n%s\n%s\n\n", binaryName, command, binaryArgs);
+        
+        /* Run Pathologist */
+        run();
+
+        /* clean up */
+        freePathologistArgs();
+
+        return ret;
+}
diff --git a/pathologist/src/pathologist/pathologist_edb.h b/pathologist/src/pathologist/pathologist_edb.h
new file mode 100644
index 0000000..33e18ee
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist_edb.h
@@ -0,0 +1,158 @@
+/**
+ * @file monkey/MONKEY_edb.h
+ * @brief Monkey API for accessing the Expression Database (edb)
+ */
+
+#ifndef MONKEY_EDB_H
+#define MONKEY_EDB_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+struct MONKEY_EDB_Context;
+
+/**
+ * Establish a connection to the Expression Database
+ *
+ * @param db_file_name path the Expression Database file
+ * @return context to use for Accessing the Expression Database, NULL on error
+ */
+struct MONKEY_EDB_Context *MONKEY_EDB_connect (const char
+                                                             *db_file_name);
+
+
+/**
+ * Disconnect from Database, and cleanup resources
+ *
+ * @param context context
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int MONKEY_EDB_disconnect (struct MONKEY_EDB_Context *cntxt);
+
+
+typedef int (*MONKEY_ExpressionIterator) (void *, int, char **,
+                                                 char **);
+
+typedef int (*MONKEY_FileIterator) (void *, int, char **, char **);
+
+
+
+int
+MONKEY_EDB_get_all_outer_scopes(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int function_beginning,
+                int scope_in_question_start,
+                int scope_in_question_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls);
+
+int
+MONKEY_EDB_expression_function_end_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int start_lineno,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls);
+int
+MONKEY_EDB_function_start_line_for_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int scope_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls);
+/**
+ * Return the line number of the end-of-scope for the expression indicated by start_line_no
+ *
+ * @param cntxt context containing the Expression Database handle
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression's line
+ * @param iter callback function, iterator for values returned from the Database
+ * @param iter_cls closure for the expression iterator, will contain the scope-end line number
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_get_expression_scope_end (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            int start_line_no,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls);
+
+
+int
+MONKEY_EDB_get_expression_scope_end_for_expression (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            const char * expr_syntax,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls);
+
+/**
+ * Return all the source code file names available in the Expression Database
+ *
+ * @param cntxt context containing the Expression Database handle
+ * @param iter callback function, iterator for values returned from the Database
+ * @param iter_cls closure for the file names iterator, will contain the file names
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_get_file_names (struct MONKEY_EDB_Context *cntxt,
+                                  MONKEY_FileIterator iter,
+                                  void *iter_cls);
+
+
+int
+MONKEY_EDB_get_globals (struct MONKEY_EDB_Context *cntxt,
+                                                const char* file_names,
+                                                MONKEY_ExpressionIterator iter,
+                                                void *iter_cls);
+
+/**
+ * Run an SQLite query to retrieve those expressions that are previous to
+ * given expression and are in the same scope of the given expression
+ * For example, consider the following code snippet:
+ *
+ * {
+ *   struct Something whole; // line no.1 
+ *   struct SomethingElse part; // line no.2
+ *   whole.part = &part; // line no.3
+ *   whole.part->member = 1; // line no.4
+ * }
+ *
+ * If the expression supplied to the function is that of line no.4 "whole.part->member = 1;"
+ * The returned list of expressions will be: whole.part (line no.4), whole.part->member (line no.4),
+ * whole (line no.3), whole.part (line no.3), &part (line no.3), whole.part = &part (line no.3)
+ *
+ * @param cntxt context containing the Expression Database handle.
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression beginning line
+ * @param iter callback function, iterator for expressions returned from the Database
+ * @param iter_cls closure for the expression iterator
+ * @return MONKEY_OK success, MONKEY_NO failure
+ */
+int
+MONKEY_EDB_get_expressions (struct MONKEY_EDB_Context *cntxt,
+                                   const char *file_name, int start_line_no,
+                                   MONKEY_ExpressionIterator iter,
+                                   void *iter_cls);
+
+
+int
+MONKEY_EDB_get_sub_expressions (struct MONKEY_EDB_Context
+                                       *cntxt, const char *file_name,
+                                       int start_line_no, int end_line_no,
+                                       MONKEY_ExpressionIterator iter,
+                                       void *iter_cls);
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pathologist/src/pathologist/pathologist_xml_writer.h b/pathologist/src/pathologist/pathologist_xml_writer.h
new file mode 100644
index 0000000..5e74060
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist_xml_writer.h
@@ -0,0 +1,54 @@
+/**
+ * @file monkey/MONKEY_xml_writer.h
+ * @brief Monkey API for generating XML debug report
+ */
+
+
+#ifndef MONKEY_XML_WRITER_H
+#define MONKEY_XML_WRITER_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+struct XmlAttribute {
+        struct XmlAttribute *next;
+        struct XmlAttribute *prev;
+        const char *name;
+        const char *value;
+};
+
+
+struct MONKEY_XML_Node {
+        struct MONKEY_XML_Node *next;
+        struct MONKEY_XML_Node *prev;
+        const char *name;
+        const char *value;
+        const char *innerText;
+        struct XmlAttribute* attributeListHead;
+        struct XmlAttribute* attributeListTail;
+        struct MONKEY_XML_Node *childrenListHead;
+        struct MONKEY_XML_Node *childrenListTail;
+};
+
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_new_node(const char *name, const char *innerText);
+int MONKEY_XML_WRITER_delete_tree(struct MONKEY_XML_Node *root);
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_add_child(struct MONKEY_XML_Node *parent, struct MONKEY_XML_Node *child);
+int MONKEY_XML_WRITER_write_document(FILE* file, struct MONKEY_XML_Node *root);
+FILE* MONKEY_XML_WRITER_create_document(const char *filePath);
+int MONKEY_XML_WRITER_add_attribute(struct MONKEY_XML_Node* node, const char *attrName, const char *attrValue);
+int MONKEY_XML_WRITER_add_inner_text(struct MONKEY_XML_Node *node, const char *innerText);
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pathologist/src/pathologist/test_monkey_assertion_failure.sh b/pathologist/src/pathologist/test_monkey_assertion_failure.sh
new file mode 100644
index 0000000..2a6d3b0
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_assertion_failure.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+echo -n "Test Monkey with Bug - Assertion Failure -"
+gnunet-monkey -m text -d bug_assertion_failure.db -b bug_assertion_failure -o monkey.out || (echo "Monkey Failed!" && exit 1)
+grep "Bug detected in file:bug_assertion_failure.c" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "function:assertionFailure" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "line:8" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "received signal:SIGABRT" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Aborted" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Details:" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Assertion Failure" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Expression evaluation:" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "assert(x<4) = Not evaluated" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "x<4 = 0" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "x = 5" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+rm -f monkey.out
+echo "PASS"
diff --git a/pathologist/src/pathologist/test_monkey_bad_memory_access.sh b/pathologist/src/pathologist/test_monkey_bad_memory_access.sh
new file mode 100644
index 0000000..cd86a84
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_bad_memory_access.sh
@@ -0,0 +1,15 @@
+echo -n "Test Monkey with Bug - Bad Memory Access -"
+gnunet-monkey -m text -d bug_bad_memory_access.db -b bug_bad_memory_access -o monkey.out || (echo "Monkey Failed!" && exit 1)
+for i in `cat bug_bad_memory_access_rpt.ref`
+do
+        grep $i monkey.out
+        if [ $? -ne 0 ]
+        then
+                {
+                echo $i
+                echo "FAIL"
+                exit 1
+                }
+        fi
+done 
+echo "PASS"
diff --git a/pathologist/src/pathologist/test_monkey_data.conf b/pathologist/src/pathologist/test_monkey_data.conf
new file mode 100644
index 0000000..9ae1d67
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_data.conf
@@ -0,0 +1,43 @@
+[PATHS]
+SERVICEHOME = /tmp/test-gnunetd-arm/
+DEFAULTCONFIG = test_arm_api_data.conf
+
+[arm]
+PORT = 23354
+DEFAULTSERVICES =
+BINARY = gnunet-service-arm
+OPTIONS = -L ERROR
+# DEBUG = YES
+#PREFIX = valgrind --tool=memcheck --leak-check=yes
+
+[gnunet-monkey]
+# DEBUG = YES
+PORT = 23355
+BINARY = gnunet-monkey
+# PREFIX = valgrind
+
+
+[fs]
+AUTOSTART = NO
+
+[datastore]
+AUTOSTART = NO
+
+[core]
+AUTOSTART = NO
+
+[transport]
+AUTOSTART = NO
+
+[peerinfo]
+AUTOSTART = NO
+
+[statistics]
+AUTOSTART = YES
+# DEBUG = NO
+
+
+[dns]
+AUTOSTART = NO
+
+
diff --git a/pathologist/src/pathologist/test_monkey_npe.sh b/pathologist/src/pathologist/test_monkey_npe.sh
new file mode 100755
index 0000000..5f3d528
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_npe.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+echo -n "Test Monkey with Bug - Null Pointer Exception -"
+gnunet-monkey -m text -d bug_null_pointer_exception.db -b bug_null_pointer_exception -o npe.out || (echo "Monkey Failed!" && exit 1)
+grep "Bug detected in file:bug_null_pointer_exception.c" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "function:crashFunction" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "line:14" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "reason:(null)" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "received signal:SIGSEGV" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Segmentation fault" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep " Details:" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep " Expression:crashStruct is NULL" npe.out > /dev/null || (echo "FAIL" && exit 1)
+rm -f npe.out
+echo "PASS"
diff --git a/pathologist/src/pathologist/test_pathologist.c b/pathologist/src/pathologist/test_pathologist.c
new file mode 100644
index 0000000..eac5d2f
--- /dev/null
+++ b/pathologist/src/pathologist/test_pathologist.c
@@ -0,0 +1,412 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "mxml.h"
+
+#undef DEBUG_ENABLED
+static int OK = 0;
+static int NO = 1;
+static char *reportPath = "../../refs/reports";
+static char *dbPath = "../../refs/db";
+static char *binPath = "../../refs/src";
+
+int compareReports(const char *refFileName, const char *testFileName) {
+        FILE *testFilePtr;
+        FILE *refFilePtr;
+        mxml_node_t *refTree;
+        mxml_node_t *testTree;
+        mxml_node_t *refNode;
+        mxml_node_t *testNode;
+        mxml_node_t *refEpochNode;
+        mxml_node_t *testEpochNode;
+        mxml_node_t *refFunctionNode;
+        mxml_node_t *testFunctionNode;
+        mxml_node_t *refExpressionNode;
+        mxml_node_t *testExpressionNode;
+        const char *refExpressionValue;
+        const char *testExpressionValue;
+
+        refFilePtr = fopen(refFileName, "r");
+        testFilePtr = fopen(testFileName, "r");
+        if (NULL == refFilePtr) {
+                fprintf(stderr, "Test failed: cannot locate reference report: %s.\n", strerror(errno));
+                return NO;
+        }
+        if (NULL == testFilePtr) {
+                fprintf(stderr, "Test failed: cannot locate test report: %s.\n", strerror(errno));
+                return NO;
+        }
+
+        refTree = mxmlLoadFile(NULL, refFilePtr, MXML_TEXT_CALLBACK);
+        testTree = mxmlLoadFile(NULL, testFilePtr, MXML_TEXT_CALLBACK);
+        if (NULL == refTree) {
+                fprintf(stderr, "Test failed: cannot parse reference report.\n");
+                return NO;
+        }
+        if (NULL == testTree) {
+                fprintf(stderr, "Test failed: cannot parse test report.\n");
+                return NO;
+        }
+        fclose(refFilePtr);
+        fclose(testFilePtr);
+
+        refNode = refTree; testNode = testTree; // <?xml version="1.0"?>
+
+        // <crash>...
+        refNode = mxmlWalkNext(mxmlGetFirstChild(refNode), refTree, MXML_DESCEND);
+        testNode = mxmlWalkNext(mxmlGetFirstChild(testNode), testTree, MXML_DESCEND);
+        if (0 != strcmp(mxmlGetElement(refNode), "crash") ||
+                        0 != strcmp(mxmlGetElement(testNode), "crash")) {
+                fprintf(stderr, "Test failed: wrong tag. <crash> expected\n");
+                return NO;
+        }
+        if (0 != strcmp(mxmlElementGetAttr(refNode, "category"), mxmlElementGetAttr(testNode, "category")) ||
+                        0 != strcmp(mxmlElementGetAttr(refNode, "function"), mxmlElementGetAttr(testNode, "function")) ||
+                        0 != strcmp(mxmlElementGetAttr(refNode, "line"), mxmlElementGetAttr(testNode, "line")) ||
+                        0 != strcmp(mxmlElementGetAttr(refNode, "file"), mxmlElementGetAttr(testNode, "file"))) {
+                fprintf(stderr, "Test failed: crash attributes mismatch.\n");
+                return NO;
+        }
+
+         // <valgrind> or <history>...
+        refNode = mxmlWalkNext(mxmlGetFirstChild(refNode), refTree, MXML_DESCEND);
+        testNode = mxmlWalkNext(mxmlGetFirstChild(testNode), testTree, MXML_DESCEND);
+        if (0 == strcmp(mxmlGetElement(refNode), "valgrind")) {
+                if (0 != strcmp(mxmlGetElement(testNode), "valgrind")) {
+                        fprintf(stderr, "Test failed: wrong tag, <valgrind> expected.\n");
+                        return NO;
+                }
+                refNode = mxmlFindElement(refNode, refTree, "history", NULL, NULL, MXML_DESCEND); // move to <history>
+                testNode = mxmlFindElement(testNode, testTree, "history", NULL, NULL, MXML_DESCEND);
+        } else if (0 == strcmp(mxmlGetElement(refNode), "history")) {
+                if (0 != strcmp(mxmlGetElement(testNode), "history")) {
+                        fprintf(stderr, "Test failed: wrong tag, <history> expected.\n");
+                        return NO;
+                }
+        } else {
+                fprintf(stderr, "Test failed: unknown tag.\n");
+                return NO;
+        }
+
+        // <epoch>'s
+        refEpochNode = mxmlGetFirstChild(refNode);
+        testEpochNode = mxmlGetFirstChild(testNode);
+        while (NULL != refEpochNode && NULL != testEpochNode) {
+                if (0 != strcmp(mxmlGetElement(refEpochNode), "epoch") ||
+                                0 != strcmp(mxmlGetElement(testEpochNode), "epoch")) {
+                        fprintf(stderr, "Test failed: wrong tag, <epoch> expected.\n");
+                        return NO;
+                }
+                // Comparing the epoch steps
+                if (0 != strcmp(mxmlElementGetAttr(refEpochNode, "step"), mxmlElementGetAttr(testEpochNode, "step"))) {
+                        fprintf(stderr, "Test failed: epoch steps mismatch.\n");
+                        return NO;
+                }
+
+                // <trace>
+                refNode = mxmlWalkNext(mxmlGetFirstChild(refEpochNode), refTree, MXML_DESCEND);
+                testNode = mxmlWalkNext(mxmlGetFirstChild(testEpochNode), testTree, MXML_DESCEND);
+
+                // <function>'s
+                refFunctionNode = mxmlGetFirstChild(refNode);
+                testFunctionNode = mxmlGetFirstChild(testNode);
+                while (NULL != refFunctionNode && NULL != testFunctionNode) {
+                        if (0 != strcmp(mxmlGetElement(refFunctionNode), "function") ||
+                                        0 != strcmp(mxmlGetElement(testFunctionNode), "function")) {
+                                fprintf(stderr, "Test failed: wrong tag, <function> expected.\n");
+                                return NO;
+                        }
+                        //comparing function attributes
+                        if (0 != strcmp(mxmlElementGetAttr(refFunctionNode, "name"), mxmlElementGetAttr(testFunctionNode, "name")) ||
+                                        0 != strcmp(mxmlElementGetAttr(refFunctionNode, "line"), mxmlElementGetAttr(testFunctionNode, "line")) ||
+                                        0 != strcmp(mxmlElementGetAttr(refFunctionNode, "file"), mxmlElementGetAttr(testFunctionNode, "file")) ||
+                                        0 != strcmp(mxmlElementGetAttr(refFunctionNode, "depth"), mxmlElementGetAttr(testFunctionNode, "depth"))) {
+                                fprintf(stderr, "Test failed: function attributes mismatch.\n");
+                                return NO;
+                        }
+
+                        // <expressions>
+                        refNode = mxmlWalkNext(mxmlGetFirstChild(refFunctionNode), refTree, MXML_DESCEND);
+                        testNode = mxmlWalkNext(mxmlGetFirstChild(testFunctionNode), testTree, MXML_DESCEND);
+
+                        // <expression>'s
+                        refExpressionNode = mxmlGetFirstChild(refNode);
+                        testExpressionNode = mxmlGetFirstChild(testNode);
+                        while (NULL != refExpressionNode && NULL != testExpressionNode) {
+                                if (0 != strcmp(mxmlGetElement(refExpressionNode), "expression") ||
+                                                0 != strcmp(mxmlGetElement(testExpressionNode), "expression")) {
+                                        fprintf(stderr, "Test failed: wrong tag, <expression> expected.\n");
+                                        return NO;
+                                }
+
+                                // comparing expression syntax
+                                if (0 != strcmp(mxmlElementGetAttr(refExpressionNode, "name"), mxmlElementGetAttr(testExpressionNode, "name"))) {
+                                        fprintf(stderr, "Test failed: expression syntax mismatch.\n");
+                                        return NO;
+                                }
+
+                                // comparing expression values
+                                refExpressionValue = mxmlGetText(refExpressionNode, 0);
+                                testExpressionValue = mxmlGetText(testExpressionNode, 0);
+                                if (0 != strcmp(refExpressionValue, testExpressionValue)) {
+                                        // different pointer values are accepted
+                                        if (!(refExpressionValue[0] == '0' && refExpressionValue[1] == 'x'
+                                                        && testExpressionValue[0] == '0' && testExpressionValue[1] == 'x')) {
+                                                if ((strlen(refExpressionValue) >= 5) || (strlen(testExpressionValue) >= 5)) {
+                                                        // different numeric values longer than 5 digits are accepted (such values are considered garbage in uninitialized variables)
+                                                        char *endPtr = NULL;
+                                                        long refIntVal;
+                                                        long testIntVal;
+                                                        refIntVal = strtol(refExpressionValue, &endPtr, 0); // testing whether the values are numeric
+                                                        testIntVal = strtol(testExpressionValue, &endPtr, 0);
+                                                        if ((0 == refIntVal || 0 == testIntVal) && (ERANGE == errno || EINVAL == errno)) {
+                                                                fprintf(stderr, "Test failed: expression value mismatch.\n");
+                                                                return NO;
+                                                        }
+                                                } else {
+                                                        // not pointers and not 5+ digits numbers, then mismatch
+                                                        fprintf(stderr, "Test failed: expression value mismatch.\n");
+                                                        return NO;
+                                                }
+                                        }
+                                }
+
+                                // next expression
+                                refExpressionNode = mxmlGetNextSibling(mxmlGetNextSibling(refExpressionNode));
+                                testExpressionNode = mxmlGetNextSibling(mxmlGetNextSibling(testExpressionNode));
+                        }
+                        if (NULL != refExpressionNode || NULL != testExpressionNode) {
+                                fprintf(stderr, "Test failed: expression mismatch.\n");
+                                return NO;
+                        }
+
+                        // next function
+                        refFunctionNode = mxmlGetNextSibling(mxmlGetNextSibling(refFunctionNode));
+                        testFunctionNode = mxmlGetNextSibling(mxmlGetNextSibling(testFunctionNode));
+                }
+                if (NULL != refFunctionNode || NULL != testFunctionNode) {
+                        fprintf(stderr, "Test failed: function mismatch.\n");
+                        return NO;
+                }
+
+                // next epoch step
+                refEpochNode = mxmlGetNextSibling(mxmlGetNextSibling(refEpochNode));
+                testEpochNode = mxmlGetNextSibling(mxmlGetNextSibling(testEpochNode));
+        }
+        if (NULL != refEpochNode || NULL != testEpochNode) {
+                fprintf(stderr, "Test failed: epoch steps mismatch.\n");
+                return NO;
+        }
+
+        mxmlDelete(refTree);
+        mxmlDelete(testTree);
+        return OK;
+}
+
+
+int runTest(const char *refReportName, const char *testReportName,
+                const char *dbName, const char *binaryName, char *commandStr) {
+        FILE *pathologistPipe;
+        char *refReportPath;
+        char *testReportPath;
+        char *dbFilePath;
+        char *binFilePath;
+        char *command;
+        int ret = OK;
+
+        asprintf(&testReportPath, "%s/%s", reportPath, testReportName);
+        asprintf(&dbFilePath, "%s/%s", dbPath, dbName);
+        asprintf(&binFilePath, "%s/%s", binPath, binaryName);
+        asprintf(&command, commandStr, dbFilePath, testReportPath, binFilePath);
+        asprintf(&refReportPath, "%s/%s", reportPath, refReportName);
+
+        // run Monkey pathologist
+        pathologistPipe = popen(command, "r");
+#ifdef DEBUG_ENABLED
+        fprintf(stderr, "Running command: %s\n", command);
+#endif
+        if (NULL == pathologistPipe) {
+                fprintf(stderr, "Fatal error: unable to run Monkey pathologist.\n");
+                ret = NO;
+        }
+        else {
+                char buffer[128];
+                while(!feof(pathologistPipe)) {
+                        if(fgets(buffer, 128, pathologistPipe) != NULL) {
+#ifdef DEBUG_ENABLED
+                                fputs(buffer, stdout);
+#endif
+                        }
+                }
+                pclose(pathologistPipe);
+                // compare results with ref
+                if (NO == compareReports(refReportPath, testReportPath)) {
+                        ret = NO;
+                } else {
+                        // test passed, delete test report
+                        if (0 != remove(testReportPath)) {
+                                fprintf(stderr, "Warning: could not remove test file %s\n", testReportPath);
+                        }
+                }
+        }
+
+        free(refReportPath); free(command); free(binFilePath); free(dbFilePath); free(testReportPath);
+        return ret;
+}
+
+int main() {
+        int ret = OK;
+        char *commandStr = "pathologist -d %s -o %s %s";
+        char *commandStrReverse = "pathologist -d %s -o %s -r %s";
+        char *commandStrDepthOne = "pathologist -d %s -o %s -p 1 %s";
+        char *commandStrDepthOneReverse = "pathologist -d %s -o %s -p 1 -r %s";
+        char *commandStrDepthThousand = "pathologist -d %s -o %s -p 1000 %s";
+
+        fprintf(stderr, "Testing Monkey Pathologist...\n");
+
+        // Bug Null Pointer Exception
+        fprintf(stderr, "Testing bug null pointer exception...\n");
+        if (NO == runTest("ref_bug_null_pointer_exception.xml",
+                        "test_bug_null_pointer_exception.xml", "bug_null_pointer_exception.db",
+                        "bug_null_pointer_exception", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug null pointer exception: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug null pointer exception: PASSED\n");
+        }
+
+        // Bug Null Pointer Exception with backtracking
+        fprintf(stderr, "Testing bug null pointer exception with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_null_pointer_exception.xml",
+                        "test_bt_bug_null_pointer_exception.xml", "bug_null_pointer_exception.db",
+                        "bug_null_pointer_exception", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug null pointer exception with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug null pointer exception with backtracking: PASSED\n");
+        }
+
+        // Bug Null Pointer Exception modified with backtracking
+        fprintf(stderr, "Testing bug null pointer exception modified with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_null_pointer_exception_modified.xml",
+                        "test_bt_bug_null_pointer_exception_modified.xml", "bug_null_pointer_exception_modified.db",
+                        "bug_null_pointer_exception_modified", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug null pointer exception modified with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug null pointer exception modified with backtracking: PASSED\n");
+        }
+
+        // Bug Bad Memory Access
+        fprintf(stderr, "Testing bug bad memory access...\n");
+        if (NO == runTest("ref_bug_bad_memory_access.xml",
+                        "test_bug_bad_memory_access.xml", "bug_bad_memory_access.db",
+                        "bug_bad_memory_access", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug bad memory access: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug bad memory access: PASSED\n");
+        }
+
+        // Bug Bad Memory Access with backtracking
+        fprintf(stderr, "Testing bug bad memory access with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_bad_memory_access.xml",
+                        "test_bt_bug_bad_memory_access.xml", "bug_bad_memory_access.db",
+                        "bug_bad_memory_access", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug bad memory access with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug bad memory access with backtracking: PASSED\n");
+        }
+
+        // Bug Assertion Failure
+        fprintf(stderr, "Testing bug assertion failure...\n");
+        if (NO == runTest("ref_bug_assertion_failure.xml",
+                        "test_bug_assertion_failure.xml", "bug_assertion_failure.db",
+                        "bug_assertion_failure", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug assertion failure: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug assertion failure: PASSED\n");
+        }
+
+        // Bug Assertion Failure with backtracking
+        fprintf(stderr, "Testing bug assertion failure with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_assertion_failure.xml",
+                        "test_bt_bug_assertion_failure.xml", "bug_assertion_failure.db",
+                        "bug_assertion_failure", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug assertion failure with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug assertion failure with backtracking: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop no depth
+        fprintf(stderr, "Testing bug division by zero loop no depth...\n");
+        if (NO == runTest("ref_bug_division_by_zero_nodepth.xml",
+                        "test_bug_division_by_zero_nodepth.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with no depth: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with no depth: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop no depth with backtracking
+        fprintf(stderr, "Testing bug division by zero loop no depth with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_division_by_zero_nodepth.xml",
+                        "test_bt_bug_division_by_zero_nodepth.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with no depth with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with no depth with backtracking: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop depth 1
+        fprintf(stderr, "Testing bug division by zero loop depth 1...\n");
+        if (NO == runTest("ref_bug_division_by_zero_depth_1.xml",
+                        "test_bug_division_by_zero_depth_1.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrDepthOne)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with depth 1: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with depth 1: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop depth 1 with backtracking
+        fprintf(stderr, "Testing bug division by zero loop depth 1 with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_division_by_zero_depth_1.xml",
+                        "test_bt_bug_division_by_zero_depth_1.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrDepthOneReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with depth 1 with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with depth 1 with backtracking: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop depth 1000
+        fprintf(stderr, "Testing bug division by zero loop depth 1000...\n");
+        if (NO == runTest("ref_bug_division_by_zero_depth_1.xml",
+                        "test_bug_division_by_zero_depth_1000.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrDepthThousand)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with depth 1000: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with depth 1000: PASSED\n");
+        }
+
+        // Bug Bad Food
+        fprintf(stderr, "Testing bug bad food...\n");
+        if (NO == runTest("ref_bug_bad_food.xml",
+                        "test_bug_bad_food.xml", "bug_bad_food.db",
+                        "bug_bad_food", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug bad food: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug bad food: PASSED\n");
+        }
+
+        return ret;
+}
diff --git a/pathologist/src/pathologist/xml_writer.c b/pathologist/src/pathologist/xml_writer.c
new file mode 100644
index 0000000..64775a4
--- /dev/null
+++ b/pathologist/src/pathologist/xml_writer.c
@@ -0,0 +1,126 @@
+/**
+ * @file monkey/xml_writer.c
+ * @brief Monkey API for generating XML debug report
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "monkey_common.h"
+#include "pathologist_xml_writer.h"
+
+
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_new_node(const char *name, const char *innerText) {
+        struct MONKEY_XML_Node *node = MONKEY_malloc(sizeof(struct MONKEY_XML_Node));
+        node->name = name;
+        node->innerText = innerText;
+        node->childrenListHead = NULL;
+        node->childrenListTail = NULL;
+        node->attributeListHead = NULL;
+        node->attributeListTail = NULL;
+        return node;
+}
+
+
+int MONKEY_XML_WRITER_add_attribute(struct MONKEY_XML_Node* node, const char *attrName, const char *attrValue)
+{
+        struct XmlAttribute *attribute = MONKEY_malloc(sizeof(struct XmlAttribute));
+        attribute->name = attrName;
+        attribute->value  = attrValue;
+        attribute->next = NULL; attribute->prev = NULL;
+        MONKEY_CONTAINER_DLL_insert_tail (node->attributeListHead, node->attributeListTail,
+                                                         attribute);
+        return MONKEY_OK;
+}
+
+
+int MONKEY_XML_WRITER_add_inner_text(struct MONKEY_XML_Node *node, const char *innerText)
+{
+        node->innerText = innerText;
+        return MONKEY_OK;
+}
+
+
+int MONKEY_XML_WRITER_delete_tree(struct MONKEY_XML_Node *root)
+{
+        struct MONKEY_XML_Node *tmp = NULL;
+        struct XmlAttribute *tmpAttribute = NULL;
+
+        /* MONKEY_freeing children list - Depth First */
+        while (NULL != root->childrenListHead) {
+                tmp = root->childrenListHead;
+                root->childrenListHead = tmp->next;
+                MONKEY_XML_WRITER_delete_tree(tmp);
+        }
+
+        /* MONKEY_freeing Attributes List */
+        while (NULL != root->attributeListHead) {
+                tmpAttribute = root->attributeListHead;
+                root->attributeListHead = tmpAttribute->next;
+                MONKEY_free(tmpAttribute);
+        }
+
+        /* MONKEY_freeing Leaf Node */
+        MONKEY_free(root);
+
+        return MONKEY_OK;
+}
+
+
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_add_child(struct MONKEY_XML_Node *parent, struct MONKEY_XML_Node *child) {
+        child->next = NULL; child->prev = NULL;
+        MONKEY_CONTAINER_DLL_insert_tail (parent->childrenListHead, parent->childrenListTail,
+                                                 child);
+        return child;
+}
+
+
+FILE* MONKEY_XML_WRITER_create_document(const char *filePath) {
+        FILE* file = fopen(filePath, "w");
+        if (NULL != file) {
+                fprintf(file, "<?xml version=\"1.0\"?>\n");
+                return file;
+        }
+        return NULL;
+}
+
+static char* escapeSpecialCharacters(const char * s) {
+        char* escaped;
+        escaped = MONKEY_str_replace_all (s, "&", "&amp;"); // & (escaping amp character MUST be the first, otherwise, it will spoil the other escaped characters
+        escaped = MONKEY_str_replace_all (escaped, "\"", "&quot;"); // single quote
+        escaped = MONKEY_str_replace_all (escaped, "'", "&apos;"); // double quotes
+        escaped = MONKEY_str_replace_all (escaped, "<", "&lt;"); // less than
+        escaped = MONKEY_str_replace_all (escaped, ">", "&gt;");// greater than
+
+        return escaped;
+}
+
+int MONKEY_XML_WRITER_write_document(FILE* file, struct MONKEY_XML_Node *root) {
+        struct MONKEY_XML_Node *tmp = root->childrenListHead;
+        struct XmlAttribute *tmpAttribute = root->attributeListHead;
+        if (!tmpAttribute)
+                fprintf(file, "<%s>", root->name);
+        else {
+                fprintf(file, "<%s ", root->name);
+                while (NULL != tmpAttribute) {
+                        /* Escaping special characters in attribute values */
+                        fprintf(file, "%s=\"%s\" ", tmpAttribute->name,
+                                        (tmpAttribute->value) ? 
+                                        (escapeSpecialCharacters(tmpAttribute->value)) : "");
+                        tmpAttribute = tmpAttribute->next;
+                }
+                fprintf(file, ">");
+        }
+        if(tmp) fprintf(file, "\n");
+
+        if (NULL != root->innerText)
+                fprintf(file, "%s", escapeSpecialCharacters(root->innerText));
+
+        while (NULL != tmp) {
+                MONKEY_XML_WRITER_write_document(file, tmp);
+                tmp = tmp->next;
+        }
+        fprintf(file, "</%s>\n", root->name);//End
+        return MONKEY_OK;
+}
diff --git a/pathologist/src/struct_parse/exmpl.c b/pathologist/src/struct_parse/exmpl.c
new file mode 100644
index 0000000..00d3a6f
--- /dev/null
+++ b/pathologist/src/struct_parse/exmpl.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct a {
+        char c;
+        char c2;
+        char* s[2];
+        struct a* a;
+        char r[4];
+        int i[2];
+        float f;
+};
+
+int main(int argc, char* argv[]) {
+        struct a a;
+        struct a b;
+        a.c = '\'';
+        a.c2 = '"';
+        a.s[0] = "bliblablu\"";
+        a.s[1] = "trololo";
+        a.a = &b;
+        a.r[0] = '\n';
+        a.r[1] = 'a';
+        a.r[2] = '
';
+        a.r[3] = '"';
+        a.i[0] = -5;
+        a.i[1] = 42;
+        a.f = 3.141f;
+
+        return 0;
+}
diff --git a/pathologist/src/struct_parse/p.c b/pathologist/src/struct_parse/p.c
new file mode 100644
index 0000000..c99a654
--- /dev/null
+++ b/pathologist/src/struct_parse/p.c
@@ -0,0 +1,147 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char* parse(char* str, int indent);
+
+// parses one pair of curly braces recursively.
+// expects first char to be the opening '{'
+// returns pointer to the next char after the closing '}' or NULL on error
+char* parse(char* str, int indent) {
+        int is_struct = 0, is_array = 0, had_equals = 0, had_children = 0, had_end = 0;
+        char* first = NULL;
+        char* second = NULL;
+        char* ws = NULL;
+        char* count = NULL;
+
+        if(*str++ != '{') return NULL;
+        while(*str == ' ') str++;
+        if(!*str) return NULL;
+        while(*str) {
+                first = str;
+                second = NULL;
+                had_equals = 0;
+                had_children = 0;
+                had_end = 0;
+                count = NULL;
+                while(*str) {
+                        if(*str == '{') {
+                                if(     (is_struct && !had_equals) ||
+                                        (str != first && str != second) ) return NULL;
+                                if(str == second) {
+                                        printf("%*s<expression name=\"%s\">\n", 2*indent, "", first);
+                                        had_children = 1;
+                                }
+                                str = parse(str, indent+1);
+                                //continue; // have to check this char => no str++ at end of loop.
+                        } else if(*str == '=') {
+                                if(had_equals || is_array) return NULL;
+                                had_equals = 1;
+                                if(!is_struct && !is_array)
+                                        is_struct = 1;
+                                for(ws = str-1; *ws == ' '; ws--)
+                                        *ws = '\0';
+                                *str = '\0';
+                                while(*++str == ' ');
+                                second = str;
+                                continue; // have to check this char => no str++ at end of loop.
+                        } else if(*str == '\'' || *str == '"') {
+                                char end_char = *str;
+                                if(had_equals) second = str;
+                                else first = str;
+                                for(str++; *str != end_char; str++) {
+                                        if(!*str) return NULL;
+                                        if(*str == '\\') {
+                                                if(!*(str+1)) return NULL;
+                                                else str++;
+                                        }
+                                }
+                        } else if(*str == '<') {
+                                for(ws = str-1; *ws == ' '; ws--)
+                                        *ws = '\0';
+                                if(!(str = strpbrk(str+1, "0123456789>"))) return NULL;
+                                if(*str == '>') continue;
+                                count = str;
+                                if(!(str = strpbrk(str+1, " >"))) return NULL;
+                                if(*str == ' ')
+                                *str = '\0';
+                                else {
+                                        *str = '\0';
+                                        if(!(str = strchr(str+1, '>'))) return NULL;
+                                }
+                        } else if(*str == ',') {
+                                if(is_struct && !had_equals) return NULL;
+                                is_array = !is_struct;
+                                is_struct = !is_array;
+                                break;
+                        } else if(*str == '}') {
+                                had_end = 1;
+                                break;
+                        }
+                        str++;
+                }
+                for(ws = str-1; *ws == ' '; ws--)
+                        *ws = '\0';
+                *str = '\0';
+                if(had_children)
+                        printf("%*s</expression>\n", 2*indent, "");
+                else if(is_array)
+                        if(count)
+                                printf("%*s<element count=\"%s\">%s</element>\n", 2*indent, "", count, first);
+                        else
+                                printf("%*s<element>%s</element>\n", 2*indent, "", first);
+                else
+                        printf("%*s<expression name=\"%s\">%s</expression>\n", 2*indent, "", first, second);
+                if(had_end) return str;
+                str++;
+                while(*str == ' ') str++;
+        }
+        return NULL;
+}
+
+
+char * getl(void) {
+        char * line = malloc(128), * linep = line;
+        size_t lenmax = 128, len = lenmax;
+        int c;
+
+        if(line == NULL)
+                return NULL;
+
+        for(;;) {
+                c = fgetc(stdin);
+                if(c == EOF)
+                        break;
+
+                if(--len == 0) {
+                        len = lenmax;
+                        char * linen = realloc(linep, lenmax *= 2);
+
+                        if(linen == NULL) {
+                                free(linep);
+                                return NULL;
+                        }
+                        line = linen + (line - linep);
+                        linep = linen;
+                }
+
+                if((*line = c) == '\n')
+                        break;
+                line++;
+        }
+        *line = '\0';
+        return linep;
+}
+
+
+int main(int argc, char* argv[]) {
+        char* line;
+        while(line = getl()) {
+                if(*line == '\0') break;
+                if(!parse(line, 1))
+                        printf("=====FAILED!=====\n\n");
+                free(line);
+        }
+        if(line) free(line);
+        return 0;
+}
diff --git a/pathologist/src/struct_parse/test.sh b/pathologist/src/struct_parse/test.sh
new file mode 100644
index 0000000..2ab8cec
--- /dev/null
+++ b/pathologist/src/struct_parse/test.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+for n in `seq 1 1000`; do zzuf -r 0.00$n -s $n -i valgrind -q --leak-check=summary --track-origins=yes ./a.out < test.txt; done
diff --git a/pathologist/src/struct_parse/test.txt b/pathologist/src/struct_parse/test.txt
new file mode 100644
index 0000000..030fe36
--- /dev/null
+++ b/pathologist/src/struct_parse/test.txt
@@ -0,0 +1 @@
+{value = {publish = {pc = 0x607a20, fi = 0x60b580, cctx = 0x0, pctx = 0x0, filename = 0x60b9e0 "/home/grothoff/svn/gnunet/src/core/../../COPYING", size = 35147, eta = { rel_value = 18446744073709551615}, duration = {rel_value = 1360752708604}, completed = 0, anonymity = 1, specifics = {progress = {data = 0x0, offset = 0, data_len = 140737349529600, depth = 4158564850}, resume = {message = 0x0, chk_uri = 0x0}, completed = {chk_uri = 0x0}, error = {message = 0x0}}}, download = {dc = 0x607a20,   cctx = 0x60b580, pctx = 0x0, sctx = 0x0, uri = 0x60b9e0, filename = 0x894b <Address 0x894b out of bounds>, size = 18446744073709551615, eta = {rel_value = 1360752708604}, duration = {      rel_value = 0}, completed = 1, anonymity = 0, is_active = 0, specifics = {progress = {data = 0x0, offset = 140737349529600, data_len = 140737351952882, block_download_duration = {            rel_value = 140733193388033}, depth = 0, respect_offered = 0, num_transmissions = 6336704}, start = {meta = 0x0}, resume = {meta = 0x0,           message = 0x7ffff7b9b000 "\177ELF\002\001\001"}, error = {message = 0x0}}}, search = {sc = 0x607a20, cctx = 0x60b580, pctx = 0x0, query = 0x0, duration = {rel_value = 6339040},       anonymity = 35147, specifics = {result = {meta = 0xffffffffffffffff, uri = 0x13cd32e8bfc, result = 0x0, applicability_rank = 1}, resume_result = {meta = 0xffffffffffffffff,           uri = 0x13cd32e8bfc, result = 0x0, availability_rank = 1, availability_certainty = 0, applicability_rank = 0}, update = {cctx = 0xffffffffffffffff, meta = 0x13cd32e8bfc,           uri = 0x0, availability_rank = 1, availability_certainty = 0, applicability_rank = 0, current_probe_time = {rel_value = 0}}, result_suspend = {cctx = 0xffffffffffffffff,           meta = 0x13cd32e8bfc, uri = 0x0}, result_stopped = {cctx = 0xffffffffffffffff, meta = 0x13cd32e8bfc, uri = 0x0}, resume = {          message = 0xffffffffffffffff <Address 0xffffffffffffffff out of bounds>, is_paused = -751924228}, error = {          message = 0xffffffffffffffff <Address 0xffffffffffffffff out of bounds>}, ns = {ns = 0xffffffffffffffff, name = 0x13cd32e8bfc <Address 0x13cd32e8bfc out of bounds>, root = 0x0,           meta = 0x1, id = {bits = {0, 0, 0, 0, 4156141568, 32767, 4158564850, 32767, 1, 32767, 0, 0, 6336704, 0, 4156149880, 32767}}}}}, unindex = {uc = 0x607a20, cctx = 0x60b580,       filename = 0x0, size = 0, eta = {rel_value = 6339040}, duration = {rel_value = 35147}, completed = 18446744073709551615, specifics = {progress = {data = 0x13cd32e8bfc, offset = 0,           data_len = 1, depth = 0}, resume = {message = 0x13cd32e8bfc <Address 0x13cd32e8bfc out of bounds>}, error = {message = 0x13cd32e8bfc <Address 0x13cd32e8bfc out of bounds>}}}},   status = GNUNET_FS_STATUS_PUBLISH_START}
diff --git a/pathologist/src/struct_parse/test1.txt b/pathologist/src/struct_parse/test1.txt
new file mode 100644
index 0000000..9ddec90
--- /dev/null
+++ b/pathologist/src/struct_parse/test1.txt
@@ -0,0 +1 @@
+{0 <repeats 9274 times>, -136430974, 32767, 0 <repeats 18 times>, 1560576, 0, 1560100, 0, 1560100, 0, 0, 0, 5, 0, 3657728, 0, 3678208, 0, 3677624, 0, 3696728, 0, 1560576, 0, 3, 0 <repeats 47 times>, -136436024, 32767, 0, 0, 0, 0, 0, 0, -134241024, 32767, 47, 0, -136413867, 32767, 0, 0, -134239856, 32767, 32, 0, 0, 1, -134241104, 32767, 0, 0, -8304, 32767, -136414759, 32767, -134225464, 32767, -134240992, 32767, -8304, 32767, -136431348, 32767, 1811964521, 778265193, 909012851, 1932419840, 3550831, 3550831, -136398771, 32767, 0, 0,  -140067357, 32767, 0, 0, -136427454, 32767, -136478720, 32767, -136460200, 32767, -136479304, 32767, 0, 0, -8656, 32767, -134241024, 32767, 4195056, 0, -134225504, 32767, 3, 1, -8136, 0, 6, 0, 3696728, 0, 2053, 0, 1324524, 0, 1, 0, 33261, 0, 0, 0, 0, 0, 1583120, 0, 4096, 0, 3104, 0, 1349347463, 0, 0, 0, 1342975530, 0, 0, 0, 1349347464, 0 <repeats 11 times>, 4195056, 0, -134225464, 32767, -134229952, 32767, 0, 0, -134224528, 32767, 0, 0, -136427174, 32767, 0, 32767, -7304, 32767, 0, 0, 0, 0, 0, 0, -134261768, 32767, 0, 0, 7, 0, 0, 1...}
diff --git a/pathologist/src/struct_parse/test2.txt b/pathologist/src/struct_parse/test2.txt
new file mode 100644
index 0000000..e89ac3a
--- /dev/null
+++ b/pathologist/src/struct_parse/test2.txt
@@ -0,0 +1 @@
+{"buil\"e" , '" ueuil \"\'', "\\\\", 0 ,1560576,0,  1560100,0  , 1560100}
diff --git a/pathologist/src/struct_parse/test3.txt b/pathologist/src/struct_parse/test3.txt
new file mode 100644
index 0000000..39bbf8c
--- /dev/null
+++ b/pathologist/src/struct_parse/test3.txt
@@ -0,0 +1 @@
+{data  =  0x0,offset=0,  data_len=  140737349529600  ,depth  =4158564850  }
diff --git a/pathologist/src/struct_parse/test4.txt b/pathologist/src/struct_parse/test4.txt
new file mode 100644
index 0000000..3735a52
--- /dev/null
+++ b/pathologist/src/struct_parse/test4.txt
@@ -0,0 +1 @@
+{0 <repeats 9274 times>, -136430974, 32767, 0 <repeats 18 times>, 1560576, 0,1560100, 0, 1560100, 0, 0}
diff --git a/pathologist/src/util/Makefile.am b/pathologist/src/util/Makefile.am
new file mode 100644
index 0000000..6961228
--- /dev/null
+++ b/pathologist/src/util/Makefile.am
@@ -0,0 +1,12 @@
+INCLUDES = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = libpathologistutil.la
+
+libpathologistutil_la_SOURCES = \
+  common_allocation.c \
+  str_replace_all.c
\ No newline at end of file
diff --git a/pathologist/src/util/common_allocation.c b/pathologist/src/util/common_allocation.c
new file mode 100644
index 0000000..2eef7d5
--- /dev/null
+++ b/pathologist/src/util/common_allocation.c
@@ -0,0 +1,338 @@
+/*
+     This file is part of MONKEY.
+     (C) 2001, 2002, 2003, 2005, 2006 Christian Grothoff (and other contributing authors)
+
+     MONKEY 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.
+
+     MONKEY 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 MONKEY; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file util/common_allocation.c
+ * @brief wrapper around malloc/free
+ * @author Christian Grothoff
+ * @author Safey A.Halim
+ */
+
+#include "monkey_common.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#ifndef INT_MAX
+#define INT_MAX 0x7FFFFFFF
+#endif
+
+#if 0
+#define W32_MEM_LIMIT 200000000
+#endif
+
+#ifdef W32_MEM_LIMIT
+static LONG mem_used = 0;
+#endif
+
+/**
+ * Allocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ *
+ * @param size how many bytes of memory to allocate, do NOT use
+ *  this function (or MONKEY_malloc) to allocate more than several MB
+ *  of memory, if you are possibly needing a very large chunk use
+ *  MONKEY_xmalloc_unchecked_ instead.
+ * @param filename where in the code was the call to MONKEY_malloc
+ * @param linenumber where in the code was the call to MONKEY_malloc
+ * @return pointer to size bytes of memory
+ */
+void *
+MONKEY_xmalloc_ (size_t size, const char *filename, int linenumber)
+{
+  void *ret;
+
+  /* As a security precaution, we generally do not allow very large
+   * allocations using the default 'MONKEY_malloc' macro */
+  MONKEY_assert_at (size <= MONKEY_MAX_MALLOC_CHECKED, filename, linenumber);
+  ret = MONKEY_xmalloc_unchecked_ (size, filename, linenumber);
+  if (ret == NULL)
+  {
+    fprintf (stderr, "malloc");
+    abort ();
+  }
+  return ret;
+}
+
+
+/**
+ * Allocate and initialize memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use MONKEY_xmemdup_ directly. Use the
+ * MONKEY_memdup macro.
+ *
+ * @param buf buffer to initialize from (must contain size bytes)
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *
+MONKEY_xmemdup_ (const void *buf, size_t size, const char *filename,
+                 int linenumber)
+{
+  void *ret;
+
+  /* As a security precaution, we generally do not allow very large
+   * allocations here */
+  MONKEY_assert_at (size <= MONKEY_MAX_MALLOC_CHECKED, filename, linenumber);
+#ifdef W32_MEM_LIMIT
+  size += sizeof (size_t);
+  if (mem_used + size > W32_MEM_LIMIT)
+    return NULL;
+#endif
+  MONKEY_assert_at (size < INT_MAX, filename, linenumber);
+  ret = malloc (size);
+  if (ret == NULL)
+  {
+    fprintf (stderr, "malloc");
+    abort ();
+  }
+#ifdef W32_MEM_LIMIT
+  *((size_t *) ret) = size;
+  ret = &((size_t *) ret)[1];
+  mem_used += size;
+#endif
+  memcpy (ret, buf, size);
+  return ret;
+}
+
+
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate
+ * @param filename where in the code was the call to MONKEY_malloc_large
+ * @param linenumber where in the code was the call to MONKEY_malloc_large
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
+void *
+MONKEY_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
+{
+  void *result;
+
+#ifdef W32_MEM_LIMIT
+  size += sizeof (size_t);
+  if (mem_used + size > W32_MEM_LIMIT)
+    return NULL;
+#endif
+
+  MONKEY_assert_at (size < INT_MAX, filename, linenumber);
+  result = malloc (size);
+  if (result == NULL)
+    return NULL;
+  memset (result, 0, size);
+
+#ifdef W32_MEM_LIMIT
+  *((size_t *) result) = size;
+  result = &((size_t *) result)[1];
+  mem_used += size;
+#endif
+
+  return result;
+}
+
+
+/**
+ * Reallocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ *
+ * @param ptr the pointer to reallocate
+ * @param n how many bytes of memory to allocate
+ * @param filename where in the code was the call to MONKEY_realloc
+ * @param linenumber where in the code was the call to MONKEY_realloc
+ * @return pointer to size bytes of memory
+ */
+void *
+MONKEY_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
+{
+#ifdef W32_MEM_LIMIT
+  n += sizeof (size_t);
+  ptr = &((size_t *) ptr)[-1];
+  mem_used = mem_used - *((size_t *) ptr) + n;
+#endif
+  ptr = realloc (ptr, n);
+  if ((NULL == ptr) && (n > 0))
+  {
+    fprintf (stderr, "realloc");
+    abort ();
+  }
+#ifdef W32_MEM_LIMIT
+  ptr = &((size_t *) ptr)[1];
+#endif
+  return ptr;
+}
+
+
+/**
+ * Free memory. Merely a wrapper for the case that we
+ * want to keep track of allocations.
+ *
+ * @param ptr the pointer to free
+ * @param filename where in the code was the call to MONKEY_array_grow
+ * @param linenumber where in the code was the call to MONKEY_array_grow
+ */
+void
+MONKEY_xfree_ (void *ptr, const char *filename, int linenumber)
+{
+  MONKEY_assert_at (ptr != NULL, filename, linenumber);
+#ifdef W32_MEM_LIMIT
+  ptr = &((size_t *) ptr)[-1];
+  mem_used -= *((size_t *) ptr);
+#endif
+  free (ptr);
+}
+
+/**
+ * Dup a string (same semantics as strdup).
+ *
+ * @param str the string to dup
+ * @param filename where in the code was the call to MONKEY_strdup
+ * @param linenumber where in the code was the call to MONKEY_strdup
+ * @return strdup(str)
+ */
+char *
+MONKEY_xstrdup_ (const char *str, const char *filename, int linenumber)
+{
+  char *res;
+
+  MONKEY_assert_at (str != NULL, filename, linenumber);
+  res = MONKEY_xmalloc_ (strlen (str) + 1, filename, linenumber);
+  memcpy (res, str, strlen (str) + 1);
+  return res;
+}
+
+
+/**
+ * Dup partially a string (same semantics as strndup).
+ *
+ * @param str the string to dup
+ * @param len the length of the string to dup
+ * @param filename where in the code was the call to MONKEY_strndup
+ * @param linenumber where in the code was the call to MONKEY_strndup
+ * @return strndup(str,len)
+ */
+char *
+MONKEY_xstrndup_ (const char *str, size_t len, const char *filename,
+                  int linenumber)
+{
+  char *res;
+
+  MONKEY_assert_at (str != NULL, filename, linenumber);
+  len = MONKEY_MIN (len, strlen (str));
+  res = MONKEY_xmalloc_ (len + 1, filename, linenumber);
+  memcpy (res, str, len);
+  res[len] = '\0';
+  return res;
+}
+
+
+/**
+ * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
+ * and sets *oldCount to newCount.
+ *
+ * @param old address of the pointer to the array
+ *        *old may be NULL
+ * @param elementSize the size of the elements of the array
+ * @param oldCount address of the number of elements in the *old array
+ * @param newCount number of elements in the new array, may be 0
+ * @param filename where in the code was the call to MONKEY_array_grow
+ * @param linenumber where in the code was the call to MONKEY_array_grow
+ */
+void
+MONKEY_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
+               unsigned int newCount, const char *filename, int linenumber)
+{
+  void *tmp;
+  size_t size;
+
+  MONKEY_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
+  size = newCount * elementSize;
+  if (size == 0)
+  {
+    tmp = NULL;
+  }
+  else
+  {
+    tmp = MONKEY_xmalloc_ (size, filename, linenumber);
+    memset (tmp, 0, size);      /* client code should not rely on this, though... */
+    if (*oldCount > newCount)
+      *oldCount = newCount;     /* shrink is also allowed! */
+    memcpy (tmp, *old, elementSize * (*oldCount));
+  }
+
+  if (*old != NULL)
+  {
+    MONKEY_xfree_ (*old, filename, linenumber);
+  }
+  *old = tmp;
+  *oldCount = newCount;
+}
+
+
+/**
+ * Like asprintf, just portable.
+ *
+ * @param buf set to a buffer of sufficient size (allocated, caller must free)
+ * @param format format string (see printf, fprintf, etc.)
+ * @param ... data for format string
+ * @return number of bytes in "*buf" excluding 0-termination
+ */
+int
+MONKEY_asprintf (char **buf, const char *format, ...)
+{
+  int ret;
+  va_list args;
+
+  va_start (args, format);
+  ret = vsnprintf (NULL, 0, format, args);
+  va_end (args);
+  *buf = MONKEY_malloc (ret + 1);
+  va_start (args, format);
+  ret = vsprintf (*buf, format, args);
+  va_end (args);
+  return ret;
+}
+
+
+/**
+ * Like snprintf, just aborts if the buffer is of insufficient size.
+ *
+ * @param buf pointer to buffer that is written to
+ * @param size number of bytes in buf
+ * @param format format strings
+ * @param ... data for format string
+ * @return number of bytes written to buf or negative value on error
+ */
+int
+MONKEY_snprintf (char *buf, size_t size, const char *format, ...)
+{
+  int ret;
+  va_list args;
+
+  va_start (args, format);
+  ret = vsnprintf (buf, size, format, args);
+  va_end (args);
+  MONKEY_assert (ret <= size);
+  return ret;
+}
+
+/* end of common_allocation.c */
diff --git a/pathologist/src/util/str_replace_all.c b/pathologist/src/util/str_replace_all.c
new file mode 100644
index 0000000..a167523
--- /dev/null
+++ b/pathologist/src/util/str_replace_all.c
@@ -0,0 +1,56 @@
+/**
+ * vim: tabstop=2:shiftwidth=2:softtabstop=2:expandtab
+ *
+ * str_replace.c implements a str_replace PHP like function
+ * Copyright (C) 2010  chantra <chantra__A__debuntu__D__org>
+ *
+ * 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.
+ *
+ * gcc -o str_replace_all str_replace_all.c
+ */
+
+#include <string.h>
+#include "monkey_common.h"
+
+char *
+MONKEY_str_replace_all ( const char *string, const char *substr, const char *replacement ){
+  char *tok = NULL;
+  char *newstr = NULL;
+  char *oldstr = NULL;
+  char *head = NULL;
+
+  /* if either substr or replacement is NULL, duplicate string a let caller handle it */
+  if ( substr == NULL || replacement == NULL ) return MONKEY_strdup (string);
+  newstr = MONKEY_strdup (string);
+  head = newstr;
+  while ( (tok = strstr ( head, substr ))){
+    oldstr = newstr;
+    newstr = MONKEY_malloc ( strlen ( oldstr ) - strlen ( substr ) + strlen ( replacement ) + 1 );
+    /*failed to alloc mem, free old string and return NULL */
+    if ( newstr == NULL ){
+      MONKEY_free (oldstr);
+      return NULL;
+    }
+    memcpy ( newstr, oldstr, tok - oldstr );
+    memcpy ( newstr + (tok - oldstr), replacement, strlen ( replacement ) );
+    memcpy ( newstr + (tok - oldstr) + strlen( replacement ), tok + strlen ( substr ), strlen ( oldstr ) - strlen ( substr ) - ( tok - oldstr ) );
+    memset ( newstr + strlen ( oldstr ) - strlen ( substr ) + strlen ( replacement ) , 0, 1 );
+    /* move back head right after the last replacement */
+    head = newstr + (tok - oldstr) + strlen( replacement );
+    MONKEY_free (oldstr);
+  }
+  return newstr;
+}
+
diff --git a/seaspider/Makefile b/seaspider/Makefile
new file mode 100755
index 0000000..edd4681
--- /dev/null
+++ b/seaspider/Makefile
@@ -0,0 +1,3 @@
+install: seasp2_convert seasp2
+        install -t /usr/local/bin seasp2 seasp2_convert
+
diff --git a/seaspider/ignorefile.example b/seaspider/ignorefile.example
new file mode 100644
index 0000000..dad99d5
--- /dev/null
+++ b/seaspider/ignorefile.example
@@ -0,0 +1,14 @@
+# lines starting with a # are comments
+# other lines have to be in the format:
+# ^(filename)?:(functionname)?:pattern$
+# if filename or functionname is empty it matches any file / function.
+# leading and trailing whitespace will be ignored.
+
+# ignore every expression containing 'user_privatekey'
+::user_privatekey
+
+# ignore the local variable 'salt' in function 'encrypt_msg'
+:encrypt_msg:salt
+
+# ignore the variable 'mailto' in file libmail.c
+libmail.c::mailto
diff --git a/seaspider/remove_inc b/seaspider/remove_inc
new file mode 100755
index 0000000..9c55d7a
--- /dev/null
+++ b/seaspider/remove_inc
@@ -0,0 +1,30 @@
+#! /usr/bin/env python
+
+def escaped(part):
+    if part.endswith('\\'):
+        if part.endswith("\\\\"):
+            return escaped(part[:-2])
+        else:
+            return True
+    else:
+        return False
+
+def remove_increment_decrement(expr):
+    old = expr.split('"')
+    print old
+    new = [old[0]]
+    for i in range(1, len(old)):
+        if escaped(old[i-1]):
+            new[-1] += '"' + old[i]
+        else:
+            new.append(old[i])
+    for i in range(len(new)/2):
+        new[2*i] = new[2*i].replace("++", "").replace("--", "")
+    print new
+    print expr
+    print '"'.join(new)
+
+
+
+
+remove_increment_decrement('a = "--1\\"2++" + "3++ --4\\\\" + "5--\\\\\\"++6"troll')
diff --git a/seaspider/seasp2 b/seaspider/seasp2
new file mode 100755
index 0000000..ebaec86
--- /dev/null
+++ b/seaspider/seasp2
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+echo "BEWARE! This is an unfinished and unstable script. use with care!"
+echo "Will start in 5..."
+sleep 1s
+echo "Will start in 4..."
+sleep 1s
+echo "Will start in 3..."
+sleep 1s
+echo "Will start in 2..."
+sleep 1s
+echo "Will start in 1..."
+sleep 1s
+
+export CC="/usr/local/bin/cparser"
+export CFLAGS="--seaspider -m32"
+./configure
+make clean
+make $1
+seasp2_convert -o expressions.sqlite
+rm -f `find * -name "*.sea"`
diff --git a/seaspider/seasp2_convert b/seaspider/seasp2_convert
new file mode 100755
index 0000000..fa4d3a0
--- /dev/null
+++ b/seaspider/seasp2_convert
@@ -0,0 +1,233 @@
+#! /usr/bin/env python
+
+import sqlite3
+import argparse
+import os
+import re
+from collections import deque
+
+
+def parseIgnores(ignfile):
+    if not ignfile:
+        return []
+
+    ignlist = []
+    ignexp = []
+    lineno = 0
+
+    lines = ignfile.readlines(100)
+    while lines:
+        for line in lines:
+            lineno += 1
+            line = line.strip()
+            if line == '' or line.startswith('#'):
+                continue
+            m = re.match(r'^([^:]*):([^:]*):(.+)$', line)
+            if not m or m.lastindex < 3:
+                print 'unknown ignore pattern on line %s: %s' % (lineno, line)
+                continue
+#            ign_file = m.group(1)
+#            ign_func = m.group(2)
+#            ign_pattern = m.group(3)
+#            ignlist.append((ign_file, ign_func, ign_pattern))
+            ignexp.append((re.compile(m.group(1)),
+                           re.compile(m.group(2)),
+                           re.compile(m.group(3))))
+
+        lines = ignfile.readlines(100)
+    ignfile.close()
+    return ignexp
+
+# argparse Action for a readable dir
+class readable_dir(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        prospective_dir=values
+        if not os.path.exists(prospective_dir):
+            raise argparse.ArgumentTypeError("readable_dir:{0} is not a valid path".format(prospective_dir))
+        if os.access(prospective_dir, os.R_OK):
+            setattr(namespace, self.dest, prospective_dir)
+        else:
+            raise argparse.ArgumentTypeError("readable_dir:{0} is not a readable dir".format(prospective_dir))
+
+
+# initialize argument parser
+parser = argparse.ArgumentParser(description="converts .sea files generated by cparser to a seaspider sqlite database")
+
+parser.add_argument('--version', action='version', version='db_convert 1.0')
+parser.add_argument("-o", "--output", metavar="FILENAME",
+                    type=argparse.FileType('w'), dest="outfile",
+                    help="filename for the resulting sqlite database."
+                    + " defaults to INPUT.sqlite")
+parser.add_argument("-i", "--ignore", metavar="FILENAME",
+                    type=argparse.FileType('r'), dest="ignorefile",
+                    help="filename for the ignores.")
+parser.add_argument('INPUT', nargs='?', action=readable_dir,
+                    default=os.getcwd(),
+                    help='input file or directory which is traversed'
+                    + ' recursively. defaults to PWD')
+args = parser.parse_args()
+
+# parse ignores
+ignores = parseIgnores(args.ignorefile) or []
+
+# build output filename
+if args.outfile== None:
+    if os.path.isdir(args.INPUT):
+        in_dir = os.path.abspath(args.INPUT)
+        tmp_name = os.path.split(in_dir)[1]
+        outfilename = in_dir + '/' + tmp_name + '.sqlite'
+    elif os.path.isfile(args.INPUT):
+        outfilename = os.path.splitext(args.INPUT)[0] + '.sqlite'
+    else:
+        print 'unknown output target, writing to expressions.sqlite'
+        outfilename = 'expressions.sqlite'
+else:
+    outfilename = args.outfile.name
+    args.outfile.close()
+
+# remove old db
+try:
+    os.remove(outfilename)
+except OSError:
+    pass
+
+# connect to db
+sql_conn = sqlite3.connect(outfilename)
+sql_conn.text_factory = str
+sql_cur = sql_conn.cursor()
+
+# create table
+sql_cur.execute('''CREATE TABLE Expression (
+                expr_ID INTEGER PRIMARY KEY AUTOINCREMENT,
+                file_name TEXT NOT NULL,
+                expr_syntax TEXT,
+                start_lineno INT,
+                end_lineno INT,
+                is_call INT,
+                UNIQUE (file_name, expr_syntax, start_lineno, end_lineno))''')
+
+
+# adds an Expression to the db
+def add_expr(cur, ignores, func_name,
+             file_name, expr_syntax, start_lineno, end_lineno, is_call):
+    for i in ignores:
+        if (i[0].search(file_name) and
+            i[1].search(func_name) and
+            i[2].search(expr_syntax)):
+            return
+    vals = (file_name, expr_syntax, start_lineno, end_lineno, is_call)
+    cur.execute('INSERT OR IGNORE INTO Expression VALUES (NULL,?,?,?,?,?)', vals)
+
+
+# parses one .sea file
+def parse_sea_file(filename):
+    scope_end = []
+    scope_end.append(32767)
+    parameters = deque()
+    expr_list = []
+    prevtype = ""
+    seafile_lineno = 0
+    func_name = (32767, '')
+
+    try:
+        infile = open(filename, 'r')
+        print 'reading file: ',filename
+    except IOError:
+        print 'could not read file: ',filename
+        infile.close()
+        return
+    cfilename = os.path.split(os.path.splitext(filename)[0])[1] + '.c'
+
+    local_ignores = [ign for ign in ignores if ign[0].search(cfilename)]
+
+    lines = infile.readlines(10000)
+    while lines:
+        for line in lines:
+            seafile_lineno += 1
+            if prevtype == 'Begin-Expression':
+                if re.match(re.escape("End-Expression: " + rowfile + ':' + str(lineno) + ' ' + str(iscall)), line):
+                    add_expr(sql_cur, local_ignores, func_name[1],
+                             rowfile, ' '.join(expr_list), lineno, scope_end[-1], iscall)
+                    prevtype = 'End-Expression'
+                expr_list.append(line.strip())
+                continue
+
+            m = re.match(r'([A-Za-z-]+): ([^:]+):(\d+) (.+)', line)
+            if not m or m.lastindex < 4:
+                print 'unknown entry type: ', filename, ' on line ', seafile_lineno
+                prevtype = ''
+                continue
+            rowtype = m.group(1)
+            rowfile = m.group(2)
+
+            if rowtype == 'SystemGlobal':
+                globalvar = m.group(4)
+                add_expr(sql_cur, ignores, func_name[1],
+                         cfilename, globalvar, 0, 32767, 0)
+            elif rowtype == 'Global':
+                lineno = int(m.group(3))
+                globalvar = m.group(4)
+                add_expr(sql_cur, ignores, func_name[1],
+                         rowfile, globalvar, lineno, 32767, 0)
+            elif rowtype == 'Function':
+                funame = m.group(4)
+            elif rowtype == 'Parameter':
+                if prevtype != 'Function' and prevtype != 'Parameter':
+                    print 'Parameter can only follow Function or another Parameter: ', filename, ' on line ', seafile_lineno
+                lineno = int(m.group(3))
+                para = m.group(4)
+                parameters.append((rowfile, para, lineno))
+            elif rowtype == 'Scope':
+                scope_begin = int(m.group(3))
+                scope_end.append(int(m.group(4)) + 1)
+                if prevtype == 'Parameter' or prevtype == 'Function':
+                    func_name = (scope_end[-1], funame)
+                while prevtype == 'Parameter':
+                    try:
+                        (rowfile, para, lineno) = parameters.popleft()
+                    except IndexError:
+                        break
+                    add_expr(sql_cur, local_ignores, func_name[1],
+                             rowfile, para, lineno, scope_end[-1], 0)
+            elif rowtype == 'Begin-Expression':
+                lineno = int(m.group(3))
+                iscall = int(m.group(4)[0])
+                if lineno > scope_end[-1]:
+                    scope_end.pop()
+                    if lineno > func_name[0]:
+                        func_name = (32767, '')
+                del expr_list[:]
+                tmp = (m.group(4)[1:]).strip()
+                if len(tmp) > 0: expr_list.append(tmp)
+            else:
+                print 'unknown entry type: ', filename, ' on line ', seafile_lineno
+            prevtype = rowtype
+        sql_conn.commit()
+        lines = infile.readlines(10000)
+    infile.close()
+
+
+# traverses all .sea files in the input folder
+def traverse_sea_files(dummy, dirr, filess):
+    for child in filess:
+        if '.sea' == os.path.splitext(child)[1] and os.path.isfile(dirr+'/'+child):
+            parse_sea_file(dirr+'/'+child)
+
+
+
+# parse it
+if os.path.isdir(args.INPUT):
+    os.path.walk(os.path.abspath(args.INPUT), traverse_sea_files, 0)
+elif os.path.isfile(args.INPUT):
+    parse_sea_file(args.INPUT)
+else:
+    print 'unknown INPUT, no rows written to ',outfilename
+
+# commit changes
+sql_conn.commit()
+
+# close db
+sql_conn.close()
+
+
+