自学教程：C++ valuePush函数代码示例

/** * xsltUnparsedEntityURIFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the unparsed-entity-uri() XSLT function *   string unparsed-entity-uri(string) */voidxsltUnparsedEntityURIFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlXPathObjectPtr obj;    xmlChar *str;    if ((nargs != 1) || (ctxt->value == NULL)) {        xsltGenericError(xsltGenericErrorContext,		"unparsed-entity-uri() : expects one string arg/n");	ctxt->error = XPATH_INVALID_ARITY;	return;    }    obj = valuePop(ctxt);    if (obj->type != XPATH_STRING) {	obj = xmlXPathConvertString(obj);    }    str = obj->stringval;    if (str == NULL) {	valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));    } else {	xmlEntityPtr entity;	entity = xmlGetDocEntity(ctxt->context->doc, str);	if (entity == NULL) {	    valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));	} else {	    if (entity->URI != NULL)		valuePush(ctxt, xmlXPathNewString(entity->URI));	    else		valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));	}    }    xmlXPathFreeObject(obj);}

static voidexsltDynEvaluateFunction(xmlXPathParserContextPtr ctxt, int nargs) {	xmlChar *str = NULL;	xmlXPathObjectPtr ret = NULL;	if (ctxt == NULL)		return;	if (nargs != 1) {		xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);        xsltGenericError(xsltGenericErrorContext,			"dyn:evalute() : invalid number of args %d/n", nargs);		ctxt->error = XPATH_INVALID_ARITY;		return;	}	str = xmlXPathPopString(ctxt);		if (!str||!xmlStrlen(str)) {		if (str) xmlFree(str);		valuePush(ctxt,xmlXPathNewNodeSet(NULL));		return;	}	ret = xmlXPathEval(str,ctxt->context);	if (ret)		valuePush(ctxt,ret); 	else {		xsltGenericError(xsltGenericErrorContext,			"dyn:evaluate() : unable to evaluate expression '%s'/n",str);		valuePush(ctxt,xmlXPathNewNodeSet(NULL));	}		xmlFree(str);	return;}

/** * xsltElementAvailableFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the element-available() XSLT function *   boolean element-available(string) */voidxsltElementAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlXPathObjectPtr obj;    xmlChar *prefix, *name;    const xmlChar *nsURI = NULL;    xsltTransformContextPtr tctxt;    if (nargs != 1) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"element-available() : expects one string arg/n");	ctxt->error = XPATH_INVALID_ARITY;	return;    }    xmlXPathStringFunction(ctxt, 1);    if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,	    "element-available() : invalid arg expecting a string/n");	ctxt->error = XPATH_INVALID_TYPE;	return;    }    obj = valuePop(ctxt);    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"element-available() : internal error tctxt == NULL/n");	xmlXPathFreeObject(obj);	valuePush(ctxt, xmlXPathNewBoolean(0));	return;    }    name = xmlSplitQName2(obj->stringval, &prefix);    if (name == NULL) {	xmlNsPtr ns;	name = xmlStrdup(obj->stringval);	ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, NULL);	if (ns != NULL) nsURI = xmlStrdup(ns->href);    } else {	nsURI = xmlXPathNsLookup(ctxt->context, prefix);	if (nsURI == NULL) {	    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"element-available() : prefix %s is not bound/n", prefix);	}    }    if (xsltExtElementLookup(tctxt, name, nsURI) != NULL) {	valuePush(ctxt, xmlXPathNewBoolean(1));    } else {	valuePush(ctxt, xmlXPathNewBoolean(0));    }    xmlXPathFreeObject(obj);    if (name != NULL)	xmlFree(name);    if (prefix != NULL)	xmlFree(prefix);}

static voidgda_xslt_getnodeset_function (xmlXPathParserContextPtr ctxt, int nargs){	GdaXsltIntCont *data;	xsltTransformContextPtr tctxt;	xmlXPathObjectPtr setname, nodeset;	GdaXsltExCont *execc;	if (nargs != 1) {		xsltGenericError (xsltGenericErrorContext,				  "gda_xslt_getnodeset_function: invalid number of arguments/n");		return;	}	tctxt = xsltXPathGetTransformContext (ctxt);	if (tctxt == NULL) {		xsltGenericError (xsltGenericErrorContext,				  "sqlxslt: failed to get the transformation context/n");		return;	}	execc = (GdaXsltExCont *) tctxt->_private;	data = (GdaXsltIntCont *) xsltGetExtData (tctxt,						  BAD_CAST GDA_XSLT_EXTENSION_URI);	if (data == NULL) {		xsltGenericError (xsltGenericErrorContext,				  "sqlxslt: failed to get module data/n");		return;	}	setname = valuePop (ctxt);	if (setname == NULL) {		xsltGenericError (xsltGenericErrorContext,				  "sqlxslt: internal error/n");		return;	}	if (setname->type != XPATH_STRING) {		valuePush (ctxt, setname);		xmlXPathStringFunction (ctxt, 1);		setname = valuePop (ctxt);		if (setname == NULL) {			xsltGenericError (xsltGenericErrorContext,					  "sqlxslt: internal error/n");			return;		}	}	nodeset =		_gda_xslt_bk_fun_getnodeset (setname->stringval, execc, data);	if (nodeset == NULL) {		xsltGenericError (xsltGenericErrorContext,				  "exsltDynMapFunctoin: ret == NULL/n");		return;	}	valuePush (ctxt, nodeset);}

/** * xsltGenerateIdFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the generate-id() XSLT function *   string generate-id(node-set?) */voidxsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){    static char base_address;    xmlNodePtr cur = NULL;    xmlXPathObjectPtr obj = NULL;    long val;    xmlChar str[30];    if (nargs == 0) {	cur = ctxt->context->node;    } else if (nargs == 1) {	xmlNodeSetPtr nodelist;	int i, ret;	if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {	    ctxt->error = XPATH_INVALID_TYPE;	    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"generate-id() : invalid arg expecting a node-set/n");	    return;	}	obj = valuePop(ctxt);	nodelist = obj->nodesetval;	if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {	    xmlXPathFreeObject(obj);	    valuePush(ctxt, xmlXPathNewCString(""));	    return;	}	cur = nodelist->nodeTab[0];	for (i = 1;i < nodelist->nodeNr;i++) {	    ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);	    if (ret == -1)	        cur = nodelist->nodeTab[i];	}    } else {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"generate-id() : invalid number of args %d/n", nargs);	ctxt->error = XPATH_INVALID_ARITY;	return;    }    if (obj)        xmlXPathFreeObject(obj);    val = (long)((char *)cur - (char *)&base_address);    if (val >= 0) {      snprintf((char *)str, sizeof(str), "idp%ld", val);    } else {      snprintf((char *)str, sizeof(str), "idm%ld", -val);    }    valuePush(ctxt, xmlXPathNewString(str));}

/** * xsltGenerateIdFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the generate-id() XSLT function *   string generate-id(node-set?) */voidxsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlNodePtr cur = NULL;    unsigned long val;    xmlChar str[20];    if (nargs == 0) {	cur = ctxt->context->node;    } else if (nargs == 1) {	xmlXPathObjectPtr obj;	xmlNodeSetPtr nodelist;	int i, ret;	if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {	    ctxt->error = XPATH_INVALID_TYPE;	    xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),				  NULL, NULL);	    xsltGenericError(xsltGenericErrorContext,		"generate-id() : invalid arg expecting a node-set/n");	    return;	}	obj = valuePop(ctxt);	nodelist = obj->nodesetval;	if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {	    xmlXPathFreeObject(obj);	    valuePush(ctxt, xmlXPathNewCString(""));	    return;	}	cur = nodelist->nodeTab[0];	for (i = 1;i < nodelist->nodeNr;i++) {	    ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);	    if (ret == -1)	        cur = nodelist->nodeTab[i];	}	xmlXPathFreeObject(obj);    } else {	xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);        xsltGenericError(xsltGenericErrorContext,		"generate-id() : invalid number of args %d/n", nargs);	ctxt->error = XPATH_INVALID_ARITY;	return;    }    /*     * Okay this is ugly but should work, use the NodePtr address     * to forge the ID     */    val = (unsigned long)((char *)cur - (char *)0);    val /= sizeof(xmlNode);    sprintf((char *)str, "id%ld", val);    valuePush(ctxt, xmlXPathNewString(str));}

static void GDALGMLJP2XPathUUID(xmlXPathParserContextPtr ctxt, int nargs){    CHECK_ARITY(0);    CPLString osRet;    static int nCounter = 0;    srand(static_cast<unsigned int>(time(nullptr)) + nCounter);    ++nCounter;    for( int i=0; i<4; i ++ )        osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);    osRet += "-";    osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);    osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);    osRet += "-";    // Set the version number bits (4 == random).    osRet += GDALGMLJP2HexFormatter((rand() & 0x0F) | 0x40);    osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);    osRet += "-";    // Set the variant bits.    osRet += GDALGMLJP2HexFormatter((rand() & 0x3F) | 0x80);    osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);    osRet += "-";    for( int i = 0; i < 6; ++i )    {        // coverity[dont_call]        osRet += GDALGMLJP2HexFormatter(rand() & 0xFF);    }    valuePush(ctxt,              xmlXPathNewString(                  reinterpret_cast<const xmlChar *>(osRet.c_str())));}

/** * exsltStrReturnString: * @ctxt: an XPath parser context * @str: a string * @len: length of string * * Returns a string as a node set. */static intexsltStrReturnString(xmlXPathParserContextPtr ctxt, const xmlChar *str,                     int len){    xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);    xmlDocPtr container;    xmlNodePtr text_node;    xmlXPathObjectPtr ret;    container = xsltCreateRVT(tctxt);    if (container == NULL) {        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);        return(-1);    }    xsltRegisterLocalRVT(tctxt, container);    text_node = xmlNewTextLen(str, len);    if (text_node == NULL) {        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);        return(-1);    }    xmlAddChild((xmlNodePtr) container, text_node);    ret = xmlXPathNewNodeSet(text_node);    if (ret == NULL) {        xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);        return(-1);    }    xsltExtensionInstructionResultRegister(tctxt, ret);    valuePush(ctxt, ret);    return(0);}

static xmlChar *extBitStringVal (xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr xop){    if (xop->type == XPATH_NUMBER) {	xmlChar *res;	int width;	unsigned long long val = xop->floatval, v2;	if (xop->floatval >= pow(2, 64))	    val = (unsigned long long) -1;	xmlXPathFreeObject(xop);	for (width = 0, v2 = val; v2; width++, v2 /= 2)	    continue;	if (width == 0)		/* Gotta have one zero */	    width = 1;	res = xmlMalloc(width + 1);	if (res == NULL)	    return NULL;	res[width] = '/0';	for (width--, v2 = val; width >= 0; width--, v2 /= 2)	    res[width] = (v2 & 1) ? '1' : '0';	return res;    }    /* Make libxml do the work for us */    valuePush(ctxt, xop);    return xmlXPathPopString(ctxt);}

// FIXME: This code is taken from libexslt 1.1.11; should sync with newer versions.static void exsltNodeSetFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlChar *strval;    xmlNodePtr retNode;    xmlXPathObjectPtr ret;    if (nargs != 1) {        xmlXPathSetArityError(ctxt);        return;    }    if (xmlXPathStackIsNodeSet(ctxt)) {        xsltFunctionNodeSet(ctxt, nargs);        return;    }    strval = xmlXPathPopString(ctxt);    retNode = xmlNewDocText(NULL, strval);    ret = xmlXPathNewValueTree(retNode);    if (ret == NULL) {        xsltGenericError(xsltGenericErrorContext,                         "exsltNodeSetFunction: ret == NULL/n");    } else {        ret->type = XPATH_NODESET;    }    if (strval != NULL)        xmlFree(strval);    valuePush(ctxt, ret);}

// FIXME: This code is taken from libexslt 1.1.11; should sync with newer// versions.static void exsltNodeSetFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlChar* strval;    xmlNodePtr retNode;    xmlXPathObjectPtr ret;    if (nargs != 1) {        xmlXPathSetArityError(ctxt);        return;    }    if (xmlXPathStackIsNodeSet(ctxt)) {        xsltFunctionNodeSet(ctxt, nargs);        return;    }    strval = xmlXPathPopString(ctxt);    retNode = xmlNewDocText(0, strval);    ret = xmlXPathNewValueTree(retNode);    // FIXME: It might be helpful to push any errors from xmlXPathNewValueTree    // up to the Javascript Console.    if (ret)        ret->type = XPATH_NODESET;    if (strval)        xmlFree(strval);    valuePush(ctxt, ret);}

/** * xsltFunctionAvailableFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the function-available() XSLT function *   boolean function-available(string) */voidxsltFunctionAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlXPathObjectPtr obj;    xmlChar *prefix, *name;    const xmlChar *nsURI = NULL;    if (nargs != 1) {	xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);        xsltGenericError(xsltGenericErrorContext,		"function-available() : expects one string arg/n");	ctxt->error = XPATH_INVALID_ARITY;	return;    }    if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {	xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt), NULL, NULL);	xsltGenericError(xsltGenericErrorContext,	    "function-available() : invalid arg expecting a string/n");	ctxt->error = XPATH_INVALID_TYPE;	return;    }    obj = valuePop(ctxt);    name = xmlSplitQName2(obj->stringval, &prefix);    if (name == NULL) {	name = xmlStrdup(obj->stringval);    } else {	nsURI = xmlXPathNsLookup(ctxt->context, prefix);	if (nsURI == NULL) {	    xsltPrintErrorContext(xsltXPathGetTransformContext(ctxt),				  NULL, NULL);	    xsltGenericError(xsltGenericErrorContext,		"function-available() : prefix %s is not bound/n", prefix);	}    }    if (xmlXPathFunctionLookupNS(ctxt->context, name, nsURI) != NULL) {	valuePush(ctxt, xmlXPathNewBoolean(1));    } else {	valuePush(ctxt, xmlXPathNewBoolean(0));    }    xmlXPathFreeObject(obj);    if (name != NULL)	xmlFree(name);    if (prefix != NULL)	xmlFree(prefix);}

/************************************************************************** * * xmlSecXPathHereFunction: * @ctxt:               the ponter to XPath context. * @nargs:              the arguments nubmer. * * The implementation of XPath "here()" function. * See xmlXPtrHereFunction() in xpointer.c. the only change is that * we return NodeSet instead of NodeInterval. * *****************************************************************************/static voidxmlSecXPathHereFunction(xmlXPathParserContextPtr ctxt, int nargs) {    CHECK_ARITY(0);    if((ctxt == NULL) || (ctxt->context == NULL) || (ctxt->context->here == NULL)) {        XP_ERROR(XPTR_SYNTAX_ERROR);    }    valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->here));}

/** * xsltCurrentFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the current() XSLT function *   node-set current() */static voidxsltCurrentFunction(xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    if (nargs != 0) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"current() : function uses no argument/n");	ctxt->error = XPATH_INVALID_ARITY;	return;    }    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"current() : internal error tctxt == NULL/n");	valuePush(ctxt, xmlXPathNewNodeSet(NULL));    } else {	valuePush(ctxt, xmlXPathNewNodeSet(tctxt->node)); /* current */    }}

voidRXSLT_source(xmlXPathParserContextPtr ctxt, int nargs){   Rboolean ok;   xmlXPathObjectPtr obj;   obj = valuePop(ctxt);    ok = RXSLT_internalSource(xmlXPathCastToString(obj));   valuePush(ctxt, xmlXPathNewBoolean(ok));}

/** * xsltFormatNumberFunction: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the format-number() XSLT function *   string format-number(number, string, string?) */voidxsltFormatNumberFunction(xmlXPathParserContextPtr ctxt, int nargs){    xmlXPathObjectPtr numberObj = NULL;    xmlXPathObjectPtr formatObj = NULL;    xmlXPathObjectPtr decimalObj = NULL;    xsltStylesheetPtr sheet;    xsltDecimalFormatPtr formatValues;    xmlChar *result;    xsltTransformContextPtr tctxt;    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL)	return;    sheet = tctxt->style;    if (sheet == NULL)	return;    formatValues = sheet->decimalFormat;    switch (nargs) {    case 3:	CAST_TO_STRING;	decimalObj = valuePop(ctxt);	formatValues = xsltDecimalFormatGetByName(sheet, decimalObj->stringval);	if (formatValues == NULL) {	    xsltTransformError(tctxt, NULL, NULL,		    "format-number() : undeclared decimal format '%s'/n",		    decimalObj->stringval);	}	/* Intentional fall-through */    case 2:	CAST_TO_STRING;	formatObj = valuePop(ctxt);	CAST_TO_NUMBER;	numberObj = valuePop(ctxt);	break;    default:	XP_ERROR(XPATH_INVALID_ARITY);    }    if (formatValues != NULL) {	if (xsltFormatNumberConversion(formatValues,				       formatObj->stringval,				       numberObj->floatval,				       &result) == XPATH_EXPRESSION_OK) {	    valuePush(ctxt, xmlXPathNewString(result));	    xmlFree(result);	}    }    xmlXPathFreeObject(numberObj);    xmlXPathFreeObject(formatObj);    xmlXPathFreeObject(decimalObj);}

static voidexsltNodeSetFunction (xmlXPathParserContextPtr ctxt, int nargs) {    if (nargs != 1) {	xmlXPathSetArityError(ctxt);	return;    }    if (xmlXPathStackIsNodeSet (ctxt)) {	xsltFunctionNodeSet (ctxt, nargs);	return;    } else {	xmlDocPtr fragment;	xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);	xmlNodePtr txt;	xmlChar *strval;	xmlXPathObjectPtr obj;	/*	* SPEC EXSLT:	* "You can also use this function to turn a string into a text	* node, which is helpful if you want to pass a string to a	* function that only accepts a node-set."	*/	fragment = xsltCreateRVT(tctxt);	if (fragment == NULL) {	    xsltTransformError(tctxt, NULL, tctxt->inst,		"exsltNodeSetFunction: Failed to create a tree fragment./n");	    tctxt->state = XSLT_STATE_STOPPED; 	    return;	}	xsltRegisterLocalRVT(tctxt, fragment);	strval = xmlXPathPopString (ctxt);		txt = xmlNewDocText (fragment, strval);	xmlAddChild((xmlNodePtr) fragment, txt);	obj = xmlXPathNewNodeSet(txt);		if (obj == NULL) {	    xsltTransformError(tctxt, NULL, tctxt->inst,		"exsltNodeSetFunction: Failed to create a node set object./n");	    tctxt->state = XSLT_STATE_STOPPED;	} else {	    /*	     * Mark it as a function result in order to avoid garbage	     * collecting of tree fragments	     */	    xsltExtensionInstructionResultRegister(tctxt, obj);	}	if (strval != NULL)	    xmlFree (strval);		valuePush (ctxt, obj);    }}

static void GDALGMLJP2XPathIf(xmlXPathParserContextPtr ctxt, int nargs){    xmlXPathObjectPtr cond_val,then_val,else_val;    CHECK_ARITY(3);    else_val = valuePop(ctxt);    then_val = valuePop(ctxt);    CAST_TO_BOOLEAN    cond_val = valuePop(ctxt);    if( cond_val->boolval )    {        xmlXPathFreeObject(else_val);        valuePush(ctxt, then_val);    }    else    {        xmlXPathFreeObject(then_val);        valuePush(ctxt, else_val);    }    xmlXPathFreeObject(cond_val);}

voidRXSLT_callNamedFunction(const char *name, xmlXPathParserContextPtr ctxt, int nargs, int leaveAsRObject){  USER_OBJECT_ e, ans;//  xmlXPathObjectPtr obj;  int errorOccurred;  int i, j;#if 0  PROTECT(e = allocVector(LANGSXP, 2));  SETCAR(e, Rf_install((char *) name));  SETCAR(CDR(e), tmp = NEW_CHARACTER(1));  obj = valuePop(ctxt);   SET_STRING_ELT(tmp, 0, COPY_TO_USER_STRING(xmlXPathCastToString(obj)));#else  PROTECT(e = allocVector(LANGSXP, nargs+1));  SETCAR(e, Rf_install((char *) name));#if 0  for(i = 0; i < nargs; i++) {    ans = CDR(e);    for(j = nargs-1; j > i ; j--) {      ans = CDR(ans);    }    SETCAR(ans, tmp = NEW_CHARACTER(1));    obj = valuePop(ctxt);     SET_STRING_ELT(tmp, 0, COPY_TO_USER_STRING(xmlXPathCastToString(obj)));  }#else  for(i = 0; i < nargs; i++) {    ans = CDR(e);    for(j = nargs-1; j > i ; j--) {      ans = CDR(ans);    }   SETCAR(ans, convertFromXPath(ctxt, valuePop(ctxt)));  }#endif#endif    ans = R_tryEval(e, R_GlobalEnv, &errorOccurred);  if(errorOccurred) {      RXSLT_Error(ctxt, "error in call to R function");   } else {     PROTECT(ans);     valuePush(ctxt, convertToXPath(ctxt, ans));     UNPROTECT(1);  }  UNPROTECT(1);  return;}

voidRXSLT_init(xmlXPathParserContextPtr ctxt, int nargs){    const char *defaultArgs[] = {"Rxsltproc", "--silent"};    char **args;    int argc, i;    int mustFree;    if(R_alreadyInitialized)      return;#ifdef XSLT_DEBUG    fprintf(stderr, "in RXSLT_init %d/n", nargs);fflush(stderr);#endif    if(nargs == 0) {       argc = sizeof(defaultArgs)/sizeof(defaultArgs[0]);          args = (char **)defaultArgs;    } else {	args = (char **) malloc((nargs+1) * sizeof(char*));        args[0] = strdup("Rxsltproc");        argc = nargs+1;        for(i = 0; i < nargs; i++) {            xmlXPathObjectPtr obj = valuePop(ctxt);             if(obj->type) {		args[i+1] = strdup(xmlXPathCastToString(obj));	    }	}        mustFree = TRUE;    }    Rf_initEmbeddedR(argc, args);    loadXSLPackage();    valuePush(ctxt, xmlXPathNewBoolean(1));    if(mustFree) {        for(i = 0; i < nargs+1; i++) {	    free(args[i]);	}              free(args);    }#if DEBUG_REGISTRATION xsltRegisterExtFunction(getTransformCtxt(), "foo", R_URI, RXSLT_genericFunctionCall); RXSLT_addFunction("foo", NULL_USER_OBJECT);#endif    R_alreadyInitialized = 1;    return;}

static voidxslt_yelp_input (xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    xmlXPathObjectPtr ret;    YelpTransform *transform;    tctxt = xsltXPathGetTransformContext (ctxt);    transform = (YelpTransform *) tctxt->_private;    /* FIXME: pretty sure this eats transform->input, memory corruption will follow */    transform->input_xslt = xsltNewDocument (tctxt, transform->input);    ret = xmlXPathNewNodeSet (xmlDocGetRootElement (transform->input));    xsltExtensionInstructionResultRegister (tctxt, ret);    valuePush (ctxt, ret);}

static voidxslt_yelp_aux (xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    xmlXPathObjectPtr ret;    YelpTransform *transform;    YelpTransformPrivate *priv;    tctxt = xsltXPathGetTransformContext (ctxt);    transform = YELP_TRANSFORM (tctxt->_private);    priv = GET_PRIV (transform);    priv->aux_xslt = xsltNewDocument (tctxt, priv->aux);    ret = xmlXPathNewNodeSet (xmlDocGetRootElement (priv->aux));    xsltExtensionInstructionResultRegister (tctxt, ret);    valuePush (ctxt, ret);}

static voidexsltObjectTypeFunction (xmlXPathParserContextPtr ctxt, int nargs) {    xmlXPathObjectPtr obj, ret;    if (nargs != 1) {	xmlXPathSetArityError(ctxt);	return;    }    obj = valuePop(ctxt);    switch (obj->type) {    case XPATH_STRING:	ret = xmlXPathNewCString("string");	break;    case XPATH_NUMBER:	ret = xmlXPathNewCString("number");	break;    case XPATH_BOOLEAN:	ret = xmlXPathNewCString("boolean");	break;    case XPATH_NODESET:	ret = xmlXPathNewCString("node-set");	break;    case XPATH_XSLT_TREE:	ret = xmlXPathNewCString("RTF");	break;    case XPATH_USERS:	ret = xmlXPathNewCString("external");	break;    default:	xsltGenericError(xsltGenericErrorContext,		"object-type() invalid arg/n");	ctxt->error = XPATH_INVALID_TYPE;	xmlXPathFreeObject(obj);	return;    }    xmlXPathFreeObject(obj);    valuePush(ctxt, ret);}

/** * xsltFunctionLocalTime: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the localTime XSLT function used by NORM *   string localTime(???) * * This function is available in Norm's extension namespace * Code (and comments) contributed by Norm */static voidxsltFunctionLocalTime(xmlXPathParserContextPtr ctxt, int nargs) {    xmlXPathObjectPtr obj;    char *str;    char digits[5];    char result[29];    long int field;    time_t gmt, lmt;    struct tm gmt_tm;    struct tm *local_tm;     if (nargs != 1) {       xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,                      "localTime() : invalid number of args %d/n", nargs);       ctxt->error = XPATH_INVALID_ARITY;       return;    }     obj = valuePop(ctxt);    if (obj->type != XPATH_STRING) {	obj = xmlXPathConvertString(obj);    }    if (obj == NULL) {	valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));	return;    }        str = (char *) obj->stringval;    /* str = "$Date: Tuesday, November 03, 2009 11:37:25 AM$" */    memset(digits, 0, sizeof(digits));    strncpy(digits, str+7, 4);    field = strtol(digits, NULL, 10);    gmt_tm.tm_year = field - 1900;    memset(digits, 0, sizeof(digits));    strncpy(digits, str+12, 2);    field = strtol(digits, NULL, 10);    gmt_tm.tm_mon = field - 1;    memset(digits, 0, sizeof(digits));    strncpy(digits, str+15, 2);    field = strtol(digits, NULL, 10);    gmt_tm.tm_mday = field;    memset(digits, 0, sizeof(digits));    strncpy(digits, str+18, 2);    field = strtol(digits, NULL, 10);    gmt_tm.tm_hour = field;    memset(digits, 0, sizeof(digits));    strncpy(digits, str+21, 2);    field = strtol(digits, NULL, 10);    gmt_tm.tm_min = field;    memset(digits, 0, sizeof(digits));    strncpy(digits, str+24, 2);    field = strtol(digits, NULL, 10);    gmt_tm.tm_sec = field;    /* Now turn gmt_tm into a time. */    gmt = mktime(&gmt_tm);    /*     * FIXME: it's been too long since I did manual memory management.     * (I swore never to do it again.) Does this introduce a memory leak?     */    local_tm = localtime(&gmt);    /*     * Calling localtime() has the side-effect of setting timezone.     * After we know the timezone, we can adjust for it     */    lmt = gmt - timezone;    /*     * FIXME: it's been too long since I did manual memory management.     * (I swore never to do it again.) Does this introduce a memory leak?     */    local_tm = localtime(&lmt);    /*     * Now convert local_tm back into a string. This doesn't introduce     * a memory leak, so says asctime(3).     */    str = asctime(local_tm);           /* "Tue Jun 26 05:02:16 2001" *///.........这里部分代码省略.........

//.........这里部分代码省略.........static voidexsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    xmlChar *str, *delimiters, *cur;    const xmlChar *token, *delimiter;    xmlNodePtr node;    xmlDocPtr container;    xmlXPathObjectPtr ret = NULL;    int clen;    if ((nargs < 1) || (nargs > 2)) {        xmlXPathSetArityError(ctxt);        return;    }    if (nargs == 2) {        delimiters = xmlXPathPopString(ctxt);        if (xmlXPathCheckError(ctxt))            return;    } else {        delimiters = xmlStrdup((const xmlChar *) "/t/r/n ");    }    if (delimiters == NULL)        return;    str = xmlXPathPopString(ctxt);    if (xmlXPathCheckError(ctxt) || (str == NULL)) {        xmlFree(delimiters);        return;    }    /* Return a result tree fragment */    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,	      "exslt:tokenize : internal error tctxt == NULL/n");	goto fail;    }    container = xsltCreateRVT(tctxt);    if (container != NULL) {        xsltRegisterLocalRVT(tctxt, container);        ret = xmlXPathNewNodeSet(NULL);        if (ret != NULL) {            for (cur = str, token = str; *cur != 0; cur += clen) {	        clen = xmlUTF8Size(cur);		if (*delimiters == 0) {	/* empty string case */		    xmlChar ctmp;		    ctmp = *(cur+clen);		    *(cur+clen) = 0;                    node = xmlNewDocRawNode(container, NULL,                                       (const xmlChar *) "token", cur);		    xmlAddChild((xmlNodePtr) container, node);		    xmlXPathNodeSetAddUnique(ret->nodesetval, node);                    *(cur+clen) = ctmp; /* restore the changed byte */                    token = cur + clen;                } else for (delimiter = delimiters; *delimiter != 0;				delimiter += xmlUTF8Size(delimiter)) {                    if (!xmlUTF8Charcmp(cur, delimiter)) {                        if (cur == token) {                            /* discard empty tokens */                            token = cur + clen;                            break;                        }                        *cur = 0;	/* terminate the token */                        node = xmlNewDocRawNode(container, NULL,                                           (const xmlChar *) "token", token);			xmlAddChild((xmlNodePtr) container, node);			xmlXPathNodeSetAddUnique(ret->nodesetval, node);                        *cur = *delimiter; /* restore the changed byte */                        token = cur + clen;                        break;                    }                }            }            if (token != cur) {		node = xmlNewDocRawNode(container, NULL,				    (const xmlChar *) "token", token);                xmlAddChild((xmlNodePtr) container, node);	        xmlXPathNodeSetAddUnique(ret->nodesetval, node);            }	    /*	     * Mark it as a function result in order to avoid garbage	     * collecting of tree fragments	     */	    xsltExtensionInstructionResultRegister(tctxt, ret);        }    }fail:    if (str != NULL)        xmlFree(str);    if (delimiters != NULL)        xmlFree(delimiters);    if (ret != NULL)        valuePush(ctxt, ret);    else        valuePush(ctxt, xmlXPathNewNodeSet(NULL));}

//.........这里部分代码省略.........    xsltTransformContextPtr tctxt;    xmlChar *str, *delimiter, *cur;    const xmlChar *token;    xmlNodePtr node;    xmlDocPtr container;    xmlXPathObjectPtr ret = NULL;    int delimiterLength;    if ((nargs < 1) || (nargs > 2)) {        xmlXPathSetArityError(ctxt);        return;    }    if (nargs == 2) {        delimiter = xmlXPathPopString(ctxt);        if (xmlXPathCheckError(ctxt))            return;    } else {        delimiter = xmlStrdup((const xmlChar *) " ");    }    if (delimiter == NULL)        return;    delimiterLength = xmlStrlen (delimiter);    str = xmlXPathPopString(ctxt);    if (xmlXPathCheckError(ctxt) || (str == NULL)) {        xmlFree(delimiter);        return;    }    /* Return a result tree fragment */    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,	      "exslt:tokenize : internal error tctxt == NULL/n");	goto fail;    }    /*    * OPTIMIZE TODO: We are creating an xmlDoc for every split!    */    container = xsltCreateRVT(tctxt);    if (container != NULL) {        xsltRegisterLocalRVT(tctxt, container);        ret = xmlXPathNewNodeSet(NULL);        if (ret != NULL) {            for (cur = str, token = str; *cur != 0; cur++) {		if (delimiterLength == 0) {		    if (cur != token) {			xmlChar tmp = *cur;			*cur = 0;                        node = xmlNewDocRawNode(container, NULL,                                           (const xmlChar *) "token", token);			xmlAddChild((xmlNodePtr) container, node);			xmlXPathNodeSetAddUnique(ret->nodesetval, node);			*cur = tmp;			token++;		    }		}		else if (!xmlStrncasecmp(cur, delimiter, delimiterLength)) {		    if (cur == token) {			/* discard empty tokens */			cur = cur + delimiterLength - 1;			token = cur + 1;			continue;		    }		    *cur = 0;		    node = xmlNewDocRawNode(container, NULL,				       (const xmlChar *) "token", token);		    xmlAddChild((xmlNodePtr) container, node);		    xmlXPathNodeSetAddUnique(ret->nodesetval, node);		    *cur = *delimiter;		    cur = cur + delimiterLength - 1;		    token = cur + 1;                }            }	    if (token != cur) {		node = xmlNewDocRawNode(container, NULL,				   (const xmlChar *) "token", token);		xmlAddChild((xmlNodePtr) container, node);		xmlXPathNodeSetAddUnique(ret->nodesetval, node);	    }	    /*	     * Mark it as a function result in order to avoid garbage	     * collecting of tree fragments	     */	    xsltExtensionInstructionResultRegister(tctxt, ret);        }    }fail:    if (str != NULL)        xmlFree(str);    if (delimiter != NULL)        xmlFree(delimiter);    if (ret != NULL)        valuePush(ctxt, ret);    else        valuePush(ctxt, xmlXPathNewNodeSet(NULL));}

//.........这里部分代码省略.........								node->parent = nsparent;								node->ns = curns;							} else {								node = xmlDocCopyNodeList(domintern->document->ptr, node);							}							php_dom_create_object(node, &child, domintern);							add_next_index_zval(&args[i], &child);						}					}				}				break;			default:				str = (char *) xmlXPathCastToString(obj);				ZVAL_STRING(&args[i], str);				xmlFree(str);		}		xmlXPathFreeObject(obj);	}	fci.size = sizeof(fci);	fci.function_table = EG(function_table);	if (fci.param_count > 0) {		fci.params = args;	} else {		fci.params = NULL;	}	obj = valuePop(ctxt);	if (obj->stringval == NULL) {		php_error_docref(NULL, E_WARNING, "Handler name must be a string");		xmlXPathFreeObject(obj);		valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));		if (fci.param_count > 0) {			for (i = 0; i < nargs - 1; i++) {				zval_ptr_dtor(&args[i]);			}			efree(args);		}		return;	}	ZVAL_STRING(&handler, (char *) obj->stringval);	xmlXPathFreeObject(obj);	ZVAL_COPY_VALUE(&fci.function_name, &handler);	fci.symbol_table = NULL;	fci.object = NULL;	fci.retval = &retval;	fci.no_separation = 0;	/*fci.function_handler_cache = &function_ptr;*/	if (!zend_make_callable(&handler, &callable)) {		php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", ZSTR_VAL(callable));		valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));	} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {		php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'", ZSTR_VAL(callable));		/* Push an empty string, so that we at least have an xslt result... */		valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));	} else {		result = zend_call_function(&fci, NULL);		if (result == FAILURE) {			if (Z_TYPE(handler) == IS_STRING) {				php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", Z_STRVAL(handler));				valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));			}		/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */

//.........这里部分代码省略.........  Array args;  // Reverse order to pop values off ctxt stack  for (int i = nargs - 2; i >= 0; i--) {    Variant arg;    obj = valuePop(ctxt);    switch (obj->type) {    case XPATH_STRING:      arg = String((char*)obj->stringval, CopyString);      break;    case XPATH_BOOLEAN:      arg = (bool)obj->boolval;      break;    case XPATH_NUMBER:      arg = (double)obj->floatval;      break;    case XPATH_NODESET:      if (type == 1) {        char *str = (char*)xmlXPathCastToString(obj);        arg = String(str, CopyString);        xmlFree(str);      } else if (type == 2) {        arg = Array::Create();        if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {          for (int j = 0; j < obj->nodesetval->nodeNr; j++) {            // TODO: not sure this is the right thing to do.            xmlNodePtr node = obj->nodesetval->nodeTab[j];            if (node->type == XML_ELEMENT_NODE) {              Object element = newNode(s_DOMElement,                                       xmlCopyNode(node, /*extended*/ 1));              arg.toArrRef().append(element);            } else if (node->type == XML_ATTRIBUTE_NODE) {              Object attribute =                newNode(s_DOMAttr,                        (xmlNodePtr)xmlCopyProp(nullptr, (xmlAttrPtr)node));              arg.toArrRef().append(attribute);            } else if (node->type == XML_TEXT_NODE) {              Object text =                newNode(s_DOMText,                        (xmlNodePtr)xmlNewText(xmlNodeGetContent(node)));              arg.toArrRef().append(text);            } else {              raise_warning("Unhandled node type '%d'", node->type);              // Use a generic DOMNode as fallback for now.              Object nodeobj = newNode(s_DOMNode,                                       xmlCopyNode(node, /*extended*/ 1));              arg.toArrRef().append(nodeobj);            }          }        }      }      break;    default:      arg = String((char*)xmlXPathCastToString(obj), CopyString);    }    xmlXPathFreeObject(obj);    args.prepend(arg);  }  obj = valuePop(ctxt);  if (obj->stringval == nullptr) {    raise_warning("Handler name must be a string");    xmlXPathFreeObject(obj);    // Push an empty string to get an xslt result.    valuePush(ctxt, xmlXPathNewString((xmlChar*)""));    return;  }  String handler((char*)obj->stringval, CopyString);  xmlXPathFreeObject(obj);  if (!HHVM_FN(is_callable)(handler)) {    raise_warning("Unable to call handler %s()", handler.data());    // Push an empty string to get an xslt result.    valuePush(ctxt, xmlXPathNewString((xmlChar*)""));  } else if (intern->m_registerPhpFunctions == 2 &&             !intern->m_registered_phpfunctions.exists(handler)) {    raise_warning("Not allowed to call handler '%s()'", handler.data());    // Push an empty string to get an xslt result.    valuePush(ctxt, xmlXPathNewString((xmlChar*)""));  } else {    Variant retval = vm_call_user_func(handler, args);    if (retval.isObject() &&        retval.getObjectData()->instanceof(s_DOMNode)) {      ObjectData *retval_data = retval.asCObjRef().get();      xmlNode* nodep = Native::data<DOMNode>(retval_data)->nodep();      valuePush(ctxt, xmlXPathNewNodeSet(nodep));      intern->m_usedElements.prepend(retval);    } else if (retval.is(KindOfBoolean)) {      valuePush(ctxt, xmlXPathNewBoolean(retval.toBoolean()));    } else if (retval.isObject()) {      raise_warning("A PHP Object cannot be converted to an XPath-string");      // Push an empty string to get an xslt result.      valuePush(ctxt, xmlXPathNewString((xmlChar*)""));    } else {      String sretval = retval.toString();      valuePush(ctxt, xmlXPathNewString((xmlChar*)sretval.data()));    }  }}

//.........这里部分代码省略.........						for (j = 0; j < obj->nodesetval->nodeNr; j++) {							xmlNodePtr node = obj->nodesetval->nodeTab[j];							zval child;							/* not sure, if we need this... it's copied from xpath.c */							if (node->type == XML_NAMESPACE_DECL) {								xmlNsPtr curns;								xmlNodePtr nsparent;								nsparent = node->_private;								curns = xmlNewNs(NULL, node->name, NULL);								if (node->children) {									curns->prefix = xmlStrdup((xmlChar *) node->children);								}								if (node->children) {									node = xmlNewDocNode(node->doc, NULL, (xmlChar *) node->children, node->name);								} else {									node = xmlNewDocNode(node->doc, NULL, (xmlChar *) "xmlns", node->name);								}								node->type = XML_NAMESPACE_DECL;								node->parent = nsparent;								node->ns = curns;							}							php_dom_create_object(node, &child, &intern->dom);							add_next_index_zval(&fci.params[i], &child);						}					}				}				break;			default:			ZVAL_STRING(&fci.params[i], (char *)xmlXPathCastToString(obj));		}		xmlXPathFreeObject(obj);	}	fci.size = sizeof(fci);	fci.function_table = EG(function_table);	obj = valuePop(ctxt);	if (obj->stringval == NULL) {		php_error_docref(NULL, E_WARNING, "Handler name must be a string");		xmlXPathFreeObject(obj);		if (fci.param_count > 0) {			for (i = 0; i < nargs - 1; i++) {				zval_ptr_dtor(&fci.params[i]);			}			efree(fci.params);		}		return;	}	ZVAL_STRING(&fci.function_name, (char *) obj->stringval);	xmlXPathFreeObject(obj);	fci.symbol_table = NULL;	fci.object = NULL;	fci.retval = &retval;	fci.no_separation = 0;	if (!zend_make_callable(&fci.function_name, &callable)) {		php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", callable->val);	} else if (intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {		php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'.", callable->val);		/* Push an empty string, so that we at least have an xslt result... */		valuePush(ctxt, xmlXPathNewString((xmlChar *)""));	} else {		result = zend_call_function(&fci, NULL);		if (result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {			if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {				xmlNode *nodep;				dom_object *obj;				if (intern->node_list == NULL) {					ALLOC_HASHTABLE(intern->node_list);					zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);				}				GC_REFCOUNT(&retval)++;				zend_hash_next_index_insert(intern->node_list, &retval);				obj = Z_DOMOBJ_P(&retval);				nodep = dom_object_get_node(obj);				valuePush(ctxt, xmlXPathNewNodeSet(nodep));			} else if (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE) {				valuePush(ctxt, xmlXPathNewBoolean(Z_TYPE(retval) == IS_TRUE));			} else if (Z_TYPE(retval) == IS_OBJECT) {				php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");				valuePush(ctxt, xmlXPathNewString((xmlChar *)""));			} else {				zend_string *str = zval_get_string(&retval);				valuePush(ctxt, xmlXPathNewString((xmlChar *) str->val));				zend_string_release(str);			}			zval_ptr_dtor(&retval);		}	}	zend_string_release(callable);	zval_dtor(&fci.function_name);	if (fci.param_count > 0) {		for (i = 0; i < nargs - 1; i++) {			zval_ptr_dtor(&fci.params[i]);		}		efree(fci.params);	}}

/** * exsltStrTokenizeFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * Splits up a string on the characters of the delimiter string and returns a * node set of token elements, each containing one token from the string.  */static voidexsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs){    xsltTransformContextPtr tctxt;    xmlChar *str, *delimiters, *cur;    const xmlChar *token, *delimiter;    xmlNodePtr node;    xmlDocPtr container;    xmlXPathObjectPtr ret = NULL;    if ((nargs < 1) || (nargs > 2)) {        xmlXPathSetArityError(ctxt);        return;    }    if (nargs == 2) {        delimiters = xmlXPathPopString(ctxt);        if (xmlXPathCheckError(ctxt))            return;    } else {        delimiters = xmlStrdup((const xmlChar *) "/t/r/n ");    }    if (delimiters == NULL)        return;    str = xmlXPathPopString(ctxt);    if (xmlXPathCheckError(ctxt) || (str == NULL)) {        xmlFree(delimiters);        return;    }    /* Return a result tree fragment */    tctxt = xsltXPathGetTransformContext(ctxt);    if (tctxt == NULL) {        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,	      "exslt:tokenize : internal error tctxt == NULL/n");	goto fail;    }    container = xsltCreateRVT(tctxt);    if (container != NULL) {        xsltRegisterTmpRVT(tctxt, container);        ret = xmlXPathNewNodeSet(NULL);        if (ret != NULL) {            ret->boolval = 0; /* Freeing is not handled there anymore */            for (cur = str, token = str; *cur != 0; cur++) {                for (delimiter = delimiters; *delimiter != 0; delimiter++) {                    if (*cur == *delimiter) {                        if (cur == token) {                            /* discard empty tokens */                            token = cur + 1;                            break;                        }                        *cur = 0;                        node = xmlNewDocRawNode(container, NULL,                                           (const xmlChar *) "token", token);			xmlAddChild((xmlNodePtr) container, node);			xmlXPathNodeSetAddUnique(ret->nodesetval, node);                        *cur = *delimiter;                        token = cur + 1;                        break;                    }                }            }            if (token != cur) {	    	node = xmlNewDocRawNode(container, NULL,				    (const xmlChar *) "token", token);                xmlAddChild((xmlNodePtr) container, node);	        xmlXPathNodeSetAddUnique(ret->nodesetval, node);            }        }    }fail:    if (str != NULL)        xmlFree(str);    if (delimiters != NULL)        xmlFree(delimiters);    if (ret != NULL)        valuePush(ctxt, ret);    else        valuePush(ctxt, xmlXPathNewNodeSet(NULL));}