Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libexslt/functions.c

 #define IN_LIBEXSLT
 #include "libexslt/libexslt.h"
 
 #if defined(WIN32) && !defined (__CYGWIN__) && (!__MINGW32__)
 #include <win32config.h>
 #else
 #include "config.h"
 #endif
 
 #include <string.h>
@@ skipping 88 matching lines @@
 exsltFuncRegisterImportFunc (exsltFuncFunctionData *data,
                              exsltFuncImportRegData *ch,
                              const xmlChar *URI, const xmlChar *name,
                              ATTRIBUTE_UNUSED const xmlChar *ignored) {
     exsltFuncFunctionData *func=NULL;
 
     if ((data == NULL) || (ch == NULL) || (URI == NULL) || (name == NULL))
             return;
 
     if (ch->ctxt == NULL || ch->hash == NULL)
-        return;
+        return;
 
     /* Check if already present */
     func = (exsltFuncFunctionData*)xmlHashLookup2(ch->hash, URI, name);
     if (func == NULL) {         /* Not yet present - copy it in */
-        func = exsltFuncNewFunctionData();
+        func = exsltFuncNewFunctionData();
+        if (func == NULL)
+            return;
         memcpy(func, data, sizeof(exsltFuncFunctionData));
         if (xmlHashAddEntry2(ch->hash, URI, name, func) < 0) {
             xsltGenericError(xsltGenericErrorContext,
-                    "Failed to register function {%s}%s\n",
+                    "Failed to register function {%s}%s\n",
                     URI, name);
         } else {                /* Do the registration */
             xsltGenericDebug(xsltGenericDebugContext,
                     "exsltFuncRegisterImportFunc: register {%s}%s\n",
                     URI, name);
             xsltRegisterExtFunction(ch->ctxt, name, URI,
                     exsltFuncFunctionFunction);
         }
     }
 }
@@ skipping 10 matching lines @@
  * functions with lower import precedence.
  *
  * Returns the data for this transformation
  */
 static exsltFuncData *
 exsltFuncInit (xsltTransformContextPtr ctxt, const xmlChar *URI) {
     exsltFuncData *ret;
     xsltStylesheetPtr tmp;
     exsltFuncImportRegData ch;
     xmlHashTablePtr hash;
-    
+
     ret = (exsltFuncData *) xmlMalloc (sizeof(exsltFuncData));
     if (ret == NULL) {
         xsltGenericError(xsltGenericErrorContext,
                          "exsltFuncInit: not enough memory\n");
         return(NULL);
     }
     memset(ret, 0, sizeof(exsltFuncData));
 
     ret->result = NULL;
     ret->error = 0;
 
     ch.hash = (xmlHashTablePtr) xsltStyleGetExtData(ctxt->style, URI);
     ret->funcs = ch.hash;
     xmlHashScanFull(ch.hash, (xmlHashScannerFull) exsltFuncRegisterFunc, ctxt);
     tmp = ctxt->style;
     ch.ctxt = ctxt;
     while ((tmp=xsltNextImport(tmp))!=NULL) {
         hash = xsltGetExtInfo(tmp, URI);
         if (hash != NULL) {
-            xmlHashScanFull(hash, 
+            xmlHashScanFull(hash,
                     (xmlHashScannerFull) exsltFuncRegisterImportFunc, &ch);
         }
     }
 
     return(ret);
 }
 
 /**
  * exsltFuncShutdown:
  * @ctxt: an XSLT transformation context
  * @URI: the namespace URI for the extension
  * @data: the module data to free up
- *  
+ *
  * Shutdown the EXSLT - Functions module
  * Called at transformation-time.
  */
 static void
 exsltFuncShutdown (xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED,
                    const xmlChar *URI ATTRIBUTE_UNUSED,
                    exsltFuncData *data) {
     if (data->result != NULL)
         xmlXPathFreeObject(data->result);
     xmlFree(data);
@@ skipping 12 matching lines @@
 static xmlHashTablePtr
 exsltFuncStyleInit (xsltStylesheetPtr style ATTRIBUTE_UNUSED,
                     const xmlChar *URI ATTRIBUTE_UNUSED) {
     return xmlHashCreate(1);
 }
 
 /**
  * exsltFuncStyleShutdown:
  * @style: an XSLT stylesheet
  * @URI: the namespace URI for the extension
- * @data: the stylesheet data to free up 
+ * @data: the stylesheet data to free up
  *
  * Shutdown the EXSLT - Function module
  * Called at compile-time.
  */
 static void
 exsltFuncStyleShutdown (xsltStylesheetPtr style ATTRIBUTE_UNUSED,
                         const xmlChar *URI ATTRIBUTE_UNUSED,
                         xmlHashTablePtr data) {
     xmlHashFree(data, (xmlHashDeallocator) xmlFree);
 }
@@ skipping 117 matching lines @@
      * order (since a variable is "in scope" as soon as it is declared).
      * However, on entry to this routine, the values (from the caller) are
      * in reverse order (held on the XPath context variable stack).  To
      * accomplish what is required, I have added code to pop the XPath
      * objects off of the stack at the beginning and save them, then use
      * them (in the reverse order) as the params are evaluated.  This
      * requires an xmlMalloc/xmlFree for each param set by the caller,
      * which is not very nice.  There is probably a much better solution
      * (like change other code to delay the evaluation).
      */
-    /* 
+    /*
      * In order to give the function params and variables a new 'scope'
      * we change varsBase in the context.
      */
     oldBase = tctxt->varsBase;
     tctxt->varsBase = tctxt->varsNr;
     /* If there are any parameters */
     if (paramNode != NULL) {
         /* Fetch the stored argument values from the caller */
         for (i = 0; i < nargs; i++) {
             savedObj = xmlMalloc(sizeof(struct objChain));
@@ skipping 40 matching lines @@
     fake = xmlNewDocNode(tctxt->output, NULL,
                          (const xmlChar *)"fake", NULL);
     oldInsert = tctxt->insert;
     tctxt->insert = fake;
     xsltApplyOneTemplate (tctxt, xmlXPathGetContextNode(ctxt),
                           func->content, NULL, NULL);
     xsltLocalVariablePop(tctxt, tctxt->varsBase, -2);
     tctxt->insert = oldInsert;
     tctxt->varsBase = oldBase;  /* restore original scope */
     if (params != NULL)
-        xsltFreeStackElemList(params);    
+        xsltFreeStackElemList(params);
 
     if (data->error != 0)
         goto error;
 
     if (data->result != NULL) {
         ret = data->result;
     } else
         ret = xmlXPathNewCString("");
 
     data->result = oldResult;
@@ skipping 27 matching lines @@
 }
 
 
 static void
 exsltFuncFunctionComp (xsltStylesheetPtr style, xmlNodePtr inst) {
     xmlChar *name, *prefix;
     xmlNsPtr ns;
     xmlHashTablePtr data;
     exsltFuncFunctionData *func;
 
-    if ((style == NULL) || (inst == NULL))
+    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
         return;
 
-
     {
         xmlChar *qname;
 
         qname = xmlGetProp(inst, (const xmlChar *) "name");
         name = xmlSplitQName2 (qname, &prefix);
         xmlFree(qname);
     }
     if ((name == NULL) || (prefix == NULL)) {
         xsltGenericError(xsltGenericErrorContext,
                          "func:function: not a QName\n");
         if (name != NULL)
             xmlFree(name);
         return;
     }
     /* namespace lookup */
     ns = xmlSearchNs (inst->doc, inst, prefix);
     if (ns == NULL) {
         xsltGenericError(xsltGenericErrorContext,
                          "func:function: undeclared prefix %s\n",
                          prefix);
         xmlFree(name);
         xmlFree(prefix);
         return;
     }
     xmlFree(prefix);
 
+    xsltParseTemplateContent(style, inst);
+
     /*
      * Create function data
      */
     func = exsltFuncNewFunctionData();
+    if (func == NULL) {
+        xmlFree(name);
+        return;
+    }
     func->content = inst->children;
     while (IS_XSLT_ELEM(func->content) &&
            IS_XSLT_NAME(func->content, "param")) {
         func->content = func->content->next;
         func->nargs++;
     }
 
-    xsltParseTemplateContent(style, inst);
-
     /*
      * Register the function data such that it can be retrieved
      * by exslFuncFunctionFunction
      */
 #ifdef XSLT_REFACTORED
     /*
     * Ensure that the hash table will be stored in the *current*
     * stylesheet level in order to correctly evaluate the
     * import precedence.
     */
@@ skipping 24 matching lines @@
     xmlFree(name);
 }
 
 static xsltElemPreCompPtr
 exsltFuncResultComp (xsltStylesheetPtr style, xmlNodePtr inst,
                      xsltTransformFunction function) {
     xmlNodePtr test;
     xmlChar *sel;
     exsltFuncResultPreComp *ret;
 
+    if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
+        return (NULL);
+
     /*
      * "Validity" checking
      */
     /* it is an error to have any following sibling elements aside
      * from the xsl:fallback element.
      */
     for (test = inst->next; test != NULL; test = test->next) {
         if (test->type != XML_ELEMENT_NODE)
             continue;
         if (IS_XSLT_ELEM(test) && IS_XSLT_NAME(test, "fallback"))
             continue;
         xsltGenericError(xsltGenericErrorContext,
                          "exsltFuncResultElem: only xsl:fallback is "
                          "allowed to follow func:result\n");
+        style->errors++;
         return (NULL);
     }
     /* it is an error for a func:result element to not be a descendant
      * of func:function.
      * it is an error if a func:result occurs within a func:result
      * element.
      * it is an error if instanciating the content of a variable
-     * binding element (i.e. xsl:variable, xsl:param) results in the 
+     * binding element (i.e. xsl:variable, xsl:param) results in the
      * instanciation of a func:result element.
      */
     for (test = inst->parent; test != NULL; test = test->parent) {
         if (IS_XSLT_ELEM(test) &&
             IS_XSLT_NAME(test, "stylesheet")) {
             xsltGenericError(xsltGenericErrorContext,
                              "func:result element not a descendant "
                              "of a func:function\n");
+            style->errors++;
             return (NULL);
         }
         if ((test->ns != NULL) &&
             (xmlStrEqual(test->ns->href, EXSLT_FUNCTIONS_NAMESPACE))) {
             if (xmlStrEqual(test->name, (const xmlChar *) "function")) {
                 break;
             }
             if (xmlStrEqual(test->name, (const xmlChar *) "result")) {
                 xsltGenericError(xsltGenericErrorContext,
                                  "func:result element not allowed within"
                                  " another func:result element\n");
+                style->errors++;
                 return (NULL);
             }
         }
         if (IS_XSLT_ELEM(test) &&
             (IS_XSLT_NAME(test, "variable") ||
              IS_XSLT_NAME(test, "param"))) {
             xsltGenericError(xsltGenericErrorContext,
                              "func:result element not allowed within"
                              " a variable binding element\n");
+            style->errors++;
             return (NULL);
         }
     }
 
     /*
      * Precomputation
      */
     ret = (exsltFuncResultPreComp *)
         xmlMalloc (sizeof(exsltFuncResultPreComp));
     if (ret == NULL) {
         xsltPrintErrorContext(NULL, NULL, NULL);
         xsltGenericError(xsltGenericErrorContext,
                          "exsltFuncResultComp : malloc failed\n");
+        style->errors++;
         return (NULL);
     }
     memset(ret, 0, sizeof(exsltFuncResultPreComp));
 
     xsltInitElemPreComp ((xsltElemPreCompPtr) ret, style, inst, function,
                  (xsltElemPreCompDeallocator) exsltFreeFuncResultPreComp);
     ret->select = NULL;
 
     /*
      * Precompute the select attribute
@@ skipping 15 matching lines @@
     }
     return ((xsltElemPreCompPtr) ret);
 }
 
 static void
 exsltFuncResultElem (xsltTransformContextPtr ctxt,
                      xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr inst,
                      exsltFuncResultPreComp *comp) {
     exsltFuncData *data;
     xmlXPathObjectPtr ret;
-    
+
 
     /* It is an error if instantiating the content of the
      * func:function element results in the instantiation of more than
      * one func:result elements.
      */
     data = (exsltFuncData *) xsltGetExtData (ctxt, EXSLT_FUNCTIONS_NAMESPACE);
     if (data == NULL) {
         xsltGenericError(xsltGenericErrorContext,
                          "exsltFuncReturnElem: data == NULL\n");
         return;
@@ skipping 55 matching lines @@
         xmlNodePtr oldInsert;
         xmlDocPtr container;
 
         container = xsltCreateRVT(ctxt);
         if (container == NULL) {
             xsltGenericError(xsltGenericErrorContext,
                              "exsltFuncResultElem: out of memory\n");
             data->error = 1;
             return;
         }
-        xsltRegisterLocalRVT(ctxt, container);  
+        xsltRegisterLocalRVT(ctxt, container);
 
         oldInsert = ctxt->insert;
         ctxt->insert = (xmlNodePtr) container;
         xsltApplyOneTemplate (ctxt, ctxt->xpathCtxt->node,
                               inst->children, NULL, NULL);
         ctxt->insert = oldInsert;
 
         ret = xmlXPathNewValueTree((xmlNodePtr) container);
         if (ret == NULL) {
             xsltGenericError(xsltGenericErrorContext,
@@ skipping 31 matching lines @@
                        (xsltStyleExtShutdownFunction) exsltFuncStyleShutdown);
 
     xsltRegisterExtModuleTopLevel ((const xmlChar *) "function",
                                    EXSLT_FUNCTIONS_NAMESPACE,
                                    exsltFuncFunctionComp);
     xsltRegisterExtModuleElement ((const xmlChar *) "result",
                           EXSLT_FUNCTIONS_NAMESPACE,
                           (xsltPreComputeFunction)exsltFuncResultComp,
                           (xsltTransformFunction) exsltFuncResultElem);
 }