Author(s):
#define EXSLT_DATE_NAMESPACE; +#define EXSLT_COMMON_NAMESPACE; +#define EXSLT_CRYPTO_NAMESPACE; +#define EXSLT_DATE_NAMESPACE; +#define EXSLT_DYNAMIC_NAMESPACE; +#define EXSLT_FUNCTIONS_NAMESPACE; +#define EXSLT_MATH_NAMESPACE; +#define EXSLT_SETS_NAMESPACE; #define EXSLT_STRINGS_NAMESPACE; #define SAXON_NAMESPACE; -#define EXSLT_COMMON_NAMESPACE; -#define EXSLT_FUNCTIONS_NAMESPACE; -#define EXSLT_SETS_NAMESPACE; -#define EXSLT_DYNAMIC_NAMESPACE; -#define EXSLT_CRYPTO_NAMESPACE; -#define EXSLT_MATH_NAMESPACE; -void exsltDynRegister (void); void exsltCommonRegister (void); -void exsltRegisterAll (void); -int exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix); -int exsltSetsXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix); -void exsltFuncRegister (void); -void exsltStrRegister (void); -void exsltSetsRegister (void); -void exsltDateRegister (void); void exsltCryptoRegister (void); +void exsltDateRegister (void); +int exsltDateXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix); +void exsltDynRegister (void); +void exsltFuncRegister (void); void exsltMathRegister (void); int exsltMathXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix); +void exsltRegisterAll (void); void exsltSaxonRegister (void); -int exsltDateXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix); +void exsltSetsRegister (void); +int exsltSetsXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix); +void exsltStrRegister (void); +int exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt,
const xmlChar * prefix);
Author(s):
#define LIBEXSLT_PUBLIC; -#define EXSLTPUBLIC; -#define EXSLTCALL; +#define EXSLTCALL; #define EXSLTPUBFUN; +#define EXSLTPUBLIC; #define EXSLTPUBVAR; +#define LIBEXSLT_PUBLIC;
Author(s): Daniel Veillard
void xsltResolveStylesheetAttributeSet (xsltStylesheetPtr style); -void xsltParseStylesheetAttributeSet (xsltStylesheetPtr style,
xmlNodePtr cur); -void xsltApplyAttributeSet (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
const xmlChar * attrSets); +void xsltApplyAttributeSet (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
const xmlChar * attrSets); void xsltFreeAttributeSetsHashes (xsltStylesheetPtr style); +void xsltParseStylesheetAttributeSet (xsltStylesheetPtr style,
xmlNodePtr cur); +void xsltResolveStylesheetAttributeSet (xsltStylesheetPtr style);
typedef enum xsltLoadType; -void xsltFreeStyleDocuments (xsltStylesheetPtr style); typedef xmlDocPtr xsltDocLoaderFunc (const xmlChar * URI,
xmlDictPtr dict,
int options,
void * ctxt,
xsltLoadType type); +xsltDocumentPtr xsltFindDocument (xsltTransformContextPtr ctxt,
xmlDocPtr doc); +void xsltFreeDocuments (xsltTransformContextPtr ctxt); +void xsltFreeStyleDocuments (xsltStylesheetPtr style); xsltDocumentPtr xsltLoadDocument (xsltTransformContextPtr ctxt,
const xmlChar * URI); +xsltDocumentPtr xsltLoadStyleDocument (xsltStylesheetPtr style,
const xmlChar * URI); +xsltDocumentPtr xsltNewDocument (xsltTransformContextPtr ctxt,
xmlDocPtr doc); xsltDocumentPtr xsltNewStyleDocument (xsltStylesheetPtr style,
xmlDocPtr doc); void xsltSetLoaderFunc (xsltDocLoaderFunc f); -void xsltFreeDocuments (xsltTransformContextPtr ctxt); -xsltDocumentPtr xsltNewDocument (xsltTransformContextPtr ctxt,
xmlDocPtr doc); -xsltDocumentPtr xsltLoadStyleDocument (xsltStylesheetPtr style,
const xmlChar * URI); -xsltDocumentPtr xsltFindDocument (xsltTransformContextPtr ctxt,
xmlDocPtr doc);
Author(s): Daniel Veillard
int xsltRegisterExtFunction (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * URI,
xmlXPathFunction function); -int xsltRegisterExtModuleElement (const xmlChar * name,
const xmlChar * URI,
xsltPreComputeFunction precomp,
xsltTransformFunction transform); -int xsltInitCtxtExts (xsltTransformContextPtr ctxt); -void * xsltGetExtData (xsltTransformContextPtr ctxt,
const xmlChar * URI); -void * xsltStyleGetExtData (xsltStylesheetPtr style,
const xmlChar * URI); -typedef void * xsltStyleExtInitFunction (xsltStylesheetPtr style,
const xmlChar * URI); -void xsltInitGlobals (void); -void xsltShutdownExts (xsltStylesheetPtr style); -xsltPreComputeFunction xsltExtModuleElementPreComputeLookup (const xmlChar * name,
const xmlChar * URI); -void xsltRegisterTestModule (void); -void * xsltStyleStylesheetLevelGetExtData (xsltStylesheetPtr style,
const xmlChar * URI); -xsltTransformFunction xsltExtModuleElementLookup (const xmlChar * name,
const xmlChar * URI); -typedef void xsltStyleExtShutdownFunction (xsltStylesheetPtr style,
const xmlChar * URI,
void * data); -void xsltInitElemPreComp (xsltElemPreCompPtr comp,
xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function,
xsltElemPreCompDeallocator freeFunc); -void xsltDebugDumpExtensions (FILE * output); -xmlHashTablePtr xsltGetExtInfo (xsltStylesheetPtr style,
const xmlChar * URI); -xsltTopLevelFunction xsltExtModuleTopLevelLookup (const xmlChar * name,
const xmlChar * URI); -void xsltFreeExts (xsltStylesheetPtr style); +int xsltCheckExtPrefix (xsltStylesheetPtr style,
const xmlChar * URI); int xsltCheckExtURI (xsltStylesheetPtr style,
const xmlChar * URI); -xmlXPathFunction xsltExtModuleFunctionLookup (const xmlChar * name,
const xmlChar * URI); -xsltElemPreCompPtr xsltPreComputeExtModuleElement (xsltStylesheetPtr style,
xmlNodePtr inst); -int xsltRegisterExtModuleTopLevel (const xmlChar * name,
const xmlChar * URI,
xsltTopLevelFunction function); -typedef xsltElemPreCompPtr xsltPreComputeFunction (xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function); -typedef void xsltTopLevelFunction (xsltStylesheetPtr style,
xmlNodePtr inst); -void xsltShutdownCtxtExts (xsltTransformContextPtr ctxt); -xsltTransformContextPtr xsltXPathGetTransformContext (xmlXPathParserContextPtr ctxt); -int xsltRegisterExtElement (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * URI,
xsltTransformFunction function); +void xsltDebugDumpExtensions (FILE * output); +xsltTransformFunction xsltExtElementLookup (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * URI); typedef void * xsltExtInitFunction (xsltTransformContextPtr ctxt,
const xmlChar * URI); +xsltTransformFunction xsltExtModuleElementLookup (const xmlChar * name,
const xmlChar * URI); +xsltPreComputeFunction xsltExtModuleElementPreComputeLookup (const xmlChar * name,
const xmlChar * URI); +xmlXPathFunction xsltExtModuleFunctionLookup (const xmlChar * name,
const xmlChar * URI); +xsltTopLevelFunction xsltExtModuleTopLevelLookup (const xmlChar * name,
const xmlChar * URI); +typedef void xsltExtShutdownFunction (xsltTransformContextPtr ctxt,
const xmlChar * URI,
void * data); void xsltFreeCtxtExts (xsltTransformContextPtr ctxt); -int xsltUnregisterExtModule (const xmlChar * URI); -int xsltRegisterExtModuleFull (const xmlChar * URI,
xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc,
xsltStyleExtInitFunction styleInitFunc,
xsltStyleExtShutdownFunction styleShutdownFunc); -int xsltUnregisterExtModuleTopLevel (const xmlChar * name,
const xmlChar * URI); +void xsltFreeExts (xsltStylesheetPtr style); +void * xsltGetExtData (xsltTransformContextPtr ctxt,
const xmlChar * URI); +xmlHashTablePtr xsltGetExtInfo (xsltStylesheetPtr style,
const xmlChar * URI); +int xsltInitCtxtExts (xsltTransformContextPtr ctxt); +void xsltInitElemPreComp (xsltElemPreCompPtr comp,
xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function,
xsltElemPreCompDeallocator freeFunc); +void xsltInitGlobals (void); xsltElemPreCompPtr xsltNewElemPreComp (xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function); +xsltElemPreCompPtr xsltPreComputeExtModuleElement (xsltStylesheetPtr style,
xmlNodePtr inst); +typedef xsltElemPreCompPtr xsltPreComputeFunction (xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function); +int xsltRegisterExtElement (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * URI,
xsltTransformFunction function); +int xsltRegisterExtFunction (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * URI,
xmlXPathFunction function); +int xsltRegisterExtModule (const xmlChar * URI,
xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc); +int xsltRegisterExtModuleElement (const xmlChar * name,
const xmlChar * URI,
xsltPreComputeFunction precomp,
xsltTransformFunction transform); +int xsltRegisterExtModuleFull (const xmlChar * URI,
xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc,
xsltStyleExtInitFunction styleInitFunc,
xsltStyleExtShutdownFunction styleShutdownFunc); +int xsltRegisterExtModuleFunction (const xmlChar * name,
const xmlChar * URI,
xmlXPathFunction function); +int xsltRegisterExtModuleTopLevel (const xmlChar * name,
const xmlChar * URI,
xsltTopLevelFunction function); +int xsltRegisterExtPrefix (xsltStylesheetPtr style,
const xmlChar * prefix,
const xmlChar * URI); +void xsltRegisterTestModule (void); +void xsltShutdownCtxtExts (xsltTransformContextPtr ctxt); +void xsltShutdownExts (xsltStylesheetPtr style); +typedef void * xsltStyleExtInitFunction (xsltStylesheetPtr style,
const xmlChar * URI); +typedef void xsltStyleExtShutdownFunction (xsltStylesheetPtr style,
const xmlChar * URI,
void * data); +void * xsltStyleGetExtData (xsltStylesheetPtr style,
const xmlChar * URI); +void * xsltStyleStylesheetLevelGetExtData (xsltStylesheetPtr style,
const xmlChar * URI); +typedef void xsltTopLevelFunction (xsltStylesheetPtr style,
xmlNodePtr inst); +int xsltUnregisterExtModule (const xmlChar * URI); int xsltUnregisterExtModuleElement (const xmlChar * name,
const xmlChar * URI); int xsltUnregisterExtModuleFunction (const xmlChar * name,
const xmlChar * URI); -int xsltCheckExtPrefix (xsltStylesheetPtr style,
const xmlChar * URI); -int xsltRegisterExtModule (const xmlChar * URI,
xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc); -xsltTransformFunction xsltExtElementLookup (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * URI); -int xsltRegisterExtModuleFunction (const xmlChar * name,
const xmlChar * URI,
xmlXPathFunction function); -int xsltRegisterExtPrefix (xsltStylesheetPtr style,
const xmlChar * prefix,
const xmlChar * URI); -typedef void xsltExtShutdownFunction (xsltTransformContextPtr ctxt,
const xmlChar * URI,
void * data); +int xsltUnregisterExtModuleTopLevel (const xmlChar * name,
const xmlChar * URI); +xsltTransformContextPtr xsltXPathGetTransformContext (xmlXPathParserContextPtr ctxt);
Author(s): Daniel Veillard
#define XSLT_XT_NAMESPACE; -#define XSLT_XALAN_NAMESPACE; +#define XSLT_LIBXSLT_NAMESPACE; #define XSLT_SAXON_NAMESPACE; -#define XSLT_LIBXSLT_NAMESPACE; -void xsltFunctionNodeSet (xmlXPathParserContextPtr ctxt,
int nargs); -void xsltRegisterExtras (xsltTransformContextPtr ctxt); +#define XSLT_XALAN_NAMESPACE; +#define XSLT_XT_NAMESPACE; void xsltDebug (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); +void xsltFunctionNodeSet (xmlXPathParserContextPtr ctxt,
int nargs); void xsltRegisterAllExtras (void); +void xsltRegisterExtras (xsltTransformContextPtr ctxt);
#define XSLT_REGISTER_FUNCTION_LOOKUP; -xmlXPathFunction xsltXPathFunctionLookup (void * vctxt,
const xmlChar * name,
const xmlChar * ns_uri); -void xsltFunctionAvailableFunction (xmlXPathParserContextPtr ctxt,
int nargs); -void xsltFormatNumberFunction (xmlXPathParserContextPtr ctxt,
int nargs); -void xsltRegisterAllFunctions (xmlXPathContextPtr ctxt); -void xsltKeyFunction (xmlXPathParserContextPtr ctxt,
int nargs); -void xsltUnparsedEntityURIFunction (xmlXPathParserContextPtr ctxt,
int nargs); void xsltDocumentFunction (xmlXPathParserContextPtr ctxt,
int nargs); -void xsltSystemPropertyFunction (xmlXPathParserContextPtr ctxt,
int nargs); void xsltElementAvailableFunction (xmlXPathParserContextPtr ctxt,
int nargs); +void xsltFormatNumberFunction (xmlXPathParserContextPtr ctxt,
int nargs); +void xsltFunctionAvailableFunction (xmlXPathParserContextPtr ctxt,
int nargs); void xsltGenerateIdFunction (xmlXPathParserContextPtr ctxt,
int nargs); +void xsltKeyFunction (xmlXPathParserContextPtr ctxt,
int nargs); +void xsltRegisterAllFunctions (xmlXPathContextPtr ctxt); +void xsltSystemPropertyFunction (xmlXPathParserContextPtr ctxt,
int nargs); +void xsltUnparsedEntityURIFunction (xmlXPathParserContextPtr ctxt,
int nargs); +xmlXPathFunction xsltXPathFunctionLookup (void * vctxt,
const xmlChar * name,
const xmlChar * ns_uri);
Author(s): Daniel Veillard
#define XSLT_GET_IMPORT_PTR; -#define XSLT_GET_IMPORT_INT; -xsltTemplatePtr xsltFindTemplate (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * nameURI); -xsltStylesheetPtr xsltNextImport (xsltStylesheetPtr cur); -int xsltParseStylesheetInclude (xsltStylesheetPtr style,
xmlNodePtr cur); -int xsltNeedElemSpaceHandling (xsltTransformContextPtr ctxt); +#define XSLT_GET_IMPORT_INT; +#define XSLT_GET_IMPORT_PTR; int xsltFindElemSpaceHandling (xsltTransformContextPtr ctxt,
xmlNodePtr node); +xsltTemplatePtr xsltFindTemplate (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * nameURI); +int xsltNeedElemSpaceHandling (xsltTransformContextPtr ctxt); +xsltStylesheetPtr xsltNextImport (xsltStylesheetPtr cur); int xsltParseStylesheetImport (xsltStylesheetPtr style,
xmlNodePtr cur); +int xsltParseStylesheetInclude (xsltStylesheetPtr style,
xmlNodePtr cur);
#define NODE_IS_KEYED; -void xsltInitCtxtKeys (xsltTransformContextPtr ctxt,
xsltDocumentPtr idoc); +int xsltAddKey (xsltStylesheetPtr style,
const xmlChar * name,
const xmlChar * nameURI,
const xmlChar * match,
const xmlChar * use,
xmlNodePtr inst); +void xsltFreeDocumentKeys (xsltDocumentPtr idoc); void xsltFreeKeys (xsltStylesheetPtr style); xmlNodeSetPtr xsltGetKey (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * nameURI,
const xmlChar * value); -void xsltFreeDocumentKeys (xsltDocumentPtr idoc); -int xsltAddKey (xsltStylesheetPtr style,
const xmlChar * name,
const xmlChar * nameURI,
const xmlChar * match,
const xmlChar * use,
xmlNodePtr inst); +void xsltInitCtxtKeys (xsltTransformContextPtr ctxt,
xsltDocumentPtr idoc);
#define UNDEFINED_DEFAULT_NS; -void xsltFreeNamespaceAliasHashes (xsltStylesheetPtr style); xmlNsPtr xsltCopyNamespace (xsltTransformContextPtr ctxt,
xmlNodePtr elem,
xmlNsPtr ns); xmlNsPtr xsltCopyNamespaceList (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNsPtr cur); +void xsltFreeNamespaceAliasHashes (xsltStylesheetPtr style); xmlNsPtr xsltGetNamespace (xsltTransformContextPtr ctxt,
xmlNodePtr cur,
xmlNsPtr ns,
xmlNodePtr out); xmlNsPtr xsltGetPlainNamespace (xsltTransformContextPtr ctxt,
xmlNodePtr cur,
xmlNsPtr ns,
xmlNodePtr out); xmlNsPtr xsltGetSpecialNamespace (xsltTransformContextPtr ctxt,
xmlNodePtr invocNode,
const xmlChar * nsName,
const xmlChar * nsPrefix,
xmlNodePtr target); diff --git a/doc/devhelp/libxslt-numbersInternals.html b/doc/devhelp/libxslt-numbersInternals.html index ff892f5a..05dda0b7 100644 --- a/doc/devhelp/libxslt-numbersInternals.html +++ b/doc/devhelp/libxslt-numbersInternals.html @@ -44,9 +44,9 @@Synopsis
typedef struct _xsltFormatNumberInfo xsltFormatNumberInfo; +typedef xsltFormatNumberInfo * xsltFormatNumberInfoPtr; typedef struct _xsltNumberData xsltNumberData; typedef xsltNumberData * xsltNumberDataPtr; -typedef xsltFormatNumberInfo * xsltFormatNumberInfoPtr;diff --git a/doc/devhelp/libxslt-pattern.html b/doc/devhelp/libxslt-pattern.html index 5c7187e3..ce476e59 100644 --- a/doc/devhelp/libxslt-pattern.html +++ b/doc/devhelp/libxslt-pattern.html @@ -45,16 +45,16 @@Synopsis
typedef struct _xsltCompMatch xsltCompMatch; typedef xsltCompMatch * xsltCompMatchPtr; -void xsltNormalizeCompSteps (void * payload,
void * data,
const xmlChar * name); int xsltAddTemplate (xsltStylesheetPtr style,
xsltTemplatePtr cur,
const xmlChar * mode,
const xmlChar * modeURI); -xsltCompMatchPtr xsltCompilePattern (const xmlChar * pattern,
xmlDocPtr doc,
xmlNodePtr node,
xsltStylesheetPtr style,
xsltTransformContextPtr runtime); -int xsltMatchPattern (xsltTransformContextPtr ctxt,
xmlNodePtr node,
const xmlChar * pattern,
xmlDocPtr ctxtdoc,
xmlNodePtr ctxtnode); -xsltTemplatePtr xsltGetTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xsltStylesheetPtr style); +void xsltCleanupTemplates (xsltStylesheetPtr style); void xsltCompMatchClearCache (xsltTransformContextPtr ctxt,
xsltCompMatchPtr comp); -int xsltTestCompMatchList (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xsltCompMatchPtr comp); +xsltCompMatchPtr xsltCompilePattern (const xmlChar * pattern,
xmlDocPtr doc,
xmlNodePtr node,
xsltStylesheetPtr style,
xsltTransformContextPtr runtime); void xsltFreeCompMatchList (xsltCompMatchPtr comp); void xsltFreeTemplateHashes (xsltStylesheetPtr style); -void xsltCleanupTemplates (xsltStylesheetPtr style); +xsltTemplatePtr xsltGetTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xsltStylesheetPtr style); +int xsltMatchPattern (xsltTransformContextPtr ctxt,
xmlNodePtr node,
const xmlChar * pattern,
xmlDocPtr ctxtdoc,
xmlNodePtr ctxtnode); +void xsltNormalizeCompSteps (void * payload,
void * data,
const xmlChar * name); +int xsltTestCompMatchList (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xsltCompMatchPtr comp);diff --git a/doc/devhelp/libxslt-preproc.html b/doc/devhelp/libxslt-preproc.html index 93dd848b..37fc4c61 100644 --- a/doc/devhelp/libxslt-preproc.html +++ b/doc/devhelp/libxslt-preproc.html @@ -43,8 +43,8 @@Author(s): Daniel Veillard
diff --git a/doc/devhelp/libxslt-security.html b/doc/devhelp/libxslt-security.html index 87e73a83..d167090f 100644 --- a/doc/devhelp/libxslt-security.html +++ b/doc/devhelp/libxslt-security.html @@ -43,21 +43,21 @@Synopsis
-void xsltFreeStylePreComps (xsltStylesheetPtr style); -xsltElemPreCompPtr xsltDocumentComp (xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function); +xsltElemPreCompPtr xsltDocumentComp (xsltStylesheetPtr style,
xmlNodePtr inst,
xsltTransformFunction function); +void xsltFreeStylePreComps (xsltStylesheetPtr style); void xsltStylePreCompute (xsltStylesheetPtr style,
xmlNodePtr inst);Author(s): Daniel Veillard
Synopsis
-typedef struct _xsltSecurityPrefs xsltSecurityPrefs; +typedef enum xsltSecurityOption; +typedef struct _xsltSecurityPrefs xsltSecurityPrefs; typedef xsltSecurityPrefs * xsltSecurityPrefsPtr; -typedef enum xsltSecurityOption; -xsltSecurityPrefsPtr xsltNewSecurityPrefs (void); -typedef int xsltSecurityCheck (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const char * value); -int xsltSetSecurityPrefs (xsltSecurityPrefsPtr sec,
xsltSecurityOption option,
xsltSecurityCheck func); -xsltSecurityPrefsPtr xsltGetDefaultSecurityPrefs (void); -void xsltFreeSecurityPrefs (xsltSecurityPrefsPtr sec); -void xsltSetDefaultSecurityPrefs (xsltSecurityPrefsPtr sec); -int xsltSetCtxtSecurityPrefs (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt); -xsltSecurityCheck xsltGetSecurityPrefs (xsltSecurityPrefsPtr sec,
xsltSecurityOption option); -int xsltSecurityAllow (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const char * value); -int xsltCheckWrite (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const xmlChar * URL); int xsltCheckRead (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const xmlChar * URL); +int xsltCheckWrite (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const xmlChar * URL); +void xsltFreeSecurityPrefs (xsltSecurityPrefsPtr sec); +xsltSecurityPrefsPtr xsltGetDefaultSecurityPrefs (void); +xsltSecurityCheck xsltGetSecurityPrefs (xsltSecurityPrefsPtr sec,
xsltSecurityOption option); +xsltSecurityPrefsPtr xsltNewSecurityPrefs (void); +int xsltSecurityAllow (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const char * value); +typedef int xsltSecurityCheck (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const char * value); int xsltSecurityForbid (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt,
const char * value); +int xsltSetCtxtSecurityPrefs (xsltSecurityPrefsPtr sec,
xsltTransformContextPtr ctxt); +void xsltSetDefaultSecurityPrefs (xsltSecurityPrefsPtr sec); +int xsltSetSecurityPrefs (xsltSecurityPrefsPtr sec,
xsltSecurityOption option,
xsltSecurityCheck func);diff --git a/doc/devhelp/libxslt-templates.html b/doc/devhelp/libxslt-templates.html index ec89ded2..c636c4da 100644 --- a/doc/devhelp/libxslt-templates.html +++ b/doc/devhelp/libxslt-templates.html @@ -43,17 +43,17 @@Author(s): Daniel Veillard
Synopsis
-const xmlChar * xsltEvalStaticAttrValueTemplate (xsltStylesheetPtr style,
xmlNodePtr inst,
const xmlChar * name,
const xmlChar * ns,
int * found); -xmlAttrPtr xsltAttrListTemplateProcess (xsltTransformContextPtr ctxt,
xmlNodePtr target,
xmlAttrPtr attrs); -xmlChar * xsltEvalTemplateString (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst); -xmlChar * xsltAttrTemplateValueProcess (xsltTransformContextPtr ctxt,
const xmlChar * str); +xmlAttrPtr xsltAttrListTemplateProcess (xsltTransformContextPtr ctxt,
xmlNodePtr target,
xmlAttrPtr attrs); xmlAttrPtr xsltAttrTemplateProcess (xsltTransformContextPtr ctxt,
xmlNodePtr target,
xmlAttrPtr attr); -xmlChar * xsltEvalAttrValueTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr inst,
const xmlChar * name,
const xmlChar * ns); -int xsltEvalXPathPredicate (xsltTransformContextPtr ctxt,
xmlXPathCompExprPtr comp,
xmlNsPtr * nsList,
int nsNr); +xmlChar * xsltAttrTemplateValueProcess (xsltTransformContextPtr ctxt,
const xmlChar * str); xmlChar * xsltAttrTemplateValueProcessNode (xsltTransformContextPtr ctxt,
const xmlChar * str,
xmlNodePtr inst); -xmlNodePtr * xsltTemplateProcess (xsltTransformContextPtr ctxt,
xmlNodePtr node); -xmlChar * xsltEvalXPathStringNs (xsltTransformContextPtr ctxt,
xmlXPathCompExprPtr comp,
int nsNr,
xmlNsPtr * nsList); +xmlChar * xsltEvalAttrValueTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr inst,
const xmlChar * name,
const xmlChar * ns); +const xmlChar * xsltEvalStaticAttrValueTemplate (xsltStylesheetPtr style,
xmlNodePtr inst,
const xmlChar * name,
const xmlChar * ns,
int * found); +xmlChar * xsltEvalTemplateString (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst); +int xsltEvalXPathPredicate (xsltTransformContextPtr ctxt,
xmlXPathCompExprPtr comp,
xmlNsPtr * nsList,
int nsNr); xmlChar * xsltEvalXPathString (xsltTransformContextPtr ctxt,
xmlXPathCompExprPtr comp); +xmlChar * xsltEvalXPathStringNs (xsltTransformContextPtr ctxt,
xmlXPathCompExprPtr comp,
int nsNr,
xmlNsPtr * nsList); +xmlNodePtr * xsltTemplateProcess (xsltTransformContextPtr ctxt,
xmlNodePtr node);diff --git a/doc/devhelp/libxslt-transform.html b/doc/devhelp/libxslt-transform.html index d6ecef6e..6c96eba7 100644 --- a/doc/devhelp/libxslt-transform.html +++ b/doc/devhelp/libxslt-transform.html @@ -43,40 +43,40 @@Author(s): Daniel Veillard
Synopsis
-void xsltValueOf (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -void xsltRegisterAllElement (xsltTransformContextPtr ctxt); -void xsltSort (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); -void xsltSetXIncludeDefault (int xinclude); -void xsltCopyOf (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -void xsltApplyTemplates (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -void xsltIf (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -void xsltCallTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -xmlDocPtr xsltApplyStylesheet (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params); -void xsltApplyStripSpaces (xsltTransformContextPtr ctxt,
xmlNodePtr node); -int xsltLocalVariablePush (xsltTransformContextPtr ctxt,
xsltStackElemPtr variable,
int level); -void xsltFreeTransformContext (xsltTransformContextPtr ctxt); -int xsltRunStylesheet (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params,
const char * output,
xmlSAXHandlerPtr SAX,
xmlOutputBufferPtr IObuf); -void xsltChoose (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr comp); -xmlNodePtr xsltCopyTextString (xsltTransformContextPtr ctxt,
xmlNodePtr target,
const xmlChar * string,
int noescape); -void xsltText (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); -void xsltProcessOneNode (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xsltStackElemPtr withParams); -void xsltLocalVariablePop (xsltTransformContextPtr ctxt,
int limitNr,
int level); -void xsltNumber (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -int xsltRunStylesheetUser (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params,
const char * output,
xmlSAXHandlerPtr SAX,
xmlOutputBufferPtr IObuf,
FILE * profile,
xsltTransformContextPtr userCtxt); -xsltTransformContextPtr xsltNewTransformContext (xsltStylesheetPtr style,
xmlDocPtr doc); -int xsltGetXIncludeDefault (void); -void xsltApplyOneTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr list,
xsltTemplatePtr templ,
xsltStackElemPtr params); -void xslHandleDebugger (xmlNodePtr cur,
xmlNodePtr node,
xsltTemplatePtr templ,
xsltTransformContextPtr ctxt); -void xsltCopy (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -void xsltDocumentElem (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -void xsltAttribute (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xslHandleDebugger (xmlNodePtr cur,
xmlNodePtr node,
xsltTemplatePtr templ,
xsltTransformContextPtr ctxt); void xsltApplyImports (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr comp); -void xsltElement (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); -xmlDocPtr xsltProfileStylesheet (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params,
FILE * output); -void xsltForEach (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltApplyOneTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr list,
xsltTemplatePtr templ,
xsltStackElemPtr params); +void xsltApplyStripSpaces (xsltTransformContextPtr ctxt,
xmlNodePtr node); +xmlDocPtr xsltApplyStylesheet (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params); xmlDocPtr xsltApplyStylesheetUser (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params,
const char * output,
FILE * profile,
xsltTransformContextPtr userCtxt); -void xsltProcessingInstruction (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltApplyTemplates (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltAttribute (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltCallTemplate (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltChoose (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr comp); void xsltComment (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); +void xsltCopy (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltCopyOf (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +xmlNodePtr xsltCopyTextString (xsltTransformContextPtr ctxt,
xmlNodePtr target,
const xmlChar * string,
int noescape); +void xsltDocumentElem (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltElement (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltForEach (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltFreeTransformContext (xsltTransformContextPtr ctxt); +int xsltGetXIncludeDefault (void); +void xsltIf (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltLocalVariablePop (xsltTransformContextPtr ctxt,
int limitNr,
int level); +int xsltLocalVariablePush (xsltTransformContextPtr ctxt,
xsltStackElemPtr variable,
int level); +xsltTransformContextPtr xsltNewTransformContext (xsltStylesheetPtr style,
xmlDocPtr doc); +void xsltNumber (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +void xsltProcessOneNode (xsltTransformContextPtr ctxt,
xmlNodePtr contextNode,
xsltStackElemPtr withParams); +void xsltProcessingInstruction (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp); +xmlDocPtr xsltProfileStylesheet (xsltStylesheetPtr style,
xmlDocPtr doc,
const char ** params,
FILE * output); +void xsltRegisterAllElement (xsltTransformContextPtr ctxt); +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 xsltSetXIncludeDefault (int xinclude); +void xsltSort (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); +void xsltText (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); +void xsltValueOf (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr castedComp);@@ -155,7 +155,7 @@ void xsltComment (+xsltFreeTransformContext ()
void xsltFreeTransformContext (xsltTransformContextPtr ctxt)
Free up the memory allocated by @ctxt
-
ctxt: an XSLT parser context
ctxt: an XSLT transform context
xsltGetXIncludeDefault ()
int xsltGetXIncludeDefault (void)
Provides the default state for XInclude processing
diff --git a/doc/devhelp/libxslt-variables.html b/doc/devhelp/libxslt-variables.html index 628ab55d..6c8efa9e 100644 --- a/doc/devhelp/libxslt-variables.html +++ b/doc/devhelp/libxslt-variables.html @@ -47,20 +47,20 @@ #define XSLT_RVT_FUNC_RESULT; #define XSLT_RVT_GLOBAL; #define XSLT_RVT_LOCAL; -void xsltFreeGlobalVariables (xsltTransformContextPtr ctxt); -int xsltQuoteUserParams (xsltTransformContextPtr ctxt,
const char ** params); -xmlXPathObjectPtr xsltXPathVariableLookup (void * ctxt,
const xmlChar * name,
const xmlChar * ns_uri); -int xsltEvalUserParams (xsltTransformContextPtr ctxt,
const char ** params); -xsltStackElemPtr xsltParseStylesheetCallerParam (xsltTransformContextPtr ctxt,
xmlNodePtr inst); int xsltAddStackElemList (xsltTransformContextPtr ctxt,
xsltStackElemPtr elems); -void xsltParseGlobalVariable (xsltStylesheetPtr style,
xmlNodePtr cur); -int xsltQuoteOneUserParam (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * value); -void xsltParseGlobalParam (xsltStylesheetPtr style,
xmlNodePtr cur); -void xsltParseStylesheetVariable (xsltTransformContextPtr ctxt,
xmlNodePtr inst); int xsltEvalGlobalVariables (xsltTransformContextPtr ctxt); int xsltEvalOneUserParam (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * value); +int xsltEvalUserParams (xsltTransformContextPtr ctxt,
const char ** params); +void xsltFreeGlobalVariables (xsltTransformContextPtr ctxt); +void xsltParseGlobalParam (xsltStylesheetPtr style,
xmlNodePtr cur); +void xsltParseGlobalVariable (xsltStylesheetPtr style,
xmlNodePtr cur); +xsltStackElemPtr xsltParseStylesheetCallerParam (xsltTransformContextPtr ctxt,
xmlNodePtr inst); void xsltParseStylesheetParam (xsltTransformContextPtr ctxt,
xmlNodePtr cur); +void xsltParseStylesheetVariable (xsltTransformContextPtr ctxt,
xmlNodePtr inst); +int xsltQuoteOneUserParam (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * value); +int xsltQuoteUserParams (xsltTransformContextPtr ctxt,
const char ** params); xmlXPathObjectPtr xsltVariableLookup (xsltTransformContextPtr ctxt,
const xmlChar * name,
const xmlChar * ns_uri); +xmlXPathObjectPtr xsltXPathVariableLookup (void * ctxt,
const xmlChar * name,
const xmlChar * ns_uri);diff --git a/doc/devhelp/libxslt-xslt.html b/doc/devhelp/libxslt-xslt.html index aed8eb06..2707ac95 100644 --- a/doc/devhelp/libxslt-xslt.html +++ b/doc/devhelp/libxslt-xslt.html @@ -43,11 +43,11 @@Author(s): Daniel Veillard
Synopsis
-#define XSLT_DEFAULT_VERSION; +#define XSLT_DEFAULT_URL; #define XSLT_DEFAULT_VENDOR; -#define XSLT_PARSE_OPTIONS; -#define XSLT_DEFAULT_URL; +#define XSLT_DEFAULT_VERSION; #define XSLT_NAMESPACE; +#define XSLT_PARSE_OPTIONS; void xsltCleanupGlobals (void); void xsltInit (void);@@ -79,19 +79,19 @@ void xsltInit (void);
Variable xsltLibxmlVersion
const int xsltLibxmlVersion; -+The version of libxml libxslt was compiled against.
Variable xsltMaxVars
int xsltMaxVars; diff --git a/doc/devhelp/libxslt-xsltInternals.html b/doc/devhelp/libxslt-xsltInternals.html index 31b61e3b..8fa8c653 100644 --- a/doc/devhelp/libxslt-xsltInternals.html +++ b/doc/devhelp/libxslt-xsltInternals.html @@ -43,183 +43,186 @@Author(s): Daniel Veillard
Synopsis
-#define CHECK_STOPPED0; -#define XSLT_PAT_NO_PRIORITY; -#define XSLT_ITEM_NSINSCOPE_FIELDS; -#define XSLT_IS_TEXT_NODE; -#define IS_XSLT_ELEM_FAST; -#define XSLT_REFACTORED_VARS; -#define XSLT_RUNTIME_EXTRA_LST(ctxt, nr); -#define XSLT_ITEM_COMPATIBILITY_FIELDS; -#define IS_XSLT_ATTR_FAST; -#define XSLT_HAS_INTERNAL_NSMAP; -#define XSLT_FAST_IF; -#define XSLT_MARK_RES_TREE_FRAG; -#define XSLT_GET_INTERNAL_NSMAP; -#define XSLT_REFACTORED_KEYCOMP; -#define XSLT_ITEM_NAVIGATION_FIELDS; -#define XSLT_MAX_SORT; -#define XSLT_RUNTIME_EXTRA(ctxt, nr); -#define XSLT_IS_RES_TREE_FRAG; -#define XML_CAST_FPTR(fptr); -#define XSLT_ITEM_COMMON_FIELDS; -#define CHECK_STOPPED; -#define XSLT_RUNTIME_EXTRA_FREE(ctxt, nr); -#define XSLT_CCTXT; +#define CHECK_STOPPED; +#define CHECK_STOPPED0; #define CHECK_STOPPEDE; -typedef struct _xsltElemPreComp xsltElemPreComp; -typedef xsltStyleItemPI * xsltStyleItemPIPtr; -typedef struct _xsltDocument xsltDocument; -typedef struct _xsltStyleItemDocument xsltStyleItemDocument; -typedef xsltStyleItemMessage * xsltStyleItemMessagePtr; -typedef xsltStyleItemNumber * xsltStyleItemNumberPtr; -typedef xsltStyleBasicItemVariable * xsltStyleBasicItemVariablePtr; -typedef xsltStyleItemForEach * xsltStyleItemForEachPtr; -typedef enum xsltTransformState; -typedef xsltCompilerNodeInfo * xsltCompilerNodeInfoPtr; -typedef xsltStyleItemLRElementInfo * xsltStyleItemLRElementInfoPtr; -typedef xsltRuntimeExtra * xsltRuntimeExtraPtr; -typedef struct _xsltStyleItemLRElementInfo xsltStyleItemLRElementInfo; -typedef xsltStyleItemWithParam * xsltStyleItemWithParamPtr; -typedef xsltStyleItemComment * xsltStyleItemCommentPtr; -typedef struct _xsltStyleItemMessage xsltStyleItemMessage; -typedef xsltStyleItemParam * xsltStyleItemParamPtr; -typedef xsltStyleBasicExpressionItem xsltStyleItemCopyOf; -typedef xsltStyleItemCallTemplate * xsltStyleItemCallTemplatePtr; -typedef struct _xsltTransformCache xsltTransformCache; -typedef xsltStyleItemCopyOf * xsltStyleItemCopyOfPtr; -typedef struct _xsltNsMap xsltNsMap; -typedef struct _xsltEffectiveNs xsltEffectiveNs; -typedef xsltStyleItemApplyImports * xsltStyleItemApplyImportsPtr; -typedef struct _xsltStylesheet xsltStylesheet; -typedef xsltStylePreComp * xsltStylePreCompPtr; -typedef xsltNsMap * xsltNsMapPtr; -typedef xsltDecimalFormat * xsltDecimalFormatPtr; -typedef xsltStyleItemInclude * xsltStyleItemIncludePtr; -typedef xsltKeyTable * xsltKeyTablePtr; -typedef xsltStyleItemText * xsltStyleItemTextPtr; -typedef struct _xsltCompilerNodeInfo xsltCompilerNodeInfo; -typedef xsltStylesheet * xsltStylesheetPtr; -typedef xsltTemplate * xsltTemplatePtr; -typedef struct _xsltStyleBasicEmptyItem xsltStyleBasicEmptyItem; -typedef struct _xsltStackElem xsltStackElem; -typedef xsltStyleItemIf * xsltStyleItemIfPtr; -typedef xsltStyleItemWhen * xsltStyleItemWhenPtr; -typedef xsltStyleItemElement * xsltStyleItemElementPtr; -typedef struct _xsltStyleItemOtherwise xsltStyleItemOtherwise; -typedef struct _xsltStyleItemCopy xsltStyleItemCopy; -typedef xsltKeyDef * xsltKeyDefPtr; -typedef xsltVarInfo * xsltVarInfoPtr; -typedef struct _xsltStyleItemSort xsltStyleItemSort; -typedef xsltTransformCache * xsltTransformCachePtr; -typedef xsltStyleItemExtElement * xsltStyleItemExtElementPtr; -typedef xsltNsAlias * xsltNsAliasPtr; -typedef xsltStyleItemValueOf * xsltStyleItemValueOfPtr; -typedef xsltDocument * xsltDocumentPtr; -typedef xsltPointerList * xsltPointerListPtr; -typedef struct _xsltTemplate xsltTemplate; -typedef xsltStyleBasicExpressionItem * xsltStyleBasicExpressionItemPtr; -typedef struct _xsltRuntimeExtra xsltRuntimeExtra; -typedef xsltStyleItemAttribute * xsltStyleItemAttributePtr; -typedef struct _xsltTransformContext xsltTransformContext; -typedef struct _xsltPointerList xsltPointerList; -typedef struct _xsltStyleItemUknown xsltStyleItemUknown; -typedef enum xsltErrorSeverityType; -typedef xsltElemPreComp * xsltElemPreCompPtr; -typedef xsltStyleBasicEmptyItem xsltStyleItemFallback; -typedef xsltStyleItemOtherwise * xsltStyleItemOtherwisePtr; -typedef struct _xsltStyleItemWhen xsltStyleItemWhen; -typedef struct _xsltStyleItemIf xsltStyleItemIf; -typedef xsltTransformContext * xsltTransformContextPtr; -typedef struct _xsltNsList xsltNsList; -typedef xsltStyleBasicExpressionItem xsltStyleItemForEach; -typedef struct _xsltStyleItemExtElement xsltStyleItemExtElement; -typedef xsltNsListContainer * xsltNsListContainerPtr; -typedef struct _xsltStyleBasicExpressionItem xsltStyleBasicExpressionItem; -typedef xsltStyleBasicItemVariable xsltStyleItemWithParam; -typedef struct _xsltStyleItemElement xsltStyleItemElement; +#define IS_XSLT_ATTR_FAST; +#define IS_XSLT_ELEM_FAST; +#define XML_CAST_FPTR(fptr); +#define XSLT_CCTXT; +#define XSLT_FAST_IF; +#define XSLT_GET_INTERNAL_NSMAP; +#define XSLT_HAS_INTERNAL_NSMAP; +#define XSLT_IS_RES_TREE_FRAG; +#define XSLT_IS_TEXT_NODE; +#define XSLT_ITEM_COMMON_FIELDS; +#define XSLT_ITEM_COMPATIBILITY_FIELDS; +#define XSLT_ITEM_NAVIGATION_FIELDS; +#define XSLT_ITEM_NSINSCOPE_FIELDS; +#define XSLT_MARK_RES_TREE_FRAG; +#define XSLT_MAX_SORT; +#define XSLT_PAT_NO_PRIORITY; +#define XSLT_REFACTORED_KEYCOMP; +#define XSLT_REFACTORED_VARS; +#define XSLT_RUNTIME_EXTRA(ctxt, nr); +#define XSLT_RUNTIME_EXTRA_FREE(ctxt, nr); +#define XSLT_RUNTIME_EXTRA_LST(ctxt, nr); typedef struct _xsltCompilerCtxt xsltCompilerCtxt; -typedef xsltStyleBasicEmptyItem xsltStyleItemComment; -typedef xsltEffectiveNs * xsltEffectiveNsPtr; -typedef xsltStyleBasicItemVariable xsltStyleItemVariable; -typedef xsltStyleItemVariable * xsltStyleItemVariablePtr; -typedef struct _xsltStyleItemParam xsltStyleItemParam; -typedef struct _xsltNsListContainer xsltNsListContainer; -typedef xsltStackElem * xsltStackElemPtr; -typedef xsltStyleBasicEmptyItem * xsltStyleBasicEmptyItemPtr; -typedef struct _xsltStyleItemText xsltStyleItemText; -typedef xsltStyleItemCopy * xsltStyleItemCopyPtr; -typedef xsltStyleItemSort * xsltStyleItemSortPtr; -typedef struct _xsltPrincipalStylesheetData xsltPrincipalStylesheetData; -typedef enum xsltOutputType; -typedef xsltPrincipalStylesheetData * xsltPrincipalStylesheetDataPtr; -typedef struct _xsltStyleBasicItemVariable xsltStyleBasicItemVariable; -typedef xsltStyleItemChoose * xsltStyleItemChoosePtr; -typedef struct _xsltNsAlias xsltNsAlias; -typedef struct _xsltVarInfo xsltVarInfo; -typedef xsltStyleBasicEmptyItem xsltStyleItemApplyImports; -typedef struct _xsltKeyTable xsltKeyTable; -typedef struct _xsltStylePreComp xsltStylePreComp; -typedef xsltNsList * xsltNsListPtr; -typedef struct _xsltKeyDef xsltKeyDef; +typedef xsltCompilerCtxt * xsltCompilerCtxtPtr; +typedef struct _xsltCompilerNodeInfo xsltCompilerNodeInfo; +typedef xsltCompilerNodeInfo * xsltCompilerNodeInfoPtr; typedef struct _xsltDecimalFormat xsltDecimalFormat; +typedef xsltDecimalFormat * xsltDecimalFormatPtr; +typedef struct _xsltDocument xsltDocument; +typedef xsltDocument * xsltDocumentPtr; +typedef struct _xsltEffectiveNs xsltEffectiveNs; +typedef xsltEffectiveNs * xsltEffectiveNsPtr; +typedef struct _xsltElemPreComp xsltElemPreComp; +typedef xsltElemPreComp * xsltElemPreCompPtr; +typedef enum xsltErrorSeverityType; +typedef struct _xsltKeyDef xsltKeyDef; +typedef xsltKeyDef * xsltKeyDefPtr; +typedef struct _xsltKeyTable xsltKeyTable; +typedef xsltKeyTable * xsltKeyTablePtr; +typedef struct _xsltNsAlias xsltNsAlias; +typedef xsltNsAlias * xsltNsAliasPtr; +typedef struct _xsltNsList xsltNsList; +typedef struct _xsltNsListContainer xsltNsListContainer; +typedef xsltNsListContainer * xsltNsListContainerPtr; +typedef xsltNsList * xsltNsListPtr; +typedef struct _xsltNsMap xsltNsMap; +typedef xsltNsMap * xsltNsMapPtr; +typedef enum xsltOutputType; +typedef struct _xsltPointerList xsltPointerList; +typedef xsltPointerList * xsltPointerListPtr; +typedef struct _xsltPrincipalStylesheetData xsltPrincipalStylesheetData; +typedef xsltPrincipalStylesheetData * xsltPrincipalStylesheetDataPtr; +typedef struct _xsltRuntimeExtra xsltRuntimeExtra; +typedef xsltRuntimeExtra * xsltRuntimeExtraPtr; +typedef struct _xsltStackElem xsltStackElem; +typedef xsltStackElem * xsltStackElemPtr; +typedef struct _xsltStyleBasicEmptyItem xsltStyleBasicEmptyItem; +typedef xsltStyleBasicEmptyItem * xsltStyleBasicEmptyItemPtr; +typedef struct _xsltStyleBasicExpressionItem xsltStyleBasicExpressionItem; +typedef xsltStyleBasicExpressionItem * xsltStyleBasicExpressionItemPtr; +typedef struct _xsltStyleBasicItemVariable xsltStyleBasicItemVariable; +typedef xsltStyleBasicItemVariable * xsltStyleBasicItemVariablePtr; +typedef xsltStyleBasicEmptyItem xsltStyleItemApplyImports; +typedef xsltStyleItemApplyImports * xsltStyleItemApplyImportsPtr; +typedef struct _xsltStyleItemApplyTemplates xsltStyleItemApplyTemplates; typedef xsltStyleItemApplyTemplates * xsltStyleItemApplyTemplatesPtr; +typedef struct _xsltStyleItemAttribute xsltStyleItemAttribute; +typedef xsltStyleItemAttribute * xsltStyleItemAttributePtr; +typedef struct _xsltStyleItemCallTemplate xsltStyleItemCallTemplate; +typedef xsltStyleItemCallTemplate * xsltStyleItemCallTemplatePtr; +typedef xsltStyleBasicEmptyItem xsltStyleItemChoose; +typedef xsltStyleItemChoose * xsltStyleItemChoosePtr; +typedef xsltStyleBasicEmptyItem xsltStyleItemComment; +typedef xsltStyleItemComment * xsltStyleItemCommentPtr; +typedef struct _xsltStyleItemCopy xsltStyleItemCopy; +typedef xsltStyleBasicExpressionItem xsltStyleItemCopyOf; +typedef xsltStyleItemCopyOf * xsltStyleItemCopyOfPtr; +typedef xsltStyleItemCopy * xsltStyleItemCopyPtr; +typedef struct _xsltStyleItemDocument xsltStyleItemDocument; +typedef xsltStyleItemDocument * xsltStyleItemDocumentPtr; +typedef struct _xsltStyleItemElement xsltStyleItemElement; +typedef xsltStyleItemElement * xsltStyleItemElementPtr; +typedef struct _xsltStyleItemExtElement xsltStyleItemExtElement; +typedef xsltStyleItemExtElement * xsltStyleItemExtElementPtr; +typedef xsltStyleBasicEmptyItem xsltStyleItemFallback; +typedef xsltStyleItemFallback * xsltStyleItemFallbackPtr; +typedef xsltStyleBasicExpressionItem xsltStyleItemForEach; +typedef xsltStyleItemForEach * xsltStyleItemForEachPtr; +typedef struct _xsltStyleItemIf xsltStyleItemIf; +typedef xsltStyleItemIf * xsltStyleItemIfPtr; +typedef struct _xsltStyleItemInclude xsltStyleItemInclude; +typedef xsltStyleItemInclude * xsltStyleItemIncludePtr; +typedef struct _xsltStyleItemLRElementInfo xsltStyleItemLRElementInfo; +typedef xsltStyleItemLRElementInfo * xsltStyleItemLRElementInfoPtr; +typedef struct _xsltStyleItemMessage xsltStyleItemMessage; +typedef xsltStyleItemMessage * xsltStyleItemMessagePtr; +typedef struct _xsltStyleItemNumber xsltStyleItemNumber; +typedef xsltStyleItemNumber * xsltStyleItemNumberPtr; +typedef struct _xsltStyleItemOtherwise xsltStyleItemOtherwise; +typedef xsltStyleItemOtherwise * xsltStyleItemOtherwisePtr; +typedef struct _xsltStyleItemPI xsltStyleItemPI; +typedef xsltStyleItemPI * xsltStyleItemPIPtr; +typedef struct _xsltStyleItemParam xsltStyleItemParam; +typedef xsltStyleItemParam * xsltStyleItemParamPtr; +typedef struct _xsltStyleItemSort xsltStyleItemSort; +typedef xsltStyleItemSort * xsltStyleItemSortPtr; +typedef struct _xsltStyleItemText xsltStyleItemText; +typedef xsltStyleItemText * xsltStyleItemTextPtr; +typedef struct _xsltStyleItemUknown xsltStyleItemUknown; typedef xsltStyleItemUknown * xsltStyleItemUknownPtr; typedef struct _xsltStyleItemValueOf xsltStyleItemValueOf; -typedef xsltCompilerCtxt * xsltCompilerCtxtPtr; -typedef struct _xsltStyleItemAttribute xsltStyleItemAttribute; -typedef xsltStyleItemDocument * xsltStyleItemDocumentPtr; -typedef struct _xsltStyleItemCallTemplate xsltStyleItemCallTemplate; -typedef xsltStyleItemFallback * xsltStyleItemFallbackPtr; -typedef struct _xsltStyleItemNumber xsltStyleItemNumber; -typedef struct _xsltStyleItemApplyTemplates xsltStyleItemApplyTemplates; -typedef xsltStyleBasicEmptyItem xsltStyleItemChoose; +typedef xsltStyleItemValueOf * xsltStyleItemValueOfPtr; +typedef xsltStyleBasicItemVariable xsltStyleItemVariable; +typedef xsltStyleItemVariable * xsltStyleItemVariablePtr; +typedef struct _xsltStyleItemWhen xsltStyleItemWhen; +typedef xsltStyleItemWhen * xsltStyleItemWhenPtr; +typedef xsltStyleBasicItemVariable xsltStyleItemWithParam; +typedef xsltStyleItemWithParam * xsltStyleItemWithParamPtr; +typedef struct _xsltStylePreComp xsltStylePreComp; +typedef xsltStylePreComp * xsltStylePreCompPtr; typedef enum xsltStyleType; -typedef struct _xsltStyleItemPI xsltStyleItemPI; -typedef struct _xsltStyleItemInclude xsltStyleItemInclude; -typedef void xsltElemPreCompDeallocator (xsltElemPreCompPtr comp); -int xsltRegisterPersistRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); -xsltStylesheetPtr xsltParseStylesheetImportedDoc (xmlDocPtr doc,
xsltStylesheetPtr parentStyle); -void xsltFreeStackElemList (xsltStackElemPtr elem); +typedef struct _xsltStylesheet xsltStylesheet; +typedef xsltStylesheet * xsltStylesheetPtr; +typedef struct _xsltTemplate xsltTemplate; +typedef xsltTemplate * xsltTemplatePtr; +typedef struct _xsltTransformCache xsltTransformCache; +typedef xsltTransformCache * xsltTransformCachePtr; +typedef struct _xsltTransformContext xsltTransformContext; +typedef xsltTransformContext * xsltTransformContextPtr; +typedef enum xsltTransformState; +typedef struct _xsltVarInfo xsltVarInfo; +typedef xsltVarInfo * xsltVarInfoPtr; int xsltAllocateExtra (xsltStylesheetPtr style); -int xsltFlagRVTs (xsltTransformContextPtr ctxt,
xmlXPathObjectPtr obj,
void * val); -void xsltParseSequenceConstructor (xsltCompilerCtxtPtr cctxt,
xmlNodePtr cur); -int xsltRegisterTmpRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); -int xsltInitAllDocKeys (xsltTransformContextPtr ctxt); -xsltDecimalFormatPtr xsltDecimalFormatGetByName (xsltStylesheetPtr style,
xmlChar * name); -int xsltExtensionInstructionResultFinalize (xsltTransformContextPtr ctxt); -int xsltParseStylesheetUser (xsltStylesheetPtr style,
xmlDocPtr doc); -void xsltPointerListFree (xsltPointerListPtr list); -int xsltIsBlank (xmlChar * str); -xmlXPathError xsltFormatNumberConversion (xsltDecimalFormatPtr self,
xmlChar * format,
double number,
xmlChar ** result); -int xsltPointerListAddSize (xsltPointerListPtr list,
void * item,
int initialSize); -typedef void xsltSortFunc (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts); -void xsltUninit (void); -void xsltFreeStylesheet (xsltStylesheetPtr style); -xmlDocPtr xsltCreateRVT (xsltTransformContextPtr ctxt); -xsltStylesheetPtr xsltParseStylesheetFile (const xmlChar * filename); -void xsltParseStylesheetOutput (xsltStylesheetPtr style,
xmlNodePtr cur); -int xsltParseAnyXSLTElem (xsltCompilerCtxtPtr cctxt,
xmlNodePtr elem); -void xsltCompileAttr (xsltStylesheetPtr style,
xmlAttrPtr attr); -int xsltRestoreDocumentNamespaces (xsltNsMapPtr ns,
xmlDocPtr doc); -void xsltNumberFormat (xsltTransformContextPtr ctxt,
xsltNumberDataPtr data,
xmlNodePtr node); -void xsltReleaseRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); -void xsltFreeRVTs (xsltTransformContextPtr ctxt); -int xsltExtensionInstructionResultRegister (xsltTransformContextPtr ctxt,
xmlXPathObjectPtr obj); -xsltPointerListPtr xsltPointerListCreate (int initialSize); -void xsltFreeAVTList (void * avt); int xsltAllocateExtraCtxt (xsltTransformContextPtr ctxt); -void xsltParseTemplateContent (xsltStylesheetPtr style,
xmlNodePtr templ); -xsltStylesheetPtr xsltNewStylesheet (void); -xsltStylesheetPtr xsltParseStylesheetProcess (xsltStylesheetPtr ret,
xmlDocPtr doc); +void xsltCompileAttr (xsltStylesheetPtr style,
xmlAttrPtr attr); +xmlDocPtr xsltCreateRVT (xsltTransformContextPtr ctxt); +xsltDecimalFormatPtr xsltDecimalFormatGetByName (xsltStylesheetPtr style,
xmlChar * name); xsltDecimalFormatPtr xsltDecimalFormatGetByQName (xsltStylesheetPtr style,
const xmlChar * nsUri,
const xmlChar * name); -typedef void xsltTransformFunction (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); -int xsltRegisterLocalRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); -xsltStylesheetPtr xsltParseStylesheetDoc (xmlDocPtr doc); -int xsltInitCtxtKey (xsltTransformContextPtr ctxt,
xsltDocumentPtr idoc,
xsltKeyDefPtr keyDef); +typedef void xsltElemPreCompDeallocator (xsltElemPreCompPtr comp); xmlChar * xsltEvalAVT (xsltTransformContextPtr ctxt,
void * avt,
xmlNodePtr node); -void xsltPointerListClear (xsltPointerListPtr list); +int xsltExtensionInstructionResultFinalize (xsltTransformContextPtr ctxt); +int xsltExtensionInstructionResultRegister (xsltTransformContextPtr ctxt,
xmlXPathObjectPtr obj); +int xsltFlagRVTs (xsltTransformContextPtr ctxt,
xmlXPathObjectPtr obj,
int val); +xmlXPathError xsltFormatNumberConversion (xsltDecimalFormatPtr self,
xmlChar * format,
double number,
xmlChar ** result); +void xsltFreeAVTList (void * avt); +typedef void xsltFreeLocaleFunc (void * locale); +void xsltFreeRVTs (xsltTransformContextPtr ctxt); +void xsltFreeStackElemList (xsltStackElemPtr elem); +void xsltFreeStylesheet (xsltStylesheetPtr style); +typedef xmlChar * xsltGenSortKeyFunc (void * locale,
const xmlChar * lang); +int xsltInitAllDocKeys (xsltTransformContextPtr ctxt); +int xsltInitCtxtKey (xsltTransformContextPtr ctxt,
xsltDocumentPtr idoc,
xsltKeyDefPtr keyDef); +int xsltIsBlank (xmlChar * str); xsltStylesheetPtr xsltLoadStylesheetPI (xmlDocPtr doc); +typedef void * xsltNewLocaleFunc (const xmlChar * lang,
int lowerFirst); +xsltStylesheetPtr xsltNewStylesheet (void); +void xsltNumberFormat (xsltTransformContextPtr ctxt,
xsltNumberDataPtr data,
xmlNodePtr node); +int xsltParseAnyXSLTElem (xsltCompilerCtxtPtr cctxt,
xmlNodePtr elem); +void xsltParseSequenceConstructor (xsltCompilerCtxtPtr cctxt,
xmlNodePtr cur); +xsltStylesheetPtr xsltParseStylesheetDoc (xmlDocPtr doc); +xsltStylesheetPtr xsltParseStylesheetFile (const xmlChar * filename); +xsltStylesheetPtr xsltParseStylesheetImportedDoc (xmlDocPtr doc,
xsltStylesheetPtr parentStyle); +void xsltParseStylesheetOutput (xsltStylesheetPtr style,
xmlNodePtr cur); +xsltStylesheetPtr xsltParseStylesheetProcess (xsltStylesheetPtr ret,
xmlDocPtr doc); +int xsltParseStylesheetUser (xsltStylesheetPtr style,
xmlDocPtr doc); +void xsltParseTemplateContent (xsltStylesheetPtr style,
xmlNodePtr templ); +int xsltPointerListAddSize (xsltPointerListPtr list,
void * item,
int initialSize); +void xsltPointerListClear (xsltPointerListPtr list); +xsltPointerListPtr xsltPointerListCreate (int initialSize); +void xsltPointerListFree (xsltPointerListPtr list); +int xsltRegisterLocalRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); +int xsltRegisterPersistRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); +int xsltRegisterTmpRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); +void xsltReleaseRVT (xsltTransformContextPtr ctxt,
xmlDocPtr RVT); +int xsltRestoreDocumentNamespaces (xsltNsMapPtr ns,
xmlDocPtr doc); +typedef void xsltSortFunc (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts); +typedef void xsltTransformFunction (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp); +void xsltUninit (void);@@ -644,7 +647,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemApplyImports
xsltStyleBasicEmptyItem xsltStyleItemApplyImports; -+<!-- Category: instruction --> <xsl:apply-imports />
Typedef xsltStyleItemApplyImportsPtr
xsltStyleItemApplyImports * xsltStyleItemApplyImportsPtr; @@ -693,7 +696,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemChoose
xsltStyleBasicEmptyItem xsltStyleItemChoose; -+<!-- Category: instruction --> <xsl:choose> <!-- Content: (xsl:when+, xsl:otherwise?) --> </xsl:choose>
Typedef xsltStyleItemChoosePtr
xsltStyleItemChoose * xsltStyleItemChoosePtr; @@ -701,7 +704,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemComment
xsltStyleBasicEmptyItem xsltStyleItemComment; -+<!-- Category: instruction --> <xsl:comment> <!-- Content: template --> </xsl:comment>
Typedef xsltStyleItemCommentPtr
xsltStyleItemComment * xsltStyleItemCommentPtr; @@ -716,7 +719,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemCopyOf
xsltStyleBasicExpressionItem xsltStyleItemCopyOf; -+<!-- Category: instruction --> <xsl:copy-of select = expression />
Typedef xsltStyleItemCopyOfPtr
xsltStyleItemCopyOf * xsltStyleItemCopyOfPtr; @@ -766,7 +769,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemFallback
xsltStyleBasicEmptyItem xsltStyleItemFallback; -+<!-- Category: instruction --> <xsl:fallback> <!-- Content: template --> </xsl:fallback>
Typedef xsltStyleItemFallbackPtr
xsltStyleItemFallback * xsltStyleItemFallbackPtr; @@ -774,7 +777,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemForEach
xsltStyleBasicExpressionItem xsltStyleItemForEach; -+<!-- Category: instruction --> <xsl:for-each select = node-set-expression> <!-- Content: (xsl:sort*, template) --> </xsl:for-each>
Typedef xsltStyleItemForEachPtr
xsltStyleItemForEach * xsltStyleItemForEachPtr; @@ -877,7 +880,6 @@ The content of this structure is not made public by the API. int descending : sort const xmlChar * lang : sort int has_lang : sort - xsltLocale locale : sort const xmlChar * case_order : sort int lower_first : sort const xmlChar * use @@ -925,7 +927,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemVariable
xsltStyleBasicItemVariable xsltStyleItemVariable; -+<!-- Category: top-level-element --> <xsl:param name = qname select = expression> <!-- Content: template --> </xsl:param>
Typedef xsltStyleItemVariablePtr
xsltStyleItemVariable * xsltStyleItemVariablePtr; @@ -944,7 +946,7 @@ The content of this structure is not made public by the API.
Typedef xsltStyleItemWithParam
xsltStyleBasicItemVariable xsltStyleItemWithParam; -+<xsl:with-param name = qname select = expression> <!-- Content: template --> </xsl:with-param>
@@ -1244,6 +1250,18 @@ The content of this structure is not made public by the API.Typedef xsltStyleItemWithParamPtr
xsltStyleItemWithParam * xsltStyleItemWithParamPtr; @@ -964,7 +966,6 @@ The content of this structure is not made public by the API. int descending : sort const xmlChar * lang : sort int has_lang : sort - xsltLocale locale : sort const xmlChar * case_order : sort int lower_first : sort const xmlChar * use : copy, element @@ -1211,6 +1212,11 @@ The content of this structure is not made public by the API. int maxTemplateVars unsigned long opLimit unsigned long opCount + int sourceDocDirty + unsigned long currentId : For generate-id() + xsltNewLocaleFunc newLocale + xsltFreeLocaleFunc freeLocale + xsltGenSortKeyFunc genSortKey } xsltTransformContext;+Function type xsltElemPreCompDeallocator
void xsltElemPreCompDeallocator (xsltElemPreCompPtr comp)
Deallocates an #xsltElemPreComp structure.
comp: the #xsltElemPreComp to free up
+ +
++Function type xsltGenSortKeyFunc
xmlChar * xsltGenSortKeyFunc (void * locale,+
const xmlChar * lang)
+
locale: lang: Returns:
+Function type xsltNewLocaleFunc
void * xsltNewLocaleFunc (const xmlChar * lang,+
int lowerFirst)
+
lang: lowerFirst: Returns:
Function type xsltSortFunc
void xsltSortFunc (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts)
Signature of the function to use during sorting
@@ -1258,7 +1276,7 @@ The content of this structure is not made public by the API.
Variable xsltXSLTAttrMarker
const xmlChar * xsltXSLTAttrMarker; -+Marker for XSLT attribute on Literal Result Elements.
xsltAllocateExtra ()
int xsltAllocateExtra (xsltStylesheetPtr style)
@@ -1297,7 +1315,7 @@ The content of this structure is not made public by the API.Marks the result of a value-returning extension instruction in order to avoid it being garbage collected before the extension instruction exits. Note that one still has to additionally register any newly created tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT().
ctxt: an XSLT transformation context obj: an XPath object to be inspected for result tree fragments Returns: 0 in case of success and -1 in case of error. It isn't necessary to call this function in newer releases of libxslt.
-xsltFlagRVTs ()
int xsltFlagRVTs (xsltTransformContextPtr ctxt,
xmlXPathObjectPtr obj,
void * val)
+xsltFlagRVTs ()
int xsltFlagRVTs (xsltTransformContextPtr ctxt,
xmlXPathObjectPtr obj,
int val)
Updates ownership information of RVTs in @obj according to @val. @val = XSLT_RVT_FUNC_RESULT for the result of an extension function, so its RVTs won't be destroyed after leaving the returning scope. @val = XSLT_RVT_LOCAL for the result of an extension function to reset the state of its RVTs after it was returned to a new scope. @val = XSLT_RVT_GLOBAL for parts of global variables.
ctxt: an XSLT transformation context obj: an XPath object to be inspected for result tree fragments val: the flag value Returns: 0 in case of success and -1 in case of error.
@@ -1355,7 +1373,7 @@ The content of this structure is not made public by the API.
+xsltParseStylesheetDoc ()
xsltStylesheetPtr xsltParseStylesheetDoc (xmlDocPtr doc)
parse an XSLT stylesheet, building the associated structures. doc is kept as a reference within the returned stylesheet, so changes to doc after the parsing will be reflected when the stylesheet is applied, and the doc is automatically freed when the stylesheet is closed.
-
doc: and xmlDoc parsed XML Returns: a new XSLT stylesheet structure.
doc: an xmlDoc parsed XML Returns: a new XSLT stylesheet structure.
xsltParseStylesheetFile ()
xsltStylesheetPtr xsltParseStylesheetFile (const xmlChar * filename)
Load and parse an XSLT stylesheet
diff --git a/doc/devhelp/libxslt-xsltexports.html b/doc/devhelp/libxslt-xsltexports.html index dc9413df..07421495 100644 --- a/doc/devhelp/libxslt-xsltexports.html +++ b/doc/devhelp/libxslt-xsltexports.html @@ -44,10 +44,10 @@Synopsis
#define LIBXSLT_PUBLIC; -#define XSLTPUBFUN; -#define XSLTPUBVAR; -#define XSLTPUBLIC; #define XSLTCALL; +#define XSLTPUBFUN; +#define XSLTPUBLIC; +#define XSLTPUBVAR;diff --git a/doc/devhelp/libxslt-xsltlocale.html b/doc/devhelp/libxslt-xsltlocale.html index 9861b8c0..64ce6770 100644 --- a/doc/devhelp/libxslt-xsltlocale.html +++ b/doc/devhelp/libxslt-xsltlocale.html @@ -43,16 +43,13 @@Author(s): Nick Wellnhofer
Synopsis
-#define XSLT_LOCALE_WINAPI; -#define XSLT_LOCALE_NONE; -#define XSLT_LOCALE_POSIX; -typedef void * xsltLocale; +typedef void * xsltLocale; typedef xmlChar xsltLocaleChar; -xsltLocale xsltNewLocale (const xmlChar * languageTag); -int xsltLocaleStrcmp (xsltLocale locale,
const xsltLocaleChar * str1,
const xsltLocaleChar * str2); -void xsltFreeLocale (xsltLocale locale); -xsltLocaleChar * xsltStrxfrm (xsltLocale locale,
const xmlChar * string); +void xsltFreeLocale (void * locale); void xsltFreeLocales (void); +int xsltLocaleStrcmp (void * locale,
const xmlChar * str1,
const xmlChar * str2); +void * xsltNewLocale (const xmlChar * languageTag,
int lowerFirst); +xmlChar * xsltStrxfrm (void * vlocale,
const xmlChar * string);@@ -61,18 +58,6 @@ void xsltFreeLocales (void);diff --git a/doc/devhelp/libxslt-xsltutils.html b/doc/devhelp/libxslt-xsltutils.html index 9611b946..59540fe6 100644 --- a/doc/devhelp/libxslt-xsltutils.html +++ b/doc/devhelp/libxslt-xsltutils.html @@ -38,55 +38,56 @@Details
--Macro XSLT_LOCALE_NONE
#define XSLT_LOCALE_NONE; -Macro indicating that there's no extended locale support
-
--Macro XSLT_LOCALE_POSIX
#define XSLT_LOCALE_POSIX; -Macro indicating to use POSIX locale extensions
-
--Macro XSLT_LOCALE_WINAPI
#define XSLT_LOCALE_WINAPI; -Macro indicating to use WinAPI for extended locale support
-
@@ -81,7 +66,7 @@ void xsltFreeLocales (void);Typedef xsltLocale
void * xsltLocale;
-xsltFreeLocale ()
void xsltFreeLocale (xsltLocale locale)
+xsltFreeLocale ()
void xsltFreeLocale (void * locale)
Frees a locale created with xsltNewLocale
locale: the locale to free
@@ -89,17 +74,17 @@ void xsltFreeLocales (void);Cleanup function for the locale support on shutdown
-+xsltLocaleStrcmp ()
int xsltLocaleStrcmp (xsltLocale locale,
const xsltLocaleChar * str1,
const xsltLocaleChar * str2)
-Compares two strings transformed with xsltStrxfrm
-
locale: a locale identifier str1: a string transformed with xsltStrxfrm str2: a string transformed with xsltStrxfrm Returns: a value < 0 if str1 sorts before str2, a value > 0 if str1 sorts after str2, 0 if str1 and str2 are equal wrt sorting xsltLocaleStrcmp ()
int xsltLocaleStrcmp (void * locale,
const xmlChar * str1,
const xmlChar * str2)
+DEPRECATED: Same as xmlStrcmp. Compares two strings transformed with xsltStrxfrm.
+
locale: unused str1: a string transformed with xsltStrxfrm str2: a string transformed with xsltStrxfrm Returns: a value < 0 if str1 sorts before str2, a value > 0 if str1 sorts after str2, 0 if str1 and str2 are equal wrt sorting
-xsltNewLocale ()
xsltLocale xsltNewLocale (const xmlChar * languageTag)
++xsltNewLocale ()
void * xsltNewLocale (const xmlChar * languageTag,
int lowerFirst)
Creates a new locale of an opaque system dependent type based on the language tag.
-
languageTag: RFC 3066 language tag Returns: the locale or NULL on error or if no matching locale was found
languageTag: RFC 3066 language tag lowerFirst: Returns: the locale or NULL on error or if no matching locale was found
-+xsltStrxfrm ()
xsltLocaleChar * xsltStrxfrm (xsltLocale locale,
const xmlChar * string)
-Transforms a string according to locale. The transformed string must then be compared with xsltLocaleStrcmp and freed with xmlFree.
-
locale: locale created with xsltNewLocale string: UTF-8 string to transform Returns: the transformed string or NULL on error xsltStrxfrm ()
xmlChar * xsltStrxfrm (void * vlocale,
const xmlChar * string)
+Transforms a string according to locale. The transformed string must be freed with xmlFree.
+
vlocale: string: UTF-8 string to transform Returns: the transformed string or NULL on error
Author(s): Daniel Veillard
Synopsis
-#define IS_XSLT_REAL_NODE; -#define IS_XSLT_ELEM; +#define IS_XSLT_ELEM; #define IS_XSLT_NAME; -#define XSLT_TODO; +#define IS_XSLT_REAL_NODE; #define XSLT_STRANGE; #define XSLT_TIMESTAMP_TICS_PER_SEC; +#define XSLT_TODO; #define XSLT_TRACE; -typedef enum xsltDebugTraceCodes; typedef enum xsltDebugStatusCodes; -int xsltSaveResultToFile (FILE * file,
xmlDocPtr result,
xsltStylesheetPtr style); -void xsltSetGenericErrorFunc (void * ctx,
xmlGenericErrorFunc handler); -int xsltSetDebuggerCallbacks (int no,
void * block); -int xsltSaveResultTo (xmlOutputBufferPtr buf,
xmlDocPtr result,
xsltStylesheetPtr style); -void xsltTransformError (xsltTransformContextPtr ctxt,
xsltStylesheetPtr style,
xmlNodePtr node,
const char * msg,
... ...); +typedef enum xsltDebugTraceCodes; int xslAddCall (xsltTemplatePtr templ,
xmlNodePtr source); -void xsltDocumentSortFunction (xmlNodeSetPtr list); -const xmlChar * xsltGetQNameURI2 (xsltStylesheetPtr style,
xmlNodePtr node,
const xmlChar ** name); -xmlXPathObjectPtr * xsltComputeSortResult (xsltTransformContextPtr ctxt,
xmlNodePtr sort); -void xsltPrintErrorContext (xsltTransformContextPtr ctxt,
xsltStylesheetPtr style,
xmlNodePtr node); -int xsltGetUTF8Char (const unsigned char * utf,
int * len); -void xsltDefaultSortFunction (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts); -int xsltSaveResultToFd (int fd,
xmlDocPtr result,
xsltStylesheetPtr style); -void xsltSetCtxtSortFunc (xsltTransformContextPtr ctxt,
xsltSortFunc handler); -xmlChar * xsltGetNsProp (xmlNodePtr node,
const xmlChar * name,
const xmlChar * nameSpace); -const xmlChar * xsltGetCNsProp (xsltStylesheetPtr style,
xmlNodePtr node,
const xmlChar * name,
const xmlChar * nameSpace); -const xmlChar * xsltGetQNameURI (xmlNodePtr node,
xmlChar ** name); +void xslDropCall (void); typedef int xsltAddCallCallback (xsltTemplatePtr templ,
xmlNodePtr source); void xsltCalibrateAdjust (long delta); -void xsltSaveProfiling (xsltTransformContextPtr ctxt,
FILE * output); -int xsltSaveResultToString (xmlChar ** doc_txt_ptr,
int * doc_txt_len,
xmlDocPtr result,
xsltStylesheetPtr style); -const xmlChar * xsltSplitQName (xmlDictPtr dict,
const xmlChar * name,
const xmlChar ** prefix); -void xsltDoSortFunction (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts); +xmlXPathObjectPtr * xsltComputeSortResult (xsltTransformContextPtr ctxt,
xmlNodePtr sort); xsltDebugTraceCodes xsltDebugGetDefaultTrace (void); -void xsltMessage (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst); -int xsltGetDebuggerStatus (void); -long xsltTimestamp (void); -void xsltSetTransformErrorFunc (xsltTransformContextPtr ctxt,
void * ctx,
xmlGenericErrorFunc handler); -xmlXPathCompExprPtr xsltXPathCompile (xsltStylesheetPtr style,
const xmlChar * str); void xsltDebugSetDefaultTrace (xsltDebugTraceCodes val); -void xsltSetGenericDebugFunc (void * ctx,
xmlGenericErrorFunc handler); -xmlXPathCompExprPtr xsltXPathCompileFlags (xsltStylesheetPtr style,
const xmlChar * str,
int flags); -int xsltSetCtxtParseOptions (xsltTransformContextPtr ctxt,
int options); -void xsltSetDebuggerStatus (int value); -void xslDropCall (void); -void xsltSetSortFunc (xsltSortFunc handler); -typedef void xsltHandleDebuggerCallback (xmlNodePtr cur,
xmlNodePtr node,
xsltTemplatePtr templ,
xsltTransformContextPtr ctxt); -int xsltSaveResultToFilename (const char * URL,
xmlDocPtr result,
xsltStylesheetPtr style,
int compression); +void xsltDefaultSortFunction (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts); +void xsltDoSortFunction (xsltTransformContextPtr ctxt,
xmlNodePtr * sorts,
int nbsorts); +void xsltDocumentSortFunction (xmlNodeSetPtr list); typedef void xsltDropCallCallback (void); +const xmlChar * xsltGetCNsProp (xsltStylesheetPtr style,
xmlNodePtr node,
const xmlChar * name,
const xmlChar * nameSpace); +int xsltGetDebuggerStatus (void); +xmlChar * xsltGetNsProp (xmlNodePtr node,
const xmlChar * name,
const xmlChar * nameSpace); xmlDocPtr xsltGetProfileInformation (xsltTransformContextPtr ctxt); +const xmlChar * xsltGetQNameURI (xmlNodePtr node,
xmlChar ** name); +const xmlChar * xsltGetQNameURI2 (xsltStylesheetPtr style,
xmlNodePtr node,
const xmlChar ** name); +int xsltGetUTF8Char (const unsigned char * utf,
int * len); +typedef void xsltHandleDebuggerCallback (xmlNodePtr cur,
xmlNodePtr node,
xsltTemplatePtr templ,
xsltTransformContextPtr ctxt); +void xsltMessage (xsltTransformContextPtr ctxt,
xmlNodePtr node,
xmlNodePtr inst); +void xsltPrintErrorContext (xsltTransformContextPtr ctxt,
xsltStylesheetPtr style,
xmlNodePtr node); +void xsltSaveProfiling (xsltTransformContextPtr ctxt,
FILE * output); +int xsltSaveResultTo (xmlOutputBufferPtr buf,
xmlDocPtr result,
xsltStylesheetPtr style); +int xsltSaveResultToFd (int fd,
xmlDocPtr result,
xsltStylesheetPtr style); +int xsltSaveResultToFile (FILE * file,
xmlDocPtr result,
xsltStylesheetPtr style); +int xsltSaveResultToFilename (const char * URL,
xmlDocPtr result,
xsltStylesheetPtr style,
int compression); +int xsltSaveResultToString (xmlChar ** doc_txt_ptr,
int * doc_txt_len,
xmlDocPtr result,
xsltStylesheetPtr style); +void xsltSetCtxtLocaleHandlers (xsltTransformContextPtr ctxt,
xsltNewLocaleFunc newLocale,
xsltFreeLocaleFunc freeLocale,
xsltGenSortKeyFunc genSortKey); +int xsltSetCtxtParseOptions (xsltTransformContextPtr ctxt,
int options); +void xsltSetCtxtSortFunc (xsltTransformContextPtr ctxt,
xsltSortFunc handler); +int xsltSetDebuggerCallbacks (int no,
void * block); +void xsltSetDebuggerStatus (int value); +void xsltSetGenericDebugFunc (void * ctx,
xmlGenericErrorFunc handler); +void xsltSetGenericErrorFunc (void * ctx,
xmlGenericErrorFunc handler); +void xsltSetSortFunc (xsltSortFunc handler); +void xsltSetTransformErrorFunc (xsltTransformContextPtr ctxt,
void * ctx,
xmlGenericErrorFunc handler); +const xmlChar * xsltSplitQName (xmlDictPtr dict,
const xmlChar * name,
const xmlChar ** prefix); +long xsltTimestamp (void); +void xsltTransformError (xsltTransformContextPtr ctxt,
xsltStylesheetPtr style,
xmlNodePtr node,
const char * msg,
... ...); +xmlXPathCompExprPtr xsltXPathCompile (xsltStylesheetPtr style,
const xmlChar * str); +xmlXPathCompExprPtr xsltXPathCompileFlags (xsltStylesheetPtr style,
const xmlChar * str,
int flags);@@ -289,13 +290,17 @@ xmlDocPtr xsltGetProfileInformation (+xsltSaveResultToString ()
int xsltSaveResultToString (xmlChar ** doc_txt_ptr,
int * doc_txt_len,
xmlDocPtr result,
xsltStylesheetPtr style)
Save the result @result obtained by applying the @style stylesheet to a new allocated string.
doc_txt_ptr: Memory pointer for allocated XML text doc_txt_len: Length of the generated XML text result: the result xmlDocPtr style: the stylesheet Returns: 0 in case of success and -1 in case of error
+xsltSetCtxtLocaleHandlers ()
void xsltSetCtxtLocaleHandlers (xsltTransformContextPtr ctxt,
xsltNewLocaleFunc newLocale,
xsltFreeLocaleFunc freeLocale,
xsltGenSortKeyFunc genSortKey)
+Set the locale handlers.
+
ctxt: an XSLT transform context newLocale: locale constructor freeLocale: locale destructor genSortKey: sort key generator
xsltSetCtxtParseOptions ()
int xsltSetCtxtParseOptions (xsltTransformContextPtr ctxt,
int options)
Change the default parser option passed by the XSLT engine to the parser when using document() loading.
ctxt: a XSLT process context options: a combination of libxml2 xmlParserOption Returns: the previous options or -1 in case of error
xsltSetCtxtSortFunc ()
void xsltSetCtxtSortFunc (xsltTransformContextPtr ctxt,
xsltSortFunc handler)
-Function to set the handler for XSLT sorting for the specified context. If the handler is NULL, then the global sort function will be called
+DEPRECATED: Use xsltSetCtxtLocaleHandlers. Function to set the handler for XSLT sorting for the specified context. If the handler is NULL, then the global sort function will be called
ctxt: a XSLT process context handler: the new handler function
xsltSetDebuggerCallbacks ()
int xsltSetDebuggerCallbacks (int no,
void * block)
@@ -315,7 +320,7 @@ xmlDocPtr xsltGetProfileInformation (
ctx: the new error handling context handler: the new handler function
xsltSetSortFunc ()
void xsltSetSortFunc (xsltSortFunc handler)
-Function to reset the global handler for XSLT sorting. If the handler is NULL, the default sort function will be used.
+DEPRECATED: Use xsltSetCtxtLocaleHandlers. Function to reset the global handler for XSLT sorting. If the handler is NULL, the default sort function will be used.
handler: the new handler function
xsltSetTransformErrorFunc ()
void xsltSetTransformErrorFunc (xsltTransformContextPtr ctxt,
void * ctx,
xmlGenericErrorFunc handler)
diff --git a/doc/devhelp/libxslt.devhelp2 b/doc/devhelp/libxslt.devhelp2 index 40295fab..230c772d 100644 --- a/doc/devhelp/libxslt.devhelp2 +++ b/doc/devhelp/libxslt.devhelp2 @@ -57,9 +57,6 @@- - - @@ -286,7 +283,10 @@ + + + @@ -514,6 +514,7 @@ + diff --git a/doc/libxslt-api.xml b/doc/libxslt-api.xml index 785eeafc..70deb993 100644 --- a/doc/libxslt-api.xml +++ b/doc/libxslt-api.xml @@ -5,137 +5,137 @@ interface for the XSLT attribute handling this module handles the specificities of attribute and attribute groups processing. Daniel Veillard -- + + interface for the document handling implements document loading and cache (multiple document() reference for the same resources must be equal. Daniel Veillard -+ - + + + + + - - - - interface for the extension support This provide the API needed for simple and module extension support. Daniel Veillard -- - - - - - - - - - - - - - - - - + - - - - - - - - + + + + + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + interface for the non-standard features implement some extension outside the XSLT namespace but not EXSLT with is in a different library. Daniel Veillard -- - - - + + + + + interface for the XSLT functions not from XPath a set of extra functions coming from XSLT but not in XPath Daniel Veillard and Bjorn Reese <breese@users.sourceforge.net> - - - - - - - + + + + + + + interface for the XSLT import support macros and fuctions needed to implement and access the import tree Daniel Veillard -- - - - + + + + + interface for the key matching used in key() and template matches. implementation of the key mechanims. Daniel Veillard - + + - - + interface for the XSLT namespace handling set of function easing the processing and generation of namespace nodes in XSLT. Daniel Veillard - + @@ -146,12 +146,12 @@ Implementation of the XSLT number functions Bjorn Reese <breese@users.sourceforge.net> and Daniel Veillard + - - + interface for the pattern matching used in template matches. @@ -159,24 +159,24 @@Daniel Veillard - - - - + - + - + + + + precomputing stylesheets this is the compilation phase, where most of the stylesheet is "compiled" into faster to use data. Daniel Veillard - + @@ -184,80 +184,80 @@ the libxslt security framework allow to restrict the access to new resources (file or URL) from the stylesheet at runtime. Daniel Veillard - - + + + - - - - - - - - - - - + + + + + + + + + + interface for the template processing This set of routine encapsulates XPath calls and Attribute Value Templates evaluation. Daniel Veillard -- - - - + - - + + + + + + the XSLT engine transformation part. This module implements the bulk of the actual Daniel Veillard -- - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + interface for the variable matching and lookup. @@ -267,32 +267,32 @@- - - - - - - - - + + + + + + + + + Interfaces, constants and types related to the XSLT engine Interfaces, constants and types related to the XSLT engine Daniel Veillard -- - + + - + + @@ -303,379 +303,380 @@ internal data structures, constants and functions Internal data structures, constants and functions used by the XSLT engine. They are not part of the API or ABI, i.e. they can change without prior notice, use carefully. Daniel Veillard -- - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - - - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + macros for marking symbols as exportable/importable. macros for marking symbols as exportable/importable. - - - + + + Locale handling Interfaces for locale handling. Needed for language dependent sorting. Nick Wellnhofer -- - - - - + + + set of utilities for the XSLT engine interfaces for the utilities module of the XSLT engine. things like message handling, profiling, and other generally useful routines. Daniel Veillard -- + + - - - - - - - - - - - - - - - - - - - - - - + + - - - + + + + + + + + + + + + + + + + + + + + + - + + - - - + + - - - - - + + - - - - - - - - - - - + - - - - + - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -775,15 +776,6 @@ - This is the libxslt namespace for specific extensions. - -Macro indicating that there's no extended locale support -- -Macro indicating to use POSIX locale extensions -- Macro indicating to use WinAPI for extended locale support -@@ -1186,7 +1178,9 @@ the variables'/> internal macro to set up tree fragments - + + <!-- Category: instruction --> <xsl:apply-imports /> +@@ -1211,15 +1205,21 @@ the variables'/> - + + <!-- Category: instruction --> <xsl:choose> <!-- Content: (xsl:when+, xsl:otherwise?) --> </xsl:choose> +- + + <!-- Category: instruction --> <xsl:comment> <!-- Content: template --> </xsl:comment> +- + + <!-- Category: instruction --> <xsl:copy-of select = expression /> +@@ -1244,9 +1244,13 @@ TODO: Check if we need.'/> - + + <!-- Category: instruction --> <xsl:fallback> <!-- Content: template --> </xsl:fallback> +- + + <!-- Category: instruction --> <xsl:for-each select = node-set-expression> <!-- Content: (xsl:sort*, template) --> </xsl:for-each> +@@ -1295,7 +1299,6 @@ TODO: Check if we need.'/> - @@ -1317,14 +1320,18 @@ TODO: Check if we need.'/> - + + <!-- Category: top-level-element --> <xsl:param name = qname select = expression> <!-- Content: template --> </xsl:param> +- + + <xsl:with-param name = qname select = expression> <!-- Content: template --> </xsl:with-param> +@@ -1340,7 +1347,6 @@ TODO: Check if we need.'/> - @@ -1575,6 +1581,11 @@ exits'/> + + + + + @@ -1589,28 +1600,38 @@ exits'/> - + + The version string for libxslt. +- - - + + +The version of libxml libxslt was compiled against. ++ +The version of libxslt compiled. ++ This value is used to detect templates loops. +- - + + +Marker for XSLT attribute on Literal Result Elements. +- Add template "call" to call stack + - Drop the topmost item off the call stack + - If either cur or node are a breakpoint, or xslDebugStatus in state where debugging must occcur at this time then transfer control to the xslDebugBreak function @@ -1618,13 +1639,13 @@ exits'/> + - + - add a key definition to a stylesheet @@ -1634,13 +1655,13 @@ exits'/> + - Push an element list onto the stack. + - Register the XSLT pattern associated to @cur @@ -1648,17 +1669,17 @@ exits'/> + - Allocate an extra runtime information slot statically while compiling the stylesheet and return its number + - Allocate an extra runtime information slot at run-time and return its number This make sure there is a slot ready in the transformation context + - Apply the xsl:use-attribute-sets. If @attrSets is NULL, then @inst will be used to exctract this value. If both, @attrSets and @inst, are NULL, then this will do nothing. @@ -1666,7 +1687,7 @@ exits'/> + - Process the XSLT apply-imports element. @@ -1674,7 +1695,7 @@ exits'/> + - Processes a sequence constructor on the current node in the source tree. @params are the already computed variable stack items; this function pushes them on the variable stack, and pops them before exiting; it's left to the caller to free or reuse @params afterwards. The initial states of the variable stack will always be restored before this function exits. NOTE that this does *not* initiate a new distinct variable scope; i.e. variables already on the stack are visible to the process. The caller's side needs to start a new variable scope if needed (e.g. in exsl:function). @templ is obsolete and not used anymore (e.g. <exslt:function> does not provide a @templ); a non-NULL @templ might raise an error in the future. BIG NOTE: This function is not intended to process the content of an xsl:template; it does not expect xsl:param instructions in @list and will report errors if found. Called by: - xsltEvalVariable() (variables.c) - exsltFuncFunctionFunction() (libexsl/functions.c) @@ -1683,20 +1704,20 @@ exits'/> + - Strip the unwanted ignorable spaces from the input tree + - Apply the stylesheet to the document NOTE: This may lead to a non-wellformed output XML wise ! + - Apply the stylesheet to the document and allow the user to provide its own transformation context. @@ -1706,7 +1727,7 @@ exits'/> + - Processes the XSLT 'apply-templates' instruction on the current node. @@ -1714,34 +1735,34 @@ exits'/> + - Processes all attributes of a Literal Result Element. Attribute references are applied via xsl:use-attribute-set attributes. Copies all non XSLT-attributes over to the @target element and evaluates Attribute Value Templates. Called by xsltApplySequenceConstructor() (transform.c). + - Process one attribute of a Literal Result Element (in the stylesheet). Evaluates Attribute Value Templates and copies the attribute over to the result element. This does *not* process attribute sets (xsl:use-attribute-set). + - Process the given node and return the new string value. + - Process the given string, allowing to pass a namespace mapping context and return the new string value. Called by: - xsltAttrTemplateValueProcess() (templates.c) - xsltEvalAttrValueTemplate() (templates.c) QUESTION: Why is this function public? It is not used outside of templates.c. + - Process the xslt attribute node on the source node @@ -1749,12 +1770,12 @@ exits'/> + - Used for to correct the calibration for xsltTimestamp() + - Processes the XSLT call-template instruction on the source node. @@ -1762,33 +1783,33 @@ exits'/> + - Check if the given prefix is one of the declared extensions. This is intended to be called only at compile-time. Called by: xsltGetInheritedNsList() (xslt.c) xsltParseTemplateContent (xslt.c) + - Check if the given prefix is one of the declared extensions. This is intended to be called only at compile-time. Called by: xsltPrecomputeStylesheet() (xslt.c) xsltParseTemplateContent (xslt.c) + - Check if the resource is allowed to be read + - Check if the resource is allowed to be written, if necessary makes some preliminary work like creating directories + - Processes the xsl:choose instruction on the source node. @@ -1796,16 +1817,16 @@ exits'/> + - Unregister all global variables set up by the XSLT library + - Cleanup the state of the templates used by the stylesheet and the ones it imports. + - Process the xslt comment node on the source node @@ -1813,19 +1834,19 @@ exits'/> + - Clear pattern match cache. + - Precompile an attribute in a stylesheet, basically it checks if it is an attribute value template, and if yes, establish some structures needed to process it at transformation time. + - Compile the XSLT pattern and generates a list of precompiled form suitable for fast matching. [1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern @@ -1834,13 +1855,13 @@ exits'/> + - reorder the current node list accordingly to the set of sorting requirement provided by the array of nodes. + - Execute the XSLT-copy instruction on the source node. @@ -1848,21 +1869,21 @@ exits'/> + - Copies a namespace node (declaration). If @elem is not NULL, then the new namespace will be declared on @elem. + - Do a copy of an namespace list. If @node is non-NULL the new namespaces are added automatically. This handles namespaces aliases. This function is intended only for *internal* use at transformation-time for copying ns-declarations of Literal Result Elements. Called by: xsltCopyTreeInternal() (transform.c) xsltShallowCopyElem() (transform.c) REVISIT: This function won't be used in the refactored code. + - Process the XSLT copy-of instruction. @@ -1870,7 +1891,7 @@ exits'/> + - Adds @string to a newly created or an existent text node child of @target. @@ -1878,12 +1899,12 @@ exits'/> + - Creates a Result Value Tree (the XSLT 1.0 term for this is "Result Tree Fragment") + - Process an debug node @@ -1891,48 +1912,48 @@ exits'/> + - Dumps a list of the registered XSLT extension functions and elements + - Get the current default debug tracing level mask + - Set the default debug tracing level mask + - Find decimal-format by name + - Find decimal-format by QName + - reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. + - reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. This is a wrapper function, the actual function used is specified using xsltSetCtxtSortFunc() to set the context specific sort function, or xsltSetSortFunc() to set the global sort function. If a sort function is set on the context, this will get called. Otherwise the global sort function is called. + - An xsltDocLoaderFunc is a signature for a function which can be registered to load document not provided by the compilation or transformation API themselve, for example when an xsl:import, xsl:include is found at compilation time or when a document() call is made at runtime. @@ -1941,14 +1962,14 @@ exits'/> + - Pre process an XSLT-1.1 document element + - Process an EXSLT/XSLT-1.1 document element @@ -1956,27 +1977,27 @@ exits'/> + - Implement the document() XSLT function node-set document(object, node-set?) + - reorder the current node list @list accordingly to the document order This function is slow, obsolete and should not be used anymore. + - + - Deallocates an #xsltElemPreComp structure. + - Process the xslt element node on the source node @@ -1984,20 +2005,20 @@ exits'/> + - Implement the element-available() XSLT function boolean element-available(string) + - Process the given AVT, and return the new string value. + - Evaluate a attribute value template, i.e. the attribute value can contain expressions contained in curly braces ({}) and those are substituted by they computed value. @@ -2005,19 +2026,19 @@ exits'/> + - Evaluates all global variables and parameters of a stylesheet. For internal use only. This is called at start of a transformation. + - This is normally called from xsltEvalUserParams to process a single parameter from a list of parameters. The @value is evaluated as an XPath expression and the result is stored in the context's global variable/parameter hash table. To have a parameter treated literally (not as an XPath expression) use xsltQuoteUserParams (or xsltQuoteOneUserParam). For more details see description of xsltProcessOneUserParamInternal. + - Check if an attribute value template has a static value, i.e. the attribute value does not contain expressions contained in curly braces ({}) @@ -2026,20 +2047,20 @@ exits'/> + - Processes the sequence constructor of the given instruction on @contextNode and converts the resulting tree to a string. This is needed by e.g. xsl:comment and xsl:processing-instruction. + - Evaluate the global variables of a stylesheet. This needs to be done on parsed stylesheets before starting to apply transformations. Each of the parameters is evaluated as an XPath expression and stored in the global variables/parameter hash table. If you want your parameter used literally, use xsltQuoteUserParams. + - Process the expression using XPath and evaluate the result as an XPath predicate @@ -2047,13 +2068,13 @@ exits'/> + - Process the expression using XPath and get a string + - Process the expression using XPath, allowing to pass a namespace mapping context and get a string @@ -2061,88 +2082,88 @@ exits'/> + - Looks up an extension element. @ctxt can be NULL to search only in module elements. + - A function called at initialization time of an XSLT extension module. + - Looks up an extension module element + - Looks up an extension module element pre-computation function + - Looks up an extension module function + - Looks up an extension module top-level element + - A function called at shutdown time of an XSLT extension module. + - Finalizes the data (e.g. result tree fragments) created within a value-returning process (e.g. EXSLT's function). Tree fragments marked as being returned by a function are set to normal state, which means that the fragment garbage collector will free them after the function-calling process exits. + - Marks the result of a value-returning extension instruction in order to avoid it being garbage collected before the extension instruction exits. Note that one still has to additionally register any newly created tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT(). + - Try to find a document within the XSLT transformation context. This will not find document infos for temporary Result Tree Fragments. + - Find strip-space or preserve-space information for an element respect the import precedence or the wildcards + - Finds the named template, apply import precedence rule. REVISIT TODO: We'll change the nameURI fields of templates to be in the string dict, so if the specified @nameURI is in the same dict, then use pointer comparison. Check if this can be done in a sane way. Maybe this function is not needed internally at transformation-time if we hard-wire the called templates to the caller. + - Updates ownership information of RVTs in @obj according to @val. @val = XSLT_RVT_FUNC_RESULT for the result of an extension function, so its RVTs won't be destroyed after leaving the returning scope. @val = XSLT_RVT_LOCAL for the result of an extension function to reset the state of its RVTs after it was returned to a new scope. @val = XSLT_RVT_GLOBAL for parts of global variables. - + + - Process the xslt for-each node on the source node @@ -2150,7 +2171,7 @@ exits'/> + - 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. @@ -2158,130 +2179,141 @@ exits'/> + - Implement the format-number() XSLT function string format-number(number, string, string?) + - Free up the memory associated to the attribute value templates + - Free up the memory used by attribute sets + - Free up the memory allocated by all the elements of @comp + - Free the XSLT extension data + - Free the keys associated to a document + - Free up all the space used by the loaded documents + - Free up the memory used by XSLT extensions in a stylesheet + - Free up the data associated to the global variables its value. + - Free up the memory used by XSLT keys in a stylesheet + - Frees a locale created with xsltNewLocale - + + + ++ + + - Cleanup function for the locale support on shutdown + - Free up the memory used by namespaces aliases + - Frees all registered result value trees (Result Tree Fragments) of the transformation. Internal function; should not be called by user-code. + - Free up a security preference block + - Free up the memory allocated by @elem + - Frees the node-trees (and xsltDocument structures) of all stylesheet-modules of the stylesheet-level represented by the given @style. + - Free up the memory allocated by all precomputed blocks + - Free up the memory allocated by @style + - Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism + - Free up the memory allocated by @ctxt - + + - Implement the function-available() XSLT function boolean function-available(string) + - Implement the node-set() XSLT function node-set node-set(result-tree) This function is available in libxslt, saxon or xt namespace. + + ++ + + + - Implement the generate-id() XSLT function string generate-id(node-set?) + - Similar to xmlGetNsProp() but with a slightly different semantic Search and get the value of an attribute associated to a node This attribute has to be anchored in the namespace specified, or has no namespace and the element is in that namespace. This does the entity substitution. This function looks in DTD attribute declaration for #FIXED or default declaration values unless DTD use has been turned off. @@ -2289,27 +2321,27 @@ exits'/> + - Get xslDebugStatus. + - Get the default security preference application-wide + - Retrieve the data associated to the extension module in this given transformation. + - looks up URI in extInfos of the stylesheet + - Looks up a key of the in current source doc (the document info on @ctxt->document). Computes the key if not already done for the current source doc. @@ -2317,7 +2349,7 @@ exits'/> + - Find a matching (prefix and ns-name) ns-declaration for the requested @ns->prefix and @ns->href in the result tree. If none is found then a new ns-declaration will be added to @resultElem. If, in this case, the given prefix is already in use, then a ns-declaration with a modified ns-prefix be we created. Called by: - xsltCopyPropList() (*not* anymore) - xsltShallowCopyElement() - xsltCopyTreeInternal() (*not* anymore) - xsltApplySequenceConstructor() (*not* in the refactored code), - xsltElement() (*not* anymore) @@ -2325,14 +2357,14 @@ exits'/> + - Similar to xmlGetNsProp() but with a slightly different semantic Search and get the value of an attribute associated to a node This attribute has to be anchored in the namespace specified, or has no namespace and the element is in that namespace. This does the entity substitution. This function looks in DTD attribute declaration for #FIXED or default declaration values unless DTD use has been turned off. + - Obsolete. *Not* called by any Libxslt/Libexslt function. Exaclty the same as xsltGetNamespace(). @@ -2340,31 +2372,31 @@ exits'/> + - This function should be called after the transformation completed to extract template processing profiling information if available. The information is returned as an XML document tree like <?xml version="1.0"?> <profile> <template rank="1" match="*" name="" mode="" calls="6" time="48" average="8"/> <template rank="2" match="item2|item3" name="" mode="" calls="10" time="30" average="3"/> <template rank="3" match="item1" name="" mode="" calls="5" time="17" average="3"/> </profile> The caller will need to free up the returned tree with xmlFreeDoc() + - This function analyzes @name, if the name contains a prefix, the function seaches the associated namespace in scope for it. It will also replace @name value with the NCName, the old value being freed. Errors in the prefix lookup are signalled by setting @name to NULL. NOTE: the namespace returned is a pointer to the place where it is defined and hence has the same lifespan as the document holding it. + - This function is similar to xsltGetQNameURI, but is used when @name is a dictionary entry. + - Lookup the security option to get the callback checking function + - Find a matching (prefix and ns-name) ns-declaration for the requested @nsName and @nsPrefix in the result tree. If none is found then a new ns-declaration will be added to @resultElem. If, in this case, the given prefix is already in use, then a ns-declaration with a modified ns-prefix be we created. Note that this function's priority is to preserve ns-prefixes; it will only change a prefix if there's a namespace clash. If both @nsName and @nsPrefix are NULL, then this will try to "undeclare" a default namespace by declaring an xmlns="". @@ -2373,24 +2405,24 @@ exits'/> + - Finds the template applying to this node, if @style is non-NULL it means one needs to look for the next imported template in scope. + - Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API + - Provides the default state for XInclude processing + - @@ -2398,7 +2430,7 @@ exits'/> + - Processes the xsl:if instruction on the source node. @@ -2406,34 +2438,34 @@ exits'/> + - Initializes the processor (e.g. registers built-in extensions, etc.) + - INTERNAL ROUTINE ONLY Check if any keys on the current document need to be computed + - Initialize the set of modules with registered stylesheet data + - Computes the key tables this key and for the current input document. + - Computes all the keys tables for the current input document. Should be done before global varibales are initialized. NOTE: Not used anymore in the refactored code. + - Initializes an existing #xsltElemPreComp structure. This is usefull when extending an #xsltElemPreComp to store precomputed data. This function MUST be called on any extension element precomputed data struct. @@ -2442,60 +2474,60 @@ exits'/> + - Initialize the global variables for extensions + - Check if a string is ignorable + - Implement the key() XSLT function node-set key(string, object) + - Try to load a document (not a stylesheet) within the XSLT transformation context + - Try to load a stylesheet document within the XSLT transformation context + - This function tries to locate the stylesheet PI in the given document If found, and if contained within the document, it will extract that subtree to build the stylesheet to process @doc (doc itself will be modified). If found but referencing an external document it will attempt to load it and generate a stylesheet from it. In both cases, the resulting stylesheet and the document need to be freed once the transformation is done. + - Pops all variable values at the given @depth from the stack. + - Places the variable onto the local variable stack - Compares two strings transformed with xsltStrxfrm ++ -DEPRECATED: Same as xmlStrcmp. Compares two strings transformed with xsltStrxfrm. - - - + + + + - @@ -2504,75 +2536,82 @@ exits'/> + - Process and xsl:message construct + - Read the stylesheet-prefix and result-prefix attributes, register them as well as the corresponding namespace. + - Checks whether that stylesheet requires white-space stripping + - Register a new document, apply key computations + - Creates and initializes an #xsltElemPreComp + - Creates a new locale of an opaque system dependent type based on the language tag. -+ + + + ++ + + + - Create a new security preference block + - Register a new document, apply key computations + - Create a new XSLT Stylesheet + - Create a new XSLT TransformContext + - Find the next stylesheet in import precedence. + - This is a hashtable scanner function to normalize the compiled steps of an imported stylesheet. + - Process the xslt number node on the source node @@ -2580,163 +2619,163 @@ exits'/> + - Convert one number. + - Parses, validates the content models and compiles XSLT instructions. + - parse an XSLT transformation param declaration and record its value. + - Parses a global XSLT 'variable' declaration at compilation time and registers it + - Parses a "template" content (or "sequence constructor" in XSLT 2.0 terms). This will additionally remove xsl:text elements from the tree. + - parse an XSLT stylesheet attribute-set element + - Processes an xsl:with-param instruction at transformation time. The value is computed, but not recorded. NOTE that this is also called with an *xsl:param* element from exsltFuncFunctionFunction(). + - parse an XSLT stylesheet, building the associated structures. doc is kept as a reference within the returned stylesheet, so changes to doc after the parsing will be reflected when the stylesheet is applied, and the doc is automatically freed when the stylesheet is closed. - + + - Load and parse an XSLT stylesheet + - parse an XSLT stylesheet import element + - parse an XSLT stylesheet building the associated structures except the processing not needed for imported documents. + - parse an XSLT stylesheet include element + - parse an XSLT stylesheet output element and record information related to the stylesheet output + - Registers a local XSLT 'param' declaration at transformation time and evaluates its value. + - Parses an XSLT stylesheet, adding the associated structures. Called by: xsltParseStylesheetImportedDoc() (xslt.c) xsltParseStylesheetInclude() (imports.c) + - Parse an XSLT stylesheet with a user-provided stylesheet struct. + - Registers a local XSLT 'variable' instruction at transformation time and evaluates its value. + - parse a template content-model Clean-up the template content from unwanted ignorable blank nodes and process xslt:text + - Adds an item to the list. + - Resets the list, but does not free the allocated array and does not free the content of the list. + - Creates an xsltPointerList structure. + - Frees the xsltPointerList structure. This does not free the content of the list. + - Precomputes an extension module element + - + - Display the context of an error. + - Process the source node. + - Process the xslt processing-instruction node on the source node @@ -2744,7 +2783,7 @@ exits'/> + - Apply the stylesheet to the document and dump the profiling to the given output. @@ -2752,34 +2791,34 @@ exits'/> + - This is normally called from xsltQuoteUserParams to process a single parameter from a list of parameters. The @value is stored in the context's global variable/parameter hash table. + - Similar to xsltEvalUserParams, but the values are treated literally and are * *not* evaluated as XPath expressions. This should be done on parsed stylesheets before starting to apply transformations. + - Registers all default XSLT elements in this context + - Registers the built-in extensions + - Registers all default XSLT functions in this context + - Registers an extension element @@ -2787,7 +2826,7 @@ exits'/> + - Registers an extension function @@ -2795,14 +2834,14 @@ exits'/> + - Register an XSLT extension module to the library. + - Registers an extension module element. @@ -2810,7 +2849,7 @@ exits'/> + - Register an XSLT extension module to the library. @@ -2819,72 +2858,72 @@ exits'/> + - Registers an extension module function. + - Registers an extension module top-level element. + - Registers an extension namespace This is called from xslt.c during compile-time. The given prefix is not needed. Called by: xsltParseExtElemPrefixes() (new function) xsltRegisterExtPrefix() (old function) + - Registers the built-in extensions. This function is deprecated, use xsltRegisterAllExtras instead. + - Registers a result value tree (XSLT 1.0 term: Result Tree Fragment) in the RVT garbage collector. The fragment will be freed when the instruction which created the fragment exits. + - Register the result value tree (XSLT 1.0 term: Result Tree Fragment) in the fragment garbage collector. The fragment will be freed when the transformation context is freed. + - Registers the test module + - Registers the result value tree (XSLT 1.0 term: Result Tree Fragment) in the garbage collector. The fragment will be freed at the exit of the currently instantiated xsl:template. Obsolete; this function might produce massive memory overhead, since the fragment is only freed when the current xsl:template exits. Use xsltRegisterLocalRVT() instead. + - Either frees the RVT (which is an xmlDoc) or stores it in the context's cache for later reuse. + - resolve the references between attribute sets. + - Restore the namespaces for the document + - Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8 @@ -2894,7 +2933,7 @@ exits'/> + - 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 @@ -2906,34 +2945,34 @@ exits'/> + - Save the profiling information on @output + - Save the result @result obtained by applying the @style stylesheet to an I/O output channel @buf + - Save the result @result obtained by applying the @style stylesheet to an open file descriptor This does not close the descriptor. + - Save the result @result obtained by applying the @style stylesheet to an open FILE * I/O. This does not close the FILE @file + - Save the result @result obtained by applying the @style stylesheet to a file or @URL @@ -2941,7 +2980,7 @@ exits'/> + - Save the result @result obtained by applying the @style stylesheet to a new allocated string. @@ -2949,113 +2988,121 @@ exits'/> + - Function used to always allow an operation + - User provided function to check the value of a string like a file path or an URL ... + - Function used to always forbid an operation + + +Set the locale handlers. ++ + + + + - Change the default parser option passed by the XSLT engine to the parser when using document() loading. +