Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libxslt/extensions.c

 /*
  * extensions.c: Implemetation of the extensions support
  *
  * Reference:
  *   http://www.w3.org/TR/1999/REC-xslt-19991116
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
@@ skipping 26 matching lines @@
 #ifndef PATH_MAX
 #define PATH_MAX _MAX_PATH
 #endif
 #endif
 
 #ifdef WITH_XSLT_DEBUG
 #define WITH_XSLT_DEBUG_EXTENSIONS
 #endif
 
 /************************************************************************
- *                                                                      *
- *                      Private Types and Globals                       *
- *                                                                      *
+ *                                                                      *
+ *                      Private Types and Globals                       *
+ *                                                                      *
  ************************************************************************/
 
 typedef struct _xsltExtDef xsltExtDef;
 typedef xsltExtDef *xsltExtDefPtr;
 struct _xsltExtDef {
     struct _xsltExtDef *next;
     xmlChar *prefix;
     xmlChar *URI;
     void *data;
 };
@@ skipping 22 matching lines @@
 };
 
 static xmlHashTablePtr xsltExtensionsHash = NULL;
 static xmlHashTablePtr xsltFunctionsHash = NULL;
 static xmlHashTablePtr xsltElementsHash = NULL;
 static xmlHashTablePtr xsltTopLevelsHash = NULL;
 static xmlHashTablePtr xsltModuleHash = NULL;
 static xmlMutexPtr xsltExtMutex = NULL;
 
 /************************************************************************
- *                                                                      *
- *                      Type functions                                  *
- *                                                                      *
+ *                                                                      *
+ *                      Type functions                                  *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xsltNewExtDef:
  * @prefix:  the extension prefix
  * @URI:  the namespace URI
  *
  * Create a new XSLT ExtDef
  *
  * Returns the newly allocated xsltExtDefPtr or NULL in case of error
@@ skipping 190 matching lines @@
 
 #ifndef PATH_MAX
 #define PATH_MAX 4096
 #endif
 
 /**
  * xsltExtModuleRegisterDynamic:
  * @URI:  the function or element namespace URI
  *
  * Dynamically loads an extension plugin when available.
- * 
- * The plugin name is derived from the URI by removing the 
+ *
+ * The plugin name is derived from the URI by removing the
  * initial protocol designation, e.g. "http://", then converting
  * the characters ".", "-", "/", and "\" into "_", the removing
  * any trailing "/", then concatenating LIBXML_MODULE_EXTENSION.
- * 
- * Plugins are loaded from the directory specified by the 
- * environment variable LIBXSLT_PLUGINS_PATH, or if NULL, 
+ *
+ * Plugins are loaded from the directory specified by the
+ * environment variable LIBXSLT_PLUGINS_PATH, or if NULL,
  * by LIBXSLT_DEFAULT_PLUGINS_PATH() which is determined at
  * compile time.
  *
- * Returns 0 if successful, -1 in case of error. 
+ * Returns 0 if successful, -1 in case of error.
  */
 
 static int
 xsltExtModuleRegisterDynamic(const xmlChar * URI)
 {
 
     xmlModulePtr m;
     exsltRegisterFunction regfunc;
     xmlChar *ext_name;
     char module_filename[PATH_MAX];
@@ skipping 57 matching lines @@
                        "LIBXSLT_PLUGINS_PATH is %s\n", ext_directory);
 #endif
 
     /* build the module filename, and confirm the module exists */
     xmlStrPrintf((xmlChar *) module_filename, sizeof(module_filename),
                  BAD_CAST "%s/%s%s",
                  ext_directory, ext_name, LIBXML_MODULE_EXTENSION);
 
 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
     xsltGenericDebug(xsltGenericDebugContext,
-                     "Attempting to load plugin: %s for URI: %s\n", 
+                     "Attempting to load plugin: %s for URI: %s\n",
                      module_filename, URI);
 #endif
 
     if (1 != xmlCheckFilename(module_filename)) {
 
 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
         xsltGenericDebug(xsltGenericDebugContext,
                      "xmlCheckFilename failed for plugin: %s\n", module_filename);
 #endif
 
@@ skipping 30 matching lines @@
         (*regfunc) ();
 
         /* register this module in our hash */
         xmlMutexLock(xsltExtMutex);
         xmlHashAddEntry(xsltModuleHash, URI, (void *) m);
         xmlMutexUnlock(xsltExtMutex);
     } else {
 
 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
         xsltGenericDebug(xsltGenericDebugContext,
-                     "xmlModuleSymbol failed for plugin: %s, regfunc: %s\n", 
+                     "xmlModuleSymbol failed for plugin: %s, regfunc: %s\n",
                      module_filename, regfunc_name);
 #endif
 
         /* if regfunc not found unload the module immediately */
         xmlModuleClose(m);
     }
 
     xmlFree(ext_name);
     xmlFree(regfunc_name);
     return (NULL == regfunc) ? -1 : 0;
 }
 #else
 static int
 xsltExtModuleRegisterDynamic(const xmlChar * URI ATTRIBUTE_UNUSED)
 {
   return -1;
 }
 #endif
 
 /************************************************************************
- *                                                                      *
- *              The stylesheet extension prefixes handling              *
- *                                                                      *
+ *                                                                      *
+ *              The stylesheet extension prefixes handling              *
+ *                                                                      *
  ************************************************************************/
 
 
 /**
  * xsltFreeExts:
  * @style: an XSLT stylesheet
  *
  * Free up the memory used by XSLT extensions in a stylesheet
  */
 void
 xsltFreeExts(xsltStylesheetPtr style)
 {
     if (style->nsDefs != NULL)
         xsltFreeExtDefList((xsltExtDefPtr) style->nsDefs);
 }
 
 /**
  * xsltRegisterExtPrefix:
  * @style: an XSLT stylesheet
  * @prefix: the prefix used (optional)
  * @URI: the URI associated to the extension
- * 
+ *
  * Registers an extension namespace
  * This is called from xslt.c during compile-time.
  * The given prefix is not needed.
  * Called by:
  *   xsltParseExtElemPrefixes() (new function)
  *   xsltRegisterExtPrefix() (old function)
  *
  * Returns 0 in case of success, 1 if the @URI was already
  *         registered as an extension namespace and
  *         -1 in case of failure
@@ skipping 59 matching lines @@
         }
         if (module != NULL) {
             xsltStyleGetExtData(style, URI);
         }
     }
 #endif
     return (0);
 }
 
 /************************************************************************
- *                                                                      *
- *              The extensions modules interfaces                       *
- *                                                                      *
+ *                                                                      *
+ *              The extensions modules interfaces                       *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xsltRegisterExtFunction:
  * @ctxt: an XSLT transformation context
  * @name: the name of the element
  * @URI: the URI associated to the element
- * @function: the actual implementation which should be called 
+ * @function: the actual implementation which should be called
  *
  * Registers an extension function
  *
  * Returns 0 in case of success, -1 in case of failure
  */
 int
 xsltRegisterExtFunction(xsltTransformContextPtr ctxt, const xmlChar * name,
                         const xmlChar * URI, xmlXPathFunction function)
 {
     int ret;
@@ skipping 13 matching lines @@
                            XML_CAST_FPTR(function));
 
     return(ret);
 }
 
 /**
  * xsltRegisterExtElement:
  * @ctxt: an XSLT transformation context
  * @name: the name of the element
  * @URI: the URI associated to the element
- * @function: the actual implementation which should be called 
+ * @function: the actual implementation which should be called
  *
  * Registers an extension element
  *
  * Returns 0 in case of success, -1 in case of failure
  */
 int
 xsltRegisterExtElement(xsltTransformContextPtr ctxt, const xmlChar * name,
                        const xmlChar * URI, xsltTransformFunction function)
 {
     if ((ctxt == NULL) || (name == NULL) ||
@@ skipping 34 matching lines @@
  * Returns the create module-data container
  *         or NULL if such a module was not registered.
  */
 static xsltExtDataPtr
 xsltStyleInitializeStylesheetModule(xsltStylesheetPtr style,
                                      const xmlChar * URI)
 {
     xsltExtDataPtr dataContainer;
     void *userData = NULL;
     xsltExtModulePtr module;
-    
-    if ((style == NULL) || (URI == NULL))       
+
+    if ((style == NULL) || (URI == NULL))
         return(NULL);
 
     if (xsltExtensionsHash == NULL) {
 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
         xsltGenericDebug(xsltGenericDebugContext,
             "Not registered extension module: %s\n", URI);
 #endif
         return(NULL);
     }
 
@@ skipping 28 matching lines @@
 #endif
     } else {
 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
         xsltGenericDebug(xsltGenericDebugContext,
             "Initializing module with callback: %s\n", URI);
 #endif
         /*
         * Fire the initialization callback.
         */
         userData = module->styleInitFunc(style, URI);
-    }    
+    }
     /*
     * Store the user-data in the context of the given stylesheet.
     */
     dataContainer = xsltNewExtData(module, userData);
     if (dataContainer == NULL)
         return (NULL);
 
     if (xmlHashAddEntry(style->extInfos, URI,
         (void *) dataContainer) < 0)
     {
-        xsltTransformError(NULL, style, NULL,       
+        xsltTransformError(NULL, style, NULL,
             "Failed to register module '%s'.\n", URI);
         style->errors++;
         if (module->styleShutdownFunc)
             module->styleShutdownFunc(style, URI, userData);
         xsltFreeExtData(dataContainer);
         return (NULL);
     }
 
     return(dataContainer);
 }
@@ skipping 14 matching lines @@
 void *
 xsltStyleGetExtData(xsltStylesheetPtr style, const xmlChar * URI)
 {
     xsltExtDataPtr dataContainer = NULL;
     xsltStylesheetPtr tmpStyle;
 
     if ((style == NULL) || (URI == NULL) ||
         (xsltExtensionsHash == NULL))
         return (NULL);
 
-    
+
 #ifdef XSLT_REFACTORED
     /*
     * This is intended for global storage, so only the main
     * stylesheet will hold the data.
     */
     tmpStyle = style;
     while (tmpStyle->parent != NULL)
         tmpStyle = tmpStyle->parent;
     if (tmpStyle->extInfos != NULL) {
         dataContainer =
@@ skipping 55 matching lines @@
 
     if (style->extInfos != NULL) {
         dataContainer = (xsltExtDataPtr) xmlHashLookup(style->extInfos, URI);
         /*
         * The module was already initialized in the context
         * of this stylesheet; just return the user-data that
         * comes with it.
         */
         if (dataContainer)
             return(dataContainer->extData);
-    }  
+    }
 
     dataContainer =
         xsltStyleInitializeStylesheetModule(style, URI);
     if (dataContainer != NULL)
         return (dataContainer->extData);
     return(NULL);
 }
 #endif
 
 /**
@@ skipping 261 matching lines @@
     xsltGenericDebug(xsltGenericDebugContext,
                      "Shutting down module : %s\n", URI);
 #endif
     module->styleShutdownFunc(style, URI, data->extData);
     /*
     * Don't remove the entry from the hash table here, since
     * this will produce segfaults - this fixes bug #340624.
     *
     * xmlHashRemoveEntry(style->extInfos, URI,
     *   (xmlHashDeallocator) xsltFreeExtData);
-    */    
+    */
 }
 
 /**
  * xsltShutdownExts:
  * @style: an XSLT stylesheet
  *
  * Shutdown the set of modules loaded
  */
 void
 xsltShutdownExts(xsltStylesheetPtr style)
@@ skipping 15 matching lines @@
  * Check if the given prefix is one of the declared extensions.
  * This is intended to be called only at compile-time.
  * Called by:
  *  xsltGetInheritedNsList() (xslt.c)
  *  xsltParseTemplateContent (xslt.c)
  *
  * Returns 1 if this is an extension, 0 otherwise
  */
 int
 xsltCheckExtPrefix(xsltStylesheetPtr style, const xmlChar * URI)
-{    
+{
 #ifdef XSLT_REFACTORED
     if ((style == NULL) || (style->compCtxt == NULL) ||
         (XSLT_CCTXT(style)->inode == NULL) ||
         (XSLT_CCTXT(style)->inode->extElemNs == NULL))
-        return (0);    
+        return (0);
     /*
     * Lookup the extension namespaces registered
     * at the current node in the stylesheet's tree.
     */
     if (XSLT_CCTXT(style)->inode->extElemNs != NULL) {
         int i;
         xsltPointerListPtr list = XSLT_CCTXT(style)->inode->extElemNs;
 
         for (i = 0; i < list->number; i++) {
             if (xmlStrEqual((const xmlChar *) list->items[i],
                 URI))
             {
                 return(1);
-            }       
+            }
         }
     }
 #else
     xsltExtDefPtr cur;
 
     if ((style == NULL) || (style->nsDefs == NULL))
         return (0);
     if (URI == NULL)
         URI = BAD_CAST "#default";
     cur = (xsltExtDefPtr) style->nsDefs;
@@ skipping 426 matching lines @@
  *
  * Registers an extension module element.
  *
  * Returns 0 if successful, -1 in case of error.
  */
 int
 xsltRegisterExtModuleElement(const xmlChar * name, const xmlChar * URI,
                              xsltPreComputeFunction precomp,
                              xsltTransformFunction transform)
 {
-    int ret;
+    int ret = 0;
 
     xsltExtElementPtr ext;
 
     if ((name == NULL) || (URI == NULL) || (transform == NULL))
         return (-1);
 
     if (xsltElementsHash == NULL)
         xsltElementsHash = xmlHashCreate(10);
     if (xsltElementsHash == NULL)
         return (-1);
 
     xmlMutexLock(xsltExtMutex);
 
     ext = xsltNewExtElement(precomp, transform);
     if (ext == NULL) {
         ret = -1;
         goto done;
     }
 
     xmlHashUpdateEntry2(xsltElementsHash, name, URI, (void *) ext,
                         (xmlHashDeallocator) xsltFreeExtElement);
 
 done:
     xmlMutexUnlock(xsltExtMutex);
 
-    return (0);
+    return (ret);
 }
 
 /**
  * xsltExtElementLookup:
  * @ctxt:  an XSLT process context
  * @name:  the element name
  * @URI:  the element namespace URI
  *
  * Looks up an extension element. @ctxt can be NULL to search only in
  * module elements.
@@ skipping 281 matching lines @@
 
     if (style != NULL && style->extInfos != NULL) {
         data = xmlHashLookup(style->extInfos, URI);
         if (data != NULL && data->extData != NULL)
             return data->extData;
     }
     return NULL;
 }
 
 /************************************************************************
- *                                                                      *
- *              Test module http://xmlsoft.org/XSLT/                    *
- *                                                                      *
+ *                                                                      *
+ *              Test module http://xmlsoft.org/XSLT/                    *
+ *                                                                      *
  ************************************************************************/
 
 /************************************************************************
- *                                                                      *
- *              Test of the extension module API                        *
- *                                                                      *
+ *                                                                      *
+ *              Test of the extension module API                        *
+ *                                                                      *
  ************************************************************************/
 
 static xmlChar *testData = NULL;
 static xmlChar *testStyleData = NULL;
 
 /**
  * xsltExtFunctionTest:
  * @ctxt:  the XPath Parser context
  * @nargs:  the number of arguments
  *
@@ skipping 310 matching lines @@
     /* cleanup dynamic module hash */
     if (NULL != xsltModuleHash) {
         xmlHashScan(xsltModuleHash, xsltHashScannerModuleFree, 0);
         xmlHashFree(xsltModuleHash, NULL);
         xsltModuleHash = NULL;
     }
     xmlMutexUnlock(xsltExtMutex);
 
     xmlFreeMutex(xsltExtMutex);
     xsltExtMutex = NULL;
+    xsltFreeLocales();
     xsltUninit();
 }
 
 static void
 xsltDebugDumpExtensionsCallback(void *function ATTRIBUTE_UNUSED,
                                 FILE * output, const xmlChar * name,
                                 const xmlChar * URI,
                                 const xmlChar * not_used ATTRIBUTE_UNUSED)
 {
     if (!name || !URI)
@@ skipping 50 matching lines @@
     else {
         fprintf(output, "\nRegistered Extension Modules:\n");
         xmlMutexLock(xsltExtMutex);
         xmlHashScanFull(xsltExtensionsHash,
                         (xmlHashScannerFull)
                         xsltDebugDumpExtModulesCallback, output);
         xmlMutexUnlock(xsltExtMutex);
     }
 
 }