00001 /* 00002 * The Apache Software License, Version 1.1 00003 * 00004 * 00005 * Copyright (c) 1999-2003 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/ResultTreeFrag.hpp> 00100 #include <xalanc/XSLT/ResultTreeFragAllocator.hpp> 00101 #include <xalanc/XSLT/Stylesheet.hpp> 00102 #include <xalanc/XSLT/VariablesStack.hpp> 00103 #include <xalanc/XSLT/XResultTreeFragAllocator.hpp> 00104 #include <xalanc/XSLT/XalanSourceTreeDocumentAllocator.hpp> 00105 #include <xalanc/XSLT/XalanSourceTreeDocumentFragmentAllocator.hpp> 00106 00107 00108 00109 XALAN_CPP_NAMESPACE_BEGIN 00110 00111 00112 00113 class XalanSourceTreeDocument; 00114 class XPathProcessor; 00115 class XSLTEngineImpl; 00116 00117 00118 00119 // 00120 // An class which provides support for executing stylesheets. 00121 // 00122 class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext 00123 { 00124 public: 00125 00126 #if defined(XALAN_STRICT_ANSI_HEADERS) 00127 typedef std::clock_t ClockType; 00128 #else 00129 typedef clock_t ClockType; 00130 #endif 00131 00132 #if defined(XALAN_NO_STD_NAMESPACE) 00133 typedef deque<const ElemTemplateElement*> ElementRecursionStackType; 00134 typedef vector<FormatterListener*> FormatterListenerVectorType; 00135 typedef vector<PrintWriter*> PrintWriterVectorType; 00136 typedef vector<XalanOutputStream*> OutputStreamVectorType; 00137 typedef set<const KeyDeclaration*, 00138 less<const KeyDeclaration*> > KeyDeclarationSetType; 00139 typedef pair<const XPath*, ClockType> XPathCacheEntry; 00140 typedef map<XalanDOMString, 00141 XPathCacheEntry, 00142 less<XalanDOMString> > XPathCacheMapType; 00143 #else 00144 typedef std::deque<const ElemTemplateElement*> ElementRecursionStackType; 00145 typedef std::vector<FormatterListener*> FormatterListenerVectorType; 00146 typedef std::vector<PrintWriter*> PrintWriterVectorType; 00147 typedef std::vector<XalanOutputStream*> OutputStreamVectorType; 00148 typedef std::set<const KeyDeclaration*> KeyDeclarationSetType; 00149 typedef std::pair<const XPath*, ClockType> XPathCacheEntry; 00150 typedef std::map<XalanDOMString, XPathCacheEntry> XPathCacheMapType; 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 setCurrentTemplate(const ElemTemplate* theTemplate); 00355 00356 virtual bool 00357 doDiagnosticsOutput() const; 00358 00359 virtual void 00360 diag(const XalanDOMString& theString); 00361 00362 virtual void 00363 pushTime(const void* theKey); 00364 00365 virtual void 00366 displayDuration( 00367 const XalanDOMString& theMessage, 00368 const void* theKey); 00369 00370 virtual bool 00371 isElementPending() const; 00372 00373 virtual void 00374 replacePendingAttribute( 00375 const XalanDOMChar* theName, 00376 const XalanDOMChar* theNewType, 00377 const XalanDOMChar* theNewValue); 00378 00379 virtual void 00380 pushOutputContext(FormatterListener* flistener = 0); 00381 00382 virtual void 00383 popOutputContext(); 00384 00385 virtual void 00386 addResultAttribute( 00387 const XalanDOMString& aname, 00388 const XalanDOMString& value); 00389 00390 virtual void 00391 addResultAttribute( 00392 const XalanDOMString& aname, 00393 const XalanDOMChar* value); 00394 00395 virtual void 00396 copyNamespaceAttributes(const XalanNode& src); 00397 00398 virtual const XalanDOMString* 00399 getResultPrefixForNamespace(const XalanDOMString& theNamespace) const; 00400 00401 virtual const XalanDOMString* 00402 getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const; 00403 00404 virtual bool 00405 isPendingResultPrefix(const XalanDOMString& thePrefix); 00406 00407 virtual XalanDOMString 00408 getUniqueNamespaceValue() const; 00409 00410 virtual void 00411 getUniqueNamespaceValue(XalanDOMString& theValue) const; 00412 00413 virtual FormatterListener* 00414 getFormatterListener() const; 00415 00416 virtual void 00417 setFormatterListener(FormatterListener* flistener); 00418 00419 virtual int 00420 getIndent() const; 00421 00422 virtual void 00423 setIndent(int indentAmount); 00424 00425 virtual const XPath* 00426 createMatchPattern( 00427 const XalanDOMString& str, 00428 const PrefixResolver& resolver); 00429 00430 virtual void 00431 returnXPath(const XPath* xpath); 00432 00433 virtual void 00434 pushTopLevelVariables(const ParamVectorType& topLevelParams); 00435 00436 virtual const XObjectPtr 00437 createVariable( 00438 const XPath& xpath, 00439 XalanNode* contextNode, 00440 const PrefixResolver& resolver); 00441 00442 virtual const XObjectPtr 00443 createVariable( 00444 const ElemTemplateElement& templateChild, 00445 XalanNode* sourceNode); 00446 00447 virtual void 00448 pushVariable( 00449 const XalanQName& name, 00450 const ElemTemplateElement* element, 00451 const XalanDOMString& str, 00452 XalanNode* contextNode, 00453 const PrefixResolver& resolver); 00454 00455 virtual void 00456 pushVariable( 00457 const XalanQName& name, 00458 const XObjectPtr val, 00459 const ElemTemplateElement* element); 00460 00461 virtual void 00462 pushVariable( 00463 const XalanQName& name, 00464 const ElemVariable* var, 00465 const ElemTemplateElement* element); 00466 00467 virtual void 00468 pushVariable( 00469 const XalanQName& name, 00470 const ElemTemplateElement* element, 00471 const XPath& xpath, 00472 XalanNode* contextNode, 00473 const PrefixResolver& resolver); 00474 00475 virtual void 00476 pushVariable( 00477 const XalanQName& name, 00478 const ElemTemplateElement* element, 00479 const ElemTemplateElement& templateChild, 00480 XalanNode* sourceNode); 00481 00482 virtual void 00483 pushContextMarker(); 00484 00485 virtual void 00486 popContextMarker(); 00487 00488 virtual void 00489 resolveTopLevelParams(); 00490 00491 virtual void 00492 clearTopLevelParams(); 00493 00494 virtual void 00495 pushParams( 00496 const ElemTemplateElement& xslCallTemplateElement, 00497 XalanNode* sourceNode, 00498 const ElemTemplateElement* targetTemplate); 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(const ElemTemplateElement* elem); 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 eCaseOrder theCaseOrder = eDefault); 00720 00721 virtual int 00722 collationCompare( 00723 const XalanDOMString& theLHS, 00724 const XalanDOMString& theRHS, 00725 const XalanDOMString& theLocale, 00726 eCaseOrder theCaseOrder = eDefault); 00727 00728 virtual int 00729 collationCompare( 00730 const XalanDOMChar* theLHS, 00731 const XalanDOMChar* theRHS, 00732 eCaseOrder theCaseOrder = eDefault); 00733 00734 virtual int 00735 collationCompare( 00736 const XalanDOMChar* theLHS, 00737 const XalanDOMChar* theRHS, 00738 const XalanDOMChar* theLocale, 00739 eCaseOrder theCaseOrder = eDefault); 00740 00741 class XALAN_XSLT_EXPORT CollationCompareFunctor 00742 { 00743 public: 00744 00745 CollationCompareFunctor(); 00746 00747 virtual 00748 ~CollationCompareFunctor(); 00749 00750 // Const version is suitable for use by 00751 // multiple threads. 00752 virtual int 00753 operator()( 00754 const XalanDOMChar* theLHS, 00755 const XalanDOMChar* theRHS, 00756 eCaseOrder theCaseOrder = eDefault) const = 0; 00757 00758 // Const version is suitable for use by 00759 // multiple threads. 00760 virtual int 00761 operator()( 00762 const XalanDOMChar* theLHS, 00763 const XalanDOMChar* theRHS, 00764 const XalanDOMChar* theLocale, 00765 eCaseOrder theCaseOrder = eDefault) const = 0; 00766 }; 00767 00768 class XALAN_XSLT_EXPORT DefaultCollationCompareFunctor : public CollationCompareFunctor 00769 { 00770 public: 00771 00772 DefaultCollationCompareFunctor(); 00773 00774 virtual 00775 ~DefaultCollationCompareFunctor(); 00776 00777 virtual int 00778 operator()( 00779 const XalanDOMChar* theLHS, 00780 const XalanDOMChar* theRHS, 00781 eCaseOrder theCaseOrder = eDefault) const; 00782 00783 virtual int 00784 operator()( 00785 const XalanDOMChar* theLHS, 00786 const XalanDOMChar* theRHS, 00787 const XalanDOMChar* theLocale, 00788 eCaseOrder theCaseOrder = eDefault) const; 00789 }; 00790 00791 const CollationCompareFunctor* 00792 installCollationCompareFunctor(CollationCompareFunctor* theFunctor); 00793 00794 CollationCompareFunctor* 00795 uninstallCollationCompareFunctor(); 00796 00797 virtual bool 00798 getInConstruction(const KeyDeclaration& keyDeclaration) const; 00799 00800 virtual void 00801 beginConstruction(const KeyDeclaration& keyDeclaration); 00802 00803 virtual void 00804 endConstruction(const KeyDeclaration& keyDeclaration); 00805 00806 virtual const XalanDecimalFormatSymbols* 00807 getDecimalFormatSymbols(const XalanQName& qname); 00808 00809 virtual PrintWriter* 00810 createPrintWriter(XalanOutputStream* theTextOutputStream); 00811 00812 virtual PrintWriter* 00813 createPrintWriter( 00814 const XalanDOMString& theFileName, 00815 const XalanDOMString& theEncoding); 00816 00817 virtual PrintWriter* 00818 createPrintWriter(StreamType& theStream); 00819 00820 virtual PrintWriter* 00821 createPrintWriter(FILE* theStream); 00822 00823 virtual CountersTable& 00824 getCountersTable(); 00825 00826 virtual void 00827 characters(const XalanNode& node); 00828 00829 virtual void 00830 characters(const XObjectPtr& xobject); 00831 00832 virtual void 00833 charactersRaw(const XalanNode& node); 00834 00835 virtual void 00836 charactersRaw(const XObjectPtr& xobject); 00837 00838 00839 // These interfaces are inherited from XPathExecutionContext... 00840 00841 virtual void 00842 reset(); 00843 00844 virtual XalanNode* 00845 getCurrentNode() const; 00846 00847 virtual void 00848 setCurrentNode(XalanNode* theCurrentNode); 00849 00850 virtual bool 00851 isNodeAfter( 00852 const XalanNode& node1, 00853 const XalanNode& node2) const; 00854 00855 virtual const NodeRefListBase& 00856 getContextNodeList() const; 00857 00858 virtual void 00859 setContextNodeList(const NodeRefListBase& theList); 00860 00861 virtual size_type 00862 getContextNodeListLength() const; 00863 00864 virtual size_type 00865 getContextNodeListPosition(const XalanNode& contextNode) const; 00866 00867 virtual bool 00868 elementAvailable(const XalanQName& theQName) const; 00869 00870 virtual bool 00871 elementAvailable( 00872 const XalanDOMString& theName, 00873 const LocatorType* locator) const; 00874 00875 virtual bool 00876 functionAvailable(const XalanQName& theQName) const; 00877 00878 virtual bool 00879 functionAvailable( 00880 const XalanDOMString& theName, 00881 const LocatorType* locator) const; 00882 00883 virtual const XObjectPtr 00884 extFunction( 00885 const XalanDOMString& theNamespace, 00886 const XalanDOMString& functionName, 00887 XalanNode* context, 00888 const XObjectArgVectorType& argVec, 00889 const LocatorType* locator); 00890 00891 virtual XalanDocument* 00892 parseXML( 00893 const XalanDOMString& urlString, 00894 const XalanDOMString& base) const; 00895 00896 virtual MutableNodeRefList* 00897 borrowMutableNodeRefList(); 00898 00899 virtual bool 00900 returnMutableNodeRefList(MutableNodeRefList* theList); 00901 00902 virtual MutableNodeRefList* 00903 createMutableNodeRefList() const; 00904 00905 virtual XalanDOMString& 00906 getCachedString(); 00907 00908 virtual bool 00909 releaseCachedString(XalanDOMString& theString); 00910 00911 virtual void 00912 getNodeSetByKey( 00913 XalanDocument* doc, 00914 const XalanQName& qname, 00915 const XalanDOMString& ref, 00916 MutableNodeRefList& nodelist); 00917 00918 virtual void 00919 getNodeSetByKey( 00920 XalanDocument* doc, 00921 const XalanDOMString& name, 00922 const XalanDOMString& ref, 00923 const LocatorType* locator, 00924 MutableNodeRefList& nodelist); 00925 00926 virtual const XObjectPtr 00927 getVariable( 00928 const XalanQName& name, 00929 const LocatorType* locator = 0); 00930 00931 virtual const PrefixResolver* 00932 getPrefixResolver() const; 00933 00934 virtual void 00935 setPrefixResolver(const PrefixResolver* thePrefixResolver); 00936 00937 virtual const XalanDOMString* 00938 getNamespaceForPrefix(const XalanDOMString& prefix) const; 00939 00940 virtual XalanDOMString 00941 findURIFromDoc(const XalanDocument* owner) const; 00942 00943 virtual const XalanDOMString& 00944 getUnparsedEntityURI( 00945 const XalanDOMString& theName, 00946 const XalanDocument& theDocument) const; 00947 00948 virtual bool 00949 shouldStripSourceNode(const XalanNode& node); 00950 00951 virtual bool 00952 getThrowFoundIndex() const; 00953 00954 virtual void 00955 setThrowFoundIndex(bool fThrow); 00956 00957 virtual XalanDocument* 00958 getSourceDocument(const XalanDOMString& theURI) const; 00959 00960 virtual void 00961 setSourceDocument( 00962 const XalanDOMString& theURI, 00963 XalanDocument* theDocument); 00964 00965 00966 // These interfaces are inherited from ExecutionContext... 00967 00968 virtual void 00969 error( 00970 const XalanDOMString& msg, 00971 const XalanNode* sourceNode, 00972 const LocatorType* locator) const; 00973 00974 virtual void 00975 error( 00976 const char* msg, 00977 const XalanNode* sourceNode, 00978 const LocatorType* locator) const; 00979 00980 virtual void 00981 warn( 00982 const XalanDOMString& msg, 00983 const XalanNode* sourceNode, 00984 const LocatorType* locator) const; 00985 00986 virtual void 00987 warn( 00988 const char* msg, 00989 const XalanNode* sourceNode, 00990 const LocatorType* locator) const; 00991 00992 virtual void 00993 message( 00994 const XalanDOMString& msg, 00995 const XalanNode* sourceNode, 00996 const LocatorType* locator) const; 00997 00998 virtual void 00999 message( 01000 const char* msg, 01001 const XalanNode* sourceNode, 01002 const LocatorType* locator) const; 01003 01004 01005 class XPathCacheReturnFunctor 01006 { 01007 public: 01008 01009 XPathCacheReturnFunctor(XSLTEngineImpl& xsltProcessor) : 01010 m_xsltProcessor(xsltProcessor) 01011 { 01012 } 01013 01014 void 01015 operator()(const XPathCacheMapType::value_type& theCacheEntry); 01016 01017 private: 01018 01019 XSLTEngineImpl& m_xsltProcessor; 01020 }; 01021 01026 XalanSourceTreeDocument* 01027 getSourceTreeFactory() const; 01028 01029 protected: 01030 01031 virtual FormatterToText* 01032 borrowFormatterToText(); 01033 01034 virtual bool 01035 returnFormatterToText(FormatterToText* theFormatter); 01036 01037 private: 01038 01047 void 01048 getParams( 01049 const ElemTemplateElement& xslCallTemplateElement, 01050 XalanNode* sourceNode, 01051 ParamsVectorType& params); 01052 01059 bool 01060 isCached(const XPath* theXPath); 01061 01065 void 01066 clearXPathCache(); 01067 01075 void 01076 addToXPathCache( 01077 const XalanDOMString& pattern, 01078 const XPath* theXPath); 01079 01080 01084 void 01085 cleanUpTransients(); 01086 01087 XPathExecutionContextDefault m_xpathExecutionContextDefault; 01088 01089 XSLTEngineImpl* m_xsltProcessor; 01090 01091 XalanNode* m_rootDocument; 01092 01093 enum { eXPathCacheMax = 50, 01094 eDefaultParamsVectorSize = 10, 01095 eXResultTreeFragAllocatorBlockSize = 10, 01096 eResultTreeFragAllocatorBlockSize = 10, 01097 eDocumentAllocatorBlockSize = 10, 01098 eDocumentFragmentAllocatorBlockSize = 10, 01099 eDefaultAttributeAllocatorBlockSize = 10, 01100 eDefaultAttributeNSAllocatorBlockSize = 10, 01101 eDefaultCommentAllocatorBlockSize = 10, 01102 eDefaultElementAllocatorBlockSize = 10, 01103 eDefaultElementNSAllocatorBlockSize = 10, 01104 eDefaultPIAllocatorBlockSize = 10, 01105 eDefaultTextAllocatorBlockSize = 20, 01106 eDefaultTextIWSAllocatorBlockSize = 20 }; 01107 01108 ElementRecursionStackType m_elementRecursionStack; 01109 01110 const PrefixResolver* m_prefixResolver; 01111 01112 const StylesheetRoot* m_stylesheetRoot; 01113 01114 FormatterListenerVectorType m_formatterListeners; 01115 01116 PrintWriterVectorType m_printWriters; 01117 01118 OutputStreamVectorType m_outputStreams; 01119 01120 CollationCompareFunctor* m_collationCompareFunctor; 01121 01125 VariablesStack m_variablesStack; 01126 01127 ParamsVectorType m_paramsVector; 01128 01129 XPathCacheMapType m_matchPatternCache; 01130 01131 KeyTablesTableType m_keyTables; 01132 01133 KeyDeclarationSetType m_keyDeclarationSet; 01134 01135 CountersTable m_countersTable; 01136 01137 // If true, we will not check HTML output for elements with 01138 // namespaces. This is an optimization which can lead to 01139 // non-conforming behavior. 01140 bool m_ignoreHTMLElementNamespaces; 01141 01146 mutable XalanAutoPtr<XalanSourceTreeDocument> m_sourceTreeResultTreeFactory; 01147 01148 // Holds the current mode. 01149 const XalanQName* m_mode; 01150 01151 const ElemTemplate* m_currentTemplate; 01152 01153 typedef XalanObjectCacheDefault<FormatterToText> FormatterToTextCacheType; 01154 typedef XalanObjectCacheDefault<FormatterToSourceTree> FormatterToSourceTreeCacheType; 01155 typedef XalanObjectCacheDefault<NodeSorter> NodeSorterCacheType; 01156 01157 FormatterToTextCacheType m_formatterToTextCache; 01158 01159 FormatterToSourceTreeCacheType m_formatterToSourceTreeCache; 01160 01161 NodeSorterCacheType m_nodeSorterCache; 01162 01163 int m_indentAmount; 01164 01165 XResultTreeFragAllocator m_xresultTreeFragAllocator; 01166 01167 ResultTreeFragAllocator m_resultTreeFragAllocator; 01168 01169 XalanSourceTreeDocumentFragmentAllocator m_documentFragmentAllocator; 01170 01171 XalanSourceTreeDocumentAllocator m_documentAllocator; 01172 01173 // If true, we will use a separate document factory for 01174 // result tree fragments. 01175 bool m_usePerInstanceDocumentFactory; 01176 01177 // If true, only text nodes will be cloned in the output... 01178 bool m_cloneTextNodesOnly; 01179 01180 // Determines whether or not to override the property in the stylesheet. 01181 eEscapeURLs m_escapeURLs; 01182 01183 // Determines whether or not to override the property in the stylesheet. 01184 eOmitMETATag m_omitMETATag; 01185 01186 static XalanNumberFormatFactory s_defaultXalanNumberFormatFactory; 01187 01188 static XalanNumberFormatFactory* s_xalanNumberFormatFactory; 01189 01190 static const DefaultCollationCompareFunctor s_defaultCollationFunctor; 01191 }; 01192 01193 01194 01195 XALAN_CPP_NAMESPACE_END 01196 01197 01198 01199 #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.6 |
|