diff --git a/doc/html/libxslt-attributes.html b/doc/html/libxslt-attributes.html index 6ff69179..decbbb79 100644 --- a/doc/html/libxslt-attributes.html +++ b/doc/html/libxslt-attributes.html @@ -123,7 +123,7 @@ NAME="LIBXSLT-ATTRIBUTES" >

Name

Synopsis

Description

Details

parse an XSLT stylesheet preserve-space element and record +elements needing preserving

  the XSLT stylesheet

Free up the memory used by attribute sets

  an XSLT stylesheet

Apply the xsl:use-attribute-sets

  the XSLT stylesheet  the node in the source tree.  the xslt attribute node  the set list.

Name

Synopsis

Description

Details

A function called at initialization time of an XSLT extension module

  the namespace URI for the extension

A function called at shutdown time of an XSLT extension module

  the namespace URI for the extension  the data associated to this module

A function called at initialization time of an XSLT extension module

  an XSLT transformation context  the namespace URI for the extension

A function called at shutdown time of an XSLT extension module

  an XSLT transformation context  the namespace URI for the extension  the data associated to this module

Register an XSLT extension module to the library.

  URI associated to this module  the module initialization function  the module shutdown function 0 if sucessful, -1 in case of error

Register an XSLT extension module to the library.

  URI associated to this module  the module initialization function  the module shutdown function  the module initialization function  the module shutdown function 0 if sucessful, -1 in case of error

Unregister an XSLT extension module from the library.

  URI associated to this module 0 if sucessful, -1 in case of error

Retrieve the data associated to the extension module in this given +transformation.

  an XSLT transformation context  the URI associated to the exension module

Retrieve the data associated to the extension module in this given +stylesheet.

  an XSLT stylesheet  the URI associated to the exension module

Shutdown the set of modules loaded

  an XSLT transformation context

Shutdown the set of modules loaded

  an XSLT stylesheet

Registers an extension module function.

  the function name  the function namespace URI  the function callback 0 if successful, -1 in case of error.

Looks up an extension module function

  the function name  the function namespace URI the function if found, NULL otherwise.

Unregisters an extension module function

  the function name  the function namespace URI 0 if successful, -1 in case of error.

Creates and initializes an xsltElemPreComp

  the XSLT stylesheet  the element node  the transform function the new and initialized xsltElemPreComp

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.

  an xsltElemPreComp (or generally a derived structure)  the XSLT stylesheet  the element node  the transform function  the comp deallocator

Registers an extension module element.

  the element name  the element namespace URI  the pre-computation callback  the transformation callback 0 if successful, -1 in case of error.

Looks up an extension element. ctxt can be NULL to search only in +module elements.

Looks up an extension module element

  the element name  the element namespace URI the callback function if found, NULL otherwise.

Unregisters an extension module element

  the element name  the element namespace URI 0 if successful, -1 in case of error.

Registers an extension module top-level element.

  the top-level element name  the top-level element namespace URI  the top-level element callback 0 if successful, -1 in case of error.

Looks up an extension module top-level element

  the top-level element name  the top-level element namespace URI the callback function if found, NULL otherwise.

Unregisters an extension module top-level element

  the top-level element name  the top-level element namespace URI 0 if successful, -1 in case of error.

Registers an extension function

  an XSLT transformation context  the name of the element  the URI associated to the element  the actual implementation which should be called  0 in case of success, -1 in case of failure

Registers an extension element

  an XSLT transformation context  the name of the element  the URI associated to the element  the actual implementation which should be called  0 in case of success, -1 in case of failure

Registers an extension namespace

  an XSLT stylesheet  the prefix used  the URI associated to the extension 0 in case of success, -1 in case of failure

Check if the given prefix is one of the declared extensions

  the stylesheet  the namespace prefix (possibly NULL) 1 if this is an extension, 0 otherwise

Initialize the set of modules with registered stylesheet data

  an XSLT transformation context the number of modules initialized or -1 in case of error

Free the XSLT extension data

  an XSLT transformation context

Free up the memory used by XSLT extensions in a stylesheet

  an XSLT stylesheet

Precomputes an extension module element

  the stylesheet  the element node the precomputed data

Registers the test module

Name

Synopsis

Description

Details

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

This is the entry point when a function is needed by the XPath +interpretor.

  a void * but the XSLT transformation context actually  the function name  the function namespace URI the callback function or NULL if not found

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

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

  the XPath Parser context  the number of arguments

Registers all default XSLT functions in this context

  the XPath context

Name

Synopsis

Description

Details

a macro to import pointers from the stylesheet cascading order

a macro to import intergers from the stylesheet cascading order

parse an XSLT stylesheet strip-space element and record +elements needing stripping

  the XSLT stylesheet

parse an XSLT stylesheet strip-space element and record +elements needing stripping

  the XSLT stylesheet

Find the next stylesheet in import precedence.

 the next stylesheet or NULL if it was the last one

Returns whether that stylesheet requires white-space stripping

  an XSLT transformation context 1 if space should be stripped, 0 if not

Find strip-space or preserve-space informations for an element +respect the import precedence or the wildcards

  an XSLT transformation context  an XML node 1 if space should be stripped, 0 if not, and 2 if everything + should be CDTATA wrapped.

Finds the named template, apply import precedence rule.

  an XSLT transformation context  the template name  the template name URI the xsltTemplatePtr or NULL if not found

Name

Synopsis

Description

Details

add a key definition to a stylesheet

  an XSLT stylesheet  the key name or NULL  the name URI or NULL  the match value  the use value  the key instruction 0 in case of success, and -1 in case of failure.

Lookup a key

  an XSLT transformation context  the key name or NULL  the name URI or NULL  the key value to look for the nodeset resulting from the query or NULL

Computes all the keys tables for the current input document. +Should be done before global varibales are initialized.

  an XSLT transformation context  an XSLT document

Free up the memory used by XSLT keys in a stylesheet

  an XSLT stylesheet

Free the keys associated to a document

  a XSLT document

Name

Synopsis

Description

Details

Read the stylesheet-prefix and result-prefix attributes, register +them as well as the corresponding namespace.

  the XSLT stylesheet  the xsl:namespace-alias node

Find the right namespace value for this prefix, if needed create +and add a new namespace decalaration on the node +Handle namespace aliases

  a transformation context  the input node  the namespace  the output node (or its parent) the namespace node to use or NULL

Find the right namespace value for this URI, if needed create +and add a new namespace decalaration on the node

  a transformation context  the input node  the namespace URI  the suggested prefix  the output node (or its parent) the namespace node to use or NULL

Do a copy of an namespace node. If node is non-NULL the +new namespaces are added automatically. This handles namespaces +aliases

  a transformation context  the target node  the namespace node  a new xmlNsPtr, or NULL in case of error.

Do a copy of an namespace list. If node is non-NULL the +new namespaces are added automatically. This handles namespaces +aliases

  a transformation context  the target node  the first namespace  a new xmlNsPtr, or NULL in case of error.

Free up the memory used by namespaces aliases

  an XSLT stylesheet

Name

Synopsis

xmlChar *pattern); *pattern, + xmlDocPtr ctxtdoc, + xmlNodePtr ctxtnode);

Description

Details

Data structure used for the implementation of patterns. +It is kept private (in pattern.c)

Compile the XSLT pattern and generates a list of precompiled form suitable +for fast matching.

[1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern

  an XSLT pattern  the containing document  the containing element the generated pattern list or NULL in case of failure

Free up the memory allocated by all the elements of comp

  an XSLT comp list

Test wether the node matches one of the patterns in the list

  a XSLT process context  a node  the precompiled pattern list 1 if it matches, 0 if it doesn't and -1 in case of failure

Register the XSLT pattern associated to cur

  an XSLT stylesheet  an XSLT template  the mode name or NULL  the mode URI or NULL -1 in case of error, 0 otherwise

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.

  a XSLT process context  the node being processed  the current style the xsltTemplatePtr or NULL if not found

Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism

  an XSLT stylesheet

Cleanup the state of the templates used by the stylesheet and +the ones it imports.

  an XSLT stylesheet

xmlChar *pattern); *pattern, + xmlDocPtr ctxtdoc, + xmlNodePtr ctxtnode);

Determine if a node matches a pattern.

  a node in the source tree  an XSLT patternctxtdoc : context document (for namespaces)ctxtnode : context node (for namespaces)

Name

Synopsis

Description

Details

Process the expression using XPath and evaluate the result as +an XPath predicate

  the XSLT transformation context  the XPath compiled expression  the namespaces in scope  the number of namespaces in scope 1 is the predicate was true, 0 otherwise

Evaluate a template string value, i.e. the parent list is interpreter +as template content and the resulting tree string value is returned +This is needed for example by xsl:comment and xsl:processing-instruction

  the XSLT transformation context  the stylesheet node  the content parent the computed string value or NULL, must be deallocated by the + caller.

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.

  the XSLT transformation context  the stylesheet node  the attribute QName  the attribute namespace URI the computed string value or NULL, must be deallocated by the + caller.

Check if an attribute value template has a static value, i.e. the +attribute value does not contain expressions contained in curly braces ({})

  the XSLT stylesheet  the stylesheet node  the attribute Name  the attribute namespace URI  indicator whether the attribute is present the static string value or NULL, must be deallocated by the + caller.

Process the expression using XPath and get a string

  the XSLT transformation context  the compiled XPath expression the computed string value or NULL, must be deallocated by the + caller.

Process the given node and return the new string value.

  the XSLT transformation context  the attribute template node the computed tree replacement

Do a copy of an attribute list with attribute template processing

  the XSLT transformation context  the element where the attributes will be grafted  the first attribute  a new xmlAttrPtr, or NULL in case of error.

Process the given attribute and return the new processed copy.

  the XSLT transformation context  the result node the attribute replacement.

Process the given node and return the new string value.

  the XSLT transformation context the computed string value or NULL, must be deallocated by the + caller.

Name

Synopsis

Description

Details

Set whether XInclude should be processed on document being loaded by default

  whether to do XInclude processing

return the default state for XInclude processing

 0 if there is no processing 1 otherwise

Create a new XSLT TransformContext

  a parsed XSLT stylesheet  the input document the newly allocated xsltTransformContextPtr or NULL in case of error

Free up the memory allocated by ctxt

  an XSLT parser context

Apply the stylesheet to the document and allow the user to provide +its own transformation context.

  a parsed XSLT stylesheet  a parsed XML document  a NULL terminated arry of parameters names/values tuples  the targetted output  profile FILE * output or NULL  user provided transform context the result document or NULL in case of error

Strip the unwanted ignorable spaces from the input tree

  a XSLT process context

Looks up an extension element. ctxt can be NULL to search only in +module elements.

  an XSLT process context  the element name  the element namespace URI the element callback or NULL if not found

Apply the stylesheet to the document +NOTE: This may lead to a non-wellformed output XML wise !

  a parsed XSLT stylesheet  a parsed XML document  a NULL terminated arry of parameters names/values tuples the result document or NULL in case of error

Apply the stylesheet to the document and dump the profiling to +the given output.

  a parsed XSLT stylesheet  a parsed XML document  a NULL terminated arry of parameters names/values tuples  a FILE * for the profiling output the result document or NULL in case of error

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

  a parsed XSLT stylesheet  a parsed XML document  a NULL terminated arry of parameters names/values tuples  the URL/filename ot the generated resource if available  a SAX handler for progressive callback output (not implemented yet)  an output buffer for progressive output (not implemented yet) the number of by written to the main resource or -1 in case of + error.

Process the apply-templates node on the source node, if params are passed +they are pushed on the variable stack but not popped, it's left to the +caller to handle them back (they may be reused).

  a XSLT process context  the node in the source tree.  the template replacement nodelist  if is this a real template processing, the template processed  a set of parameters for the template or NULL

Process an XSLT-1.1 document element

  an XSLT processing context  The current node  the instruction in the stylesheet  precomputed information

function attached to xsl:sort nodes, but this should not be +called directly

  a XSLT process context  the node in the source tree.  the xslt sort node  precomputed information

Process the xslt copy node on the source node

  a XSLT process context  the node in the source tree.  the xslt copy node  precomputed information

Process the xslt text node on the source node

  a XSLT process context  the node in the source tree.  the xslt text node  precomputed information

Process the xslt element node on the source node

  a XSLT process context  the node in the source tree.  the xslt element node  precomputed information

Process the xslt comment node on the source node

  a XSLT process context  the node in the source tree.  the xslt comment node  precomputed information

Process the xslt attribute node on the source node

  a XSLT process context  the node in the source tree.  the xslt attribute node  precomputed information

Process the xslt processing-instruction node on the source node

  a XSLT process context  the node in the source tree.  the xslt processing-instruction node  precomputed information

Process the xslt copy-of node on the source node

  a XSLT process context  the node in the source tree.  the xslt copy-of node  precomputed information

Process the xslt value-of node on the source node

  a XSLT process context  the node in the source tree.  the xslt value-of node  precomputed information

Process the xslt number node on the source node

  a XSLT process context  the node in the source tree.  the xslt number node  precomputed information

Process the xslt apply-imports node on the source node

  a XSLT process context  the node in the source tree.  the xslt apply-imports node  precomputed information

Process the xslt call-template node on the source node

  a XSLT process context  the node in the source tree.  the xslt call-template node  precomputed information

Process the apply-templates node on the source node

  a XSLT process context  the node in the source tree.  the apply-templates node  precomputed information

Process the xslt choose node on the source node

  a XSLT process context  the node in the source tree.  the xslt choose node  precomputed information

Process the xslt if node on the source node

  a XSLT process context  the node in the source tree.  the xslt if node  precomputed information

Process the xslt for-each node on the source node

  a XSLT process context  the node in the source tree.  the xslt for-each node  precomputed information

Registers all default XSLT elements in this context

  the XPath context

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

  source node being executed  data node being processed  temlate that applies to node  the xslt transform context

Name

Synopsis

Description

Details

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

Evaluate the global variables of a stylesheet. This need to be +done on parsed stylesheets before starting to apply transformations

  the XSLT transformation context 0 in case of success, -1 in case of error

ctxt: the XSLT transformation context +params: a NULL terminated array of parameters name/value tuples

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.

 0 in case of success, -1 in case of error

ctxt: the XSLT transformation context +params: a NULL terminated arry of parameters names/values tuples

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.

 0 in case of success, -1 in case of error.

ctxt: the XSLT transformation context +name: a null terminated string giving the name of the parameter +value a null terminated string giving the XPath expression to be evaluated

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.

 0 in case of success, -1 in case of error.

ctxt: the XSLT transformation context +name: a null terminated string giving the name of the parameter +value a null terminated string giving the parameter value

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.

 0 in case of success, -1 in case of error.

parse an XSLT transformation variable declaration and record +its value.

  the XSLT stylesheet  the "variable" element

parse an XSLT transformation param declaration and record +its value.

  the XSLT stylesheet  the "param" element

parse an XSLT transformation variable declaration and record +its value.

  the XSLT transformation context  the "variable" element

parse an XSLT transformation param declaration and record +its value.

  the XSLT transformation context  the "param" element

parse an XSLT transformation param declaration, compute +its value but doesn't record it.

It returns the new xsltStackElemPtr or NULL

  the XSLT transformation context  the "param" element

add the new element list at this level of the stack.

  xn XSLT transformation context  a stack element list 0 in case of success, -1 in case of failure.

Free up the data associated to the global variables +its value.

  the XSLT transformation context

Search in the Variable array of the context for the given +variable value.

  the XSLT transformation context  the variable name  the variable namespace URI the value or NULL if not found

This is the entry point when a varibale is needed by the XPath +interpretor.

  a void * but the the XSLT transformation context actually  the variable name  the variable namespace URI the value or NULL if not found

The default version of XSLT supported

The XSLT "vendor" string for this processor

The XSLT "vendor" URL for this processor

The XSLT specification namespace

This macro is needed on Win32 when using MSVC. It enables the client code +to access exported variables. It should expand to nothing when compiling +this library itself, but must expand to __declspec(dllimport) when a +client includes the library header and that only if it links dynamically +against this library.

Unregister all global variables set up by the XSLT library

Name

Synopsis

Description

Details

Max number of specified xsl:sort on an element

specific value for pattern without priority expressed

The in-memory structure corresponding to an XSLT Template

Data structure of decimal-format

Data structure associated to a parsed document

The in-memory structure corresponding to element precomputed data, +designed to be extended by extension implementors.

signature of the function associated to elements part of the +stylesheet language like xsl:if or xsl:apply-templates.

  the XSLT transformation context  the input node  the stylesheet node  the compiled information from the stylesheet

Deallocates an xsltElemPreComp structure

  the xsltElemPreComp to free up

The in-memory structure corresponding to XSLT stylesheet constructs +precomputed data.

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 goto the error: label

Macro to check if the XSLT processing should be stopped +will return from the function with a 0 value

Create a new XSLT Stylesheet

 the newly allocated xsltStylesheetPtr or NULL in case of error

Load and parse an XSLT stylesheet

  the filename/URL to the stylesheet a new XSLT stylesheet structure.

Free up the memory allocated by sheet

  an XSLT stylesheet

Check if a string is ignorable

  a string 1 if the string is NULL or made of blanks chars, 0 otherwise

Free up the memory allocated by elem

  an XSLT stack element

Find decimal-format by name

  the XSLT stylesheet  the decimal-format name to find

parse an XSLT stylesheet adding the associated structures

  the XSLT stylesheet  and xmlDoc parsed XML a new XSLT stylesheet structure.

parse an XSLT stylesheet output element and record +information related to the stylesheet output

  the XSLT stylesheet  the "output" element

parse an XSLT stylesheet building the associated structures

  and xmlDoc parsed XML a new XSLT stylesheet structure.

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.

 a new XSLT stylesheet structure or NULL if not found.

Convert one number.

  the XSLT transformation context  the formatting informations  the data to format

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.

  the decimal format  the format requested  the value to format  the place to ouput the result

parse a template content-model +Clean-up the template content from unwanted ignorable blank nodes +and process xslt:text

  the XSLT stylesheet  the container node (can be a document for literal results)

Name

Synopsis

Description

Details

Checks that the element pertains to XSLt namespace

Checks the value of an element in XSLT namespace

check that a node is a 'real' one: document, element, text or attribute

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.

  the node  the attribute name  the URI of the namespace the attribute value or NULL if not found. + It's up to the caller to free the memory.

Display the context of an error.

  the transformation context  the stylesheet  the current node being processed

Process and xsl:message construct

  an XSLT processing context  The current node  The node containing the message instruction

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.

  the new error handling context  the new handler function

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.

  the new error handling context  the new handler function

reorder the current node list list accordingly to the document order

  the node set

reorder the current node list accordingly to the set of sorting +requirement provided by the arry of nodes.

  a XSLT process context  array of sort nodes  the number of sorts in the array

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.

  the node holding the QName  pointer to the initial QName value the namespace URI if there is a prefix, or NULL if name is + not prefixed.

Save the result result obtained by applying the style stylesheet +to an I/O output channel buf

  an output buffer  the result xmlDocPtr  the stylesheet the number of byte written or -1 in case of failure.

Save the result result obtained by applying the style stylesheet +to a file or URL URL

  the result xmlDocPtr  the stylesheet  the compression factor (0 - 9 included) the number of byte written or -1 in case of failure.

Save the result result obtained by applying the style stylesheet +to an open FILE * I/O. +This does not close the FILE file

  a FILE * I/O  the result xmlDocPtr  the stylesheet the number of bytes written or -1 in case of failure.

Save the result result obtained by applying the style stylesheet +to an open file descriptor +This does not close the descriptor.

  a file descriptor  the result xmlDocPtr  the stylesheet the number of bytes written or -1 in case of failure.

Save the profiling informations on output

  an XSLT context  a FILE * for saving the informations

Used for gathering profiling data

 the number of tenth of milliseconds since the beginning of the +profiling

Used for to correct the calibration for xsltTimestamp()

Add template "call" to call stack

  current template being applied  the source node being processed : 1 on sucess 0 otherwise an error may be printed if + WITH_XSLT_DEBUG_BREAKPOINTS is defined

Drop the topmost item off the call stack

+XSLT_DEFAULT_VERSION +#define XSLT_DEFAULT_VERSION "1.0" + + +XSLT_DEFAULT_VENDOR +#define XSLT_DEFAULT_VENDOR "libxslt" + + +XSLT_DEFAULT_URL +#define XSLT_DEFAULT_URL "http://xmlsoft.org/XSLT/" + + +XSLT_NAMESPACE +#define XSLT_NAMESPACE ((xmlChar *) "http://www.w3.org/1999/XSL/Transform") + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC __declspec(dllimport) + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC + + +xsltCleanupGlobals +void +void + + +XSLT_MAX_SORT +#define XSLT_MAX_SORT 5 + + +XSLT_PAT_NO_PRIORITY +#define XSLT_PAT_NO_PRIORITY -12345789 + + +xsltTemplate + + +xsltTemplatePtr +typedef xsltTemplate *xsltTemplatePtr; + + +xsltTemplate +struct xsltTemplate { + struct _xsltTemplate *next;/* chained list sorted by priority */ + struct _xsltStylesheet *style;/* the containing stylesheet */ + xmlChar *match; /* the matching string */ + float priority; /* as given from the stylesheet, not computed */ + xmlChar *name; /* the local part of the name QName */ + xmlChar *nameURI; /* the URI part of the name QName */ + xmlChar *mode; /* the local part of the mode QName */ + xmlChar *modeURI; /* the URI part of the mode QName */ + xmlNodePtr content; /* the template replacement value */ + xmlNodePtr elem; /* the source element */ + + int inheritedNsNr; /* number of inherited namespaces */ + xmlNsPtr *inheritedNs;/* inherited non-excluded namespaces */ + + /* Profiling informations */ + int nbCalls; /* the number of time the template was called */ + unsigned long time; /* the time spent in this template */ +}; + + +xsltDecimalFormat + + +xsltDecimalFormatPtr +typedef xsltDecimalFormat *xsltDecimalFormatPtr; + + +xsltDecimalFormat +struct xsltDecimalFormat { + struct _xsltDecimalFormat *next; /* chained list */ + xmlChar *name; + /* Used for interpretation of pattern */ + xmlChar *digit; + xmlChar *patternSeparator; + /* May appear in result */ + xmlChar *minusSign; + xmlChar *infinity; + xmlChar *noNumber; /* Not-a-number */ + /* Used for interpretation of pattern and may appear in result */ + xmlChar *decimalPoint; + xmlChar *grouping; + xmlChar *percent; + xmlChar *permille; + xmlChar *zeroDigit; +}; + + +xsltDocument + + +xsltDocumentPtr +typedef xsltDocument *xsltDocumentPtr; + + +xsltDocument +struct xsltDocument { + struct _xsltDocument *next; /* documents are kept in a chained list */ + int main; /* is this the main document */ + xmlDocPtr doc; /* the parsed document */ + void *keys; /* key tables storage */ +}; + + +xsltTransformContext + + +xsltTransformContextPtr +typedef xsltTransformContext *xsltTransformContextPtr; + + +xsltElemPreComp + + +xsltElemPreCompPtr +typedef xsltElemPreComp *xsltElemPreCompPtr; + + +xsltTransformFunction +void +xsltTransformContextPtr ctxt, + xmlNodePtr node, + xmlNodePtr inst, + xsltElemPreCompPtr comp + + +xsltStyleType +typedef enum { + XSLT_FUNC_COPY=1, + XSLT_FUNC_SORT, + XSLT_FUNC_TEXT, + XSLT_FUNC_ELEMENT, + XSLT_FUNC_ATTRIBUTE, + XSLT_FUNC_COMMENT, + XSLT_FUNC_PI, + XSLT_FUNC_COPYOF, + XSLT_FUNC_VALUEOF, + XSLT_FUNC_NUMBER, + XSLT_FUNC_APPLYIMPORTS, + XSLT_FUNC_CALLTEMPLATE, + XSLT_FUNC_APPLYTEMPLATES, + XSLT_FUNC_CHOOSE, + XSLT_FUNC_IF, + XSLT_FUNC_FOREACH, + XSLT_FUNC_DOCUMENT, + XSLT_FUNC_WITHPARAM, + XSLT_FUNC_PARAM, + XSLT_FUNC_VARIABLE, + XSLT_FUNC_WHEN, + XSLT_FUNC_EXTENSION +} xsltStyleType; + + +xsltElemPreCompDeallocator +void +xsltElemPreCompPtr comp + + +xsltElemPreComp +struct xsltElemPreComp { + xsltElemPreCompPtr next; /* chained list */ + xsltStyleType type; /* type of the element */ + xsltTransformFunction func; /* handling function */ + xmlNodePtr inst; /* the instruction */ + + /* end of common part */ + xsltElemPreCompDeallocator free; /* the deallocator */ +}; + + +xsltStylePreComp + + +xsltStylePreCompPtr +typedef xsltStylePreComp *xsltStylePreCompPtr; + + +xsltStylePreComp +struct xsltStylePreComp { + xsltElemPreCompPtr next; /* chained list */ + xsltStyleType type; /* type of the element */ + xsltTransformFunction func; /* handling function */ + xmlNodePtr inst; /* the instruction */ + + /* + * Pre computed values + */ + + xmlChar *stype; /* sort */ + int has_stype; /* sort */ + int number; /* sort */ + xmlChar *order; /* sort */ + int has_order; /* sort */ + int descending; /* sort */ + + xmlChar *use; /* copy, element */ + int has_use; /* copy, element */ + + int noescape; /* text */ + + xmlChar *name; /* element, attribute, pi */ + int has_name; /* element, attribute, pi */ + xmlChar *ns; /* element */ + int has_ns; /* element */ + + xmlChar *mode; /* apply-templates */ + xmlChar *modeURI; /* apply-templates */ + + xmlChar *test; /* if */ + + xsltTemplatePtr templ; /* call-template */ + + xmlChar *select; /* sort, copy-of, value-of, apply-templates */ + + int ver11; /* document */ + xmlChar *filename; /* document URL */ + int has_filename; /* document */ + + xsltNumberData numdata; /* number */ + + xmlXPathCompExprPtr comp; /* a precompiled XPath expression */ + xmlNsPtr *nsList; /* the namespaces in scope */ + int nsNr; /* the number of namespaces in scope */ +}; + + +xsltStackElem + + +xsltStackElemPtr +typedef xsltStackElem *xsltStackElemPtr; + + +xsltStackElem +struct xsltStackElem { + struct _xsltStackElem *next;/* chained list */ + xsltStylePreCompPtr comp; /* the compiled form */ + int computed; /* was the evaluation done */ + xmlChar *name; /* the local part of the name QName */ + xmlChar *nameURI; /* the URI part of the name QName */ + xmlChar *select; /* the eval string */ + xmlNodePtr tree; /* the tree if no eval string or the location */ + xmlXPathObjectPtr value; /* The value if computed */ +}; + + +xsltStylesheet + + +xsltStylesheetPtr +typedef xsltStylesheet *xsltStylesheetPtr; + + +xsltStylesheet +struct xsltStylesheet { + /* + * The stylesheet import relation is kept as a tree + */ + struct _xsltStylesheet *parent; + struct _xsltStylesheet *next; + struct _xsltStylesheet *imports; + + xsltDocumentPtr docList; /* the include document list */ + + /* + * General data on the style sheet document + */ + xmlDocPtr doc; /* the parsed XML stylesheet */ + xmlHashTablePtr stripSpaces;/* the hash table of the strip-space and + preserve space elements */ + int stripAll; /* strip-space * (1) preserve-space * (-1) */ + xmlHashTablePtr cdataSection;/* the hash table of the cdata-section */ + + /* + * Global variable or parameters + */ + xsltStackElemPtr variables; /* linked list of param and variables */ + + /* + * Template descriptions + */ + xsltTemplatePtr templates; /* the ordered list of templates */ + void *templatesHash; /* hash table or wherever compiled templates + informations are stored */ + void *rootMatch; /* template based on / */ + void *keyMatch; /* template based on key() */ + void *elemMatch; /* template based on * */ + void *attrMatch; /* template based on @* */ + void *parentMatch; /* template based on .. */ + void *textMatch; /* template based on text() */ + void *piMatch; /* template based on processing-instruction() */ + void *commentMatch; /* template based on comment() */ + + /* + * Namespace aliases + */ + xmlHashTablePtr nsAliases; /* the namespace alias hash tables */ + + /* + * Attribute sets + */ + xmlHashTablePtr attributeSets;/* the attribute sets hash tables */ + + /* + * Namespaces + */ + xmlHashTablePtr nsHash; /* the set of namespaces in use */ + void *nsDefs; /* the namespaces defined */ + + /* + * Key definitions + */ + void *keys; /* key definitions */ + + /* + * Output related stuff. + */ + xmlChar *method; /* the output method */ + xmlChar *methodURI; /* associated namespace if any */ + xmlChar *version; /* version string */ + xmlChar *encoding; /* encoding string */ + int omitXmlDeclaration; /* omit-xml-declaration = "yes" | "no" */ + + /* Number formatting */ + xsltDecimalFormatPtr decimalFormat; + int standalone; /* standalone = "yes" | "no" */ + xmlChar *doctypePublic; /* doctype-public string */ + xmlChar *doctypeSystem; /* doctype-system string */ + int indent; /* should output being indented */ + xmlChar *mediaType; /* media-type string */ + + /* + * Precomputed blocks + */ + xsltElemPreCompPtr preComps;/* list of precomputed blocks */ + int warnings; /* number of warnings found at compilation */ + int errors; /* number of errors found at compilation */ + + xmlChar *exclPrefix; /* last excluded prefixes */ + xmlChar **exclPrefixTab; /* array of excluded prefixes */ + int exclPrefixNr; /* number of excluded prefixes in scope */ + int exclPrefixMax; /* size of the array */ + + void *_private; /* user defined data */ + + /* + * Extensions + */ + xmlHashTablePtr extInfos; /* the extension data */ +}; + + +xsltOutputType +typedef enum { + XSLT_OUTPUT_XML = 0, + XSLT_OUTPUT_HTML, + XSLT_OUTPUT_TEXT +} xsltOutputType; + + +xsltTransformState +typedef enum { + XSLT_STATE_OK = 0, + XSLT_STATE_ERROR, + XSLT_STATE_STOPPED +} xsltTransformState; + + +xsltTransformContext +struct xsltTransformContext { + xsltStylesheetPtr style; /* the stylesheet used */ + xsltOutputType type; /* the type of output */ + + xsltTemplatePtr templ; /* the current template */ + int templNr; /* Nb of templates in the stack */ + int templMax; /* Size of the templtes stack */ + xsltTemplatePtr *templTab; /* the template stack */ + + xsltStackElemPtr vars; /* the current variable list */ + int varsNr; /* Nb of variable list in the stack */ + int varsMax; /* Size of the variable list stack */ + xsltStackElemPtr *varsTab; /* the variable list stack */ + int varsBase; /* the var base for current templ */ + + /* + * Extensions + */ + xmlHashTablePtr extFunctions; /* the extension functions */ + xmlHashTablePtr extElements; /* the extension elements */ + xmlHashTablePtr extInfos; /* the extension data */ + + const xmlChar *mode; /* the current mode */ + const xmlChar *modeURI; /* the current mode URI */ + + xsltDocumentPtr docList; /* the document list */ + + xsltDocumentPtr document; /* the current document */ + xmlNodePtr node; /* the current node being processed */ + xmlNodeSetPtr nodeList; /* the current node list */ + /* xmlNodePtr current; the node */ + + xmlDocPtr output; /* the resulting document */ + xmlNodePtr insert; /* the insertion node */ + + xmlXPathContextPtr xpathCtxt; /* the XPath context */ + xsltTransformState state; /* the current state */ + + /* + * Global variables + */ + xmlHashTablePtr globalVars; /* the global variables and params */ + + xmlNodePtr inst; /* the instruction in the stylesheet */ + + int xinclude; /* should XInclude be processed */ + + const char * outputFile; /* the output URI if known */ + + int profile; /* is this run profiled */ + long prof; /* the current profiled value */ + int profNr; /* Nb of templates in the stack */ + int profMax; /* Size of the templtaes stack */ + long *profTab; /* the profile template stack */ + + void *_private; /* user defined data */ +}; + + +CHECK_STOPPED +#define CHECK_STOPPED if (ctxt->state == XSLT_STATE_STOPPED) return; + + +CHECK_STOPPEDE +#define CHECK_STOPPEDE if (ctxt->state == XSLT_STATE_STOPPED) goto error; + + +CHECK_STOPPED0 +#define CHECK_STOPPED0 if (ctxt->state == XSLT_STATE_STOPPED) return(0); + + +xsltNewStylesheet +xsltStylesheetPtr +void + + +xsltParseStylesheetFile +xsltStylesheetPtr +const xmlChar* filename + + +xsltFreeStylesheet +void +xsltStylesheetPtr sheet + + +xsltIsBlank +int +xmlChar *str + + +xsltFreeStackElemList +void +xsltStackElemPtr elem + + +xsltDecimalFormatGetByName +xsltDecimalFormatPtr +xsltStylesheetPtr sheet,xmlChar *name + + +xsltParseStylesheetProcess +xsltStylesheetPtr +xsltStylesheetPtr ret,xmlDocPtr doc + + +xsltParseStylesheetOutput +void +xsltStylesheetPtr style,xmlNodePtr cur + + +xsltParseStylesheetDoc +xsltStylesheetPtr +xmlDocPtr doc + + +xsltLoadStylesheetPI +xsltStylesheetPtr +xmlDocPtr doc + + +xsltNumberFormat +void +xsltTransformContextPtr ctxt,xsltNumberDataPtr data,xmlNodePtr node + + +xsltFormatNumberConversion +xmlXPathError +xsltDecimalFormatPtr self,xmlChar *format,double number,xmlChar **result + + +xsltParseTemplateContent +void +xsltStylesheetPtr style,xmlNodePtr templ + + +LIBXSLT_DOTTED_VERSION +#define LIBXSLT_DOTTED_VERSION "1.0.10" + + +LIBXSLT_VERSION +#define LIBXSLT_VERSION 10010 + + +LIBXSLT_VERSION_STRING +#define LIBXSLT_VERSION_STRING "10010" + + +WITH_XSLT_DEBUG +#define WITH_XSLT_DEBUG + + +DEBUG_MEMORY +#define DEBUG_MEMORY + + +DEBUG_MEMORY_LOCATION +#define DEBUG_MEMORY_LOCATION + + +WITH_XSLT_DEBUGGER +#define WITH_XSLT_DEBUGGER + + +ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED + + +ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC __declspec(dllimport) + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC + + +xsltAddKey +int +xsltStylesheetPtr style,const xmlChar *name,const xmlChar *nameURI,const xmlChar *match,const xmlChar *use,xmlNodePtr inst + + +xsltGetKey +xmlNodeSetPtr +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *nameURI,const xmlChar *value + + +xsltInitCtxtKeys +void +xsltTransformContextPtr ctxt,xsltDocumentPtr doc + + +xsltFreeKeys +void +xsltStylesheetPtr style + + +xsltFreeDocumentKeys +void +xsltDocumentPtr doc + + +xsltCompMatch + + +xsltCompMatchPtr +typedef xsltCompMatch *xsltCompMatchPtr; + + +xsltCompilePattern +xsltCompMatchPtr +const xmlChar *pattern,xmlDocPtr doc,xmlNodePtr node + + +xsltFreeCompMatchList +void +xsltCompMatchPtr comp + + +xsltTestCompMatchList +int +xsltTransformContextPtr ctxt,xmlNodePtr node,xsltCompMatchPtr comp + + +xsltAddTemplate +int +xsltStylesheetPtr style,xsltTemplatePtr cur,const xmlChar *mode,const xmlChar *modeURI + + +xsltGetTemplate +xsltTemplatePtr +xsltTransformContextPtr ctxt,xmlNodePtr node,xsltStylesheetPtr style + + +xsltFreeTemplateHashes +void +xsltStylesheetPtr style + + +xsltCleanupTemplates +void +xsltStylesheetPtr style + + +xsltMatchPattern +int +xsltTransformContextPtr ctxt,xmlNodePtr node,const xmlChar *pattern,xmlDocPtr ctxtdoc,xmlNodePtr ctxtnode + + +xsltSetXIncludeDefault +void +int xinclude + + +xsltGetXIncludeDefault +int +void + + +xsltNewTransformContext +xsltTransformContextPtr +xsltStylesheetPtr style,xmlDocPtr doc + + +xsltFreeTransformContext +void +xsltTransformContextPtr ctxt + + +xsltApplyStylesheetUser +xmlDocPtr +xsltStylesheetPtr style,xmlDocPtr doc,const char **params,const char *output,FILE * profile,xsltTransformContextPtr userCtxt + + +xsltApplyStripSpaces +void +xsltTransformContextPtr ctxt,xmlNodePtr node + + +xsltExtElementLookup +xsltTransformFunction +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *URI + + +xsltApplyStylesheet +xmlDocPtr +xsltStylesheetPtr style,xmlDocPtr doc,const char **params + + +xsltProfileStylesheet +xmlDocPtr +xsltStylesheetPtr style,xmlDocPtr doc,const char **params,FILE * output + + +xsltRunStylesheet +int +xsltStylesheetPtr style,xmlDocPtr doc,const char **params,const char *output,xmlSAXHandlerPtr SAX,xmlOutputBufferPtr IObuf + + +xsltApplyOneTemplate +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr list,xsltTemplatePtr templ,xsltStackElemPtr params + + +xsltDocumentElem +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltSort +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltCopy +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltText +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltElement +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltComment +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltAttribute +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltProcessingInstruction +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltCopyOf +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltValueOf +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltNumber +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltApplyImports +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltCallTemplate +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltApplyTemplates +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltChoose +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltIf +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltForEach +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltRegisterAllElement +void +xsltTransformContextPtr ctxt + + +xslHandleDebugger +void +xmlNodePtr cur,xmlNodePtr node,xsltTemplatePtr templ,xsltTransformContextPtr ctxt + + +XSLT_TODO +#define XSLT_TODO \ + xsltGenericError(xsltGenericErrorContext, \ + "Unimplemented block at %s:%d\n", \ + __FILE__, __LINE__); + + +XSLT_STRANGE +#define XSLT_STRANGE \ + xsltGenericError(xsltGenericErrorContext, \ + "Internal error at %s:%d\n", \ + __FILE__, __LINE__); + + +IS_XSLT_ELEM +#define IS_XSLT_ELEM(n) \ + (((n) != NULL) && ((n)->ns != NULL) && \ + (xmlStrEqual((n)->ns->href, XSLT_NAMESPACE))) + + +IS_XSLT_NAME +#define IS_XSLT_NAME(n, val) \ + (xmlStrEqual((n)->name, (const xmlChar *) (val))) + + +IS_XSLT_REAL_NODE +#define IS_XSLT_REAL_NODE(n) \ + (((n) != NULL) && \ + (((n)->type == XML_ELEMENT_NODE) || \ + ((n)->type == XML_TEXT_NODE) || \ + ((n)->type == XML_ATTRIBUTE_NODE) || \ + ((n)->type == XML_DOCUMENT_NODE) || \ + ((n)->type == XML_HTML_DOCUMENT_NODE) || \ + ((n)->type == XML_DOCB_DOCUMENT_NODE))) + + +IS_XSLT_REAL_NODE +#define IS_XSLT_REAL_NODE(n) \ + (((n) != NULL) && \ + (((n)->type == XML_ELEMENT_NODE) || \ + ((n)->type == XML_TEXT_NODE) || \ + ((n)->type == XML_ATTRIBUTE_NODE) || \ + ((n)->type == XML_DOCUMENT_NODE) || \ + ((n)->type == XML_HTML_DOCUMENT_NODE))) + + +xsltGetNsProp +xmlChar * +xmlNodePtr node,const xmlChar *name,const xmlChar *nameSpace + + +xsltPrintErrorContext +void +xsltTransformContextPtr ctxt,xsltStylesheetPtr style,xmlNodePtr node + + +xsltMessage +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst + + +xsltSetGenericErrorFunc +void +void *ctx,xmlGenericErrorFunc handler + + +xsltSetGenericDebugFunc +void +void *ctx,xmlGenericErrorFunc handler + + +xsltDocumentSortFunction +void +xmlNodeSetPtr list + + +xsltDoSortFunction +void +xsltTransformContextPtr ctxt,xmlNodePtr *sorts,int nbsorts + + +xsltGetQNameURI +const xmlChar * +xmlNodePtr node,xmlChar **name + + +xsltSaveResultTo +int +xmlOutputBufferPtr buf,xmlDocPtr result,xsltStylesheetPtr style + + +xsltSaveResultToFilename +int +const char *URI,xmlDocPtr result,xsltStylesheetPtr style,int compression + + +xsltSaveResultToFile +int +FILE *file,xmlDocPtr result,xsltStylesheetPtr style + + +xsltSaveResultToFd +int +int fd,xmlDocPtr result,xsltStylesheetPtr style + + +xsltSaveProfiling +void +xsltTransformContextPtr ctxt,FILE *output + + +xsltTimestamp +long +void + + +xsltCalibrateAdjust +void +long delta + + +XSLT_TIMESTAMP_TICS_PER_SEC +#define XSLT_TIMESTAMP_TICS_PER_SEC 100000l + + +xsltDebugStatusCodes +typedef enum { + XSLT_DEBUG_NONE = 0, /* no debugging allowed */ + XSLT_DEBUG_INIT, + XSLT_DEBUG_STEP, + XSLT_DEBUG_STEPOUT, + XSLT_DEBUG_NEXT, + XSLT_DEBUG_STOP, + XSLT_DEBUG_CONT, + XSLT_DEBUG_RUN, + XSLT_DEBUG_RUN_RESTART, + XSLT_DEBUG_QUIT +} xsltDebugStatusCodes; + + +xsltHandleDebuggerCallback +void +xmlNodePtr cur, xmlNodePtr node, + xsltTemplatePtr templ, xsltTransformContextPtr ctxt + + +xsltAddCallCallback +int +xsltTemplatePtr templ, xmlNodePtr source + + +xsltDropCallCallback +void +void + + +xsltSetDebuggerCallbacks +int +int no, void *block + + +xslAddCall +int +xsltTemplatePtr templ,xmlNodePtr source + + +xslDropCall +void +void + + +xsltEvalXPathPredicate +int +xsltTransformContextPtr ctxt,xmlXPathCompExprPtr comp,xmlNsPtr *nsList,int nsNr + + +xsltEvalTemplateString +xmlChar * +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr parent + + +xsltEvalAttrValueTemplate +xmlChar * +xsltTransformContextPtr ctxt,xmlNodePtr node,const xmlChar *name,const xmlChar *ns + + +xsltEvalStaticAttrValueTemplate +xmlChar * +xsltStylesheetPtr style,xmlNodePtr node,const xmlChar *name,const xmlChar *ns,int *found + + +xsltEvalXPathString +xmlChar * +xsltTransformContextPtr ctxt,xmlXPathCompExprPtr comp + + +xsltTemplateProcess +xmlNodePtr * +xsltTransformContextPtr ctxt,xmlNodePtr node + + +xsltAttrListTemplateProcess +xmlAttrPtr +xsltTransformContextPtr ctxt,xmlNodePtr target,xmlAttrPtr cur + + +xsltAttrTemplateProcess +xmlAttrPtr +xsltTransformContextPtr ctxt,xmlNodePtr target,xmlAttrPtr attr + + +xsltAttrTemplateValueProcess +xmlChar * +xsltTransformContextPtr ctxt,const xmlChar* attr + + +XSLT_REGISTER_VARIABLE_LOOKUP +#define XSLT_REGISTER_VARIABLE_LOOKUP(ctxt) \ + xmlXPathRegisterVariableLookup((ctxt)->xpathCtxt, \ + xsltXPathVariableLookup, (void *)(ctxt)); \ + xsltRegisterAllFunctions((ctxt)->xpathCtxt); \ + xsltRegisterAllElement(ctxt); \ + (ctxt)->xpathCtxt->extra = ctxt + + +xsltEvalGlobalVariables +int +xsltTransformContextPtr ctxt + + +xsltEvalUserParams +int +xsltTransformContextPtr ctxt,const char **params + + +xsltQuoteUserParams +int +xsltTransformContextPtr ctxt,const char **params + + +xsltEvalOneUserParam +int +xsltTransformContextPtr ctxt,const xmlChar * name,const xmlChar * value + + +xsltQuoteOneUserParam +int +xsltTransformContextPtr ctxt,const xmlChar * name,const xmlChar * value + + +xsltParseGlobalVariable +void +xsltStylesheetPtr style,xmlNodePtr cur + + +xsltParseGlobalParam +void +xsltStylesheetPtr style,xmlNodePtr cur + + +xsltParseStylesheetVariable +void +xsltTransformContextPtr ctxt,xmlNodePtr cur + + +xsltParseStylesheetParam +void +xsltTransformContextPtr ctxt,xmlNodePtr cur + + +xsltParseStylesheetCallerParam +xsltStackElemPtr +xsltTransformContextPtr ctxt,xmlNodePtr cur + + +xsltAddStackElemList +int +xsltTransformContextPtr ctxt,xsltStackElemPtr elems + + +xsltFreeGlobalVariables +void +xsltTransformContextPtr ctxt + + +xsltVariableLookup +xmlXPathObjectPtr +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *ns_uri + + +xsltXPathVariableLookup +xmlXPathObjectPtr +void *ctxt,const xmlChar *name,const xmlChar *ns_uri + + +LIBXSLT_DOTTED_VERSION +#define LIBXSLT_DOTTED_VERSION "1.0.10" + + +LIBXSLT_VERSION +#define LIBXSLT_VERSION 10010 + + +LIBXSLT_VERSION_STRING +#define LIBXSLT_VERSION_STRING "10010" + + +WITH_XSLT_DEBUG +#define WITH_XSLT_DEBUG + + +DEBUG_MEMORY +#define DEBUG_MEMORY + + +DEBUG_MEMORY_LOCATION +#define DEBUG_MEMORY_LOCATION + + +ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC __declspec(dllimport) + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC + + +XSLT_REGISTER_FUNCTION_LOOKUP +#define XSLT_REGISTER_FUNCTION_LOOKUP(ctxt) \ + xmlXPathRegisterFuncLookup((ctxt)->xpathCtxt, \ + (xmlXPathFuncLookupFunc) xsltXPathFunctionLookup, \ + (void *)(ctxt->xpathCtxt)); + + +xsltXPathFunctionLookup +xmlXPathFunction +xmlXPathContextPtr ctxt,const xmlChar *name,const xmlChar *ns_uri + + +xsltDocumentFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltKeyFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltUnparsedEntityURIFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltFormatNumberFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltGenerateIdFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltSystemPropertyFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltElementAvailableFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltFunctionAvailableFunction +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltRegisterAllFunctions +void +xmlXPathContextPtr ctxt + + +xsltStyleExtInitFunction +void * +xsltStylesheetPtr style, + const xmlChar *URI + + +xsltStyleExtShutdownFunction +void +xsltStylesheetPtr style, + const xmlChar *URI, + void *data + + +xsltExtInitFunction +void * +xsltTransformContextPtr ctxt, + const xmlChar *URI + + +xsltExtShutdownFunction +void +xsltTransformContextPtr ctxt, + const xmlChar *URI, + void *data + + +xsltRegisterExtModule +int +const xmlChar *URI,xsltExtInitFunction initFunc,xsltExtShutdownFunction shutdownFunc + + +xsltRegisterExtModuleFull +int +const xmlChar * URI,xsltExtInitFunction initFunc,xsltExtShutdownFunction shutdownFunc,xsltStyleExtInitFunction styleInitFunc,xsltStyleExtShutdownFunction styleShutdownFunc + + +xsltUnregisterExtModule +int +const xmlChar * URI + + +xsltGetExtData +void * +xsltTransformContextPtr ctxt,const xmlChar *URI + + +xsltStyleGetExtData +void * +xsltStylesheetPtr style,const xmlChar *URI + + +xsltShutdownCtxtExts +void +xsltTransformContextPtr ctxt + + +xsltShutdownExts +void +xsltStylesheetPtr style + + +xsltRegisterExtModuleFunction +int +const xmlChar *name,const xmlChar *URI,xmlXPathFunction function + + +xsltExtFunctionLookup +xmlXPathFunction +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *URI + + +xsltExtModuleFunctionLookup +xmlXPathFunction +const xmlChar *name,const xmlChar *URI + + +xsltUnregisterExtModuleFunction +int +const xmlChar *name,const xmlChar *URI + + +xsltElemPreCompPtr +typedef +*xsltPreComputeFunction) (xsltStylesheetPtr style,xmlNodePtr inst,xsltTransformFunction function + + +xsltNewElemPreComp +xsltElemPreCompPtr +xsltStylesheetPtr style,xmlNodePtr inst,xsltTransformFunction function + + +xsltInitElemPreComp +void +xsltElemPreCompPtr comp,xsltStylesheetPtr style,xmlNodePtr inst,xsltTransformFunction function,xsltElemPreCompDeallocator freeFunc + + +xsltRegisterExtModuleElement +int +const xmlChar *name,const xmlChar *URI,xsltPreComputeFunction precomp,xsltTransformFunction transform + + +xsltExtElementLookup +xsltTransformFunction +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *URI + + +xsltExtModuleElementLookup +xsltTransformFunction +const xmlChar *name,const xmlChar *URI + + +xsltUnregisterExtModuleElement +int +const xmlChar *name,const xmlChar *URI + + +void +typedef +*xsltTopLevelFunction) (xsltStylesheetPtr style,xmlNodePtr inst + + +xsltRegisterExtModuleTopLevel +int +const xmlChar *name,const xmlChar *URI,xsltTopLevelFunction function + + +xsltExtModuleTopLevelLookup +xsltTopLevelFunction +const xmlChar *name,const xmlChar *URI + + +xsltUnregisterExtModuleTopLevel +int +const xmlChar *name,const xmlChar *URI + + +xsltRegisterExtFunction +int +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *URI,xmlXPathFunction function + + +xsltRegisterExtElement +int +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *URI,xsltTransformFunction function + + +xsltRegisterExtPrefix +int +xsltStylesheetPtr style,const xmlChar *prefix,const xmlChar *URI + + +xsltCheckExtPrefix +int +xsltStylesheetPtr style,const xmlChar *prefix + + +xsltInitCtxtExts +int +xsltTransformContextPtr ctxt + + +xsltFreeCtxtExts +void +xsltTransformContextPtr ctxt + + +xsltFreeExts +void +xsltStylesheetPtr style + + +xsltPreComputeExtModuleElement +xsltElemPreCompPtr +xsltStylesheetPtr style,xmlNodePtr inst + + +xsltRegisterTestModule +void +void + + +XSLT_GET_IMPORT_PTR +#define XSLT_GET_IMPORT_PTR(res, style, name) { \ + xsltStylesheetPtr st = style; \ + res = NULL; \ + while (st != NULL) { \ + if (st->name != NULL) { res = st->name; break; } \ + st = xsltNextImport(st); \ + }} + + +XSLT_GET_IMPORT_INT +#define XSLT_GET_IMPORT_INT(res, style, name) { \ + xsltStylesheetPtr st = style; \ + res = -1; \ + while (st != NULL) { \ + if (st->name != -1) { res = st->name; break; } \ + st = xsltNextImport(st); \ + }} + + +xsltParseStylesheetImport +void +xsltStylesheetPtr style,xmlNodePtr cur + + +xsltParseStylesheetInclude +void +xsltStylesheetPtr style,xmlNodePtr cur + + +xsltNextImport +xsltStylesheetPtr +xsltStylesheetPtr style + + +xsltNeedElemSpaceHandling +int +xsltTransformContextPtr ctxt + + +xsltFindElemSpaceHandling +int +xsltTransformContextPtr ctxt,xmlNodePtr node + + +xsltFindTemplate +xsltTemplatePtr +xsltTransformContextPtr ctxt,const xmlChar *name,const xmlChar *nameURI + + +xsltParseStylesheetAttributeSet +void +xsltStylesheetPtr style,xmlNodePtr cur + + +xsltFreeAttributeSetsHashes +void +xsltStylesheetPtr style + + +xsltApplyAttributeSet +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xmlChar *attributes + + +xsltNamespaceAlias +void +xsltStylesheetPtr style,xmlNodePtr node + + +xsltGetNamespace +xmlNsPtr +xsltTransformContextPtr ctxt,xmlNodePtr cur,xmlNsPtr ns,xmlNodePtr out + + +xsltGetSpecialNamespace +xmlNsPtr +xsltTransformContextPtr ctxt,xmlNodePtr cur,const xmlChar *URI,const xmlChar *prefix,xmlNodePtr out + + +xsltCopyNamespace +xmlNsPtr +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNsPtr cur + + +xsltCopyNamespaceList +xmlNsPtr +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNsPtr cur + + +xsltFreeNamespaceAliasHashes +void +xsltStylesheetPtr style + + +xsltNewDocument +xsltDocumentPtr +xsltTransformContextPtr ctxt,xmlDocPtr doc + + +xsltLoadDocument +xsltDocumentPtr +xsltTransformContextPtr ctxt,const xmlChar *URI + + +xsltFindDocument +xsltDocumentPtr +xsltTransformContextPtr ctxt,xmlDocPtr doc + + +xsltFreeDocuments +void +xsltTransformContextPtr ctxt + + +xsltLoadStyleDocument +xsltDocumentPtr +xsltStylesheetPtr style,const xmlChar *URI + + +xsltNewStyleDocument +xsltDocumentPtr +xsltStylesheetPtr style,xmlDocPtr doc + + +xsltFreeStyleDocuments +void +xsltStylesheetPtr style + + +XSLT_LIBXSLT_NAMESPACE +#define XSLT_LIBXSLT_NAMESPACE ((xmlChar *) "http://xmlsoft.org/XSLT/namespace") + + +XSLT_SAXON_NAMESPACE +#define XSLT_SAXON_NAMESPACE ((xmlChar *) "http://icl.com/saxon") + + +XSLT_XT_NAMESPACE +#define XSLT_XT_NAMESPACE ((xmlChar *) "http://www.jclark.com/xt") + + +XSLT_XALAN_NAMESPACE +#define XSLT_XALAN_NAMESPACE ((xmlChar *) \ + "org.apache.xalan.xslt.extensions.Redirect") + + +XSLT_NORM_SAXON_NAMESPACE +#define XSLT_NORM_SAXON_NAMESPACE ((xmlChar *) \ + "http://nwalsh.com/xslt/ext/com.nwalsh.saxon.CVS") + + +xsltFunctionNodeSet +void +xmlXPathParserContextPtr ctxt,int nargs + + +xsltDebug +void +xsltTransformContextPtr ctxt,xmlNodePtr node,xmlNodePtr inst,xsltStylePreCompPtr comp + + +xsltRegisterExtras +void +xsltTransformContextPtr ctxt + + +xsltRegisterAllExtras +void +void + + +xsltExtMarker +extern const xmlChar *xsltExtMarker; + + +xsltDocumentComp +xsltElemPreCompPtr +xsltStylesheetPtr style,xmlNodePtr inst,xsltTransformFunction function + + +xsltStylePreCompute +void +xsltStylesheetPtr style,xmlNodePtr inst + + +xsltFreeStylePreComps +void +xsltStylesheetPtr style + + +IN_LIBXSLT +#define IN_LIBXSLT + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC __declspec(dllimport) + + +LIBXSLT_PUBLIC +#define LIBXSLT_PUBLIC +