functions.h File Reference

#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "xsltexports.h"
#include "xsltInternals.h"

Include dependency graph for functions.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	XSLT_REGISTER_FUNCTION_LOOKUP(ctxt)

Functions
XSLTPUBFUN xmlXPathFunction XSLTCALL	xsltXPathFunctionLookup (void *vctxt, const xmlChar *name, const xmlChar *ns_uri)
XSLTPUBFUN void XSLTCALL	xsltDocumentFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltKeyFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltUnparsedEntityURIFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltFormatNumberFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltGenerateIdFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltSystemPropertyFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltElementAvailableFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltFunctionAvailableFunction (xmlXPathParserContextPtr ctxt, int nargs)
XSLTPUBFUN void XSLTCALL	xsltRegisterAllFunctions (xmlXPathContextPtr ctxt)

Macro Definition Documentation

XSLT_REGISTER_FUNCTION_LOOKUP

#define XSLT_REGISTER_FUNCTION_LOOKUP

(

ctxt

)

Value:

    xmlXPathRegisterFuncLookup((ctxt)->xpathCtxt,       \
    xsltXPathFunctionLookup,                \
    (void *)(ctxt->xpathCtxt));

XSLT_REGISTER_FUNCTION_LOOKUP:

Registering macro, not general purpose at all but used in different modules.

Definition at line 27 of file functions.h.

Function Documentation

xsltDocumentFunction()

XSLTPUBFUN void XSLTCALL xsltDocumentFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltDocumentFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the document() XSLT function node-set document(object, node-set?)

Definition at line 193 of file functions.c.

{
    xmlXPathObjectPtr obj, obj2 = NULL;
    xmlChar *base = NULL, *URI;
 
 
    if ((nargs < 1) || (nargs > 2)) {
        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
                         "document() : invalid number of args %d\n",
                         nargs);
        ctxt->error = XPATH_INVALID_ARITY;
        return;
    }
    if (ctxt->value == NULL) {
        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
                         "document() : invalid arg value\n");
        ctxt->error = XPATH_INVALID_TYPE;
        return;
    }
 
    if (nargs == 2) {
        if (ctxt->value->type != XPATH_NODESET) {
            xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
                             "document() : invalid arg expecting a nodeset\n");
            ctxt->error = XPATH_INVALID_TYPE;
            return;
        }
 
        obj2 = valuePop(ctxt);
    }
 
    if (ctxt->value->type == XPATH_NODESET) {
        int i;
        xmlXPathObjectPtr newobj, ret;
 
        obj = valuePop(ctxt);
        ret = xmlXPathNewNodeSet(NULL);
 
        if ((obj != NULL) && obj->nodesetval) {
            for (i = 0; i < obj->nodesetval->nodeNr; i++) {
                valuePush(ctxt,
                          xmlXPathNewNodeSet(obj->nodesetval->nodeTab[i]));
                xmlXPathStringFunction(ctxt, 1);
                if (nargs == 2) {
                    valuePush(ctxt, xmlXPathObjectCopy(obj2));
                } else {
                    valuePush(ctxt,
                              xmlXPathNewNodeSet(obj->nodesetval->
                                                 nodeTab[i]));
                }
                xsltDocumentFunction(ctxt, 2);
                newobj = valuePop(ctxt);
                ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
                                                       newobj->nodesetval);
                xmlXPathFreeObject(newobj);
            }
        }
 
        if (obj != NULL)
            xmlXPathFreeObject(obj);
        if (obj2 != NULL)
            xmlXPathFreeObject(obj2);
        valuePush(ctxt, ret);
        return;
    }
    /*
     * Make sure it's converted to a string
     */
    xmlXPathStringFunction(ctxt, 1);
    if (ctxt->value->type != XPATH_STRING) {
        xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
                         "document() : invalid arg expecting a string\n");
        ctxt->error = XPATH_INVALID_TYPE;
        if (obj2 != NULL)
            xmlXPathFreeObject(obj2);
        return;
    }
    obj = valuePop(ctxt);
    if (obj->stringval == NULL) {
        valuePush(ctxt, xmlXPathNewNodeSet(NULL));
    } else {
        xsltTransformContextPtr tctxt;
        tctxt = xsltXPathGetTransformContext(ctxt);
        if ((obj2 != NULL) && (obj2->nodesetval != NULL) &&
            (obj2->nodesetval->nodeNr > 0) &&
            IS_XSLT_REAL_NODE(obj2->nodesetval->nodeTab[0])) {
            xmlNodePtr target;
 
            target = obj2->nodesetval->nodeTab[0];
            if ((target->type == XML_ATTRIBUTE_NODE) ||
            (target->type == XML_PI_NODE)) {
                target = ((xmlAttrPtr) target)->parent;
            }
            base = xmlNodeGetBase(target->doc, target);
        } else {
            if ((tctxt != NULL) && (tctxt->inst != NULL)) {
                base = xmlNodeGetBase(tctxt->inst->doc, tctxt->inst);
            } else if ((tctxt != NULL) && (tctxt->style != NULL) &&
                       (tctxt->style->doc != NULL)) {
                base = xmlNodeGetBase(tctxt->style->doc,
                                      (xmlNodePtr) tctxt->style->doc);
            }
        }
        URI = xmlBuildURI(obj->stringval, base);
        if (base != NULL)
            xmlFree(base);
        if (URI == NULL) {
            if ((tctxt != NULL) && (tctxt->style != NULL) &&
                (tctxt->style->doc != NULL) &&
                (xmlStrEqual(URI, tctxt->style->doc->URL))) {
                /* This selects the stylesheet's doc itself. */
                valuePush(ctxt, xmlXPathNewNodeSet((xmlNodePtr) tctxt->style->doc));
            } else {
                valuePush(ctxt, xmlXPathNewNodeSet(NULL));
            }
        } else {
        xsltDocumentFunctionLoadDocument( ctxt, URI );
        xmlFree(URI);
    }
    }
    xmlXPathFreeObject(obj);
    if (obj2 != NULL)
        xmlXPathFreeObject(obj2);
}

Referenced by xsltDocumentFunction(), and xsltRegisterAllFunctions().

xsltElementAvailableFunction()

XSLTPUBFUN void XSLTCALL xsltElementAvailableFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltElementAvailableFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the element-available() XSLT function boolean element-available(string)

Definition at line 807 of file functions.c.

                                                                      {
    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) || (tctxt->inst == 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 = 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);
}

Referenced by xsltRegisterAllFunctions().

xsltFormatNumberFunction()

XSLTPUBFUN void XSLTCALL xsltFormatNumberFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltFormatNumberFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the format-number() XSLT function string format-number(number, string, string?)

Definition at line 567 of file functions.c.

{
    xmlXPathObjectPtr numberObj = NULL;
    xmlXPathObjectPtr formatObj = NULL;
    xmlXPathObjectPtr decimalObj = NULL;
    xsltStylesheetPtr sheet;
    xsltDecimalFormatPtr formatValues = NULL;
    xmlChar *result;
    const xmlChar *ncname;
    const xmlChar *prefix = NULL;
    const xmlChar *nsUri = NULL;
    xsltTransformContextPtr tctxt;
 
    tctxt = xsltXPathGetTransformContext(ctxt);
    if ((tctxt == NULL) || (tctxt->inst == NULL))
    return;
    sheet = tctxt->style;
    if (sheet == NULL)
    return;
    formatValues = sheet->decimalFormat;
 
    switch (nargs) {
    case 3:
        if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING))
            xmlXPathStringFunction(ctxt, 1);
    decimalObj = valuePop(ctxt);
        ncname = xsltSplitQName(sheet->dict, decimalObj->stringval, &prefix);
        if (prefix != NULL) {
            xmlNsPtr ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, prefix);
            if (ns == NULL) {
                xsltTransformError(tctxt, NULL, NULL,
                    "format-number : No namespace found for QName '%s:%s'\n",
                    prefix, ncname);
                sheet->errors++;
                ncname = NULL;
            }
            else {
                nsUri = ns->href;
            }
        }
        if (ncname != NULL) {
        formatValues = xsltDecimalFormatGetByQName(sheet, nsUri, ncname);
        }
    if (formatValues == NULL) {
        xsltTransformError(tctxt, NULL, NULL,
            "format-number() : undeclared decimal format '%s'\n",
            decimalObj->stringval);
    }
    /* Intentional fall-through */
    case 2:
        if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING))
            xmlXPathStringFunction(ctxt, 1);
    formatObj = valuePop(ctxt);
        if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_NUMBER))
            xmlXPathNumberFunction(ctxt, 1);
    numberObj = valuePop(ctxt);
    break;
    default:
    xmlXPathErr(ctxt, XPATH_INVALID_ARITY);
        return;
    }
 
    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);
}

Referenced by xsltRegisterAllFunctions().

xsltFunctionAvailableFunction()

XSLTPUBFUN void XSLTCALL xsltFunctionAvailableFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltFunctionAvailableFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the function-available() XSLT function boolean function-available(string)

Definition at line 874 of file functions.c.

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

Referenced by xsltRegisterAllFunctions().

xsltGenerateIdFunction()

XSLTPUBFUN void XSLTCALL xsltGenerateIdFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltGenerateIdFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the generate-id() XSLT function string generate-id(node-set?)

Definition at line 653 of file functions.c.

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

Referenced by xsltRegisterAllFunctions().

xsltKeyFunction()

XSLTPUBFUN void XSLTCALL xsltKeyFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltKeyFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the key() XSLT function node-set key(string, object)

Definition at line 327 of file functions.c.

                                                         {
    xmlXPathObjectPtr obj1, obj2;
 
    if (nargs != 2) {
    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
        "key() : expects two arguments\n");
    ctxt->error = XPATH_INVALID_ARITY;
    return;
    }
 
    /*
    * Get the key's value.
    */
    obj2 = valuePop(ctxt);
    xmlXPathStringFunction(ctxt, 1);
    if ((obj2 == NULL) ||
    (ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
        "key() : invalid arg expecting a string\n");
    ctxt->error = XPATH_INVALID_TYPE;
    xmlXPathFreeObject(obj2);
 
    return;
    }
    /*
    * Get the key's name.
    */
    obj1 = valuePop(ctxt);
 
    if ((obj2->type == XPATH_NODESET) || (obj2->type == XPATH_XSLT_TREE)) {
    int i;
    xmlXPathObjectPtr newobj, ret;
 
    ret = xmlXPathNewNodeSet(NULL);
 
    if (obj2->nodesetval != NULL) {
        for (i = 0; i < obj2->nodesetval->nodeNr; i++) {
        valuePush(ctxt, xmlXPathObjectCopy(obj1));
        valuePush(ctxt,
              xmlXPathNewNodeSet(obj2->nodesetval->nodeTab[i]));
        xmlXPathStringFunction(ctxt, 1);
        xsltKeyFunction(ctxt, 2);
        newobj = valuePop(ctxt);
        ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
                               newobj->nodesetval);
        xmlXPathFreeObject(newobj);
        }
    }
    valuePush(ctxt, ret);
    } else {
    xmlNodeSetPtr nodelist = NULL;
    xmlChar *key = NULL, *value;
    const xmlChar *keyURI;
    xsltTransformContextPtr tctxt;
    xmlChar *qname, *prefix;
    xmlXPathContextPtr xpctxt = ctxt->context;
    xmlNodePtr tmpNode = NULL;
    xsltDocumentPtr oldDocInfo;
 
    tctxt = xsltXPathGetTransformContext(ctxt);
 
    oldDocInfo = tctxt->document;
 
    if (xpctxt->node == NULL) {
        xsltTransformError(tctxt, NULL, tctxt->inst,
        "Internal error in xsltKeyFunction(): "
        "The context node is not set on the XPath context.\n");
        tctxt->state = XSLT_STATE_STOPPED;
        goto error;
    }
    /*
     * Get the associated namespace URI if qualified name
     */
    qname = obj1->stringval;
    key = xmlSplitQName2(qname, &prefix);
    if (key == NULL) {
        key = xmlStrdup(obj1->stringval);
        keyURI = NULL;
        if (prefix != NULL)
        xmlFree(prefix);
    } else {
        if (prefix != NULL) {
        keyURI = xmlXPathNsLookup(xpctxt, prefix);
        if (keyURI == NULL) {
            xsltTransformError(tctxt, NULL, tctxt->inst,
            "key() : prefix %s is not bound\n", prefix);
            /*
            * TODO: Shouldn't we stop here?
            */
        }
        xmlFree(prefix);
        } else {
        keyURI = NULL;
        }
    }
 
    /*
     * Force conversion of first arg to string
     */
    valuePush(ctxt, obj2);
    xmlXPathStringFunction(ctxt, 1);
    if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
        xsltTransformError(tctxt, NULL, tctxt->inst,
        "key() : invalid arg expecting a string\n");
        ctxt->error = XPATH_INVALID_TYPE;
        goto error;
    }
    obj2 = valuePop(ctxt);
    value = obj2->stringval;
 
    /*
    * We need to ensure that ctxt->document is available for
    * xsltGetKey().
    * First find the relevant doc, which is the context node's
    * owner doc; using context->doc is not safe, since
    * the doc could have been acquired via the document() function,
    * or the doc might be a Result Tree Fragment.
    * FUTURE INFO: In XSLT 2.0 the key() function takes an additional
    * argument indicating the doc to use.
    */
    if (xpctxt->node->type == XML_NAMESPACE_DECL) {
        /*
        * REVISIT: This is a libxml hack! Check xpath.c for details.
        * The XPath module sets the owner element of a ns-node on
        * the ns->next field.
        */
        if ((((xmlNsPtr) xpctxt->node)->next != NULL) &&
        (((xmlNsPtr) xpctxt->node)->next->type == XML_ELEMENT_NODE))
        {
        tmpNode = (xmlNodePtr) ((xmlNsPtr) xpctxt->node)->next;
        }
    } else
        tmpNode = xpctxt->node;
 
    if ((tmpNode == NULL) || (tmpNode->doc == NULL)) {
        xsltTransformError(tctxt, NULL, tctxt->inst,
        "Internal error in xsltKeyFunction(): "
        "Couldn't get the doc of the XPath context node.\n");
        goto error;
    }
 
    if ((tctxt->document == NULL) ||
        (tctxt->document->doc != tmpNode->doc))
    {
        if (tmpNode->doc->name && (tmpNode->doc->name[0] == ' ')) {
        /*
        * This is a Result Tree Fragment.
        */
        if (tmpNode->doc->_private == NULL) {
            tmpNode->doc->_private = xsltNewDocument(tctxt, tmpNode->doc);
            if (tmpNode->doc->_private == NULL)
            goto error;
        }
        tctxt->document = (xsltDocumentPtr) tmpNode->doc->_private;
        } else {
        /*
        * May be the initial source doc or a doc acquired via the
        * document() function.
        */
        tctxt->document = xsltFindDocument(tctxt, tmpNode->doc);
        }
        if (tctxt->document == NULL) {
        xsltTransformError(tctxt, NULL, tctxt->inst,
            "Internal error in xsltKeyFunction(): "
            "Could not get the document info of a context doc.\n");
        tctxt->state = XSLT_STATE_STOPPED;
        goto error;
        }
    }
    /*
    * Get/compute the key value.
    */
    nodelist = xsltGetKey(tctxt, key, keyURI, value);
 
error:
    tctxt->document = oldDocInfo;
    valuePush(ctxt, xmlXPathWrapNodeSet(
        xmlXPathNodeSetMerge(NULL, nodelist)));
    if (key != NULL)
        xmlFree(key);
    }
 
    if (obj1 != NULL)
    xmlXPathFreeObject(obj1);
    if (obj2 != NULL)
    xmlXPathFreeObject(obj2);
}

Referenced by xsltKeyFunction(), and xsltRegisterAllFunctions().

xsltRegisterAllFunctions()

XSLTPUBFUN void XSLTCALL xsltRegisterAllFunctions

(

xmlXPathContextPtr

ctxt

)

xsltRegisterAllFunctions: @ctxt: the XPath context

Registers all default XSLT functions in this context

Definition at line 959 of file functions.c.

{
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "current",
                         xsltCurrentFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "document",
                         xsltDocumentFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "key", xsltKeyFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "unparsed-entity-uri",
                         xsltUnparsedEntityURIFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "format-number",
                         xsltFormatNumberFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "generate-id",
                         xsltGenerateIdFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "system-property",
                         xsltSystemPropertyFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "element-available",
                         xsltElementAvailableFunction);
    xmlXPathRegisterFunc(ctxt, (const xmlChar *) "function-available",
                         xsltFunctionAvailableFunction);
}

xsltSystemPropertyFunction()

XSLTPUBFUN void XSLTCALL xsltSystemPropertyFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltSystemPropertyFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the system-property() XSLT function object system-property(string)

Definition at line 713 of file functions.c.

                                                                    {
    xmlXPathObjectPtr obj;
    xmlChar *prefix, *name;
    const xmlChar *nsURI = NULL;
 
    if (nargs != 1) {
    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
        "system-property() : expects one string arg\n");
    ctxt->error = XPATH_INVALID_ARITY;
    return;
    }
    if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
        "system-property() : invalid arg expecting a string\n");
    ctxt->error = XPATH_INVALID_TYPE;
    return;
    }
    obj = valuePop(ctxt);
    if (obj->stringval == NULL) {
    valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
    } else {
    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,
            "system-property() : prefix %s is not bound\n", prefix);
        }
    }
 
    if (xmlStrEqual(nsURI, XSLT_NAMESPACE)) {
#ifdef DOCBOOK_XSL_HACK
        if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
        xsltStylesheetPtr sheet;
        xsltTransformContextPtr tctxt;
 
        tctxt = xsltXPathGetTransformContext(ctxt);
        if ((tctxt != NULL) && (tctxt->inst != NULL) &&
            (xmlStrEqual(tctxt->inst->name, BAD_CAST "variable")) &&
            (tctxt->inst->parent != NULL) &&
            (xmlStrEqual(tctxt->inst->parent->name,
                 BAD_CAST "template")))
            sheet = tctxt->style;
        else
            sheet = NULL;
        if ((sheet != NULL) && (sheet->doc != NULL) &&
            (sheet->doc->URL != NULL) &&
            (xmlStrstr(sheet->doc->URL,
                   (const xmlChar *)"chunk") != NULL)) {
            valuePush(ctxt, xmlXPathNewString(
            (const xmlChar *)"libxslt (SAXON 6.2 compatible)"));
 
        } else {
            valuePush(ctxt, xmlXPathNewString(
            (const xmlChar *)XSLT_DEFAULT_VENDOR));
        }
        } else
#else
        if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
        valuePush(ctxt, xmlXPathNewString(
              (const xmlChar *)XSLT_DEFAULT_VENDOR));
        } else
#endif
        if (xmlStrEqual(name, (const xmlChar *)"version")) {
        valuePush(ctxt, xmlXPathNewString(
            (const xmlChar *)XSLT_DEFAULT_VERSION));
        } else if (xmlStrEqual(name, (const xmlChar *)"vendor-url")) {
        valuePush(ctxt, xmlXPathNewString(
            (const xmlChar *)XSLT_DEFAULT_URL));
        } else {
        valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
        }
    } else {
        valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
        }
    if (name != NULL)
        xmlFree(name);
    if (prefix != NULL)
        xmlFree(prefix);
    }
    xmlXPathFreeObject(obj);
}

Referenced by xsltRegisterAllFunctions().

xsltUnparsedEntityURIFunction()

XSLTPUBFUN void XSLTCALL xsltUnparsedEntityURIFunction	(	xmlXPathParserContextPtr	ctxt,
		int	nargs
	)

xsltUnparsedEntityURIFunction: @ctxt: the XPath Parser context @nargs: the number of arguments

Implement the unparsed-entity-uri() XSLT function string unparsed-entity-uri(string)

Definition at line 524 of file functions.c.

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

Referenced by xsltRegisterAllFunctions().

xsltXPathFunctionLookup()

XSLTPUBFUN xmlXPathFunction XSLTCALL xsltXPathFunctionLookup	(	void *	vctxt,
		const xmlChar *	name,
		const xmlChar *	ns_uri
	)

Definition at line 40 of file functions.c.

                                                         {
    xmlXPathContextPtr ctxt = (xmlXPathContextPtr) vctxt;
    xmlXPathFunction ret;
 
    if ((ctxt == NULL) || (name == NULL) || (ns_uri == NULL))
    return (NULL);
 
#ifdef WITH_XSLT_DEBUG_FUNCTION
    xsltGenericDebug(xsltGenericDebugContext,
            "Lookup function {%s}%s\n", ns_uri, name);
#endif
 
    /* give priority to context-level functions */
    /*
    ret = (xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri);
    */
    XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
 
    if (ret == NULL)
    ret = xsltExtModuleFunctionLookup(name, ns_uri);
 
#ifdef WITH_XSLT_DEBUG_FUNCTION
    if (ret != NULL)
        xsltGenericDebug(xsltGenericDebugContext,
            "found function %s\n", name);
#endif
    return(ret);
}