xsltSetXIncludeDefault ()

void        xsltSetXIncludeDefault          (int xinclude);

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

xsltGetXIncludeDefault ()

int         xsltGetXIncludeDefault          (void);

Provides the default state for XInclude processing

xsltNewTransformContext ()

xsltTransformContextPtr xsltNewTransformContext
                                            (xsltStylesheetPtr style,
                                             xmlDocPtr doc);

Create a new XSLT TransformContext

xsltFreeTransformContext ()

void        xsltFreeTransformContext        (xsltTransformContextPtr ctxt);

Free up the memory allocated by ctxt

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.

xsltApplyStripSpaces ()

void        xsltApplyStripSpaces            (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node);

Strip the unwanted ignorable spaces from the input tree

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 !

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.

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

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

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

xsltDocumentElem ()

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

Process an EXSLT/XSLT-1.1 document element

xsltSort ()

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

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

xsltCopy ()

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

Process the xslt copy node on the source node

xsltText ()

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

Process the xslt text node on the source node

xsltElement ()

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

Process the xslt element node on the source node

xsltComment ()

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

Process the xslt comment node on the source node

xsltAttribute ()

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

Process the xslt attribute node on the source node

xsltProcessingInstruction ()

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

Process the xslt processing-instruction node on the source node

xsltCopyOf ()

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

Process the xslt copy-of node on the source node

xsltValueOf ()

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

Process the xslt value-of node on the source node

xsltNumber ()

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

Process the xslt number node on the source node

xsltApplyImports ()

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

Process the xslt apply-imports node on the source node

xsltCallTemplate ()

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

Process the xslt call-template node on the source node

xsltApplyTemplates ()

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

Process the apply-templates node on the source node

xsltChoose ()

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

Process the xslt choose node on the source node

xsltIf ()

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

Process the xslt if node on the source node

xsltForEach ()

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

Process the xslt for-each node on the source node

xsltRegisterAllElement ()

void        xsltRegisterAllElement          (xsltTransformContextPtr ctxt);

Registers all default XSLT elements in this context

xsltCopyTextString ()

xmlNodePtr  xsltCopyTextString              (xsltTransformContextPtr ctxt,
                                             xmlNodePtr target,
                                             const xmlChar *string,
                                             int noescape);

Create a text node

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