Roll libxslt to 8345634c5482ca04293ae1862d52fa9dd764aeca

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 17 matching lines @@
 struct _exsltFuncFunctionData {
     int nargs;                  /* number of arguments to the function */
     xmlNodePtr content;         /* the func:fuction template content */
 };
 
 typedef struct _exsltFuncData exsltFuncData;
 struct _exsltFuncData {
     xmlHashTablePtr funcs;      /* pointer to the stylesheet module data */
     xmlXPathObjectPtr result;   /* returned by func:result */
     int error;                  /* did an error occur? */
-    xmlDocPtr RVT;   /* result tree fragment */
 };
 
 typedef struct _exsltFuncResultPreComp exsltFuncResultPreComp;
 struct _exsltFuncResultPreComp {
     xsltElemPreComp comp;
     xmlXPathCompExprPtr select;
     xmlNsPtr *nsList;
     int nsNr;
 };
 
 /* Used for callback function in exsltInitFunc */
 typedef struct _exsltFuncImportRegData exsltFuncImportRegData;
 struct _exsltFuncImportRegData {
     xsltTransformContextPtr ctxt;
     xmlHashTablePtr hash;
 };
 
 static void exsltFuncFunctionFunction (xmlXPathParserContextPtr ctxt,
                                        int nargs);
 static exsltFuncFunctionData *exsltFuncNewFunctionData(void);
 
-#define MAX_FUNC_RECURSION 1000
-
 /*static const xmlChar *exsltResultDataID = (const xmlChar *) "EXSLT Result";*/
 
 /**
  * exsltFuncRegisterFunc:
  * @func:  the #exsltFuncFunctionData for the function
  * @ctxt:  an XSLT transformation context
  * @URI:  the function namespace URI
  * @name: the function name
  *
  * Registers a function declared by a func:function element
@@ skipping 254 matching lines @@
         paramNode = func->content->prev;
     }
     else
         paramNode = NULL;
     if ((paramNode == NULL) && (func->nargs != 0)) {
         xsltGenericError(xsltGenericErrorContext,
                          "exsltFuncFunctionFunction: nargs != 0 and "
                          "param == NULL\n");
         return;
     }
-    if (tctxt->funcLevel > MAX_FUNC_RECURSION) {
-        xsltGenericError(xsltGenericErrorContext,
-                         "{%s}%s: detected a recursion\n",
-                         ctxt->context->functionURI, ctxt->context->function);
-        ctxt->error = XPATH_MEMORY_ERROR;
-        return;
-    }
-    tctxt->funcLevel++;
 
     /*
      * We have a problem with the evaluation of function parameters.
      * The original library code did not evaluate XPath expressions until
      * the last moment.  After version 1.1.17 of the libxslt, the logic
      * of other parts of the library was changed, and the evaluation of
      * XPath expressions within parameters now takes place as soon as the
      * parameter is parsed/evaluated (xsltParseStylesheetCallerParam).
      * This means that the parameters need to be evaluated in lexical
      * order (since a variable is "in scope" as soon as it is declared).
@@ skipping 63 matching lines @@
     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);
 
     if (data->error != 0)
-        goto error;
+        return;
 
     if (data->result != NULL) {
         ret = data->result;
+        /*
+        * IMPORTANT: This enables previously tree fragments marked as
+        * being results of a function, to be garbage-collected after
+        * the calling process exits.
+        */
+        xsltFlagRVTs(tctxt, ret, XSLT_RVT_LOCAL);
     } else
         ret = xmlXPathNewCString("");
 
     data->result = oldResult;
 
     /*
      * It is an error if the instantiation of the template results in
      * the generation of result nodes.
      */
     if (fake->children != NULL) {
 #ifdef LIBXML_DEBUG_ENABLED
         xmlDebugDumpNode (stderr, fake, 1);
 #endif
         xsltGenericError(xsltGenericErrorContext,
                          "{%s}%s: cannot write to result tree while "
                          "executing a function\n",
                          ctxt->context->functionURI, ctxt->context->function);
         xmlFreeNode(fake);
-        goto error;
+        return;
     }
     xmlFreeNode(fake);
     valuePush(ctxt, ret);
-
-error:
-    /*
-    * IMPORTANT: This enables previously tree fragments marked as
-    * being results of a function, to be garbage-collected after
-    * the calling process exits.
-    */
-    xsltExtensionInstructionResultFinalize(tctxt);
-    tctxt->funcLevel--;
 }
 
 
 static void
 exsltFuncFunctionComp (xsltStylesheetPtr style, xmlNodePtr inst) {
     xmlChar *name, *prefix;
     xmlNsPtr ns;
     xmlHashTablePtr data;
     exsltFuncFunctionData *func;
 
@@ skipping 245 matching lines @@
 
         if (ret == NULL) {
             xsltGenericError(xsltGenericErrorContext,
                              "exsltFuncResultElem: ret == NULL\n");
             return;
         }
         /*
         * Mark it as a function result in order to avoid garbage
         * collecting of tree fragments before the function exits.
         */
-        xsltExtensionInstructionResultRegister(ctxt, ret);
+        xsltFlagRVTs(ctxt, ret, XSLT_RVT_FUNC_RESULT);
     } else if (inst->children != NULL) {
         /* If the func:result element does not have a select attribute
          * and has non-empty content (i.e. the func:result element has
          * one or more child nodes), then the content of the
          * func:result element specifies the value.
          */
         xmlNodePtr oldInsert;
         xmlDocPtr container;
 
         container = xsltCreateRVT(ctxt);
         if (container == NULL) {
             xsltGenericError(xsltGenericErrorContext,
                              "exsltFuncResultElem: out of memory\n");
             data->error = 1;
             return;
         }
-        xsltRegisterLocalRVT(ctxt, container);
+        /* Mark as function result. */
+        container->psvi = XSLT_RVT_FUNC_RESULT;
 
         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,
                              "exsltFuncResultElem: ret == NULL\n");
             data->error = 1;
         } else {
             ret->boolval = 0; /* Freeing is not handled there anymore */
-            /*
-            * Mark it as a function result in order to avoid garbage
-            * collecting of tree fragments before the function exits.
-            */
-            xsltExtensionInstructionResultRegister(ctxt, ret);
         }
     } else {
         /* If the func:result element has empty content and does not
          * have a select attribute, then the returned value is an
          * empty string.
          */
         ret = xmlXPathNewCString("");
     }
     data->result = ret;
 }
@@ skipping 12 matching lines @@
                        (xsltStyleExtShutdownFunction) exsltFuncStyleShutdown);
 
     xsltRegisterExtModuleTopLevel ((const xmlChar *) "function",
                                    EXSLT_FUNCTIONS_NAMESPACE,
                                    exsltFuncFunctionComp);
     xsltRegisterExtModuleElement ((const xmlChar *) "result",
                           EXSLT_FUNCTIONS_NAMESPACE,
                           (xsltPreComputeFunction)exsltFuncResultComp,
                           (xsltTransformFunction) exsltFuncResultElem);
 }