1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 #if !defined(STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680) 19 #define STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680 20 21 22 23 // Base class include file. 24 #include <xalanc/XSLT/StylesheetExecutionContext.hpp> 25 26 27 28 #include <ctime> 29 #include <memory> 30 31 32 33 #include <xalanc/Include/XalanVector.hpp> 34 #include <xalanc/Include/XalanMap.hpp> 35 #include <xalanc/Include/XalanSet.hpp> 36 #include <xalanc/Include/XalanObjectCache.hpp> 37 #include <xalanc/Include/XalanObjectStackCache.hpp> 38 39 40 #include <xalanc/PlatformSupport/DOMStringHelper.hpp> 41 42 43 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 44 #include <xalanc/PlatformSupport/DOMStringPrintWriter.hpp> 45 #endif 46 47 48 49 #include <xalanc/XPath/XPathExecutionContextDefault.hpp> 50 51 52 53 #include <xalanc/XMLSupport/FormatterToText.hpp> 54 55 56 57 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) 58 #include <xalanc/XalanSourceTree/XalanSourceTreeDocument.hpp> 59 #endif 60 #include <xalanc/XalanSourceTree/FormatterToSourceTree.hpp> 61 #include <xalanc/XalanSourceTree/XalanSourceTreeDocumentFragment.hpp> 62 63 64 65 #include <xalanc/XSLT/CountersTable.hpp> 66 #include <xalanc/XSLT/NodeSorter.hpp> 67 #include <xalanc/XSLT/Stylesheet.hpp> 68 #include <xalanc/XSLT/VariablesStack.hpp> 69 #include <xalanc/XSLT/XResultTreeFragAllocator.hpp> 70 #include <xalanc/XSLT/XalanSourceTreeDocumentAllocator.hpp> 71 #include <xalanc/XSLT/XalanSourceTreeDocumentFragmentAllocator.hpp> 72 73 74 75 namespace XALAN_CPP_NAMESPACE { 76 77 78 79 class XalanSourceTreeDocument; 80 class XPathProcessor; 81 class XSLTEngineImpl; 82 83 typedef VariablesStack::ParamsVectorType ParamsVectorTypeDecl; 84 XALAN_USES_MEMORY_MANAGER(ParamsVectorTypeDecl) 85 // 86 // An class which provides support for executing stylesheets. 87 // 88 class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext 89 { 90 public: 91 92 typedef std::clock_t ClockType; 93 94 typedef XalanVector<FormatterListener*> FormatterListenerVectorType; 95 typedef XalanVector<PrintWriter*> PrintWriterVectorType; 96 typedef XalanVector<XalanOutputStream*> OutputStreamVectorType; 97 98 typedef XalanVector<const ElemTemplateElement*> ElementTemplateElementStackType; 99 typedef std::pair<const XPath*, ClockType> XPathCacheEntry; 100 typedef XalanMap <XalanDOMString, XPathCacheEntry> XPathCacheMapType; 101 typedef XalanVector<const ElemTemplate*> CurrentTemplateStackType; 102 103 typedef Stylesheet::KeyTablesTableType KeyTablesTableType; 104 typedef ParamsVectorTypeDecl ParamsVectorType; 105 106 /** 107 * Construct a StylesheetExecutionContextDefault object 108 * 109 * @param theXPathEnvSupport XPath environment support class instance 110 * @param theDOMSupport DOMSupport class instance 111 * @param theXobjectFactory factory class instance for XObjects 112 * @param theCurrentNode current node in the source tree 113 * @param theContextNodeList node list for current context 114 * @param thePrefixResolver pointer to prefix resolver to use 115 */ 116 StylesheetExecutionContextDefault( 117 MemoryManager& theManager, 118 XSLTEngineImpl& xsltProcessor, 119 XPathEnvSupport& theXPathEnvSupport, 120 DOMSupport& theDOMSupport, 121 XObjectFactory& theXObjectFactory, 122 XalanNode* theCurrentNode = 0, 123 const NodeRefListBase* theContextNodeList = 0, 124 const PrefixResolver* thePrefixResolver = 0); 125 126 /** 127 * Construct a StylesheetExecutionContextDefault object 128 * 129 * @param theXPathEnvSupport XPath environment support class instance 130 * @param theDOMSupport DOMSupport class instance 131 * @param theXobjectFactory factory class instance for XObjects 132 * @param theCurrentNode current node in the source tree 133 * @param theContextNodeList node list for current context 134 * @param thePrefixResolver pointer to prefix resolver to use 135 */ 136 explicit 137 StylesheetExecutionContextDefault( 138 MemoryManager& theManager, 139 XalanNode* theCurrentNode = 0, 140 const NodeRefListBase* theContextNodeList = 0, 141 const PrefixResolver* thePrefixResolver = 0); 142 143 static StylesheetExecutionContextDefault* 144 create( 145 MemoryManager& theManager, 146 XalanNode* theCurrentNode = 0, 147 const NodeRefListBase* theContextNodeList = 0, 148 const PrefixResolver* thePrefixResolver = 0); 149 150 virtual 151 ~StylesheetExecutionContextDefault(); 152 153 154 /** 155 * Set the XPathEnvSupport instance. 156 * 157 * @param theSupport a reference to the instance to use. 158 */ 159 void setXPathEnvSupport(XPathEnvSupport * theSupport)160 setXPathEnvSupport(XPathEnvSupport* theSupport) 161 { 162 m_xpathExecutionContextDefault.setXPathEnvSupport(theSupport); 163 } 164 165 /** 166 * Set the DOMSupport instance. 167 * 168 * @param theDOMSupport a reference to the instance to use. 169 */ 170 void setDOMSupport(DOMSupport * theDOMSupport)171 setDOMSupport(DOMSupport* theDOMSupport) 172 { 173 m_xpathExecutionContextDefault.setDOMSupport(theDOMSupport); 174 } 175 176 /** 177 * Set the XObjectFactory instance. 178 * 179 * @param theFactory a reference to the instance to use. 180 */ 181 void setXObjectFactory(XObjectFactory * theXObjectFactory)182 setXObjectFactory(XObjectFactory* theXObjectFactory) 183 { 184 m_xpathExecutionContextDefault.setXObjectFactory(theXObjectFactory); 185 186 m_xobjectFactory = theXObjectFactory; 187 } 188 189 190 /** 191 * Set the DOMSupport instance. 192 * 193 * @param theDOMSupport a reference to the instance to use. 194 */ 195 void setXSLTProcessor(XSLTEngineImpl * theProcessor)196 setXSLTProcessor(XSLTEngineImpl* theProcessor) 197 { 198 m_xsltProcessor = theProcessor; 199 } 200 201 bool getUsePerInstanceDocumentFactory() const202 getUsePerInstanceDocumentFactory() const 203 { 204 return m_usePerInstanceDocumentFactory; 205 } 206 207 void setUsePerInstanceDocumentFactory(bool fValue)208 setUsePerInstanceDocumentFactory(bool fValue) 209 { 210 m_usePerInstanceDocumentFactory = fValue; 211 } 212 213 214 // These interfaces are inherited from StylesheetExecutionContext... 215 216 virtual bool 217 getQuietConflictWarnings() const; 218 219 virtual bool 220 getCopyTextNodesOnly() const; 221 222 virtual void 223 pushCopyTextNodesOnly(bool copyTextNodesOnly); 224 225 virtual bool 226 popCopyTextNodesOnly(); 227 228 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 229 virtual void 230 pushProcessCurrentAttribute(bool processAttribute); 231 232 virtual bool 233 popProcessCurrentAttribute(); 234 235 virtual void 236 pushSkipElementAttributes(bool skipAttributes); 237 238 virtual bool 239 getSkipElementAttributes() const; 240 241 virtual bool 242 popSkipElementAttributes(); 243 244 virtual void 245 pushExecuteIf(bool executeIf); 246 247 virtual bool 248 popExecuteIf(); 249 #endif 250 251 virtual XalanNode* 252 getRootDocument() const; 253 254 virtual void 255 setRootDocument(XalanNode* theDocument); 256 257 virtual void 258 setStylesheetRoot(const StylesheetRoot* theStylesheet); 259 260 virtual const XalanQName* 261 getCurrentMode() const; 262 263 virtual void 264 pushCurrentMode(const XalanQName* theMode); 265 266 virtual void 267 popCurrentMode(); 268 269 virtual const ElemTemplate* 270 getCurrentTemplate() const; 271 272 virtual void 273 pushCurrentTemplate(const ElemTemplate* theTemplate); 274 275 virtual void 276 popCurrentTemplate(); 277 278 virtual bool 279 isElementPending() const; 280 281 virtual void 282 replacePendingAttribute( 283 const XalanDOMChar* theName, 284 const XalanDOMChar* theNewType, 285 const XalanDOMChar* theNewValue); 286 287 virtual void 288 pushOutputContext(FormatterListener* flistener = 0); 289 290 virtual void 291 popOutputContext(); 292 293 virtual void 294 addResultAttribute( 295 const XalanDOMString& aname, 296 const XalanDOMString& value); 297 298 virtual void 299 addResultAttribute( 300 const XalanDOMString& aname, 301 const XalanDOMChar* value); 302 303 virtual void 304 copyNamespaceAttributes(const XalanNode& src); 305 306 virtual const XalanDOMString* 307 getResultPrefixForNamespace(const XalanDOMString& theNamespace) const; 308 309 virtual const XalanDOMString* 310 getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const; 311 312 virtual bool 313 isPendingResultPrefix(const XalanDOMString& thePrefix); 314 315 virtual void 316 getUniqueNamespaceValue(XalanDOMString& theValue) const; 317 318 virtual FormatterListener* 319 getFormatterListener() const; 320 321 virtual void 322 setFormatterListener(FormatterListener* flistener); 323 324 virtual int 325 getIndent() const; 326 327 virtual void 328 setIndent(int indentAmount); 329 330 virtual const XPath* 331 createMatchPattern( 332 const XalanDOMString& str, 333 const PrefixResolver& resolver); 334 335 virtual void 336 returnXPath(const XPath* xpath); 337 338 virtual void 339 pushTopLevelVariables(const ParamVectorType& topLevelParams); 340 341 342 virtual const XObjectPtr 343 createVariable( 344 const XPath& xpath, 345 XalanNode* contextNode, 346 const PrefixResolver& resolver); 347 348 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 349 virtual const XObjectPtr 350 createVariable( 351 const ElemTemplateElement& templateChild, 352 XalanNode* sourceNode); 353 #endif 354 355 virtual void 356 pushVariable( 357 const XalanQName& name, 358 const ElemTemplateElement* element, 359 const XalanDOMString& str, 360 XalanNode* contextNode, 361 const PrefixResolver& resolver); 362 363 virtual void 364 pushVariable( 365 const XalanQName& name, 366 const XObjectPtr val, 367 const ElemTemplateElement* element); 368 369 virtual void 370 pushVariable( 371 const XalanQName& name, 372 const ElemVariable* var, 373 const ElemTemplateElement* element); 374 375 virtual void 376 pushVariable( 377 const XalanQName& name, 378 const ElemTemplateElement* element, 379 const XPath& xpath, 380 XalanNode* contextNode, 381 const PrefixResolver& resolver); 382 383 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 384 virtual void 385 pushVariable( 386 const XalanQName& name, 387 const ElemTemplateElement* element, 388 const ElemTemplateElement& templateChild, 389 XalanNode* sourceNode); 390 #endif 391 392 393 virtual void 394 pushContextMarker(); 395 396 virtual void 397 popContextMarker(); 398 399 virtual void 400 resolveTopLevelParams(); 401 402 virtual void 403 clearTopLevelParams(); 404 405 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 406 virtual void beginParams(); 407 408 virtual void endParams(); 409 410 virtual void pushParam(const XalanQName& qName,const XObjectPtr& theValue); 411 #else 412 virtual void 413 pushParams(const ElemTemplateElement& xslCallTemplateElement); 414 #endif 415 416 virtual const XObjectPtr 417 getParamVariable(const XalanQName& theName); 418 419 virtual void 420 pushElementFrame(const ElemTemplateElement* elem); 421 422 virtual void 423 popElementFrame(); 424 425 virtual int 426 getGlobalStackFrameIndex() const; 427 428 virtual int 429 getCurrentStackFrameIndex() const; 430 431 virtual void 432 pushCurrentStackFrameIndex(int currentStackFrameIndex = -1); 433 434 virtual void 435 popCurrentStackFrameIndex(); 436 437 virtual void 438 startDocument(); 439 440 virtual void 441 endDocument(); 442 443 virtual void 444 startElement(const XalanDOMChar* name); 445 446 virtual void 447 endElement(const XalanDOMChar* name); 448 449 virtual void 450 characters( 451 const XalanDOMChar* ch, 452 fl_size_type start, 453 fl_size_type length); 454 455 virtual void 456 charactersRaw( 457 const XalanDOMChar* ch, 458 fl_size_type start, 459 fl_size_type length); 460 461 virtual void 462 comment(const XalanDOMChar* data); 463 464 virtual void 465 processingInstruction( 466 const XalanDOMChar* target, 467 const XalanDOMChar* data); 468 469 virtual void 470 flushPending(); 471 472 virtual void 473 cloneToResultTree( 474 const XalanNode& node, 475 const Locator* locator); 476 477 virtual void 478 cloneToResultTree( 479 const XalanNode& node, 480 XalanNode::NodeType nodeType, 481 bool overrideStrip, 482 bool shouldCloneAttributes, 483 const Locator* locator); 484 485 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 486 virtual void 487 beginCreateXResultTreeFrag(XalanNode* sourceNode); 488 489 virtual const XObjectPtr 490 endCreateXResultTreeFrag(); 491 492 virtual void 493 beginFormatToText(XalanDOMString& theResult); 494 495 virtual void 496 endFormatToText(); 497 #endif 498 499 500 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 501 virtual const XObjectPtr 502 createXResultTreeFrag( 503 const ElemTemplateElement& templateChild, 504 XalanNode* sourceNode); 505 #endif 506 507 virtual void 508 outputToResultTree( 509 const XObject& xobj, 510 const Locator* locator); 511 512 virtual void 513 outputResultTreeFragment( 514 const XObject& theTree, 515 const Locator* locator); 516 517 virtual const XalanDOMString& 518 getXSLNameSpaceURL() const; 519 520 virtual const XalanDOMString& 521 getXalanXSLNameSpaceURL() const; 522 523 virtual bool 524 findOnElementRecursionStack(const ElemTemplateElement* theElement) const; 525 526 virtual void 527 pushOnElementRecursionStack(const ElemTemplateElement* theElement); 528 529 virtual const ElemTemplateElement* 530 popElementRecursionStack(); 531 532 virtual bool 533 returnXResultTreeFrag(XResultTreeFrag* theXResultTreeFrag); 534 535 virtual eEscapeURLs 536 getEscapeURLs() const; 537 538 virtual void 539 setEscapeURLs(eEscapeURLs value); 540 541 virtual eOmitMETATag 542 getOmitMETATag() const; 543 544 void 545 setOmitMETATag(eOmitMETATag value); 546 547 virtual FormatterListener* 548 createFormatterToXML( 549 Writer& writer, 550 const XalanDOMString& version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 551 bool doIndent = false, 552 int indent = eDefaultXMLIndentAmount, 553 const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 554 const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 555 const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 556 const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 557 bool xmlDecl = true, 558 const XalanDOMString& standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr())); 559 560 virtual FormatterListener* 561 createFormatterToHTML( 562 Writer& writer, 563 const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 564 const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 565 const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 566 const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 567 bool doIndent = true, 568 int indent = eDefaultHTMLIndentAmount, 569 bool escapeURLs = true, 570 bool omitMetaTag = false); 571 572 virtual FormatterListener* 573 createFormatterToText( 574 Writer& writer, 575 const XalanDOMString& encoding); 576 577 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 578 virtual NodeSorter* 579 getNodeSorter(); 580 #else 581 virtual NodeSorter* 582 borrowNodeSorter(); 583 584 virtual bool 585 returnNodeSorter(NodeSorter* theSorter); 586 #endif 587 588 virtual XalanNumberFormatAutoPtr 589 createXalanNumberFormat(); 590 591 // A basic class to create XalanNumberFormat instances... 592 class XALAN_XSLT_EXPORT XalanNumberFormatFactory 593 { 594 public: 595 596 explicit 597 XalanNumberFormatFactory(); 598 599 virtual 600 ~XalanNumberFormatFactory(); 601 602 virtual XalanNumberFormat* 603 create(MemoryManager& theManager); 604 }; 605 606 static XalanNumberFormatFactory& getDefaultXalanNumberFormatFactory()607 getDefaultXalanNumberFormatFactory() 608 { 609 return s_defaultXalanNumberFormatFactory; 610 } 611 612 /** 613 * Static function to install a new XalanNumberFormatFactory. 614 * The caller owns the XalanNumberFormatFactory instance. 615 * 616 * @param a pointer to the new factory instance to use. 617 * @return a pointer to the old factory instance. 618 */ 619 static XalanNumberFormatFactory* 620 installXalanNumberFormatFactory(XalanNumberFormatFactory* theFactory); 621 622 623 virtual tl_size_type 624 getTraceListeners() const; 625 626 virtual void 627 fireGenerateEvent(const GenerateEvent& ge); 628 629 virtual void 630 fireTraceEvent(const TracerEvent& te); 631 632 virtual void 633 fireSelectEvent(const SelectionEvent& se); 634 635 virtual bool 636 getTraceSelects() const; 637 638 virtual void 639 traceSelect( 640 const ElemTemplateElement& theStylesheetElement, 641 const NodeRefListBase& nl, 642 const XPath* xpath); 643 644 virtual int 645 collationCompare( 646 const XalanDOMString& theLHS, 647 const XalanDOMString& theRHS, 648 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 649 650 virtual int 651 collationCompare( 652 const XalanDOMString& theLHS, 653 const XalanDOMString& theRHS, 654 const XalanDOMString& theLocale, 655 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 656 657 virtual int 658 collationCompare( 659 const XalanDOMChar* theLHS, 660 const XalanDOMChar* theRHS, 661 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 662 663 virtual int 664 collationCompare( 665 const XalanDOMChar* theLHS, 666 const XalanDOMChar* theRHS, 667 const XalanDOMChar* theLocale, 668 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 669 670 typedef XalanCollationServices::CollationCompareFunctor CollationCompareFunctor; 671 672 class XALAN_XSLT_EXPORT DefaultCollationCompareFunctor : public CollationCompareFunctor 673 { 674 public: 675 676 DefaultCollationCompareFunctor(); 677 678 virtual 679 ~DefaultCollationCompareFunctor(); 680 681 virtual int 682 operator()( 683 const XalanDOMChar* theLHS, 684 const XalanDOMChar* theRHS, 685 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; 686 687 virtual int 688 operator()( 689 const XalanDOMChar* theLHS, 690 const XalanDOMChar* theRHS, 691 const XalanDOMChar* theLocale, 692 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; 693 }; 694 695 696 const CollationCompareFunctor* 697 installCollationCompareFunctor(CollationCompareFunctor* theFunctor); 698 699 CollationCompareFunctor* 700 uninstallCollationCompareFunctor(); 701 702 703 class XALAN_XSLT_EXPORT FormatNumberFunctor 704 { 705 public: 706 FormatNumberFunctor()707 FormatNumberFunctor() {}; 708 709 virtual ~FormatNumberFunctor()710 ~FormatNumberFunctor() {}; 711 712 virtual void 713 operator() ( 714 XPathExecutionContext& executionContext, 715 double theNumber, 716 const XalanDOMString& thePattern, 717 const XalanDecimalFormatSymbols* theDFS, 718 XalanDOMString& theResult, 719 const XalanNode* context = 0, 720 const Locator* locator = 0) const = 0; 721 }; 722 723 virtual void 724 formatNumber( 725 double number, 726 const XalanDOMString& pattern, 727 XalanDOMString& theResult, 728 const XalanNode* context = 0, 729 const Locator* locator = 0); 730 731 virtual void 732 formatNumber( 733 double number, 734 const XalanDOMString& pattern, 735 const XalanDOMString& dfsName, 736 XalanDOMString& theResult, 737 const XalanNode* context = 0, 738 const Locator* locator = 0); 739 740 741 const FormatNumberFunctor* 742 installFormatNumberFunctor(FormatNumberFunctor* formatNumberFunctor); 743 744 FormatNumberFunctor* 745 uninstallFormatNumberFunctor(); 746 747 virtual PrintWriter* 748 createPrintWriter(XalanOutputStream* theTextOutputStream); 749 750 virtual PrintWriter* 751 createPrintWriter( 752 const XalanDOMString& theFileName, 753 const XalanDOMString& theEncoding); 754 755 virtual PrintWriter* 756 createPrintWriter(StreamType& theStream); 757 758 virtual PrintWriter* 759 createPrintWriter(FILE* theStream); 760 761 virtual CountersTable& 762 getCountersTable(); 763 764 virtual void 765 characters(const XalanNode& node); 766 767 virtual void 768 characters(const XObjectPtr& xobject); 769 770 virtual void 771 charactersRaw(const XalanNode& node); 772 773 virtual void 774 charactersRaw(const XObjectPtr& xobject); 775 776 777 // These interfaces are inherited from XPathExecutionContext... 778 779 virtual void 780 reset(); 781 782 virtual XalanNode* 783 getCurrentNode() const; 784 785 virtual void 786 pushCurrentNode(XalanNode* theCurrentNode); 787 788 virtual void 789 popCurrentNode(); 790 791 virtual bool 792 isNodeAfter( 793 const XalanNode& node1, 794 const XalanNode& node2) const; 795 796 virtual void 797 pushContextNodeList(const NodeRefListBase& theList); 798 799 virtual void 800 popContextNodeList(); 801 802 virtual const NodeRefListBase& 803 getContextNodeList() const; 804 805 virtual size_type 806 getContextNodeListLength() const; 807 808 virtual size_type 809 getContextNodeListPosition(const XalanNode& contextNode) const; 810 811 virtual bool 812 elementAvailable(const XalanQName& theQName) const; 813 814 virtual bool 815 elementAvailable( 816 const XalanDOMString& theName, 817 const Locator* locator) const; 818 819 virtual bool 820 functionAvailable(const XalanQName& theQName) const; 821 822 virtual bool 823 functionAvailable( 824 const XalanDOMString& theName, 825 const Locator* locator) const; 826 827 virtual const XObjectPtr 828 extFunction( 829 const XalanDOMString& theNamespace, 830 const XalanDOMString& functionName, 831 XalanNode* context, 832 const XObjectArgVectorType& argVec, 833 const Locator* locator); 834 835 virtual XalanDocument* 836 parseXML( 837 MemoryManager& theManager, 838 const XalanDOMString& urlString, 839 const XalanDOMString& base, 840 ErrorHandler* theErrorHandler = 0) const; 841 842 virtual MutableNodeRefList* 843 borrowMutableNodeRefList(); 844 845 virtual bool 846 returnMutableNodeRefList(MutableNodeRefList* theList); 847 848 virtual MutableNodeRefList* 849 createMutableNodeRefList(MemoryManager& theManager) const; 850 851 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 852 virtual void 853 createUseAttributeSetIndexesOnStack(); 854 855 virtual UseAttributeSetIndexes& 856 getUseAttributeSetIndexes(); 857 858 virtual void 859 popUseAttributeSetIndexesFromStack(); 860 861 virtual void 862 pushInvoker(const ElemTemplateElement * invoker); 863 864 virtual void 865 popInvoker(); 866 867 virtual const ElemTemplateElement* 868 getInvoker() const; 869 870 virtual MutableNodeRefList& 871 createAndPushMutableNodeRefList(); 872 873 virtual void 874 releaseAndPopMutableNodeRefList(); 875 876 virtual void 877 pushXObjectPtr(const XObjectPtr& xobjectPtr); 878 879 virtual void 880 popXObjectPtr(); 881 882 virtual void 883 createAndPushNodesToTransformList(const NodeRefListBase* nodeList); 884 885 virtual XalanNode* 886 getNextNodeToTransform(); 887 888 virtual void 889 popNodesToTransformList(); 890 891 virtual XalanDOMString& 892 getAndPushCachedString(); 893 894 virtual XalanDOMString& 895 getLastCachedString(); 896 897 virtual XalanDOMString& 898 getAndPopCachedString(); 899 #endif 900 901 virtual XalanDOMString& 902 getCachedString(); 903 904 virtual bool 905 releaseCachedString(XalanDOMString& theString); 906 907 908 virtual void 909 getNodeSetByKey( 910 XalanNode* context, 911 const XalanQName& qname, 912 const XalanDOMString& ref, 913 const Locator* locator, 914 MutableNodeRefList& nodelist); 915 916 virtual void 917 getNodeSetByKey( 918 XalanNode* context, 919 const XalanDOMString& name, 920 const XalanDOMString& ref, 921 const Locator* locator, 922 MutableNodeRefList& nodelist); 923 924 virtual const XObjectPtr 925 getVariable( 926 const XalanQName& name, 927 const Locator* locator = 0); 928 929 virtual const PrefixResolver* 930 getPrefixResolver() const; 931 932 virtual void 933 setPrefixResolver(const PrefixResolver* thePrefixResolver); 934 935 virtual const XalanDOMString* 936 getNamespaceForPrefix(const XalanDOMString& prefix) const; 937 938 virtual const XalanDOMString& 939 findURIFromDoc(const XalanDocument* owner) const; 940 941 virtual const XalanDOMString& 942 getUnparsedEntityURI( 943 const XalanDOMString& theName, 944 const XalanDocument& theDocument) const; 945 946 virtual bool 947 shouldStripSourceNode(const XalanText& node); 948 949 virtual XalanDocument* 950 getSourceDocument(const XalanDOMString& theURI) const; 951 952 virtual void 953 setSourceDocument( 954 const XalanDOMString& theURI, 955 XalanDocument* theDocument); 956 957 // These interfaces are inherited from ExecutionContext... 958 virtual void 959 problem( 960 eSource source, 961 eClassification classification, 962 const XalanDOMString& msg, 963 const Locator* locator, 964 const XalanNode* sourceNode); 965 966 virtual void 967 problem( 968 eSource source, 969 eClassification classification, 970 const XalanDOMString& msg, 971 const XalanNode* sourceNode); 972 973 class XPathCacheReturnFunctor 974 { 975 public: 976 XPathCacheReturnFunctor(XSLTEngineImpl & xsltProcessor)977 XPathCacheReturnFunctor(XSLTEngineImpl& xsltProcessor) : 978 m_xsltProcessor(xsltProcessor) 979 { 980 } 981 982 void 983 operator()(const XPathCacheMapType::value_type& theCacheEntry); 984 985 private: 986 987 XSLTEngineImpl& m_xsltProcessor; 988 }; 989 990 /** 991 * Get a XalanSourceTreeDocument, primarily for creating result 992 * tree fragments. 993 */ 994 XalanSourceTreeDocument* 995 getSourceTreeFactory(MemoryManager& theManager) const; 996 997 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 998 protected: 999 1000 virtual FormatterToText* 1001 borrowFormatterToText(); 1002 1003 virtual bool 1004 returnFormatterToText(FormatterToText* theFormatter); 1005 #endif 1006 1007 private: 1008 1009 const XalanDecimalFormatSymbols* 1010 getDecimalFormatSymbols(const XalanQName& qname); 1011 1012 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 1013 /** 1014 * Given a context, create the params for a template 1015 * call. 1016 * 1017 * @param xslCallTemplateElement "call-template" element 1018 * @param params The params 1019 */ 1020 void 1021 getParams( 1022 const ElemTemplateElement& xslCallTemplateElement, 1023 ParamsVectorType& params); 1024 #endif 1025 1026 /** 1027 * Determine if the XPath is one that we have cached. 1028 * 1029 * @param theXPath the XPath instance to check 1030 * @return true if the instance has been cached, false if not. 1031 */ 1032 bool 1033 isCached(const XPath* theXPath); 1034 1035 /** 1036 * Clear out the cache of XPath instances. 1037 */ 1038 void 1039 clearXPathCache(); 1040 1041 /** 1042 * Add an XPath instance to the cache, clearing out an old entry 1043 * if the cache is full. 1044 * 1045 * @param pattern the key for looking up the XPath instance in the cache. 1046 * @param theXPath the XPath instance to cache 1047 */ 1048 void 1049 addToXPathCache( 1050 const XalanDOMString& pattern, 1051 const XPath* theXPath); 1052 1053 1054 /** 1055 * Clean up anything that was created for use only during the transformation. 1056 */ 1057 void 1058 cleanUpTransients(); 1059 1060 XPathExecutionContextDefault m_xpathExecutionContextDefault; 1061 1062 XSLTEngineImpl* m_xsltProcessor; 1063 1064 XalanNode* m_rootDocument; 1065 1066 enum { eXPathCacheMax = 50, 1067 eDefaultParamsVectorSize = 10, 1068 eXResultTreeFragAllocatorBlockSize = 10, 1069 eDocumentAllocatorBlockSize = 10, 1070 eDocumentFragmentAllocatorBlockSize = 10, 1071 eDefaultAttributeAllocatorBlockSize = 10, 1072 eDefaultAttributeNSAllocatorBlockSize = 10, 1073 eDefaultCommentAllocatorBlockSize = 10, 1074 eDefaultElementAllocatorBlockSize = 10, 1075 eDefaultElementNSAllocatorBlockSize = 10, 1076 eDefaultPIAllocatorBlockSize = 10, 1077 eDefaultTextAllocatorBlockSize = 20, 1078 eDefaultTextIWSAllocatorBlockSize = 20 }; 1079 1080 ElementTemplateElementStackType m_elementRecursionStack; 1081 1082 const StylesheetRoot* m_stylesheetRoot; 1083 1084 FormatterListenerVectorType m_formatterListeners; 1085 1086 PrintWriterVectorType m_printWriters; 1087 1088 OutputStreamVectorType m_outputStreams; 1089 1090 CollationCompareFunctor* m_collationCompareFunctor; 1091 1092 FormatNumberFunctor * m_formatNumberFunctor; 1093 1094 /** 1095 * Holds all information about variables during execution. 1096 */ 1097 VariablesStack m_variablesStack; 1098 1099 ParamsVectorType m_paramsVector; 1100 1101 XPathCacheMapType m_matchPatternCache; 1102 1103 KeyTablesTableType m_keyTables; 1104 1105 CountersTable m_countersTable; 1106 1107 /** 1108 * The factory that will be used to create result tree fragments based on our 1109 * internal source tree. 1110 */ 1111 mutable XalanMemMgrAutoPtr<XalanSourceTreeDocument> m_sourceTreeResultTreeFactory; 1112 1113 // Holds the current mode. 1114 const XalanQName* m_mode; 1115 1116 CurrentTemplateStackType m_currentTemplateStack; 1117 1118 int m_indentAmount; 1119 1120 XResultTreeFragAllocator m_xresultTreeFragAllocator; 1121 1122 XalanSourceTreeDocumentFragmentAllocator m_documentFragmentAllocator; 1123 1124 XalanSourceTreeDocumentAllocator m_documentAllocator; 1125 1126 typedef XalanVector<bool> BooleanStackType; 1127 typedef XalanVector<const XalanQName*> ModeStackType; 1128 typedef XalanVector<int> IntStackType; 1129 1130 BooleanStackType m_copyTextNodesOnlyStack; 1131 ModeStackType m_modeStack; 1132 IntStackType m_currentIndexStack; 1133 1134 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 1135 typedef XalanMemoryManagerObjectCacheDefault<FormatterToText> FormatterToTextCacheType; 1136 typedef XalanMemoryManagerObjectCacheDefault<FormatterToSourceTree> FormatterToSourceTreeCacheType; 1137 typedef XalanMemoryManagerObjectCacheDefault<NodeSorter> NodeSorterCacheType; 1138 1139 FormatterToTextCacheType m_formatterToTextCache; 1140 1141 FormatterToSourceTreeCacheType m_formatterToSourceTreeCache; 1142 1143 NodeSorterCacheType m_nodeSorterCache; 1144 #else 1145 1146 class FormatterToTextDOMString : public FormatterToText 1147 { 1148 public: 1149 1150 FormatterToTextDOMString(MemoryManager& theManager); 1151 1152 virtual 1153 ~FormatterToTextDOMString(); 1154 1155 void setDOMString(XalanDOMString & theString)1156 setDOMString(XalanDOMString& theString) 1157 { 1158 m_printWriter.setString(theString); 1159 } 1160 1161 private: 1162 1163 // These are not defined... 1164 FormatterToTextDOMString(const FormatterToTextDOMString&); 1165 1166 FormatterToTextDOMString& 1167 operator=(const FormatterToTextDOMString&); 1168 1169 bool 1170 operator==(const FormatterToTextDOMString&) const; 1171 1172 1173 // Data members... 1174 DOMStringPrintWriter m_printWriter; 1175 1176 static XalanDOMString s_dummyString; 1177 }; 1178 1179 typedef XalanVector<XObjectPtr> XObjectPtrStackType; 1180 typedef XalanVector<ParamsVectorType> ParamsVectorStackType; 1181 typedef XalanVector<UseAttributeSetIndexes> UseAttributeSetIndexesStackType; 1182 typedef XalanObjectStackCache<MutableNodeRefList,DefaultCacheCreateFunctorMemMgr<MutableNodeRefList> > 1183 MutableNodeRefListStackType; 1184 1185 typedef XalanObjectStackCache<XalanDOMString,DefaultCacheCreateFunctorMemMgr<XalanDOMString> > 1186 StringStackType; 1187 1188 typedef XalanObjectStackCache<FormatterToTextDOMString,DefaultCacheCreateFunctorMemMgr<FormatterToTextDOMString> > 1189 FormatterToTextStackType; 1190 typedef XalanObjectStackCache<FormatterToSourceTree,DefaultCacheCreateFunctorMemMgr<FormatterToSourceTree> > 1191 FormatterToSourceTreeStackType; 1192 1193 /* 1194 * class to maintain the list of nodes to be transformed by an element 1195 */ 1196 class NodesToTransform 1197 { 1198 public: NodesToTransform(const NodeRefListBase * nodeList)1199 NodesToTransform(const NodeRefListBase* nodeList) : 1200 m_nodeList(nodeList), m_index(0) 1201 { 1202 assert(m_nodeList != 0); 1203 } 1204 operator ()()1205 const NodeRefListBase* operator() () 1206 { 1207 return m_nodeList; 1208 } 1209 index()1210 NodeRefListBase::size_type& index() 1211 { 1212 return m_index; 1213 } 1214 next()1215 XalanNode* next() 1216 { 1217 if (m_index < m_nodeList->getLength()) 1218 { 1219 return m_nodeList->item(m_index++); 1220 } 1221 return 0; 1222 } 1223 1224 private: 1225 const NodeRefListBase* m_nodeList; 1226 NodeRefListBase::size_type m_index; 1227 }; 1228 1229 typedef XalanVector<NodesToTransform> NodesToTransformStackType; 1230 1231 XObjectPtrStackType m_xobjectPtrStack; 1232 MutableNodeRefListStackType m_mutableNodeRefListStack; 1233 NodesToTransformStackType m_nodesToTransformStack; 1234 BooleanStackType m_processCurrentAttributeStack; 1235 BooleanStackType m_executeIfStack; 1236 StringStackType m_stringStack; 1237 FormatterToTextStackType m_formatterToTextStack; 1238 BooleanStackType m_skipElementAttributesStack; 1239 FormatterToSourceTreeStackType m_formatterToSourceTreeStack; 1240 ParamsVectorStackType m_paramsVectorStack; 1241 ElementTemplateElementStackType m_elementInvokerStack; 1242 UseAttributeSetIndexesStackType m_useAttributeSetIndexesStack; 1243 1244 NodeSorter m_nodeSorter; 1245 #endif 1246 1247 // If true, we will use a separate document factory for 1248 // result tree fragments. 1249 bool m_usePerInstanceDocumentFactory; 1250 1251 // Determines whether or not to override the property in the stylesheet. 1252 eEscapeURLs m_escapeURLs; 1253 1254 // Determines whether or not to override the property in the stylesheet. 1255 eOmitMETATag m_omitMETATag; 1256 1257 static XalanNumberFormatFactory s_defaultXalanNumberFormatFactory; 1258 1259 static XalanNumberFormatFactory* s_xalanNumberFormatFactory; 1260 1261 static const DefaultCollationCompareFunctor s_defaultCollationFunctor; 1262 }; 1263 1264 1265 1266 } 1267 1268 1269 1270 #endif // STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680 1271