Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libxslt/xsltInternals.h

 /*
  * Summary: internal data structures, constants and functions
  * Description: Internal data structures, constants and functions used
- *              by the XSLT engine. 
+ *              by the XSLT engine.
  *              They are not part of the API or ABI, i.e. they can change
  *              without prior notice, use carefully.
  *
  * Copy: See Copyright for the status of this software.
  *
  * Author: Daniel Veillard
  */
 
 #ifndef __XML_XSLT_INTERNALS_H__
 #define __XML_XSLT_INTERNALS_H__
@@ skipping 79 matching lines @@
 
 
 /* TODO: REMOVE: #define XSLT_REFACTORED_EXCLRESNS */
 
 /* TODO: REMOVE: #define XSLT_REFACTORED_NSALIAS */
 
 /**
  * XSLT_REFACTORED_XSLT_NSCOMP
  *
  * Internal define to enable the pointer-comparison of
- * namespaces of XSLT elements. 
+ * namespaces of XSLT elements.
  */
 /* #define XSLT_REFACTORED_XSLT_NSCOMP */
 
 /**
  * XSLT_REFACTORED_XPATHCOMP:
  *
  * Internal define to enable the optimization of the
  * compilation of XPath expressions.
  */
 #define XSLT_REFACTORED_XPATHCOMP
@@ skipping 172 matching lines @@
     * TODO: @inheritedNsNr and @inheritedNs won't be used in the
     *  refactored code.
     */
     int inheritedNsNr;  /* number of inherited namespaces */
     xmlNsPtr *inheritedNs;/* inherited non-excluded namespaces */
 
     /* Profiling informations */
     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 */
 };
 
 /**
  * xsltDecimalFormat:
  *
  * Data structure of decimal-format.
  */
 typedef struct _xsltDecimalFormat xsltDecimalFormat;
 typedef xsltDecimalFormat *xsltDecimalFormatPtr;
 struct _xsltDecimalFormat {
@@ skipping 160 matching lines @@
  *
  * The basic structure for compiled items of the AST of the XSLT processor.
  * This structure is also intended to be extended by extension implementors.
  * TODO: This is somehow not nice, since it has a "free" field, which
  *   derived stylesheet-structs do not have.
  */
 struct _xsltElemPreComp {
     xsltElemPreCompPtr next;            /* next item in the global chained
                                            list hold by xsltStylesheet. */
     xsltStyleType type;         /* type of the element */
-    xsltTransformFunction func;         /* handling function */
+    xsltTransformFunction func; /* handling function */
     xmlNodePtr inst;                    /* the node in the stylesheet's tree
                                            corresponding to this item */
 
     /* end of common part */
     xsltElemPreCompDeallocator free;    /* the deallocator */
 };
 
 /**
  * xsltStylePreComp:
  *
@@ skipping 11 matching lines @@
 /*
 * Some pointer-list utility functions.
 */
 XSLTPUBFUN xsltPointerListPtr XSLTCALL
                 xsltPointerListCreate           (int initialSize);
 XSLTPUBFUN void XSLTCALL
                 xsltPointerListFree             (xsltPointerListPtr list);
 XSLTPUBFUN void XSLTCALL
                 xsltPointerListClear            (xsltPointerListPtr list);
 XSLTPUBFUN int XSLTCALL
-                xsltPointerListAddSize          (xsltPointerListPtr list,                                                
+                xsltPointerListAddSize          (xsltPointerListPtr list,
                                                  void *item,
                                                  int initialSize);
 
 /************************************************************************
  *                                                                      *
  * Refactored structures                                                *
  *                                                                      *
  ************************************************************************/
 
 typedef struct _xsltNsListContainer xsltNsListContainer;
 typedef xsltNsListContainer *xsltNsListContainerPtr;
 struct _xsltNsListContainer {
     xmlNsPtr *list;
     int totalNumber;
-    int xpathNumber;    
+    int xpathNumber;
 };
 
 /**
  * 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.
  */
 #define XSLT_ITEM_COMPATIBILITY_FIELDS \
     xsltElemPreCompPtr next;\
     xsltStyleType type;\
     xsltTransformFunction func;\
     xmlNodePtr inst;
 
 /**
  * XSLT_ITEM_NAVIGATION_FIELDS:
  *
  * Currently empty.
  * TODO: It is intended to hold navigational fields in the future.
  */
 #define XSLT_ITEM_NAVIGATION_FIELDS
 /*
     xsltStylePreCompPtr parent;\
     xsltStylePreCompPtr children;\
-    xsltStylePreCompPtr nextItem; 
+    xsltStylePreCompPtr nextItem;
 */
 
 /**
  * XSLT_ITEM_NSINSCOPE_FIELDS:
  *
  * The in-scope namespaces.
  */
 #define XSLT_ITEM_NSINSCOPE_FIELDS xsltNsListContainerPtr inScopeNs;
 
 /**
  * XSLT_ITEM_COMMON_FIELDS:
  *
  * Common fields used for all items.
  */
 #define XSLT_ITEM_COMMON_FIELDS \
     XSLT_ITEM_COMPATIBILITY_FIELDS \
     XSLT_ITEM_NAVIGATION_FIELDS \
     XSLT_ITEM_NSINSCOPE_FIELDS
 
 /**
- * _xsltStylePreComp: 
+ * _xsltStylePreComp:
  *
  * The abstract basic structure for items of the XSLT processor.
  * This includes:
  * 1) compiled forms of XSLT instructions (e.g. xsl:if, xsl:attribute, etc.)
  * 2) compiled forms of literal result elements
  * 3) various properties for XSLT instructions (e.g. xsl:when,
  *    xsl:with-param)
  *
  * REVISIT TODO: Keep this structure equal to the fields
  *   defined by XSLT_ITEM_COMMON_FIELDS
  */
 struct _xsltStylePreComp {
     xsltElemPreCompPtr next;    /* next item in the global chained
                                    list hold by xsltStylesheet */
-    xsltStyleType type;         /* type of the item */ 
+    xsltStyleType type;         /* type of the item */
     xsltTransformFunction func; /* handling function */
     xmlNodePtr inst;            /* the node in the stylesheet's tree
                                    corresponding to this item. */
     /* Currently no navigational fields. */
     xsltNsListContainerPtr inScopeNs;
 };
 
 /**
  * xsltStyleBasicEmptyItem:
- * 
+ *
  * Abstract structure only used as a short-cut for
  * XSLT items with no extra fields.
  * NOTE that it is intended that this structure looks the same as
  *  _xsltStylePreComp.
  */
 typedef struct _xsltStyleBasicEmptyItem xsltStyleBasicEmptyItem;
 typedef xsltStyleBasicEmptyItem *xsltStyleBasicEmptyItemPtr;
 
 struct _xsltStyleBasicEmptyItem {
     XSLT_ITEM_COMMON_FIELDS
 };
 
 /**
  * xsltStyleBasicExpressionItem:
- * 
+ *
  * Abstract structure only used as a short-cut for
  * XSLT items with just an expression.
  */
 typedef struct _xsltStyleBasicExpressionItem xsltStyleBasicExpressionItem;
 typedef xsltStyleBasicExpressionItem *xsltStyleBasicExpressionItemPtr;
 
 struct _xsltStyleBasicExpressionItem {
     XSLT_ITEM_COMMON_FIELDS
 
     const xmlChar *select; /* TODO: Change this to "expression". */
     xmlXPathCompExprPtr comp; /* TODO: Change this to compExpr. */
 };
 
 /************************************************************************
  *                                                                      *
  * XSLT-instructions/declarations                                       *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xsltStyleItemElement:
- * 
+ *
  * <!-- Category: instruction -->
  * <xsl:element
  *  name = { qname }
  *  namespace = { uri-reference }
  *  use-attribute-sets = qnames>
  *  <!-- Content: template -->
  * </xsl:element>
  */
 typedef struct _xsltStyleItemElement xsltStyleItemElement;
 typedef xsltStyleItemElement *xsltStyleItemElementPtr;
 
 struct _xsltStyleItemElement {
-    XSLT_ITEM_COMMON_FIELDS 
+    XSLT_ITEM_COMMON_FIELDS
 
     const xmlChar *use;
     int      has_use;
-    const xmlChar *name;    
+    const xmlChar *name;
     int      has_name;
     const xmlChar *ns;
     const xmlChar *nsPrefix;
     int      has_ns;
 };
 
 /**
  * xsltStyleItemAttribute:
  *
  * <!-- Category: instruction -->
@@ skipping 124 matching lines @@
  *  use-attribute-sets = qnames>
  *  <!-- Content: template -->
  * </xsl:copy>
  */
 typedef struct _xsltStyleItemCopy xsltStyleItemCopy;
 typedef xsltStyleItemCopy *xsltStyleItemCopyPtr;
 
 struct _xsltStyleItemCopy {
    XSLT_ITEM_COMMON_FIELDS
     const xmlChar *use;         /* copy, element */
-    int      has_use;           /* copy, element */    
+    int      has_use;           /* copy, element */
 };
 
 /**
  * xsltStyleItemIf:
  *
  * <!-- Category: instruction -->
  *  <xsl:if
  *  test = boolean-expression>
  *  <!-- Content: template -->
  * </xsl:if>
@@ skipping 101 matching lines @@
  * <!-- Category: instruction -->
  * <xsl:message
  *   terminate = "yes" | "no">
  *   <!-- Content: template -->
  * </xsl:message>
  */
 typedef struct _xsltStyleItemMessage xsltStyleItemMessage;
 typedef xsltStyleItemMessage *xsltStyleItemMessagePtr;
 
 struct _xsltStyleItemMessage {
-    XSLT_ITEM_COMMON_FIELDS    
+    XSLT_ITEM_COMMON_FIELDS
     int terminate;
 };
 
 /**
  * xsltStyleItemDocument:
  *
  * NOTE: This is not an instruction of XSLT 1.0.
  */
 typedef struct _xsltStyleItemDocument xsltStyleItemDocument;
 typedef xsltStyleItemDocument *xsltStyleItemDocumentPtr;
 
 struct _xsltStyleItemDocument {
     XSLT_ITEM_COMMON_FIELDS
     int      ver11;             /* assigned: in xsltDocumentComp;
                                   read: nowhere;
                                   TODO: Check if we need. */
     const xmlChar *filename;    /* document URL */
     int has_filename;
-};   
+};
 
 /************************************************************************
  *                                                                      *
  * Non-instructions (actually properties of instructions/declarations)  *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xsltStyleBasicItemVariable:
  *
@@ skipping 49 matching lines @@
 
 struct _xsltStyleItemParam {
     XSLT_ITEM_COMMON_FIELDS
 
     const xmlChar *select;
     xmlXPathCompExprPtr comp;
 
     const xmlChar *name;
     int      has_name;
     const xmlChar *ns;
-    int      has_ns;    
+    int      has_ns;
 };
 
 /**
  * xsltStyleItemWithParam:
  *
  * <xsl:with-param
  *  name = qname
  *  select = expression>
  *  <!-- Content: template -->
  * </xsl:with-param>
@@ skipping 35 matching lines @@
     int      has_use;
 
     const xmlChar *select;      /* sort, copy-of, value-of, apply-templates */
 
     xmlXPathCompExprPtr comp;   /* a precompiled XPath expression */
 };
 
 
 /**
  * xsltStyleItemWhen:
- * 
+ *
  * <xsl:when
  *   test = boolean-expression>
  *   <!-- Content: template -->
  * </xsl:when>
  * Allowed parent: xsl:choose
  */
 typedef struct _xsltStyleItemWhen xsltStyleItemWhen;
 typedef xsltStyleItemWhen *xsltStyleItemWhenPtr;
 
 struct _xsltStyleItemWhen {
@@ skipping 62 matching lines @@
  *  the xsltElemPreCompPtr.
  *  However the place where the structure is anchored in the node-tree,
  *  namely node->psvi, has beed already once been moved from node->_private
  *  to node->psvi, so we have a precedent here, which, I think, should allow
  *  us to change such semantics without headaches.
  */
 typedef struct _xsltStyleItemExtElement xsltStyleItemExtElement;
 typedef xsltStyleItemExtElement *xsltStyleItemExtElementPtr;
 struct _xsltStyleItemExtElement {
     XSLT_ITEM_COMMON_FIELDS
-    xsltElemPreCompPtr item;   
+    xsltElemPreCompPtr item;
 };
 
 /************************************************************************
  *                                                                      *
  *  Literal result elements                                             *
  *                                                                      *
  ************************************************************************/
 
 typedef struct _xsltEffectiveNs xsltEffectiveNs;
 typedef xsltEffectiveNs *xsltEffectiveNsPtr;
 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
     * needed.
     */
     int holdByElem;
 };
 
 /*
  * Info for literal result elements.
  * This will be set on the elem->psvi field and will be
  * shared by literal result elements, which have the same
@@ skipping 15 matching lines @@
     */
     xsltEffectiveNsPtr effectiveNs;
 
 };
 
 #ifdef XSLT_REFACTORED
 
 typedef struct _xsltNsAlias xsltNsAlias;
 typedef xsltNsAlias *xsltNsAliasPtr;
 struct _xsltNsAlias {
-    xsltNsAliasPtr next; /* next in the list */    
+    xsltNsAliasPtr next; /* next in the list */
     xmlNsPtr literalNs;
     xmlNsPtr targetNs;
     xmlDocPtr docOfTargetNs;
 };
 #endif
 
 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
 
 typedef struct _xsltNsMap xsltNsMap;
 typedef xsltNsMap *xsltNsMapPtr;
 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 */    
+    const xmlChar *newNsName; /* the mapped XML namespace name */
 };
 #endif
 
 /************************************************************************
  *                                                                      *
  *  Compile-time structures for *internal* use only                     *
  *                                                                      *
  ************************************************************************/
 
 typedef struct _xsltPrincipalStylesheetData xsltPrincipalStylesheetData;
@@ skipping 34 matching lines @@
     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; 
+    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 namespaces changed,
     *  or extension element namespaces changed.
     * This will trigger creation of new infos
     *  for literal result elements.
     */
     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 extension element was processed */
     int extContentHandled;
     /* the type of the current child */
-    xsltStyleType curChildType;    
+    xsltStyleType curChildType;
 };
 
 /**
  * XSLT_CCTXT:
  *
  * get pointer to compiler context
  */
-#define XSLT_CCTXT(style) ((xsltCompilerCtxtPtr) style->compCtxt) 
+#define XSLT_CCTXT(style) ((xsltCompilerCtxtPtr) style->compCtxt)
 
 typedef enum {
     XSLT_ERROR_SEVERITY_ERROR = 0,
     XSLT_ERROR_SEVERITY_WARNING
 } xsltErrorSeverityType;
 
 typedef struct _xsltCompilerCtxt xsltCompilerCtxt;
 typedef xsltCompilerCtxt *xsltCompilerCtxtPtr;
 struct _xsltCompilerCtxt {
     void *errorCtxt;            /* user specific error context */
     /*
     * used for error/warning reports; e.g. XSLT_ERROR_SEVERITY_WARNING */
-    xsltErrorSeverityType errSeverity;          
+    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 error contexts. */
     int depth; /* Current depth of processing */
-    
+
     xsltCompilerNodeInfoPtr inode;
     xsltCompilerNodeInfoPtr inodeList;
     xsltCompilerNodeInfoPtr inodeLast;
     xsltPointerListPtr tmpList; /* Used for various purposes */
     /*
     * 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;  /* TEMP TODO: just for the interest */
-    /* 
+    /*
     * In order to keep the old behaviour, applying strict rules of
     * the spec can be turned off. This has effect only on special
     * mechanisms like whitespace-stripping in the stylesheet.
     */
     int strict;
     xsltPrincipalStylesheetDataPtr psData;
 #ifdef XSLT_REFACTORED_XPATHCOMP
     xmlXPathContextPtr xpathCtxt;
 #endif
     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. */
-};   
+};
 
 #else /* XSLT_REFACTORED */
 /*
 * The old structures before refactoring.
 */
 
 /**
  * _xsltStylePreComp:
  *
  * The in-memory structure corresponding to XSLT stylesheet constructs
@@ skipping 102 matching lines @@
     xsltPointerListPtr extElemNamespaces;
     xsltEffectiveNsPtr effectiveNs;
 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
     /*
     * Namespace name map to get rid of string comparison of namespace names.
     */
     xsltNsMapPtr nsMap;
 #endif
 };
 
-    
+
 #endif
 /*
  * Note that we added a @compCtxt field to anchor an stylesheet compilation
  * context, since, due to historical reasons, various compile-time function
  * take only the stylesheet as argument and not a compilation context.
  */
 struct _xsltStylesheet {
     /*
      * The stylesheet import relation is kept as a tree.
      */
@@ skipping 24 matching lines @@
     void *templatesHash;        /* hash table or wherever compiled templates
                                    informations are 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;         /* template based on comment() */
-    
+
     /*
      * Namespace aliases.
      * NOTE: Not used in the refactored code.
      */
     xmlHashTablePtr nsAliases;  /* the namespace alias hash tables */
 
     /*
      * Attribute sets.
      */
     xmlHashTablePtr attributeSets;/* the attribute sets hash tables */
 
     /*
      * Namespaces.
      * TODO: Eliminate this.
      */
     xmlHashTablePtr nsHash;     /* the set of namespaces in use:
                                    ATTENTION: This is used for
                                    execution of XPath expressions; unfortunately
                                    it restricts the stylesheet to have distinct
                                    prefixes.
-                                   TODO: We need to get rid of this.    
+                                   TODO: We need to get rid of this.
                                  */
     void           *nsDefs;     /* ATTENTION TODO: This is currently used to store
                                    xsltExtDefPtr (in extensions.c) and
                                    *not* xmlNsPtr.
                                  */
 
     /*
      * Key definitions.
      */
     void *keys;                 /* key definitions */
 
     /*
      * Output related stuff.
      */
     xmlChar *method;            /* the output method */
     xmlChar *methodURI;         /* associated namespace if any */
     xmlChar *version;           /* version string */
     xmlChar *encoding;          /* encoding string */
     int omitXmlDeclaration;     /* omit-xml-declaration = "yes" | "no" */
 
-    /* 
+    /*
      * 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;         /* media-type string */
 
     /*
@@ skipping 49 matching lines @@
     /*
     * The principal stylesheet
     */
     xsltStylesheetPtr principal;
 #ifdef XSLT_REFACTORED
     /*
     * Compilation context used during compile-time.
     */
     xsltCompilerCtxtPtr compCtxt; /* TODO: Change this to (void *). */
 
-    xsltPrincipalStylesheetDataPtr principalData;    
+    xsltPrincipalStylesheetDataPtr principalData;
 #endif
+    /*
+     * Forwards-compatible processing
+     */
+    int forwards_compatible;
 };
 
 typedef struct _xsltTransformCache xsltTransformCache;
 typedef xsltTransformCache *xsltTransformCachePtr;
 struct _xsltTransformCache {
     xmlDocPtr RVT;
     int nbRVT;
     xsltStackElemPtr stackItems;
     int nbStackItems;
 #ifdef XSLT_DEBUG_PROFILE_CACHE
@@ skipping 125 matching lines @@
     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 which created the fragment
                            exits */
     xmlDocPtr localRVTBase;
     int keyInitLevel;   /* Needed to catch recursive keys issues */
     int funcLevel;      /* Needed to catch recursive functions issues */
+    int maxTemplateDepth;
+    int maxTemplateVars;
 };
 
 /**
  * CHECK_STOPPED:
  *
  * Macro to check if the XSLT processing should be stopped.
  * Will return from the function.
  */
 #define CHECK_STOPPED if (ctxt->state == XSLT_STATE_STOPPED) return;
 
@@ skipping 33 matching lines @@
  * so it is disabled now
  */
 
 #define XML_CAST_FPTR(fptr) fptr
 #endif
 /*
  * Functions associated to the internal types
 xsltDecimalFormatPtr    xsltDecimalFormatGetByName(xsltStylesheetPtr sheet,
                                                    xmlChar *name);
  */
-XSLTPUBFUN xsltStylesheetPtr XSLTCALL   
+XSLTPUBFUN xsltStylesheetPtr XSLTCALL
                         xsltNewStylesheet       (void);
-XSLTPUBFUN xsltStylesheetPtr XSLTCALL   
+XSLTPUBFUN xsltStylesheetPtr XSLTCALL
                         xsltParseStylesheetFile (const xmlChar* filename);
-XSLTPUBFUN void XSLTCALL                        
+XSLTPUBFUN void XSLTCALL
                         xsltFreeStylesheet      (xsltStylesheetPtr style);
-XSLTPUBFUN int XSLTCALL                 
+XSLTPUBFUN int XSLTCALL
                         xsltIsBlank             (xmlChar *str);
-XSLTPUBFUN void XSLTCALL                        
+XSLTPUBFUN void XSLTCALL
                         xsltFreeStackElemList   (xsltStackElemPtr elem);
-XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL        
+XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL
                         xsltDecimalFormatGetByName(xsltStylesheetPtr style,
                                                  xmlChar *name);
 
-XSLTPUBFUN xsltStylesheetPtr XSLTCALL   
+XSLTPUBFUN xsltStylesheetPtr XSLTCALL
                         xsltParseStylesheetProcess(xsltStylesheetPtr ret,
                                                  xmlDocPtr doc);
-XSLTPUBFUN void XSLTCALL                        
+XSLTPUBFUN void XSLTCALL
                         xsltParseStylesheetOutput(xsltStylesheetPtr style,
                                                  xmlNodePtr cur);
-XSLTPUBFUN xsltStylesheetPtr XSLTCALL   
+XSLTPUBFUN xsltStylesheetPtr XSLTCALL
                         xsltParseStylesheetDoc  (xmlDocPtr doc);
-XSLTPUBFUN xsltStylesheetPtr XSLTCALL   
+XSLTPUBFUN xsltStylesheetPtr XSLTCALL
                         xsltParseStylesheetImportedDoc(xmlDocPtr doc,
                                                 xsltStylesheetPtr style);
-XSLTPUBFUN xsltStylesheetPtr XSLTCALL   
+XSLTPUBFUN xsltStylesheetPtr XSLTCALL
                         xsltLoadStylesheetPI    (xmlDocPtr doc);
-XSLTPUBFUN void XSLTCALL                        
+XSLTPUBFUN void XSLTCALL
                         xsltNumberFormat        (xsltTransformContextPtr ctxt,
                                                  xsltNumberDataPtr data,
                                                  xmlNodePtr node);
-XSLTPUBFUN xmlXPathError XSLTCALL                
+XSLTPUBFUN xmlXPathError XSLTCALL
                         xsltFormatNumberConversion(xsltDecimalFormatPtr self,
                                                  xmlChar *format,
                                                  double number,
                                                  xmlChar **result);
 
-XSLTPUBFUN void XSLTCALL                        
+XSLTPUBFUN void XSLTCALL
                         xsltParseTemplateContent(xsltStylesheetPtr style,
                                                  xmlNodePtr templ);
-XSLTPUBFUN int XSLTCALL                 
+XSLTPUBFUN int XSLTCALL
                         xsltAllocateExtra       (xsltStylesheetPtr style);
-XSLTPUBFUN int XSLTCALL                 
+XSLTPUBFUN int XSLTCALL
                         xsltAllocateExtraCtxt   (xsltTransformContextPtr ctxt);
 /*
  * Extra functions for Result Value Trees
  */
-XSLTPUBFUN xmlDocPtr XSLTCALL           
+XSLTPUBFUN xmlDocPtr XSLTCALL
                         xsltCreateRVT           (xsltTransformContextPtr ctxt);
-XSLTPUBFUN int XSLTCALL                 
+XSLTPUBFUN int XSLTCALL
                         xsltRegisterTmpRVT      (xsltTransformContextPtr ctxt,
                                                  xmlDocPtr RVT);
-XSLTPUBFUN int XSLTCALL                 
+XSLTPUBFUN int XSLTCALL
                         xsltRegisterLocalRVT    (xsltTransformContextPtr ctxt,
                                                  xmlDocPtr RVT);
-XSLTPUBFUN int XSLTCALL                 
+XSLTPUBFUN int XSLTCALL
                         xsltRegisterPersistRVT  (xsltTransformContextPtr ctxt,
                                                  xmlDocPtr RVT);
 XSLTPUBFUN int XSLTCALL
                         xsltExtensionInstructionResultRegister(
                                                  xsltTransformContextPtr ctxt,
                                                  xmlXPathObjectPtr obj);
 XSLTPUBFUN int XSLTCALL
                         xsltExtensionInstructionResultFinalize(
                                                  xsltTransformContextPtr ctxt);
 XSLTPUBFUN void XSLTCALL
                         xsltFreeRVTs            (xsltTransformContextPtr ctxt);
 XSLTPUBFUN void XSLTCALL
                         xsltReleaseRVT          (xsltTransformContextPtr ctxt,
                                                  xmlDocPtr RVT);
-XSLTPUBFUN int XSLTCALL
-                        xsltTransStorageAdd     (xsltTransformContextPtr ctxt,
-                                                 void *id,
-                                                 void *data);
-XSLTPUBFUN void * XSLTCALL
-                        xsltTransStorageRemove  (xsltTransformContextPtr ctxt,
-                                                 void *id);
-
 /*
  * Extra functions for Attribute Value Templates
  */
 XSLTPUBFUN void XSLTCALL
                         xsltCompileAttr         (xsltStylesheetPtr style,
                                                  xmlAttrPtr attr);
 XSLTPUBFUN xmlChar * XSLTCALL
                         xsltEvalAVT             (xsltTransformContextPtr ctxt,
                                                  void *avt,
                                                  xmlNodePtr node);
 XSLTPUBFUN void XSLTCALL
                         xsltFreeAVTList         (void *avt);
 
 /*
  * Extra function for successful xsltCleanupGlobals / xsltInit sequence.
  */
 
 XSLTPUBFUN void XSLTCALL
                         xsltUninit              (void);
 
 /************************************************************************
  *                                                                      *
  *  Compile-time functions for *internal* use only                      *
  *                                                                      *
  ************************************************************************/
 
-#ifdef XSLT_REFACTORED  
+#ifdef XSLT_REFACTORED
 XSLTPUBFUN void XSLTCALL
                         xsltParseSequenceConstructor(
                                                  xsltCompilerCtxtPtr cctxt,
                                                  xmlNodePtr start);
 XSLTPUBFUN int XSLTCALL
                         xsltParseAnyXSLTElem    (xsltCompilerCtxtPtr cctxt,
                                                  xmlNodePtr elem);
 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
 XSLTPUBFUN int XSLTCALL
                         xsltRestoreDocumentNamespaces(
@@ skipping 12 matching lines @@
                                                  xsltDocumentPtr doc,
                                                  xsltKeyDefPtr keyd);
 XSLTPUBFUN int XSLTCALL
                         xsltInitAllDocKeys      (xsltTransformContextPtr ctxt);
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* __XML_XSLT_H__ */