diff --git a/catalog.c b/catalog.c
index 21270d4..2ea69db 100644
--- a/catalog.c
+++ b/catalog.c
@@ -46,6 +46,8 @@
             __FILE__, __LINE__);
 
 #define XML_URN_PUBID "urn:publicid:"
+#define XML_CATAL_BREAK ((xmlChar *) -1)
+#define XML_DEFAULT_CATALOG "/etc/xml/catalog"
 
 /************************************************************************
  *									*
@@ -54,11 +56,6 @@
  ************************************************************************/
 
 typedef enum {
-    XML_CATA_PREFER_PUBLIC = 1,
-    XML_CATA_PREFER_SYSTEM
-} xmlCatalogPrefer;
-
-typedef enum {
     XML_CATA_NONE = 0,
     XML_CATA_CATALOG,
     XML_CATA_NEXT_CATALOG,
@@ -93,11 +90,14 @@
     xmlCatalogEntryType type;
     xmlChar *name;
     xmlChar *value;
-    /* TODO : 1234 xmlCatalogPrefer prefer */
+    xmlCatalogPrefer prefer;
 };
 
 static xmlHashTablePtr xmlDefaultCatalog;
 static xmlCatalogEntryPtr xmlDefaultXMLCatalogList = NULL;
+static int xmlCatalogInitialized = 0;
+static xmlCatalogPrefer xmlCatalogDefaultPrefer = XML_CATA_PREFER_SYSTEM;
+
 
 /* Catalog stack */
 static const char * catalTab[10];  /* stack of catals */
@@ -114,7 +114,7 @@
 
 static xmlCatalogEntryPtr
 xmlNewCatalogEntry(xmlCatalogEntryType type, const xmlChar *name,
-	           const xmlChar *value) {
+	           const xmlChar *value, xmlCatalogPrefer prefer) {
     xmlCatalogEntryPtr ret;
 
     ret = (xmlCatalogEntryPtr) xmlMalloc(sizeof(xmlCatalogEntry));
@@ -135,6 +135,7 @@
 	ret->value = xmlStrdup(value);
     else
 	ret->value = NULL;
+    ret->prefer = prefer;
     return(ret);
 }
 
@@ -240,6 +241,77 @@
 
 /************************************************************************
  *									*
+ *			Helper function					*
+ *									*
+ ************************************************************************/
+
+/**
+ * xmlCatalogUnWrapURN:
+ * @urn:  an "urn:publicid:" to unwrapp
+ *
+ * Expand the URN into the equivalent Public Identifier
+ *
+ * Returns the new identifier or NULL, the string must be deallocated
+ *         by the caller.
+ */
+static xmlChar *
+xmlCatalogUnWrapURN(const xmlChar *urn) {
+    xmlChar result[2000];
+    unsigned int i = 0;
+
+    if (xmlStrncmp(urn, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1))
+	return(NULL);
+    urn += sizeof(XML_URN_PUBID) - 1;
+    
+    while (*urn != 0) {
+	if (i > sizeof(result) - 3)
+	    break;
+	if (*urn == '+') {
+	    result[i++] = ' ';
+	    urn++;
+	} else if (*urn == ':') {
+	    result[i++] = '/';
+	    result[i++] = '/';
+	    urn++;
+	} else if (*urn == ';') {
+	    result[i++] = ':';
+	    result[i++] = ':';
+	    urn++;
+	} else if (*urn == '%') {
+	    if ((urn[1] == '2') && (urn[1] == 'B'))
+		result[i++] = '+';
+	    else if ((urn[1] == '3') && (urn[1] == 'A'))
+		result[i++] = ':';
+	    else if ((urn[1] == '2') && (urn[1] == 'F'))
+		result[i++] = '/';
+	    else if ((urn[1] == '3') && (urn[1] == 'B'))
+		result[i++] = ';';
+	    else if ((urn[1] == '2') && (urn[1] == '7'))
+		result[i++] = '\'';
+	    else if ((urn[1] == '3') && (urn[1] == 'F'))
+		result[i++] = '?';
+	    else if ((urn[1] == '2') && (urn[1] == '3'))
+		result[i++] = '#';
+	    else if ((urn[1] == '2') && (urn[1] == '5'))
+		result[i++] = '%';
+	    else {
+		result[i++] = *urn;
+		urn++;
+		continue;
+	    }
+	    urn += 3;
+	} else {
+	    result[i++] = *urn;
+	    urn++;
+	}
+    }
+    result[i] = 0;
+
+    return(xmlStrdup(result));
+}
+
+/************************************************************************
+ *									*
  *			The XML Catalog parser				*
  *									*
  ************************************************************************/
@@ -286,7 +358,7 @@
 static xmlCatalogEntryPtr
 xmlParseXMLCatalogOneNode(xmlNodePtr cur, xmlCatalogEntryType type,
 			  const xmlChar *name, const xmlChar *attrName,
-			  const xmlChar *uriAttrName) {
+			  const xmlChar *uriAttrName, xmlCatalogPrefer prefer) {
     int ok = 1;
     xmlChar *uriValue;
     xmlChar *nameValue = NULL;
@@ -319,13 +391,15 @@
     base = xmlNodeGetBase(cur->doc, cur);
     URL = xmlBuildURI(uriValue, base);
     if (URL != NULL) {
-	if (xmlDebugCatalogs) {
+	if (xmlDebugCatalogs > 1) {
 	    if (nameValue != NULL)
-		printf("Found %s: '%s' '%s'\n", name, nameValue, URL);
+		xmlGenericError(xmlGenericErrorContext,
+			"Found %s: '%s' '%s'\n", name, nameValue, URL);
 	    else
-		printf("Found %s: '%s'\n", name, URL);
+		xmlGenericError(xmlGenericErrorContext,
+			"Found %s: '%s'\n", name, URL);
 	}
-	ret = xmlNewCatalogEntry(type, nameValue, URL);
+	ret = xmlNewCatalogEntry(type, nameValue, URL, prefer);
     } else {
 	xmlGenericError(xmlGenericErrorContext,
 		"%s entry '%s' broken ?: %s\n", name, uriAttrName, uriValue);
@@ -374,38 +448,38 @@
         xmlParseXMLCatalogNodeList(cur->children, prefer, parent);
     } else if (xmlStrEqual(cur->name, BAD_CAST "public")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_PUBLIC,
-		BAD_CAST "public", BAD_CAST "publicId", BAD_CAST "uri");
+		BAD_CAST "public", BAD_CAST "publicId", BAD_CAST "uri", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "system")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_SYSTEM,
-		BAD_CAST "system", BAD_CAST "systemId", BAD_CAST "uri");
+		BAD_CAST "system", BAD_CAST "systemId", BAD_CAST "uri", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "rewriteSystem")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_REWRITE_SYSTEM,
 		BAD_CAST "rewriteSystem", BAD_CAST "systemIdStartString",
-		BAD_CAST "rewritePrefix");
+		BAD_CAST "rewritePrefix", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "delegatePublic")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_PUBLIC,
 		BAD_CAST "delegatePublic", BAD_CAST "publicIdStartString",
-		BAD_CAST "catalog");
+		BAD_CAST "catalog", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "delegateSystem")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_SYSTEM,
 		BAD_CAST "delegateSystem", BAD_CAST "systemIdStartString",
-		BAD_CAST "catalog");
+		BAD_CAST "catalog", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "uri")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_URI,
 		BAD_CAST "uri", BAD_CAST "name",
-		BAD_CAST "uri");
+		BAD_CAST "uri", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "rewriteURI")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_REWRITE_URI,
 		BAD_CAST "rewriteURI", BAD_CAST "uriStartString",
-		BAD_CAST "rewritePrefix");
+		BAD_CAST "rewritePrefix", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "delegateURI")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_DELEGATE_URI,
 		BAD_CAST "delegateURI", BAD_CAST "uriStartString",
-		BAD_CAST "catalog");
+		BAD_CAST "catalog", prefer);
     } else if (xmlStrEqual(cur->name, BAD_CAST "nextCatalog")) {
 	entry = xmlParseXMLCatalogOneNode(cur, XML_CATA_NEXT_CATALOG,
 		BAD_CAST "nextCatalog", NULL,
-		BAD_CAST "catalog");
+		BAD_CAST "catalog", prefer);
     }
     if ((entry != NULL) && (parent != NULL)) {
 	entry->parent = parent;
@@ -452,6 +526,10 @@
     if ((value == NULL) || (file == NULL))
         return(NULL);
 
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Parsing catalog %s's content\n", file);
+
     doc = xmlParseDoc((xmlChar *) value);
     if (doc == NULL) 
 	return(NULL);
@@ -462,13 +540,6 @@
 	(cur->ns != NULL) && (cur->ns->href != NULL) &&
 	(xmlStrEqual(cur->ns->href, XML_CATALOGS_NAMESPACE))) {
 
-	parent = xmlNewCatalogEntry(XML_CATA_CATALOG,
-		                    (const xmlChar *)file, NULL);
-        if (parent == NULL) {
-	    xmlFreeDoc(doc);
-	    return(NULL);
-	}
-
 	prop = xmlGetProp(cur, BAD_CAST "prefer");
 	if (prop != NULL) {
 	    if (xmlStrEqual(prop, BAD_CAST "system")) {
@@ -482,6 +553,13 @@
 	    }
 	    xmlFree(prop);
 	}
+	parent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+		                    (const xmlChar *)file, prefer);
+        if (parent == NULL) {
+	    xmlFreeDoc(doc);
+	    return(NULL);
+	}
+
 	cur = cur->children;
 	xmlParseXMLCatalogNodeList(cur, prefer, parent);
     } else {
@@ -505,16 +583,24 @@
         return(NULL);
 
     doc = xmlParseFile((const char *) filename);
-    if (doc == NULL) 
+    if (doc == NULL) {
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Failed to parse catalog %s\n", filename);
 	return(NULL);
+    }
+
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Parsing catalog %s\n", filename);
 
     cur = xmlDocGetRootElement(doc);
     if ((cur != NULL) && (xmlStrEqual(cur->name, BAD_CAST "catalog")) &&
 	(cur->ns != NULL) && (cur->ns->href != NULL) &&
 	(xmlStrEqual(cur->ns->href, XML_CATALOGS_NAMESPACE))) {
 
-	parent = xmlNewCatalogEntry(XML_CATA_CATALOG,
-		                    (const xmlChar *)filename, NULL);
+	parent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
+		                    (const xmlChar *)filename, prefer);
         if (parent == NULL) {
 	    xmlFreeDoc(doc);
 	    return(NULL);
@@ -569,8 +655,7 @@
     /*
      * Fetch and parse
      */
-    /* TODO : 1234 s/XML_CATA_PREFER_PUBLIC/catal->prefer */
-    children = xmlParseXMLCatalogFile(XML_CATA_PREFER_PUBLIC, catal->value);
+    children = xmlParseXMLCatalogFile(catal->prefer, catal->value);
     if (children == NULL)
 	return(-1);
 
@@ -747,8 +832,12 @@
     if ((catal == NULL) || (catal->type != XML_CATA_CATALOG))
 	return(-1);
     typ = xmlGetXMLCatalogEntryType(type);
-    if (typ == XML_CATA_NONE)
+    if (typ == XML_CATA_NONE) {
+	if (xmlDebugCatalogs)
+	    xmlGenericError(xmlGenericErrorContext,
+		    "Failed to add unknown element %s to catalog\n", type);
 	return(-1);
+    }
 
     cur = catal->children;
     /*
@@ -758,6 +847,9 @@
 	while (cur != NULL) {
 	    if ((orig != NULL) && (cur->type == typ) &&
 		(xmlStrEqual(orig, cur->name))) {
+		if (xmlDebugCatalogs)
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Updating element %s to catalog\n", type);
 		if (cur->value != NULL)
 		    xmlFree(cur->value);
 		cur->value = xmlStrdup(replace);
@@ -768,10 +860,13 @@
 	    cur = cur->next;
 	}
     }
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Adding element %s to catalog\n", type);
     if (cur == NULL)
-	catal->children = xmlNewCatalogEntry(typ, orig, replace);
+	catal->children = xmlNewCatalogEntry(typ, orig, replace, catal->prefer);
     else
-	cur->next = xmlNewCatalogEntry(typ, orig, replace);
+	cur->next = xmlNewCatalogEntry(typ, orig, replace, catal->prefer);
     return(0);
 }
 
@@ -803,6 +898,14 @@
     while (cur != NULL) {
 	if (((cur->name != NULL) && (xmlStrEqual(value, cur->name))) ||
 	    (xmlStrEqual(value, cur->value))) {
+	    if (xmlDebugCatalogs) {
+		if (cur->name != NULL)
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Removing element %s from catalog\n", cur->name);
+		else
+		    xmlGenericError(xmlGenericErrorContext,
+			    "Removing element %s from catalog\n", cur->value);
+	    }
 	    ret++;
 	    tmp = cur;
 	    cur = tmp->next;
@@ -821,69 +924,6 @@
 }
 
 /**
- * xmlCatalogGetXMLPublic:
- * @catal:  an XML catalog
- * @pubId:  the public ID string
- *
- * Try to lookup the system ID associated to a public ID
- *
- * Returns the system ID if found or NULL otherwise.
- */
-static const xmlChar *
-xmlCatalogGetXMLPublic(xmlCatalogEntryPtr catal, const xmlChar *pubID) {
-    const xmlChar *ret;
-    while (catal != NULL) {
-	switch (catal->type) {
-            case XML_CATA_CATALOG:
-		if (catal->children == NULL) {
-		    if (xmlFetchXMLCatalogFile(catal))
-			break;
-		}
-		ret = xmlCatalogGetXMLPublic(catal->children, pubID);
-		if (ret != NULL)
-		    return(ret);
-		break;
-            case XML_CATA_NEXT_CATALOG:
-		if (catal->children == NULL) {
-		    if (xmlFetchXMLCatalogFile(catal))
-			break;
-		}
-            case XML_CATA_PUBLIC:
-		if (xmlStrEqual(pubID, catal->name))
-		    return(catal->value);
-		break;
-            case XML_CATA_SYSTEM:
-            case XML_CATA_REWRITE_SYSTEM:
-            case XML_CATA_DELEGATE_PUBLIC:
-            case XML_CATA_DELEGATE_SYSTEM:
-            case XML_CATA_URI:
-            case XML_CATA_REWRITE_URI:
-            case XML_CATA_DELEGATE_URI:
-		TODO;
-		break;
-
-            case XML_CATA_NONE:
-            case SGML_CATA_SYSTEM:
-            case SGML_CATA_PUBLIC:
-            case SGML_CATA_ENTITY:
-            case SGML_CATA_PENTITY:
-            case SGML_CATA_DOCTYPE:
-            case SGML_CATA_LINKTYPE:
-            case SGML_CATA_NOTATION:
-            case SGML_CATA_DELEGATE:
-            case SGML_CATA_BASE:
-            case SGML_CATA_CATALOG:
-            case SGML_CATA_DOCUMENT:
-            case SGML_CATA_SGMLDECL:
-		/* Ignored entries */
-		break;
-	}
-	catal = catal->next;
-    }
-    return(NULL);
-}
-
-/**
  * xmlCatalogXMLResolve:
  * @catal:  a catalog list
  * @pubId:  the public ID string
@@ -916,8 +956,12 @@
 	while (cur != NULL) {
 	    switch (cur->type) {
 		case XML_CATA_SYSTEM:
-		    if (xmlStrEqual(sysID, cur->name))
+		    if (xmlStrEqual(sysID, cur->name)) {
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Found system match %s\n", cur->name);
 			return(xmlStrdup(cur->value));
+		    }
 		    break;
 		case XML_CATA_REWRITE_SYSTEM:
 		    len = xmlStrlen(cur->name);
@@ -940,6 +984,9 @@
 	    cur = cur->next;
 	}
 	if (rewrite != NULL) {
+	    if (xmlDebugCatalogs)
+		xmlGenericError(xmlGenericErrorContext,
+			"Using rewriting rule %s\n", rewrite->name);
 	    ret = xmlStrdup(rewrite->value);
 	    if (ret != NULL)
 		ret = xmlStrcat(ret, &sysID[lenrewrite]);
@@ -947,7 +994,7 @@
 	}
 	if (haveDelegate) {
 	    /*
-	     * Assume the entries have been sorted by decreasing subscting
+	     * Assume the entries have been sorted by decreasing substring
 	     * matches when the list was produced.
 	     */
 	    cur = catal;
@@ -958,11 +1005,21 @@
 			xmlFetchXMLCatalogFile(cur);
 		    }
 		    if (cur->children != NULL) {
-			TODO /* handle a delegate system entry */
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Trying system delegate %s\n", cur->value);
+			ret = xmlCatalogListXMLResolve(cur->children, NULL,
+				                       sysID);
+			if (ret != NULL)
+			    return(ret);
 		    }
 		}
 		cur = cur->next;
 	    }
+	    /*
+	     * Apply the cut algorithm explained in 4/
+	     */
+	    return(XML_CATAL_BREAK);
 	}
     }
     /*
@@ -974,11 +1031,16 @@
 	while (cur != NULL) {
 	    switch (cur->type) {
 		case XML_CATA_PUBLIC:
-		    if (xmlStrEqual(pubID, cur->name))
+		    if (xmlStrEqual(pubID, cur->name)) {
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Found public match %s\n", cur->name);
 			return(xmlStrdup(cur->value));
+		    }
 		    break;
 		case XML_CATA_DELEGATE_PUBLIC:
-		    if (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)))
+		    if (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)) &&
+			(cur->prefer == XML_CATA_PREFER_PUBLIC))
 			haveDelegate++;
 		    break;
 		case XML_CATA_NEXT_CATALOG:
@@ -992,22 +1054,33 @@
 	}
 	if (haveDelegate) {
 	    /*
-	     * Assume the entries have been sorted by decreasing subscting
+	     * Assume the entries have been sorted by decreasing substring
 	     * matches when the list was produced.
 	     */
 	    cur = catal;
 	    while (cur != NULL) {
 		if ((cur->type == XML_CATA_DELEGATE_PUBLIC) &&
-		    (!xmlStrncmp(sysID, cur->name, xmlStrlen(cur->name)))) {
+		    (cur->prefer == XML_CATA_PREFER_PUBLIC) &&
+		    (!xmlStrncmp(pubID, cur->name, xmlStrlen(cur->name)))) {
 		    if (cur->children == NULL) {
 			xmlFetchXMLCatalogFile(cur);
 		    }
 		    if (cur->children != NULL) {
-			TODO /* handle a delegate public entry */
+			if (xmlDebugCatalogs)
+			    xmlGenericError(xmlGenericErrorContext,
+				    "Trying public delegate %s\n", cur->value);
+			ret = xmlCatalogListXMLResolve(cur->children, pubID,
+				                       NULL);
+			if (ret != NULL)
+			    return(ret);
 		    }
 		}
 		cur = cur->next;
 	    }
+	    /*
+	     * Apply the cut algorithm explained in 4/
+	     */
+	    return(XML_CATAL_BREAK);
 	}
     }
     if (haveNext) {
@@ -1048,28 +1121,59 @@
 xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
 	              const xmlChar *sysID) {
     xmlChar *ret = NULL;
-    if (!xmlStrncmp(pubID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID))) {
-	TODO /* convert to PublicId */
+    xmlChar *urnID = NULL;
+    
+    if (catal == NULL)
+        return(NULL);
+    if ((pubID == NULL) && (sysID == NULL))
+	return(NULL);
+
+    if (!xmlStrncmp(pubID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
+	urnID = xmlCatalogUnWrapURN(pubID);
+	if (xmlDebugCatalogs) {
+	    if (urnID == NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"Public URN ID %s expanded to NULL\n", pubID);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"Public URN ID expanded to %s\n", urnID);
+	}
+	ret = xmlCatalogListXMLResolve(catal, urnID, sysID);
+	if (urnID != NULL)
+	    xmlFree(urnID);
+	return(ret);
     }
-    if (!xmlStrncmp(sysID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID))) {
-	TODO /* convert to PublicId and check */
+    if (!xmlStrncmp(sysID, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
+	urnID = xmlCatalogUnWrapURN(sysID);
+	if (xmlDebugCatalogs) {
+	    if (urnID == NULL)
+		xmlGenericError(xmlGenericErrorContext,
+			"System URN ID %s expanded to NULL\n", sysID);
+	    else
+		xmlGenericError(xmlGenericErrorContext,
+			"System URN ID expanded to %s\n", urnID);
+	}
+	if (pubID == NULL)
+	    ret = xmlCatalogListXMLResolve(catal, urnID, NULL);
+	else if (xmlStrEqual(pubID, urnID))
+	    ret = xmlCatalogListXMLResolve(catal, pubID, NULL);
+	else {
+	    ret = xmlCatalogListXMLResolve(catal, pubID, NULL);
+	}
+	if (urnID != NULL)
+	    xmlFree(urnID);
+	return(ret);
     }
     while (catal != NULL) {
 	if (catal->type == XML_CATA_CATALOG) {
 	    if (catal->children == NULL) {
-		/*
-		 * Construct the list on the fly, then double check
-		 * in case of threaded program that it hasn't already
-		 * being built by a concurrent thread.
-		xmlCatalogEntryPtr list;
-
-		list = 
-		 */
-		TODO
+		xmlFetchXMLCatalogFile(catal);
 	    }
-	    ret = xmlCatalogXMLResolve(catal->children, pubID, sysID);
-	    if (ret != NULL)
-		return(ret);
+	    if (catal->children != NULL) {
+		ret = xmlCatalogXMLResolve(catal->children, pubID, sysID);
+		if (ret != NULL)
+		    return(ret);
+	    }
 	}
 	catal = catal->next;
     }
@@ -1365,7 +1469,8 @@
 		if (filename != NULL) {
 		    xmlCatalogEntryPtr entry;
 
-		    entry = xmlNewCatalogEntry(type, name, filename);
+		    entry = xmlNewCatalogEntry(type, name, filename,
+			                       XML_CATA_PREFER_NONE);
 		    res = xmlHashAddEntry(xmlDefaultCatalog, name, entry);
 		    if (res < 0) {
 			xmlFreeCatalogEntry(entry);
@@ -1423,6 +1528,30 @@
 }
 
 /**
+ * xmlCatalogGetSGMLSystem:
+ * @catal:  an SGML catalog hash
+ * @sysId:  the public ID string
+ *
+ * Try to lookup the catalog local reference for a system ID
+ *
+ * Returns the system ID if found or NULL otherwise.
+ */
+static const xmlChar *
+xmlCatalogGetSGMLSystem(xmlHashTablePtr catal, const xmlChar *sysID) {
+    xmlCatalogEntryPtr entry;
+
+    if (catal == NULL)
+	return(NULL);
+
+    entry = (xmlCatalogEntryPtr) xmlHashLookup(catal, sysID);
+    if (entry == NULL)
+	return(NULL);
+    if (entry->type == SGML_CATA_SYSTEM)
+	return(entry->value);
+    return(NULL);
+}
+
+/**
  * xmlCatalogSGMLResolve:
  * @pubId:  the public ID string
  * @sysId:  the system ID string
@@ -1444,13 +1573,40 @@
  ************************************************************************/
 
 /**
+ * xmlInitializeCatalog:
+ *
+ * Do the catalog initialization.
+ * TODO: this function is not thread safe, catalog initialization should
+ *       preferably be done once at startup
+ */
+void
+xmlInitializeCatalog(void) {
+    const char *catalogs;
+
+    if (xmlCatalogInitialized != 0)
+	return;
+
+    if (getenv("XML_DEBUG_CATALOG")) 
+	xmlDebugCatalogs = 1;
+    if ((xmlDefaultXMLCatalogList == NULL) && (xmlDefaultCatalog == NULL)) {
+	catalogs = getenv("XML_CATALOG_FILES");
+	if (catalogs == NULL)
+	    catalogs = XML_DEFAULT_CATALOG;
+	xmlDefaultXMLCatalogList = xmlNewCatalogEntry(XML_CATA_CATALOG,
+			   NULL, BAD_CAST catalogs, xmlCatalogDefaultPrefer);
+    }
+
+    xmlCatalogInitialized = 1;
+}
+
+/**
  * xmlLoadCatalog:
  * @filename:  a file path
  *
  * Load the catalog and makes its definitions effective for the default
  * external entity loader. It will recuse in CATALOG entries.
  * TODO: this function is not thread safe, catalog initialization should
- *       be done once at startup
+ *       preferably be done once at startup
  *
  * Returns 0 in case of success -1 in case of error
  */
@@ -1467,9 +1623,17 @@
 	xmlDefaultCatalog = xmlHashCreate(20);
     if (xmlDefaultCatalog == NULL)
 	return(-1);
-    
+
+    /*
+     * Need to be done after ...
+     */
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+#ifdef HAVE_STAT
     if (stat(filename, &info) < 0) 
 	return(-1);
+#endif
 
     /*
      * Prevent loops
@@ -1545,7 +1709,7 @@
  * Load the catalogs and makes their definitions effective for the default
  * external entity loader.
  * TODO: this function is not thread safe, catalog initialization should
- *       be done once at startup
+ *       preferably be done once at startup
  */
 void
 xmlLoadCatalogs(const char *pathss) {
@@ -1578,33 +1742,93 @@
  */
 void
 xmlCatalogCleanup(void) {
+    if (xmlDebugCatalogs)
+	xmlGenericError(xmlGenericErrorContext,
+		"Catalogs cleanup\n");
     if (xmlDefaultXMLCatalogList != NULL)
 	xmlFreeCatalogEntryList(xmlDefaultXMLCatalogList);
+    xmlDefaultXMLCatalogList = NULL;
     if (xmlDefaultCatalog != NULL)
 	xmlHashFree(xmlDefaultCatalog,
 		    (xmlHashDeallocator) xmlFreeCatalogEntry);
+    xmlDebugCatalogs = 0;
     xmlDefaultCatalog = NULL;
+    xmlCatalogInitialized = 0;
 }
 
 /**
  * xmlCatalogGetSystem:
- * @sysId:  the system ID string
+ * @pubId:  the public ID string
  *
- * Try to lookup the resource associated to a system ID
+ * Try to lookup the system ID associated to a public ID
+ * DEPRECATED, use xmlCatalogResolveSystem()
  *
- * Returns the resource name if found or NULL otherwise.
+ * Returns the system ID if found or NULL otherwise.
  */
 const xmlChar *
 xmlCatalogGetSystem(const xmlChar *sysID) {
-    xmlCatalogEntryPtr entry;
+    xmlChar *ret;
+    static xmlChar result[1000];
 
-    if ((sysID == NULL) || (xmlDefaultCatalog == NULL))
+    if (sysID == NULL)
 	return(NULL);
-    entry = (xmlCatalogEntryPtr) xmlHashLookup(xmlDefaultCatalog, sysID);
-    if (entry == NULL)
+    
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    /*
+     * Check first the XML catalogs
+     */
+    if (xmlDefaultXMLCatalogList != NULL) {
+	ret = xmlCatalogListXMLResolve(xmlDefaultXMLCatalogList, NULL, sysID);
+	if (ret != NULL) {
+	    snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
+	    result[sizeof(result) - 1] = 0;
+	    return(result);
+	}
+    }
+
+    if (xmlDefaultCatalog != NULL)
+	return(xmlCatalogGetSGMLSystem(xmlDefaultCatalog, sysID));
+    return(NULL);
+}
+
+/**
+ * xmlCatalogResolveSystem:
+ * @sysId:  the public ID string
+ *
+ * Try to lookup the catalog resource for a system ID
+ *
+ * Returns the system ID if found or NULL otherwise, the value returned
+ *      must be freed by the caller.
+ */
+xmlChar *
+xmlCatalogResolveSystem(const xmlChar *sysID) {
+    xmlCatalogEntryPtr catal;
+    xmlChar *ret;
+    const xmlChar *sgml;
+
+    if (sysID == NULL)
 	return(NULL);
-    if (entry->type == SGML_CATA_SYSTEM)
-	return(entry->value);
+    
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    /*
+     * Check first the XML catalogs
+     */
+    catal = xmlDefaultXMLCatalogList;
+    if (catal != NULL) {
+	ret = xmlCatalogListXMLResolve(xmlDefaultXMLCatalogList, NULL, sysID);
+	if ((ret != NULL) && (ret != XML_CATAL_BREAK))
+	    return(ret);
+    }
+
+    if (xmlDefaultCatalog != NULL) {
+	sgml = xmlCatalogGetSGMLSystem(xmlDefaultCatalog, sysID);
+	if (sgml != NULL)
+	    return(xmlStrdup(sgml));
+    }
     return(NULL);
 }
 
@@ -1613,29 +1837,74 @@
  * @pubId:  the public ID string
  *
  * Try to lookup the system ID associated to a public ID
+ * DEPRECATED, use xmlCatalogResolvePublic()
  *
  * Returns the system ID if found or NULL otherwise.
  */
 const xmlChar *
 xmlCatalogGetPublic(const xmlChar *pubID) {
-    xmlCatalogEntryPtr catal;
-    const xmlChar *ret;
+    xmlChar *ret;
+    static xmlChar result[1000];
 
     if (pubID == NULL)
 	return(NULL);
     
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
+    /*
+     * Check first the XML catalogs
+     */
+    if (xmlDefaultXMLCatalogList != NULL) {
+	ret = xmlCatalogListXMLResolve(xmlDefaultXMLCatalogList, pubID, NULL);
+	if ((ret != NULL) && (ret != XML_CATAL_BREAK)) {
+	    snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
+	    result[sizeof(result) - 1] = 0;
+	    return(result);
+	}
+    }
+
+    if (xmlDefaultCatalog != NULL)
+	return(xmlCatalogGetSGMLPublic(xmlDefaultCatalog, pubID));
+    return(NULL);
+}
+
+/**
+ * xmlCatalogResolvePublic:
+ * @pubId:  the public ID string
+ *
+ * Try to lookup the system ID associated to a public ID
+ *
+ * Returns the system ID if found or NULL otherwise, the value returned
+ *      must be freed by the caller.
+ */
+xmlChar *
+xmlCatalogResolvePublic(const xmlChar *pubID) {
+    xmlCatalogEntryPtr catal;
+    xmlChar *ret;
+    const xmlChar *sgml;
+
+    if (pubID == NULL)
+	return(NULL);
+    
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
     /*
      * Check first the XML catalogs
      */
     catal = xmlDefaultXMLCatalogList;
     if (catal != NULL) {
-	ret = xmlCatalogGetXMLPublic(catal, pubID);
-	if (ret != NULL)
+	ret = xmlCatalogListXMLResolve(xmlDefaultXMLCatalogList, pubID, NULL);
+	if ((ret != NULL) && (ret != XML_CATAL_BREAK))
 	    return(ret);
     }
 
-    if (xmlDefaultCatalog != NULL)
-	return(xmlCatalogGetSGMLPublic(xmlDefaultCatalog, pubID));
+    if (xmlDefaultCatalog != NULL) {
+	sgml = xmlCatalogGetSGMLPublic(xmlDefaultCatalog, pubID);
+	if (sgml != NULL)
+	    return(xmlStrdup(sgml));
+    }
     return(NULL);
 }
 
@@ -1651,11 +1920,19 @@
  */
 xmlChar *
 xmlCatalogResolve(const xmlChar *pubID, const xmlChar *sysID) {
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
     if (xmlDefaultXMLCatalogList != NULL) {
 	return(xmlCatalogListXMLResolve(xmlDefaultXMLCatalogList, pubID, sysID));
     } else {
-	return(xmlCatalogSGMLResolve(pubID, sysID));
+	const xmlChar *ret;
+
+	ret = xmlCatalogSGMLResolve(pubID, sysID);
+	if (ret != NULL)
+	    return(xmlStrdup(ret));
     }
+    return(NULL);
 }
 
 /**
@@ -1692,6 +1969,9 @@
 xmlCatalogAdd(const xmlChar *type, const xmlChar *orig, const xmlChar *replace) {
     int res = -1;
 
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
     if (xmlDefaultXMLCatalogList != NULL) {
 	res = xmlAddXMLCatalog(xmlDefaultXMLCatalogList, type, orig, replace);
     } else if (xmlDefaultCatalog != NULL) {
@@ -1700,7 +1980,7 @@
 	typ = xmlGetSGMLCatalogEntryType(type);
 	if (type != XML_CATA_NONE) {
 	    xmlCatalogEntryPtr entry;
-	    entry = xmlNewCatalogEntry(typ, orig, replace);
+	    entry = xmlNewCatalogEntry(typ, orig, replace, XML_CATA_PREFER_NONE);
 	    res = xmlHashAddEntry(xmlDefaultCatalog, orig, entry);
 	}
     } 
@@ -1719,6 +1999,9 @@
 xmlCatalogRemove(const xmlChar *value) {
     int res = -1;
 
+    if (!xmlCatalogInitialized)
+	xmlInitializeCatalog();
+
     if (xmlDefaultXMLCatalogList != NULL) {
 	res = xmlDelXMLCatalog(xmlDefaultXMLCatalogList, value);
     } else if (xmlDefaultCatalog != NULL) {
@@ -1728,6 +2011,23 @@
 }
 
 /**
+ * xmlCatalogSetDefaultPrefer:
+ * @prefer:  the default preference for delegation
+ *
+ * Allows to set the preference between public and system for deletion
+ * in XML Catalog resolution. C.f. section 4.1.1 of the spec
+ *
+ * Returns the previous value of the default preference for delegation
+ */
+xmlCatalogPrefer
+xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer) {
+    xmlCatalogPrefer ret = xmlCatalogDefaultPrefer;
+
+    xmlCatalogDefaultPrefer = prefer;
+    return(ret);
+}
+
+/**
  * xmlCatalogSetDebug:
  * @level:  the debug level of catalogs required
  *