Whole document tree
    

Whole document tree

transform

transform

Name

transform -- 

Synopsis



void        xsltSetXIncludeDefault          (int xinclude);
int         xsltGetXIncludeDefault          (void);
xsltTransformContextPtr xsltNewTransformContext
                                            (xsltStylesheetPtr style,
                                             xmlDocPtr doc);
void        xsltFreeTransformContext        (xsltTransformContextPtr ctxt);
xmlDocPtr   xsltApplyStylesheetUser         (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             const char *output,
                                             FILE *profile,
                                             xsltTransformContextPtr userCtxt);
void        xsltApplyStripSpaces            (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node);
xsltTransformFunction xsltExtElementLookup  (xsltTransformContextPtr ctxt,
                                             const xmlChar *name,
                                             const xmlChar *URI);
xmlDocPtr   xsltApplyStylesheet             (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params);
xmlDocPtr   xsltProfileStylesheet           (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             FILE *output);
int         xsltRunStylesheet               (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             const char *output,
                                             xmlSAXHandlerPtr SAX,
                                             xmlOutputBufferPtr IObuf);
int         xsltRunStylesheetUser           (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             const char *output,
                                             xmlSAXHandlerPtr SAX,
                                             xmlOutputBufferPtr IObuf,
                                             FILE *profile,
                                             xsltTransformContextPtr userCtxt);
void        xsltApplyOneTemplate            (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr list,
                                             xsltTemplatePtr templ,
                                             xsltStackElemPtr params);
void        xsltDocumentElem                (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltSort                        (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltCopy                        (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltText                        (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltElement                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltComment                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltAttribute                   (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltProcessingInstruction       (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltCopyOf                      (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltValueOf                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltNumber                      (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltApplyImports                (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltCallTemplate                (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltApplyTemplates              (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltChoose                      (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltIf                          (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltForEach                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);
void        xsltRegisterAllElement          (xsltTransformContextPtr ctxt);
void        xslHandleDebugger               (xmlNodePtr cur,
                                             xmlNodePtr node,
                                             xsltTemplatePtr templ,
                                             xsltTransformContextPtr ctxt);

Description

Details

xsltSetXIncludeDefault ()

void        xsltSetXIncludeDefault          (int xinclude);

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

xinclude : whether to do XInclude processing


xsltGetXIncludeDefault ()

int         xsltGetXIncludeDefault          (void);

return the default state for XInclude processing

Returns :0 if there is no processing 1 otherwise


xsltNewTransformContext ()

xsltTransformContextPtr xsltNewTransformContext
                                            (xsltStylesheetPtr style,
                                             xmlDocPtr doc);

Create a new XSLT TransformContext

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


xsltFreeTransformContext ()

void        xsltFreeTransformContext        (xsltTransformContextPtr ctxt);

Free up the memory allocated by ctxt

ctxt : an XSLT parser context


xsltApplyStylesheetUser ()

xmlDocPtr   xsltApplyStylesheetUser         (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             const char *output,
                                             FILE *profile,
                                             xsltTransformContextPtr userCtxt);

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

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


xsltApplyStripSpaces ()

void        xsltApplyStripSpaces            (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node);

Strip the unwanted ignorable spaces from the input tree

ctxt : a XSLT process context
node : 


xsltExtElementLookup ()

xsltTransformFunction xsltExtElementLookup  (xsltTransformContextPtr ctxt,
                                             const xmlChar *name,
                                             const xmlChar *URI);

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

ctxt : 
name : 
URI : 
Returns : 


xsltApplyStylesheet ()

xmlDocPtr   xsltApplyStylesheet             (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params);

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

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


xsltProfileStylesheet ()

xmlDocPtr   xsltProfileStylesheet           (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             FILE *output);

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

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


xsltRunStylesheet ()

int         xsltRunStylesheet               (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             const char *output,
                                             xmlSAXHandlerPtr SAX,
                                             xmlOutputBufferPtr IObuf);

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

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


xsltRunStylesheetUser ()

int         xsltRunStylesheetUser           (xsltStylesheetPtr style,
                                             xmlDocPtr doc,
                                             const char **params,
                                             const char *output,
                                             xmlSAXHandlerPtr SAX,
                                             xmlOutputBufferPtr IObuf,
                                             FILE *profile,
                                             xsltTransformContextPtr userCtxt);

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

style : a parsed XSLT stylesheet
doc : a parsed XML document
params : a NULL terminated arry of parameters names/values tuples
output : the URL/filename ot the generated resource if available
SAX : a SAX handler for progressive callback output (not implemented yet)
IObuf : an output buffer for progressive output (not implemented yet)
profile : profile FILE * output or NULL
userCtxt : user provided transform context
Returns :the number of by written to the main resource or -1 in case of error.


xsltApplyOneTemplate ()

void        xsltApplyOneTemplate            (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr list,
                                             xsltTemplatePtr templ,
                                             xsltStackElemPtr params);

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).

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


xsltDocumentElem ()

void        xsltDocumentElem                (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process an XSLT-1.1 document element

ctxt : an XSLT processing context
node : The current node
inst : the instruction in the stylesheet
comp : precomputed information


xsltSort ()

void        xsltSort                        (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

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

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt sort node
comp : precomputed information


xsltCopy ()

void        xsltCopy                        (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt copy node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt copy node
comp : precomputed information


xsltText ()

void        xsltText                        (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt text node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt text node
comp : precomputed information


xsltElement ()

void        xsltElement                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt element node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt element node
comp : precomputed information


xsltComment ()

void        xsltComment                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt comment node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt comment node
comp : precomputed information


xsltAttribute ()

void        xsltAttribute                   (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt attribute node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt attribute node
comp : precomputed information


xsltProcessingInstruction ()

void        xsltProcessingInstruction       (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt processing-instruction node on the source node

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


xsltCopyOf ()

void        xsltCopyOf                      (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt copy-of node on the source node

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


xsltValueOf ()

void        xsltValueOf                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt value-of node on the source node

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


xsltNumber ()

void        xsltNumber                      (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt number node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt number node
comp : precomputed information


xsltApplyImports ()

void        xsltApplyImports                (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt apply-imports node on the source node

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


xsltCallTemplate ()

void        xsltCallTemplate                (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt call-template node on the source node

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


xsltApplyTemplates ()

void        xsltApplyTemplates              (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the apply-templates node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the apply-templates node
comp : precomputed information


xsltChoose ()

void        xsltChoose                      (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt choose node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt choose node
comp : precomputed information


xsltIf ()

void        xsltIf                          (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt if node on the source node

ctxt : a XSLT process context
node : the node in the source tree.
inst : the xslt if node
comp : precomputed information


xsltForEach ()

void        xsltForEach                     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr inst,
                                             xsltStylePreCompPtr comp);

Process the xslt for-each node on the source node

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


xsltRegisterAllElement ()

void        xsltRegisterAllElement          (xsltTransformContextPtr ctxt);

Registers all default XSLT elements in this context

ctxt : the XPath context


xslHandleDebugger ()

void        xslHandleDebugger               (xmlNodePtr cur,
                                             xmlNodePtr node,
                                             xsltTemplatePtr templ,
                                             xsltTransformContextPtr ctxt);

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

cur : source node being executed
node : data node being processed
templ : temlate that applies to node
ctxt : the xslt transform context