00001 /* 00002 * The Apache Software License, Version 1.1 00003 * 00004 * 00005 * Copyright (c) 1999-2004 The Apache Software Foundation. All rights 00006 * reserved. 00007 * 00008 * Redistribution and use in source and binary forms, with or without 00009 * modification, are permitted provided that the following conditions 00010 * are met: 00011 * 00012 * 1. Redistributions of source code must retain the above copyright 00013 * notice, this list of conditions and the following disclaimer. 00014 * 00015 * 2. Redistributions in binary form must reproduce the above copyright 00016 * notice, this list of conditions and the following disclaimer in 00017 * the documentation and/or other materials provided with the 00018 * distribution. 00019 * 00020 * 3. The end-user documentation included with the redistribution, 00021 * if any, must include the following acknowledgment: 00022 * "This product includes software developed by the 00023 * Apache Software Foundation (http://www.apache.org/)." 00024 * Alternately, this acknowledgment may appear in the software itself, 00025 * if and wherever such third-party acknowledgments normally appear. 00026 * 00027 * 4. The names "Xalan" and "Apache Software Foundation" must 00028 * not be used to endorse or promote products derived from this 00029 * software without prior written permission. For written 00030 * permission, please contact apache@apache.org. 00031 * 00032 * 5. Products derived from this software may not be called "Apache", 00033 * nor may "Apache" appear in their name, without prior written 00034 * permission of the Apache Software Foundation. 00035 * 00036 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 00037 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 00038 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00039 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR 00040 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00041 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 00042 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 00043 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 00044 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00045 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 00046 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 00047 * SUCH DAMAGE. 00048 * ==================================================================== 00049 * 00050 * This software consists of voluntary contributions made by many 00051 * individuals on behalf of the Apache Software Foundation and was 00052 * originally based on software copyright (c) 1999, International 00053 * Business Machines, Inc., http://www.ibm.com. For more 00054 * information on the Apache Software Foundation, please see 00055 * <http://www.apache.org/>. 00056 * 00057 * @author <a href="mailto:david_n_bertoni@lotus.com">David N. Bertoni</a> 00058 */ 00059 #if !defined(STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680) 00060 #define STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680 00061 00062 00063 00064 // Base class include file. 00065 #include <xalanc/XSLT/StylesheetExecutionContext.hpp> 00066 00067 00068 00069 #include <ctime> 00070 #include <deque> 00071 #include <memory> 00072 #include <set> 00073 #include <vector> 00074 00075 00076 00077 #include <xalanc/Include/XalanObjectCache.hpp> 00078 00079 00080 00081 #include <xalanc/XPath/XPathExecutionContextDefault.hpp> 00082 00083 00084 00085 #include <xalanc/XMLSupport/FormatterToText.hpp> 00086 00087 00088 00089 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) 00090 #include <xalanc/XalanSourceTree/XalanSourceTreeDocument.hpp> 00091 #endif 00092 #include <xalanc/XalanSourceTree/FormatterToSourceTree.hpp> 00093 #include <xalanc/XalanSourceTree/XalanSourceTreeDocumentFragment.hpp> 00094 00095 00096 00097 #include <xalanc/XSLT/CountersTable.hpp> 00098 #include <xalanc/XSLT/NodeSorter.hpp> 00099 #include <xalanc/XSLT/Stylesheet.hpp> 00100 #include <xalanc/XSLT/VariablesStack.hpp> 00101 #include <xalanc/XSLT/XResultTreeFragAllocator.hpp> 00102 #include <xalanc/XSLT/XalanSourceTreeDocumentAllocator.hpp> 00103 #include <xalanc/XSLT/XalanSourceTreeDocumentFragmentAllocator.hpp> 00104 00105 00106 00107 XALAN_CPP_NAMESPACE_BEGIN 00108 00109 00110 00111 class XalanSourceTreeDocument; 00112 class XPathProcessor; 00113 class XSLTEngineImpl; 00114 00115 00116 00117 // 00118 // An class which provides support for executing stylesheets. 00119 // 00120 class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext 00121 { 00122 public: 00123 00124 #if defined(XALAN_STRICT_ANSI_HEADERS) 00125 typedef std::clock_t ClockType; 00126 #else 00127 typedef clock_t ClockType; 00128 #endif 00129 00130 #if defined(XALAN_NO_STD_NAMESPACE) 00131 typedef deque<const ElemTemplateElement*> ElementTemplateElementStackType; 00132 typedef vector<FormatterListener*> FormatterListenerVectorType; 00133 typedef vector<PrintWriter*> PrintWriterVectorType; 00134 typedef vector<XalanOutputStream*> OutputStreamVectorType; 00135 typedef set<const KeyDeclaration*, 00136 less<const KeyDeclaration*> > KeyDeclarationSetType; 00137 typedef pair<const XPath*, ClockType> XPathCacheEntry; 00138 typedef map<XalanDOMString, 00139 XPathCacheEntry, 00140 less<XalanDOMString> > XPathCacheMapType; 00141 typedef deque<const ElemTemplate*> CurrentTemplateStackType; 00142 #else 00143 typedef std::deque<const ElemTemplateElement*> ElementTemplateElementStackType; 00144 typedef std::vector<FormatterListener*> FormatterListenerVectorType; 00145 typedef std::vector<PrintWriter*> PrintWriterVectorType; 00146 typedef std::vector<XalanOutputStream*> OutputStreamVectorType; 00147 typedef std::set<const KeyDeclaration*> KeyDeclarationSetType; 00148 typedef std::pair<const XPath*, ClockType> XPathCacheEntry; 00149 typedef std::map<XalanDOMString, XPathCacheEntry> XPathCacheMapType; 00150 typedef std::deque<const ElemTemplate*> CurrentTemplateStackType; 00151 #endif 00152 00153 typedef Stylesheet::KeyTablesTableType KeyTablesTableType; 00154 typedef VariablesStack::ParamsVectorType ParamsVectorType; 00155 00156 00167 StylesheetExecutionContextDefault( 00168 XSLTEngineImpl& xsltProcessor, 00169 XPathEnvSupport& theXPathEnvSupport, 00170 DOMSupport& theDOMSupport, 00171 XObjectFactory& theXObjectFactory, 00172 XalanNode* theCurrentNode = 0, 00173 const NodeRefListBase* theContextNodeList = 0, 00174 const PrefixResolver* thePrefixResolver = 0); 00175 00186 explicit 00187 StylesheetExecutionContextDefault( 00188 XalanNode* theCurrentNode = 0, 00189 const NodeRefListBase* theContextNodeList = 0, 00190 const PrefixResolver* thePrefixResolver = 0); 00191 00192 virtual 00193 ~StylesheetExecutionContextDefault(); 00194 00195 00207 bool 00208 setIgnoreHTMLElementNamespaces() const 00209 { 00210 return m_ignoreHTMLElementNamespaces; 00211 } 00212 00219 void 00220 setIgnoreHTMLElementNamespaces(bool theValue) 00221 { 00222 m_ignoreHTMLElementNamespaces = theValue; 00223 } 00224 00230 void 00231 setXPathEnvSupport(XPathEnvSupport* theSupport) 00232 { 00233 m_xpathExecutionContextDefault.setXPathEnvSupport(theSupport); 00234 } 00235 00241 void 00242 setDOMSupport(DOMSupport* theDOMSupport) 00243 { 00244 m_xpathExecutionContextDefault.setDOMSupport(theDOMSupport); 00245 } 00246 00252 void 00253 setXObjectFactory(XObjectFactory* theXObjectFactory) 00254 { 00255 m_xpathExecutionContextDefault.setXObjectFactory(theXObjectFactory); 00256 00257 m_xobjectFactory = theXObjectFactory; 00258 } 00259 00260 00266 void 00267 setXSLTProcessor(XSLTEngineImpl* theProcessor) 00268 { 00269 m_xsltProcessor = theProcessor; 00270 } 00271 00272 bool 00273 getUsePerInstanceDocumentFactory() const 00274 { 00275 return m_usePerInstanceDocumentFactory; 00276 } 00277 00278 void 00279 setUsePerInstanceDocumentFactory(bool fValue) 00280 { 00281 m_usePerInstanceDocumentFactory = fValue; 00282 } 00283 00284 00285 // These interfaces are inherited from StylesheetExecutionContext... 00286 00287 virtual void 00288 error( 00289 const XalanDOMString& msg, 00290 const ElemTemplateElement& styleNode, 00291 const XalanNode* sourceNode = 0) const; 00292 00293 virtual void 00294 error( 00295 const char* msg, 00296 const ElemTemplateElement& styleNode, 00297 const XalanNode* sourceNode = 0) const; 00298 00299 virtual void 00300 warn( 00301 const XalanDOMString& msg, 00302 const ElemTemplateElement& styleNode, 00303 const XalanNode* sourceNode = 0) const; 00304 00305 virtual void 00306 warn( 00307 const char* msg, 00308 const ElemTemplateElement& styleNode, 00309 const XalanNode* sourceNode = 0) const; 00310 00311 virtual void 00312 message( 00313 const XalanDOMString& msg, 00314 const ElemTemplateElement& styleNode, 00315 const XalanNode* sourceNode = 0) const; 00316 00317 virtual void 00318 message( 00319 const char* msg, 00320 const ElemTemplateElement& styleNode, 00321 const XalanNode* sourceNode = 0) const; 00322 00323 virtual bool 00324 getQuietConflictWarnings() const; 00325 00326 virtual bool 00327 getCopyTextNodesOnly() const; 00328 00329 virtual void 00330 setCopyTextNodesOnly(bool fValue); 00331 00332 virtual XalanNode* 00333 getRootDocument() const; 00334 00335 virtual void 00336 setRootDocument(XalanNode* theDocument); 00337 00338 virtual XalanDocument* 00339 createDocument() const; 00340 00341 virtual void 00342 setStylesheetRoot(const StylesheetRoot* theStylesheet); 00343 00344 virtual const XalanQName* 00345 getCurrentMode() const; 00346 00347 virtual void 00348 setCurrentMode(const XalanQName* theMode); 00349 00350 virtual const ElemTemplate* 00351 getCurrentTemplate() const; 00352 00353 virtual void 00354 pushCurrentTemplate(const ElemTemplate* theTemplate); 00355 00356 virtual void 00357 popCurrentTemplate(); 00358 00359 virtual bool 00360 doDiagnosticsOutput() const; 00361 00362 virtual void 00363 diag(const XalanDOMString& theString); 00364 00365 virtual void 00366 pushTime(const void* theKey); 00367 00368 virtual void 00369 displayDuration( 00370 const XalanDOMString& theMessage, 00371 const void* theKey); 00372 00373 virtual bool 00374 isElementPending() const; 00375 00376 virtual void 00377 replacePendingAttribute( 00378 const XalanDOMChar* theName, 00379 const XalanDOMChar* theNewType, 00380 const XalanDOMChar* theNewValue); 00381 00382 virtual void 00383 pushOutputContext(FormatterListener* flistener = 0); 00384 00385 virtual void 00386 popOutputContext(); 00387 00388 virtual void 00389 addResultAttribute( 00390 const XalanDOMString& aname, 00391 const XalanDOMString& value); 00392 00393 virtual void 00394 addResultAttribute( 00395 const XalanDOMString& aname, 00396 const XalanDOMChar* value); 00397 00398 virtual void 00399 copyNamespaceAttributes(const XalanNode& src); 00400 00401 virtual const XalanDOMString* 00402 getResultPrefixForNamespace(const XalanDOMString& theNamespace) const; 00403 00404 virtual const XalanDOMString* 00405 getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const; 00406 00407 virtual bool 00408 isPendingResultPrefix(const XalanDOMString& thePrefix); 00409 00410 virtual XalanDOMString 00411 getUniqueNamespaceValue() const; 00412 00413 virtual void 00414 getUniqueNamespaceValue(XalanDOMString& theValue) const; 00415 00416 virtual FormatterListener* 00417 getFormatterListener() const; 00418 00419 virtual void 00420 setFormatterListener(FormatterListener* flistener); 00421 00422 virtual int 00423 getIndent() const; 00424 00425 virtual void 00426 setIndent(int indentAmount); 00427 00428 virtual const XPath* 00429 createMatchPattern( 00430 const XalanDOMString& str, 00431 const PrefixResolver& resolver); 00432 00433 virtual void 00434 returnXPath(const XPath* xpath); 00435 00436 virtual void 00437 pushTopLevelVariables(const ParamVectorType& topLevelParams); 00438 00439 virtual const XObjectPtr 00440 createVariable( 00441 const XPath& xpath, 00442 XalanNode* contextNode, 00443 const PrefixResolver& resolver); 00444 00445 virtual const XObjectPtr 00446 createVariable( 00447 const ElemTemplateElement& templateChild, 00448 XalanNode* sourceNode); 00449 00450 virtual void 00451 pushVariable( 00452 const XalanQName& name, 00453 const ElemTemplateElement* element, 00454 const XalanDOMString& str, 00455 XalanNode* contextNode, 00456 const PrefixResolver& resolver); 00457 00458 virtual void 00459 pushVariable( 00460 const XalanQName& name, 00461 const XObjectPtr val, 00462 const ElemTemplateElement* element); 00463 00464 virtual void 00465 pushVariable( 00466 const XalanQName& name, 00467 const ElemVariable* var, 00468 const ElemTemplateElement* element); 00469 00470 virtual void 00471 pushVariable( 00472 const XalanQName& name, 00473 const ElemTemplateElement* element, 00474 const XPath& xpath, 00475 XalanNode* contextNode, 00476 const PrefixResolver& resolver); 00477 00478 virtual void 00479 pushVariable( 00480 const XalanQName& name, 00481 const ElemTemplateElement* element, 00482 const ElemTemplateElement& templateChild, 00483 XalanNode* sourceNode); 00484 00485 virtual void 00486 pushContextMarker(); 00487 00488 virtual void 00489 popContextMarker(); 00490 00491 virtual void 00492 resolveTopLevelParams(); 00493 00494 virtual void 00495 clearTopLevelParams(); 00496 00497 virtual void 00498 pushParams(const ElemTemplateElement& xslCallTemplateElement); 00499 00500 virtual const XObjectPtr 00501 getParamVariable(const XalanQName& theName); 00502 00503 virtual void 00504 pushElementFrame(const ElemTemplateElement* elem); 00505 00506 virtual void 00507 popElementFrame(); 00508 00509 virtual int 00510 getGlobalStackFrameIndex() const; 00511 00512 virtual int 00513 getCurrentStackFrameIndex() const; 00514 00515 virtual void 00516 setCurrentStackFrameIndex(int currentStackFrameIndex = -1); 00517 00518 virtual void 00519 startDocument(); 00520 00521 virtual void 00522 endDocument(); 00523 00524 virtual void 00525 startElement(const XalanDOMChar* name); 00526 00527 virtual void 00528 endElement(const XalanDOMChar* name); 00529 00530 virtual void 00531 characters( 00532 const XalanDOMChar* ch, 00533 XalanDOMString::size_type start, 00534 XalanDOMString::size_type length); 00535 00536 virtual void 00537 charactersRaw( 00538 const XalanDOMChar* ch, 00539 XalanDOMString::size_type start, 00540 XalanDOMString::size_type length); 00541 00542 virtual void 00543 comment(const XalanDOMChar* data); 00544 00545 virtual void 00546 processingInstruction( 00547 const XalanDOMChar* target, 00548 const XalanDOMChar* data); 00549 00550 virtual void 00551 flushPending(); 00552 00553 virtual void 00554 cloneToResultTree( 00555 const XalanNode& node, 00556 const LocatorType* locator); 00557 00558 virtual void 00559 cloneToResultTree( 00560 const XalanNode& node, 00561 XalanNode::NodeType nodeType, 00562 bool isLiteral, 00563 bool overrideStrip, 00564 bool shouldCloneAttributes, 00565 const LocatorType* locator); 00566 00567 virtual const XObjectPtr 00568 createXResultTreeFrag( 00569 const ElemTemplateElement& templateChild, 00570 XalanNode* sourceNode); 00571 00572 virtual void 00573 outputToResultTree( 00574 const XObject& xobj, 00575 const LocatorType* locator); 00576 00577 virtual void 00578 outputResultTreeFragment( 00579 const XObject& theTree, 00580 const LocatorType* locator); 00581 00582 virtual const XalanDOMString& 00583 getXSLNameSpaceURL() const; 00584 00585 virtual const XalanDOMString& 00586 getXalanXSLNameSpaceURL() const; 00587 00588 virtual bool 00589 findOnElementRecursionStack(const ElemTemplateElement* theElement) const; 00590 00591 virtual void 00592 pushOnElementRecursionStack(const ElemTemplateElement* theElement); 00593 00594 virtual const ElemTemplateElement* 00595 popElementRecursionStack(); 00596 00597 virtual bool 00598 returnXResultTreeFrag(XResultTreeFrag* theXResultTreeFrag); 00599 00600 virtual eEscapeURLs 00601 getEscapeURLs() const; 00602 00603 virtual void 00604 setEscapeURLs(eEscapeURLs value); 00605 00606 virtual eOmitMETATag 00607 getOmitMETATag() const; 00608 00609 void 00610 setOmitMETATag(eOmitMETATag value); 00611 00612 virtual FormatterListener* 00613 createFormatterToXML( 00614 Writer& writer, 00615 const XalanDOMString& version = XalanDOMString(), 00616 bool doIndent = false, 00617 int indent = eDefaultXMLIndentAmount, 00618 const XalanDOMString& encoding = XalanDOMString(), 00619 const XalanDOMString& mediaType = XalanDOMString(), 00620 const XalanDOMString& doctypeSystem = XalanDOMString(), 00621 const XalanDOMString& doctypePublic = XalanDOMString(), 00622 bool xmlDecl = true, 00623 const XalanDOMString& standalone = XalanDOMString()); 00624 00625 virtual FormatterListener* 00626 createFormatterToHTML( 00627 Writer& writer, 00628 const XalanDOMString& encoding = XalanDOMString(), 00629 const XalanDOMString& mediaType = XalanDOMString(), 00630 const XalanDOMString& doctypeSystem = XalanDOMString(), 00631 const XalanDOMString& doctypePublic = XalanDOMString(), 00632 bool doIndent = true, 00633 int indent = eDefaultHTMLIndentAmount, 00634 bool escapeURLs = true, 00635 bool omitMetaTag = false); 00636 00637 virtual FormatterListener* 00638 createFormatterToDOM( 00639 XalanDocument* doc, 00640 XalanDocumentFragment* docFrag, 00641 XalanElement* currentElement); 00642 00643 virtual FormatterListener* 00644 createFormatterToDOM( 00645 XalanDocument* doc, 00646 XalanElement* elem); 00647 00648 virtual FormatterListener* 00649 createFormatterToText( 00650 Writer& writer, 00651 const XalanDOMString& encoding); 00652 00653 virtual NodeSorter* 00654 borrowNodeSorter(); 00655 00656 virtual bool 00657 returnNodeSorter(NodeSorter* theSorter); 00658 00659 virtual XalanNumberFormatAutoPtr 00660 createXalanNumberFormat(); 00661 00662 // A basic class to create XalanNumberFormat instances... 00663 class XALAN_XSLT_EXPORT XalanNumberFormatFactory 00664 { 00665 public: 00666 00667 explicit 00668 XalanNumberFormatFactory(); 00669 00670 virtual 00671 ~XalanNumberFormatFactory(); 00672 00673 virtual XalanNumberFormat* 00674 create(); 00675 }; 00676 00677 static XalanNumberFormatFactory& 00678 getDefaultXalanNumberFormatFactory() 00679 { 00680 return s_defaultXalanNumberFormatFactory; 00681 } 00682 00690 static XalanNumberFormatFactory* 00691 installXalanNumberFormatFactory(XalanNumberFormatFactory* theFactory); 00692 00693 00694 virtual size_type 00695 getTraceListeners() const; 00696 00697 virtual void 00698 fireGenerateEvent(const GenerateEvent& ge); 00699 00700 virtual void 00701 fireTraceEvent(const TracerEvent& te); 00702 00703 virtual void 00704 fireSelectEvent(const SelectionEvent& se); 00705 00706 virtual bool 00707 getTraceSelects() const; 00708 00709 virtual void 00710 traceSelect( 00711 const ElemTemplateElement& theStylesheetElement, 00712 const NodeRefListBase& nl, 00713 const XPath* xpath); 00714 00715 virtual int 00716 collationCompare( 00717 const XalanDOMString& theLHS, 00718 const XalanDOMString& theRHS, 00719 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00720 00721 virtual int 00722 collationCompare( 00723 const XalanDOMString& theLHS, 00724 const XalanDOMString& theRHS, 00725 const XalanDOMString& theLocale, 00726 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00727 00728 virtual int 00729 collationCompare( 00730 const XalanDOMChar* theLHS, 00731 const XalanDOMChar* theRHS, 00732 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00733 00734 virtual int 00735 collationCompare( 00736 const XalanDOMChar* theLHS, 00737 const XalanDOMChar* theRHS, 00738 const XalanDOMChar* theLocale, 00739 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00740 00741 typedef XalanCollationServices::CollationCompareFunctor CollationCompareFunctor; 00742 00743 class XALAN_XSLT_EXPORT DefaultCollationCompareFunctor : public CollationCompareFunctor 00744 { 00745 public: 00746 00747 DefaultCollationCompareFunctor(); 00748 00749 virtual 00750 ~DefaultCollationCompareFunctor(); 00751 00752 virtual int 00753 operator()( 00754 const XalanDOMChar* theLHS, 00755 const XalanDOMChar* theRHS, 00756 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; 00757 00758 virtual int 00759 operator()( 00760 const XalanDOMChar* theLHS, 00761 const XalanDOMChar* theRHS, 00762 const XalanDOMChar* theLocale, 00763 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; 00764 }; 00765 00766 const CollationCompareFunctor* 00767 installCollationCompareFunctor(CollationCompareFunctor* theFunctor); 00768 00769 CollationCompareFunctor* 00770 uninstallCollationCompareFunctor(); 00771 00772 virtual bool 00773 getInConstruction(const KeyDeclaration& keyDeclaration) const; 00774 00775 virtual void 00776 beginConstruction(const KeyDeclaration& keyDeclaration); 00777 00778 virtual void 00779 endConstruction(const KeyDeclaration& keyDeclaration); 00780 00781 virtual const XalanDecimalFormatSymbols* 00782 getDecimalFormatSymbols(const XalanQName& qname); 00783 00784 virtual PrintWriter* 00785 createPrintWriter(XalanOutputStream* theTextOutputStream); 00786 00787 virtual PrintWriter* 00788 createPrintWriter( 00789 const XalanDOMString& theFileName, 00790 const XalanDOMString& theEncoding); 00791 00792 virtual PrintWriter* 00793 createPrintWriter(StreamType& theStream); 00794 00795 virtual PrintWriter* 00796 createPrintWriter(FILE* theStream); 00797 00798 virtual CountersTable& 00799 getCountersTable(); 00800 00801 virtual void 00802 characters(const XalanNode& node); 00803 00804 virtual void 00805 characters(const XObjectPtr& xobject); 00806 00807 virtual void 00808 charactersRaw(const XalanNode& node); 00809 00810 virtual void 00811 charactersRaw(const XObjectPtr& xobject); 00812 00813 00814 // These interfaces are inherited from XPathExecutionContext... 00815 00816 virtual void 00817 reset(); 00818 00819 virtual XalanNode* 00820 getCurrentNode() const; 00821 00822 virtual void 00823 pushCurrentNode(XalanNode* theCurrentNode); 00824 00825 virtual void 00826 popCurrentNode(); 00827 00828 virtual bool 00829 isNodeAfter( 00830 const XalanNode& node1, 00831 const XalanNode& node2) const; 00832 00833 virtual void 00834 pushContextNodeList(const NodeRefListBase& theList); 00835 00836 virtual void 00837 popContextNodeList(); 00838 00839 virtual const NodeRefListBase& 00840 getContextNodeList() const; 00841 00842 virtual size_type 00843 getContextNodeListLength() const; 00844 00845 virtual size_type 00846 getContextNodeListPosition(const XalanNode& contextNode) const; 00847 00848 virtual bool 00849 elementAvailable(const XalanQName& theQName) const; 00850 00851 virtual bool 00852 elementAvailable( 00853 const XalanDOMString& theName, 00854 const LocatorType* locator) const; 00855 00856 virtual bool 00857 functionAvailable(const XalanQName& theQName) const; 00858 00859 virtual bool 00860 functionAvailable( 00861 const XalanDOMString& theName, 00862 const LocatorType* locator) const; 00863 00864 virtual const XObjectPtr 00865 extFunction( 00866 const XalanDOMString& theNamespace, 00867 const XalanDOMString& functionName, 00868 XalanNode* context, 00869 const XObjectArgVectorType& argVec, 00870 const LocatorType* locator); 00871 00872 virtual XalanDocument* 00873 parseXML( 00874 const XalanDOMString& urlString, 00875 const XalanDOMString& base) const; 00876 00877 virtual MutableNodeRefList* 00878 borrowMutableNodeRefList(); 00879 00880 virtual bool 00881 returnMutableNodeRefList(MutableNodeRefList* theList); 00882 00883 virtual MutableNodeRefList* 00884 createMutableNodeRefList() const; 00885 00886 virtual XalanDOMString& 00887 getCachedString(); 00888 00889 virtual bool 00890 releaseCachedString(XalanDOMString& theString); 00891 00892 virtual void 00893 getNodeSetByKey( 00894 XalanDocument* doc, 00895 const XalanQName& qname, 00896 const XalanDOMString& ref, 00897 MutableNodeRefList& nodelist); 00898 00899 virtual void 00900 getNodeSetByKey( 00901 XalanDocument* doc, 00902 const XalanDOMString& name, 00903 const XalanDOMString& ref, 00904 const LocatorType* locator, 00905 MutableNodeRefList& nodelist); 00906 00907 virtual const XObjectPtr 00908 getVariable( 00909 const XalanQName& name, 00910 const LocatorType* locator = 0); 00911 00912 virtual const PrefixResolver* 00913 getPrefixResolver() const; 00914 00915 virtual void 00916 setPrefixResolver(const PrefixResolver* thePrefixResolver); 00917 00918 virtual const XalanDOMString* 00919 getNamespaceForPrefix(const XalanDOMString& prefix) const; 00920 00921 virtual XalanDOMString 00922 findURIFromDoc(const XalanDocument* owner) const; 00923 00924 virtual const XalanDOMString& 00925 getUnparsedEntityURI( 00926 const XalanDOMString& theName, 00927 const XalanDocument& theDocument) const; 00928 00929 virtual bool 00930 shouldStripSourceNode(const XalanNode& node); 00931 00932 virtual XalanDocument* 00933 getSourceDocument(const XalanDOMString& theURI) const; 00934 00935 virtual void 00936 setSourceDocument( 00937 const XalanDOMString& theURI, 00938 XalanDocument* theDocument); 00939 00940 00941 // These interfaces are inherited from ExecutionContext... 00942 00943 virtual void 00944 error( 00945 const XalanDOMString& msg, 00946 const XalanNode* sourceNode, 00947 const LocatorType* locator) const; 00948 00949 virtual void 00950 error( 00951 const char* msg, 00952 const XalanNode* sourceNode, 00953 const LocatorType* locator) const; 00954 00955 virtual void 00956 warn( 00957 const XalanDOMString& msg, 00958 const XalanNode* sourceNode, 00959 const LocatorType* locator) const; 00960 00961 virtual void 00962 warn( 00963 const char* msg, 00964 const XalanNode* sourceNode, 00965 const LocatorType* locator) const; 00966 00967 virtual void 00968 message( 00969 const XalanDOMString& msg, 00970 const XalanNode* sourceNode, 00971 const LocatorType* locator) const; 00972 00973 virtual void 00974 message( 00975 const char* msg, 00976 const XalanNode* sourceNode, 00977 const LocatorType* locator) const; 00978 00979 00980 class XPathCacheReturnFunctor 00981 { 00982 public: 00983 00984 XPathCacheReturnFunctor(XSLTEngineImpl& xsltProcessor) : 00985 m_xsltProcessor(xsltProcessor) 00986 { 00987 } 00988 00989 void 00990 operator()(const XPathCacheMapType::value_type& theCacheEntry); 00991 00992 private: 00993 00994 XSLTEngineImpl& m_xsltProcessor; 00995 }; 00996 01001 XalanSourceTreeDocument* 01002 getSourceTreeFactory() const; 01003 01004 protected: 01005 01006 virtual FormatterToText* 01007 borrowFormatterToText(); 01008 01009 virtual bool 01010 returnFormatterToText(FormatterToText* theFormatter); 01011 01012 private: 01013 01021 void 01022 getParams( 01023 const ElemTemplateElement& xslCallTemplateElement, 01024 ParamsVectorType& params); 01025 01032 bool 01033 isCached(const XPath* theXPath); 01034 01038 void 01039 clearXPathCache(); 01040 01048 void 01049 addToXPathCache( 01050 const XalanDOMString& pattern, 01051 const XPath* theXPath); 01052 01053 01057 void 01058 cleanUpTransients(); 01059 01060 XPathExecutionContextDefault m_xpathExecutionContextDefault; 01061 01062 XSLTEngineImpl* m_xsltProcessor; 01063 01064 XalanNode* m_rootDocument; 01065 01066 enum { eXPathCacheMax = 50, 01067 eDefaultParamsVectorSize = 10, 01068 eXResultTreeFragAllocatorBlockSize = 10, 01069 eDocumentAllocatorBlockSize = 10, 01070 eDocumentFragmentAllocatorBlockSize = 10, 01071 eDefaultAttributeAllocatorBlockSize = 10, 01072 eDefaultAttributeNSAllocatorBlockSize = 10, 01073 eDefaultCommentAllocatorBlockSize = 10, 01074 eDefaultElementAllocatorBlockSize = 10, 01075 eDefaultElementNSAllocatorBlockSize = 10, 01076 eDefaultPIAllocatorBlockSize = 10, 01077 eDefaultTextAllocatorBlockSize = 20, 01078 eDefaultTextIWSAllocatorBlockSize = 20 }; 01079 01080 ElementTemplateElementStackType m_elementRecursionStack; 01081 01082 const PrefixResolver* m_prefixResolver; 01083 01084 const StylesheetRoot* m_stylesheetRoot; 01085 01086 FormatterListenerVectorType m_formatterListeners; 01087 01088 PrintWriterVectorType m_printWriters; 01089 01090 OutputStreamVectorType m_outputStreams; 01091 01092 CollationCompareFunctor* m_collationCompareFunctor; 01093 01097 VariablesStack m_variablesStack; 01098 01099 ParamsVectorType m_paramsVector; 01100 01101 XPathCacheMapType m_matchPatternCache; 01102 01103 KeyTablesTableType m_keyTables; 01104 01105 KeyDeclarationSetType m_keyDeclarationSet; 01106 01107 CountersTable m_countersTable; 01108 01109 // If true, we will not check HTML output for elements with 01110 // namespaces. This is an optimization which can lead to 01111 // non-conforming behavior. 01112 bool m_ignoreHTMLElementNamespaces; 01113 01118 mutable XalanAutoPtr<XalanSourceTreeDocument> m_sourceTreeResultTreeFactory; 01119 01120 // Holds the current mode. 01121 const XalanQName* m_mode; 01122 01123 CurrentTemplateStackType m_currentTemplateStack; 01124 01125 typedef XalanObjectCacheDefault<FormatterToText> FormatterToTextCacheType; 01126 typedef XalanObjectCacheDefault<FormatterToSourceTree> FormatterToSourceTreeCacheType; 01127 typedef XalanObjectCacheDefault<NodeSorter> NodeSorterCacheType; 01128 01129 FormatterToTextCacheType m_formatterToTextCache; 01130 01131 FormatterToSourceTreeCacheType m_formatterToSourceTreeCache; 01132 01133 NodeSorterCacheType m_nodeSorterCache; 01134 01135 int m_indentAmount; 01136 01137 XResultTreeFragAllocator m_xresultTreeFragAllocator; 01138 01139 XalanSourceTreeDocumentFragmentAllocator m_documentFragmentAllocator; 01140 01141 XalanSourceTreeDocumentAllocator m_documentAllocator; 01142 01143 // If true, we will use a separate document factory for 01144 // result tree fragments. 01145 bool m_usePerInstanceDocumentFactory; 01146 01147 // If true, only text nodes will be cloned in the output... 01148 bool m_cloneTextNodesOnly; 01149 01150 // Determines whether or not to override the property in the stylesheet. 01151 eEscapeURLs m_escapeURLs; 01152 01153 // Determines whether or not to override the property in the stylesheet. 01154 eOmitMETATag m_omitMETATag; 01155 01156 static XalanNumberFormatFactory s_defaultXalanNumberFormatFactory; 01157 01158 static XalanNumberFormatFactory* s_xalanNumberFormatFactory; 01159 01160 static const DefaultCollationCompareFunctor s_defaultCollationFunctor; 01161 }; 01162 01163 01164 01165 XALAN_CPP_NAMESPACE_END 01166 01167 01168 01169 #endif // STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSLT Processor Version 1.7 |
|