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

/** * xsltExtElementPreCompTest: * @style:  the stylesheet * @inst:  the instruction in the stylesheet * * Process a libxslt:test node */static xsltElemPreCompPtrxsltExtElementPreCompTest(xsltStylesheetPtr style, xmlNodePtr inst,                          xsltTransformFunction function){    xsltElemPreCompPtr ret;    if (style == NULL) {        xsltTransformError(NULL, NULL, inst,                           "xsltExtElementTest: no transformation context/n");        return (NULL);    }    if (testStyleData == NULL) {        xsltGenericDebug(xsltGenericDebugContext,                         "xsltExtElementPreCompTest: not initialized,"                         " calling xsltStyleGetExtData/n");        xsltStyleGetExtData(style, (const xmlChar *) XSLT_TESTPLUGIN_URL);        if (testStyleData == NULL) {            xsltTransformError(NULL, style, inst,                               "xsltExtElementPreCompTest: not initialized/n");            if (style != NULL)                style->errors++;            return (NULL);        }    }    if (inst == NULL) {        xsltTransformError(NULL, style, inst,                           "xsltExtElementPreCompTest: no instruction/n");        if (style != NULL)            style->errors++;        return (NULL);    }    ret = xsltNewElemPreComp(style, inst, function);    return (ret);}

/** * 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);}

void mxslt_transform_value_of(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp) {  mxslt_doc_t * document=mxslt_get_state()->document;  char * var, * value;  mxslt_doc_debug_print(document, MXSLT_DBG_LIBXML | MXSLT_DBG_DEBUG | MXSLT_DBG_VERBOSE0, 		    "%s: <modxslt:value-of called/n", mxslt_debug_string(document->localfile));    /* Check input parameters */  if(ctxt == NULL || node == NULL || inst == NULL)    return;     /* Check type is correct */  if(inst->type != XML_ELEMENT_NODE)    return;    /* Verify we have some attribute */  if(inst->properties == NULL || inst->properties->type != XML_ATTRIBUTE_NODE ||     !inst->properties->children || inst->properties->children->type != XML_TEXT_NODE ||     !inst->properties->children->content) {    xsltTransformError(ctxt, ctxt->style, inst, "<modxslt:value-of select='... no valid attribute specifyed!");    return;  }    /* Get attribute value */  if(!xmlStrEqual(inst->properties->name, (xmlChar *)"select")) {    xsltTransformError(ctxt, ctxt->style, inst, "<modxslt:value-of %s='... unknown attribute!", inst->properties->name);    return;  }    /* Warn if we were provided more     * attributes than expected */  if(inst->properties->next)     xsltTransformError(ctxt, ctxt->style, inst, "<modxslt:value-of %s='... unknown additional attribute!", 		       inst->properties->next->name);  var=(char *)inst->properties->children->content;    /* Now, let's do it... */  value=mxslt_yy_str_parse(document, var, strlen(var));  if(!value)    value="";  mxslt_doc_debug_print(document, MXSLT_DBG_LIBXML, "setting variable '%s' to value '%s'/n", 		    mxslt_debug_string(var), value);    /* XXX: uhm... how do I know I always need escaping? what      * if escaping was disabled? */  var=(char *)xsltCopyTextString(ctxt, ctxt->insert, (xmlChar *)value, 0);   xfree(value);  if(!var)    xsltTransformError(ctxt, ctxt->style, inst, "<modxslt:value-of %s='...xsltCopyTextString failed!", 		       inst->properties->next->name);  return;}

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);    }}

/** * 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));}

/** * xsltStrxfrm: * @locale: locale created with xsltNewLocale * @string: UTF-8 string to transform * * Transforms a string according to locale. The transformed string must then be * compared with xsltLocaleStrcmp and freed with xmlFree. * * Returns the transformed string or NULL on error */xsltLocaleChar *xsltStrxfrm(xsltLocale locale, const xmlChar *string){#ifdef XSLT_LOCALE_NONE    return(NULL);#else    size_t xstrlen, r;    xsltLocaleChar *xstr;#ifdef XSLT_LOCALE_POSIX    xstrlen = strxfrm_l(NULL, (const char *)string, 0, locale) + 1;    xstr = (xsltLocaleChar *) xmlMalloc(xstrlen);    if (xstr == NULL) {	xsltTransformError(NULL, NULL, NULL,	    "xsltStrxfrm : out of memory error/n");	return(NULL);    }    r = strxfrm_l((char *)xstr, (const char *)string, xstrlen, locale);#endif#ifdef XSLT_LOCALE_WINAPI    xstrlen = MultiByteToWideChar(CP_UTF8, 0, (char *) string, -1, NULL, 0);    if (xstrlen == 0) {        xsltTransformError(NULL, NULL, NULL, "xsltStrxfrm : MultiByteToWideChar check failed/n");        return(NULL);    }    xstr = (xsltLocaleChar*) xmlMalloc(xstrlen * sizeof(xsltLocaleChar));    if (xstr == NULL) {        xsltTransformError(NULL, NULL, NULL, "xsltStrxfrm : out of memory/n");        return(NULL);    }    r = MultiByteToWideChar(CP_UTF8, 0, (char *) string, -1, xstr, xstrlen);    if (r == 0) {        xsltTransformError(NULL, NULL, NULL, "xsltStrxfrm : MultiByteToWideChar failed/n");        xmlFree(xstr);        return(NULL);    }    return(xstr);#endif /* XSLT_LOCALE_WINAPI */    if (r >= xstrlen) {	xsltTransformError(NULL, NULL, NULL, "xsltStrxfrm : strxfrm failed/n");        xmlFree(xstr);        return(NULL);    }    return(xstr);#endif /* XSLT_LOCALE_NONE */}

/** * 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;	    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];	}	xmlXPathFreeObject(obj);    } else {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"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));}

xmlChar *xsltEvalTemplateString(xsltTransformContextPtr ctxt,		       xmlNodePtr contextNode,	               xmlNodePtr inst){    xmlNodePtr oldInsert, insert = NULL;    xmlChar *ret;    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL))	return(NULL);    if (inst->children == NULL)	return(NULL);    insert = xmlNewDocNode(ctxt->output, NULL,	                   (const xmlChar *)"fake", NULL);    if (insert == NULL) {	xsltTransformError(ctxt, NULL, contextNode,		"Failed to create temporary node/n");	return(NULL);    }    oldInsert = ctxt->insert;    ctxt->insert = insert;    xsltApplyOneTemplate(ctxt, contextNode, inst->children, NULL, NULL);    ctxt->insert = oldInsert;    ret = xmlNodeGetContent(insert);    if (insert != NULL)	xmlFreeNode(insert);    return(ret);}

/** * xsltNewAttrVT: * @style:  a XSLT process context * * Build a new xsltAttrVT structure * * Returns the structure or NULL in case of error */static xsltAttrVTPtrxsltNewAttrVT(xsltStylesheetPtr style) {    xsltAttrVTPtr cur;    cur = (xsltAttrVTPtr) xmlMalloc(sizeof(xsltAttrVT));    if (cur == NULL) {	xsltTransformError(NULL, style, NULL,		"xsltNewAttrVTPtr : malloc failed/n");	if (style != NULL) style->errors++;	return(NULL);    }    memset(cur, 0, sizeof(xsltAttrVT));    cur->nb_seg = 0;    cur->max_seg = MAX_AVT_SEG;    cur->strstart = 0;    cur->next = style->attVTs;    /*     * Note: this pointer may be changed by a re-alloc within xsltCompileAttr,     * so that code may change the stylesheet pointer also!     */    style->attVTs = (xsltAttrVTPtr) cur;    return(cur);}

/** * xsltExtShutdownTest: * @ctxt:  an XSLT transformation context * @URI:  the namespace URI for the extension * @data:  the data associated to this module * * A function called at shutdown time of an XSLT extension module */static voidxsltExtShutdownTest(xsltTransformContextPtr ctxt,                    const xmlChar * URI, void *data){    if (testData == NULL) {        xsltTransformError(ctxt, NULL, NULL,                           "xsltExtShutdownTest: not initialized/n");        return;    }    if (data != testData) {        xsltTransformError(ctxt, NULL, NULL,                           "xsltExtShutdownTest: wrong data/n");    }    testData = NULL;    xsltGenericDebug(xsltGenericDebugContext,                     "Unregistered test plugin module : %s/n", URI);}

static intexsltRegexpExecute(xmlXPathParserContextPtr ctxt,                    const xmlChar* haystack, const xmlChar* regexp,                   int flags, int ovector[], int ovector_len){  int haystack_len = 0;  pcre *compiled_regexp = NULL;  int rc = 0, erroffset = 0;  const char *error = 0;  compiled_regexp = pcre_compile(regexp,      /* the pattern */                                 flags,       /* default options */                                 &error,      /* for error message */                                 &erroffset,  /* for error offset */                                 NULL);       /* use default character tables */  if (compiled_regexp == NULL) {    xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,                        "exslt:regexp failed to compile %s (char: %d). %s", regexp, erroffset, error);    return -1;  }  haystack_len = xmlUTF8Strlen (haystack);  rc = pcre_exec(compiled_regexp,               /* result of pcre_compile() */                 NULL,                          /* we didn't study the pattern */                 haystack,                      /* the subject string */                 haystack_len,                  /* the length of the subject string */                 0,                             /* start at offset 0 in the subject */                 0,                             /* default options */                 (int*)ovector,                       /* vector of integers for substring information */                 ovector_len);  /* number of elements in the vector  (NOT size in bytes) */  if (rc < -1) {    xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,                        "exslt:regexp failed to execute %s for %s", regexp, haystack);    rc = 0;  }    if (compiled_regexp != NULL)     pcre_free(compiled_regexp);  return rc;}

/** * 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) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"function-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,	    "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) {	    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"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);}

/** * 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 */    }}

/** * xsltExtFunctionTest: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * function libxslt:test() for testing the extensions support. */static voidxsltExtFunctionTest(xmlXPathParserContextPtr ctxt,                    int nargs ATTRIBUTE_UNUSED){    xsltTransformContextPtr tctxt;    void *data = NULL;    tctxt = xsltXPathGetTransformContext(ctxt);    if (testData == NULL) {        xsltGenericDebug(xsltGenericDebugContext,                         "xsltExtFunctionTest: not initialized,"                         " calling xsltGetExtData/n");        data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_TESTPLUGIN_URL);        if (data == NULL) {            xsltTransformError(tctxt, NULL, NULL,                               "xsltExtElementTest: not initialized/n");            return;        }    }    if (tctxt == NULL) {        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,                           "xsltExtFunctionTest: failed to get the transformation context/n");        return;    }    if (data == NULL)        data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_TESTPLUGIN_URL);    if (data == NULL) {        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,                           "xsltExtFunctionTest: failed to get module data/n");        return;    }    if (data != testData) {        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,                           "xsltExtFunctionTest: got wrong module data/n");        return;    }#ifdef WITH_XSLT_DEBUG_FUNCTION    xsltGenericDebug(xsltGenericDebugContext,                     "libxslt:test() called with %d args/n", nargs);#endif}

/** * xsltExtElementTest: * @ctxt:  an XSLT processing context * @node:  The current node * @inst:  the instruction in the stylesheet * @comp:  precomputed informations * * Process a libxslt:test node */static voidxsltExtElementTest(xsltTransformContextPtr ctxt, xmlNodePtr node,                   xmlNodePtr inst,                   xsltElemPreCompPtr comp ATTRIBUTE_UNUSED){    xmlNodePtr commentNode;    if (testData == NULL) {        xsltGenericDebug(xsltGenericDebugContext,                         "xsltExtElementTest: not initialized,"                         " calling xsltGetExtData/n");        xsltGetExtData(ctxt, (const xmlChar *) XSLT_TESTPLUGIN_URL);        if (testData == NULL) {            xsltTransformError(ctxt, NULL, inst,                               "xsltExtElementTest: not initialized/n");            return;        }    }    if (ctxt == NULL) {        xsltTransformError(ctxt, NULL, inst,                           "xsltExtElementTest: no transformation context/n");        return;    }    if (node == NULL) {        xsltTransformError(ctxt, NULL, inst,                           "xsltExtElementTest: no current node/n");        return;    }    if (inst == NULL) {        xsltTransformError(ctxt, NULL, inst,                           "xsltExtElementTest: no instruction/n");        return;    }    if (ctxt->insert == NULL) {        xsltTransformError(ctxt, NULL, inst,                           "xsltExtElementTest: no insertion point/n");        return;    }    commentNode = xmlNewComment((const xmlChar *)                                "libxslt:testplugin element test worked");    xmlAddChild(ctxt->insert, commentNode);}

voidRXSLT_Error(xmlXPathParserContextPtr ctxt, const char *msg, ...){    char buf[5000];    va_list args;    va_start(args, msg);    vsnprintf(buf, 5000, msg, args);    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, xsltXPathGetTransformContext(ctxt)->insert, buf);}

/** * xsltFunctionNodeSet: * @ctxt:  the XPath Parser context * @nargs:  the number of arguments * * Implement the node-set() XSLT function *   node-set node-set(result-tree) * * This function is available in libxslt, saxon or xt namespace. */voidxsltFunctionNodeSet(xmlXPathParserContextPtr ctxt, int nargs){    if (nargs != 1) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,		"node-set() : expects one result-tree arg/n");	ctxt->error = XPATH_INVALID_ARITY;	return;    }    if ((ctxt->value == NULL) ||	((ctxt->value->type != XPATH_XSLT_TREE) &&	 (ctxt->value->type != XPATH_NODESET))) {	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,	    "node-set() invalid arg expecting a result tree/n");	ctxt->error = XPATH_INVALID_TYPE;	return;    }    if (ctxt->value->type == XPATH_XSLT_TREE) {	ctxt->value->type = XPATH_NODESET;    }}

/** * 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 voidexsltCryptoGcryptRc4Decrypt (xmlXPathParserContextPtr ctxt,			     const unsigned char *key,			     const unsigned char *msg, int msglen,			     unsigned char *dest, int destlen) {    gcry_cipher_hd_t cipher;    gcry_error_t rc = 0;    exsltCryptoGcryptInit ();    rc = gcry_cipher_open (&cipher, GCRY_CIPHER_ARCFOUR,			   GCRY_CIPHER_MODE_STREAM, 0);    if (rc) {	xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,			    NULL,			    "exslt:crypto internal error %s (gcry_cipher_open)/n",			    gcry_strerror (rc));    }    rc = gcry_cipher_setkey (cipher, key, RC4_KEY_LENGTH);    if (rc) {	xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,			    NULL,			    "exslt:crypto internal error %s (gcry_cipher_setkey)/n",			    gcry_strerror (rc));    }    rc = gcry_cipher_decrypt (cipher, (unsigned char *) dest, destlen,			      (const unsigned char *) msg, msglen);    if (rc) {	xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,			    NULL,			    "exslt:crypto internal error %s (gcry_cipher_decrypt)/n",			    gcry_strerror (rc));    }    gcry_cipher_close (cipher);}

static voidexsltCryptoCryptoApiRc4Decrypt (xmlXPathParserContextPtr ctxt,				const unsigned char *key,				const unsigned char *msg, int msglen,				unsigned char *dest, int destlen) {    HCRYPTPROV hCryptProv;    HCRYPTKEY hKey;    HCRYPTHASH hHash;    DWORD dwDataLen;    unsigned char hash[HASH_DIGEST_LENGTH];    if (msglen > destlen) {	xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,			    NULL,			    "exslt:crypto : internal error exsltCryptoCryptoApiRc4Encrypt dest buffer too small./n");	return;    }    if (!CryptAcquireContext (&hCryptProv, NULL, NULL, PROV_RSA_FULL,			      CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {	exsltCryptoCryptoApiReportError (ctxt, __LINE__);	return;    }    hHash = exsltCryptoCryptoApiCreateHash (ctxt, hCryptProv,					    CALG_SHA1, key,					    RC4_KEY_LENGTH, hash,					    HASH_DIGEST_LENGTH);    if (!CryptDeriveKey	(hCryptProv, CALG_RC4, hHash, 0x00800000, &hKey)) {	exsltCryptoCryptoApiReportError (ctxt, __LINE__);	goto fail;    }/* Now encrypt data. */    dwDataLen = msglen;    memcpy (dest, msg, msglen);    if (!CryptDecrypt (hKey, 0, TRUE, 0, dest, &dwDataLen)) {	exsltCryptoCryptoApiReportError (ctxt, __LINE__);	goto fail;    }  fail:    if (0 != hHash) {	CryptDestroyHash (hHash);    }    CryptDestroyKey (hKey);    CryptReleaseContext (hCryptProv, 0);}

/** * xsltExtStyleInitTest: * @style:  an XSLT stylesheet * @URI:  the namespace URI for the extension * * A function called at initialization time of an XSLT extension module * * Returns a pointer to the module specific data for this transformation */static void *xsltExtStyleInitTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED,                     const xmlChar * URI){    if (testStyleData != NULL) {        xsltTransformError(NULL, NULL, NULL,                           "xsltExtInitTest: already initialized/n");        return (NULL);    }    testStyleData = (void *) "test data";    xsltGenericDebug(xsltGenericDebugContext,                     "Registered test plugin module : %s/n", URI);    return (testStyleData);}

/** * xsltEvalXPathStringNs: * @ctxt:  the XSLT transformation context * @comp:  the compiled XPath expression * @nsNr:  the number of namespaces in the list * @nsList:  the list of in-scope namespaces to use * * Process the expression using XPath, allowing to pass a namespace mapping * context and get a string * * Returns the computed string value or NULL, must be deallocated by the *    caller. */xmlChar *xsltEvalXPathStringNs(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp,	              int nsNr, xmlNsPtr *nsList) {    xmlChar *ret = NULL;    xmlXPathObjectPtr res;    xmlNodePtr oldInst;    xmlNodePtr oldNode;    int	oldPos, oldSize;    int oldNsNr;    xmlNsPtr *oldNamespaces;    oldInst = ctxt->inst;    oldNode = ctxt->node;    oldPos = ctxt->xpathCtxt->proximityPosition;    oldSize = ctxt->xpathCtxt->contextSize;    oldNsNr = ctxt->xpathCtxt->nsNr;    oldNamespaces = ctxt->xpathCtxt->namespaces;    ctxt->xpathCtxt->node = ctxt->node;    /* TODO: do we need to propagate the namespaces here ? */    ctxt->xpathCtxt->namespaces = nsList;    ctxt->xpathCtxt->nsNr = nsNr;    res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);    if (res != NULL) {	if (res->type != XPATH_STRING)	    res = xmlXPathConvertString(res);	if (res->type == XPATH_STRING) {            ret = res->stringval;	    res->stringval = NULL;	} else {	    xsltTransformError(ctxt, NULL, NULL,		 "xpath : string() function didn't return a String/n");	}	xmlXPathFreeObject(res);    } else {	ctxt->state = XSLT_STATE_STOPPED;    }#ifdef WITH_XSLT_DEBUG_TEMPLATES    XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,	 "xsltEvalXPathString: returns %s/n", ret));#endif    ctxt->inst = oldInst;    ctxt->node = oldNode;    ctxt->xpathCtxt->contextSize = oldSize;    ctxt->xpathCtxt->proximityPosition = oldPos;    ctxt->xpathCtxt->nsNr = oldNsNr;    ctxt->xpathCtxt->namespaces = oldNamespaces;    return(ret);}

/** * xsltExtInitTest: * @ctxt:  an XSLT transformation context * @URI:  the namespace URI for the extension * * A function called at initialization time of an XSLT extension module * * Returns a pointer to the module specific data for this transformation */static void *xsltExtInitTest(xsltTransformContextPtr ctxt, const xmlChar * URI){    if (testStyleData == NULL) {        xsltGenericDebug(xsltGenericErrorContext,                         "xsltExtInitTest: not initialized,"                         " calling xsltStyleGetExtData/n");        xsltStyleGetExtData(ctxt->style, URI);        if (testStyleData == NULL) {            xsltTransformError(ctxt, NULL, NULL,                               "xsltExtInitTest: not initialized/n");            return (NULL);        }    }    if (testData != NULL) {        xsltTransformError(ctxt, NULL, NULL,                           "xsltExtInitTest: already initialized/n");        return (NULL);    }    testData = (void *) "test data";    xsltGenericDebug(xsltGenericDebugContext,                     "Registered test plugin module : %s/n", URI);    return (testData);}

/** * xsltNewSecurityPrefs: * * Create a new security preference block * * Returns a pointer to the new block or NULL in case of error */xsltSecurityPrefsPtrxsltNewSecurityPrefs(void) {    xsltSecurityPrefsPtr ret;    xsltInitGlobals();    ret = (xsltSecurityPrefsPtr) xmlMalloc(sizeof(xsltSecurityPrefs));    if (ret == NULL) {	xsltTransformError(NULL, NULL, NULL,		"xsltNewSecurityPrefs : malloc failed/n");	return(NULL);    }    memset(ret, 0, sizeof(xsltSecurityPrefs));    return(ret);}

static voidexsltCryptoCryptoApiReportError (xmlXPathParserContextPtr ctxt,				 int line) {    LPVOID lpMsgBuf;    DWORD dw = GetLastError ();    FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER |		   FORMAT_MESSAGE_FROM_SYSTEM, NULL, dw,		   MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),		   (LPTSTR) & lpMsgBuf, 0, NULL);    xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,			"exslt:crypto error (line %d). %s", line,			lpMsgBuf);    LocalFree (lpMsgBuf);}

/** * xsltExtStyleShutdownTest: * @style:  an XSLT stylesheet * @URI:  the namespace URI for the extension * @data:  the data associated to this module * * A function called at shutdown time of an XSLT extension module */static voidxsltExtStyleShutdownTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED,                         const xmlChar * URI, void *data){    if (testStyleData == NULL) {        xsltGenericError(xsltGenericErrorContext,                         "xsltExtShutdownTest: not initialized/n");        return;    }    if (data != testStyleData) {        xsltTransformError(NULL, NULL, NULL,                           "xsltExtShutdownTest: wrong data/n");    }    testStyleData = NULL;    xsltGenericDebug(xsltGenericDebugContext,                     "Unregistered test plugin module : %s/n", URI);}

/** * xsltInitDocKeyTable: * * INTERNAL ROUTINE ONLY * * Check if any keys on the current document need to be computed */static intxsltInitDocKeyTable(xsltTransformContextPtr ctxt, const xmlChar *name,                    const xmlChar *nameURI){    xsltStylesheetPtr style;    xsltKeyDefPtr keyd = NULL;    int found = 0;#ifdef KEY_INIT_DEBUGfprintf(stderr, "xsltInitDocKeyTable %s/n", name);#endif    style = ctxt->style;    while (style != NULL) {	keyd = (xsltKeyDefPtr) style->keys;	while (keyd != NULL) {	    if (((keyd->nameURI != NULL) ==		 (nameURI != NULL)) &&		xmlStrEqual(keyd->name, name) &&		xmlStrEqual(keyd->nameURI, nameURI))	    {		xsltInitCtxtKey(ctxt, ctxt->document, keyd);		if (ctxt->document->nbKeysComputed == ctxt->nbKeys)		    return(0);		found = 1;	    }	    keyd = keyd->next;	}	style = xsltNextImport(style);    }    if (found == 0) {#ifdef WITH_XSLT_DEBUG_KEYS	XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,	     "xsltInitDocKeyTable: did not found %s/n", name));#endif	xsltTransformError(ctxt, NULL, keyd? keyd->inst : NULL,	    "Failed to find key definition for %s/n", name);	ctxt->state = XSLT_STATE_STOPPED;        return(-1);    }#ifdef KEY_INIT_DEBUGfprintf(stderr, "xsltInitDocKeyTable %s done/n", name);#endif    return(0);}

/** * xsltNewKeyTable: * @name:  the key name or NULL * @nameURI:  the name URI or NULL * * Create a new XSLT KeyTable * * Returns the newly allocated xsltKeyTablePtr or NULL in case of error */static xsltKeyTablePtrxsltNewKeyTable(const xmlChar *name, const xmlChar *nameURI) {    xsltKeyTablePtr cur;    cur = (xsltKeyTablePtr) xmlMalloc(sizeof(xsltKeyTable));    if (cur == NULL) {	xsltTransformError(NULL, NULL, NULL,		"xsltNewKeyTable : malloc failed/n");	return(NULL);    }    memset(cur, 0, sizeof(xsltKeyTable));    if (name != NULL)	cur->name = xmlStrdup(name);    if (nameURI != NULL)	cur->nameURI = xmlStrdup(nameURI);    cur->keys = xmlHashCreate(0);    return(cur);}

/** * xsltNewKeyDef: * @name:  the key name or NULL * @nameURI:  the name URI or NULL * * Create a new XSLT KeyDef * * Returns the newly allocated xsltKeyDefPtr or NULL in case of error */static xsltKeyDefPtrxsltNewKeyDef(const xmlChar *name, const xmlChar *nameURI) {    xsltKeyDefPtr cur;    cur = (xsltKeyDefPtr) xmlMalloc(sizeof(xsltKeyDef));    if (cur == NULL) {	xsltTransformError(NULL, NULL, NULL,		"xsltNewKeyDef : malloc failed/n");	return(NULL);    }    memset(cur, 0, sizeof(xsltKeyDef));    if (name != NULL)	cur->name = xmlStrdup(name);    if (nameURI != NULL)	cur->nameURI = xmlStrdup(nameURI);    cur->nsList = NULL;    return(cur);}