1	/*
2	* Summary: internal data structures, constants and functions
3	* Description: Internal data structures, constants and functions used
4	* by the XSLT engine.
5	* They are not part of the API or ABI, i.e. they can change
6	* without prior notice, use carefully.
7	*
8	* Copy: See Copyright for the status of this software.
9	*
10	* Author: Daniel Veillard
11	*/
12
13	#ifndef __XML_XSLT_INTERNALS_H__
14	#define __XML_XSLT_INTERNALS_H__
15
16	#include <libxml/tree.h>
17	#include <libxml/hash.h>
18	#include <libxml/xpath.h>
19	#include <libxml/xmlerror.h>
20	#include <libxml/dict.h>
21	#include <libxml/xmlstring.h>
22	#include <libxslt/xslt.h>
23	#include "xsltexports.h"
24	#include "xsltlocale.h"
25	#include "numbersInternals.h"
26
27	#ifdef __cplusplus
28	extern "C" {
29	#endif
30
31	/* #define XSLT_DEBUG_PROFILE_CACHE */
32
33	/**
34	* XSLT_IS_TEXT_NODE:
35	*
36	* check if the argument is a text node
37	*/
38	#define XSLT_IS_TEXT_NODE(n) ((n != NULL) && \
39	(((n)->type == XML_TEXT_NODE) || \
40	((n)->type == XML_CDATA_SECTION_NODE)))
41
42
43	/**
44	* XSLT_MARK_RES_TREE_FRAG:
45	*
46	* internal macro to set up tree fragments
47	*/
48	#define XSLT_MARK_RES_TREE_FRAG(n) \
49	(n)->name = (char *) xmlStrdup(BAD_CAST " fake node libxslt");
50
51	/**
52	* XSLT_IS_RES_TREE_FRAG:
53	*
54	* internal macro to test tree fragments
55	*/
56	#define XSLT_IS_RES_TREE_FRAG(n) \
57	((n != NULL) && ((n)->type == XML_DOCUMENT_NODE) && \
58	((n)->name != NULL) && ((n)->name[0] == ' '))
59
60	/**
61	* XSLT_REFACTORED_KEYCOMP:
62	*
63	* Internal define to enable on-demand xsl:key computation.
64	* That's the only mode now but the define is kept for compatibility
65	*/
66	#define XSLT_REFACTORED_KEYCOMP
67
68	/**
69	* XSLT_FAST_IF:
70	*
71	* Internal define to enable usage of xmlXPathCompiledEvalToBoolean()
72	* for XSLT "tests"; e.g. in <xsl:if test="/foo/bar">
73	*/
74	#define XSLT_FAST_IF
75
76	/**
77	* XSLT_REFACTORED:
78	*
79	* Internal define to enable the refactored parts of Libxslt.
80	*/
81	/* #define XSLT_REFACTORED */
82	/* ==================================================================== */
83
84	/**
85	* XSLT_REFACTORED_VARS:
86	*
87	* Internal define to enable the refactored variable part of libxslt
88	*/
89	#define XSLT_REFACTORED_VARS
90
91	#ifdef XSLT_REFACTORED
92
93	extern const xmlChar *xsltXSLTAttrMarker;
94
95
96	/* TODO: REMOVE: #define XSLT_REFACTORED_EXCLRESNS */
97
98	/* TODO: REMOVE: #define XSLT_REFACTORED_NSALIAS */
99
100	/**
101	* XSLT_REFACTORED_XSLT_NSCOMP
102	*
103	* Internal define to enable the pointer-comparison of
104	* namespaces of XSLT elements.
105	*/
106	/* #define XSLT_REFACTORED_XSLT_NSCOMP */
107
108	#ifdef XSLT_REFACTORED_XSLT_NSCOMP
109
110	extern const xmlChar *xsltConstNamespaceNameXSLT;
111
112	/**
113	* IS_XSLT_ELEM_FAST:
114	*
115	* quick test to detect XSLT elements
116	*/
117	#define IS_XSLT_ELEM_FAST(n) \
118	(((n) != NULL) && ((n)->ns != NULL) && \
119	((n)->ns->href == xsltConstNamespaceNameXSLT))
120
121	/**
122	* IS_XSLT_ATTR_FAST:
123	*
124	* quick test to detect XSLT attributes
125	*/
126	#define IS_XSLT_ATTR_FAST(a) \
127	(((a) != NULL) && ((a)->ns != NULL) && \
128	((a)->ns->href == xsltConstNamespaceNameXSLT))
129
130	/**
131	* XSLT_HAS_INTERNAL_NSMAP:
132	*
133	* check for namespace mapping
134	*/
135	#define XSLT_HAS_INTERNAL_NSMAP(s) \
136	(((s) != NULL) && ((s)->principal) && \
137	((s)->principal->principalData) && \
138	((s)->principal->principalData->nsMap))
139
140	/**
141	* XSLT_GET_INTERNAL_NSMAP:
142	*
143	* get pointer to namespace map
144	*/
145	#define XSLT_GET_INTERNAL_NSMAP(s) ((s)->principal->principalData->nsMap)
146
147	#else /* XSLT_REFACTORED_XSLT_NSCOMP */
148
149	/**
150	* IS_XSLT_ELEM_FAST:
151	*
152	* quick check whether this is an xslt element
153	*/
154	#define IS_XSLT_ELEM_FAST(n) \
155	(((n) != NULL) && ((n)->ns != NULL) && \
156	(xmlStrEqual((n)->ns->href, XSLT_NAMESPACE)))
157
158	/**
159	* IS_XSLT_ATTR_FAST:
160	*
161	* quick check for xslt namespace attribute
162	*/
163	#define IS_XSLT_ATTR_FAST(a) \
164	(((a) != NULL) && ((a)->ns != NULL) && \
165	(xmlStrEqual((a)->ns->href, XSLT_NAMESPACE)))
166
167
168	#endif /* XSLT_REFACTORED_XSLT_NSCOMP */
169
170
171	/**
172	* XSLT_REFACTORED_MANDATORY_VERSION:
173	*
174	* TODO: Currently disabled to surpress regression test failures, since
175	* the old behaviour was that a missing version attribute
176	* produced a only a warning and not an error, which was incerrect.
177	* So the regression tests need to be fixed if this is enabled.
178	*/
179	/* #define XSLT_REFACTORED_MANDATORY_VERSION */
180
181	/**
182	* xsltPointerList:
183	*
184	* Pointer-list for various purposes.
185	*/
186	typedef struct _xsltPointerList xsltPointerList;
187	typedef xsltPointerList *xsltPointerListPtr;
188	struct _xsltPointerList {
189	void **items;
190	int number;
191	int size;
192	};
193
194	#endif
195
196	/**
197	* XSLT_REFACTORED_PARSING:
198	*
199	* Internal define to enable the refactored parts of Libxslt
200	* related to parsing.
201	*/
202	/* #define XSLT_REFACTORED_PARSING */
203
204	/**
205	* XSLT_MAX_SORT:
206	*
207	* Max number of specified xsl:sort on an element.
208	*/
209	#define XSLT_MAX_SORT 15
210
211	/**
212	* XSLT_PAT_NO_PRIORITY:
213	*
214	* Specific value for pattern without priority expressed.
215	*/
216	#define XSLT_PAT_NO_PRIORITY -12345789
217
218	/**
219	* xsltRuntimeExtra:
220	*
221	* Extra information added to the transformation context.
222	*/
223	typedef struct _xsltRuntimeExtra xsltRuntimeExtra;
224	typedef xsltRuntimeExtra *xsltRuntimeExtraPtr;
225	struct _xsltRuntimeExtra {
226	void *info; /* pointer to the extra data */
227	xmlFreeFunc deallocate; /* pointer to the deallocation routine */
228	union { /* dual-purpose field */
229	void *ptr; /* data not needing deallocation */
230	int ival; /* integer value storage */
231	} val;
232	};
233
234	/**
235	* XSLT_RUNTIME_EXTRA_LST:
236	* @ctxt: the transformation context
237	* @nr: the index
238	*
239	* Macro used to access extra information stored in the context
240	*/
241	#define XSLT_RUNTIME_EXTRA_LST(ctxt, nr) (ctxt)->extras[(nr)].info
242	/**
243	* XSLT_RUNTIME_EXTRA_FREE:
244	* @ctxt: the transformation context
245	* @nr: the index
246	*
247	* Macro used to free extra information stored in the context
248	*/
249	#define XSLT_RUNTIME_EXTRA_FREE(ctxt, nr) (ctxt)->extras[(nr)].deallocate
250	/**
251	* XSLT_RUNTIME_EXTRA:
252	* @ctxt: the transformation context
253	* @nr: the index
254	*
255	* Macro used to define extra information stored in the context
256	*/
257	#define XSLT_RUNTIME_EXTRA(ctxt, nr, typ) (ctxt)->extras[(nr)].val.typ
258
259	/**
260	* xsltTemplate:
261	*
262	* The in-memory structure corresponding to an XSLT Template.
263	*/
264	typedef struct _xsltTemplate xsltTemplate;
265	typedef xsltTemplate *xsltTemplatePtr;
266	struct _xsltTemplate {
267	struct _xsltTemplate *next;/* chained list sorted by priority */
268	struct _xsltStylesheet *style;/* the containing stylesheet */
269	xmlChar *match; /* the matching string */
270	float priority; /* as given from the stylesheet, not computed */
271	const xmlChar *name; /* the local part of the name QName */
272	const xmlChar *nameURI; /* the URI part of the name QName */
273	const xmlChar *mode;/* the local part of the mode QName */
274	const xmlChar *modeURI;/* the URI part of the mode QName */
275	xmlNodePtr content; /* the template replacement value */
276	xmlNodePtr elem; /* the source element */
277
278	/*
279	* TODO: @inheritedNsNr and @inheritedNs won't be used in the
280	* refactored code.
281	*/
282	int inheritedNsNr; /* number of inherited namespaces */
283	xmlNsPtr *inheritedNs;/* inherited non-excluded namespaces */
284
285	/* Profiling information */
286	int nbCalls; /* the number of time the template was called */
287	unsigned long time; /* the time spent in this template */
288	void *params; /* xsl:param instructions */
289
290	int templNr; /* Nb of templates in the stack */
291	int templMax; /* Size of the templtes stack */
292	xsltTemplatePtr *templCalledTab; /* templates called */
293	int *templCountTab; /* .. and how often */
294	};
295
296	/**
297	* xsltDecimalFormat:
298	*
299	* Data structure of decimal-format.
300	*/
301	typedef struct _xsltDecimalFormat xsltDecimalFormat;
302	typedef xsltDecimalFormat *xsltDecimalFormatPtr;
303	struct _xsltDecimalFormat {
304	struct _xsltDecimalFormat *next; /* chained list */
305	xmlChar *name;
306	/* Used for interpretation of pattern */
307	xmlChar *digit;
308	xmlChar *patternSeparator;
309	/* May appear in result */
310	xmlChar *minusSign;
311	xmlChar *infinity;
312	xmlChar *noNumber; /* Not-a-number */
313	/* Used for interpretation of pattern and may appear in result */
314	xmlChar *decimalPoint;
315	xmlChar *grouping;
316	xmlChar *percent;
317	xmlChar *permille;
318	xmlChar *zeroDigit;
319	const xmlChar *nsUri;
320	};
321
322	/**
323	* xsltDocument:
324	*
325	* Data structure associated to a parsed document.
326	*/
327	typedef struct _xsltDocument xsltDocument;
328	typedef xsltDocument *xsltDocumentPtr;
329	struct _xsltDocument {
330	struct _xsltDocument *next; /* documents are kept in a chained list */
331	int main; /* is this the main document */
332	xmlDocPtr doc; /* the parsed document */
333	void *keys; /* key tables storage */
334	struct _xsltDocument *includes; /* subsidiary includes */
335	int preproc; /* pre-processing already done */
336	int nbKeysComputed;
337	};
338
339	/**
340	* xsltKeyDef:
341	*
342	* Representation of an xsl:key.
343	*/
344	typedef struct _xsltKeyDef xsltKeyDef;
345	typedef xsltKeyDef *xsltKeyDefPtr;
346	struct _xsltKeyDef {
347	struct _xsltKeyDef *next;
348	xmlNodePtr inst;
349	xmlChar *name;
350	xmlChar *nameURI;
351	xmlChar *match;
352	xmlChar *use;
353	xmlXPathCompExprPtr comp;
354	xmlXPathCompExprPtr usecomp;
355	xmlNsPtr *nsList; /* the namespaces in scope */
356	int nsNr; /* the number of namespaces in scope */
357	};
358
359	/**
360	* xsltKeyTable:
361	*
362	* Holds the computed keys for key definitions of the same QName.
363	* Is owned by an xsltDocument.
364	*/
365	typedef struct _xsltKeyTable xsltKeyTable;
366	typedef xsltKeyTable *xsltKeyTablePtr;
367	struct _xsltKeyTable {
368	struct _xsltKeyTable *next;
369	xmlChar *name;
370	xmlChar *nameURI;
371	xmlHashTablePtr keys;
372	};
373
374	/*
375	* The in-memory structure corresponding to an XSLT Stylesheet.
376	* NOTE: most of the content is simply linked from the doc tree
377	* structure, no specific allocation is made.
378	*/
379	typedef struct _xsltStylesheet xsltStylesheet;
380	typedef xsltStylesheet *xsltStylesheetPtr;
381
382	typedef struct _xsltTransformContext xsltTransformContext;
383	typedef xsltTransformContext *xsltTransformContextPtr;
384
385	/**
386	* xsltElemPreComp:
387	*
388	* The in-memory structure corresponding to element precomputed data,
389	* designed to be extended by extension implementors.
390	*/
391	typedef struct _xsltElemPreComp xsltElemPreComp;
392	typedef xsltElemPreComp *xsltElemPreCompPtr;
393
394	/**
395	* xsltTransformFunction:
396	* @ctxt: the XSLT transformation context
397	* @node: the input node
398	* @inst: the stylesheet node
399	* @comp: the compiled information from the stylesheet
400	*
401	* Signature of the function associated to elements part of the
402	* stylesheet language like xsl:if or xsl:apply-templates.
403	*/
404	typedef void (*xsltTransformFunction) (xsltTransformContextPtr ctxt,
405	xmlNodePtr node,
406	xmlNodePtr inst,
407	xsltElemPreCompPtr comp);
408
409	/**
410	* xsltSortFunc:
411	* @ctxt: a transformation context
412	* @sorts: the node-set to sort
413	* @nbsorts: the number of sorts
414	*
415	* Signature of the function to use during sorting
416	*/
417	typedef void (*xsltSortFunc) (xsltTransformContextPtr ctxt, xmlNodePtr *sorts,
418	int nbsorts);
419
420	typedef enum {
421	XSLT_FUNC_COPY=1,
422	XSLT_FUNC_SORT,
423	XSLT_FUNC_TEXT,
424	XSLT_FUNC_ELEMENT,
425	XSLT_FUNC_ATTRIBUTE,
426	XSLT_FUNC_COMMENT,
427	XSLT_FUNC_PI,
428	XSLT_FUNC_COPYOF,
429	XSLT_FUNC_VALUEOF,
430	XSLT_FUNC_NUMBER,
431	XSLT_FUNC_APPLYIMPORTS,
432	XSLT_FUNC_CALLTEMPLATE,
433	XSLT_FUNC_APPLYTEMPLATES,
434	XSLT_FUNC_CHOOSE,
435	XSLT_FUNC_IF,
436	XSLT_FUNC_FOREACH,
437	XSLT_FUNC_DOCUMENT,
438	XSLT_FUNC_WITHPARAM,
439	XSLT_FUNC_PARAM,
440	XSLT_FUNC_VARIABLE,
441	XSLT_FUNC_WHEN,
442	XSLT_FUNC_EXTENSION
443	#ifdef XSLT_REFACTORED
444	,
445	XSLT_FUNC_OTHERWISE,
446	XSLT_FUNC_FALLBACK,
447	XSLT_FUNC_MESSAGE,
448	XSLT_FUNC_INCLUDE,
449	XSLT_FUNC_ATTRSET,
450	XSLT_FUNC_LITERAL_RESULT_ELEMENT,
451	XSLT_FUNC_UNKOWN_FORWARDS_COMPAT
452	#endif
453	} xsltStyleType;
454
455	/**
456	* xsltElemPreCompDeallocator:
457	* @comp: the #xsltElemPreComp to free up
458	*
459	* Deallocates an #xsltElemPreComp structure.
460	*/
461	typedef void (*xsltElemPreCompDeallocator) (xsltElemPreCompPtr comp);
462
463	/**
464	* xsltElemPreComp:
465	*
466	* The basic structure for compiled items of the AST of the XSLT processor.
467	* This structure is also intended to be extended by extension implementors.
468	* TODO: This is somehow not nice, since it has a "free" field, which
469	* derived stylesheet-structs do not have.
470	*/
471	struct _xsltElemPreComp {
472	xsltElemPreCompPtr next; /* next item in the global chained
473	list held by xsltStylesheet. */
474	xsltStyleType type; /* type of the element */
475	xsltTransformFunction func; /* handling function */
476	xmlNodePtr inst; /* the node in the stylesheet's tree
477	corresponding to this item */
478
479	/* end of common part */
480	xsltElemPreCompDeallocator free; /* the deallocator */
481	};
482
483	/**
484	* xsltStylePreComp:
485	*
486	* The abstract basic structure for items of the XSLT processor.
487	* This includes:
488	* 1) compiled forms of XSLT instructions (xsl:if, xsl:attribute, etc.)
489	* 2) compiled forms of literal result elements
490	* 3) compiled forms of extension elements
491	*/
492	typedef struct _xsltStylePreComp xsltStylePreComp;
493	typedef xsltStylePreComp *xsltStylePreCompPtr;
494
495	#ifdef XSLT_REFACTORED
496
497	/*
498	* Some pointer-list utility functions.
499	*/
500	XSLTPUBFUN xsltPointerListPtr XSLTCALL
501	xsltPointerListCreate (int initialSize);
502	XSLTPUBFUN void XSLTCALL
503	xsltPointerListFree (xsltPointerListPtr list);
504	XSLTPUBFUN void XSLTCALL
505	xsltPointerListClear (xsltPointerListPtr list);
506	XSLTPUBFUN int XSLTCALL
507	xsltPointerListAddSize (xsltPointerListPtr list,
508	void *item,
509	int initialSize);
510
511	/************************************************************************
512	* *
513	* Refactored structures *
514	* *
515	************************************************************************/
516
517	typedef struct _xsltNsListContainer xsltNsListContainer;
518	typedef xsltNsListContainer *xsltNsListContainerPtr;
519	struct _xsltNsListContainer {
520	xmlNsPtr *list;
521	int totalNumber;
522	int xpathNumber;
523	};
524
525	/**
526	* XSLT_ITEM_COMPATIBILITY_FIELDS:
527	*
528	* Fields for API compatibility to the structure
529	* _xsltElemPreComp which is used for extension functions.
530	* Note that @next is used for storage; it does not reflect a next
531	* sibling in the tree.
532	* TODO: Evaluate if we really need such a compatibility.
533	*/
534	#define XSLT_ITEM_COMPATIBILITY_FIELDS \
535	xsltElemPreCompPtr next;\
536	xsltStyleType type;\
537	xsltTransformFunction func;\
538	xmlNodePtr inst;
539
540	/**
541	* XSLT_ITEM_NAVIGATION_FIELDS:
542	*
543	* Currently empty.
544	* TODO: It is intended to hold navigational fields in the future.
545	*/
546	#define XSLT_ITEM_NAVIGATION_FIELDS
547	/*
548	xsltStylePreCompPtr parent;\
549	xsltStylePreCompPtr children;\
550	xsltStylePreCompPtr nextItem;
551	*/
552
553	/**
554	* XSLT_ITEM_NSINSCOPE_FIELDS:
555	*
556	* The in-scope namespaces.
557	*/
558	#define XSLT_ITEM_NSINSCOPE_FIELDS xsltNsListContainerPtr inScopeNs;
559
560	/**
561	* XSLT_ITEM_COMMON_FIELDS:
562	*
563	* Common fields used for all items.
564	*/
565	#define XSLT_ITEM_COMMON_FIELDS \
566	XSLT_ITEM_COMPATIBILITY_FIELDS \
567	XSLT_ITEM_NAVIGATION_FIELDS \
568	XSLT_ITEM_NSINSCOPE_FIELDS
569
570	/**
571	* _xsltStylePreComp:
572	*
573	* The abstract basic structure for items of the XSLT processor.
574	* This includes:
575	* 1) compiled forms of XSLT instructions (e.g. xsl:if, xsl:attribute, etc.)
576	* 2) compiled forms of literal result elements
577	* 3) various properties for XSLT instructions (e.g. xsl:when,
578	* xsl:with-param)
579	*
580	* REVISIT TODO: Keep this structure equal to the fields
581	* defined by XSLT_ITEM_COMMON_FIELDS
582	*/
583	struct _xsltStylePreComp {
584	xsltElemPreCompPtr next; /* next item in the global chained
585	list held by xsltStylesheet */
586	xsltStyleType type; /* type of the item */
587	xsltTransformFunction func; /* handling function */
588	xmlNodePtr inst; /* the node in the stylesheet's tree
589	corresponding to this item. */
590	/* Currently no navigational fields. */
591	xsltNsListContainerPtr inScopeNs;
592	};
593
594	/**
595	* xsltStyleBasicEmptyItem:
596	*
597	* Abstract structure only used as a short-cut for
598	* XSLT items with no extra fields.
599	* NOTE that it is intended that this structure looks the same as
600	* _xsltStylePreComp.
601	*/
602	typedef struct _xsltStyleBasicEmptyItem xsltStyleBasicEmptyItem;
603	typedef xsltStyleBasicEmptyItem *xsltStyleBasicEmptyItemPtr;
604
605	struct _xsltStyleBasicEmptyItem {
606	XSLT_ITEM_COMMON_FIELDS
607	};
608
609	/**
610	* xsltStyleBasicExpressionItem:
611	*
612	* Abstract structure only used as a short-cut for
613	* XSLT items with just an expression.
614	*/
615	typedef struct _xsltStyleBasicExpressionItem xsltStyleBasicExpressionItem;
616	typedef xsltStyleBasicExpressionItem *xsltStyleBasicExpressionItemPtr;
617
618	struct _xsltStyleBasicExpressionItem {
619	XSLT_ITEM_COMMON_FIELDS
620
621	const xmlChar *select; /* TODO: Change this to "expression". */
622	xmlXPathCompExprPtr comp; /* TODO: Change this to compExpr. */
623	};
624
625	/************************************************************************
626	* *
627	* XSLT-instructions/declarations *
628	* *
629	************************************************************************/
630
631	/**
632	* xsltStyleItemElement:
633	*
634	* <!-- Category: instruction -->
635	* <xsl:element
636	* name = { qname }
637	* namespace = { uri-reference }
638	* use-attribute-sets = qnames>
639	* <!-- Content: template -->
640	* </xsl:element>
641	*/
642	typedef struct _xsltStyleItemElement xsltStyleItemElement;
643	typedef xsltStyleItemElement *xsltStyleItemElementPtr;
644
645	struct _xsltStyleItemElement {
646	XSLT_ITEM_COMMON_FIELDS
647
648	const xmlChar *use;
649	int has_use;
650	const xmlChar *name;
651	int has_name;
652	const xmlChar *ns;
653	const xmlChar *nsPrefix;
654	int has_ns;
655	};
656
657	/**
658	* xsltStyleItemAttribute:
659	*
660	* <!-- Category: instruction -->
661	* <xsl:attribute
662	* name = { qname }
663	* namespace = { uri-reference }>
664	* <!-- Content: template -->
665	* </xsl:attribute>
666	*/
667	typedef struct _xsltStyleItemAttribute xsltStyleItemAttribute;
668	typedef xsltStyleItemAttribute *xsltStyleItemAttributePtr;
669
670	struct _xsltStyleItemAttribute {
671	XSLT_ITEM_COMMON_FIELDS
672	const xmlChar *name;
673	int has_name;
674	const xmlChar *ns;
675	const xmlChar *nsPrefix;
676	int has_ns;
677	};
678
679	/**
680	* xsltStyleItemText:
681	*
682	* <!-- Category: instruction -->
683	* <xsl:text
684	* disable-output-escaping = "yes" | "no">
685	* <!-- Content: #PCDATA -->
686	* </xsl:text>
687	*/
688	typedef struct _xsltStyleItemText xsltStyleItemText;
689	typedef xsltStyleItemText *xsltStyleItemTextPtr;
690
691	struct _xsltStyleItemText {
692	XSLT_ITEM_COMMON_FIELDS
693	int noescape; /* text */
694	};
695
696	/**
697	* xsltStyleItemComment:
698	*
699	* <!-- Category: instruction -->
700	* <xsl:comment>
701	* <!-- Content: template -->
702	* </xsl:comment>
703	*/
704	typedef xsltStyleBasicEmptyItem xsltStyleItemComment;
705	typedef xsltStyleItemComment *xsltStyleItemCommentPtr;
706
707	/**
708	* xsltStyleItemPI:
709	*
710	* <!-- Category: instruction -->
711	* <xsl:processing-instruction
712	* name = { ncname }>
713	* <!-- Content: template -->
714	* </xsl:processing-instruction>
715	*/
716	typedef struct _xsltStyleItemPI xsltStyleItemPI;
717	typedef xsltStyleItemPI *xsltStyleItemPIPtr;
718
719	struct _xsltStyleItemPI {
720	XSLT_ITEM_COMMON_FIELDS
721	const xmlChar *name;
722	int has_name;
723	};
724
725	/**
726	* xsltStyleItemApplyImports:
727	*
728	* <!-- Category: instruction -->
729	* <xsl:apply-imports />
730	*/
731	typedef xsltStyleBasicEmptyItem xsltStyleItemApplyImports;
732	typedef xsltStyleItemApplyImports *xsltStyleItemApplyImportsPtr;
733
734	/**
735	* xsltStyleItemApplyTemplates:
736	*
737	* <!-- Category: instruction -->
738	* <xsl:apply-templates
739	* select = node-set-expression
740	* mode = qname>
741	* <!-- Content: (xsl:sort | xsl:with-param)* -->
742	* </xsl:apply-templates>
743	*/
744	typedef struct _xsltStyleItemApplyTemplates xsltStyleItemApplyTemplates;
745	typedef xsltStyleItemApplyTemplates *xsltStyleItemApplyTemplatesPtr;
746
747	struct _xsltStyleItemApplyTemplates {
748	XSLT_ITEM_COMMON_FIELDS
749
750	const xmlChar *mode; /* apply-templates */
751	const xmlChar *modeURI; /* apply-templates */
752	const xmlChar *select; /* sort, copy-of, value-of, apply-templates */
753	xmlXPathCompExprPtr comp; /* a precompiled XPath expression */
754	/* TODO: with-params */
755	};
756
757	/**
758	* xsltStyleItemCallTemplate:
759	*
760	* <!-- Category: instruction -->
761	* <xsl:call-template
762	* name = qname>
763	* <!-- Content: xsl:with-param* -->
764	* </xsl:call-template>
765	*/
766	typedef struct _xsltStyleItemCallTemplate xsltStyleItemCallTemplate;
767	typedef xsltStyleItemCallTemplate *xsltStyleItemCallTemplatePtr;
768
769	struct _xsltStyleItemCallTemplate {
770	XSLT_ITEM_COMMON_FIELDS
771
772	xsltTemplatePtr templ; /* call-template */
773	const xmlChar *name; /* element, attribute, pi */
774	int has_name; /* element, attribute, pi */
775	const xmlChar *ns; /* element */
776	int has_ns; /* element */
777	/* TODO: with-params */
778	};
779
780	/**
781	* xsltStyleItemCopy:
782	*
783	* <!-- Category: instruction -->
784	* <xsl:copy
785	* use-attribute-sets = qnames>
786	* <!-- Content: template -->
787	* </xsl:copy>
788	*/
789	typedef struct _xsltStyleItemCopy xsltStyleItemCopy;
790	typedef xsltStyleItemCopy *xsltStyleItemCopyPtr;
791
792	struct _xsltStyleItemCopy {
793	XSLT_ITEM_COMMON_FIELDS
794	const xmlChar *use; /* copy, element */
795	int has_use; /* copy, element */
796	};
797
798	/**
799	* xsltStyleItemIf:
800	*
801	* <!-- Category: instruction -->
802	* <xsl:if
803	* test = boolean-expression>
804	* <!-- Content: template -->
805	* </xsl:if>
806	*/
807	typedef struct _xsltStyleItemIf xsltStyleItemIf;
808	typedef xsltStyleItemIf *xsltStyleItemIfPtr;
809
810	struct _xsltStyleItemIf {
811	XSLT_ITEM_COMMON_FIELDS
812
813	const xmlChar *test; /* if */
814	xmlXPathCompExprPtr comp; /* a precompiled XPath expression */
815	};
816
817
818	/**
819	* xsltStyleItemCopyOf:
820	*
821	* <!-- Category: instruction -->
822	* <xsl:copy-of
823	* select = expression />
824	*/
825	typedef xsltStyleBasicExpressionItem xsltStyleItemCopyOf;
826	typedef xsltStyleItemCopyOf *xsltStyleItemCopyOfPtr;
827
828	/**
829	* xsltStyleItemValueOf:
830	*
831	* <!-- Category: instruction -->
832	* <xsl:value-of
833	* select = string-expression
834	* disable-output-escaping = "yes" | "no" />
835	*/
836	typedef struct _xsltStyleItemValueOf xsltStyleItemValueOf;
837	typedef xsltStyleItemValueOf *xsltStyleItemValueOfPtr;
838
839	struct _xsltStyleItemValueOf {
840	XSLT_ITEM_COMMON_FIELDS
841
842	const xmlChar *select;
843	xmlXPathCompExprPtr comp; /* a precompiled XPath expression */
844	int noescape;
845	};
846
847	/**
848	* xsltStyleItemNumber:
849	*
850	* <!-- Category: instruction -->
851	* <xsl:number
852	* level = "single" | "multiple" | "any"
853	* count = pattern
854	* from = pattern
855	* value = number-expression
856	* format = { string }
857	* lang = { nmtoken }
858	* letter-value = { "alphabetic" | "traditional" }
859	* grouping-separator = { char }
860	* grouping-size = { number } />
861	*/
862	typedef struct _xsltStyleItemNumber xsltStyleItemNumber;
863	typedef xsltStyleItemNumber *xsltStyleItemNumberPtr;
864
865	struct _xsltStyleItemNumber {
866	XSLT_ITEM_COMMON_FIELDS
867	xsltNumberData numdata; /* number */
868	};
869
870	/**
871	* xsltStyleItemChoose:
872	*
873	* <!-- Category: instruction -->
874	* <xsl:choose>
875	* <!-- Content: (xsl:when+, xsl:otherwise?) -->
876	* </xsl:choose>
877	*/
878	typedef xsltStyleBasicEmptyItem xsltStyleItemChoose;
879	typedef xsltStyleItemChoose *xsltStyleItemChoosePtr;
880
881	/**
882	* xsltStyleItemFallback:
883	*
884	* <!-- Category: instruction -->
885	* <xsl:fallback>
886	* <!-- Content: template -->
887	* </xsl:fallback>
888	*/
889	typedef xsltStyleBasicEmptyItem xsltStyleItemFallback;
890	typedef xsltStyleItemFallback *xsltStyleItemFallbackPtr;
891
892	/**
893	* xsltStyleItemForEach:
894	*
895	* <!-- Category: instruction -->
896	* <xsl:for-each
897	* select = node-set-expression>
898	* <!-- Content: (xsl:sort*, template) -->
899	* </xsl:for-each>
900	*/
901	typedef xsltStyleBasicExpressionItem xsltStyleItemForEach;
902	typedef xsltStyleItemForEach *xsltStyleItemForEachPtr;
903
904	/**
905	* xsltStyleItemMessage:
906	*
907	* <!-- Category: instruction -->
908	* <xsl:message
909	* terminate = "yes" | "no">
910	* <!-- Content: template -->
911	* </xsl:message>
912	*/
913	typedef struct _xsltStyleItemMessage xsltStyleItemMessage;
914	typedef xsltStyleItemMessage *xsltStyleItemMessagePtr;
915
916	struct _xsltStyleItemMessage {
917	XSLT_ITEM_COMMON_FIELDS
918	int terminate;
919	};
920
921	/**
922	* xsltStyleItemDocument:
923	*
924	* NOTE: This is not an instruction of XSLT 1.0.
925	*/
926	typedef struct _xsltStyleItemDocument xsltStyleItemDocument;
927	typedef xsltStyleItemDocument *xsltStyleItemDocumentPtr;
928
929	struct _xsltStyleItemDocument {
930	XSLT_ITEM_COMMON_FIELDS
931	int ver11; /* assigned: in xsltDocumentComp;
932	read: nowhere;
933	TODO: Check if we need. */
934	const xmlChar *filename; /* document URL */
935	int has_filename;
936	};
937
938	/************************************************************************
939	* *
940	* Non-instructions (actually properties of instructions/declarations) *
941	* *
942	************************************************************************/
943
944	/**
945	* xsltStyleBasicItemVariable:
946	*
947	* Basic struct for xsl:variable, xsl:param and xsl:with-param.
948	* It's currently important to have equal fields, since
949	* xsltParseStylesheetCallerParam() is used with xsl:with-param from
950	* the xslt side and with xsl:param from the exslt side (in
951	* exsltFuncFunctionFunction()).
952	*
953	* FUTURE NOTE: In XSLT 2.0 xsl:param, xsl:variable and xsl:with-param
954	* have additional different fields.
955	*/
956	typedef struct _xsltStyleBasicItemVariable xsltStyleBasicItemVariable;
957	typedef xsltStyleBasicItemVariable *xsltStyleBasicItemVariablePtr;
958
959	struct _xsltStyleBasicItemVariable {
960	XSLT_ITEM_COMMON_FIELDS
961
962	const xmlChar *select;
963	xmlXPathCompExprPtr comp;
964
965	const xmlChar *name;
966	int has_name;
967	const xmlChar *ns;
968	int has_ns;
969	};
970
971	/**
972	* xsltStyleItemVariable:
973	*
974	* <!-- Category: top-level-element -->
975	* <xsl:param
976	* name = qname
977	* select = expression>
978	* <!-- Content: template -->
979	* </xsl:param>
980	*/
981	typedef xsltStyleBasicItemVariable xsltStyleItemVariable;
982	typedef xsltStyleItemVariable *xsltStyleItemVariablePtr;
983
984	/**
985	* xsltStyleItemParam:
986	*
987	* <!-- Category: top-level-element -->
988	* <xsl:param
989	* name = qname
990	* select = expression>
991	* <!-- Content: template -->
992	* </xsl:param>
993	*/
994	typedef struct _xsltStyleItemParam xsltStyleItemParam;
995	typedef xsltStyleItemParam *xsltStyleItemParamPtr;
996
997	struct _xsltStyleItemParam {
998	XSLT_ITEM_COMMON_FIELDS
999
1000	const xmlChar *select;
1001	xmlXPathCompExprPtr comp;
1002
1003	const xmlChar *name;
1004	int has_name;
1005	const xmlChar *ns;
1006	int has_ns;
1007	};
1008
1009	/**
1010	* xsltStyleItemWithParam:
1011	*
1012	* <xsl:with-param
1013	* name = qname
1014	* select = expression>
1015	* <!-- Content: template -->
1016	* </xsl:with-param>
1017	*/
1018	typedef xsltStyleBasicItemVariable xsltStyleItemWithParam;
1019	typedef xsltStyleItemWithParam *xsltStyleItemWithParamPtr;
1020
1021	/**
1022	* xsltStyleItemSort:
1023	*
1024	* Reflects the XSLT xsl:sort item.
1025	* Allowed parents: xsl:apply-templates, xsl:for-each
1026	* <xsl:sort
1027	* select = string-expression
1028	* lang = { nmtoken }
1029	* data-type = { "text" | "number" | qname-but-not-ncname }
1030	* order = { "ascending" | "descending" }
1031	* case-order = { "upper-first" | "lower-first" } />
1032	*/
1033	typedef struct _xsltStyleItemSort xsltStyleItemSort;
1034	typedef xsltStyleItemSort *xsltStyleItemSortPtr;
1035
1036	struct _xsltStyleItemSort {
1037	XSLT_ITEM_COMMON_FIELDS
1038
1039	const xmlChar *stype; /* sort */
1040	int has_stype; /* sort */
1041	int number; /* sort */
1042	const xmlChar *order; /* sort */
1043	int has_order; /* sort */
1044	int descending; /* sort */
1045	const xmlChar *lang; /* sort */
1046	int has_lang; /* sort */
1047	xsltLocale locale; /* sort */
1048	const xmlChar *case_order; /* sort */
1049	int lower_first; /* sort */
1050
1051	const xmlChar *use;
1052	int has_use;
1053
1054	const xmlChar *select; /* sort, copy-of, value-of, apply-templates */
1055
1056	xmlXPathCompExprPtr comp; /* a precompiled XPath expression */
1057	};
1058
1059
1060	/**
1061	* xsltStyleItemWhen:
1062	*
1063	* <xsl:when
1064	* test = boolean-expression>
1065	* <!-- Content: template -->
1066	* </xsl:when>
1067	* Allowed parent: xsl:choose
1068	*/
1069	typedef struct _xsltStyleItemWhen xsltStyleItemWhen;
1070	typedef xsltStyleItemWhen *xsltStyleItemWhenPtr;
1071
1072	struct _xsltStyleItemWhen {
1073	XSLT_ITEM_COMMON_FIELDS
1074
1075	const xmlChar *test;
1076	xmlXPathCompExprPtr comp;
1077	};
1078
1079	/**
1080	* xsltStyleItemOtherwise:
1081	*
1082	* Allowed parent: xsl:choose
1083	* <xsl:otherwise>
1084	* <!-- Content: template -->
1085	* </xsl:otherwise>
1086	*/
1087	typedef struct _xsltStyleItemOtherwise xsltStyleItemOtherwise;
1088	typedef xsltStyleItemOtherwise *xsltStyleItemOtherwisePtr;
1089
1090	struct _xsltStyleItemOtherwise {
1091	XSLT_ITEM_COMMON_FIELDS
1092	};
1093
1094	typedef struct _xsltStyleItemInclude xsltStyleItemInclude;
1095	typedef xsltStyleItemInclude *xsltStyleItemIncludePtr;
1096
1097	struct _xsltStyleItemInclude {
1098	XSLT_ITEM_COMMON_FIELDS
1099	xsltDocumentPtr include;
1100	};
1101
1102	/************************************************************************
1103	* *
1104	* XSLT elements in forwards-compatible mode *
1105	* *
1106	************************************************************************/
1107
1108	typedef struct _xsltStyleItemUknown xsltStyleItemUknown;
1109	typedef xsltStyleItemUknown *xsltStyleItemUknownPtr;
1110	struct _xsltStyleItemUknown {
1111	XSLT_ITEM_COMMON_FIELDS
1112	};
1113
1114
1115	/************************************************************************
1116	* *
1117	* Extension elements *
1118	* *
1119	************************************************************************/
1120
1121	/*
1122	* xsltStyleItemExtElement:
1123	*
1124	* Reflects extension elements.
1125	*
1126	* NOTE: Due to the fact that the structure xsltElemPreComp is most
1127	* probably already heavily in use out there by users, so we cannot
1128	* easily change it, we'll create an intermediate structure which will
1129	* hold an xsltElemPreCompPtr.
1130	* BIG NOTE: The only problem I see here is that the user processes the
1131	* content of the stylesheet tree, possibly he'll lookup the node->psvi
1132	* fields in order to find subsequent extension functions.
1133	* In this case, the user's code will break, since the node->psvi
1134	* field will hold now the xsltStyleItemExtElementPtr and not
1135	* the xsltElemPreCompPtr.
1136	* However the place where the structure is anchored in the node-tree,
1137	* namely node->psvi, has beed already once been moved from node->_private
1138	* to node->psvi, so we have a precedent here, which, I think, should allow
1139	* us to change such semantics without headaches.
1140	*/
1141	typedef struct _xsltStyleItemExtElement xsltStyleItemExtElement;
1142	typedef xsltStyleItemExtElement *xsltStyleItemExtElementPtr;
1143	struct _xsltStyleItemExtElement {
1144	XSLT_ITEM_COMMON_FIELDS
1145	xsltElemPreCompPtr item;
1146	};
1147
1148	/************************************************************************
1149	* *
1150	* Literal result elements *
1151	* *
1152	************************************************************************/
1153
1154	typedef struct _xsltEffectiveNs xsltEffectiveNs;
1155	typedef xsltEffectiveNs *xsltEffectiveNsPtr;
1156	struct _xsltEffectiveNs {
1157	xsltEffectiveNsPtr nextInStore; /* storage next */
1158	xsltEffectiveNsPtr next; /* next item in the list */
1159	const xmlChar *prefix;
1160	const xmlChar *nsName;
1161	/*
1162	* Indicates if eclared on the literal result element; dunno if really
1163	* needed.
1164	*/
1165	int holdByElem;
1166	};
1167
1168	/*
1169	* Info for literal result elements.
1170	* This will be set on the elem->psvi field and will be
1171	* shared by literal result elements, which have the same
1172	* excluded result namespaces; i.e., this *won't* be created uniquely
1173	* for every literal result element.
1174	*/
1175	typedef struct _xsltStyleItemLRElementInfo xsltStyleItemLRElementInfo;
1176	typedef xsltStyleItemLRElementInfo *xsltStyleItemLRElementInfoPtr;
1177	struct _xsltStyleItemLRElementInfo {
1178	XSLT_ITEM_COMMON_FIELDS
1179	/*
1180	* @effectiveNs is the set of effective ns-nodes
1181	* on the literal result element, which will be added to the result
1182	* element if not already existing in the result tree.
1183	* This means that excluded namespaces (via exclude-result-prefixes,
1184	* extension-element-prefixes and the XSLT namespace) not added
1185	* to the set.
1186	* Namespace-aliasing was applied on the @effectiveNs.
1187	*/
1188	xsltEffectiveNsPtr effectiveNs;
1189
1190	};
1191
1192	#ifdef XSLT_REFACTORED
1193
1194	typedef struct _xsltNsAlias xsltNsAlias;
1195	typedef xsltNsAlias *xsltNsAliasPtr;
1196	struct _xsltNsAlias {
1197	xsltNsAliasPtr next; /* next in the list */
1198	xmlNsPtr literalNs;
1199	xmlNsPtr targetNs;
1200	xmlDocPtr docOfTargetNs;
1201	};
1202	#endif
1203
1204	#ifdef XSLT_REFACTORED_XSLT_NSCOMP
1205
1206	typedef struct _xsltNsMap xsltNsMap;
1207	typedef xsltNsMap *xsltNsMapPtr;
1208	struct _xsltNsMap {
1209	xsltNsMapPtr next; /* next in the list */
1210	xmlDocPtr doc;
1211	xmlNodePtr elem; /* the element holding the ns-decl */
1212	xmlNsPtr ns; /* the xmlNs structure holding the XML namespace name */
1213	const xmlChar *origNsName; /* the original XML namespace name */
1214	const xmlChar *newNsName; /* the mapped XML namespace name */
1215	};
1216	#endif
1217
1218	/************************************************************************
1219	* *
1220	* Compile-time structures for *internal* use only *
1221	* *
1222	************************************************************************/
1223
1224	typedef struct _xsltPrincipalStylesheetData xsltPrincipalStylesheetData;
1225	typedef xsltPrincipalStylesheetData *xsltPrincipalStylesheetDataPtr;
1226
1227	typedef struct _xsltNsList xsltNsList;
1228	typedef xsltNsList *xsltNsListPtr;
1229	struct _xsltNsList {
1230	xsltNsListPtr next; /* next in the list */
1231	xmlNsPtr ns;
1232	};
1233
1234	/*
1235	* xsltVarInfo:
1236	*
1237	* Used at compilation time for parameters and variables.
1238	*/
1239	typedef struct _xsltVarInfo xsltVarInfo;
1240	typedef xsltVarInfo *xsltVarInfoPtr;
1241	struct _xsltVarInfo {
1242	xsltVarInfoPtr next; /* next in the list */
1243	xsltVarInfoPtr prev;
1244	int depth; /* the depth in the tree */
1245	const xmlChar *name;
1246	const xmlChar *nsName;
1247	};
1248
1249	/**
1250	* xsltCompilerNodeInfo:
1251	*
1252	* Per-node information during compile-time.
1253	*/
1254	typedef struct _xsltCompilerNodeInfo xsltCompilerNodeInfo;
1255	typedef xsltCompilerNodeInfo *xsltCompilerNodeInfoPtr;
1256	struct _xsltCompilerNodeInfo {
1257	xsltCompilerNodeInfoPtr next;
1258	xsltCompilerNodeInfoPtr prev;
1259	xmlNodePtr node;
1260	int depth;
1261	xsltTemplatePtr templ; /* The owning template */
1262	int category; /* XSLT element, LR-element or
1263	extension element */
1264	xsltStyleType type;
1265	xsltElemPreCompPtr item; /* The compiled information */
1266	/* The current in-scope namespaces */
1267	xsltNsListContainerPtr inScopeNs;
1268	/* The current excluded result namespaces */
1269	xsltPointerListPtr exclResultNs;
1270	/* The current extension instruction namespaces */
1271	xsltPointerListPtr extElemNs;
1272
1273	/* The current info for literal result elements. */
1274	xsltStyleItemLRElementInfoPtr litResElemInfo;
1275	/*
1276	* Set to 1 if in-scope namespaces changed,
1277	* or excluded result namespaces changed,
1278	* or extension element namespaces changed.
1279	* This will trigger creation of new infos
1280	* for literal result elements.
1281	*/
1282	int nsChanged;
1283	int preserveWhitespace;
1284	int stripWhitespace;
1285	int isRoot; /* whether this is the stylesheet's root node */
1286	int forwardsCompat; /* whether forwards-compatible mode is enabled */
1287	/* whether the content of an extension element was processed */
1288	int extContentHandled;
1289	/* the type of the current child */
1290	xsltStyleType curChildType;
1291	};
1292
1293	/**
1294	* XSLT_CCTXT:
1295	*
1296	* get pointer to compiler context
1297	*/
1298	#define XSLT_CCTXT(style) ((xsltCompilerCtxtPtr) style->compCtxt)
1299
1300	typedef enum {
1301	XSLT_ERROR_SEVERITY_ERROR = 0,
1302	XSLT_ERROR_SEVERITY_WARNING
1303	} xsltErrorSeverityType;
1304
1305	typedef struct _xsltCompilerCtxt xsltCompilerCtxt;
1306	typedef xsltCompilerCtxt *xsltCompilerCtxtPtr;
1307	struct _xsltCompilerCtxt {
1308	void *errorCtxt; /* user specific error context */
1309	/*
1310	* used for error/warning reports; e.g. XSLT_ERROR_SEVERITY_WARNING */
1311	xsltErrorSeverityType errSeverity;
1312	int warnings; /* TODO: number of warnings found at
1313	compilation */
1314	int errors; /* TODO: number of errors found at
1315	compilation */
1316	xmlDictPtr dict;
1317	xsltStylesheetPtr style;
1318	int simplified; /* whether this is a simplified stylesheet */
1319	/* TODO: structured/unstructured error contexts. */
1320	int depth; /* Current depth of processing */
1321
1322	xsltCompilerNodeInfoPtr inode;
1323	xsltCompilerNodeInfoPtr inodeList;
1324	xsltCompilerNodeInfoPtr inodeLast;
1325	xsltPointerListPtr tmpList; /* Used for various purposes */
1326	/*
1327	* The XSLT version as specified by the stylesheet's root element.
1328	*/
1329	int isInclude;
1330	int hasForwardsCompat; /* whether forwards-compatible mode was used
1331	in a parsing episode */
1332	int maxNodeInfos; /* TEMP TODO: just for the interest */
1333	int maxLREs; /* TEMP TODO: just for the interest */
1334	/*
1335	* In order to keep the old behaviour, applying strict rules of
1336	* the spec can be turned off. This has effect only on special
1337	* mechanisms like whitespace-stripping in the stylesheet.
1338	*/
1339	int strict;
1340	xsltPrincipalStylesheetDataPtr psData;
1341	xsltStyleItemUknownPtr unknownItem;
1342	int hasNsAliases; /* Indicator if there was an xsl:namespace-alias. */
1343	xsltNsAliasPtr nsAliases;
1344	xsltVarInfoPtr ivars; /* Storage of local in-scope variables/params. */
1345	xsltVarInfoPtr ivar; /* topmost local variable/param. */
1346	};
1347
1348	#else /* XSLT_REFACTORED */
1349	/*
1350	* The old structures before refactoring.
1351	*/
1352
1353	/**
1354	* _xsltStylePreComp:
1355	*
1356	* The in-memory structure corresponding to XSLT stylesheet constructs
1357	* precomputed data.
1358	*/
1359	struct _xsltStylePreComp {
1360	xsltElemPreCompPtr next; /* chained list */
1361	xsltStyleType type; /* type of the element */
1362	xsltTransformFunction func; /* handling function */
1363	xmlNodePtr inst; /* the instruction */
1364
1365	/*
1366	* Pre computed values.
1367	*/
1368
1369	const xmlChar *stype; /* sort */
1370	int has_stype; /* sort */
1371	int number; /* sort */
1372	const xmlChar *order; /* sort */
1373	int has_order; /* sort */
1374	int descending; /* sort */
1375	const xmlChar *lang; /* sort */
1376	int has_lang; /* sort */
1377	xsltLocale locale; /* sort */
1378	const xmlChar *case_order; /* sort */
1379	int lower_first; /* sort */
1380
1381	const xmlChar *use; /* copy, element */
1382	int has_use; /* copy, element */
1383
1384	int noescape; /* text */
1385
1386	const xmlChar *name; /* element, attribute, pi */
1387	int has_name; /* element, attribute, pi */
1388	const xmlChar *ns; /* element */
1389	int has_ns; /* element */
1390
1391	const xmlChar *mode; /* apply-templates */
1392	const xmlChar *modeURI; /* apply-templates */
1393
1394	const xmlChar *test; /* if */
1395
1396	xsltTemplatePtr templ; /* call-template */
1397
1398	const xmlChar *select; /* sort, copy-of, value-of, apply-templates */
1399
1400	int ver11; /* document */
1401	const xmlChar *filename; /* document URL */
1402	int has_filename; /* document */
1403
1404	xsltNumberData numdata; /* number */
1405
1406	xmlXPathCompExprPtr comp; /* a precompiled XPath expression */
1407	xmlNsPtr *nsList; /* the namespaces in scope */
1408	int nsNr; /* the number of namespaces in scope */
1409	};
1410
1411	#endif /* XSLT_REFACTORED */
1412
1413
1414	/*
1415	* The in-memory structure corresponding to an XSLT Variable
1416	* or Param.
1417	*/
1418	typedef struct _xsltStackElem xsltStackElem;
1419	typedef xsltStackElem *xsltStackElemPtr;
1420	struct _xsltStackElem {
1421	struct _xsltStackElem *next;/* chained list */
1422	xsltStylePreCompPtr comp; /* the compiled form */
1423	int computed; /* was the evaluation done */
1424	const xmlChar *name; /* the local part of the name QName */
1425	const xmlChar *nameURI; /* the URI part of the name QName */
1426	const xmlChar *select; /* the eval string */
1427	xmlNodePtr tree; /* the sequence constructor if no eval
1428	string or the location */
1429	xmlXPathObjectPtr value; /* The value if computed */
1430	xmlDocPtr fragment; /* The Result Tree Fragments (needed for XSLT 1.0)
1431	which are bound to the variable's lifetime. */
1432	int level; /* the depth in the tree;
1433	-1 if persistent (e.g. a given xsl:with-param) */
1434	xsltTransformContextPtr context; /* The transformation context; needed to cache
1435	the variables */
1436	int flags;
1437	};
1438
1439	#ifdef XSLT_REFACTORED
1440
1441	struct _xsltPrincipalStylesheetData {
1442	/*
1443	* Namespace dictionary for ns-prefixes and ns-names:
1444	* TODO: Shared between stylesheets, and XPath mechanisms.
1445	* Not used yet.
1446	*/
1447	xmlDictPtr namespaceDict;
1448	/*
1449	* Global list of in-scope namespaces.
1450	*/
1451	xsltPointerListPtr inScopeNamespaces;
1452	/*
1453	* Global list of information for [xsl:]excluded-result-prefixes.
1454	*/
1455	xsltPointerListPtr exclResultNamespaces;
1456	/*
1457	* Global list of information for [xsl:]extension-element-prefixes.
1458	*/
1459	xsltPointerListPtr extElemNamespaces;
1460	xsltEffectiveNsPtr effectiveNs;
1461	#ifdef XSLT_REFACTORED_XSLT_NSCOMP
1462	/*
1463	* Namespace name map to get rid of string comparison of namespace names.
1464	*/
1465	xsltNsMapPtr nsMap;
1466	#endif
1467	};
1468
1469
1470	#endif
1471	/*
1472	* Note that we added a @compCtxt field to anchor an stylesheet compilation
1473	* context, since, due to historical reasons, various compile-time function
1474	* take only the stylesheet as argument and not a compilation context.
1475	*/
1476	struct _xsltStylesheet {
1477	/*
1478	* The stylesheet import relation is kept as a tree.
1479	*/
1480	struct _xsltStylesheet *parent;
1481	struct _xsltStylesheet *next;
1482	struct _xsltStylesheet *imports;
1483
1484	xsltDocumentPtr docList; /* the include document list */
1485
1486	/*
1487	* General data on the style sheet document.
1488	*/
1489	xmlDocPtr doc; /* the parsed XML stylesheet */
1490	xmlHashTablePtr stripSpaces;/* the hash table of the strip-space and
1491	preserve space elements */
1492	int stripAll; /* strip-space * (1) preserve-space * (-1) */
1493	xmlHashTablePtr cdataSection;/* the hash table of the cdata-section */
1494
1495	/*
1496	* Global variable or parameters.
1497	*/
1498	xsltStackElemPtr variables; /* linked list of param and variables */
1499
1500	/*
1501	* Template descriptions.
1502	*/
1503	xsltTemplatePtr templates; /* the ordered list of templates */
1504	void *templatesHash; /* hash table or wherever compiled templates
1505	information is stored */
1506	void *rootMatch; /* template based on / */
1507	void *keyMatch; /* template based on key() */
1508	void *elemMatch; /* template based on * */
1509	void *attrMatch; /* template based on @* */
1510	void *parentMatch; /* template based on .. */
1511	void *textMatch; /* template based on text() */
1512	void *piMatch; /* template based on processing-instruction() */
1513	void *commentMatch; /* template based on comment() */
1514
1515	/*
1516	* Namespace aliases.
1517	* NOTE: Not used in the refactored code.
1518	*/
1519	xmlHashTablePtr nsAliases; /* the namespace alias hash tables */
1520
1521	/*
1522	* Attribute sets.
1523	*/
1524	xmlHashTablePtr attributeSets;/* the attribute sets hash tables */
1525
1526	/*
1527	* Namespaces.
1528	* TODO: Eliminate this.
1529	*/
1530	xmlHashTablePtr nsHash; /* the set of namespaces in use:
1531	ATTENTION: This is used for
1532	execution of XPath expressions; unfortunately
1533	it restricts the stylesheet to have distinct
1534	prefixes.
1535	TODO: We need to get rid of this.
1536	*/
1537	void *nsDefs; /* ATTENTION TODO: This is currently used to store
1538	xsltExtDefPtr (in extensions.c) and
1539	*not* xmlNsPtr.
1540	*/
1541
1542	/*
1543	* Key definitions.
1544	*/
1545	void *keys; /* key definitions */
1546
1547	/*
1548	* Output related stuff.
1549	*/
1550	xmlChar *method; /* the output method */
1551	xmlChar *methodURI; /* associated namespace if any */
1552	xmlChar *version; /* version string */
1553	xmlChar *encoding; /* encoding string */
1554	int omitXmlDeclaration; /* omit-xml-declaration = "yes" | "no" */
1555
1556	/*
1557	* Number formatting.
1558	*/
1559	xsltDecimalFormatPtr decimalFormat;
1560	int standalone; /* standalone = "yes" | "no" */
1561	xmlChar *doctypePublic; /* doctype-public string */
1562	xmlChar *doctypeSystem; /* doctype-system string */
1563	int indent; /* should output being indented */
1564	xmlChar *mediaType; /* media-type string */
1565
1566	/*
1567	* Precomputed blocks.
1568	*/
1569	xsltElemPreCompPtr preComps;/* list of precomputed blocks */
1570	int warnings; /* number of warnings found at compilation */
1571	int errors; /* number of errors found at compilation */
1572
1573	xmlChar *exclPrefix; /* last excluded prefixes */
1574	xmlChar **exclPrefixTab; /* array of excluded prefixes */
1575	int exclPrefixNr; /* number of excluded prefixes in scope */
1576	int exclPrefixMax; /* size of the array */
1577
1578	void *_private; /* user defined data */
1579
1580	/*
1581	* Extensions.
1582	*/
1583	xmlHashTablePtr extInfos; /* the extension data */
1584	int extrasNr; /* the number of extras required */
1585
1586	/*
1587	* For keeping track of nested includes
1588	*/
1589	xsltDocumentPtr includes; /* points to last nested include */
1590
1591	/*
1592	* dictionary: shared between stylesheet, context and documents.
1593	*/
1594	xmlDictPtr dict;
1595	/*
1596	* precompiled attribute value templates.
1597	*/
1598	void *attVTs;
1599	/*
1600	* if namespace-alias has an alias for the default stylesheet prefix
1601	* NOTE: Not used in the refactored code.
1602	*/
1603	const xmlChar *defaultAlias;
1604	/*
1605	* bypass pre-processing (already done) (used in imports)
1606	*/
1607	int nopreproc;
1608	/*
1609	* all document text strings were internalized
1610	*/
1611	int internalized;
1612	/*
1613	* Literal Result Element as Stylesheet c.f. section 2.3
1614	*/
1615	int literal_result;
1616	/*
1617	* The principal stylesheet
1618	*/
1619	xsltStylesheetPtr principal;
1620	#ifdef XSLT_REFACTORED
1621	/*
1622	* Compilation context used during compile-time.
1623	*/
1624	xsltCompilerCtxtPtr compCtxt; /* TODO: Change this to (void *). */
1625
1626	xsltPrincipalStylesheetDataPtr principalData;
1627	#endif
1628	/*
1629	* Forwards-compatible processing
1630	*/
1631	int forwards_compatible;
1632
1633	xmlHashTablePtr namedTemplates; /* hash table of named templates */
1634
1635	xmlXPathContextPtr xpathCtxt;
1636	};
1637
1638	typedef struct _xsltTransformCache xsltTransformCache;
1639	typedef xsltTransformCache *xsltTransformCachePtr;
1640	struct _xsltTransformCache {
1641	xmlDocPtr RVT;
1642	int nbRVT;
1643	xsltStackElemPtr stackItems;
1644	int nbStackItems;
1645	#ifdef XSLT_DEBUG_PROFILE_CACHE
1646	int dbgCachedRVTs;
1647	int dbgReusedRVTs;
1648	int dbgCachedVars;
1649	int dbgReusedVars;
1650	#endif
1651	};
1652
1653	/*
1654	* The in-memory structure corresponding to an XSLT Transformation.
1655	*/
1656	typedef enum {
1657	XSLT_OUTPUT_XML = 0,
1658	XSLT_OUTPUT_HTML,
1659	XSLT_OUTPUT_TEXT
1660	} xsltOutputType;
1661
1662	typedef enum {
1663	XSLT_STATE_OK = 0,
1664	XSLT_STATE_ERROR,
1665	XSLT_STATE_STOPPED
1666	} xsltTransformState;
1667
1668	struct _xsltTransformContext {
1669	xsltStylesheetPtr style; /* the stylesheet used */
1670	xsltOutputType type; /* the type of output */
1671
1672	xsltTemplatePtr templ; /* the current template */
1673	int templNr; /* Nb of templates in the stack */
1674	int templMax; /* Size of the templtes stack */
1675	xsltTemplatePtr *templTab; /* the template stack */
1676
1677	xsltStackElemPtr vars; /* the current variable list */
1678	int varsNr; /* Nb of variable list in the stack */
1679	int varsMax; /* Size of the variable list stack */
1680	xsltStackElemPtr *varsTab; /* the variable list stack */
1681	int varsBase; /* the var base for current templ */
1682
1683	/*
1684	* Extensions
1685	*/
1686	xmlHashTablePtr extFunctions; /* the extension functions */
1687	xmlHashTablePtr extElements; /* the extension elements */
1688	xmlHashTablePtr extInfos; /* the extension data */
1689
1690	const xmlChar *mode; /* the current mode */
1691	const xmlChar *modeURI; /* the current mode URI */
1692
1693	xsltDocumentPtr docList; /* the document list */
1694
1695	xsltDocumentPtr document; /* the current source document; can be NULL if an RTF */
1696	xmlNodePtr node; /* the current node being processed */
1697	xmlNodeSetPtr nodeList; /* the current node list */
1698	/* xmlNodePtr current; the node */
1699
1700	xmlDocPtr output; /* the resulting document */
1701	xmlNodePtr insert; /* the insertion node */
1702
1703	xmlXPathContextPtr xpathCtxt; /* the XPath context */
1704	xsltTransformState state; /* the current state */
1705
1706	/*
1707	* Global variables
1708	*/
1709	xmlHashTablePtr globalVars; /* the global variables and params */
1710
1711	xmlNodePtr inst; /* the instruction in the stylesheet */
1712
1713	int xinclude; /* should XInclude be processed */
1714
1715	const char * outputFile; /* the output URI if known */
1716
1717	int profile; /* is this run profiled */
1718	long prof; /* the current profiled value */
1719	int profNr; /* Nb of templates in the stack */
1720	int profMax; /* Size of the templtaes stack */
1721	long *profTab; /* the profile template stack */
1722
1723	void *_private; /* user defined data */
1724
1725	int extrasNr; /* the number of extras used */
1726	int extrasMax; /* the number of extras allocated */
1727	xsltRuntimeExtraPtr extras; /* extra per runtime information */
1728
1729	xsltDocumentPtr styleList; /* the stylesheet docs list */
1730	void * sec; /* the security preferences if any */
1731
1732	xmlGenericErrorFunc error; /* a specific error handler */
1733	void * errctx; /* context for the error handler */
1734
1735	xsltSortFunc sortfunc; /* a ctxt specific sort routine */
1736
1737	/*
1738	* handling of temporary Result Value Tree
1739	* (XSLT 1.0 term: "Result Tree Fragment")
1740	*/
1741	xmlDocPtr tmpRVT; /* list of RVT without persistance */
1742	xmlDocPtr persistRVT; /* list of persistant RVTs */
1743	int ctxtflags; /* context processing flags */
1744
1745	/*
1746	* Speed optimization when coalescing text nodes
1747	*/
1748	const xmlChar *lasttext; /* last text node content */
1749	int lasttsize; /* last text node size */
1750	int lasttuse; /* last text node use */
1751	/*
1752	* Per Context Debugging
1753	*/
1754	int debugStatus; /* the context level debug status */
1755	unsigned long* traceCode; /* pointer to the variable holding the mask */
1756
1757	int parserOptions; /* parser options xmlParserOption */
1758
1759	/*
1760	* dictionary: shared between stylesheet, context and documents.
1761	*/
1762	xmlDictPtr dict;
1763	xmlDocPtr tmpDoc; /* Obsolete; not used in the library. */
1764	/*
1765	* all document text strings are internalized
1766	*/
1767	int internalized;
1768	int nbKeys;
1769	int hasTemplKeyPatterns;
1770	xsltTemplatePtr currentTemplateRule; /* the Current Template Rule */
1771	xmlNodePtr initialContextNode;
1772	xmlDocPtr initialContextDoc;
1773	xsltTransformCachePtr cache;
1774	void *contextVariable; /* the current variable item */
1775	xmlDocPtr localRVT; /* list of local tree fragments; will be freed when
1776	the instruction which created the fragment
1777	exits */
1778	xmlDocPtr localRVTBase; /* Obsolete */
1779	int keyInitLevel; /* Needed to catch recursive keys issues */
1780	int depth; /* Needed to catch recursions */
1781	int maxTemplateDepth;
1782	int maxTemplateVars;
1783	unsigned long opLimit;
1784	unsigned long opCount;
1785
1786	unsigned long nextid;/* for generating stable ids */
1787	};
1788
1789	/**
1790	* CHECK_STOPPED:
1791	*
1792	* Macro to check if the XSLT processing should be stopped.
1793	* Will return from the function.
1794	*/
1795	#define CHECK_STOPPED if (ctxt->state == XSLT_STATE_STOPPED) return;
1796
1797	/**
1798	* CHECK_STOPPEDE:
1799	*
1800	* Macro to check if the XSLT processing should be stopped.
1801	* Will goto the error: label.
1802	*/
1803	#define CHECK_STOPPEDE if (ctxt->state == XSLT_STATE_STOPPED) goto error;
1804
1805	/**
1806	* CHECK_STOPPED0:
1807	*
1808	* Macro to check if the XSLT processing should be stopped.
1809	* Will return from the function with a 0 value.
1810	*/
1811	#define CHECK_STOPPED0 if (ctxt->state == XSLT_STATE_STOPPED) return(0);
1812
1813	/*
1814	* The macro XML_CAST_FPTR is a hack to avoid a gcc warning about
1815	* possible incompatibilities between function pointers and object
1816	* pointers. It is defined in libxml/hash.h within recent versions
1817	* of libxml2, but is put here for compatibility.
1818	*/
1819	#ifndef XML_CAST_FPTR
1820	/**
1821	* XML_CAST_FPTR:
1822	* @fptr: pointer to a function
1823	*
1824	* Macro to do a casting from an object pointer to a
1825	* function pointer without encountering a warning from
1826	* gcc
1827	*
1828	* #define XML_CAST_FPTR(fptr) (*(void **)(&fptr))
1829	* This macro violated ISO C aliasing rules (gcc4 on s390 broke)
1830	* so it is disabled now
1831	*/
1832
1833	#define XML_CAST_FPTR(fptr) fptr
1834	#endif
1835	/*
1836	* Functions associated to the internal types
1837	xsltDecimalFormatPtr xsltDecimalFormatGetByName(xsltStylesheetPtr sheet,
1838	xmlChar *name);
1839	*/
1840	XSLTPUBFUN xsltStylesheetPtr XSLTCALL
1841	xsltNewStylesheet (void);
1842	XSLTPUBFUN xsltStylesheetPtr XSLTCALL
1843	xsltParseStylesheetFile (const xmlChar* filename);
1844	XSLTPUBFUN void XSLTCALL
1845	xsltFreeStylesheet (xsltStylesheetPtr style);
1846	XSLTPUBFUN int XSLTCALL
1847	xsltIsBlank (xmlChar *str);
1848	XSLTPUBFUN void XSLTCALL
1849	xsltFreeStackElemList (xsltStackElemPtr elem);
1850	XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL
1851	xsltDecimalFormatGetByName(xsltStylesheetPtr style,
1852	xmlChar *name);
1853	XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL
1854	xsltDecimalFormatGetByQName(xsltStylesheetPtr style,
1855	const xmlChar *nsUri,
1856	const xmlChar *name);
1857
1858	XSLTPUBFUN xsltStylesheetPtr XSLTCALL
1859	xsltParseStylesheetProcess(xsltStylesheetPtr ret,
1860	xmlDocPtr doc);
1861	XSLTPUBFUN void XSLTCALL
1862	xsltParseStylesheetOutput(xsltStylesheetPtr style,
1863	xmlNodePtr cur);
1864	XSLTPUBFUN xsltStylesheetPtr XSLTCALL
1865	xsltParseStylesheetDoc (xmlDocPtr doc);
1866	XSLTPUBFUN xsltStylesheetPtr XSLTCALL
1867	xsltParseStylesheetImportedDoc(xmlDocPtr doc,
1868	xsltStylesheetPtr style);
1869	XSLTPUBFUN int XSLTCALL
1870	xsltParseStylesheetUser(xsltStylesheetPtr style,
1871	xmlDocPtr doc);
1872	XSLTPUBFUN xsltStylesheetPtr XSLTCALL
1873	xsltLoadStylesheetPI (xmlDocPtr doc);
1874	XSLTPUBFUN void XSLTCALL
1875	xsltNumberFormat (xsltTransformContextPtr ctxt,
1876	xsltNumberDataPtr data,
1877	xmlNodePtr node);
1878	XSLTPUBFUN xmlXPathError XSLTCALL
1879	xsltFormatNumberConversion(xsltDecimalFormatPtr self,
1880	xmlChar *format,
1881	double number,
1882	xmlChar **result);
1883
1884	XSLTPUBFUN void XSLTCALL
1885	xsltParseTemplateContent(xsltStylesheetPtr style,
1886	xmlNodePtr templ);
1887	XSLTPUBFUN int XSLTCALL
1888	xsltAllocateExtra (xsltStylesheetPtr style);
1889	XSLTPUBFUN int XSLTCALL
1890	xsltAllocateExtraCtxt (xsltTransformContextPtr ctxt);
1891	/*
1892	* Extra functions for Result Value Trees
1893	*/
1894	XSLTPUBFUN xmlDocPtr XSLTCALL
1895	xsltCreateRVT (xsltTransformContextPtr ctxt);
1896	XSLTPUBFUN int XSLTCALL
1897	xsltRegisterTmpRVT (xsltTransformContextPtr ctxt,
1898	xmlDocPtr RVT);
1899	XSLTPUBFUN int XSLTCALL
1900	xsltRegisterLocalRVT (xsltTransformContextPtr ctxt,
1901	xmlDocPtr RVT);
1902	XSLTPUBFUN int XSLTCALL
1903	xsltRegisterPersistRVT (xsltTransformContextPtr ctxt,
1904	xmlDocPtr RVT);
1905	XSLTPUBFUN int XSLTCALL
1906	xsltExtensionInstructionResultRegister(
1907	xsltTransformContextPtr ctxt,
1908	xmlXPathObjectPtr obj);
1909	XSLTPUBFUN int XSLTCALL
1910	xsltExtensionInstructionResultFinalize(
1911	xsltTransformContextPtr ctxt);
1912	XSLTPUBFUN int XSLTCALL
1913	xsltFlagRVTs(
1914	xsltTransformContextPtr ctxt,
1915	xmlXPathObjectPtr obj,
1916	void *val);
1917	XSLTPUBFUN void XSLTCALL
1918	xsltFreeRVTs (xsltTransformContextPtr ctxt);
1919	XSLTPUBFUN void XSLTCALL
1920	xsltReleaseRVT (xsltTransformContextPtr ctxt,
1921	xmlDocPtr RVT);
1922	/*
1923	* Extra functions for Attribute Value Templates
1924	*/
1925	XSLTPUBFUN void XSLTCALL
1926	xsltCompileAttr (xsltStylesheetPtr style,
1927	xmlAttrPtr attr);
1928	XSLTPUBFUN xmlChar * XSLTCALL
1929	xsltEvalAVT (xsltTransformContextPtr ctxt,
1930	void *avt,
1931	xmlNodePtr node);
1932	XSLTPUBFUN void XSLTCALL
1933	xsltFreeAVTList (void *avt);
1934
1935	/*
1936	* Extra function for successful xsltCleanupGlobals / xsltInit sequence.
1937	*/
1938
1939	XSLTPUBFUN void XSLTCALL
1940	xsltUninit (void);
1941
1942	/************************************************************************
1943	* *
1944	* Compile-time functions for *internal* use only *
1945	* *
1946	************************************************************************/
1947
1948	#ifdef XSLT_REFACTORED
1949	XSLTPUBFUN void XSLTCALL
1950	xsltParseSequenceConstructor(
1951	xsltCompilerCtxtPtr cctxt,
1952	xmlNodePtr start);
1953	XSLTPUBFUN int XSLTCALL
1954	xsltParseAnyXSLTElem (xsltCompilerCtxtPtr cctxt,
1955	xmlNodePtr elem);
1956	#ifdef XSLT_REFACTORED_XSLT_NSCOMP
1957	XSLTPUBFUN int XSLTCALL
1958	xsltRestoreDocumentNamespaces(
1959	xsltNsMapPtr ns,
1960	xmlDocPtr doc);
1961	#endif
1962	#endif /* XSLT_REFACTORED */
1963
1964	/************************************************************************
1965	* *
1966	* Transformation-time functions for *internal* use only *
1967	* *
1968	************************************************************************/
1969	XSLTPUBFUN int XSLTCALL
1970	xsltInitCtxtKey (xsltTransformContextPtr ctxt,
1971	xsltDocumentPtr doc,
1972	xsltKeyDefPtr keyd);
1973	XSLTPUBFUN int XSLTCALL
1974	xsltInitAllDocKeys (xsltTransformContextPtr ctxt);
1975	#ifdef __cplusplus
1976	}
1977	#endif
1978
1979	#endif /* __XML_XSLT_H__ */
1980
1981