/** * xsltExtElementPreCompTest: * @style: the stylesheet * @inst: the instruction in the stylesheet * * Process a libxslt:test node */ static xsltElemPreCompPtr xsltExtElementPreCompTest(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) */ void xsltElementAvailableFunction(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 void exsltNodeSetFunction (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); } }
/** * xsltResolveAttrSet: * @set: the attribute set * @asctx: the context for attribute set resolution * @name: the local name of the attirbute set * @ns: the namespace of the attribute set * @depth: recursion depth * * resolve the references in an attribute set. */ static void xsltResolveAttrSet(xsltAttrSetPtr set, xsltStylesheetPtr topStyle, xsltStylesheetPtr style, const xmlChar *name, const xmlChar *ns, int depth) { xsltStylesheetPtr cur; xsltAttrSetPtr other; if (set->state == ATTRSET_RESOLVED) return; if (set->state == ATTRSET_RESOLVING) { xsltTransformError(NULL, topStyle, NULL, "xsl:attribute-set : use-attribute-sets recursion detected" " on %s\n", name); topStyle->errors++; set->state = ATTRSET_RESOLVED; return; } if (depth > 100) { xsltTransformError(NULL, topStyle, NULL, "xsl:attribute-set : use-attribute-sets maximum recursion " "depth exceeded on %s\n", name); topStyle->errors++; return; } set->state = ATTRSET_RESOLVING; xsltResolveUseAttrSets(set, topStyle, depth); /* Merge imported sets. */ cur = xsltNextImport(style); while (cur != NULL) { if (cur->attributeSets != NULL) { other = xmlHashLookup2(cur->attributeSets, name, ns); if (other != NULL) { #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "xsl:attribute-set : merging import for %s\n", name); #endif xsltResolveUseAttrSets(other, topStyle, depth); xsltMergeAttrSets(set, other); xmlHashRemoveEntry2(cur->attributeSets, name, ns, NULL); xsltFreeAttrSet(other); } } cur = xsltNextImport(cur); } set->state = ATTRSET_RESOLVED; }
/** * xsltGenerateIdFunction: * @ctxt: the XPath Parser context * @nargs: the number of arguments * * Implement the generate-id() XSLT function * string generate-id(node-set?) */ void xsltGenerateIdFunction(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?) */ void xsltGenerateIdFunction(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 xsltAttrVTPtr xsltNewAttrVT(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 void xsltExtShutdownTest(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 int exsltRegexpExecute(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) */ void xsltFunctionAvailableFunction(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 void xsltCurrentFunction(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 void xsltExtFunctionTest(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 void xsltExtElementTest(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); }
void RXSLT_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. */ void xsltFunctionNodeSet(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?) */ void xsltFormatNumberFunction(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 void exsltCryptoGcryptRc4Decrypt (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 void exsltCryptoCryptoApiRc4Decrypt (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 */ xsltSecurityPrefsPtr xsltNewSecurityPrefs(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 void exsltCryptoCryptoApiReportError (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 void xsltExtStyleShutdownTest(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 int xsltInitDocKeyTable(xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *nameURI) { xsltStylesheetPtr style; xsltKeyDefPtr keyd = NULL; int found = 0; #ifdef KEY_INIT_DEBUG fprintf(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_DEBUG fprintf(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 xsltKeyTablePtr xsltNewKeyTable(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 xsltKeyDefPtr xsltNewKeyDef(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); }