### ----------------------------------------------------
### -- LibXSLT
### -- Licenses: Artistic-2.0
### -- Authors: David Warring
### -- File: etc/libxslt-api.xml
### ----------------------------------------------------
### -- Chunk 6 of 8
sltSecurityPrefsPtr' info='the current xsltSecurityPrefsPtr in use or NULL if none'/>
    </function>
    <function name='xsltGetExtData' file='extensions'>
      <info>Retrieve the data associated to the extension module in this given transformation.</info>
      <return type='void *' info='the pointer or NULL if not present'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
      <arg name='URI' type='const xmlChar *' info='the URI associated to the exension module'/>
    </function>
    <function name='xsltGetExtInfo' file='extensions'>
      <info>looks up URI in extInfos of the stylesheet</info>
      <return type='xmlHashTablePtr' info='a pointer to the hash table if found, else NULL'/>
      <arg name='style' type='xsltStylesheetPtr' info='pointer to a stylesheet'/>
      <arg name='URI' type='const xmlChar *' info='the namespace URI desired'/>
    </function>
    <function name='xsltGetKey' file='keys'>
      <info>Looks up a key of the in current source doc (the document info on @ctxt-&gt;document). Computes the key if not already done for the current source doc.</info>
      <return type='xmlNodeSetPtr' info='the nodeset resulting from the query or NULL'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
      <arg name='name' type='const xmlChar *' info='the key name or NULL'/>
      <arg name='nameURI' type='const xmlChar *' info='the name URI or NULL'/>
      <arg name='value' type='const xmlChar *' info='the key value to look for'/>
    </function>
    <function name='xsltGetNamespace' file='namespaces'>
      <info>Find a matching (prefix and ns-name) ns-declaration for the requested @ns-&gt;prefix and @ns-&gt;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)</info>
      <return type='xmlNsPtr' info='a namespace declaration or NULL in case of namespace fixup failures or API or internal errors.'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='a transformation context'/>
      <arg name='cur' type='xmlNodePtr' info='the input node'/>
      <arg name='ns' type='xmlNsPtr' info='the namespace'/>
      <arg name='out' type='xmlNodePtr' info='the output node (or its parent)'/>
    </function>
    <function name='xsltGetNsProp' file='xsltutils'>
      <info>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.</info>
      <return type='xmlChar *' info='the attribute value or NULL if not found. It&apos;s up to the caller to free the memory.'/>
      <arg name='node' type='xmlNodePtr' info='the node'/>
      <arg name='name' type='const xmlChar *' info='the attribute name'/>
      <arg name='nameSpace' type='const xmlChar *' info='the URI of the namespace'/>
    </function>
    <function name='xsltGetPlainNamespace' file='namespaces'>
      <info>Obsolete. *Not* called by any Libxslt/Libexslt function. Exaclty the same as xsltGetNamespace().</info>
      <return type='xmlNsPtr' info='a namespace declaration or NULL in case of namespace fixup failures or API or internal errors.'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='a transformation context'/>
      <arg name='cur' type='xmlNodePtr' info='the input node'/>
      <arg name='ns' type='xmlNsPtr' info='the namespace'/>
      <arg name='out' type='xmlNodePtr' info='the result element'/>
    </function>
    <function name='xsltGetProfileInformation' file='xsltutils'>
      <info>This function should be called after the transformation completed to extract template processing profiling information if available. The information is returned as an XML document tree like &lt;?xml version=&quot;1.0&quot;?&gt; &lt;profile&gt; &lt;template rank=&quot;1&quot; match=&quot;*&quot; name=&quot;&quot; mode=&quot;&quot; calls=&quot;6&quot; time=&quot;48&quot; average=&quot;8&quot;/&gt; &lt;template rank=&quot;2&quot; match=&quot;item2|item3&quot; name=&quot;&quot; mode=&quot;&quot; calls=&quot;10&quot; time=&quot;30&quot; average=&quot;3&quot;/&gt; &lt;template rank=&quot;3&quot; match=&quot;item1&quot; name=&quot;&quot; mode=&quot;&quot; calls=&quot;5&quot; time=&quot;17&quot; average=&quot;3&quot;/&gt; &lt;/profile&gt; The caller will need to free up the returned tree with xmlFreeDoc()</info>
      <return type='xmlDocPtr' info='the xmlDocPtr corresponding to the result or NULL if not available.'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='a transformation context'/>
    </function>
    <function name='xsltGetQNameURI' file='xsltutils'>
      <info>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.</info>
      <return type='const xmlChar *' info='the namespace URI if there is a prefix, or NULL if @name is not prefixed.'/>
      <arg name='node' type='xmlNodePtr' info='the node holding the QName'/>
      <arg name='name' type='xmlChar **' info='pointer to the initial QName value'/>
    </function>
    <function name='xsltGetQNameURI2' file='xsltutils'>
      <info>This function is similar to xsltGetQNameURI, but is used when @name is a dictionary entry.</info>
      <return type='const xmlChar *' info='the namespace URI if there is a prefix, or NULL if @name is not prefixed.'/>
      <arg name='style' type='xsltStylesheetPtr' info='stylesheet pointer'/>
      <arg name='node' type='xmlNodePtr' info='the node holding the QName'/>
      <arg name='name' type='const xmlChar **' info='pointer to the initial QName value'/>
    </function>
    <function name='xsltGetSecurityPrefs' file='security'>
      <info>Lookup the security option to get the callback checking function</info>
      <return type='xsltSecurityCheck' info='NULL if not found, the function otherwise'/>
      <arg name='sec' type='xsltSecurityPrefsPtr' info='the security block to update'/>
      <arg name='option' type='xsltSecurityOption' info='the option to lookup'/>
    </function>
    <function name='xsltGetSpecialNamespace' file='namespaces'>
      <info>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&apos;s priority is to preserve ns-prefixes; it will only change a prefix if there&apos;s a namespace clash. If both @nsName and @nsPrefix are NULL, then this will try to &quot;undeclare&quot; a default namespace by declaring an xmlns=&quot;&quot;.</info>
      <return type='xmlNsPtr' info='a namespace declaration or NULL.'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the transformation context'/>
      <arg name='invocNode' type='xmlNodePtr' info='the invoking node; e.g. a literal result element/attr; only used for error reports'/>
      <arg name='nsName' type='const xmlChar *' info='the namespace name (or NULL)'/>
      <arg name='nsPrefix' type='const xmlChar *' info='the suggested namespace prefix (or NULL)'/>
      <arg name='target' type='xmlNodePtr' info='the result element on which to anchor a namespace'/>
    </function>
    <function name='xsltGetTemplate' file='pattern'>
      <info>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.</info>
      <return type='xsltTemplatePtr' info='the xsltTemplatePtr or NULL if not found'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='a XSLT process context'/>
      <arg name='node' type='xmlNodePtr' info='the node being processed'/>
      <arg name='style' type='xsltStylesheetPtr' info='the current style'/>
    </function>
    <function name='xsltGetUTF8Char' file='xsltutils'>
      <info>Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API</info>
      <return type='int' info='the char value or -1 in case of error and update @len with the number of bytes used'/>
      <arg name='utf' type='const unsigned char *' info='a sequence of UTF-8 encoded bytes'/>
      <arg name='len' type='int *' info='a pointer to @bytes len'/>
    </function>
    <function name='xsltGetXIncludeDefault' file='transform'>
      <info>Provides the default state for XInclude processing</info>
      <return type='int' info='0 if there is no processing 1 otherwise'/>
    </function>
    <functype name='xsltHandleDebuggerCallback' file='xsltutils'>
      <info></info>
      <return type='void'/>
      <arg name='cur' type='xmlNodePtr' info=''/>
      <arg name='node' type='xmlNodePtr' info=''/>
      <arg name='templ' type='xsltTemplatePtr' info=''/>
      <arg name='ctxt' type='xsltTransformContextPtr' info=''/>
    </functype>
    <function name='xsltIf' file='transform'>
      <info>Processes the xsl:if instruction on the source node.</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='a XSLT process context'/>
      <arg name='contextNode' type='xmlNodePtr' info='the current node in the source tree'/>
      <arg name='inst' type='xmlNodePtr' info='the xsl:if instruction'/>
      <arg name='castedComp' type='xsltElemPreCompPtr' info='compiled information of the instruction'/>
    </function>
    <function name='xsltInit' file='xslt'>
      <info>Initializes the processor (e.g. registers built-in extensions, etc.)</info>
      <return type='void'/>
    </function>
    <function name='xsltInitAllDocKeys' file='xsltInternals'>
      <info>INTERNAL ROUTINE ONLY  Check if any keys on the current document need to be computed</info>
      <return type='int' info='0 in case of success, -1 in case of failure'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='transformation context'/>
    </function>
    <function name='xsltInitCtxtExts' file='extensions'>
      <info>Initialize the set of modules with registered stylesheet data</info>
      <return type='int' info='the number of modules initialized or -1 in case of error'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
    </function>
    <function name='xsltInitCtxtKey' file='xsltInternals'>
      <info>Computes the key tables this key and for the current input document.</info>
      <return type='int' info='0 on success, -1 on error'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
      <arg name='idoc' type='xsltDocumentPtr' info='the document information (holds key values)'/>
      <arg name='keyDef' type='xsltKeyDefPtr' info='the key definition'/>
    </function>
    <function name='xsltInitCtxtKeys' file='keys'>
      <info>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.</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
      <arg name='idoc' type='xsltDocumentPtr' info='a document info'/>
    </function>
    <function name='xsltInitElemPreComp' file='extensions'>
      <info>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.</info>
      <return type='void'/>
      <arg name='comp' type='xsltElemPreCompPtr' info='an #xsltElemPreComp (or generally a derived structure)'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='inst' type='xmlNodePtr' info='the element node'/>
      <arg name='function' type='xsltTransformFunction' info='the transform function'/>
      <arg name='freeFunc' type='xsltElemPreCompDeallocator' info='the @comp deallocator'/>
    </function>
    <function name='xsltInitGlobals' file='extensions'>
      <info>Initialize the global variables for extensions</info>
      <return type='void'/>
    </function>
    <function name='xsltIsBlank' file='xsltInternals'>
      <info>Check if a string is ignorable</info>
      <return type='int' info='1 if the string is NULL or made of blanks chars, 0 otherwise'/>
      <arg name='str' type='xmlChar *' info='a string'/>
    </function>
    <function name='xsltKeyFunction' file='functions'>
      <info>Implement the key() XSLT function node-set key(string, object)</info>
      <return type='void'/>
      <arg name='ctxt' type='xmlXPathParserContextPtr' info='the XPath Parser context'/>
      <arg name='nargs' type='int' info='the number of arguments'/>
    </function>
    <function name='xsltLoadDocument' file='documents'>
      <info>Try to load a document (not a stylesheet) within the XSLT transformation context</info>
      <return type='xsltDocumentPtr' info='the new xsltDocumentPtr or NULL in case of error'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
      <arg name='URI' type='const xmlChar *' info='the computed URI of the document'/>
    </function>
    <function name='xsltLoadStyleDocument' file='documents'>
      <info>Try to load a stylesheet document within the XSLT transformation context</info>
      <return type='xsltDocumentPtr' info='the new xsltDocumentPtr or NULL in case of error'/>
      <arg name='style' type='xsltStylesheetPtr' info='an XSLT style sheet'/>
      <arg name='URI' type='const xmlChar *' info='the computed URI of the document'/>
    </function>
    <function name='xsltLoadStylesheetPI' file='xsltInternals'>
      <info>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.</info>
      <return type='xsltStylesheetPtr' info='a new XSLT stylesheet structure or NULL if not found.'/>
      <arg name='doc' type='xmlDocPtr' info='a document to process'/>
    </function>
    <function name='xsltLocalVariablePop' file='transform'>
      <info>Pops all variable values at the given @depth from the stack.</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the transformation context'/>
      <arg name='limitNr' type='int' info='number of variables which should remain'/>
      <arg name='level' type='int' info='the depth in the xsl:template&apos;s tree'/>
    </function>
    <function name='xsltLocalVariablePush' file='transform'>
      <info>Places the variable onto the local variable stack</info>
      <return type='int' info='0 for success, -1 for any error **NOTE:** This is an internal routine and should not be called by users!'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the transformation context'/>
      <arg name='variable' type='xsltStackElemPtr' info='variable to be pushed to the variable stack'/>
      <arg name='level' type='int' info='new value for variable&apos;s level'/>
    </function>
    <function name='xsltLocaleStrcmp' file='xsltlocale'>
      <info>Compares two strings transformed with xsltStrxfrm</info>
      <return type='int' info='a value &lt; 0 if str1 sorts before str2, a value &gt; 0 if str1 sorts after str2, 0 if str1 and str2 are equal wrt sorting'/>
      <arg name='locale' type='xsltLocale' info='a locale identifier'/>
      <arg name='str1' type='const xsltLocaleChar *' info='a string transformed with xsltStrxfrm'/>
      <arg name='str2' type='const xsltLocaleChar *' info='a string transformed with xsltStrxfrm'/>
    </function>
    <function name='xsltMatchPattern' file='pattern'>
      <info></info>
      <return type='int' info=''/>
      <arg name='ctxt' type='xsltTransformContextPtr' info=''/>
      <arg name='node' type='xmlNodePtr' info=''/>
      <arg name='pattern' type='const xmlChar *' info=''/>
      <arg name='ctxtdoc' type='xmlDocPtr' info=''/>
      <arg name='ctxtnode' type='xmlNodePtr' info=''/>
    </function>
    <function name='xsltMessage' file='xsltutils'>
      <info>Process and xsl:message construct</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT processing context'/>
      <arg name='node' type='xmlNodePtr' info='The current node'/>
      <arg name='inst' type='xmlNodePtr' info='The node containing the message instruction'/>
    </function>
    <function name='xsltNamespaceAlias' file='namespaces'>
      <info>Read the stylesheet-prefix and result-prefix attributes, register them as well as the corresponding namespace.</info>
      <return type='void'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='node' type='xmlNodePtr' info='the xsl:namespace-alias node'/>
    </function>
    <function name='xsltNeedElemSpaceHandling' file='imports'>
      <info>Checks whether that stylesheet requires white-space stripping</info>
      <return type='int' info='1 if space should be stripped, 0 if not'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context'/>
    </function>
    <function name='xsltNewDocument' file='documents'>
      <info>Register a new document, apply key computations</info>
      <return type='xsltDocumentPtr' info='a handler to the document'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='an XSLT transformation context (or NULL)'/>
      <arg name='doc' type='xmlDocPtr' info='a parsed XML document'/>
    </function>
    <function name='xsltNewElemPreComp' file='extensions'>
      <info>Creates and initializes an #xsltElemPreComp</info>
      <return type='xsltElemPreCompPtr' info='the new and initialized #xsltElemPreComp'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='inst' type='xmlNodePtr' info='the element node'/>
      <arg name='function' type='xsltTransformFunction' info='the transform function'/>
    </function>
    <function name='xsltNewLocale' file='xsltlocale'>
      <info>Creates a new locale of an opaque system dependent type based on the language tag.</info>
      <return type='xsltLocale' info='the locale or NULL on error or if no matching locale was found'/>
      <arg name='languageTag' type='const xmlChar *' info='RFC 3066 language tag'/>
    </function>
    <function name='xsltNewSecurityPrefs' file='security'>
      <info>Create a new security preference block</info>
      <return type='xsltSecurityPrefsPtr' info='a pointer to the new block or NULL in case of error'/>
    </function>
    <function name='xsltNewStyleDocument' file='documents'>
      <info>Register a new document, apply key computations</info>
      <return type='xsltDocumentPtr' info='a handler to the document'/>
      <arg name='style' type='xsltStylesheetPtr' info='an XSLT style sheet'/>
      <arg name='doc' type='xmlDocPtr' info='a parsed XML document'/>
    </function>
    <function name='xsltNewStylesheet' file='xsltInternals'>
      <info>Create a new XSLT Stylesheet</info>
      <return type='xsltStylesheetPtr' info='the newly allocated xsltStylesheetPtr or NULL in case of error'/>
    </function>
    <function name='xsltNewTransformContext' file='transform'>
      <info>Create a new XSLT TransformContext</info>
      <return type='xsltTransformContextPtr' info='the newly allocated xsltTransformContextPtr or NULL in case of error'/>
      <arg name='style' type='xsltStylesheetPtr' info='a parsed XSLT stylesheet'/>
      <arg name='doc' type='xmlDocPtr' info='the input document'/>
    </function>
    <function name='xsltNextImport' file='imports'>
      <info>Find the next stylesheet in import precedence.</info>
      <return type='xsltStylesheetPtr' info='the next stylesheet or NULL if it was the last one'/>
      <arg name='cur' type='xsltStylesheetPtr' info='the current XSLT stylesheet'/>
    </function>
    <function name='xsltNormalizeCompSteps' file='pattern'>
      <info>This is a hashtable scanner function to normalize the compiled steps of an imported stylesheet.</info>
      <return type='void'/>
      <arg name='payload' type='void *' info='pointer to template hash table entry'/>
      <arg name='data' type='void *' info='pointer to the stylesheet'/>
      <arg name='name' type='const xmlChar *' info='template match name'/>
    </function>
    <function name='xsltNumber' file='transform'>
      <info>Process the xslt number node on the source node</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='a XSLT process context'/>
      <arg name='node' type='xmlNodePtr' info='the node in the source tree.'/>
      <arg name='inst' type='xmlNodePtr' info='the xslt number node'/>
      <arg name='castedComp' type='xsltElemPreCompPtr' info='precomputed information'/>
    </function>
    <function name='xsltNumberFormat' file='xsltInternals'>
      <info>Convert one number.</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the XSLT transformation context'/>
      <arg name='data' type='xsltNumberDataPtr' info='the formatting information'/>
      <arg name='node' type='xmlNodePtr' info='the data to format'/>
    </function>
    <function name='xsltParseAnyXSLTElem' file='xsltInternals'>
      <info>Parses, validates the content models and compiles XSLT instructions.</info>
      <return type='int' info='0 if everything&apos;s fine; -1 on API or internal errors.'/>
      <arg name='cctxt' type='xsltCompilerCtxtPtr' info='the compilation context'/>
      <arg name='elem' type='xmlNodePtr' info='the element node of the XSLT instruction'/>
    </function>
    <function name='xsltParseGlobalParam' file='variables'>
      <info>parse an XSLT transformation param declaration and record its value.</info>
      <return type='void'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='cur' type='xmlNodePtr' info='the &quot;param&quot; element'/>
    </function>
    <function name='xsltParseGlobalVariable' file='variables'>
      <info>Parses a global XSLT &apos;variable&apos; declaration at compilation time and registers it</info>
      <return type='void'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='cur' type='xmlNodePtr' info='the &quot;variable&quot; element'/>
    </function>
    <function name='xsltParseSequenceConstructor' file='xsltInternals'>
      <info>Parses a &quot;template&quot; content (or &quot;sequence constructor&quot; in XSLT 2.0 terms). This will additionally remove xsl:text elements from the tree.</info>
      <return type='void'/>
      <arg name='cctxt' type='xsltCompilerCtxtPtr' info='the compilation context'/>
      <arg name='cur' type='xmlNodePtr' info='the start-node of the content to be parsed'/>
    </function>
    <function name='xsltParseStylesheetAttributeSet' file='attributes'>
      <info>parse an XSLT stylesheet attribute-set element</info>
      <return type='void'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='cur' type='xmlNodePtr' info='the &quot;attribute-set&quot; element'/>
    </function>
    <function name='xsltParseStylesheetCallerParam' file='variables'>
      <info>Processes an xsl:with-param instruction at transformation time. The value is computed, but not recorded. NOTE that this is also called with an *xsl:param* element from exsltFuncFunctionFunction().</info>
      <return type='xsltStackElemPtr' info='the new xsltStackElemPtr or NULL'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the XSLT transformation context'/>
      <arg name='inst' type='xmlNodePtr' info='the xsl:with-param instruction element'/>
    </function>
    <function name='xsltParseStylesheetDoc' file='xsltInternals'>
      <info>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.</info>
      <return type='xsltStylesheetPtr' info='a new XSLT stylesheet structure.'/>
      <arg name='doc' type='xmlDocPtr' info='and xmlDoc parsed XML'/>
    </function>
    <function name='xsltParseStylesheetFile' file='xsltInternals'>
      <info>Load and parse an XSLT stylesheet</info>
      <return type='xsltStylesheetPtr' info='a new XSLT stylesheet structure.'/>
      <arg name='filename' type='const xmlChar *' info='the filename/URL to the stylesheet'/>
    </function>
    <function name='xsltParseStylesheetImport' file='imports'>
      <info>parse an XSLT stylesheet import element</info>
      <return type='int' info='0 in case of success -1 in case of failure.'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='cur' type='xmlNodePtr' info='the import element'/>
    </function>
    <function name='xsltParseStylesheetImportedDoc' file='xsltInternals'>
      <info>parse an XSLT stylesheet building the associated structures except the processing not needed for imported documents.</info>
      <return type='xsltStylesheetPtr' info='a new XSLT stylesheet structure.'/>
      <arg name='doc' type='xmlDocPtr' info='an xmlDoc parsed XML'/>
      <arg name='parentStyle' type='xsltStylesheetPtr' info='pointer to the parent stylesheet (if it exists)'/>
    </function>
    <function name='xsltParseStylesheetInclude' file='imports'>
      <info>parse an XSLT stylesheet include element</info>
      <return type='int' info='0 in case of success -1 in case of failure'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='cur' type='xmlNodePtr' info='the include node'/>
    </function>
    <function name='xsltParseStylesheetOutput' file='xsltInternals'>
      <info>parse an XSLT stylesheet output element and record information related to the stylesheet output</info>
      <return type='void'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='cur' type='xmlNodePtr' info='the &quot;output&quot; element'/>
    </function>
    <function name='xsltParseStylesheetParam' file='variables'>
      <info>Registers a local XSLT &apos;param&apos; declaration at transformation time and evaluates its value.</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the XSLT transformation context'/>
      <arg name='cur' type='xmlNodePtr' info='the XSLT &apos;param&apos; element'/>
    </function>
    <function name='xsltParseStylesheetProcess' file='xsltInternals'>
      <info>Parses an XSLT stylesheet, adding the associated structures. Called by: xsltParseStylesheetImportedDoc() (xslt.c) xsltParseStylesheetInclude() (imports.c)</info>
      <return type='xsltStylesheetPtr' info='the value of the @style parameter if everything went right, NULL if something went amiss.'/>
      <arg name='ret' type='xsltStylesheetPtr' info='the XSLT stylesheet (the current stylesheet-level)'/>
      <arg name='doc' type='xmlDocPtr' info='and xmlDoc parsed XML'/>
    </function>
    <function name='xsltParseStylesheetUser' file='xsltInternals'>
      <info>Parse an XSLT stylesheet with a user-provided stylesheet struct.</info>
      <return type='int' info='0 if successful, -1 in case of error.'/>
      <arg name='style' type='xsltStylesheetPtr' info='pointer to the stylesheet'/>
      <arg name='doc' type='xmlDocPtr' info='an xmlDoc parsed XML'/>
    </function>
    <function name='xsltParseStylesheetVariable' file='variables'>
      <info>Registers a local XSLT &apos;variable&apos; instruction at transformation time and evaluates its value.</info>
      <return type='void'/>
      <arg name='ctxt' type='xsltTransformContextPtr' info='the XSLT transformation context'/>
      <arg name='inst' type='xmlNodePtr' info='the xsl:variable instruction element'/>
    </function>
    <function name='xsltParseTemplateContent' file='xsltInternals'>
      <info>parse a template content-model Clean-up the template content from unwanted ignorable blank nodes and process xslt:text</info>
      <return type='void'/>
      <arg name='style' type='xsltStylesheetPtr' info='the XSLT stylesheet'/>
      <arg name='templ' type='xmlNodePtr' info='the container node (can be a document for literal results)'/>
    </function>
    <function name='xsltPointerListAddSize' file='xsltInternals'>
      <info>Adds an item to the list.</info>
      <return type='int' info='the position of the added item in the list or -1 in case of an error.'/>
      <arg name='list' type='xsltPointerListPtr' info='the pointer list structure'/>
      <arg name='item' type='void *' info='the item to be stored'/>
      <arg name='initialSize' type='int' info='the initial size of the list'/>
    </function>
    <function name='xsltPointerListClear' file='xsltInternals'>
      <info>Resets the list, but does not free the allocated array and does not free the content of the list.</info>
      <return type='void'/>
      <arg name='list' type='xsltPointerListPtr' info='pointer to the list to be cleared'/>
    </function>
    <function name='xsltPointerListCreate' file='xsltInternals'>
      <info>Creates an xsltPointerList structure.</info>
      <return type='xsltPointerListPtr' info='a xsltPointerList structure or NULL in case of an error.'/>
      <arg name='initialSize' type='int' info='the initial size for the list'/>
    </function>
    <function name='xsltPointerListFree' file='xsltInternals'>
      <info>Frees the xsltPointerList structure. This does not free the content of the list.</info>
      <return type='void'/>
      <arg name='list' type='xsltPointerListPtr' info='pointer to the list to be freed'/>
    </function>
    <function name='xsltPreComputeExtModuleElement' file='extensions'>
      <info>Precomputes an extension module element</info>
      <return type='xsltElemPreCompPtr' info='the precomputed data'/>
      <arg name='style' type='xsltStylesheetPtr' info='the stylesheet'/>
      <arg name='inst' type='xmlNodePtr' info='the element