From f2cd40ff3927692975c0f2e1c3b0d2d56a7c0787 Mon Sep 17 00:00:00 2001 From: Nick Wellnhofer Date: Sat, 12 Feb 2022 23:00:33 +0100 Subject: [PATCH] Add documentation in devhelp format --- configure.ac | 2 + doc/EXSLT/devhelp/Makefile.am | 38 + doc/EXSLT/devhelp/devhelp2.xsl | 127 ++ doc/EXSLT/devhelp/general.html | 38 + doc/EXSLT/devhelp/home.png | Bin 0 -> 654 bytes doc/EXSLT/devhelp/html.xsl | 569 +++++++ doc/EXSLT/devhelp/index.html | 33 + doc/EXSLT/devhelp/left.png | Bin 0 -> 459 bytes doc/EXSLT/devhelp/libexslt-exslt.html | 183 +++ doc/EXSLT/devhelp/libexslt-exsltexports.html | 77 + doc/EXSLT/devhelp/libexslt.devhelp2 | 43 + doc/EXSLT/devhelp/right.png | Bin 0 -> 472 bytes doc/EXSLT/devhelp/style.css | 66 + doc/EXSLT/devhelp/up.png | Bin 0 -> 406 bytes doc/Makefile.am | 2 + doc/devhelp/Makefile.am | 56 + doc/devhelp/devhelp2.xsl | 127 ++ doc/devhelp/general.html | 38 + doc/devhelp/home.png | Bin 0 -> 654 bytes doc/devhelp/html.xsl | 572 +++++++ doc/devhelp/index.html | 34 + doc/devhelp/left.png | Bin 0 -> 459 bytes doc/devhelp/libxslt-attributes.html | 72 + doc/devhelp/libxslt-documents.html | 115 ++ doc/devhelp/libxslt-extensions.html | 262 ++++ doc/devhelp/libxslt-extra.html | 97 ++ doc/devhelp/libxslt-functions.html | 112 ++ doc/devhelp/libxslt-imports.html | 97 ++ doc/devhelp/libxslt-keys.html | 87 ++ doc/devhelp/libxslt-namespaces.html | 97 ++ doc/devhelp/libxslt-numbersInternals.html | 101 ++ doc/devhelp/libxslt-pattern.html | 119 ++ doc/devhelp/libxslt-preproc.html | 76 + doc/devhelp/libxslt-security.html | 140 ++ doc/devhelp/libxslt-templates.html | 112 ++ doc/devhelp/libxslt-transform.html | 227 +++ doc/devhelp/libxslt-variables.html | 147 ++ doc/devhelp/libxslt-xslt.html | 112 ++ doc/devhelp/libxslt-xsltInternals.html | 1426 ++++++++++++++++++ doc/devhelp/libxslt-xsltexports.html | 82 + doc/devhelp/libxslt-xsltlocale.html | 107 ++ doc/devhelp/libxslt-xsltutils.html | 348 +++++ doc/devhelp/libxslt.devhelp2 | 558 +++++++ doc/devhelp/right.png | Bin 0 -> 472 bytes doc/devhelp/style.css | 66 + doc/devhelp/up.png | Bin 0 -> 406 bytes 46 files changed, 6565 insertions(+) create mode 100644 doc/EXSLT/devhelp/Makefile.am create mode 100644 doc/EXSLT/devhelp/devhelp2.xsl create mode 100644 doc/EXSLT/devhelp/general.html create mode 100644 doc/EXSLT/devhelp/home.png create mode 100644 doc/EXSLT/devhelp/html.xsl create mode 100644 doc/EXSLT/devhelp/index.html create mode 100644 doc/EXSLT/devhelp/left.png create mode 100644 doc/EXSLT/devhelp/libexslt-exslt.html create mode 100644 doc/EXSLT/devhelp/libexslt-exsltexports.html create mode 100644 doc/EXSLT/devhelp/libexslt.devhelp2 create mode 100644 doc/EXSLT/devhelp/right.png create mode 100644 doc/EXSLT/devhelp/style.css create mode 100644 doc/EXSLT/devhelp/up.png create mode 100644 doc/devhelp/Makefile.am create mode 100644 doc/devhelp/devhelp2.xsl create mode 100644 doc/devhelp/general.html create mode 100644 doc/devhelp/home.png create mode 100644 doc/devhelp/html.xsl create mode 100644 doc/devhelp/index.html create mode 100644 doc/devhelp/left.png create mode 100644 doc/devhelp/libxslt-attributes.html create mode 100644 doc/devhelp/libxslt-documents.html create mode 100644 doc/devhelp/libxslt-extensions.html create mode 100644 doc/devhelp/libxslt-extra.html create mode 100644 doc/devhelp/libxslt-functions.html create mode 100644 doc/devhelp/libxslt-imports.html create mode 100644 doc/devhelp/libxslt-keys.html create mode 100644 doc/devhelp/libxslt-namespaces.html create mode 100644 doc/devhelp/libxslt-numbersInternals.html create mode 100644 doc/devhelp/libxslt-pattern.html create mode 100644 doc/devhelp/libxslt-preproc.html create mode 100644 doc/devhelp/libxslt-security.html create mode 100644 doc/devhelp/libxslt-templates.html create mode 100644 doc/devhelp/libxslt-transform.html create mode 100644 doc/devhelp/libxslt-variables.html create mode 100644 doc/devhelp/libxslt-xslt.html create mode 100644 doc/devhelp/libxslt-xsltInternals.html create mode 100644 doc/devhelp/libxslt-xsltexports.html create mode 100644 doc/devhelp/libxslt-xsltlocale.html create mode 100644 doc/devhelp/libxslt-xsltutils.html create mode 100644 doc/devhelp/libxslt.devhelp2 create mode 100644 doc/devhelp/right.png create mode 100644 doc/devhelp/style.css create mode 100644 doc/devhelp/up.png diff --git a/configure.ac b/configure.ac index 24861345..21d2d8ee 100644 --- a/configure.ac +++ b/configure.ac @@ -753,6 +753,8 @@ tests/exslt/crypto/Makefile tests/plugins/Makefile tests/fuzz/Makefile doc/Makefile +doc/devhelp/Makefile +doc/EXSLT/devhelp/Makefile xslt-config libxslt.spec ]) diff --git a/doc/EXSLT/devhelp/Makefile.am b/doc/EXSLT/devhelp/Makefile.am new file mode 100644 index 00000000..b55fba5f --- /dev/null +++ b/doc/EXSLT/devhelp/Makefile.am @@ -0,0 +1,38 @@ +devhelpdir = $(datadir)/gtk-doc/html/libexslt + +dist_devhelp_DATA = \ + libexslt.devhelp2 \ + $(HTML_FILES) \ + $(EXTRA_FORMAT) + +HTML_FILES = \ + general.html \ + index.html \ + $(HTML_MODULES) + +HTML_MODULES= \ + libexslt-exsltexports.html \ + libexslt-exslt.html + +EXTRA_FORMAT= \ + home.png \ + left.png \ + right.png \ + up.png \ + style.css + +EXTRA_DIST = devhelp2.xsl html.xsl + +if REBUILD_DOCS + +rebuild: libexslt.devhelp2 +.PHONY: rebuild + +$(HTML_FILES): libexslt.devhelp2 + +libexslt.devhelp2: devhelp2.xsl html.xsl $(top_srcdir)/doc/EXSLT/libexslt-api.xml + -@(if [ -x $(XSLTPROC) ] ; then \ + echo Rebuilding devhelp2 files ; \ + $(XSLTPROC) --nonet -o $(srcdir)/libexslt.devhelp2 $(srcdir)/devhelp2.xsl $(top_srcdir)/doc/EXSLT/libexslt-api.xml ; fi ); + +endif diff --git a/doc/EXSLT/devhelp/devhelp2.xsl b/doc/EXSLT/devhelp/devhelp2.xsl new file mode 100644 index 00000000..a18f7c0b --- /dev/null +++ b/doc/EXSLT/devhelp/devhelp2.xsl @@ -0,0 +1,127 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + <xsl:value-of select="concat(@name, ': ', summary)"/> + + + + + + + + + + + + + + + + + + + + +
PrevUpHomeNextlibexslt Reference Manual
+

+

-

+

+ +

WARNING: this module is deprecated !

+ +

Author(s):

+
+

Synopsis

+ 
+	    
+
+
+
+

Description

+
+
+

Details

+
+ + + + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/EXSLT/devhelp/general.html b/doc/EXSLT/devhelp/general.html new file mode 100644 index 00000000..4c0ef291 --- /dev/null +++ b/doc/EXSLT/devhelp/general.html @@ -0,0 +1,38 @@ + + + + + libexslt: + + + + + + + + + + + + + + +
+ + Up + + + + Home + + + + Next + + libexslt Reference Manual
+

+ libexslt API Modules +

+

exslt - main header file
exsltexports - macros for marking symbols as exportable/importable.

+ + diff --git a/doc/EXSLT/devhelp/home.png b/doc/EXSLT/devhelp/home.png new file mode 100644 index 0000000000000000000000000000000000000000..17003611d9df2b066afc682cbde962f3a575002d GIT binary patch literal 654 zcmV;90&)F`P)~yY zO1cF+0vxb!W?!x?K+*#62Jq)nA4q`)5S6sgX4ao{=)(Mgq+YMr)7sjak|a^9)zS!j zlk{-n29mabXYF=7SYBQx&vO8xC}MYams+hxqtO7sImhPaCf@rq;I^3!#u*2aUP)55 zT2&N90xmEJ0s&fGT~(T<3d2xYmK9C>IP*x-M@ib*+0pFm>>uW37N2Wzaq-fCnIZE9 zpb8}0+uN+KuQM2oZVHfP8U6kQdo3?>Wo2dT)WeM9So8DqhLi#T0 z-i(>mfjhvbsYV`;4sgfJ-p>G-SqJ!fjR6BQYs1h*y9xaN0l{VB;o%`08yiy@)$8@~ z2PD1gcDuiy;j1tR0v#V8OH%W)25-YKyx(j#IXO9*YWf0mb8}QG6@b@;cHxh9{t7+@ o!Yd`f8L$sLH?yBt^q3C6015TtIu@BS5dZ)H07*qoM6N<$f*igdr~m)} literal 0 HcmV?d00001 diff --git a/doc/EXSLT/devhelp/html.xsl b/doc/EXSLT/devhelp/html.xsl new file mode 100644 index 00000000..32dc44fc --- /dev/null +++ b/doc/EXSLT/devhelp/html.xsl @@ -0,0 +1,569 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ( + + void + + + + + + + + + ,
+ + + + + + + + + + ); + + + + + + + + + + typedef + + + + + + + + + + + + ( + + void + + + + + + + + + ,
+ + + + + + + + + + ); + + + + + + + + + + + typedef + + + + + + ; + + + + + + #define + + + ( + + + + , + + + ) + + ; + + + + + + + + + + +
+

Structure

+ 
+     {
+
+    
+      The content of this structure is not made public by the API.
+
+    
+    
+            
+	
+	  
+	
+		
+	
+	
+	  	: 
+	  
+	    
+	  
+	
+	
+
+    
+    } 
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + +
+

Typedef

+ 
+    
+      
+    
+     
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + +
+

Variable

+ 
+    
+      
+    
+     
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + +
+

Enum

+ 
+    enum 
+    
+     {
+
+    
+      
+          
+      
+      
+         = 
+	
+      
+      
+         /* 
+	
+         */
+      
+      
+
+    
+    };
+
+
+

+ + + +

+ +
+ + + + +
+

Macro

+ 
+    #define 
+    
+    
+      (
+      
+        
+	
+	  , 
+	
+      
+      )
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + + + +
: + + + +
+ + + +
+ + + + + + + +
+

()

+ 
+    
+      
+    
+    	
+    
+    
+      	
+    
+    
+      	
+    
+    	(
+    
+      void
+    
+    
+      
+        
+      
+       
+      
+      
+        , 

+	
+	  	
+	
+	
+	  	
+	
+						 
+      
+    
+    )

+    
+
+
+

+ + + +

+ + +
+ + + + + + + + + + + + +
: + + + +
Returns: + + + +
+ +
+ + + + + + + +
+

Function type

+ 
+    
+      
+    
+    	
+    
+    
+      	
+    
+    
+      	
+    
+    	(
+    
+      void
+    
+    
+      
+        
+      
+       
+      
+      
+        , 

+	
+	  	
+	
+	
+	  	
+	
+						 
+      
+    
+    )

+    
+
+
+

+ + + +

+ + +
+ + + + + + + + + + + + +
: + + + +
Returns: + + + +
+ +
+ + + + + + + + + + <xsl:value-of select="concat(@name, ': ', summary)"/> + + + + + + + + + + + + + + + + + +
UpHomeNextlibexslt Reference Manual
+

libexslt API Modules

+

+ + -
+ +

+ + + + + + + + + + + + libexslt Reference Manual + + + + + + + + + + + +
HomeNextlibexslt Reference Manual
+

libexslt Reference Manual

+

Libexslt is the EXSLT C library + developed for libexslt (a part of the Gnome project). Much of the + initial work on the library was done by Thomas Broyer. EXSLT itself + is a community initiative to provide extensions to XSLT.

+ + + + + + + + diff --git a/doc/EXSLT/devhelp/index.html b/doc/EXSLT/devhelp/index.html new file mode 100644 index 00000000..cb0c8a32 --- /dev/null +++ b/doc/EXSLT/devhelp/index.html @@ -0,0 +1,33 @@ + + + + + libexslt Reference Manual + + + + + + + + + + +
+ + Home + + + + Next + + libexslt Reference Manual
+

+ libexslt Reference Manual +

+

Libexslt is the EXSLT C library + developed for libexslt (a part of the Gnome project). Much of the + initial work on the library was done by Thomas Broyer. EXSLT itself + is a community initiative to provide extensions to XSLT.

+ + diff --git a/doc/EXSLT/devhelp/left.png b/doc/EXSLT/devhelp/left.png new file mode 100644 index 0000000000000000000000000000000000000000..2d05b3d5b4aeec9384bbfe404bfc4ed0897051c4 GIT binary patch literal 459 zcmV;+0W|)JP)40xL?wO*>WZ(J#ML5j2<9jD6A%Q&kC}jOeEc;X{s;`zcnxLeZR6?6h#^ihmNF6NpGdilO$m<82oD9WQ|6nVv1`? z>KufRi{?QPXg;4;wroQu4?mN1Ydd@|kaQ|ZyWLK!)yi7Wb%=0{}lD)tfliHAUyWRQ+fD_;aV6j->y6!O_8bENg + + + + exslt: main header file + + + + + + + + + + + + + + +
+ + Up + + + + Home + + + + Next + + libexslt Reference Manual
+

+ exslt +

+

exslt - main header file

+

+

Author(s):

+
+

Synopsis

+ 
#define EXSLT_DATE_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	exsltMathRegister		(void);
+int	exsltMathXpathCtxtRegister	(xmlXPathContextPtr ctxt, 
					 const xmlChar * prefix);
+void	exsltSaxonRegister		(void);
+int	exsltDateXpathCtxtRegister	(xmlXPathContextPtr ctxt, 
					 const xmlChar * prefix);
+
+
+
+

Description

+
+
+

Details

+
+

Macro EXSLT_COMMON_NAMESPACE

#define EXSLT_COMMON_NAMESPACE;
+

Namespace for EXSLT common functions

+
+
+

Macro EXSLT_CRYPTO_NAMESPACE

#define EXSLT_CRYPTO_NAMESPACE;
+

Namespace for EXSLT crypto functions

+
+
+

Macro EXSLT_DATE_NAMESPACE

#define EXSLT_DATE_NAMESPACE;
+

Namespace for EXSLT date functions

+
+
+

Macro EXSLT_DYNAMIC_NAMESPACE

#define EXSLT_DYNAMIC_NAMESPACE;
+

Namespace for EXSLT dynamic functions

+
+
+

Macro EXSLT_FUNCTIONS_NAMESPACE

#define EXSLT_FUNCTIONS_NAMESPACE;
+

Namespace for EXSLT functions extension functions

+
+
+

Macro EXSLT_MATH_NAMESPACE

#define EXSLT_MATH_NAMESPACE;
+

Namespace for EXSLT math functions

+
+
+

Macro EXSLT_SETS_NAMESPACE

#define EXSLT_SETS_NAMESPACE;
+

Namespace for EXSLT set functions

+
+
+

Macro EXSLT_STRINGS_NAMESPACE

#define EXSLT_STRINGS_NAMESPACE;
+

Namespace for EXSLT strings functions

+
+
+

Macro SAXON_NAMESPACE

#define SAXON_NAMESPACE;
+

Namespace for SAXON extensions functions

+
+
+

Variable exsltLibexsltVersion

const int exsltLibexsltVersion;
+

+

+
+

Variable exsltLibraryVersion

const char * exsltLibraryVersion;
+

+

+
+

Variable exsltLibxmlVersion

const int exsltLibxmlVersion;
+

+

+
+

Variable exsltLibxsltVersion

const int exsltLibxsltVersion;
+

+

+
+

exsltCommonRegister ()

void	exsltCommonRegister		(void)

+

Registers the EXSLT - Common module

+
+
+

exsltCryptoRegister ()

void	exsltCryptoRegister		(void)

+

Registers the EXSLT - Crypto module

+
+
+

exsltDateRegister ()

void	exsltDateRegister		(void)

+

Registers the EXSLT - Dates and Times module

+
+
+

exsltDateXpathCtxtRegister ()

int	exsltDateXpathCtxtRegister	(xmlXPathContextPtr ctxt, 
					 const xmlChar * prefix)

+

Registers the EXSLT - Dates and Times module for use outside XSLT

+
ctxt:
prefix:
Returns:
+
+

exsltDynRegister ()

void	exsltDynRegister		(void)

+

Registers the EXSLT - Dynamic module

+
+
+

exsltFuncRegister ()

void	exsltFuncRegister		(void)

+

Registers the EXSLT - Functions module

+
+
+

exsltMathRegister ()

void	exsltMathRegister		(void)

+

Registers the EXSLT - Math module

+
+
+

exsltMathXpathCtxtRegister ()

int	exsltMathXpathCtxtRegister	(xmlXPathContextPtr ctxt, 
					 const xmlChar * prefix)

+

Registers the EXSLT - Math module for use outside XSLT

+
ctxt:
prefix:
Returns:
+
+

exsltRegisterAll ()

void	exsltRegisterAll		(void)

+

Registers all available EXSLT extensions

+
+
+

exsltSaxonRegister ()

void	exsltSaxonRegister		(void)

+

Registers the SAXON extension module

+
+
+

exsltSetsRegister ()

void	exsltSetsRegister		(void)

+

Registers the EXSLT - Sets module

+
+
+

exsltSetsXpathCtxtRegister ()

int	exsltSetsXpathCtxtRegister	(xmlXPathContextPtr ctxt, 
					 const xmlChar * prefix)

+

Registers the EXSLT - Sets module for use outside XSLT

+
ctxt:
prefix:
Returns:
+
+

exsltStrRegister ()

void	exsltStrRegister		(void)

+

Registers the EXSLT - Strings module

+
+
+

exsltStrXpathCtxtRegister ()

int	exsltStrXpathCtxtRegister	(xmlXPathContextPtr ctxt, 
					 const xmlChar * prefix)

+

Registers the EXSLT - Strings module for use outside XSLT

+
ctxt:
prefix:
Returns:
+
+
+
+ + diff --git a/doc/EXSLT/devhelp/libexslt-exsltexports.html b/doc/EXSLT/devhelp/libexslt-exsltexports.html new file mode 100644 index 00000000..b04b4c02 --- /dev/null +++ b/doc/EXSLT/devhelp/libexslt-exsltexports.html @@ -0,0 +1,77 @@ + + + + + exsltexports: macros for marking symbols as exportable/importable. + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + libexslt Reference Manual
+

+ exsltexports +

+

exsltexports - macros for marking symbols as exportable/importable.

+

+

Author(s): Igor Zlatkovic <igor@zlatkovic.com>

+
+

Synopsis

+ 
#define LIBEXSLT_PUBLIC;
+#define _REENTRANT;
+#define EXSLTCALL;
+#define EXSLTPUBFUN;
+#define EXSLTPUBVAR;
+
+
+
+

Description

+
+
+

Details

+
+

Macro EXSLTCALL

#define EXSLTCALL;
+

+

+
+

Macro EXSLTPUBFUN

#define EXSLTPUBFUN;
+

+

+
+

Macro EXSLTPUBVAR

#define EXSLTPUBVAR;
+

+

+
+

Macro LIBEXSLT_PUBLIC

#define LIBEXSLT_PUBLIC;
+

+

+
+

Macro _REENTRANT

#define _REENTRANT;
+

+

+
+
+
+ + diff --git a/doc/EXSLT/devhelp/libexslt.devhelp2 b/doc/EXSLT/devhelp/libexslt.devhelp2 new file mode 100644 index 00000000..12020f8f --- /dev/null +++ b/doc/EXSLT/devhelp/libexslt.devhelp2 @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/EXSLT/devhelp/right.png b/doc/EXSLT/devhelp/right.png new file mode 100644 index 0000000000000000000000000000000000000000..92832e3a4566e59d6e4092010e08d28f3be3a68d GIT binary patch literal 472 zcmV;}0Vn>6P)Cd4HCN^TYHBC0dz3r5|}*T3c5!K}0^NPTey!^rYo;W&eW{b1SE%dR-1ljcju- zJITo5P_e{cPDWDszO|97o#m$fni3V4d%~7^?0HU4-k!+X`e~w55Q}HA=c?CM9`EK` z^o5GF_RsnG`ey+9wOf8O4bzg>7W*;jU~M?g`OZAA$mNp|Lz<$s+~N9!2`ir8RcClo$(Q~19INM~9}j;&*|enC yGd}kJak0wj?aUKd8;%}`i}SSew>!A-2iw}^5}Rh(M>+vRkipZ{&t;ucLK6U4uc96R literal 0 HcmV?d00001 diff --git a/doc/Makefile.am b/doc/Makefile.am index 13d8c3c7..b99bf382 100644 --- a/doc/Makefile.am +++ b/doc/Makefile.am @@ -1,5 +1,7 @@ ## Process this file with automake to produce Makefile.in +SUBDIRS = devhelp EXSLT/devhelp + # The top-level SGML file. DOC_MAIN_XML_FILE=libxslt.xml diff --git a/doc/devhelp/Makefile.am b/doc/devhelp/Makefile.am new file mode 100644 index 00000000..66bc761b --- /dev/null +++ b/doc/devhelp/Makefile.am @@ -0,0 +1,56 @@ +devhelpdir = $(datadir)/gtk-doc/html/libxslt + +dist_devhelp_DATA = \ + libxslt.devhelp2 \ + $(HTML_FILES) \ + $(EXTRA_FORMAT) + +HTML_FILES = \ + general.html \ + index.html \ + $(HTML_MODULES) + +HTML_MODULES= \ + libxslt-attributes.html \ + libxslt-documents.html \ + libxslt-extensions.html \ + libxslt-extra.html \ + libxslt-functions.html \ + libxslt-imports.html \ + libxslt-keys.html \ + libxslt-namespaces.html \ + libxslt-numbersInternals.html \ + libxslt-pattern.html \ + libxslt-preproc.html \ + libxslt-security.html \ + libxslt-templates.html \ + libxslt-transform.html \ + libxslt-variables.html \ + libxslt-xsltexports.html \ + libxslt-xslt.html \ + libxslt-xsltInternals.html \ + libxslt-xsltlocale.html \ + libxslt-xsltutils.html + +EXTRA_FORMAT= \ + home.png \ + left.png \ + right.png \ + up.png \ + style.css + +EXTRA_DIST = devhelp2.xsl html.xsl + +if REBUILD_DOCS + +rebuild: libxslt.devhelp2 +.PHONY: rebuild + +$(HTML_FILES): libxslt.devhelp2 + +libxslt.devhelp2: devhelp2.xsl html.xsl $(top_srcdir)/doc/libxslt-api.xml + -@(if [ -x $(XSLTPROC) ] ; then \ + echo Rebuilding devhelp2 files ; \ + $(XSLTPROC) --nonet -o $(srcdir)/libxslt.devhelp2 $(srcdir)/devhelp2.xsl $(top_srcdir)/doc/libxslt-api.xml ; fi ); + +endif diff --git a/doc/devhelp/devhelp2.xsl b/doc/devhelp/devhelp2.xsl new file mode 100644 index 00000000..1848bfd1 --- /dev/null +++ b/doc/devhelp/devhelp2.xsl @@ -0,0 +1,127 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + <xsl:value-of select="concat(@name, ': ', summary)"/> + + + + + + + + + + + + + + + + + + + + +
PrevUpHomeNextlibxslt Reference Manual
+

+

-

+

+ +

WARNING: this module is deprecated !

+ +

Author(s):

+
+

Synopsis

+ 
+	    
+
+
+
+

Description

+
+
+

Details

+
+ + + + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/devhelp/general.html b/doc/devhelp/general.html new file mode 100644 index 00000000..6352d055 --- /dev/null +++ b/doc/devhelp/general.html @@ -0,0 +1,38 @@ + + + + + libxslt: + + + + + + + + + + + + + + +
+ + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ libxslt API Modules +

+

attributes - interface for the XSLT attribute handling
documents - interface for the document handling
extensions - interface for the extension support
extra - interface for the non-standard features
functions - interface for the XSLT functions not from XPath
imports - interface for the XSLT import support
keys - interface for the key matching used in key() and template matches.
namespaces - interface for the XSLT namespace handling
numbersInternals - Implementation of the XSLT number functions
pattern - interface for the pattern matching used in template matches.
preproc - precomputing stylesheets
security - interface for the libxslt security framework
templates - interface for the template processing
transform - the XSLT engine transformation part.
variables - interface for the variable matching and lookup.
xslt - Interfaces, constants and types related to the XSLT engine
xsltInternals - internal data structures, constants and functions
xsltexports - macros for marking symbols as exportable/importable.
xsltlocale - Locale handling
xsltutils - set of utilities for the XSLT engine

+ + diff --git a/doc/devhelp/home.png b/doc/devhelp/home.png new file mode 100644 index 0000000000000000000000000000000000000000..17003611d9df2b066afc682cbde962f3a575002d GIT binary patch literal 654 zcmV;90&)F`P)~yY zO1cF+0vxb!W?!x?K+*#62Jq)nA4q`)5S6sgX4ao{=)(Mgq+YMr)7sjak|a^9)zS!j zlk{-n29mabXYF=7SYBQx&vO8xC}MYams+hxqtO7sImhPaCf@rq;I^3!#u*2aUP)55 zT2&N90xmEJ0s&fGT~(T<3d2xYmK9C>IP*x-M@ib*+0pFm>>uW37N2Wzaq-fCnIZE9 zpb8}0+uN+KuQM2oZVHfP8U6kQdo3?>Wo2dT)WeM9So8DqhLi#T0 z-i(>mfjhvbsYV`;4sgfJ-p>G-SqJ!fjR6BQYs1h*y9xaN0l{VB;o%`08yiy@)$8@~ z2PD1gcDuiy;j1tR0v#V8OH%W)25-YKyx(j#IXO9*YWf0mb8}QG6@b@;cHxh9{t7+@ o!Yd`f8L$sLH?yBt^q3C6015TtIu@BS5dZ)H07*qoM6N<$f*igdr~m)} literal 0 HcmV?d00001 diff --git a/doc/devhelp/html.xsl b/doc/devhelp/html.xsl new file mode 100644 index 00000000..f0004696 --- /dev/null +++ b/doc/devhelp/html.xsl @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ( + + void + + + + + + + + + ,
+ + + + + + + + + + ); + + + + + + + + + + typedef + + + + + + + + + + + + ( + + void + + + + + + + + + ,
+ + + + + + + + + + ); + + + + + + + + + + + typedef + + + + + + ; + + + + + + #define + + + ( + + + + , + + + ) + + ; + + + + + + + + + + +
+

Structure

+ 
+     {
+
+    
+      The content of this structure is not made public by the API.
+
+    
+    
+            
+	
+	  
+	
+		
+	
+	
+	  	: 
+	  
+	    
+	  
+	
+	
+
+    
+    } 
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + +
+

Typedef

+ 
+    
+      
+    
+     
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + +
+

Variable

+ 
+    
+      
+    
+     
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + +
+

Enum

+ 
+    enum 
+    
+     {
+
+    
+      
+          
+      
+      
+         = 
+	
+      
+      
+         /* 
+	
+         */
+      
+      
+
+    
+    };
+
+
+

+ + + +

+ +
+ + + + +
+

Macro

+ 
+    #define 
+    
+    
+      (
+      
+        
+	
+	  , 
+	
+      
+      )
+    
+    ;
+
+
+

+ + + +

+ +
+ + + + + + +
: + + + +
+ + + +
+ + + + + + + +
+

()

+ 
+    
+      
+    
+    	
+    
+    
+      	
+    
+    
+      	
+    
+    	(
+    
+      void
+    
+    
+      
+        
+      
+       
+      
+      
+        , 

+	
+	  	
+	
+	
+	  	
+	
+						 
+      
+    
+    )

+    
+
+
+

+ + + +

+ + +
+ + + + + + + + + + + + +
: + + + +
Returns: + + + +
+ +
+ + + + + + + +
+

Function type

+ 
+    
+      
+    
+    	
+    
+    
+      	
+    
+    
+      	
+    
+    	(
+    
+      void
+    
+    
+      
+        
+      
+       
+      
+      
+        , 

+	
+	  	
+	
+	
+	  	
+	
+						 
+      
+    
+    )

+    
+
+
+

+ + + +

+ + +
+ + + + + + + + + + + + +
: + + + +
Returns: + + + +
+ +
+ + + + + + + + + + <xsl:value-of select="concat(@name, ': ', summary)"/> + + + + + + + + + + + + + + + + + +
UpHomeNextlibxslt Reference Manual
+

libxslt API Modules

+

+ + -
+ +

+ + + + + + + + + + + + libxslt Reference Manual + + + + + + + + + + + +
HomeNextlibxslt Reference Manual
+

libxslt Reference Manual

+

libxslt is the XSLT C library +developed for the GNOME project. XSLT itself is a an XML language to define +transformation for XML. Libxslt is based on libxml2 the XML C library developed for the +GNOME project. It also implements most of the EXSLT set of processor-portable extensions +functions and some of Saxon's evaluate and expressions extensions.

+ + + + + + + + diff --git a/doc/devhelp/index.html b/doc/devhelp/index.html new file mode 100644 index 00000000..f29841ec --- /dev/null +++ b/doc/devhelp/index.html @@ -0,0 +1,34 @@ + + + + + libxslt Reference Manual + + + + + + + + + + +
+ + Home + + + + Next + + libxslt Reference Manual
+

+ libxslt Reference Manual +

+

libxslt is the XSLT C library +developed for the GNOME project. XSLT itself is a an XML language to define +transformation for XML. Libxslt is based on libxml2 the XML C library developed for the +GNOME project. It also implements most of the EXSLT set of processor-portable extensions +functions and some of Saxon's evaluate and expressions extensions.

+ + diff --git a/doc/devhelp/left.png b/doc/devhelp/left.png new file mode 100644 index 0000000000000000000000000000000000000000..2d05b3d5b4aeec9384bbfe404bfc4ed0897051c4 GIT binary patch literal 459 zcmV;+0W|)JP)40xL?wO*>WZ(J#ML5j2<9jD6A%Q&kC}jOeEc;X{s;`zcnxLeZR6?6h#^ihmNF6NpGdilO$m<82oD9WQ|6nVv1`? z>KufRi{?QPXg;4;wroQu4?mN1Ydd@|kaQ|ZyWLK!)yi7Wb%=0{}lD)tfliHAUyWRQ+fD_;aV6j->y6!O_8bENg + + + + attributes: interface for the XSLT attribute handling + + + + + + + + + + + + + + +
+ + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ attributes +

+

attributes - interface for the XSLT attribute handling

+

this module handles the specificities of attribute and attribute groups processing.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
void	xsltResolveStylesheetAttributeSet	(xsltStylesheetPtr style);
+void	xsltParseStylesheetAttributeSet	(xsltStylesheetPtr style, 
					 xmlNodePtr cur);
+void	xsltApplyAttributeSet		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 const xmlChar * attrSets);
+void	xsltFreeAttributeSetsHashes	(xsltStylesheetPtr style);
+
+
+
+

Description

+
+
+

Details

+
+

xsltApplyAttributeSet ()

void	xsltApplyAttributeSet		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 const xmlChar * attrSets)

+

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.

+
ctxt:the XSLT stylesheet
node:the node in the source tree.
inst:the attribute node "xsl:use-attribute-sets"
attrSets:the list of QNames of the attribute-sets to be applied
+
+

xsltFreeAttributeSetsHashes ()

void	xsltFreeAttributeSetsHashes	(xsltStylesheetPtr style)

+

Free up the memory used by attribute sets

+
style:an XSLT stylesheet
+
+

xsltParseStylesheetAttributeSet ()

void	xsltParseStylesheetAttributeSet	(xsltStylesheetPtr style, 
					 xmlNodePtr cur)

+

parse an XSLT stylesheet attribute-set element

+
style:the XSLT stylesheet
cur:the "attribute-set" element
+
+

xsltResolveStylesheetAttributeSet ()

void	xsltResolveStylesheetAttributeSet	(xsltStylesheetPtr style)

+

resolve the references between attribute sets.

+
style:the XSLT stylesheet
+
+
+
+ + diff --git a/doc/devhelp/libxslt-documents.html b/doc/devhelp/libxslt-documents.html new file mode 100644 index 00000000..df15fcb0 --- /dev/null +++ b/doc/devhelp/libxslt-documents.html @@ -0,0 +1,115 @@ + + + + + documents: interface for the document handling + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ documents +

+

documents - interface for the document handling

+

implements document loading and cache (multiple document() reference for the same resources must be equal.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
typedef enum xsltLoadType;
+void	xsltFreeStyleDocuments		(xsltStylesheetPtr style);
+typedef xmlDocPtr xsltDocLoaderFunc	(const xmlChar * URI, 
					 xmlDictPtr dict, 
					 int options, 
					 void * ctxt, 
					 xsltLoadType type);
+xsltDocumentPtr	xsltLoadDocument	(xsltTransformContextPtr ctxt, 
					 const xmlChar * URI);
+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);
+
+
+
+

Description

+
+
+

Details

+
+

Enum xsltLoadType

enum xsltLoadType {
+    XSLT_LOAD_START = 0 /* loading for a top stylesheet */
+    XSLT_LOAD_STYLESHEET = 1 /* loading for a stylesheet include/import */
+    XSLT_LOAD_DOCUMENT = 2 /*  loading document at transformation time */
+};
+

+

+
+

Function type xsltDocLoaderFunc

xmlDocPtr	xsltDocLoaderFunc	(const xmlChar * URI, 
					 xmlDictPtr dict, 
					 int options, 
					 void * ctxt, 
					 xsltLoadType type)

+

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.

+
URI:the URI of the document to load
dict:the dictionary to use when parsing that document
options:parsing options, a set of xmlParserOption
ctxt:the context, either a stylesheet or a transformation context
type:the xsltLoadType indicating the kind of loading required
Returns:the pointer to the document (which will be modified and freed by the engine later), or NULL in case of error.
+
+

Variable xsltDocDefaultLoader

xsltDocLoaderFunc xsltDocDefaultLoader;
+

+

+
+

xsltFindDocument ()

xsltDocumentPtr	xsltFindDocument	(xsltTransformContextPtr ctxt, 
					 xmlDocPtr doc)

+

Try to find a document within the XSLT transformation context. This will not find document infos for temporary Result Tree Fragments.

+
ctxt:an XSLT transformation context
doc:a parsed XML document
Returns:the desired xsltDocumentPtr or NULL in case of error
+
+

xsltFreeDocuments ()

void	xsltFreeDocuments		(xsltTransformContextPtr ctxt)

+

Free up all the space used by the loaded documents

+
ctxt:an XSLT transformation context
+
+

xsltFreeStyleDocuments ()

void	xsltFreeStyleDocuments		(xsltStylesheetPtr style)

+

Frees the node-trees (and xsltDocument structures) of all stylesheet-modules of the stylesheet-level represented by the given @style.

+
style:an XSLT stylesheet (representing a stylesheet-level)
+
+

xsltLoadDocument ()

xsltDocumentPtr	xsltLoadDocument	(xsltTransformContextPtr ctxt, 
					 const xmlChar * URI)

+

Try to load a document (not a stylesheet) within the XSLT transformation context

+
ctxt:an XSLT transformation context
URI:the computed URI of the document
Returns:the new xsltDocumentPtr or NULL in case of error
+
+

xsltLoadStyleDocument ()

xsltDocumentPtr	xsltLoadStyleDocument	(xsltStylesheetPtr style, 
					 const xmlChar * URI)

+

Try to load a stylesheet document within the XSLT transformation context

+
style:an XSLT style sheet
URI:the computed URI of the document
Returns:the new xsltDocumentPtr or NULL in case of error
+
+

xsltNewDocument ()

xsltDocumentPtr	xsltNewDocument		(xsltTransformContextPtr ctxt, 
					 xmlDocPtr doc)

+

Register a new document, apply key computations

+
ctxt:an XSLT transformation context (or NULL)
doc:a parsed XML document
Returns:a handler to the document
+
+

xsltNewStyleDocument ()

xsltDocumentPtr	xsltNewStyleDocument	(xsltStylesheetPtr style, 
					 xmlDocPtr doc)

+

Register a new document, apply key computations

+
style:an XSLT style sheet
doc:a parsed XML document
Returns:a handler to the document
+
+

xsltSetLoaderFunc ()

void	xsltSetLoaderFunc		(xsltDocLoaderFunc f)

+

Set the new function to load document, if NULL it resets it to the default function.

+
f:the new function to handle document loading.
+
+
+
+ + diff --git a/doc/devhelp/libxslt-extensions.html b/doc/devhelp/libxslt-extensions.html new file mode 100644 index 00000000..a3ff1241 --- /dev/null +++ b/doc/devhelp/libxslt-extensions.html @@ -0,0 +1,262 @@ + + + + + extensions: interface for the extension support + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ extensions +

+

extensions - interface for the extension support

+

This provide the API needed for simple and module extension support.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
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	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);
+typedef void * xsltExtInitFunction		(xsltTransformContextPtr ctxt, 
					 const xmlChar * URI);
+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);
+xsltElemPreCompPtr	xsltNewElemPreComp	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 xsltTransformFunction function);
+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);
+
+
+
+

Description

+
+
+

Details

+
+

Function type xsltExtInitFunction

void *	xsltExtInitFunction		(xsltTransformContextPtr ctxt, 
					 const xmlChar * URI)

+

A function called at initialization time of an XSLT extension module.

+
ctxt:an XSLT transformation context
URI:the namespace URI for the extension
Returns:a pointer to the module specific data for this transformation.
+
+

Function type xsltExtShutdownFunction

void	xsltExtShutdownFunction		(xsltTransformContextPtr ctxt, 
					 const xmlChar * URI, 
					 void * data)

+

A function called at shutdown time of an XSLT extension module.

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

Function type xsltPreComputeFunction

xsltElemPreCompPtr	xsltPreComputeFunction	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 xsltTransformFunction function)

+

+

style:
inst:
function:
Returns:
+
+

Function type xsltStyleExtInitFunction

void *	xsltStyleExtInitFunction	(xsltStylesheetPtr style, 
					 const xmlChar * URI)

+

A function called at initialization time of an XSLT extension module.

+
style:
URI:the namespace URI for the extension
Returns:a pointer to the module specific data for this transformation.
+
+

Function type xsltStyleExtShutdownFunction

void	xsltStyleExtShutdownFunction	(xsltStylesheetPtr style, 
					 const xmlChar * URI, 
					 void * data)

+

A function called at shutdown time of an XSLT extension module.

+
style:
URI:the namespace URI for the extension
data:the data associated to this module
+
+

Function type xsltTopLevelFunction

void	xsltTopLevelFunction		(xsltStylesheetPtr style, 
					 xmlNodePtr inst)

+

+

style:
inst:
+
+

xsltCheckExtPrefix ()

int	xsltCheckExtPrefix		(xsltStylesheetPtr style, 
					 const xmlChar * URI)

+

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)

+
style:the stylesheet
URI:the namespace prefix (possibly NULL)
Returns:1 if this is an extension, 0 otherwise
+
+

xsltCheckExtURI ()

int	xsltCheckExtURI			(xsltStylesheetPtr style, 
					 const xmlChar * URI)

+

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)

+
style:the stylesheet
URI:the namespace URI (possibly NULL)
Returns:1 if this is an extension, 0 otherwise
+
+

xsltDebugDumpExtensions ()

void	xsltDebugDumpExtensions		(FILE * output)

+

Dumps a list of the registered XSLT extension functions and elements

+
output:the FILE * for the output, if NULL stdout is used
+
+

xsltExtElementLookup ()

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

+

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

+
ctxt:an XSLT process context
name:the element name
URI:the element namespace URI
Returns:the element callback or NULL if not found
+
+

xsltExtModuleElementLookup ()

xsltTransformFunction	xsltExtModuleElementLookup	(const xmlChar * name, 
							 const xmlChar * URI)

+

Looks up an extension module element

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

xsltExtModuleElementPreComputeLookup ()

xsltPreComputeFunction	xsltExtModuleElementPreComputeLookup	(const xmlChar * name, 
							 const xmlChar * URI)

+

Looks up an extension module element pre-computation function

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

xsltExtModuleFunctionLookup ()

xmlXPathFunction	xsltExtModuleFunctionLookup	(const xmlChar * name, 
							 const xmlChar * URI)

+

Looks up an extension module function

+
name:the function name
URI:the function namespace URI
Returns:the function if found, NULL otherwise.
+
+

xsltExtModuleTopLevelLookup ()

xsltTopLevelFunction	xsltExtModuleTopLevelLookup	(const xmlChar * name, 
							 const xmlChar * URI)

+

Looks up an extension module top-level element

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

xsltFreeCtxtExts ()

void	xsltFreeCtxtExts		(xsltTransformContextPtr ctxt)

+

Free the XSLT extension data

+
ctxt:an XSLT transformation context
+
+

xsltFreeExts ()

void	xsltFreeExts			(xsltStylesheetPtr style)

+

Free up the memory used by XSLT extensions in a stylesheet

+
style:an XSLT stylesheet
+
+

xsltGetExtData ()

void *	xsltGetExtData			(xsltTransformContextPtr ctxt, 
					 const xmlChar * URI)

+

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

+
ctxt:an XSLT transformation context
URI:the URI associated to the exension module
Returns:the pointer or NULL if not present
+
+

xsltGetExtInfo ()

xmlHashTablePtr	xsltGetExtInfo		(xsltStylesheetPtr style, 
					 const xmlChar * URI)

+

looks up URI in extInfos of the stylesheet

+
style:pointer to a stylesheet
URI:the namespace URI desired
Returns:a pointer to the hash table if found, else NULL
+
+

xsltInitCtxtExts ()

int	xsltInitCtxtExts		(xsltTransformContextPtr ctxt)

+

Initialize the set of modules with registered stylesheet data

+
ctxt:an XSLT transformation context
Returns:the number of modules initialized or -1 in case of error
+
+

xsltInitElemPreComp ()

void	xsltInitElemPreComp		(xsltElemPreCompPtr comp, 
					 xsltStylesheetPtr style, 
					 xmlNodePtr inst, 
					 xsltTransformFunction function, 
					 xsltElemPreCompDeallocator freeFunc)

+

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.

+
comp:an #xsltElemPreComp (or generally a derived structure)
style:the XSLT stylesheet
inst:the element node
function:the transform function
freeFunc:the @comp deallocator
+
+

xsltInitGlobals ()

void	xsltInitGlobals			(void)

+

Initialize the global variables for extensions

+
+
+

xsltNewElemPreComp ()

xsltElemPreCompPtr	xsltNewElemPreComp	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 xsltTransformFunction function)

+

Creates and initializes an #xsltElemPreComp

+
style:the XSLT stylesheet
inst:the element node
function:the transform function
Returns:the new and initialized #xsltElemPreComp
+
+

xsltPreComputeExtModuleElement ()

xsltElemPreCompPtr	xsltPreComputeExtModuleElement	(xsltStylesheetPtr style, 
							 xmlNodePtr inst)

+

Precomputes an extension module element

+
style:the stylesheet
inst:the element node
Returns:the precomputed data
+
+

xsltRegisterExtElement ()

int	xsltRegisterExtElement		(xsltTransformContextPtr ctxt, 
					 const xmlChar * name, 
					 const xmlChar * URI, 
					 xsltTransformFunction function)

+

Registers an extension element

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

xsltRegisterExtFunction ()

int	xsltRegisterExtFunction		(xsltTransformContextPtr ctxt, 
					 const xmlChar * name, 
					 const xmlChar * URI, 
					 xmlXPathFunction function)

+

Registers an extension function

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

xsltRegisterExtModule ()

int	xsltRegisterExtModule		(const xmlChar * URI, 
					 xsltExtInitFunction initFunc, 
					 xsltExtShutdownFunction shutdownFunc)

+

Register an XSLT extension module to the library.

+
URI:URI associated to this module
initFunc:the module initialization function
shutdownFunc:the module shutdown function
Returns:0 if sucessful, -1 in case of error
+
+

xsltRegisterExtModuleElement ()

int	xsltRegisterExtModuleElement	(const xmlChar * name, 
					 const xmlChar * URI, 
					 xsltPreComputeFunction precomp, 
					 xsltTransformFunction transform)

+

Registers an extension module element.

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

xsltRegisterExtModuleFull ()

int	xsltRegisterExtModuleFull	(const xmlChar * URI, 
					 xsltExtInitFunction initFunc, 
					 xsltExtShutdownFunction shutdownFunc, 
					 xsltStyleExtInitFunction styleInitFunc, 
					 xsltStyleExtShutdownFunction styleShutdownFunc)

+

Register an XSLT extension module to the library.

+
URI:URI associated to this module
initFunc:the module initialization function
shutdownFunc:the module shutdown function
styleInitFunc:the module initialization function
styleShutdownFunc:the module shutdown function
Returns:0 if sucessful, -1 in case of error
+
+

xsltRegisterExtModuleFunction ()

int	xsltRegisterExtModuleFunction	(const xmlChar * name, 
					 const xmlChar * URI, 
					 xmlXPathFunction function)

+

Registers an extension module function.

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

xsltRegisterExtModuleTopLevel ()

int	xsltRegisterExtModuleTopLevel	(const xmlChar * name, 
					 const xmlChar * URI, 
					 xsltTopLevelFunction function)

+

Registers an extension module top-level element.

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

xsltRegisterExtPrefix ()

int	xsltRegisterExtPrefix		(xsltStylesheetPtr style, 
					 const xmlChar * prefix, 
					 const xmlChar * URI)

+

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)

+
style:an XSLT stylesheet
prefix:the prefix used (optional)
URI:the URI associated to the extension
Returns:0 in case of success, 1 if the @URI was already registered as an extension namespace and -1 in case of failure
+
+

xsltRegisterTestModule ()

void	xsltRegisterTestModule		(void)

+

Registers the test module

+
+
+

xsltShutdownCtxtExts ()

void	xsltShutdownCtxtExts		(xsltTransformContextPtr ctxt)

+

Shutdown the set of modules loaded

+
ctxt:an XSLT transformation context
+
+

xsltShutdownExts ()

void	xsltShutdownExts		(xsltStylesheetPtr style)

+

Shutdown the set of modules loaded

+
style:an XSLT stylesheet
+
+

xsltStyleGetExtData ()

void *	xsltStyleGetExtData		(xsltStylesheetPtr style, 
					 const xmlChar * URI)

+

Retrieve the data associated to the extension module in this given stylesheet. Called by: xsltRegisterExtPrefix(), ( xsltExtElementPreCompTest(), xsltExtInitTest )

+
style:an XSLT stylesheet
URI:the URI associated to the exension module
Returns:the pointer or NULL if not present
+
+

xsltStyleStylesheetLevelGetExtData ()

void *	xsltStyleStylesheetLevelGetExtData	(xsltStylesheetPtr style, 
						 const xmlChar * URI)

+

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

+
style:an XSLT stylesheet
URI:the URI associated to the exension module
Returns:the pointer or NULL if not present
+
+

xsltUnregisterExtModule ()

int	xsltUnregisterExtModule		(const xmlChar * URI)

+

Unregister an XSLT extension module from the library.

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

xsltUnregisterExtModuleElement ()

int	xsltUnregisterExtModuleElement	(const xmlChar * name, 
					 const xmlChar * URI)

+

Unregisters an extension module element

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

xsltUnregisterExtModuleFunction ()

int	xsltUnregisterExtModuleFunction	(const xmlChar * name, 
					 const xmlChar * URI)

+

Unregisters an extension module function

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

xsltUnregisterExtModuleTopLevel ()

int	xsltUnregisterExtModuleTopLevel	(const xmlChar * name, 
					 const xmlChar * URI)

+

Unregisters an extension module top-level element

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

xsltXPathGetTransformContext ()

xsltTransformContextPtr	xsltXPathGetTransformContext	(xmlXPathParserContextPtr ctxt)

+

Provides the XSLT transformation context from the XPath transformation context. This is useful when an XPath function in the extension module is called by the XPath interpreter and that the XSLT context is needed for example to retrieve the associated data pertaining to this XSLT transformation.

+
ctxt:an XPath transformation context
Returns:the XSLT transformation context or NULL in case of error.
+
+
+
+ + diff --git a/doc/devhelp/libxslt-extra.html b/doc/devhelp/libxslt-extra.html new file mode 100644 index 00000000..72afc80a --- /dev/null +++ b/doc/devhelp/libxslt-extra.html @@ -0,0 +1,97 @@ + + + + + extra: interface for the non-standard features + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ extra +

+

extra - interface for the non-standard features

+

implement some extension outside the XSLT namespace but not EXSLT with is in a different library.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#define XSLT_XT_NAMESPACE;
+#define XSLT_XALAN_NAMESPACE;
+#define XSLT_SAXON_NAMESPACE;
+#define XSLT_LIBXSLT_NAMESPACE;
+void	xsltFunctionNodeSet		(xmlXPathParserContextPtr ctxt, 
					 int nargs);
+void	xsltRegisterExtras		(xsltTransformContextPtr ctxt);
+void	xsltDebug			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp);
+void	xsltRegisterAllExtras		(void);
+
+
+
+

Description

+
+
+

Details

+
+

Macro XSLT_LIBXSLT_NAMESPACE

#define XSLT_LIBXSLT_NAMESPACE;
+

This is the libxslt namespace for specific extensions.

+
+
+

Macro XSLT_SAXON_NAMESPACE

#define XSLT_SAXON_NAMESPACE;
+

This is Michael Kay's Saxon processor namespace for extensions.

+
+
+

Macro XSLT_XALAN_NAMESPACE

#define XSLT_XALAN_NAMESPACE;
+

This is the Apache project XALAN processor namespace for extensions.

+
+
+

Macro XSLT_XT_NAMESPACE

#define XSLT_XT_NAMESPACE;
+

This is James Clark's XT processor namespace for extensions.

+
+
+

xsltDebug ()

void	xsltDebug			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

Process an debug node

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

xsltFunctionNodeSet ()

void	xsltFunctionNodeSet		(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

Implement the node-set() XSLT function node-set node-set(result-tree) This function is available in libxslt, saxon or xt namespace.

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltRegisterAllExtras ()

void	xsltRegisterAllExtras		(void)

+

Registers the built-in extensions

+
+
+

xsltRegisterExtras ()

void	xsltRegisterExtras		(xsltTransformContextPtr ctxt)

+

Registers the built-in extensions. This function is deprecated, use xsltRegisterAllExtras instead.

+
ctxt:a XSLT process context
+
+
+
+ + diff --git a/doc/devhelp/libxslt-functions.html b/doc/devhelp/libxslt-functions.html new file mode 100644 index 00000000..767fbb2a --- /dev/null +++ b/doc/devhelp/libxslt-functions.html @@ -0,0 +1,112 @@ + + + + + functions: interface for the XSLT functions not from XPath + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ functions +

+

functions - interface for the XSLT functions not from XPath

+

a set of extra functions coming from XSLT but not in XPath

+

Author(s): Daniel Veillard and Bjorn Reese <breese@users.sourceforge.net>

+
+

Synopsis

+ 
#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	xsltGenerateIdFunction		(xmlXPathParserContextPtr ctxt, 
					 int nargs);
+
+
+
+

Description

+
+
+

Details

+
+

Macro XSLT_REGISTER_FUNCTION_LOOKUP

#define XSLT_REGISTER_FUNCTION_LOOKUP;
+

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

+
+
+

xsltDocumentFunction ()

void	xsltDocumentFunction		(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltElementAvailableFunction ()

void	xsltElementAvailableFunction	(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltFormatNumberFunction ()

void	xsltFormatNumberFunction	(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltFunctionAvailableFunction ()

void	xsltFunctionAvailableFunction	(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltGenerateIdFunction ()

void	xsltGenerateIdFunction		(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltKeyFunction ()

void	xsltKeyFunction			(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltRegisterAllFunctions ()

void	xsltRegisterAllFunctions	(xmlXPathContextPtr ctxt)

+

Registers all default XSLT functions in this context

+
ctxt:the XPath context
+
+

xsltSystemPropertyFunction ()

void	xsltSystemPropertyFunction	(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltUnparsedEntityURIFunction ()

void	xsltUnparsedEntityURIFunction	(xmlXPathParserContextPtr ctxt, 
					 int nargs)

+

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

+
ctxt:the XPath Parser context
nargs:the number of arguments
+
+

xsltXPathFunctionLookup ()

xmlXPathFunction	xsltXPathFunctionLookup	(void * vctxt, 
						 const xmlChar * name, 
						 const xmlChar * ns_uri)

+

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

+
vctxt:a void * but the XSLT transformation context actually
name:the function name
ns_uri:the function namespace URI
Returns:the callback function or NULL if not found
+
+
+
+ + diff --git a/doc/devhelp/libxslt-imports.html b/doc/devhelp/libxslt-imports.html new file mode 100644 index 00000000..6f37be63 --- /dev/null +++ b/doc/devhelp/libxslt-imports.html @@ -0,0 +1,97 @@ + + + + + imports: interface for the XSLT import support + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ imports +

+

imports - interface for the XSLT import support

+

macros and fuctions needed to implement and access the import tree

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#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);
+int	xsltFindElemSpaceHandling	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node);
+int	xsltParseStylesheetImport	(xsltStylesheetPtr style, 
					 xmlNodePtr cur);
+
+
+
+

Description

+
+
+

Details

+
+

Macro XSLT_GET_IMPORT_INT

#define XSLT_GET_IMPORT_INT;
+

A macro to import intergers from the stylesheet cascading order.

+
+
+

Macro XSLT_GET_IMPORT_PTR

#define XSLT_GET_IMPORT_PTR;
+

A macro to import pointers from the stylesheet cascading order.

+
+
+

xsltFindElemSpaceHandling ()

int	xsltFindElemSpaceHandling	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node)

+

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

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

xsltFindTemplate ()

xsltTemplatePtr	xsltFindTemplate	(xsltTransformContextPtr ctxt, 
					 const xmlChar * name, 
					 const xmlChar * nameURI)

+

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.

+
ctxt:an XSLT transformation context
name:the template name
nameURI:the template name URI
Returns:the xsltTemplatePtr or NULL if not found
+
+

xsltNeedElemSpaceHandling ()

int	xsltNeedElemSpaceHandling	(xsltTransformContextPtr ctxt)

+

Checks whether that stylesheet requires white-space stripping

+
ctxt:an XSLT transformation context
Returns:1 if space should be stripped, 0 if not
+
+

xsltNextImport ()

xsltStylesheetPtr	xsltNextImport	(xsltStylesheetPtr cur)

+

Find the next stylesheet in import precedence.

+
cur:the current XSLT stylesheet
Returns:the next stylesheet or NULL if it was the last one
+
+

xsltParseStylesheetImport ()

int	xsltParseStylesheetImport	(xsltStylesheetPtr style, 
					 xmlNodePtr cur)

+

parse an XSLT stylesheet import element

+
style:the XSLT stylesheet
cur:the import element
Returns:0 in case of success -1 in case of failure.
+
+

xsltParseStylesheetInclude ()

int	xsltParseStylesheetInclude	(xsltStylesheetPtr style, 
					 xmlNodePtr cur)

+

parse an XSLT stylesheet include element

+
style:the XSLT stylesheet
cur:the include node
Returns:0 in case of success -1 in case of failure
+
+
+
+ + diff --git a/doc/devhelp/libxslt-keys.html b/doc/devhelp/libxslt-keys.html new file mode 100644 index 00000000..59d50ba1 --- /dev/null +++ b/doc/devhelp/libxslt-keys.html @@ -0,0 +1,87 @@ + + + + + keys: interface for the key matching used in key() and template matches. + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ keys +

+

keys - interface for the key matching used in key() and template matches.

+

implementation of the key mechanims.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#define NODE_IS_KEYED;
+void	xsltInitCtxtKeys		(xsltTransformContextPtr ctxt, 
					 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);
+
+
+
+

Description

+
+
+

Details

+
+

Macro NODE_IS_KEYED

#define NODE_IS_KEYED;
+

check for bit 15 set

+
+
+

xsltAddKey ()

int	xsltAddKey			(xsltStylesheetPtr style, 
					 const xmlChar * name, 
					 const xmlChar * nameURI, 
					 const xmlChar * match, 
					 const xmlChar * use, 
					 xmlNodePtr inst)

+

add a key definition to a stylesheet

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

xsltFreeDocumentKeys ()

void	xsltFreeDocumentKeys		(xsltDocumentPtr idoc)

+

Free the keys associated to a document

+
idoc:a XSLT document
+
+

xsltFreeKeys ()

void	xsltFreeKeys			(xsltStylesheetPtr style)

+

Free up the memory used by XSLT keys in a stylesheet

+
style:an XSLT stylesheet
+
+

xsltGetKey ()

xmlNodeSetPtr	xsltGetKey		(xsltTransformContextPtr ctxt, 
					 const xmlChar * name, 
					 const xmlChar * nameURI, 
					 const xmlChar * value)

+

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.

+
ctxt:an XSLT transformation context
name:the key name or NULL
nameURI:the name URI or NULL
value:the key value to look for
Returns:the nodeset resulting from the query or NULL
+
+

xsltInitCtxtKeys ()

void	xsltInitCtxtKeys		(xsltTransformContextPtr ctxt, 
					 xsltDocumentPtr idoc)

+

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.

+
ctxt:an XSLT transformation context
idoc:a document info
+
+
+
+ + diff --git a/doc/devhelp/libxslt-namespaces.html b/doc/devhelp/libxslt-namespaces.html new file mode 100644 index 00000000..201ff74f --- /dev/null +++ b/doc/devhelp/libxslt-namespaces.html @@ -0,0 +1,97 @@ + + + + + namespaces: interface for the XSLT namespace handling + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ namespaces +

+

namespaces - interface for the XSLT namespace handling

+

set of function easing the processing and generation of namespace nodes in XSLT.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#define UNDEFINED_DEFAULT_NS;
+void	xsltFreeNamespaceAliasHashes	(xsltStylesheetPtr style);
+xmlNsPtr	xsltCopyNamespace	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr elem, 
					 xmlNsPtr ns);
+xmlNsPtr	xsltCopyNamespaceList	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNsPtr cur);
+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);
+void	xsltNamespaceAlias		(xsltStylesheetPtr style, 
					 xmlNodePtr node);
+
+
+
+

Description

+
+
+

Details

+
+

Macro UNDEFINED_DEFAULT_NS

#define UNDEFINED_DEFAULT_NS;
+

Special value for undefined namespace, internal

+
+
+

xsltCopyNamespace ()

xmlNsPtr	xsltCopyNamespace	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr elem, 
					 xmlNsPtr ns)

+

Copies a namespace node (declaration). If @elem is not NULL, then the new namespace will be declared on @elem.

+
ctxt:a transformation context
elem:the target element node
ns:the namespace node
Returns:a new xmlNsPtr, or NULL in case of an error.
+
+

xsltCopyNamespaceList ()

xmlNsPtr	xsltCopyNamespaceList	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNsPtr cur)

+

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.

+
ctxt:a transformation context
node:the target node
cur:the first namespace
Returns:a new xmlNsPtr, or NULL in case of error.
+
+

xsltFreeNamespaceAliasHashes ()

void	xsltFreeNamespaceAliasHashes	(xsltStylesheetPtr style)

+

Free up the memory used by namespaces aliases

+
style:an XSLT stylesheet
+
+

xsltGetNamespace ()

xmlNsPtr	xsltGetNamespace	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr cur, 
					 xmlNsPtr ns, 
					 xmlNodePtr out)

+

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)

+
ctxt:a transformation context
cur:the input node
ns:the namespace
out:the output node (or its parent)
Returns:a namespace declaration or NULL in case of namespace fixup failures or API or internal errors.
+
+

xsltGetPlainNamespace ()

xmlNsPtr	xsltGetPlainNamespace	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr cur, 
					 xmlNsPtr ns, 
					 xmlNodePtr out)

+

Obsolete. *Not* called by any Libxslt/Libexslt function. Exaclty the same as xsltGetNamespace().

+
ctxt:a transformation context
cur:the input node
ns:the namespace
out:the result element
Returns:a namespace declaration or NULL in case of namespace fixup failures or API or internal errors.
+
+

xsltGetSpecialNamespace ()

xmlNsPtr	xsltGetSpecialNamespace	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr invocNode, 
					 const xmlChar * nsName, 
					 const xmlChar * nsPrefix, 
					 xmlNodePtr target)

+

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="".

+
ctxt:the transformation context
invocNode:the invoking node; e.g. a literal result element/attr; only used for error reports
nsName:the namespace name (or NULL)
nsPrefix:the suggested namespace prefix (or NULL)
target:the result element on which to anchor a namespace
Returns:a namespace declaration or NULL.
+
+

xsltNamespaceAlias ()

void	xsltNamespaceAlias		(xsltStylesheetPtr style, 
					 xmlNodePtr node)

+

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

+
style:the XSLT stylesheet
node:the xsl:namespace-alias node
+
+
+
+ + diff --git a/doc/devhelp/libxslt-numbersInternals.html b/doc/devhelp/libxslt-numbersInternals.html new file mode 100644 index 00000000..ff892f5a --- /dev/null +++ b/doc/devhelp/libxslt-numbersInternals.html @@ -0,0 +1,101 @@ + + + + + numbersInternals: Implementation of the XSLT number functions + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ numbersInternals +

+

numbersInternals - Implementation of the XSLT number functions

+

Implementation of the XSLT number functions

+

Author(s): Bjorn Reese <breese@users.sourceforge.net> and Daniel Veillard

+
+

Synopsis

+ 
typedef struct _xsltFormatNumberInfo xsltFormatNumberInfo;
+typedef struct _xsltNumberData xsltNumberData;
+typedef xsltNumberData * xsltNumberDataPtr;
+typedef xsltFormatNumberInfo * xsltFormatNumberInfoPtr;
+
+
+
+

Description

+
+
+

Details

+
+

Structure xsltFormatNumberInfo

struct _xsltFormatNumberInfo {
+    int	integer_hash	: Number of '#' in integer part
+    int	integer_digits	: Number of '0' in integer part
+    int	frac_digits	: Number of '0' in fractional part
+    int	frac_hash	: Number of '#' in fractional part
+    int	group	: Number of chars per display 'group'
+    int	multiplier	: Scaling for percent or permille
+    char	add_decimal	: Flag for whether decimal point appears in pattern
+    char	is_multiplier_set	: Flag to catch multiple occurences of percent/permille
+    char	is_negative_pattern	: Flag for processing -ve prefix/suffix
+} xsltFormatNumberInfo;
+

+

+
+

Typedef xsltFormatNumberInfoPtr

xsltFormatNumberInfo * xsltFormatNumberInfoPtr;
+

+

+
+

Structure xsltNumberData

struct _xsltNumberData {
+    const xmlChar *	level
+    const xmlChar *	count
+    const xmlChar *	from
+    const xmlChar *	value
+    const xmlChar *	format
+    int	has_format
+    int	digitsPerGroup
+    int	groupingCharacter
+    int	groupingCharacterLen
+    xmlDocPtr	doc
+    xmlNodePtr	node
+    struct _xsltCompMatch *	countPat
+    struct _xsltCompMatch *	fromPat	: * accelerators *
+} xsltNumberData;
+

+

+
+

Typedef xsltNumberDataPtr

xsltNumberData * xsltNumberDataPtr;
+

+

+
+
+
+ + diff --git a/doc/devhelp/libxslt-pattern.html b/doc/devhelp/libxslt-pattern.html new file mode 100644 index 00000000..5c7187e3 --- /dev/null +++ b/doc/devhelp/libxslt-pattern.html @@ -0,0 +1,119 @@ + + + + + pattern: interface for the pattern matching used in template matches. + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ pattern +

+

pattern - interface for the pattern matching used in template matches.

+

the implementation of the lookup of the right template for a given node must be really fast in order to keep decent performances.

+

Author(s): Daniel Veillard

+
+

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	xsltCompMatchClearCache		(xsltTransformContextPtr ctxt, 
					 xsltCompMatchPtr comp);
+int	xsltTestCompMatchList		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xsltCompMatchPtr comp);
+void	xsltFreeCompMatchList		(xsltCompMatchPtr comp);
+void	xsltFreeTemplateHashes		(xsltStylesheetPtr style);
+void	xsltCleanupTemplates		(xsltStylesheetPtr style);
+
+
+
+

Description

+
+
+

Details

+
+

Structure xsltCompMatch

struct _xsltCompMatch {
+The content of this structure is not made public by the API.
+} xsltCompMatch;
+

+

+
+

Typedef xsltCompMatchPtr

xsltCompMatch * xsltCompMatchPtr;
+

+

+
+

xsltAddTemplate ()

int	xsltAddTemplate			(xsltStylesheetPtr style, 
					 xsltTemplatePtr cur, 
					 const xmlChar * mode, 
					 const xmlChar * modeURI)

+

Register the XSLT pattern associated to @cur

+
style:an XSLT stylesheet
cur:an XSLT template
mode:the mode name or NULL
modeURI:the mode URI or NULL
Returns:-1 in case of error, 0 otherwise
+
+

xsltCleanupTemplates ()

void	xsltCleanupTemplates		(xsltStylesheetPtr style)

+

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

+
style:an XSLT stylesheet
+
+

xsltCompMatchClearCache ()

void	xsltCompMatchClearCache		(xsltTransformContextPtr ctxt, 
					 xsltCompMatchPtr comp)

+

Clear pattern match cache.

+
ctxt:a XSLT process context
comp:the precompiled pattern list
+
+

xsltCompilePattern ()

xsltCompMatchPtr	xsltCompilePattern	(const xmlChar * pattern, 
						 xmlDocPtr doc, 
						 xmlNodePtr node, 
						 xsltStylesheetPtr style, 
						 xsltTransformContextPtr runtime)

+

Compile the XSLT pattern and generates a list of precompiled form suitable for fast matching. [1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern

+
pattern:an XSLT pattern
doc:the containing document
node:the containing element
style:the stylesheet
runtime:the transformation context, if done at run-time
Returns:the generated pattern list or NULL in case of failure
+
+

xsltFreeCompMatchList ()

void	xsltFreeCompMatchList		(xsltCompMatchPtr comp)

+

Free up the memory allocated by all the elements of @comp

+
comp:an XSLT comp list
+
+

xsltFreeTemplateHashes ()

void	xsltFreeTemplateHashes		(xsltStylesheetPtr style)

+

Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism

+
style:an XSLT stylesheet
+
+

xsltGetTemplate ()

xsltTemplatePtr	xsltGetTemplate		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xsltStylesheetPtr style)

+

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.

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

xsltMatchPattern ()

int	xsltMatchPattern		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 const xmlChar * pattern, 
					 xmlDocPtr ctxtdoc, 
					 xmlNodePtr ctxtnode)

+

+

ctxt:
node:
pattern:
ctxtdoc:
ctxtnode:
Returns:
+
+

xsltNormalizeCompSteps ()

void	xsltNormalizeCompSteps		(void * payload, 
					 void * data, 
					 const xmlChar * name)

+

This is a hashtable scanner function to normalize the compiled steps of an imported stylesheet.

+
payload:pointer to template hash table entry
data:pointer to the stylesheet
name:template match name
+
+

xsltTestCompMatchList ()

int	xsltTestCompMatchList		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xsltCompMatchPtr comp)

+

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

+
ctxt:a XSLT process context
node:a node
comp:the precompiled pattern list
Returns:1 if it matches, 0 if it doesn't and -1 in case of failure
+
+
+
+ + diff --git a/doc/devhelp/libxslt-preproc.html b/doc/devhelp/libxslt-preproc.html new file mode 100644 index 00000000..93dd848b --- /dev/null +++ b/doc/devhelp/libxslt-preproc.html @@ -0,0 +1,76 @@ + + + + + preproc: precomputing stylesheets + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ preproc +

+

preproc - precomputing stylesheets

+

this is the compilation phase, where most of the stylesheet is "compiled" into faster to use data.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
void	xsltFreeStylePreComps		(xsltStylesheetPtr style);
+xsltElemPreCompPtr	xsltDocumentComp	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 xsltTransformFunction function);
+void	xsltStylePreCompute		(xsltStylesheetPtr style, 
					 xmlNodePtr inst);
+
+
+
+

Description

+
+
+

Details

+
+

Variable xsltExtMarker

const xmlChar * xsltExtMarker;
+

+

+
+

xsltDocumentComp ()

xsltElemPreCompPtr	xsltDocumentComp	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 xsltTransformFunction function)

+

Pre process an XSLT-1.1 document element

+
style:the XSLT stylesheet
inst:the instruction in the stylesheet
function:unused
Returns:a precompiled data structure for the element
+
+

xsltFreeStylePreComps ()

void	xsltFreeStylePreComps		(xsltStylesheetPtr style)

+

Free up the memory allocated by all precomputed blocks

+
style:an XSLT transformation context
+
+

xsltStylePreCompute ()

void	xsltStylePreCompute		(xsltStylesheetPtr style, 
					 xmlNodePtr inst)

+

Precompute an XSLT stylesheet element

+
style:the XSLT stylesheet
inst:the instruction in the stylesheet
+
+
+
+ + diff --git a/doc/devhelp/libxslt-security.html b/doc/devhelp/libxslt-security.html new file mode 100644 index 00000000..87e73a83 --- /dev/null +++ b/doc/devhelp/libxslt-security.html @@ -0,0 +1,140 @@ + + + + + security: interface for the libxslt security framework + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ security +

+

security - interface for the libxslt security framework

+

the libxslt security framework allow to restrict the access to new resources (file or URL) from the stylesheet at runtime.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
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	xsltSecurityForbid		(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt, 
					 const char * value);
+
+
+
+

Description

+
+
+

Details

+
+

Enum xsltSecurityOption

enum xsltSecurityOption {
+    XSLT_SECPREF_READ_FILE = 1
+    XSLT_SECPREF_WRITE_FILE = 2
+    XSLT_SECPREF_CREATE_DIRECTORY = 3
+    XSLT_SECPREF_READ_NETWORK = 4
+    XSLT_SECPREF_WRITE_NETWORK = 5
+};
+

+

+
+

Structure xsltSecurityPrefs

struct _xsltSecurityPrefs {
+The content of this structure is not made public by the API.
+} xsltSecurityPrefs;
+

+

+
+

Typedef xsltSecurityPrefsPtr

xsltSecurityPrefs * xsltSecurityPrefsPtr;
+

+

+
+

Function type xsltSecurityCheck

int	xsltSecurityCheck		(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt, 
					 const char * value)

+

User provided function to check the value of a string like a file path or an URL ...

+
sec:
ctxt:
value:
Returns:
+
+

xsltCheckRead ()

int	xsltCheckRead			(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt, 
					 const xmlChar * URL)

+

Check if the resource is allowed to be read

+
sec:the security options
ctxt:an XSLT transformation context
URL:the resource to be read
Returns:1 if read is allowed, 0 if not and -1 in case or error.
+
+

xsltCheckWrite ()

int	xsltCheckWrite			(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt, 
					 const xmlChar * URL)

+

Check if the resource is allowed to be written, if necessary makes some preliminary work like creating directories

+
sec:the security options
ctxt:an XSLT transformation context
URL:the resource to be written
Returns:1 if write is allowed, 0 if not and -1 in case or error.
+
+

xsltFreeSecurityPrefs ()

void	xsltFreeSecurityPrefs		(xsltSecurityPrefsPtr sec)

+

Free up a security preference block

+
sec:the security block to free
+
+

xsltGetDefaultSecurityPrefs ()

xsltSecurityPrefsPtr	xsltGetDefaultSecurityPrefs	(void)

+

Get the default security preference application-wide

+
Returns:the current xsltSecurityPrefsPtr in use or NULL if none
+
+

xsltGetSecurityPrefs ()

xsltSecurityCheck	xsltGetSecurityPrefs	(xsltSecurityPrefsPtr sec, 
						 xsltSecurityOption option)

+

Lookup the security option to get the callback checking function

+
sec:the security block to update
option:the option to lookup
Returns:NULL if not found, the function otherwise
+
+

xsltNewSecurityPrefs ()

xsltSecurityPrefsPtr	xsltNewSecurityPrefs	(void)

+

Create a new security preference block

+
Returns:a pointer to the new block or NULL in case of error
+
+

xsltSecurityAllow ()

int	xsltSecurityAllow		(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt, 
					 const char * value)

+

Function used to always allow an operation

+
sec:the security block to use
ctxt:an XSLT transformation context
value:unused
Returns:1 always
+
+

xsltSecurityForbid ()

int	xsltSecurityForbid		(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt, 
					 const char * value)

+

Function used to always forbid an operation

+
sec:the security block to use
ctxt:an XSLT transformation context
value:unused
Returns:0 always
+
+

xsltSetCtxtSecurityPrefs ()

int	xsltSetCtxtSecurityPrefs	(xsltSecurityPrefsPtr sec, 
					 xsltTransformContextPtr ctxt)

+

Set the security preference for a specific transformation

+
sec:the security block to use
ctxt:an XSLT transformation context
Returns:-1 in case of error, 0 otherwise
+
+

xsltSetDefaultSecurityPrefs ()

void	xsltSetDefaultSecurityPrefs	(xsltSecurityPrefsPtr sec)

+

Set the default security preference application-wide

+
sec:the security block to use
+
+

xsltSetSecurityPrefs ()

int	xsltSetSecurityPrefs		(xsltSecurityPrefsPtr sec, 
					 xsltSecurityOption option, 
					 xsltSecurityCheck func)

+

Update the security option to use the new callback checking function

+
sec:the security block to update
option:the option to update
func:the user callback to use for this option
Returns:-1 in case of error, 0 otherwise
+
+
+
+ + diff --git a/doc/devhelp/libxslt-templates.html b/doc/devhelp/libxslt-templates.html new file mode 100644 index 00000000..ec89ded2 --- /dev/null +++ b/doc/devhelp/libxslt-templates.html @@ -0,0 +1,112 @@ + + + + + templates: interface for the template processing + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ templates +

+

templates - interface for the template processing

+

This set of routine encapsulates XPath calls and Attribute Value Templates evaluation.

+

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	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 *	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 *	xsltEvalXPathString	(xsltTransformContextPtr ctxt, 
					 xmlXPathCompExprPtr comp);
+
+
+
+

Description

+
+
+

Details

+
+

xsltAttrListTemplateProcess ()

xmlAttrPtr	xsltAttrListTemplateProcess	(xsltTransformContextPtr ctxt, 
						 xmlNodePtr target, 
						 xmlAttrPtr attrs)

+

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

+
ctxt:the XSLT transformation context
target:the element where the attributes will be grafted
attrs:the first attribute
Returns:a new list of attribute nodes, or NULL in case of error. (Don't assign the result to @target->properties; if the result is NULL, you'll get memory leaks, since the attributes will be disattached.)
+
+

xsltAttrTemplateProcess ()

xmlAttrPtr	xsltAttrTemplateProcess	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr target, 
					 xmlAttrPtr attr)

+

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

+
ctxt:the XSLT transformation context
target:the element where the attribute will be grafted
attr:the attribute node of a literal result element
Returns:the generated attribute node.
+
+

xsltAttrTemplateValueProcess ()

xmlChar *	xsltAttrTemplateValueProcess	(xsltTransformContextPtr ctxt, 
						 const xmlChar * str)

+

Process the given node and return the new string value.

+
ctxt:the XSLT transformation context
str:the attribute template node value
Returns:the computed string value or NULL, must be deallocated by the caller.
+
+

xsltAttrTemplateValueProcessNode ()

xmlChar *	xsltAttrTemplateValueProcessNode	(xsltTransformContextPtr ctxt, 
							 const xmlChar * str, 
							 xmlNodePtr inst)

+

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.

+
ctxt:the XSLT transformation context
str:the attribute template node value
inst:the instruction (or LRE) in the stylesheet holding the attribute with an AVT
Returns:the computed string value or NULL, must be deallocated by the caller.
+
+

xsltEvalAttrValueTemplate ()

xmlChar *	xsltEvalAttrValueTemplate	(xsltTransformContextPtr ctxt, 
						 xmlNodePtr inst, 
						 const xmlChar * name, 
						 const xmlChar * ns)

+

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.

+
ctxt:the XSLT transformation context
inst:the instruction (or LRE) in the stylesheet holding the attribute with an AVT
name:the attribute QName
ns:the attribute namespace URI
Returns:the computed string value or NULL, must be deallocated by the caller.
+
+

xsltEvalStaticAttrValueTemplate ()

const xmlChar *	xsltEvalStaticAttrValueTemplate	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 const xmlChar * name, 
						 const xmlChar * ns, 
						 int * found)

+

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

+
style:the XSLT stylesheet
inst:the instruction (or LRE) in the stylesheet holding the attribute with an AVT
name:the attribute Name
ns:the attribute namespace URI
found:indicator whether the attribute is present
Returns:the static string value or NULL, must be deallocated by the caller.
+
+

xsltEvalTemplateString ()

xmlChar *	xsltEvalTemplateString	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst)

+

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.

+
ctxt:the XSLT transformation context
contextNode:the current node in the source tree
inst:the XSLT instruction (xsl:comment, xsl:processing-instruction)
Returns:the computed string value or NULL; it's up to the caller to free the result.
+
+

xsltEvalXPathPredicate ()

int	xsltEvalXPathPredicate		(xsltTransformContextPtr ctxt, 
					 xmlXPathCompExprPtr comp, 
					 xmlNsPtr * nsList, 
					 int nsNr)

+

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

+
ctxt:the XSLT transformation context
comp:the XPath compiled expression
nsList:the namespaces in scope
nsNr:the number of namespaces in scope
Returns:1 is the predicate was true, 0 otherwise
+
+

xsltEvalXPathString ()

xmlChar *	xsltEvalXPathString	(xsltTransformContextPtr ctxt, 
					 xmlXPathCompExprPtr comp)

+

Process the expression using XPath and get a string

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

xsltEvalXPathStringNs ()

xmlChar *	xsltEvalXPathStringNs	(xsltTransformContextPtr ctxt, 
					 xmlXPathCompExprPtr comp, 
					 int nsNr, 
					 xmlNsPtr * nsList)

+

Process the expression using XPath, allowing to pass a namespace mapping context and get a string

+
ctxt:the XSLT transformation context
comp:the compiled XPath expression
nsNr:the number of namespaces in the list
nsList:the list of in-scope namespaces to use
Returns:the computed string value or NULL, must be deallocated by the caller.
+
+

xsltTemplateProcess ()

xmlNodePtr *	xsltTemplateProcess	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node)

+

Obsolete. Don't use it.

+
ctxt:the XSLT transformation context
node:the attribute template node
Returns:NULL.
+
+
+
+ + diff --git a/doc/devhelp/libxslt-transform.html b/doc/devhelp/libxslt-transform.html new file mode 100644 index 00000000..d6ecef6e --- /dev/null +++ b/doc/devhelp/libxslt-transform.html @@ -0,0 +1,227 @@ + + + + + transform: the XSLT engine transformation part. + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ transform +

+

transform - the XSLT engine transformation part.

+

This module implements the bulk of the actual

+

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	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);
+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	xsltComment			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp);
+
+
+
+

Description

+
+
+

Details

+
+

xslHandleDebugger ()

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

+

If either cur or node are a breakpoint, or xslDebugStatus in state where debugging must occcur at this time then transfer control to the xslDebugBreak function

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

xsltApplyImports ()

void	xsltApplyImports		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

Process the XSLT apply-imports element.

+
ctxt:an XSLT transformation context
contextNode:the current node in the source tree.
inst:the element node of the XSLT 'apply-imports' instruction
comp:the compiled instruction
+
+

xsltApplyOneTemplate ()

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

+

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)

+
ctxt:a XSLT process context
contextNode:the node in the source tree.
list:the nodes of a sequence constructor
templ:not used
params:a set of parameters (xsl:param) or NULL
+
+

xsltApplyStripSpaces ()

void	xsltApplyStripSpaces		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node)

+

Strip the unwanted ignorable spaces from the input tree

+
ctxt:a XSLT process context
node:the root of the XML tree
+
+

xsltApplyStylesheet ()

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

+

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

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

xsltApplyStylesheetUser ()

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

+

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

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

xsltApplyTemplates ()

void	xsltApplyTemplates		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Processes the XSLT 'apply-templates' instruction on the current node.

+
ctxt:a XSLT transformation context
node:the 'current node' in the source tree
inst:the element node of an XSLT 'apply-templates' instruction
castedComp:the compiled instruction
+
+

xsltAttribute ()

void	xsltAttribute			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the xslt attribute node on the source node

+
ctxt:a XSLT process context
contextNode:the current node in the source tree
inst:the xsl:attribute element
castedComp:precomputed information
+
+

xsltCallTemplate ()

void	xsltCallTemplate		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Processes the XSLT call-template instruction on the source node.

+
ctxt:a XSLT transformation context
node:the "current node" in the source tree
inst:the XSLT 'call-template' instruction
castedComp:the compiled information of the instruction
+
+

xsltChoose ()

void	xsltChoose			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

Processes the xsl:choose instruction on the source node.

+
ctxt:a XSLT process context
contextNode:the current node in the source tree
inst:the xsl:choose instruction
comp:compiled information of the instruction
+
+

xsltComment ()

void	xsltComment			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

Process the xslt comment node on the source node

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

xsltCopy ()

void	xsltCopy			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Execute the XSLT-copy instruction on the source node.

+
ctxt:an XSLT process context
node:the node in the source tree
inst:the element node of the XSLT-copy instruction
castedComp:computed information of the XSLT-copy instruction
+
+

xsltCopyOf ()

void	xsltCopyOf			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the XSLT copy-of instruction.

+
ctxt:an XSLT transformation context
node:the current node in the source tree
inst:the element node of the XSLT copy-of instruction
castedComp:precomputed information of the XSLT copy-of instruction
+
+

xsltCopyTextString ()

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

+

Adds @string to a newly created or an existent text node child of @target.

+
ctxt:a XSLT process context
target:the element where the text will be attached
string:the text string
noescape:should disable-escaping be activated for this text node.
Returns:the text node, where the text content of @cur is copied to. NULL in case of API or internal errors.
+
+

xsltDocumentElem ()

void	xsltDocumentElem		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process an EXSLT/XSLT-1.1 document element

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

xsltElement ()

void	xsltElement			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the xslt element node on the source node

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

xsltForEach ()

void	xsltForEach			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the xslt for-each node on the source node

+
ctxt:an XSLT transformation context
contextNode:the "current node" in the source tree
inst:the element node of the xsl:for-each instruction
castedComp:the compiled information of the instruction
+
+

xsltFreeTransformContext ()

void	xsltFreeTransformContext	(xsltTransformContextPtr ctxt)

+

Free up the memory allocated by @ctxt

+
ctxt:an XSLT parser context
+
+

xsltGetXIncludeDefault ()

int	xsltGetXIncludeDefault		(void)

+

Provides the default state for XInclude processing

+
Returns:0 if there is no processing 1 otherwise
+
+

xsltIf ()

void	xsltIf			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Processes the xsl:if instruction on the source node.

+
ctxt:a XSLT process context
contextNode:the current node in the source tree
inst:the xsl:if instruction
castedComp:compiled information of the instruction
+
+

xsltLocalVariablePop ()

void	xsltLocalVariablePop		(xsltTransformContextPtr ctxt, 
					 int limitNr, 
					 int level)

+

Pops all variable values at the given @depth from the stack.

+
ctxt:the transformation context
limitNr:number of variables which should remain
level:the depth in the xsl:template's tree
+
+

xsltLocalVariablePush ()

int	xsltLocalVariablePush		(xsltTransformContextPtr ctxt, 
					 xsltStackElemPtr variable, 
					 int level)

+

Places the variable onto the local variable stack

+
ctxt:the transformation context
variable:variable to be pushed to the variable stack
level:new value for variable's level
Returns:0 for success, -1 for any error **NOTE:** This is an internal routine and should not be called by users!
+
+

xsltNewTransformContext ()

xsltTransformContextPtr	xsltNewTransformContext	(xsltStylesheetPtr style, 
						 xmlDocPtr doc)

+

Create a new XSLT TransformContext

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

xsltNumber ()

void	xsltNumber			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the xslt number node on the source node

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

xsltProcessOneNode ()

void	xsltProcessOneNode		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xsltStackElemPtr withParams)

+

Process the source node.

+
ctxt:a XSLT process context
contextNode:the "current node" in the source tree
withParams:extra parameters (e.g. xsl:with-param) passed to the template if any
+
+

xsltProcessingInstruction ()

void	xsltProcessingInstruction	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the xslt processing-instruction node on the source node

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

xsltProfileStylesheet ()

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

+

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

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

xsltRegisterAllElement ()

void	xsltRegisterAllElement		(xsltTransformContextPtr ctxt)

+

Registers all default XSLT elements in this context

+
ctxt:the XPath context
+
+

xsltRunStylesheet ()

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

+

Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8

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

xsltRunStylesheetUser ()

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

+

Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8

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

xsltSetXIncludeDefault ()

void	xsltSetXIncludeDefault		(int xinclude)

+

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

+
xinclude:whether to do XInclude processing
+
+

xsltSort ()

void	xsltSort			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

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

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

xsltText ()

void	xsltText			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

Process the xslt text node on the source node

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

xsltValueOf ()

void	xsltValueOf			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr castedComp)

+

Process the xslt value-of node on the source node

+
ctxt:a XSLT process context
node:the node in the source tree.
inst:the xslt value-of node
castedComp:precomputed information
+
+
+
+ + diff --git a/doc/devhelp/libxslt-variables.html b/doc/devhelp/libxslt-variables.html new file mode 100644 index 00000000..628ab55d --- /dev/null +++ b/doc/devhelp/libxslt-variables.html @@ -0,0 +1,147 @@ + + + + + variables: interface for the variable matching and lookup. + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ variables +

+

variables - interface for the variable matching and lookup.

+

interface for the variable matching and lookup.

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#define XSLT_REGISTER_VARIABLE_LOOKUP;
+#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);
+void	xsltParseStylesheetParam	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr cur);
+xmlXPathObjectPtr	xsltVariableLookup	(xsltTransformContextPtr ctxt, 
						 const xmlChar * name, 
						 const xmlChar * ns_uri);
+
+
+
+

Description

+
+
+

Details

+
+

Macro XSLT_REGISTER_VARIABLE_LOOKUP

#define XSLT_REGISTER_VARIABLE_LOOKUP;
+

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

+
+
+

Macro XSLT_RVT_FUNC_RESULT

#define XSLT_RVT_FUNC_RESULT;
+

RVT is part of results returned with func:result. The RVT won't be destroyed after exiting a template and will be reset to XSLT_RVT_LOCAL or XSLT_RVT_VARIABLE in the template that receives the return value.

+
+
+

Macro XSLT_RVT_GLOBAL

#define XSLT_RVT_GLOBAL;
+

RVT is part of a global variable.

+
+
+

Macro XSLT_RVT_LOCAL

#define XSLT_RVT_LOCAL;
+

RVT is destroyed after the current instructions ends.

+
+
+

xsltAddStackElemList ()

int	xsltAddStackElemList		(xsltTransformContextPtr ctxt, 
					 xsltStackElemPtr elems)

+

Push an element list onto the stack.

+
ctxt:xn XSLT transformation context
elems:a stack element list
Returns:0 in case of success, -1 in case of failure.
+
+

xsltEvalGlobalVariables ()

int	xsltEvalGlobalVariables		(xsltTransformContextPtr ctxt)

+

Evaluates all global variables and parameters of a stylesheet. For internal use only. This is called at start of a transformation.

+
ctxt:the XSLT transformation context
Returns:0 in case of success, -1 in case of error
+
+

xsltEvalOneUserParam ()

int	xsltEvalOneUserParam		(xsltTransformContextPtr ctxt, 
					 const xmlChar * name, 
					 const xmlChar * value)

+

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.

+
ctxt:the XSLT transformation context
name:a null terminated string giving the name of the parameter
value:a null terminated string giving the XPath expression to be evaluated
Returns:0 in case of success, -1 in case of error.
+
+

xsltEvalUserParams ()

int	xsltEvalUserParams		(xsltTransformContextPtr ctxt, 
					 const char ** params)

+

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.

+
ctxt:the XSLT transformation context
params:a NULL terminated array of parameters name/value tuples
Returns:0 in case of success, -1 in case of error
+
+

xsltFreeGlobalVariables ()

void	xsltFreeGlobalVariables		(xsltTransformContextPtr ctxt)

+

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

+
ctxt:the XSLT transformation context
+
+

xsltParseGlobalParam ()

void	xsltParseGlobalParam		(xsltStylesheetPtr style, 
					 xmlNodePtr cur)

+

parse an XSLT transformation param declaration and record its value.

+
style:the XSLT stylesheet
cur:the "param" element
+
+

xsltParseGlobalVariable ()

void	xsltParseGlobalVariable		(xsltStylesheetPtr style, 
					 xmlNodePtr cur)

+

Parses a global XSLT 'variable' declaration at compilation time and registers it

+
style:the XSLT stylesheet
cur:the "variable" element
+
+

xsltParseStylesheetCallerParam ()

xsltStackElemPtr	xsltParseStylesheetCallerParam	(xsltTransformContextPtr ctxt, 
							 xmlNodePtr inst)

+

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

+
ctxt:the XSLT transformation context
inst:the xsl:with-param instruction element
Returns:the new xsltStackElemPtr or NULL
+
+

xsltParseStylesheetParam ()

void	xsltParseStylesheetParam	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr cur)

+

Registers a local XSLT 'param' declaration at transformation time and evaluates its value.

+
ctxt:the XSLT transformation context
cur:the XSLT 'param' element
+
+

xsltParseStylesheetVariable ()

void	xsltParseStylesheetVariable	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr inst)

+

Registers a local XSLT 'variable' instruction at transformation time and evaluates its value.

+
ctxt:the XSLT transformation context
inst:the xsl:variable instruction element
+
+

xsltQuoteOneUserParam ()

int	xsltQuoteOneUserParam		(xsltTransformContextPtr ctxt, 
					 const xmlChar * name, 
					 const xmlChar * value)

+

This is normally called from xsltQuoteUserParams to process a single parameter from a list of parameters. The @value is stored in the context's global variable/parameter hash table.

+
ctxt:the XSLT transformation context
name:a null terminated string giving the name of the parameter
value:a null terminated string giving the parameter value
Returns:0 in case of success, -1 in case of error.
+
+

xsltQuoteUserParams ()

int	xsltQuoteUserParams		(xsltTransformContextPtr ctxt, 
					 const char ** params)

+

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.

+
ctxt:the XSLT transformation context
params:a NULL terminated arry of parameters names/values tuples
Returns:0 in case of success, -1 in case of error.
+
+

xsltVariableLookup ()

xmlXPathObjectPtr	xsltVariableLookup	(xsltTransformContextPtr ctxt, 
						 const xmlChar * name, 
						 const xmlChar * ns_uri)

+

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

+
ctxt:the XSLT transformation context
name:the variable name
ns_uri:the variable namespace URI
Returns:the value or NULL if not found
+
+

xsltXPathVariableLookup ()

xmlXPathObjectPtr	xsltXPathVariableLookup	(void * ctxt, 
						 const xmlChar * name, 
						 const xmlChar * ns_uri)

+

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

+
ctxt:a void * but the the XSLT transformation context actually
name:the variable name
ns_uri:the variable namespace URI
Returns:the value or NULL if not found
+
+
+
+ + diff --git a/doc/devhelp/libxslt-xslt.html b/doc/devhelp/libxslt-xslt.html new file mode 100644 index 00000000..aed8eb06 --- /dev/null +++ b/doc/devhelp/libxslt-xslt.html @@ -0,0 +1,112 @@ + + + + + xslt: Interfaces, constants and types related to the XSLT engine + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ xslt +

+

xslt - Interfaces, constants and types related to the XSLT engine

+

Interfaces, constants and types related to the XSLT engine

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#define XSLT_DEFAULT_VERSION;
+#define XSLT_DEFAULT_VENDOR;
+#define XSLT_PARSE_OPTIONS;
+#define XSLT_DEFAULT_URL;
+#define XSLT_NAMESPACE;
+void	xsltCleanupGlobals		(void);
+void	xsltInit			(void);
+
+
+
+

Description

+
+
+

Details

+
+

Macro XSLT_DEFAULT_URL

#define XSLT_DEFAULT_URL;
+

The XSLT "vendor" URL for this processor.

+
+
+

Macro XSLT_DEFAULT_VENDOR

#define XSLT_DEFAULT_VENDOR;
+

The XSLT "vendor" string for this processor.

+
+
+

Macro XSLT_DEFAULT_VERSION

#define XSLT_DEFAULT_VERSION;
+

The default version of XSLT supported.

+
+
+

Macro XSLT_NAMESPACE

#define XSLT_NAMESPACE;
+

The XSLT specification namespace.

+
+
+

Macro XSLT_PARSE_OPTIONS

#define XSLT_PARSE_OPTIONS;
+

The set of options to pass to an xmlReadxxx when loading files for XSLT consumption.

+
+
+

Variable xsltEngineVersion

const char * xsltEngineVersion;
+

+

+
+

Variable xsltLibxmlVersion

const int xsltLibxmlVersion;
+

+

+
+

Variable xsltLibxsltVersion

const int xsltLibxsltVersion;
+

+

+
+

Variable xsltMaxDepth

int xsltMaxDepth;
+

+

+
+

Variable xsltMaxVars

int xsltMaxVars;
+

+

+
+

xsltCleanupGlobals ()

void	xsltCleanupGlobals		(void)

+

Unregister all global variables set up by the XSLT library

+
+
+

xsltInit ()

void	xsltInit			(void)

+

Initializes the processor (e.g. registers built-in extensions, etc.)

+
+
+
+
+ + diff --git a/doc/devhelp/libxslt-xsltInternals.html b/doc/devhelp/libxslt-xsltInternals.html new file mode 100644 index 00000000..504198c5 --- /dev/null +++ b/doc/devhelp/libxslt-xsltInternals.html @@ -0,0 +1,1426 @@ + + + + + xsltInternals: internal data structures, constants and functions + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ xsltInternals +

+

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

+

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_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;
+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 struct _xsltDecimalFormat xsltDecimalFormat;
+typedef xsltStyleItemApplyTemplates * xsltStyleItemApplyTemplatesPtr;
+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 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);
+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);
+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);
+xmlChar *	xsltEvalAVT		(xsltTransformContextPtr ctxt, 
					 void * avt, 
					 xmlNodePtr node);
+void	xsltPointerListClear		(xsltPointerListPtr list);
+xsltStylesheetPtr	xsltLoadStylesheetPI	(xmlDocPtr doc);
+
+
+
+

Description

+
+
+

Details

+
+

Macro CHECK_STOPPED

#define CHECK_STOPPED;
+

Macro to check if the XSLT processing should be stopped. Will return from the function.

+
+
+

Macro CHECK_STOPPED0

#define CHECK_STOPPED0;
+

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

+
+
+

Macro CHECK_STOPPEDE

#define CHECK_STOPPEDE;
+

Macro to check if the XSLT processing should be stopped. Will goto the error: label.

+
+
+

Macro IS_XSLT_ATTR_FAST

#define IS_XSLT_ATTR_FAST;
+

quick check for xslt namespace attribute

+
+
+

Macro IS_XSLT_ELEM_FAST

#define IS_XSLT_ELEM_FAST;
+

quick check whether this is an xslt element

+
+
+

Macro XML_CAST_FPTR

#define XML_CAST_FPTR(fptr);
+

Macro to do a casting from an object pointer to a function pointer without encountering a warning from gcc #define XML_CAST_FPTR(fptr) (*(void **)(&fptr)) This macro violated ISO C aliasing rules (gcc4 on s390 broke) so it is disabled now

fptr:pointer to a function
+
+
+

Macro XSLT_CCTXT

#define XSLT_CCTXT;
+

get pointer to compiler context

+
+
+

Macro XSLT_FAST_IF

#define XSLT_FAST_IF;
+

Internal define to enable usage of xmlXPathCompiledEvalToBoolean() for XSLT "tests"; e.g. in <xsl:if test="/foo/bar">

+
+
+

Macro XSLT_GET_INTERNAL_NSMAP

#define XSLT_GET_INTERNAL_NSMAP;
+

get pointer to namespace map

+
+
+

Macro XSLT_HAS_INTERNAL_NSMAP

#define XSLT_HAS_INTERNAL_NSMAP;
+

check for namespace mapping

+
+
+

Macro XSLT_IS_RES_TREE_FRAG

#define XSLT_IS_RES_TREE_FRAG;
+

internal macro to test tree fragments

+
+
+

Macro XSLT_IS_TEXT_NODE

#define XSLT_IS_TEXT_NODE;
+

check if the argument is a text node

+
+
+

Macro XSLT_ITEM_COMMON_FIELDS

#define XSLT_ITEM_COMMON_FIELDS;
+

Common fields used for all items.

+
+
+

Macro XSLT_ITEM_COMPATIBILITY_FIELDS

#define XSLT_ITEM_COMPATIBILITY_FIELDS;
+

Fields for API compatibility to the structure _xsltElemPreComp which is used for extension functions. Note that @next is used for storage; it does not reflect a next sibling in the tree. TODO: Evaluate if we really need such a compatibility.

+
+
+

Macro XSLT_ITEM_NAVIGATION_FIELDS

#define XSLT_ITEM_NAVIGATION_FIELDS;
+

Currently empty. TODO: It is intended to hold navigational fields in the future.

+
+
+

Macro XSLT_ITEM_NSINSCOPE_FIELDS

#define XSLT_ITEM_NSINSCOPE_FIELDS;
+

The in-scope namespaces.

+
+
+

Macro XSLT_MARK_RES_TREE_FRAG

#define XSLT_MARK_RES_TREE_FRAG;
+

internal macro to set up tree fragments

+
+
+

Macro XSLT_MAX_SORT

#define XSLT_MAX_SORT;
+

Max number of specified xsl:sort on an element.

+
+
+

Macro XSLT_PAT_NO_PRIORITY

#define XSLT_PAT_NO_PRIORITY;
+

Specific value for pattern without priority expressed.

+
+
+

Macro XSLT_REFACTORED_KEYCOMP

#define XSLT_REFACTORED_KEYCOMP;
+

Internal define to enable on-demand xsl:key computation. That's the only mode now but the define is kept for compatibility

+
+
+

Macro XSLT_REFACTORED_VARS

#define XSLT_REFACTORED_VARS;
+

Internal define to enable the refactored variable part of libxslt

+
+
+

Macro XSLT_RUNTIME_EXTRA

#define XSLT_RUNTIME_EXTRA(ctxt, nr);
+

Macro used to define extra information stored in the context

ctxt:the transformation context
nr:the index
+
+
+

Macro XSLT_RUNTIME_EXTRA_FREE

#define XSLT_RUNTIME_EXTRA_FREE(ctxt, nr);
+

Macro used to free extra information stored in the context

ctxt:the transformation context
nr:the index
+
+
+

Macro XSLT_RUNTIME_EXTRA_LST

#define XSLT_RUNTIME_EXTRA_LST(ctxt, nr);
+

Macro used to access extra information stored in the context

ctxt:the transformation context
nr:the index
+
+
+

Structure xsltCompilerCtxt

struct _xsltCompilerCtxt {
+    void *	errorCtxt	: * used for error/warning reports; e.g. XSLT_ERROR_SEVERITY_WARNING
+    xsltErrorSeverityType	errSeverity
+    int	warnings	: TODO: number of warnings found at compilation
+    int	errors	: TODO: number of errors found at compilation
+    xmlDictPtr	dict
+    xsltStylesheetPtr	style
+    int	simplified	: whether this is a simplified stylesheet TODO: structured/unstructured
+    int	depth	: Current depth of processing
+    xsltCompilerNodeInfoPtr	inode
+    xsltCompilerNodeInfoPtr	inodeList
+    xsltCompilerNodeInfoPtr	inodeLast
+    xsltPointerListPtr	tmpList	: * The XSLT version as specified by the stylesheet's root element. *
+    int	isInclude
+    int	hasForwardsCompat	: whether forwards-compatible mode was used in a parsing episode
+    int	maxNodeInfos	: TEMP TODO: just for the interest
+    int	maxLREs	: * In order to keep the old behaviour, applying strict rules of * the s
+    int	strict
+    xsltPrincipalStylesheetDataPtr	psData
+    xsltStyleItemUknownPtr	unknownItem
+    int	hasNsAliases	: Indicator if there was an xsl:namespace-alias.
+    xsltNsAliasPtr	nsAliases
+    xsltVarInfoPtr	ivars	: Storage of local in-scope variables/params.
+    xsltVarInfoPtr	ivar	: topmost local variable/param.
+} xsltCompilerCtxt;
+

+

+
+

Typedef xsltCompilerCtxtPtr

xsltCompilerCtxt * xsltCompilerCtxtPtr;
+

+

+
+

Structure xsltCompilerNodeInfo

struct _xsltCompilerNodeInfo {
+    xsltCompilerNodeInfoPtr	next
+    xsltCompilerNodeInfoPtr	prev
+    xmlNodePtr	node
+    int	depth
+    xsltTemplatePtr	templ	: The owning template
+    int	category	: XSLT element, LR-element or extension element
+    xsltStyleType	type
+    xsltElemPreCompPtr	item	: The compiled information The current in-scope namespaces
+    xsltNsListContainerPtr	inScopeNs	: The current excluded result namespaces
+    xsltPointerListPtr	exclResultNs	: The current extension instruction namespaces
+    xsltPointerListPtr	extElemNs	: The current info for literal result elements.
+    xsltStyleItemLRElementInfoPtr	litResElemInfo	: * Set to 1 if in-scope namespaces changed, * or excluded result names
+    int	nsChanged
+    int	preserveWhitespace
+    int	stripWhitespace
+    int	isRoot	: whether this is the stylesheet's root node
+    int	forwardsCompat	: whether forwards-compatible mode is enabled whether the content of an
+    int	extContentHandled	: the type of the current child
+    xsltStyleType	curChildType
+} xsltCompilerNodeInfo;
+

+

+
+

Typedef xsltCompilerNodeInfoPtr

xsltCompilerNodeInfo * xsltCompilerNodeInfoPtr;
+

+

+
+

Structure xsltDecimalFormat

struct _xsltDecimalFormat {
+    struct _xsltDecimalFormat *	next	: chained list
+    xmlChar *	name	: Used for interpretation of pattern
+    xmlChar *	digit
+    xmlChar *	patternSeparator	: May appear in result
+    xmlChar *	minusSign
+    xmlChar *	infinity
+    xmlChar *	noNumber	: Not-a-number Used for interpretation of pattern and may appear in res
+    xmlChar *	decimalPoint
+    xmlChar *	grouping
+    xmlChar *	percent
+    xmlChar *	permille
+    xmlChar *	zeroDigit
+    const xmlChar *	nsUri
+} xsltDecimalFormat;
+

+

+
+

Typedef xsltDecimalFormatPtr

xsltDecimalFormat * xsltDecimalFormatPtr;
+

+

+
+

Structure xsltDocument

struct _xsltDocument {
+    struct _xsltDocument *	next	: documents are kept in a chained list
+    int	main	: is this the main document
+    xmlDocPtr	doc	: the parsed document
+    void *	keys	: key tables storage
+    struct _xsltDocument *	includes	: subsidiary includes
+    int	preproc	: pre-processing already done
+    int	nbKeysComputed
+} xsltDocument;
+

+

+
+

Typedef xsltDocumentPtr

xsltDocument * xsltDocumentPtr;
+

+

+
+

Structure xsltEffectiveNs

struct _xsltEffectiveNs {
+    xsltEffectiveNsPtr	nextInStore	: storage next
+    xsltEffectiveNsPtr	next	: next item in the list
+    const xmlChar *	prefix
+    const xmlChar *	nsName	: * Indicates if eclared on the literal result element; dunno if really
+    int	holdByElem
+} xsltEffectiveNs;
+

+

+
+

Typedef xsltEffectiveNsPtr

xsltEffectiveNs * xsltEffectiveNsPtr;
+

+

+
+

Structure xsltElemPreComp

struct _xsltElemPreComp {
+    xsltElemPreCompPtr	next	: next item in the global chained list held by xsltStylesheet.
+    xsltStyleType	type	: type of the element
+    xsltTransformFunction	func	: handling function
+    xmlNodePtr	inst	: the node in the stylesheet's tree corresponding to this item end of c
+    xsltElemPreCompDeallocator	free	: the deallocator
+} xsltElemPreComp;
+

+

+
+

Typedef xsltElemPreCompPtr

xsltElemPreComp * xsltElemPreCompPtr;
+

+

+
+

Enum xsltErrorSeverityType

enum xsltErrorSeverityType {
+    XSLT_ERROR_SEVERITY_ERROR = 0
+    XSLT_ERROR_SEVERITY_WARNING = 1
+};
+

+

+
+

Structure xsltKeyDef

struct _xsltKeyDef {
+    struct _xsltKeyDef *	next
+    xmlNodePtr	inst
+    xmlChar *	name
+    xmlChar *	nameURI
+    xmlChar *	match
+    xmlChar *	use
+    xmlXPathCompExprPtr	comp
+    xmlXPathCompExprPtr	usecomp
+    xmlNsPtr *	nsList	: the namespaces in scope
+    int	nsNr	: the number of namespaces in scope
+} xsltKeyDef;
+

+

+
+

Typedef xsltKeyDefPtr

xsltKeyDef * xsltKeyDefPtr;
+

+

+
+

Structure xsltKeyTable

struct _xsltKeyTable {
+    struct _xsltKeyTable *	next
+    xmlChar *	name
+    xmlChar *	nameURI
+    xmlHashTablePtr	keys
+} xsltKeyTable;
+

+

+
+

Typedef xsltKeyTablePtr

xsltKeyTable * xsltKeyTablePtr;
+

+

+
+

Structure xsltNsAlias

struct _xsltNsAlias {
+    xsltNsAliasPtr	next	: next in the list
+    xmlNsPtr	literalNs
+    xmlNsPtr	targetNs
+    xmlDocPtr	docOfTargetNs
+} xsltNsAlias;
+

+

+
+

Typedef xsltNsAliasPtr

xsltNsAlias * xsltNsAliasPtr;
+

+

+
+

Structure xsltNsList

struct _xsltNsList {
+    xsltNsListPtr	next	: next in the list
+    xmlNsPtr	ns
+} xsltNsList;
+

+

+
+

Structure xsltNsListContainer

struct _xsltNsListContainer {
+    xmlNsPtr *	list
+    int	totalNumber
+    int	xpathNumber
+} xsltNsListContainer;
+

+

+
+

Typedef xsltNsListContainerPtr

xsltNsListContainer * xsltNsListContainerPtr;
+

+

+
+

Typedef xsltNsListPtr

xsltNsList * xsltNsListPtr;
+

+

+
+

Structure xsltNsMap

struct _xsltNsMap {
+    xsltNsMapPtr	next	: next in the list
+    xmlDocPtr	doc
+    xmlNodePtr	elem	: the element holding the ns-decl
+    xmlNsPtr	ns	: the xmlNs structure holding the XML namespace name
+    const xmlChar *	origNsName	: the original XML namespace name
+    const xmlChar *	newNsName	: the mapped XML namespace name
+} xsltNsMap;
+

+

+
+

Typedef xsltNsMapPtr

xsltNsMap * xsltNsMapPtr;
+

+

+
+

Enum xsltOutputType

enum xsltOutputType {
+    XSLT_OUTPUT_XML = 0
+    XSLT_OUTPUT_HTML = 1
+    XSLT_OUTPUT_TEXT = 2
+};
+

+

+
+

Structure xsltPointerList

struct _xsltPointerList {
+    void **	items
+    int	number
+    int	size
+} xsltPointerList;
+

+

+
+

Typedef xsltPointerListPtr

xsltPointerList * xsltPointerListPtr;
+

+

+
+

Structure xsltPrincipalStylesheetData

struct _xsltPrincipalStylesheetData {
+    xmlDictPtr	namespaceDict	: * Global list of in-scope namespaces. *
+    xsltPointerListPtr	inScopeNamespaces	: * Global list of information for [xsl:]excluded-result-prefixes. *
+    xsltPointerListPtr	exclResultNamespaces	: * Global list of information for [xsl:]extension-element-prefixes. *
+    xsltPointerListPtr	extElemNamespaces
+    xsltEffectiveNsPtr	effectiveNs	: * Namespace name map to get rid of string comparison of namespace name
+    xsltNsMapPtr	nsMap
+} xsltPrincipalStylesheetData;
+

+

+
+

Typedef xsltPrincipalStylesheetDataPtr

xsltPrincipalStylesheetData * xsltPrincipalStylesheetDataPtr;
+

+

+
+

Structure xsltRuntimeExtra

struct _xsltRuntimeExtra {
+    void *	info	: pointer to the extra data
+    xmlFreeFunc	deallocate	: pointer to the deallocation routine
+} xsltRuntimeExtra;
+

+

+
+

Typedef xsltRuntimeExtraPtr

xsltRuntimeExtra * xsltRuntimeExtraPtr;
+

+

+
+

Structure xsltStackElem

struct _xsltStackElem {
+    struct _xsltStackElem *	next	: chained list
+    xsltStylePreCompPtr	comp	: the compiled form
+    int	computed	: was the evaluation done
+    const xmlChar *	name	: the local part of the name QName
+    const xmlChar *	nameURI	: the URI part of the name QName
+    const xmlChar *	select	: the eval string
+    xmlNodePtr	tree	: the sequence constructor if no eval string or the location
+    xmlXPathObjectPtr	value	: The value if computed
+    xmlDocPtr	fragment	: The Result Tree Fragments (needed for XSLT 1.0) which are bound to th
+    int	level	: the depth in the tree; -1 if persistent (e.g. a given xsl:with-param)
+    xsltTransformContextPtr	context	: The transformation context; needed to cache the variables
+    int	flags
+} xsltStackElem;
+

+

+
+

Typedef xsltStackElemPtr

xsltStackElem * xsltStackElemPtr;
+

+

+
+

Structure xsltStyleBasicEmptyItem

struct _xsltStyleBasicEmptyItem {
+The content of this structure is not made public by the API.
+} xsltStyleBasicEmptyItem;
+

+

+
+

Typedef xsltStyleBasicEmptyItemPtr

xsltStyleBasicEmptyItem * xsltStyleBasicEmptyItemPtr;
+

+

+
+

Structure xsltStyleBasicExpressionItem

struct _xsltStyleBasicExpressionItem {
+    const xmlChar *	select	: TODO: Change this to "expression".
+    xmlXPathCompExprPtr	comp	: TODO: Change this to compExpr.
+} xsltStyleBasicExpressionItem;
+

+

+
+

Typedef xsltStyleBasicExpressionItemPtr

xsltStyleBasicExpressionItem * xsltStyleBasicExpressionItemPtr;
+

+

+
+

Structure xsltStyleBasicItemVariable

struct _xsltStyleBasicItemVariable {
+    const xmlChar *	select
+    xmlXPathCompExprPtr	comp
+    const xmlChar *	name
+    int	has_name
+    const xmlChar *	ns
+    int	has_ns
+} xsltStyleBasicItemVariable;
+

+

+
+

Typedef xsltStyleBasicItemVariablePtr

xsltStyleBasicItemVariable * xsltStyleBasicItemVariablePtr;
+

+

+
+

Typedef xsltStyleItemApplyImports

xsltStyleBasicEmptyItem xsltStyleItemApplyImports;
+

+

+
+

Typedef xsltStyleItemApplyImportsPtr

xsltStyleItemApplyImports * xsltStyleItemApplyImportsPtr;
+

+

+
+

Structure xsltStyleItemApplyTemplates

struct _xsltStyleItemApplyTemplates {
+    const xmlChar *	mode	: apply-templates
+    const xmlChar *	modeURI	: apply-templates
+    const xmlChar *	select	: sort, copy-of, value-of, apply-templates
+    xmlXPathCompExprPtr	comp	: a precompiled XPath expression TODO: with-params
+} xsltStyleItemApplyTemplates;
+

+

+
+

Typedef xsltStyleItemApplyTemplatesPtr

xsltStyleItemApplyTemplates * xsltStyleItemApplyTemplatesPtr;
+

+

+
+

Structure xsltStyleItemAttribute

struct _xsltStyleItemAttribute {
+    const xmlChar *	name
+    int	has_name
+    const xmlChar *	ns
+    const xmlChar *	nsPrefix
+    int	has_ns
+} xsltStyleItemAttribute;
+

+

+
+

Typedef xsltStyleItemAttributePtr

xsltStyleItemAttribute * xsltStyleItemAttributePtr;
+

+

+
+

Structure xsltStyleItemCallTemplate

struct _xsltStyleItemCallTemplate {
+    xsltTemplatePtr	templ	: call-template
+    const xmlChar *	name	: element, attribute, pi
+    int	has_name	: element, attribute, pi
+    const xmlChar *	ns	: element
+    int	has_ns	: element TODO: with-params
+} xsltStyleItemCallTemplate;
+

+

+
+

Typedef xsltStyleItemCallTemplatePtr

xsltStyleItemCallTemplate * xsltStyleItemCallTemplatePtr;
+

+

+
+

Typedef xsltStyleItemChoose

xsltStyleBasicEmptyItem xsltStyleItemChoose;
+

+

+
+

Typedef xsltStyleItemChoosePtr

xsltStyleItemChoose * xsltStyleItemChoosePtr;
+

+

+
+

Typedef xsltStyleItemComment

xsltStyleBasicEmptyItem xsltStyleItemComment;
+

+

+
+

Typedef xsltStyleItemCommentPtr

xsltStyleItemComment * xsltStyleItemCommentPtr;
+

+

+
+

Structure xsltStyleItemCopy

struct _xsltStyleItemCopy {
+    const xmlChar *	use	: copy, element
+    int	has_use	: copy, element
+} xsltStyleItemCopy;
+

+

+
+

Typedef xsltStyleItemCopyOf

xsltStyleBasicExpressionItem xsltStyleItemCopyOf;
+

+

+
+

Typedef xsltStyleItemCopyOfPtr

xsltStyleItemCopyOf * xsltStyleItemCopyOfPtr;
+

+

+
+

Typedef xsltStyleItemCopyPtr

xsltStyleItemCopy * xsltStyleItemCopyPtr;
+

+

+
+

Structure xsltStyleItemDocument

struct _xsltStyleItemDocument {
+    int	ver11	: assigned: in xsltDocumentComp; read: nowhere; TODO: Check if we need.
+    const xmlChar *	filename	: document URL
+    int	has_filename
+} xsltStyleItemDocument;
+

+

+
+

Typedef xsltStyleItemDocumentPtr

xsltStyleItemDocument * xsltStyleItemDocumentPtr;
+

+

+
+

Structure xsltStyleItemElement

struct _xsltStyleItemElement {
+    const xmlChar *	use
+    int	has_use
+    const xmlChar *	name
+    int	has_name
+    const xmlChar *	ns
+    const xmlChar *	nsPrefix
+    int	has_ns
+} xsltStyleItemElement;
+

+

+
+

Typedef xsltStyleItemElementPtr

xsltStyleItemElement * xsltStyleItemElementPtr;
+

+

+
+

Structure xsltStyleItemExtElement

struct _xsltStyleItemExtElement {
+    xsltElemPreCompPtr	item
+} xsltStyleItemExtElement;
+

+

+
+

Typedef xsltStyleItemExtElementPtr

xsltStyleItemExtElement * xsltStyleItemExtElementPtr;
+

+

+
+

Typedef xsltStyleItemFallback

xsltStyleBasicEmptyItem xsltStyleItemFallback;
+

+

+
+

Typedef xsltStyleItemFallbackPtr

xsltStyleItemFallback * xsltStyleItemFallbackPtr;
+

+

+
+

Typedef xsltStyleItemForEach

xsltStyleBasicExpressionItem xsltStyleItemForEach;
+

+

+
+

Typedef xsltStyleItemForEachPtr

xsltStyleItemForEach * xsltStyleItemForEachPtr;
+

+

+
+

Structure xsltStyleItemIf

struct _xsltStyleItemIf {
+    const xmlChar *	test	: if
+    xmlXPathCompExprPtr	comp	: a precompiled XPath expression
+} xsltStyleItemIf;
+

+

+
+

Typedef xsltStyleItemIfPtr

xsltStyleItemIf * xsltStyleItemIfPtr;
+

+

+
+

Structure xsltStyleItemInclude

struct _xsltStyleItemInclude {
+    xsltDocumentPtr	include
+} xsltStyleItemInclude;
+

+

+
+

Typedef xsltStyleItemIncludePtr

xsltStyleItemInclude * xsltStyleItemIncludePtr;
+

+

+
+

Structure xsltStyleItemLRElementInfo

struct _xsltStyleItemLRElementInfo {
+    xsltEffectiveNsPtr	effectiveNs
+} xsltStyleItemLRElementInfo;
+

+

+
+

Typedef xsltStyleItemLRElementInfoPtr

xsltStyleItemLRElementInfo * xsltStyleItemLRElementInfoPtr;
+

+

+
+

Structure xsltStyleItemMessage

struct _xsltStyleItemMessage {
+    int	terminate
+} xsltStyleItemMessage;
+

+

+
+

Typedef xsltStyleItemMessagePtr

xsltStyleItemMessage * xsltStyleItemMessagePtr;
+

+

+
+

Structure xsltStyleItemNumber

struct _xsltStyleItemNumber {
+    xsltNumberData	numdata	: number
+} xsltStyleItemNumber;
+

+

+
+

Typedef xsltStyleItemNumberPtr

xsltStyleItemNumber * xsltStyleItemNumberPtr;
+

+

+
+

Structure xsltStyleItemOtherwise

struct _xsltStyleItemOtherwise {
+The content of this structure is not made public by the API.
+} xsltStyleItemOtherwise;
+

+

+
+

Typedef xsltStyleItemOtherwisePtr

xsltStyleItemOtherwise * xsltStyleItemOtherwisePtr;
+

+

+
+

Structure xsltStyleItemPI

struct _xsltStyleItemPI {
+    const xmlChar *	name
+    int	has_name
+} xsltStyleItemPI;
+

+

+
+

Typedef xsltStyleItemPIPtr

xsltStyleItemPI * xsltStyleItemPIPtr;
+

+

+
+

Structure xsltStyleItemParam

struct _xsltStyleItemParam {
+    const xmlChar *	select
+    xmlXPathCompExprPtr	comp
+    const xmlChar *	name
+    int	has_name
+    const xmlChar *	ns
+    int	has_ns
+} xsltStyleItemParam;
+

+

+
+

Typedef xsltStyleItemParamPtr

xsltStyleItemParam * xsltStyleItemParamPtr;
+

+

+
+

Structure xsltStyleItemSort

struct _xsltStyleItemSort {
+    const xmlChar *	stype	: sort
+    int	has_stype	: sort
+    int	number	: sort
+    const xmlChar *	order	: sort
+    int	has_order	: sort
+    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
+    int	has_use
+    const xmlChar *	select	: sort, copy-of, value-of, apply-templates
+    xmlXPathCompExprPtr	comp	: a precompiled XPath expression
+} xsltStyleItemSort;
+

+

+
+

Typedef xsltStyleItemSortPtr

xsltStyleItemSort * xsltStyleItemSortPtr;
+

+

+
+

Structure xsltStyleItemText

struct _xsltStyleItemText {
+    int	noescape	: text
+} xsltStyleItemText;
+

+

+
+

Typedef xsltStyleItemTextPtr

xsltStyleItemText * xsltStyleItemTextPtr;
+

+

+
+

Structure xsltStyleItemUknown

struct _xsltStyleItemUknown {
+The content of this structure is not made public by the API.
+} xsltStyleItemUknown;
+

+

+
+

Typedef xsltStyleItemUknownPtr

xsltStyleItemUknown * xsltStyleItemUknownPtr;
+

+

+
+

Structure xsltStyleItemValueOf

struct _xsltStyleItemValueOf {
+    const xmlChar *	select
+    xmlXPathCompExprPtr	comp	: a precompiled XPath expression
+    int	noescape
+} xsltStyleItemValueOf;
+

+

+
+

Typedef xsltStyleItemValueOfPtr

xsltStyleItemValueOf * xsltStyleItemValueOfPtr;
+

+

+
+

Typedef xsltStyleItemVariable

xsltStyleBasicItemVariable xsltStyleItemVariable;
+

+

+
+

Typedef xsltStyleItemVariablePtr

xsltStyleItemVariable * xsltStyleItemVariablePtr;
+

+

+
+

Structure xsltStyleItemWhen

struct _xsltStyleItemWhen {
+    const xmlChar *	test
+    xmlXPathCompExprPtr	comp
+} xsltStyleItemWhen;
+

+

+
+

Typedef xsltStyleItemWhenPtr

xsltStyleItemWhen * xsltStyleItemWhenPtr;
+

+

+
+

Typedef xsltStyleItemWithParam

xsltStyleBasicItemVariable xsltStyleItemWithParam;
+

+

+
+

Typedef xsltStyleItemWithParamPtr

xsltStyleItemWithParam * xsltStyleItemWithParamPtr;
+

+

+
+

Structure xsltStylePreComp

struct _xsltStylePreComp {
+    xsltElemPreCompPtr	next	: chained list
+    xsltStyleType	type	: type of the element
+    xsltTransformFunction	func	: handling function
+    xmlNodePtr	inst	: * Pre computed values. *
+    const xmlChar *	stype	: sort
+    int	has_stype	: sort
+    int	number	: sort
+    const xmlChar *	order	: sort
+    int	has_order	: sort
+    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
+    int	has_use	: copy, element
+    int	noescape	: text
+    const xmlChar *	name	: element, attribute, pi
+    int	has_name	: element, attribute, pi
+    const xmlChar *	ns	: element
+    int	has_ns	: element
+    const xmlChar *	mode	: apply-templates
+    const xmlChar *	modeURI	: apply-templates
+    const xmlChar *	test	: if
+    xsltTemplatePtr	templ	: call-template
+    const xmlChar *	select	: sort, copy-of, value-of, apply-templates
+    int	ver11	: document
+    const xmlChar *	filename	: document URL
+    int	has_filename	: document
+    xsltNumberData	numdata	: number
+    xmlXPathCompExprPtr	comp	: a precompiled XPath expression
+    xmlNsPtr *	nsList	: the namespaces in scope
+    int	nsNr	: the number of namespaces in scope
+} xsltStylePreComp;
+

+

+
+

Typedef xsltStylePreCompPtr

xsltStylePreComp * xsltStylePreCompPtr;
+

+

+
+

Enum xsltStyleType

enum xsltStyleType {
+    XSLT_FUNC_COPY = 1
+    XSLT_FUNC_SORT = 2
+    XSLT_FUNC_TEXT = 3
+    XSLT_FUNC_ELEMENT = 4
+    XSLT_FUNC_ATTRIBUTE = 5
+    XSLT_FUNC_COMMENT = 6
+    XSLT_FUNC_PI = 7
+    XSLT_FUNC_COPYOF = 8
+    XSLT_FUNC_VALUEOF = 9
+    XSLT_FUNC_NUMBER = 10
+    XSLT_FUNC_APPLYIMPORTS = 11
+    XSLT_FUNC_CALLTEMPLATE = 12
+    XSLT_FUNC_APPLYTEMPLATES = 13
+    XSLT_FUNC_CHOOSE = 14
+    XSLT_FUNC_IF = 15
+    XSLT_FUNC_FOREACH = 16
+    XSLT_FUNC_DOCUMENT = 17
+    XSLT_FUNC_WITHPARAM = 18
+    XSLT_FUNC_PARAM = 19
+    XSLT_FUNC_VARIABLE = 20
+    XSLT_FUNC_WHEN = 21
+    XSLT_FUNC_EXTENSION = 22
+    XSLT_FUNC_OTHERWISE = 23
+    XSLT_FUNC_FALLBACK = 24
+    XSLT_FUNC_MESSAGE = 25
+    XSLT_FUNC_INCLUDE = 26
+    XSLT_FUNC_ATTRSET = 27
+    XSLT_FUNC_LITERAL_RESULT_ELEMENT = 28
+    XSLT_FUNC_UNKOWN_FORWARDS_COMPAT = 29
+};
+

+

+
+

Structure xsltStylesheet

struct _xsltStylesheet {
+    struct _xsltStylesheet *	parent
+    struct _xsltStylesheet *	next
+    struct _xsltStylesheet *	imports
+    xsltDocumentPtr	docList	: * General data on the style sheet document. *
+    xmlDocPtr	doc	: the parsed XML stylesheet
+    xmlHashTablePtr	stripSpaces	: the hash table of the strip-space and preserve space elements
+    int	stripAll	: strip-space * (1) preserve-space * (-1)
+    xmlHashTablePtr	cdataSection	: * Global variable or parameters. *
+    xsltStackElemPtr	variables	: * Template descriptions. *
+    xsltTemplatePtr	templates	: the ordered list of templates
+    void *	templatesHash	: hash table or wherever compiled templates information is stored
+    void *	rootMatch	: template based on /
+    void *	keyMatch	: template based on key()
+    void *	elemMatch	: template based on *
+    void *	attrMatch	: template based on @*
+    void *	parentMatch	: template based on ..
+    void *	textMatch	: template based on text()
+    void *	piMatch	: template based on processing-instruction()
+    void *	commentMatch	: * Namespace aliases. * NOTE: Not used in the refactored code. *
+    xmlHashTablePtr	nsAliases	: * Attribute sets. *
+    xmlHashTablePtr	attributeSets	: * Namespaces. * TODO: Eliminate this. *
+    xmlHashTablePtr	nsHash	: the set of namespaces in use: ATTENTION: This is used for execution o
+    void *	nsDefs	: * Key definitions. *
+    void *	keys	: * Output related stuff. *
+    xmlChar *	method	: the output method
+    xmlChar *	methodURI	: associated namespace if any
+    xmlChar *	version	: version string
+    xmlChar *	encoding	: encoding string
+    int	omitXmlDeclaration	: * Number formatting. *
+    xsltDecimalFormatPtr	decimalFormat
+    int	standalone	: standalone = "yes" | "no"
+    xmlChar *	doctypePublic	: doctype-public string
+    xmlChar *	doctypeSystem	: doctype-system string
+    int	indent	: should output being indented
+    xmlChar *	mediaType	: * Precomputed blocks. *
+    xsltElemPreCompPtr	preComps	: list of precomputed blocks
+    int	warnings	: number of warnings found at compilation
+    int	errors	: number of errors found at compilation
+    xmlChar *	exclPrefix	: last excluded prefixes
+    xmlChar **	exclPrefixTab	: array of excluded prefixes
+    int	exclPrefixNr	: number of excluded prefixes in scope
+    int	exclPrefixMax	: size of the array
+    void *	_private	: * Extensions. *
+    xmlHashTablePtr	extInfos	: the extension data
+    int	extrasNr	: * For keeping track of nested includes *
+    xsltDocumentPtr	includes	: * dictionary: shared between stylesheet, context and documents. *
+    xmlDictPtr	dict	: * precompiled attribute value templates. *
+    void *	attVTs	: * if namespace-alias has an alias for the default stylesheet prefix *
+    const xmlChar *	defaultAlias	: * bypass pre-processing (already done) (used in imports) *
+    int	nopreproc	: * all document text strings were internalized *
+    int	internalized	: * Literal Result Element as Stylesheet c.f. section 2.3 *
+    int	literal_result	: * The principal stylesheet *
+    xsltStylesheetPtr	principal	: * Compilation context used during compile-time. *
+    xsltCompilerCtxtPtr	compCtxt	: TODO: Change this to (void *).
+    xsltPrincipalStylesheetDataPtr	principalData	: * Forwards-compatible processing *
+    int	forwards_compatible
+    xmlHashTablePtr	namedTemplates	: hash table of named templates
+    xmlXPathContextPtr	xpathCtxt
+} xsltStylesheet;
+

+

+
+

Typedef xsltStylesheetPtr

xsltStylesheet * xsltStylesheetPtr;
+

+

+
+

Structure xsltTemplate

struct _xsltTemplate {
+    struct _xsltTemplate *	next	: chained list sorted by priority
+    struct _xsltStylesheet *	style	: the containing stylesheet
+    xmlChar *	match	: the matching string
+    float	priority	: as given from the stylesheet, not computed
+    const xmlChar *	name	: the local part of the name QName
+    const xmlChar *	nameURI	: the URI part of the name QName
+    const xmlChar *	mode	: the local part of the mode QName
+    const xmlChar *	modeURI	: the URI part of the mode QName
+    xmlNodePtr	content	: the template replacement value
+    xmlNodePtr	elem	: * TODO: @inheritedNsNr and @inheritedNs won't be used in the * refact
+    int	inheritedNsNr	: number of inherited namespaces
+    xmlNsPtr *	inheritedNs	: inherited non-excluded namespaces Profiling information
+    int	nbCalls	: the number of time the template was called
+    unsigned long	time	: the time spent in this template
+    void *	params	: xsl:param instructions
+    int	templNr	: Nb of templates in the stack
+    int	templMax	: Size of the templtes stack
+    xsltTemplatePtr *	templCalledTab	: templates called
+    int *	templCountTab	: .. and how often
+} xsltTemplate;
+

+

+
+

Typedef xsltTemplatePtr

xsltTemplate * xsltTemplatePtr;
+

+

+
+

Structure xsltTransformCache

struct _xsltTransformCache {
+    xmlDocPtr	RVT
+    int	nbRVT
+    xsltStackElemPtr	stackItems
+    int	nbStackItems
+    int	dbgCachedRVTs
+    int	dbgReusedRVTs
+    int	dbgCachedVars
+    int	dbgReusedVars
+} xsltTransformCache;
+

+

+
+

Typedef xsltTransformCachePtr

xsltTransformCache * xsltTransformCachePtr;
+

+

+
+

Structure xsltTransformContext

struct _xsltTransformContext {
+    xsltStylesheetPtr	style	: the stylesheet used
+    xsltOutputType	type	: the type of output
+    xsltTemplatePtr	templ	: the current template
+    int	templNr	: Nb of templates in the stack
+    int	templMax	: Size of the templtes stack
+    xsltTemplatePtr *	templTab	: the template stack
+    xsltStackElemPtr	vars	: the current variable list
+    int	varsNr	: Nb of variable list in the stack
+    int	varsMax	: Size of the variable list stack
+    xsltStackElemPtr *	varsTab	: the variable list stack
+    int	varsBase	: * Extensions *
+    xmlHashTablePtr	extFunctions	: the extension functions
+    xmlHashTablePtr	extElements	: the extension elements
+    xmlHashTablePtr	extInfos	: the extension data
+    const xmlChar *	mode	: the current mode
+    const xmlChar *	modeURI	: the current mode URI
+    xsltDocumentPtr	docList	: the document list
+    xsltDocumentPtr	document	: the current source document; can be NULL if an RTF
+    xmlNodePtr	node	: the current node being processed
+    xmlNodeSetPtr	nodeList	: the current node list xmlNodePtr current; the node
+    xmlDocPtr	output	: the resulting document
+    xmlNodePtr	insert	: the insertion node
+    xmlXPathContextPtr	xpathCtxt	: the XPath context
+    xsltTransformState	state	: * Global variables *
+    xmlHashTablePtr	globalVars	: the global variables and params
+    xmlNodePtr	inst	: the instruction in the stylesheet
+    int	xinclude	: should XInclude be processed
+    const char *	outputFile	: the output URI if known
+    int	profile	: is this run profiled
+    long	prof	: the current profiled value
+    int	profNr	: Nb of templates in the stack
+    int	profMax	: Size of the templtaes stack
+    long *	profTab	: the profile template stack
+    void *	_private	: user defined data
+    int	extrasNr	: the number of extras used
+    int	extrasMax	: the number of extras allocated
+    xsltRuntimeExtraPtr	extras	: extra per runtime information
+    xsltDocumentPtr	styleList	: the stylesheet docs list
+    void *	sec	: the security preferences if any
+    xmlGenericErrorFunc	error	: a specific error handler
+    void *	errctx	: context for the error handler
+    xsltSortFunc	sortfunc	: * handling of temporary Result Value Tree * (XSLT 1.0 term: "Result Tr
+    xmlDocPtr	tmpRVT	: list of RVT without persistance
+    xmlDocPtr	persistRVT	: list of persistant RVTs
+    int	ctxtflags	: * Speed optimization when coalescing text nodes *
+    const xmlChar *	lasttext	: last text node content
+    int	lasttsize	: last text node size
+    int	lasttuse	: * Per Context Debugging *
+    int	debugStatus	: the context level debug status
+    unsigned long *	traceCode	: pointer to the variable holding the mask
+    int	parserOptions	: * dictionary: shared between stylesheet, context and documents. *
+    xmlDictPtr	dict
+    xmlDocPtr	tmpDoc	: * all document text strings are internalized *
+    int	internalized
+    int	nbKeys
+    int	hasTemplKeyPatterns
+    xsltTemplatePtr	currentTemplateRule	: the Current Template Rule
+    xmlNodePtr	initialContextNode
+    xmlDocPtr	initialContextDoc
+    xsltTransformCachePtr	cache
+    void *	contextVariable	: the current variable item
+    xmlDocPtr	localRVT	: list of local tree fragments; will be freed when the instruction whic
+    xmlDocPtr	localRVTBase	: Obsolete
+    int	keyInitLevel	: Needed to catch recursive keys issues
+    int	depth	: Needed to catch recursions
+    int	maxTemplateDepth
+    int	maxTemplateVars
+    unsigned long	opLimit
+    unsigned long	opCount
+} xsltTransformContext;
+

+

+
+

Typedef xsltTransformContextPtr

xsltTransformContext * xsltTransformContextPtr;
+

+

+
+

Enum xsltTransformState

enum xsltTransformState {
+    XSLT_STATE_OK = 0
+    XSLT_STATE_ERROR = 1
+    XSLT_STATE_STOPPED = 2
+};
+

+

+
+

Structure xsltVarInfo

struct _xsltVarInfo {
+    xsltVarInfoPtr	next	: next in the list
+    xsltVarInfoPtr	prev
+    int	depth	: the depth in the tree
+    const xmlChar *	name
+    const xmlChar *	nsName
+} xsltVarInfo;
+

+

+
+

Typedef xsltVarInfoPtr

xsltVarInfo * xsltVarInfoPtr;
+

+

+
+

Function type xsltElemPreCompDeallocator

void	xsltElemPreCompDeallocator	(xsltElemPreCompPtr comp)

+

Deallocates an #xsltElemPreComp structure.

+
comp:the #xsltElemPreComp to free up
+
+

Function type xsltSortFunc

void	xsltSortFunc			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr * sorts, 
					 int nbsorts)

+

Signature of the function to use during sorting

+
ctxt:a transformation context
sorts:the node-set to sort
nbsorts:the number of sorts
+
+

Function type xsltTransformFunction

void	xsltTransformFunction		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst, 
					 xsltElemPreCompPtr comp)

+

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

+
ctxt:the XSLT transformation context
node:the input node
inst:the stylesheet node
comp:the compiled information from the stylesheet
+
+

Variable xsltConstNamespaceNameXSLT

const xmlChar * xsltConstNamespaceNameXSLT;
+

+

+
+

Variable xsltXSLTAttrMarker

const xmlChar * xsltXSLTAttrMarker;
+

+

+
+

xsltAllocateExtra ()

int	xsltAllocateExtra		(xsltStylesheetPtr style)

+

Allocate an extra runtime information slot statically while compiling the stylesheet and return its number

+
style:an XSLT stylesheet
Returns:the number of the slot
+
+

xsltAllocateExtraCtxt ()

int	xsltAllocateExtraCtxt		(xsltTransformContextPtr ctxt)

+

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

+
ctxt:an XSLT transformation context
Returns:the number of the slot
+
+

xsltCompileAttr ()

void	xsltCompileAttr			(xsltStylesheetPtr style, 
					 xmlAttrPtr attr)

+

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.

+
style:a XSLT process context
attr:the attribute coming from the stylesheet.
+
+

xsltCreateRVT ()

xmlDocPtr	xsltCreateRVT		(xsltTransformContextPtr ctxt)

+

Creates a Result Value Tree (the XSLT 1.0 term for this is "Result Tree Fragment")

+
ctxt:an XSLT transformation context
Returns:the result value tree or NULL in case of API or internal errors.
+
+

xsltDecimalFormatGetByName ()

xsltDecimalFormatPtr	xsltDecimalFormatGetByName	(xsltStylesheetPtr style, 
							 xmlChar * name)

+

Find decimal-format by name

+
style:the XSLT stylesheet
name:the decimal-format name to find
Returns:the xsltDecimalFormatPtr
+
+

xsltDecimalFormatGetByQName ()

xsltDecimalFormatPtr	xsltDecimalFormatGetByQName	(xsltStylesheetPtr style, 
							 const xmlChar * nsUri, 
							 const xmlChar * name)

+

Find decimal-format by QName

+
style:the XSLT stylesheet
nsUri:the namespace URI of the QName
name:the local part of the QName
Returns:the xsltDecimalFormatPtr
+
+

xsltEvalAVT ()

xmlChar *	xsltEvalAVT		(xsltTransformContextPtr ctxt, 
					 void * avt, 
					 xmlNodePtr node)

+

Process the given AVT, and return the new string value.

+
ctxt:the XSLT transformation context
avt:the prevompiled attribute value template info
node:the node hosting the attribute
Returns:the computed string value or NULL, must be deallocated by the caller.
+
+

xsltExtensionInstructionResultFinalize ()

int	xsltExtensionInstructionResultFinalize	(xsltTransformContextPtr ctxt)

+

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.

+
ctxt:an XSLT transformation context
Returns:0 in case of success and -1 in case of API or internal errors. This function is unsupported in newer releases of libxslt.
+
+

xsltExtensionInstructionResultRegister ()

int	xsltExtensionInstructionResultRegister	(xsltTransformContextPtr ctxt, 
						 xmlXPathObjectPtr obj)

+

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)

+

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

xsltFormatNumberConversion ()

xmlXPathError	xsltFormatNumberConversion	(xsltDecimalFormatPtr self, 
						 xmlChar * format, 
						 double number, 
						 xmlChar ** result)

+

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.

+
self:the decimal format
format:the format requested
number:the value to format
result:the place to output the result
Returns:a possible XPath error
+
+

xsltFreeAVTList ()

void	xsltFreeAVTList			(void * avt)

+

Free up the memory associated to the attribute value templates

+
avt:pointer to an list of AVT structures
+
+

xsltFreeRVTs ()

void	xsltFreeRVTs			(xsltTransformContextPtr ctxt)

+

Frees all registered result value trees (Result Tree Fragments) of the transformation. Internal function; should not be called by user-code.

+
ctxt:an XSLT transformation context
+
+

xsltFreeStackElemList ()

void	xsltFreeStackElemList		(xsltStackElemPtr elem)

+

Free up the memory allocated by @elem

+
elem:an XSLT stack element
+
+

xsltFreeStylesheet ()

void	xsltFreeStylesheet		(xsltStylesheetPtr style)

+

Free up the memory allocated by @style

+
style:an XSLT stylesheet
+
+

xsltInitAllDocKeys ()

int	xsltInitAllDocKeys		(xsltTransformContextPtr ctxt)

+

INTERNAL ROUTINE ONLY Check if any keys on the current document need to be computed

+
ctxt:transformation context
Returns:0 in case of success, -1 in case of failure
+
+

xsltInitCtxtKey ()

int	xsltInitCtxtKey			(xsltTransformContextPtr ctxt, 
					 xsltDocumentPtr idoc, 
					 xsltKeyDefPtr keyDef)

+

Computes the key tables this key and for the current input document.

+
ctxt:an XSLT transformation context
idoc:the document information (holds key values)
keyDef:the key definition
Returns:0 on success, -1 on error
+
+

xsltIsBlank ()

int	xsltIsBlank			(xmlChar * str)

+

Check if a string is ignorable

+
str:a string
Returns:1 if the string is NULL or made of blanks chars, 0 otherwise
+
+

xsltLoadStylesheetPI ()

xsltStylesheetPtr	xsltLoadStylesheetPI	(xmlDocPtr doc)

+

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.

+
doc:a document to process
Returns:a new XSLT stylesheet structure or NULL if not found.
+
+

xsltNewStylesheet ()

xsltStylesheetPtr	xsltNewStylesheet	(void)

+

Create a new XSLT Stylesheet

+
Returns:the newly allocated xsltStylesheetPtr or NULL in case of error
+
+

xsltNumberFormat ()

void	xsltNumberFormat		(xsltTransformContextPtr ctxt, 
					 xsltNumberDataPtr data, 
					 xmlNodePtr node)

+

Convert one number.

+
ctxt:the XSLT transformation context
data:the formatting information
node:the data to format
+
+

xsltParseAnyXSLTElem ()

int	xsltParseAnyXSLTElem		(xsltCompilerCtxtPtr cctxt, 
					 xmlNodePtr elem)

+

Parses, validates the content models and compiles XSLT instructions.

+
cctxt:the compilation context
elem:the element node of the XSLT instruction
Returns:0 if everything's fine; -1 on API or internal errors.
+
+

xsltParseSequenceConstructor ()

void	xsltParseSequenceConstructor	(xsltCompilerCtxtPtr cctxt, 
					 xmlNodePtr cur)

+

Parses a "template" content (or "sequence constructor" in XSLT 2.0 terms). This will additionally remove xsl:text elements from the tree.

+
cctxt:the compilation context
cur:the start-node of the content to be parsed
+
+

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

xsltParseStylesheetFile ()

xsltStylesheetPtr	xsltParseStylesheetFile	(const xmlChar * filename)

+

Load and parse an XSLT stylesheet

+
filename:the filename/URL to the stylesheet
Returns:a new XSLT stylesheet structure.
+
+

xsltParseStylesheetImportedDoc ()

xsltStylesheetPtr	xsltParseStylesheetImportedDoc	(xmlDocPtr doc, 
							 xsltStylesheetPtr parentStyle)

+

parse an XSLT stylesheet building the associated structures except the processing not needed for imported documents.

+
doc:an xmlDoc parsed XML
parentStyle:pointer to the parent stylesheet (if it exists)
Returns:a new XSLT stylesheet structure.
+
+

xsltParseStylesheetOutput ()

void	xsltParseStylesheetOutput	(xsltStylesheetPtr style, 
					 xmlNodePtr cur)

+

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

+
style:the XSLT stylesheet
cur:the "output" element
+
+

xsltParseStylesheetProcess ()

xsltStylesheetPtr	xsltParseStylesheetProcess	(xsltStylesheetPtr ret, 
							 xmlDocPtr doc)

+

Parses an XSLT stylesheet, adding the associated structures. Called by: xsltParseStylesheetImportedDoc() (xslt.c) xsltParseStylesheetInclude() (imports.c)

+
ret:the XSLT stylesheet (the current stylesheet-level)
doc:and xmlDoc parsed XML
Returns:the value of the @style parameter if everything went right, NULL if something went amiss.
+
+

xsltParseStylesheetUser ()

int	xsltParseStylesheetUser		(xsltStylesheetPtr style, 
					 xmlDocPtr doc)

+

Parse an XSLT stylesheet with a user-provided stylesheet struct.

+
style:pointer to the stylesheet
doc:an xmlDoc parsed XML
Returns:0 if successful, -1 in case of error.
+
+

xsltParseTemplateContent ()

void	xsltParseTemplateContent	(xsltStylesheetPtr style, 
					 xmlNodePtr templ)

+

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

+
style:the XSLT stylesheet
templ:the container node (can be a document for literal results)
+
+

xsltPointerListAddSize ()

int	xsltPointerListAddSize		(xsltPointerListPtr list, 
					 void * item, 
					 int initialSize)

+

Adds an item to the list.

+
list:the pointer list structure
item:the item to be stored
initialSize:the initial size of the list
Returns:the position of the added item in the list or -1 in case of an error.
+
+

xsltPointerListClear ()

void	xsltPointerListClear		(xsltPointerListPtr list)

+

Resets the list, but does not free the allocated array and does not free the content of the list.

+
list:pointer to the list to be cleared
+
+

xsltPointerListCreate ()

xsltPointerListPtr	xsltPointerListCreate	(int initialSize)

+

Creates an xsltPointerList structure.

+
initialSize:the initial size for the list
Returns:a xsltPointerList structure or NULL in case of an error.
+
+

xsltPointerListFree ()

void	xsltPointerListFree		(xsltPointerListPtr list)

+

Frees the xsltPointerList structure. This does not free the content of the list.

+
list:pointer to the list to be freed
+
+

xsltRegisterLocalRVT ()

int	xsltRegisterLocalRVT		(xsltTransformContextPtr ctxt, 
					 xmlDocPtr RVT)

+

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.

+
ctxt:an XSLT transformation context
RVT:a result value tree (Result Tree Fragment; xmlDocPtr)
Returns:0 in case of success and -1 in case of API or internal errors.
+
+

xsltRegisterPersistRVT ()

int	xsltRegisterPersistRVT		(xsltTransformContextPtr ctxt, 
					 xmlDocPtr RVT)

+

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.

+
ctxt:an XSLT transformation context
RVT:a result value tree (Result Tree Fragment)
Returns:0 in case of success and -1 in case of error.
+
+

xsltRegisterTmpRVT ()

int	xsltRegisterTmpRVT		(xsltTransformContextPtr ctxt, 
					 xmlDocPtr RVT)

+

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.

+
ctxt:an XSLT transformation context
RVT:a result value tree (Result Tree Fragment)
Returns:0 in case of success and -1 in case of API or internal errors.
+
+

xsltReleaseRVT ()

void	xsltReleaseRVT			(xsltTransformContextPtr ctxt, 
					 xmlDocPtr RVT)

+

Either frees the RVT (which is an xmlDoc) or stores it in the context's cache for later reuse.

+
ctxt:an XSLT transformation context
RVT:a result value tree (Result Tree Fragment)
+
+

xsltRestoreDocumentNamespaces ()

int	xsltRestoreDocumentNamespaces	(xsltNsMapPtr ns, 
					 xmlDocPtr doc)

+

Restore the namespaces for the document

+
ns:map of namespaces
doc:the document
Returns:0 in case of success, -1 in case of failure
+
+

xsltUninit ()

void	xsltUninit			(void)

+

Uninitializes the processor.

+
+
+
+
+ + diff --git a/doc/devhelp/libxslt-xsltexports.html b/doc/devhelp/libxslt-xsltexports.html new file mode 100644 index 00000000..e9479ea1 --- /dev/null +++ b/doc/devhelp/libxslt-xsltexports.html @@ -0,0 +1,82 @@ + + + + + xsltexports: macros for marking symbols as exportable/importable. + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ xsltexports +

+

xsltexports - macros for marking symbols as exportable/importable.

+

macros for marking symbols as exportable/importable.

+

Author(s): Igor Zlatkovic <igor@zlatkovic.com>

+
+

Synopsis

+ 
#define LIBXSLT_PUBLIC;
+#define XSLTPUBFUN;
+#define XSLTPUBVAR;
+#define _REENTRANT;
+#define XSLTCALL;
+
+
+
+

Description

+
+
+

Details

+
+

Macro LIBXSLT_PUBLIC

#define LIBXSLT_PUBLIC;
+

+

+
+

Macro XSLTCALL

#define XSLTCALL;
+

+

+
+

Macro XSLTPUBFUN

#define XSLTPUBFUN;
+

+

+
+

Macro XSLTPUBVAR

#define XSLTPUBVAR;
+

+

+
+

Macro _REENTRANT

#define _REENTRANT;
+

+

+
+
+
+ + diff --git a/doc/devhelp/libxslt-xsltlocale.html b/doc/devhelp/libxslt-xsltlocale.html new file mode 100644 index 00000000..9861b8c0 --- /dev/null +++ b/doc/devhelp/libxslt-xsltlocale.html @@ -0,0 +1,107 @@ + + + + + xsltlocale: Locale handling + + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + + + Next + + libxslt Reference Manual
+

+ xsltlocale +

+

xsltlocale - Locale handling

+

Interfaces for locale handling. Needed for language dependent sorting.

+

Author(s): Nick Wellnhofer

+
+

Synopsis

+ 
#define XSLT_LOCALE_WINAPI;
+#define XSLT_LOCALE_NONE;
+#define XSLT_LOCALE_POSIX;
+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	xsltFreeLocales			(void);
+
+
+
+

Description

+
+
+

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

+
+
+

Typedef xsltLocale

void * xsltLocale;
+

+

+
+

Typedef xsltLocaleChar

xmlChar xsltLocaleChar;
+

+

+
+

xsltFreeLocale ()

void	xsltFreeLocale			(xsltLocale locale)

+

Frees a locale created with xsltNewLocale

+
locale:the locale to free
+
+

xsltFreeLocales ()

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
+
+

xsltNewLocale ()

xsltLocale	xsltNewLocale		(const xmlChar * languageTag)

+

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
+
+

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
+
+
+
+ + diff --git a/doc/devhelp/libxslt-xsltutils.html b/doc/devhelp/libxslt-xsltutils.html new file mode 100644 index 00000000..9611b946 --- /dev/null +++ b/doc/devhelp/libxslt-xsltutils.html @@ -0,0 +1,348 @@ + + + + + xsltutils: set of utilities for the XSLT engine + + + + + + + + + + + + + + +
+ + Prev + + + + Up + + + + Home + + libxslt Reference Manual
+

+ xsltutils +

+

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

+

Author(s): Daniel Veillard

+
+

Synopsis

+ 
#define IS_XSLT_REAL_NODE;
+#define IS_XSLT_ELEM;
+#define IS_XSLT_NAME;
+#define XSLT_TODO;
+#define XSLT_STRANGE;
+#define XSLT_TIMESTAMP_TICS_PER_SEC;
+#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, 
					 ... ...);
+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);
+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);
+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);
+typedef void xsltDropCallCallback		(void);
+xmlDocPtr	xsltGetProfileInformation	(xsltTransformContextPtr ctxt);
+
+
+
+

Description

+
+
+

Details

+
+

Macro IS_XSLT_ELEM

#define IS_XSLT_ELEM;
+

Checks that the element pertains to XSLT namespace.

+
+
+

Macro IS_XSLT_NAME

#define IS_XSLT_NAME;
+

Checks the value of an element in XSLT namespace.

+
+
+

Macro IS_XSLT_REAL_NODE

#define IS_XSLT_REAL_NODE;
+

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

+
+
+

Macro XSLT_STRANGE

#define XSLT_STRANGE;
+

Macro to flag that a problem was detected internally.

+
+
+

Macro XSLT_TIMESTAMP_TICS_PER_SEC

#define XSLT_TIMESTAMP_TICS_PER_SEC;
+

Sampling precision for profiling

+
+
+

Macro XSLT_TODO

#define XSLT_TODO;
+

Macro to flag unimplemented blocks.

+
+
+

Macro XSLT_TRACE

#define XSLT_TRACE;
+

Control the type of xsl debugtrace messages emitted.

+
+
+

Enum xsltDebugStatusCodes

enum xsltDebugStatusCodes {
+    XSLT_DEBUG_NONE = 0 /* no debugging allowed */
+    XSLT_DEBUG_INIT = 1
+    XSLT_DEBUG_STEP = 2
+    XSLT_DEBUG_STEPOUT = 3
+    XSLT_DEBUG_NEXT = 4
+    XSLT_DEBUG_STOP = 5
+    XSLT_DEBUG_CONT = 6
+    XSLT_DEBUG_RUN = 7
+    XSLT_DEBUG_RUN_RESTART = 8
+    XSLT_DEBUG_QUIT = 9
+};
+

+

+
+

Enum xsltDebugTraceCodes

enum xsltDebugTraceCodes {
+    XSLT_TRACE_ALL = -1
+    XSLT_TRACE_NONE = 0
+    XSLT_TRACE_COPY_TEXT = 1
+    XSLT_TRACE_PROCESS_NODE = 2
+    XSLT_TRACE_APPLY_TEMPLATE = 4
+    XSLT_TRACE_COPY = 8
+    XSLT_TRACE_COMMENT = 16
+    XSLT_TRACE_PI = 32
+    XSLT_TRACE_COPY_OF = 64
+    XSLT_TRACE_VALUE_OF = 128
+    XSLT_TRACE_CALL_TEMPLATE = 256
+    XSLT_TRACE_APPLY_TEMPLATES = 512
+    XSLT_TRACE_CHOOSE = 1024
+    XSLT_TRACE_IF = 2048
+    XSLT_TRACE_FOR_EACH = 4096
+    XSLT_TRACE_STRIP_SPACES = 8192
+    XSLT_TRACE_TEMPLATES = 16384
+    XSLT_TRACE_KEYS = 32768
+    XSLT_TRACE_VARIABLES = 65536
+};
+

+

+
+

Function type xsltAddCallCallback

int	xsltAddCallCallback		(xsltTemplatePtr templ, 
					 xmlNodePtr source)

+

+

templ:
source:
Returns:
+
+

Function type xsltDropCallCallback

void	xsltDropCallCallback		(void)

+

+

+
+

Function type xsltHandleDebuggerCallback

void	xsltHandleDebuggerCallback	(xmlNodePtr cur, 
					 xmlNodePtr node, 
					 xsltTemplatePtr templ, 
					 xsltTransformContextPtr ctxt)

+

+

cur:
node:
templ:
ctxt:
+
+

Variable xslDebugStatus

int xslDebugStatus;
+

+

+
+

Variable xsltGenericDebug

xmlGenericErrorFunc xsltGenericDebug;
+

+

+
+

Variable xsltGenericDebugContext

void * xsltGenericDebugContext;
+

+

+
+

Variable xsltGenericError

xmlGenericErrorFunc xsltGenericError;
+

+

+
+

Variable xsltGenericErrorContext

void * xsltGenericErrorContext;
+

+

+
+

xslAddCall ()

int	xslAddCall			(xsltTemplatePtr templ, 
					 xmlNodePtr source)

+

Add template "call" to call stack

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

xslDropCall ()

void	xslDropCall			(void)

+

Drop the topmost item off the call stack

+
+
+

xsltCalibrateAdjust ()

void	xsltCalibrateAdjust		(long delta)

+

Used for to correct the calibration for xsltTimestamp()

+
delta:a negative dealy value found
+
+

xsltComputeSortResult ()

xmlXPathObjectPtr *	xsltComputeSortResult	(xsltTransformContextPtr ctxt, 
						 xmlNodePtr sort)

+

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

+
ctxt:a XSLT process context
sort:node list
Returns:a ordered XPath nodeset or NULL in case of error.
+
+

xsltDebugGetDefaultTrace ()

xsltDebugTraceCodes	xsltDebugGetDefaultTrace	(void)

+

Get the current default debug tracing level mask

+
Returns:the current default debug tracing level mask
+
+

xsltDebugSetDefaultTrace ()

void	xsltDebugSetDefaultTrace	(xsltDebugTraceCodes val)

+

Set the default debug tracing level mask

+
val:tracing level mask
+
+

xsltDefaultSortFunction ()

void	xsltDefaultSortFunction		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr * sorts, 
					 int nbsorts)

+

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

+
ctxt:a XSLT process context
sorts:array of sort nodes
nbsorts:the number of sorts in the array
+
+

xsltDoSortFunction ()

void	xsltDoSortFunction		(xsltTransformContextPtr ctxt, 
					 xmlNodePtr * sorts, 
					 int nbsorts)

+

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.

+
ctxt:a XSLT process context
sorts:array of sort nodes
nbsorts:the number of sorts in the array
+
+

xsltDocumentSortFunction ()

void	xsltDocumentSortFunction	(xmlNodeSetPtr list)

+

reorder the current node list @list accordingly to the document order This function is slow, obsolete and should not be used anymore.

+
list:the node set
+
+

xsltGetCNsProp ()

const xmlChar *	xsltGetCNsProp		(xsltStylesheetPtr style, 
					 xmlNodePtr node, 
					 const xmlChar * name, 
					 const xmlChar * nameSpace)

+

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.

+
style:the stylesheet
node:the node
name:the attribute name
nameSpace:the URI of the namespace
Returns:the attribute value or NULL if not found. The string is allocated in the stylesheet dictionary.
+
+

xsltGetDebuggerStatus ()

int	xsltGetDebuggerStatus		(void)

+

Get xslDebugStatus.

+
Returns:the value of xslDebugStatus.
+
+

xsltGetNsProp ()

xmlChar *	xsltGetNsProp		(xmlNodePtr node, 
					 const xmlChar * name, 
					 const xmlChar * nameSpace)

+

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.

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

xsltGetProfileInformation ()

xmlDocPtr	xsltGetProfileInformation	(xsltTransformContextPtr ctxt)

+

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

+
ctxt:a transformation context
Returns:the xmlDocPtr corresponding to the result or NULL if not available.
+
+

xsltGetQNameURI ()

const xmlChar *	xsltGetQNameURI		(xmlNodePtr node, 
					 xmlChar ** name)

+

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.

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

xsltGetQNameURI2 ()

const xmlChar *	xsltGetQNameURI2	(xsltStylesheetPtr style, 
					 xmlNodePtr node, 
					 const xmlChar ** name)

+

This function is similar to xsltGetQNameURI, but is used when @name is a dictionary entry.

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

xsltGetUTF8Char ()

int	xsltGetUTF8Char			(const unsigned char * utf, 
					 int * len)

+

Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API

+
utf:a sequence of UTF-8 encoded bytes
len:a pointer to @bytes len
Returns:the char value or -1 in case of error and update @len with the number of bytes used
+
+

xsltMessage ()

void	xsltMessage			(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node, 
					 xmlNodePtr inst)

+

Process and xsl:message construct

+
ctxt:an XSLT processing context
node:The current node
inst:The node containing the message instruction
+
+

xsltPrintErrorContext ()

void	xsltPrintErrorContext		(xsltTransformContextPtr ctxt, 
					 xsltStylesheetPtr style, 
					 xmlNodePtr node)

+

Display the context of an error.

+
ctxt:the transformation context
style:the stylesheet
node:the current node being processed
+
+

xsltSaveProfiling ()

void	xsltSaveProfiling		(xsltTransformContextPtr ctxt, 
					 FILE * output)

+

Save the profiling information on @output

+
ctxt:an XSLT context
output:a FILE * for saving the information
+
+

xsltSaveResultTo ()

int	xsltSaveResultTo		(xmlOutputBufferPtr buf, 
					 xmlDocPtr result, 
					 xsltStylesheetPtr style)

+

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

+
buf:an output buffer
result:the result xmlDocPtr
style:the stylesheet
Returns:the number of byte written or -1 in case of failure.
+
+

xsltSaveResultToFd ()

int	xsltSaveResultToFd		(int fd, 
					 xmlDocPtr result, 
					 xsltStylesheetPtr style)

+

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

+
fd:a file descriptor
result:the result xmlDocPtr
style:the stylesheet
Returns:the number of bytes written or -1 in case of failure.
+
+

xsltSaveResultToFile ()

int	xsltSaveResultToFile		(FILE * file, 
					 xmlDocPtr result, 
					 xsltStylesheetPtr style)

+

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

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

xsltSaveResultToFilename ()

int	xsltSaveResultToFilename	(const char * URL, 
					 xmlDocPtr result, 
					 xsltStylesheetPtr style, 
					 int compression)

+

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

+
URL:a filename or URL
result:the result xmlDocPtr
style:the stylesheet
compression:the compression factor (0 - 9 included)
Returns:the number of byte written or -1 in case of failure.
+
+

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
+
+

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

+
ctxt:a XSLT process context
handler:the new handler function
+
+

xsltSetDebuggerCallbacks ()

int	xsltSetDebuggerCallbacks	(int no, 
					 void * block)

+

This function allow to plug a debugger into the XSLT library @block points to a block of memory containing the address of @no callback routines.

+
no:number of callbacks
block:the block of callbacks
Returns:0 in case of success and -1 in case of error
+
+

xsltSetDebuggerStatus ()

void	xsltSetDebuggerStatus		(int value)

+

This function sets the value of xslDebugStatus.

+
value:the value to be set
+
+

xsltSetGenericDebugFunc ()

void	xsltSetGenericDebugFunc		(void * ctx, 
					 xmlGenericErrorFunc handler)

+

Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing or validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.

+
ctx:the new error handling context
handler:the new handler function
+
+

xsltSetGenericErrorFunc ()

void	xsltSetGenericErrorFunc		(void * ctx, 
					 xmlGenericErrorFunc handler)

+

Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing nor validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.

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

+
handler:the new handler function
+
+

xsltSetTransformErrorFunc ()

void	xsltSetTransformErrorFunc	(xsltTransformContextPtr ctxt, 
					 void * ctx, 
					 xmlGenericErrorFunc handler)

+

Function to reset the handler and the error context for out of context error messages specific to a given XSLT transromation. This simply means that @handler will be called for subsequent error messages while running the transformation.

+
ctxt:the XSLT transformation context
ctx:the new error handling context
handler:the new handler function
+
+

xsltSplitQName ()

const xmlChar *	xsltSplitQName		(xmlDictPtr dict, 
					 const xmlChar * name, 
					 const xmlChar ** prefix)

+

Split QNames into prefix and local names, both allocated from a dictionary.

+
dict:a dictionary
name:the full QName
prefix:the return value
Returns:the localname or NULL in case of error.
+
+

xsltTimestamp ()

long	xsltTimestamp			(void)

+

Used for gathering profiling data

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

xsltTransformError ()

void	xsltTransformError		(xsltTransformContextPtr ctxt, 
					 xsltStylesheetPtr style, 
					 xmlNodePtr node, 
					 const char * msg, 
					 ... ...)

+

Display and format an error messages, gives file, line, position and extra parameters, will use the specific transformation context if available

+
ctxt:an XSLT transformation context
style:the XSLT stylesheet used
node:the current node in the stylesheet
msg:the message to display/transmit
...:extra parameters for the message display
+
+

xsltXPathCompile ()

xmlXPathCompExprPtr	xsltXPathCompile	(xsltStylesheetPtr style, 
						 const xmlChar * str)

+

Compile an XPath expression

+
style:the stylesheet
str:the XPath expression
Returns:the xmlXPathCompExprPtr resulting from the compilation or NULL. the caller has to free the object.
+
+

xsltXPathCompileFlags ()

xmlXPathCompExprPtr	xsltXPathCompileFlags	(xsltStylesheetPtr style, 
						 const xmlChar * str, 
						 int flags)

+

Compile an XPath expression

+
style:the stylesheet
str:the XPath expression
flags:extra compilation flags to pass down to libxml2 XPath
Returns:the xmlXPathCompExprPtr resulting from the compilation or NULL. the caller has to free the object.
+
+
+
+ + diff --git a/doc/devhelp/libxslt.devhelp2 b/doc/devhelp/libxslt.devhelp2 new file mode 100644 index 00000000..4a44f803 --- /dev/null +++ b/doc/devhelp/libxslt.devhelp2 @@ -0,0 +1,558 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/devhelp/right.png b/doc/devhelp/right.png new file mode 100644 index 0000000000000000000000000000000000000000..92832e3a4566e59d6e4092010e08d28f3be3a68d GIT binary patch literal 472 zcmV;}0Vn>6P)Cd4HCN^TYHBC0dz3r5|}*T3c5!K}0^NPTey!^rYo;W&eW{b1SE%dR-1ljcju- zJITo5P_e{cPDWDszO|97o#m$fni3V4d%~7^?0HU4-k!+X`e~w55Q}HA=c?CM9`EK` z^o5GF_RsnG`ey+9wOf8O4bzg>7W*;jU~M?g`OZAA$mNp|Lz<$s+~N9!2`ir8RcClo$(Q~19INM~9}j;&*|enC yGd}kJak0wj?aUKd8;%}`i}SSew>!A-2iw}^5}Rh(M>+vRkipZ{&t;ucLK6U4uc96R literal 0 HcmV?d00001