Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/catalog.c

 /**
- * catalog.c: set of generic Catalog related routines 
+ * catalog.c: set of generic Catalog related routines
  *
  * Reference:  SGML Open Technical Resolution TR9401:1997.
  *             http://www.jclark.com/sp/catalog.htm
  *
  *             XML Catalogs Working Draft 06 August 2001
  *             http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
  *
  * See Copyright for the status of this software.
  *
  * Daniel.Veillard@imag.fr
@@ skipping 21 matching lines @@
 #include <string.h>
 #include <libxml/xmlmemory.h>
 #include <libxml/hash.h>
 #include <libxml/uri.h>
 #include <libxml/parserInternals.h>
 #include <libxml/catalog.h>
 #include <libxml/xmlerror.h>
 #include <libxml/threads.h>
 #include <libxml/globals.h>
 
+#include "buf.h"
+
 #define MAX_DELEGATE    50
 #define MAX_CATAL_DEPTH 50
 
 #ifdef _WIN32
 # define PATH_SEAPARATOR ';'
 #else
 # define PATH_SEAPARATOR ':'
 #endif
 
 /**
  * TODO:
  *
  * macro to flag unimplemented blocks
  * XML_CATALOG_PREFER user env to select between system/public prefered
  * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
  *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
  *> values "system" and "public".  I have made the default be "system" to
  *> match yours.
  */
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 #define XML_URN_PUBID "urn:publicid:"
 #define XML_CATAL_BREAK ((xmlChar *) -1)
 #ifndef XML_XML_DEFAULT_CATALOG
 #define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
 #endif
 #ifndef XML_SGML_DEFAULT_CATALOG
 #define XML_SGML_DEFAULT_CATALOG "file:///etc/sgml/catalog"
 #endif
 
 #if defined(_WIN32) && defined(_MSC_VER)
 #undef XML_XML_DEFAULT_CATALOG
 static char XML_XML_DEFAULT_CATALOG[256] = "file:///etc/xml/catalog";
 #if defined(_WIN32_WCE)
 /* Windows CE don't have a A variant */
 #define GetModuleHandleA GetModuleHandle
 #define GetModuleFileNameA GetModuleFileName
 #else
+#if !defined(_WINDOWS_)
 void* __stdcall GetModuleHandleA(const char*);
 unsigned long __stdcall GetModuleFileNameA(void*, char*, unsigned long);
 #endif
 #endif
+#endif
 
 static xmlChar *xmlCatalogNormalizePublic(const xmlChar *pubID);
 static int xmlExpandCatalog(xmlCatalogPtr catal, const char *filename);
 
 /************************************************************************
  *                                                                      *
  *                      Types, all private                              *
  *                                                                      *
  ************************************************************************/
 
@@ skipping 100 matching lines @@
  */
 static xmlRMutexPtr xmlCatalogMutex = NULL;
 
 /*
  * Whether the catalog support was initialized.
  */
 static int xmlCatalogInitialized = 0;
 
 /************************************************************************
  *                                                                      *
- *                      Catalog error handlers                          *
+ *                      Catalog error handlers                          *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlCatalogErrMemory:
  * @extra:  extra informations
  *
  * Handle an out of memory condition
  */
 static void
@@ skipping 32 matching lines @@
  *                      Allocation and Freeing                          *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlNewCatalogEntry:
  * @type:  type of entry
  * @name:  name of the entry
  * @value:  value of the entry
  * @prefer:  the PUBLIC vs. SYSTEM current preference value
- * @group:  for members of a group, the group entry 
+ * @group:  for members of a group, the group entry
  *
- * create a new Catalog entry, this type is shared both by XML and 
+ * create a new Catalog entry, this type is shared both by XML and
  * SGML catalogs, but the acceptable types values differs.
  *
  * Returns the xmlCatalogEntryPtr or NULL in case of error
  */
 static xmlCatalogEntryPtr
 xmlNewCatalogEntry(xmlCatalogEntryType type, const xmlChar *name,
            const xmlChar *value, const xmlChar *URL, xmlCatalogPrefer prefer,
            xmlCatalogEntryPtr group) {
     xmlCatalogEntryPtr ret;
     xmlChar *normid = NULL;
@@ skipping 117 matching lines @@
     }
     catal->dealloc = 0;
     xmlFreeCatalogEntry(catal);
 }
 
 /**
  * xmlCreateNewCatalog:
  * @type:  type of catalog
  * @prefer:  the PUBLIC vs. SYSTEM current preference value
  *
- * create a new Catalog, this type is shared both by XML and 
+ * create a new Catalog, this type is shared both by XML and
  * SGML catalogs, but the acceptable types values differs.
  *
  * Returns the xmlCatalogPtr or NULL in case of error
  */
 static xmlCatalogPtr
 xmlCreateNewCatalog(xmlCatalogType type, xmlCatalogPrefer prefer) {
     xmlCatalogPtr ret;
 
     ret = (xmlCatalogPtr) xmlMalloc(sizeof(xmlCatalog));
     if (ret == NULL) {
@@ skipping 147 matching lines @@
                 case XML_CATA_NONE:
                     break;
                 case XML_CATA_GROUP:
                     node = xmlNewDocNode(doc, ns, BAD_CAST "group", NULL);
                     xmlSetProp(node, BAD_CAST "id", cur->name);
                     if (cur->value != NULL) {
                         xmlNsPtr xns;
                         xns = xmlSearchNsByHref(doc, node, XML_XML_NAMESPACE);
                         if (xns != NULL)
                             xmlSetNsProp(node, xns, BAD_CAST "base",
-                                         cur->value);
+                                         cur->value);
                     }
                     switch (cur->prefer) {
                         case XML_CATA_PREFER_NONE:
                             break;
                         case XML_CATA_PREFER_PUBLIC:
                             xmlSetProp(node, BAD_CAST "prefer", BAD_CAST "public");
                             break;
                         case XML_CATA_PREFER_SYSTEM:
                             xmlSetProp(node, BAD_CAST "prefer", BAD_CAST "system");
                             break;
@@ skipping 97 matching lines @@
     catalog = xmlNewDocNode(doc, ns, BAD_CAST "catalog", NULL);
     if (catalog == NULL) {
         xmlFreeNs(ns);
         xmlFreeDoc(doc);
         return(-1);
     }
     catalog->nsDef = ns;
     xmlAddChild((xmlNodePtr) doc, catalog);
 
     xmlDumpXMLCatalogNode(catal, catalog, doc, ns, NULL);
-    
+
     /*
      * reserialize it
      */
     buf = xmlOutputBufferCreateFile(out, NULL);
     if (buf == NULL) {
         xmlFreeDoc(doc);
         return(-1);
     }
     ret = xmlSaveFormatFileTo(buf, doc, NULL, 1);
 
@@ skipping 116 matching lines @@
  *         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) - 4)
             break;
         if (*urn == '+') {
             result[i++] = ' ';
             urn++;
         } else if (*urn == ':') {
             result[i++] = '/';
             result[i++] = '/';
             urn++;
@@ skipping 69 matching lines @@
     }
 
     inputStream = xmlNewInputStream(ctxt);
     if (inputStream == NULL) {
         xmlFreeParserCtxt(ctxt);
         return(NULL);
     }
 
     inputStream->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
     inputStream->buf = buf;
-    inputStream->base = inputStream->buf->buffer->content;
-    inputStream->cur = inputStream->buf->buffer->content;
-    inputStream->end = 
-        &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+    xmlBufResetInput(buf->buffer, inputStream);
 
     inputPush(ctxt, inputStream);
     if ((ctxt->directory == NULL) && (directory == NULL))
         directory = xmlParserGetDirectory(filename);
     if ((ctxt->directory == NULL) && (directory != NULL))
         ctxt->directory = directory;
     ctxt->valid = 0;
     ctxt->validate = 0;
     ctxt->loadsubset = 0;
     ctxt->pedantic = 0;
     ctxt->dictNames = 1;
 
     xmlParseDocument(ctxt);
 
     if (ctxt->wellFormed)
         ret = ctxt->myDoc;
     else {
         ret = NULL;
         xmlFreeDoc(ctxt->myDoc);
         ctxt->myDoc = NULL;
     }
     xmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 }
 
 /**
  * xmlLoadFileContent:
  * @filename:  a file path
  *
  * Load a file content into memory.
  *
  * Returns a pointer to the 0 terminated string or NULL in case of error
@@ skipping 31 matching lines @@
         return (NULL);
     }
 #ifdef HAVE_STAT
     size = info.st_size;
 #else
     if (fseek(fd, 0, SEEK_END) || (size = ftell(fd)) == EOF || fseek(fd, 0, SEEK_SET)) {        /* File operations denied? ok, just close and return failure */
         fclose(fd);
         return (NULL);
     }
 #endif
-    content = xmlMallocAtomic(size + 10);
+    content = (xmlChar*)xmlMallocAtomic(size + 10);
     if (content == NULL) {
         xmlCatalogErrMemory("allocating catalog data");
+#ifdef HAVE_STAT
+        close(fd);
+#else
+        fclose(fd);
+#endif
         return (NULL);
     }
 #ifdef HAVE_STAT
     len = read(fd, content, size);
+    close(fd);
 #else
     len = fread(content, 1, size, fd);
+    fclose(fd);
 #endif
     if (len < 0) {
         xmlFree(content);
         return (NULL);
     }
-#ifdef HAVE_STAT
-    close(fd);
-#else
-    fclose(fd);
-#endif
     content[len] = 0;
 
     return(content);
 }
 
 /**
  * xmlCatalogNormalizePublic:
  * @pubID:  the public ID string
  *
  *  Normalizes the Public Identifier
@@ skipping 302 matching lines @@
     /* TODO: sort the list according to REWRITE lengths and prefer value */
 }
 
 /**
  * xmlParseXMLCatalogFile:
  * @prefer:  the PUBLIC vs. SYSTEM current preference value
  * @filename:  the filename for the catalog
  *
  * Parses the catalog file to extract the XML tree and then analyze the
  * tree to build a list of Catalog entries corresponding to this catalog
- * 
+ *
  * Returns the resulting Catalog entries list
  */
 static xmlCatalogEntryPtr
 xmlParseXMLCatalogFile(xmlCatalogPrefer prefer, const xmlChar *filename) {
     xmlDocPtr doc;
     xmlNodePtr cur;
     xmlChar *prop;
     xmlCatalogEntryPtr parent = NULL;
 
     if (filename == NULL)
@@ skipping 47 matching lines @@
     }
     xmlFreeDoc(doc);
     return(parent);
 }
 
 /**
  * xmlFetchXMLCatalogFile:
  * @catal:  an existing but incomplete catalog entry
  *
  * Fetch and parse the subcatalog referenced by an entry
- * 
+ *
  * Returns 0 in case of success, -1 otherwise
  */
 static int
 xmlFetchXMLCatalogFile(xmlCatalogEntryPtr catal) {
     xmlCatalogEntryPtr doc;
 
-    if (catal == NULL) 
+    if (catal == NULL)
         return(-1);
     if (catal->URL == NULL)
         return(-1);
-    if (catal->children != NULL)
-        return(-1);
 
     /*
      * lock the whole catalog for modification
      */
     xmlRMutexLock(xmlCatalogMutex);
     if (catal->children != NULL) {
         /* Okay someone else did it in the meantime */
         xmlRMutexUnlock(xmlCatalogMutex);
         return(0);
     }
@@ skipping 68 matching lines @@
  *
  * Returns 0 if successful, -1 otherwise
  */
 static int
 xmlAddXMLCatalog(xmlCatalogEntryPtr catal, const xmlChar *type,
               const xmlChar *orig, const xmlChar *replace) {
     xmlCatalogEntryPtr cur;
     xmlCatalogEntryType typ;
     int doregister = 0;
 
-    if ((catal == NULL) || 
+    if ((catal == NULL) ||
         ((catal->type != XML_CATA_CATALOG) &&
          (catal->type != XML_CATA_BROKEN_CATALOG)))
         return(-1);
     if (catal->children == NULL) {
         xmlFetchXMLCatalogFile(catal);
     }
     if (catal->children == NULL)
         doregister = 1;
 
     typ = xmlGetXMLCatalogEntryType(type);
@@ skipping 32 matching lines @@
         xmlGenericError(xmlGenericErrorContext,
                 "Adding element %s to catalog\n", type);
     if (cur == NULL)
         catal->children = xmlNewCatalogEntry(typ, orig, replace,
                                              NULL, catal->prefer, NULL);
     else
         cur->next = xmlNewCatalogEntry(typ, orig, replace,
                                        NULL, catal->prefer, NULL);
     if (doregister) {
         catal->type = XML_CATA_CATALOG;
-        cur = xmlHashLookup(xmlCatalogXMLFiles, catal->URL);
+        cur = (xmlCatalogEntryPtr)xmlHashLookup(xmlCatalogXMLFiles, catal->URL);
         if (cur != NULL)
             cur->children = catal->children;
     }
 
     return(0);
 }
 
 /**
  * xmlDelXMLCatalog:
  * @catal:  top of an XML catalog
  * @value:  the value to remove from the catalog
  *
  * Remove entries in the XML catalog where the value or the URI
  * is equal to @value
  *
  * Returns the number of entries removed if successful, -1 otherwise
  */
 static int
 xmlDelXMLCatalog(xmlCatalogEntryPtr catal, const xmlChar *value) {
     xmlCatalogEntryPtr cur;
     int ret = 0;
 
-    if ((catal == NULL) || 
+    if ((catal == NULL) ||
         ((catal->type != XML_CATA_CATALOG) &&
          (catal->type != XML_CATA_BROKEN_CATALOG)))
         return(-1);
     if (value == NULL)
         return(-1);
     if (catal->children == NULL) {
         xmlFetchXMLCatalogFile(catal);
     }
 
     /*
@@ skipping 194 matching lines @@
 
                     for (i = 0;i < nbList;i++)
                         if (xmlStrEqual(cur->URL, delegates[i]))
                             break;
                     if (i < nbList) {
                         cur = cur->next;
                         continue;
                     }
                     if (nbList < MAX_DELEGATE)
                         delegates[nbList++] = cur->URL;
-                            
+
                     if (cur->children == NULL) {
                         xmlFetchXMLCatalogFile(cur);
                     }
                     if (cur->children != NULL) {
                         if (xmlDebugCatalogs)
                             xmlGenericError(xmlGenericErrorContext,
                                     "Trying public delegate %s\n", cur->URL);
                         ret = xmlCatalogListXMLResolve(
                                 cur->children, pubID, NULL);
                         if (ret != NULL) {
@@ skipping 192 matching lines @@
  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
  *
  * Returns the URI of the resource or NULL if not found
  */
 static xmlChar *
 xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
                       const xmlChar *sysID) {
     xmlChar *ret = NULL;
     xmlChar *urnID = NULL;
     xmlChar *normid;
-    
+
     if (catal == NULL)
         return(NULL);
     if ((pubID == NULL) && (sysID == NULL))
         return(NULL);
 
     normid = xmlCatalogNormalizePublic(pubID);
     if (normid != NULL)
         pubID = (*normid != 0 ? normid : 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);
         }
@@ skipping 59 matching lines @@
  *
  * Implements (or tries to) 7.2. URI Resolution
  * from http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
  *
  * Returns the URI of the resource or NULL if not found
  */
 static xmlChar *
 xmlCatalogListXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI) {
     xmlChar *ret = NULL;
     xmlChar *urnID = NULL;
-    
+
     if (catal == NULL)
         return(NULL);
     if (URI == NULL)
         return(NULL);
 
     if (!xmlStrncmp(URI, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
         urnID = xmlCatalogUnWrapURN(URI);
         if (xmlDebugCatalogs) {
             if (urnID == NULL)
                 xmlGenericError(xmlGenericErrorContext,
@@ skipping 39 matching lines @@
 /**
  * xmlParseSGMLCatalogComment:
  * @cur:  the current character
  *
  * Skip a comment in an SGML catalog
  *
  * Returns new current character
  */
 static const xmlChar *
 xmlParseSGMLCatalogComment(const xmlChar *cur) {
-    if ((cur[0] != '-') || (cur[1] != '-')) 
+    if ((cur[0] != '-') || (cur[1] != '-'))
         return(cur);
     SKIP(2);
     while ((cur[0] != 0) && ((cur[0] != '-') || ((cur[1] != '-'))))
         NEXT;
     if (cur[0] == 0) {
         return(NULL);
     }
     return(cur + 2);
 }
 
@@ skipping 514 matching lines @@
     xmlChar *first;
     xmlCatalogPtr catal;
     int ret;
 
     content = xmlLoadFileContent(filename);
     if (content == NULL)
         return(NULL);
 
 
     first = content;
-   
+
     while ((*first != 0) && (*first != '-') && (*first != '<') &&
            (!(((*first >= 'A') && (*first <= 'Z')) ||
               ((*first >= 'a') && (*first <= 'z')))))
         first++;
 
     if (*first != '<') {
         catal = xmlCreateNewCatalog(XML_SGML_CATALOG_TYPE, xmlCatalogDefaultPrefer);
         if (catal == NULL) {
             xmlFree(content);
             return(NULL);
@@ skipping 74 matching lines @@
  *
  * Returns the resource if found or NULL otherwise, the value returned
  *      must be freed by the caller.
  */
 xmlChar *
 xmlACatalogResolveSystem(xmlCatalogPtr catal, const xmlChar *sysID) {
     xmlChar *ret = NULL;
 
     if ((sysID == NULL) || (catal == NULL))
         return(NULL);
-    
+
     if (xmlDebugCatalogs)
         xmlGenericError(xmlGenericErrorContext,
                 "Resolve sysID %s\n", sysID);
 
     if (catal->type == XML_XML_CATALOG_TYPE) {
         ret = xmlCatalogListXMLResolve(catal->xml, NULL, sysID);
         if (ret == XML_CATAL_BREAK)
             ret = NULL;
     } else {
         const xmlChar *sgml;
@@ skipping 14 matching lines @@
  *
  * Returns the local resource if found or NULL otherwise, the value returned
  *      must be freed by the caller.
  */
 xmlChar *
 xmlACatalogResolvePublic(xmlCatalogPtr catal, const xmlChar *pubID) {
     xmlChar *ret = NULL;
 
     if ((pubID == NULL) || (catal == NULL))
         return(NULL);
-    
+
     if (xmlDebugCatalogs)
         xmlGenericError(xmlGenericErrorContext,
                 "Resolve pubID %s\n", pubID);
 
     if (catal->type == XML_XML_CATALOG_TYPE) {
         ret = xmlCatalogListXMLResolve(catal->xml, pubID, NULL);
         if (ret == XML_CATAL_BREAK)
             ret = NULL;
     } else {
         const xmlChar *sgml;
@@ skipping 98 matching lines @@
 void
 xmlACatalogDump(xmlCatalogPtr catal, FILE *out) {
     if ((out == NULL) || (catal == NULL))
         return;
 
     if (catal->type == XML_XML_CATALOG_TYPE) {
         xmlDumpXMLCatalog(out, catal->xml);
     } else {
         xmlHashScan(catal->sgml,
                     (xmlHashScanner) xmlCatalogDumpEntry, out);
-    } 
+    }
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlACatalogAdd:
  * @catal:  a Catalog
  * @type:  the type of record to add to the catalog
- * @orig:  the system, public or prefix to match 
+ * @orig:  the system, public or prefix to match
  * @replace:  the replacement value for the match
  *
  * Add an entry in the catalog, it may overwrite existing but
  * different entries.
  *
  * Returns 0 if successful, -1 otherwise
  */
 int
 xmlACatalogAdd(xmlCatalogPtr catal, const xmlChar * type,
               const xmlChar * orig, const xmlChar * replace)
@@ skipping 38 matching lines @@
     if ((catal == NULL) || (value == NULL))
         return(-1);
 
     if (catal->type == XML_XML_CATALOG_TYPE) {
         res = xmlDelXMLCatalog(catal->xml, value);
     } else {
         res = xmlHashRemoveEntry(catal->sgml, value,
                 (xmlHashDeallocator) xmlFreeCatalogEntry);
         if (res == 0)
             res = 1;
-    } 
+    }
     return(res);
 }
 
 /**
  * xmlNewCatalog:
  * @sgml:  should this create an SGML catalog
  *
  * create a new Catalog.
  *
  * Returns the xmlCatalogPtr or NULL in case of error
@@ skipping 38 matching lines @@
     } else {
         int res;
 
         if (catal->sgml == NULL)
             return(1);
         res = xmlHashSize(catal->sgml);
         if (res == 0)
             return(1);
         if (res < 0)
             return(-1);
-    } 
+    }
     return(0);
 }
 
 /************************************************************************
  *                                                                      *
  *   Public interfaces manipulating the global shared default catalog   *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlInitializeCatalogData:
  *
  * Do the catalog initialization only of global data, doesn't try to load
  * any catalog actually.
  * this function is not thread safe, catalog initialization should
  * preferably be done once at startup
  */
 static void
 xmlInitializeCatalogData(void) {
     if (xmlCatalogInitialized != 0)
         return;
 
-    if (getenv("XML_DEBUG_CATALOG")) 
+    if (getenv("XML_DEBUG_CATALOG"))
         xmlDebugCatalogs = 1;
     xmlCatalogMutex = xmlNewRMutex();
 
     xmlCatalogInitialized = 1;
 }
 /**
  * xmlInitializeCatalog:
  *
  * Do the catalog initialization.
  * this function is not thread safe, catalog initialization should
  * preferably be done once at startup
  */
 void
 xmlInitializeCatalog(void) {
     if (xmlCatalogInitialized != 0)
         return;
 
     xmlInitializeCatalogData();
     xmlRMutexLock(xmlCatalogMutex);
 
-    if (getenv("XML_DEBUG_CATALOG")) 
+    if (getenv("XML_DEBUG_CATALOG"))
         xmlDebugCatalogs = 1;
 
     if (xmlDefaultCatalog == NULL) {
         const char *catalogs;
         char *path;
         const char *cur, *paths;
         xmlCatalogPtr catal;
         xmlCatalogEntryPtr *nextent;
 
         catalogs = (const char *) getenv("XML_CATALOG_FILES");
         if (catalogs == NULL)
 #if defined(_WIN32) && defined(_MSC_VER)
     {
                 void* hmodule;
                 hmodule = GetModuleHandleA("libxml2.dll");
                 if (hmodule == NULL)
                         hmodule = GetModuleHandleA(NULL);
                 if (hmodule != NULL) {
                         char buf[256];
                         unsigned long len = GetModuleFileNameA(hmodule, buf, 255);
                         if (len != 0) {
                                 char* p = &(buf[len]);
-                                while (*p != '\\' && p > buf) 
+                                while (*p != '\\' && p > buf)
                                         p--;
                                 if (p != buf) {
                                         xmlChar* uri;
                                         strncpy(p, "\\..\\etc\\catalog", 255 - (p - buf));
-                                        uri = xmlCanonicPath(buf);
+                                        uri = xmlCanonicPath((const xmlChar*)buf);
                                         if (uri != NULL) {
                                                 strncpy(XML_XML_DEFAULT_CATALOG, uri, 255);
                                                 xmlFree(uri);
                                         }
                                 }
                         }
                 }
                 catalogs = XML_XML_DEFAULT_CATALOG;
     }
 #else
             catalogs = XML_XML_DEFAULT_CATALOG;
 #endif
 
-        catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE, 
+        catal = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
                 xmlCatalogDefaultPrefer);
         if (catal != NULL) {
-            /* the XML_CATALOG_FILES envvar is allowed to contain a 
+            /* the XML_CATALOG_FILES envvar is allowed to contain a
                space-separated list of entries. */
             cur = catalogs;
             nextent = &catal->xml;
             while (*cur != '\0') {
-                while (xmlIsBlank_ch(*cur)) 
+                while (xmlIsBlank_ch(*cur))
                     cur++;
                 if (*cur != 0) {
                     paths = cur;
                     while ((*cur != 0) && (!xmlIsBlank_ch(*cur)))
                         cur++;
                     path = (char *) xmlStrndup((const xmlChar *)paths, cur - paths);
                     if (path != NULL) {
                         *nextent = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
                                 NULL, BAD_CAST path, xmlCatalogDefaultPrefer, NULL);
                         if (*nextent != NULL)
@@ skipping 72 matching lines @@
 
     cur = pathss;
     while (*cur != 0) {
         while (xmlIsBlank_ch(*cur)) cur++;
         if (*cur != 0) {
             paths = cur;
             while ((*cur != 0) && (*cur != PATH_SEAPARATOR) && (!xmlIsBlank_ch(*cur)))
                 cur++;
             path = xmlStrndup((const xmlChar *)paths, cur - paths);
 #ifdef _WIN32
-        iLen = strlen(path);
+        iLen = strlen((const char*)path);
         for(i = 0; i < iLen; i++) {
             if(path[i] == '\\') {
                 path[i] = '/';
             }
         }
 #endif
             if (path != NULL) {
                 xmlLoadCatalog((const char *) path);
                 xmlFree(path);
             }
@@ skipping 11 matching lines @@
 void
 xmlCatalogCleanup(void) {
     if (xmlCatalogInitialized == 0)
         return;
 
     xmlRMutexLock(xmlCatalogMutex);
     if (xmlDebugCatalogs)
         xmlGenericError(xmlGenericErrorContext,
                 "Catalogs cleanup\n");
     if (xmlCatalogXMLFiles != NULL)
-        xmlHashFree(xmlCatalogXMLFiles, 
+        xmlHashFree(xmlCatalogXMLFiles,
                     (xmlHashDeallocator)xmlFreeCatalogHashEntryList);
     xmlCatalogXMLFiles = NULL;
     if (xmlDefaultCatalog != NULL)
         xmlFreeCatalog(xmlDefaultCatalog);
     xmlDefaultCatalog = NULL;
     xmlDebugCatalogs = 0;
     xmlCatalogInitialized = 0;
     xmlRMutexUnlock(xmlCatalogMutex);
     xmlFreeRMutex(xmlCatalogMutex);
 }
@@ skipping 94 matching lines @@
     if (!xmlCatalogInitialized)
         xmlInitializeCatalog();
 
     xmlACatalogDump(xmlDefaultCatalog, out);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /**
  * xmlCatalogAdd:
  * @type:  the type of record to add to the catalog
- * @orig:  the system, public or prefix to match 
+ * @orig:  the system, public or prefix to match
  * @replace:  the replacement value for the match
  *
  * Add an entry in the catalog, it may overwrite existing but
  * different entries.
  * If called before any other catalog routine, allows to override the
  * default shared catalog put in place by xmlInitializeCatalog();
  *
  * Returns 0 if successful, -1 otherwise
  */
 int
@@ skipping 10 matching lines @@
      */
     if ((xmlDefaultCatalog == NULL) &&
         (xmlStrEqual(type, BAD_CAST "catalog"))) {
         xmlDefaultCatalog = xmlCreateNewCatalog(XML_XML_CATALOG_TYPE,
                                           xmlCatalogDefaultPrefer);
         xmlDefaultCatalog->xml = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL,
                                     orig, NULL,  xmlCatalogDefaultPrefer, NULL);
 
         xmlRMutexUnlock(xmlCatalogMutex);
         return(0);
-    } 
+    }
 
     res = xmlACatalogAdd(xmlDefaultCatalog, type, orig, replace);
     xmlRMutexUnlock(xmlCatalogMutex);
     return(res);
 }
 
 /**
  * xmlCatalogRemove:
  * @value:  the value to remove
  *
@@ skipping 105 matching lines @@
     if (xmlDebugCatalogs) {
         switch (prefer) {
             case XML_CATA_PREFER_PUBLIC:
                 xmlGenericError(xmlGenericErrorContext,
                         "Setting catalog preference to PUBLIC\n");
                 break;
             case XML_CATA_PREFER_SYSTEM:
                 xmlGenericError(xmlGenericErrorContext,
                         "Setting catalog preference to SYSTEM\n");
                 break;
-            case XML_CATA_PREFER_NONE:
-                break;
+            default:
+                return(ret);
         }
     }
     xmlCatalogDefaultPrefer = prefer;
     return(ret);
 }
 
 /**
  * xmlCatalogSetDebug:
  * @level:  the debug level of catalogs required
  *
@@ skipping 40 matching lines @@
 
 /**
  * xmlCatalogAddLocal:
  * @catalogs:  a document's list of catalogs
  * @URL:  the URL to a new local catalog
  *
  * Add the new entry to the catalog list
  *
  * Returns the updated list
  */
-void *  
+void *
 xmlCatalogAddLocal(void *catalogs, const xmlChar *URL) {
     xmlCatalogEntryPtr catal, add;
 
     if (!xmlCatalogInitialized)
         xmlInitializeCatalog();
 
     if (URL == NULL)
         return(catalogs);
 
     if (xmlDebugCatalogs)
         xmlGenericError(xmlGenericErrorContext,
                 "Adding document catalog %s\n", URL);
 
     add = xmlNewCatalogEntry(XML_CATA_CATALOG, NULL, URL, NULL,
                              xmlCatalogDefaultPrefer, NULL);
     if (add == NULL)
         return(catalogs);
 
     catal = (xmlCatalogEntryPtr) catalogs;
-    if (catal == NULL) 
+    if (catal == NULL)
         return((void *) add);
 
     while (catal->next != NULL)
         catal = catal->next;
     catal->next = add;
     return(catalogs);
 }
 
 /**
  * xmlCatalogLocalResolve:
  * @catalogs:  a document's list of catalogs
  * @pubID:  the public ID string
  * @sysID:  the system ID string
  *
- * Do a complete resolution lookup of an External Identifier using a 
+ * Do a complete resolution lookup of an External Identifier using a
  * document's private catalog list
  *
  * Returns the URI of the resource or NULL if not found, it must be freed
  *      by the caller.
  */
 xmlChar *
 xmlCatalogLocalResolve(void *catalogs, const xmlChar *pubID,
                        const xmlChar *sysID) {
     xmlCatalogEntryPtr catal;
     xmlChar *ret;
@@ skipping 24 matching lines @@
     if ((ret != NULL) && (ret != XML_CATAL_BREAK))
         return(ret);
     return(NULL);
 }
 
 /**
  * xmlCatalogLocalResolveURI:
  * @catalogs:  a document's list of catalogs
  * @URI:  the URI
  *
- * Do a complete resolution lookup of an URI using a 
+ * Do a complete resolution lookup of an URI using a
  * document's private catalog list
  *
  * Returns the URI of the resource or NULL if not found, it must be freed
  *      by the caller.
  */
 xmlChar *
 xmlCatalogLocalResolveURI(void *catalogs, const xmlChar *URI) {
     xmlCatalogEntryPtr catal;
     xmlChar *ret;
 
@@ skipping 40 matching lines @@
         xmlInitializeCatalog();
 
     if (msg == 0) {
         xmlGenericError(xmlGenericErrorContext,
                 "Use of deprecated xmlCatalogGetSystem() call\n");
         msg++;
     }
 
     if (sysID == NULL)
         return(NULL);
-    
+
     /*
      * Check first the XML catalogs
      */
     if (xmlDefaultCatalog != NULL) {
         ret = xmlCatalogListXMLResolve(xmlDefaultCatalog->xml, NULL, sysID);
         if ((ret != NULL) && (ret != XML_CATAL_BREAK)) {
             snprintf((char *) result, sizeof(result) - 1, "%s", (char *) ret);
             result[sizeof(result) - 1] = 0;
             return(result);
         }
@@ skipping 23 matching lines @@
         xmlInitializeCatalog();
 
     if (msg == 0) {
         xmlGenericError(xmlGenericErrorContext,
                 "Use of deprecated xmlCatalogGetPublic() call\n");
         msg++;
     }
 
     if (pubID == NULL)
         return(NULL);
-    
+
     /*
      * Check first the XML catalogs
      */
     if (xmlDefaultCatalog != NULL) {
         ret = xmlCatalogListXMLResolve(xmlDefaultCatalog->xml, 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->sgml, pubID));
     return(NULL);
 }
 
 #define bottom_catalog
 #include "elfgcchack.h"
 #endif /* LIBXML_CATALOG_ENABLED */