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