interface for the XSLT attribute handling

this module handles the specificities of attribute and attribute groups processing. Daniel Veillard

interface for the document handling

implements document loading and cache (multiple document() reference for the same resources must be equal. Daniel Veillard

interface for the extension support

This provide the API needed for simple and module extension support. Daniel Veillard

interface for the non-standard features

implement some extension outside the XSLT namespace but not EXSLT with is in a different library. Daniel Veillard

interface for the XSLT functions not from XPath

a set of extra functions coming from XSLT but not in XPath Daniel Veillard and Bjorn Reese <breese@users.sourceforge.net>

interface for the XSLT import support

macros and fuctions needed to implement and access the import tree Daniel Veillard

interface for the key matching used in key() and template matches.

implementation of the key mechanims. Daniel Veillard

interface for the XSLT namespace handling

set of function easing the processing and generation of namespace nodes in XSLT. Daniel Veillard

Implementation of the XSLT number functions

Implementation of the XSLT number functions Bjorn Reese <breese@users.sourceforge.net> and Daniel Veillard

interface for the pattern matching used in template matches.

the implementation of the lookup of the right template for a given node must be really fast in order to keep decent performances. Daniel Veillard

precomputing stylesheets

this is the compilation phase, where most of the stylesheet is "compiled" into faster to use data. Daniel Veillard

interface for the libxslt security framework

the libxslt security framework allow to restrict the access to new resources (file or URL) from the stylesheet at runtime. Daniel Veillard

interface for the template processing

This set of routine encapsulates XPath calls and Attribute Value Templates evaluation. Daniel Veillard

the XSLT engine transformation part.

This module implements the bulk of the actual Daniel Veillard

interface for the variable matching and lookup.

interface for the variable matching and lookup. Daniel Veillard

Interfaces, constants and types related to the XSLT engine

Interfaces, constants and types related to the XSLT engine Daniel Veillard

internal data structures, constants and functions

Internal data structures, constants and functions used by the XSLT engine. They are not part of the API or ABI, i.e. they can change without prior notice, use carefully. Daniel Veillard

macros for marking symbols as exportable/importable.

macros for marking symbols as exportable/importable. Igor Zlatkovic <igor@zlatkovic.com>

Locale handling

Interfaces for locale handling. Needed for language dependent sorting. Nick Wellnhofer

set of utilities for the XSLT engine

interfaces for the utilities module of the XSLT engine. things like message handling, profiling, and other generally useful routines. Daniel Veillard Macro to check if the XSLT processing should be stopped. Will return from the function. Macro to check if the XSLT processing should be stopped. Will return from the function with a 0 value. Macro to check if the XSLT processing should be stopped. Will goto the error: label. quick check for xslt namespace attribute Checks that the element pertains to XSLT namespace. quick check whether this is an xslt element Checks the value of an element in XSLT namespace. Check that a node is a 'real' one: document, element, text or attribute. check for bit 15 set Special value for undefined namespace, internal Macro to do a casting from an object pointer to a function pointer without encountering a warning from gcc #define XML_CAST_FPTR(fptr) (*(void **)(&fptr)) This macro violated ISO C aliasing rules (gcc4 on s390 broke) so it is disabled now get pointer to compiler context The XSLT "vendor" URL for this processor. The XSLT "vendor" string for this processor. The default version of XSLT supported. Internal define to enable usage of xmlXPathCompiledEvalToBoolean() for XSLT "tests"; e.g. in <xsl:if test="/foo/bar"> A macro to import intergers from the stylesheet cascading order. A macro to import pointers from the stylesheet cascading order. get pointer to namespace map check for namespace mapping internal macro to test tree fragments check if the argument is a text node Common fields used for all items. Fields for API compatibility to the structure _xsltElemPreComp which is used for extension functions. Note that @next is used for storage; it does not reflect a next sibling in the tree. TODO: Evaluate if we really need such a compatibility. Currently empty. TODO: It is intended to hold navigational fields in the future. The in-scope namespaces. This is the libxslt namespace for specific extensions. Macro indicating that locale are not supported internal macro to set up tree fragments Max number of specified xsl:sort on an element. The XSLT specification namespace. This is Norm's namespace for SAXON extensions. The set of options to pass to an xmlReadxxx when loading files for XSLT consumption. Specific value for pattern without priority expressed. Internal define to enable on-demand xsl:key computation. That's the only mode now but the define is kept for compatibility Internal define to enable the refactored variable part of libxslt Internal define to enable the optimization of the compilation of XPath expressions. Registering macro, not general purpose at all but used in different modules. Registering macro, not general purpose at all but used in different modules. Macro used to define extra information stored in the context Macro used to free extra information stored in the context Macro used to access extra information stored in the context This is Michael Kay's Saxon processor namespace for extensions. Macro to flag that a problem was detected internally. Sampling precision for profiling Macro to flag unimplemented blocks. Control the type of xsl debugtrace messages emitted. This is the Apache project XALAN processor namespace for extensions. This is James Clark's XT processor namespace for extensions. Add template "call" to call stack Drop the topmost item off the call stack If either cur or node are a breakpoint, or xslDebugStatus in state where debugging must occcur at this time then transfer control to the xslDebugBreak function add a key definition to a stylesheet Push an element list onto the stack. Register the XSLT pattern associated to @cur Allocate an extra runtime information slot statically while compiling the stylesheet and return its number Allocate an extra runtime information slot at run-time and return its number This make sure there is a slot ready in the transformation context Apply the xsl:use-attribute-sets. If @attrSets is NULL, then @inst will be used to exctract this value. If both, @attrSets and @inst, are NULL, then this will do nothing. Process the XSLT apply-imports element. Processes a sequence constructor on the current node in the source tree. @params are the already computed variable stack items; this function pushes them on the variable stack, and pops them before exiting; it's left to the caller to free or reuse @params afterwards. The initial states of the variable stack will always be restored before this function exits. NOTE that this does *not* initiate a new distinct variable scope; i.e. variables already on the stack are visible to the process. The caller's side needs to start a new variable scope if needed (e.g. in exsl:function). @templ is obsolete and not used anymore (e.g. <exslt:function> does not provide a @templ); a non-NULL @templ might raise an error in the future. BIG NOTE: This function is not intended to process the content of an xsl:template; it does not expect xsl:param instructions in @list and will report errors if found. Called by: - xsltEvalVariable() (variables.c) - exsltFuncFunctionFunction() (libexsl/functions.c) Strip the unwanted ignorable spaces from the input tree Apply the stylesheet to the document NOTE: This may lead to a non-wellformed output XML wise ! Apply the stylesheet to the document and allow the user to provide its own transformation context. Processes the XSLT 'apply-templates' instruction on the current node. Processes all attributes of a Literal Result Element. Attribute references are applied via xsl:use-attribute-set attributes. Copies all non XSLT-attributes over to the @target element and evaluates Attribute Value Templates. Called by xsltApplySequenceConstructor() (transform.c). Process one attribute of a Literal Result Element (in the stylesheet). Evaluates Attribute Value Templates and copies the attribute over to the result element. This does *not* process attribute sets (xsl:use-attribute-set). Process the given node and return the new string value. Process the given string, allowing to pass a namespace mapping context and return the new string value. Called by: - xsltAttrTemplateValueProcess() (templates.c) - xsltEvalAttrValueTemplate() (templates.c) QUESTION: Why is this function public? It is not used outside of templates.c. Process the xslt attribute node on the source node Used for to correct the calibration for xsltTimestamp() Processes the XSLT call-template instruction on the source node. Check if the given prefix is one of the declared extensions. This is intended to be called only at compile-time. Called by: xsltGetInheritedNsList() (xslt.c) xsltParseTemplateContent (xslt.c) Check if the given prefix is one of the declared extensions. This is intended to be called only at compile-time. Called by: xsltPrecomputeStylesheet() (xslt.c) xsltParseTemplateContent (xslt.c) Check if the resource is allowed to be read Check if the resource is allowed to be written, if necessary makes some preliminary work like creating directories Processes the xsl:choose instruction on the source node. Unregister all global variables set up by the XSLT library Cleanup the state of the templates used by the stylesheet and the ones it imports. Process the xslt comment node on the source node Precompile an attribute in a stylesheet, basically it checks if it is an attrubute value template, and if yes establish some structures needed to process it at transformation time. Compile the XSLT pattern and generates a list of precompiled form suitable for fast matching. [1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern reorder the current node list accordingly to the set of sorting requirement provided by the array of nodes. Execute the XSLT-copy instruction on the source node. Copies a namespace node (declaration). If @elem is not NULL, then the new namespace will be declared on @elem. Do a copy of an namespace list. If @node is non-NULL the new namespaces are added automatically. This handles namespaces aliases. This function is intended only for *internal* use at transformation-time for copying ns-declarations of Literal Result Elements. Called by: xsltCopyTreeInternal() (transform.c) xsltShallowCopyElem() (transform.c) REVISIT: This function won't be used in the refactored code. Process the XSLT copy-of instruction. Adds @string to a newly created or an existent text node child of @target. Creates a Result Value Tree (the XSLT 1.0 term for this is "Result Tree Fragment") Process an debug node Dumps a list of the registered XSLT extension functions and elements Get the current default debug tracing level mask Set the default debug tracing level mask Find decimal-format by name reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. This is a wrapper function, the actual function used is specified using xsltSetCtxtSortFunc() to set the context specific sort function, or xsltSetSortFunc() to set the global sort function. If a sort function is set on the context, this will get called. Otherwise the global sort function is called. An xsltDocLoaderFunc is a signature for a function which can be registered to load document not provided by the compilation or transformation API themselve, for example when an xsl:import, xsl:include is found at compilation time or when a document() call is made at runtime. Pre process an XSLT-1.1 document element Process an EXSLT/XSLT-1.1 document element Implement the document() XSLT function node-set document(object, node-set?) reorder the current node list @list accordingly to the document order This function is slow, obsolete and should not be used anymore. Deallocates an #xsltElemPreComp structure. Process the xslt element node on the source node Implement the element-available() XSLT function boolean element-available(string) Process the given AVT, and return the new string value. Evaluate a attribute value template, i.e. the attribute value can contain expressions contained in curly braces ({}) and those are substituted by they computed value. Evaluates all global variables and parameters of a stylesheet. For internal use only. This is called at start of a transformation. This is normally called from xsltEvalUserParams to process a single parameter from a list of parameters. The @value is evaluated as an XPath expression and the result is stored in the context's global variable/parameter hash table. To have a parameter treated literally (not as an XPath expression) use xsltQuoteUserParams (or xsltQuoteOneUserParam). For more details see description of xsltProcessOneUserParamInternal. Check if an attribute value template has a static value, i.e. the attribute value does not contain expressions contained in curly braces ({}) Processes the sequence constructor of the given instruction on @contextNode and converts the resulting tree to a string. This is needed by e.g. xsl:comment and xsl:processing-instruction. Evaluate the global variables of a stylesheet. This needs to be done on parsed stylesheets before starting to apply transformations. Each of the parameters is evaluated as an XPath expression and stored in the global variables/parameter hash table. If you want your parameter used literally, use xsltQuoteUserParams. Process the expression using XPath and evaluate the result as an XPath predicate Process the expression using XPath and get a string Process the expression using XPath, allowing to pass a namespace mapping context and get a string Looks up an extension element. @ctxt can be NULL to search only in module elements. A function called at initialization time of an XSLT extension module. Looks up an extension module element Looks up an extension module element pre-computation function Looks up an extension module function Looks up an extension module top-level element A function called at shutdown time of an XSLT extension module. Finalizes the data (e.g. result tree fragments) created within a value-returning process (e.g. EXSLT's function). Tree fragments marked as being returned by a function are set to normal state, which means that the fragment garbage collector will free them after the function-calling process exits. Marks the result of a value-returning extension instruction in order to avoid it being garbage collected before the extension instruction exits. Note that one still has to additionally register any newly created tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT(). Try to find a document within the XSLT transformation context. This will not find document infos for temporary Result Tree Fragments. Find strip-space or preserve-space informations for an element respect the import precedence or the wildcards Finds the named template, apply import precedence rule. REVISIT TODO: We'll change the nameURI fields of templates to be in the string dict, so if the specified @nameURI is in the same dict, then use pointer comparison. Check if this can be done in a sane way. Maybe this function is not needed internally at transformation-time if we hard-wire the called templates to the caller. Process the xslt for-each node on the source node format-number() uses the JDK 1.1 DecimalFormat class: http://java.sun.com/products/jdk/1.1/docs/api/java.text.DecimalFormat.html Structure: pattern := subpattern{;subpattern} subpattern := {prefix}integer{.fraction}{suffix} prefix := '\\u0000'..'\\uFFFD' - specialCharacters suffix := '\\u0000'..'\\uFFFD' - specialCharacters integer := '#'* '0'* '0' fraction := '0'* '#'* Notation: X* 0 or more instances of X (X | Y) either X or Y. X..Y any character from X up to Y, inclusive. S - T characters in S, except those in T Special Characters: Symbol Meaning 0 a digit # a digit, zero shows as absent . placeholder for decimal separator , placeholder for grouping separator. ; separates formats. - default negative prefix. % multiply by 100 and show as percentage ? multiply by 1000 and show as per mille X any other characters can be used in the prefix or suffix ' used to quote special characters in a prefix or suffix. Implement the format-number() XSLT function string format-number(number, string, string?) Free up the memory associated to the attribute value templates Free up the memory used by attribute sets Free up the memory allocated by all the elements of @comp Free the XSLT extension data Free the keys associated to a document Free up all the space used by the loaded documents Free up the memory used by XSLT extensions in a stylesheet Free up the data associated to the global variables its value. Free up the memory used by XSLT keys in a stylesheet Frees a locale created with xsltNewLocale Free up the memory used by namespaces aliases Frees all registered result value trees (Result Tree Fragments) of the transformation. Internal function; should not be called by user-code. Free up a security preference block Free up the memory allocated by @elem Frees the node-trees (and xsltDocument structures) of all stylesheet-modules of the stylesheet-level represented by the given @style. Free up the memory allocated by all precomputed blocks Free up the memory allocated by @style Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism Free up the memory allocated by @ctxt Implement the function-available() XSLT function boolean function-available(string) Implement the node-set() XSLT function node-set node-set(result-tree) This function is available in libxslt, saxon or xt namespace. Implement the generate-id() XSLT function string generate-id(node-set?) Similar to xmlGetNsProp() but with a slightly different semantic Search and get the value of an attribute associated to a node This attribute has to be anchored in the namespace specified, or has no namespace and the element is in that namespace. This does the entity substitution. This function looks in DTD attribute declaration for #FIXED or default declaration values unless DTD use has been turned off. Get xslDebugStatus. Get the default security preference application-wide Retrieve the data associated to the extension module in this given transformation. looks up URI in extInfos of the stylesheet Looks up a key of the in current source doc (the document info on @ctxt->document). Computes the key if not already done for the current source doc. Find a matching (prefix and ns-name) ns-declaration for the requested @ns->prefix and @ns->href in the result tree. If none is found then a new ns-declaration will be added to @resultElem. If, in this case, the given prefix is already in use, then a ns-declaration with a modified ns-prefix be we created. Called by: - xsltCopyPropList() (*not* anymore) - xsltShallowCopyElement() - xsltCopyTreeInternal() (*not* anymore) - xsltApplySequenceConstructor() (*not* in the refactored code), - xsltElement() (*not* anymore) Similar to xmlGetNsProp() but with a slightly different semantic Search and get the value of an attribute associated to a node This attribute has to be anchored in the namespace specified, or has no namespace and the element is in that namespace. This does the entity substitution. This function looks in DTD attribute declaration for #FIXED or default declaration values unless DTD use has been turned off. Obsolete. *Not* called by any Libxslt/Libexslt function. Exaclty the same as xsltGetNamespace(). This function should be called after the transformation completed to extract template processing profiling informations if availble. The informations are returned as an XML document tree like <?xml version="1.0"?> <profile> <template rank="1" match="*" name="" mode="" calls="6" time="48" average="8"/> <template rank="2" match="item2|item3" name="" mode="" calls="10" time="30" average="3"/> <template rank="3" match="item1" name="" mode="" calls="5" time="17" average="3"/> </profile> The caller will need to free up the returned tree with xmlFreeDoc() This function analyzes @name, if the name contains a prefix, the function seaches the associated namespace in scope for it. It will also replace @name value with the NCName, the old value being freed. Errors in the prefix lookup are signalled by setting @name to NULL. NOTE: the namespace returned is a pointer to the place where it is defined and hence has the same lifespan as the document holding it. This function is similar to xsltGetQNameURI, but is used when @name is a dictionary entry. Lookup the security option to get the callback checking function Find a matching (prefix and ns-name) ns-declaration for the requested @nsName and @nsPrefix in the result tree. If none is found then a new ns-declaration will be added to @resultElem. If, in this case, the given prefix is already in use, then a ns-declaration with a modified ns-prefix be we created. Note that this function's priority is to preserve ns-prefixes; it will only change a prefix if there's a namespace clash. If both @nsName and @nsPrefix are NULL, then this will try to "undeclare" a default namespace by declaring an xmlns="". Finds the template applying to this node, if @style is non-NULL it means one needs to look for the next imported template in scope. Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API Provides the default state for XInclude processing Processes the xsl:if instruction on the source node. Initializes the processor (e.g. registers built-in extensions, etc.) INTERNAL ROUTINE ONLY Check if any keys on the current document need to be computed Initialize the set of modules with registered stylesheet data Computes the key tables this key and for the current input document. Computes all the keys tables for the current input document. Should be done before global varibales are initialized. NOTE: Not used anymore in the refactored code. Initializes an existing #xsltElemPreComp structure. This is usefull when extending an #xsltElemPreComp to store precomputed data. This function MUST be called on any extension element precomputed data struct. Initialize the global variables for extensions Check if a string is ignorable Implement the key() XSLT function node-set key(string, object) Try to load a document (not a stylesheet) within the XSLT transformation context Try to load a stylesheet document within the XSLT transformation context This function tries to locate the stylesheet PI in the given document If found, and if contained within the document, it will extract that subtree to build the stylesheet to process @doc (doc itself will be modified). If found but referencing an external document it will attempt to load it and generate a stylesheet from it. In both cases, the resulting stylesheet and the document need to be freed once the transformation is done. Pops all variable values at the given @depth from the stack. Places the variable onto the local variable stack Compares two strings transformed with xsltStrxfrm Process and xsl:message construct Read the stylesheet-prefix and result-prefix attributes, register them as well as the corresponding namespace. Checks whether that stylesheet requires white-space stripping Register a new document, apply key computations Creates and initializes an #xsltElemPreComp Creates a new locale of an opaque system dependent type based on the language tag. Create a new security preference block Register a new document, apply key computations Create a new XSLT Stylesheet Create a new XSLT TransformContext Find the next stylesheet in import precedence. This is a hashtable scanner function to normalize the compiled steps of an imported stylesheet. Process the xslt number node on the source node Convert one number. Parses, validates the content models and compiles XSLT instructions. parse an XSLT transformation param declaration and record its value. Parses a global XSLT 'variable' declaration at compilation time and registers it Parses a "template" content (or "sequence constructor" in XSLT 2.0 terms). This will additionally remove xsl:text elements from the tree. parse an XSLT stylesheet attribute-set element Processes an xsl:with-param instruction at transformation time. The value is compute, but not recorded. NOTE that this is also called with an *xsl:param* element from exsltFuncFunctionFunction(). parse an XSLT stylesheet, building the associated structures. doc is kept as a reference within the returned stylesheet, so changes to doc after the parsing will be reflected when the stylesheet is applied, and the doc is automatically freed when the stylesheet is closed. Load and parse an XSLT stylesheet parse an XSLT stylesheet import element parse an XSLT stylesheet building the associated structures except the processing not needed for imported documents. parse an XSLT stylesheet include element parse an XSLT stylesheet output element and record information related to the stylesheet output Registers a local XSLT 'param' declaration at transformation time and evaluates its value. Parses an XSLT stylesheet, adding the associated structures. Called by: xsltParseStylesheetImportedDoc() (xslt.c) xsltParseStylesheetInclude() (imports.c) Registers a local XSLT 'variable' instruction at transformation time and evaluates its value. parse a template content-model Clean-up the template content from unwanted ignorable blank nodes and process xslt:text Adds an item to the list. Resets the list, but does not free the allocated array and does not free the content of the list. Creates an xsltPointerList structure. Frees the xsltPointerList structure. This does not free the content of the list. Precomputes an extension module element Display the context of an error. Process the xslt processing-instruction node on the source node Apply the stylesheet to the document and dump the profiling to the given output. This is normally called from xsltQuoteUserParams to process a single parameter from a list of parameters. The @value is stored in the context's global variable/parameter hash table. Similar to xsltEvalUserParams, but the values are treated literally and are * *not* evaluated as XPath expressions. This should be done on parsed stylesheets before starting to apply transformations. Registers all default XSLT elements in this context Registers the built-in extensions Registers all default XSLT functions in this context Registers an extension element Registers an extension function Register an XSLT extension module to the library. Registers an extension module element. Register an XSLT extension module to the library. Registers an extension module function. Registers an extension module top-level element. Registers an extension namespace This is called from xslt.c during compile-time. The given prefix is not needed. Called by: xsltParseExtElemPrefixes() (new function) xsltRegisterExtPrefix() (old function) Registers the built-in extensions. This function is deprecated, use xsltRegisterAllExtras instead. Registers a result value tree (XSLT 1.0 term: Result Tree Fragment) in the RVT garbage collector. The fragment will be freed when the instruction which created the fragment exits. Register the result value tree (XSLT 1.0 term: Result Tree Fragment) in the fragment garbage collector. The fragment will be freed when the transformation context is freed. Registers the test module Registers the result value tree (XSLT 1.0 term: Result Tree Fragment) in the garbage collector. The fragment will be freed at the exit of the currently instantiated xsl:template. Obsolete; this function might produce massive memory overhead, since the fragment is only freed when the current xsl:template exits. Use xsltRegisterLocalRVT() instead. Either frees the RVT (which is an xmlDoc) or stores it in the context's cache for later reuse. resolve the references between attribute sets. Restore the namespaces for the document Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8 Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8 Save the profiling informations on @output Save the result @result obtained by applying the @style stylesheet to an I/O output channel @buf Save the result @result obtained by applying the @style stylesheet to an open file descriptor This does not close the descriptor. Save the result @result obtained by applying the @style stylesheet to an open FILE * I/O. This does not close the FILE @file Save the result @result obtained by applying the @style stylesheet to a file or @URL Save the result @result obtained by applying the @style stylesheet to a new allocated string. Function used to always allow an operation User provided function to check the value of a string like a file path or an URL ... Function used to always forbid an operation Change the default parser option passed by the XSLT engine to the parser when using document() loading. Set the security preference for a specific transformation Function to set the handler for XSLT sorting for the specified context. If the handler is NULL, then the global sort function will be called This function allow to plug a debugger into the XSLT library @block points to a block of memory containing the address of @no callback routines. This function sets the value of xslDebugStatus. Set the default security preference application-wide Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing or validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL. Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing nor validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL. Set the new function to load document, if NULL it resets it to the default function. Update the security option to use the new callback checking function Function to reset the global handler for XSLT sorting. If the handler is NULL, the default sort function will be used. Function to reset the handler and the error context for out of context error messages specific to a given XSLT transromation. This simply means that @handler will be called for subsequent error messages while running the transformation. Set whether XInclude should be processed on document being loaded by default Shutdown the set of modules loaded Shutdown the set of modules loaded function attached to xsl:sort nodes, but this should not be called directly Signature of the function to use during sorting Split QNames into prefix and local names, both allocated from a dictionary. Transforms a string according to locale. The transformed string must then be compared with xsltLocaleStrcmp and freed with xmlFree. A function called at initialization time of an XSLT extension module. A function called at shutdown time of an XSLT extension module. Retrieve the data associated to the extension module in this given stylesheet. Called by: xsltRegisterExtPrefix(), ( xsltExtElementPreCompTest(), xsltExtInitTest ) Precompute an XSLT stylesheet element Retrieve the data associated to the extension module in this given stylesheet. Implement the system-property() XSLT function object system-property(string) Obsolete. Don't use it. Test whether the node matches one of the patterns in the list Process the xslt text node on the source node Used for gathering profiling data Display and format an error messages, gives file, line, position and extra parameters, will use the specific transformation context if available Signature of the function associated to elements part of the stylesheet language like xsl:if or xsl:apply-templates. Uninitializes the processor. Implement the unparsed-entity-uri() XSLT function string unparsed-entity-uri(string) Unregister an XSLT extension module from the library. Unregisters an extension module element Unregisters an extension module function Unregisters an extension module top-level element Process the xslt value-of node on the source node Search in the Variable array of the context for the given variable value. Compile an XPath expression This is the entry point when a function is needed by the XPath interpretor. Provides the XSLT transformation context from the XPath transformation context. This is useful when an XPath function in the extension module is called by the XPath interpreter and that the XSLT context is needed for example to retrieve the associated data pertaining to this XSLT transformation. This is the entry point when a varibale is needed by the XPath interpretor.