00001 /* 00002 * Licensed to the Apache Software Foundation (ASF) under one 00003 * or more contributor license agreements. See the NOTICE file 00004 * distributed with this work for additional information 00005 * regarding copyright ownership. The ASF licenses this file 00006 * to you under the Apache License, Version 2.0 (the "License"); 00007 * you may not use this file except in compliance with the License. 00008 * You may obtain a copy of the License at 00009 * 00010 * http://www.apache.org/licenses/LICENSE-2.0 00011 * 00012 * Unless required by applicable law or agreed to in writing, software 00013 * distributed under the License is distributed on an "AS IS" BASIS, 00014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00015 * See the License for the specific language governing permissions and 00016 * limitations under the License. 00017 */ 00018 #if !defined(STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680) 00019 #define STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680 00020 00021 00022 00023 // Base class include file. 00024 #include <xalanc/XSLT/StylesheetExecutionContext.hpp> 00025 00026 00027 00028 #include <ctime> 00029 #include <memory> 00030 00031 00032 00033 #include <xalanc/Include/XalanVector.hpp> 00034 #include <xalanc/Include/XalanMap.hpp> 00035 #include <xalanc/Include/XalanSet.hpp> 00036 #include <xalanc/Include/XalanObjectCache.hpp> 00037 #include <xalanc/Include/XalanObjectStackCache.hpp> 00038 00039 00040 #include <xalanc/PlatformSupport/DOMStringHelper.hpp> 00041 00042 00043 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00044 #include <xalanc/PlatformSupport/DOMStringPrintWriter.hpp> 00045 #endif 00046 00047 00048 00049 #include <xalanc/XPath/XPathExecutionContextDefault.hpp> 00050 00051 00052 00053 #include <xalanc/XMLSupport/FormatterToText.hpp> 00054 00055 00056 00057 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) 00058 #include <xalanc/XalanSourceTree/XalanSourceTreeDocument.hpp> 00059 #endif 00060 #include <xalanc/XalanSourceTree/FormatterToSourceTree.hpp> 00061 #include <xalanc/XalanSourceTree/XalanSourceTreeDocumentFragment.hpp> 00062 00063 00064 00065 #include <xalanc/XSLT/CountersTable.hpp> 00066 #include <xalanc/XSLT/NodeSorter.hpp> 00067 #include <xalanc/XSLT/Stylesheet.hpp> 00068 #include <xalanc/XSLT/VariablesStack.hpp> 00069 #include <xalanc/XSLT/XResultTreeFragAllocator.hpp> 00070 #include <xalanc/XSLT/XalanSourceTreeDocumentAllocator.hpp> 00071 #include <xalanc/XSLT/XalanSourceTreeDocumentFragmentAllocator.hpp> 00072 00073 00074 00075 XALAN_CPP_NAMESPACE_BEGIN 00076 00077 00078 00079 class XalanSourceTreeDocument; 00080 class XPathProcessor; 00081 class XSLTEngineImpl; 00082 00083 typedef VariablesStack::ParamsVectorType ParamsVectorTypeDecl; 00084 XALAN_USES_MEMORY_MANAGER(ParamsVectorTypeDecl) 00085 // 00086 // An class which provides support for executing stylesheets. 00087 // 00088 class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext 00089 { 00090 public: 00091 00092 #if defined(XALAN_STRICT_ANSI_HEADERS) 00093 typedef std::clock_t ClockType; 00094 #else 00095 typedef clock_t ClockType; 00096 #endif 00097 00098 typedef XalanVector<FormatterListener*> FormatterListenerVectorType; 00099 typedef XalanVector<PrintWriter*> PrintWriterVectorType; 00100 typedef XalanVector<XalanOutputStream*> OutputStreamVectorType; 00101 00102 typedef XalanVector<const ElemTemplateElement*> ElementTemplateElementStackType; 00103 typedef XALAN_STD_QUALIFIER pair<const XPath*, ClockType> XPathCacheEntry; 00104 typedef XalanMap <XalanDOMString, XPathCacheEntry> XPathCacheMapType; 00105 typedef XalanVector<const ElemTemplate*> CurrentTemplateStackType; 00106 00107 typedef Stylesheet::KeyTablesTableType KeyTablesTableType; 00108 typedef ParamsVectorTypeDecl ParamsVectorType; 00109 00110 /** 00111 * Construct a StylesheetExecutionContextDefault object 00112 * 00113 * @param theXPathEnvSupport XPath environment support class instance 00114 * @param theDOMSupport DOMSupport class instance 00115 * @param theXobjectFactory factory class instance for XObjects 00116 * @param theCurrentNode current node in the source tree 00117 * @param theContextNodeList node list for current context 00118 * @param thePrefixResolver pointer to prefix resolver to use 00119 */ 00120 StylesheetExecutionContextDefault( 00121 MemoryManager& theManager, 00122 XSLTEngineImpl& xsltProcessor, 00123 XPathEnvSupport& theXPathEnvSupport, 00124 DOMSupport& theDOMSupport, 00125 XObjectFactory& theXObjectFactory, 00126 XalanNode* theCurrentNode = 0, 00127 const NodeRefListBase* theContextNodeList = 0, 00128 const PrefixResolver* thePrefixResolver = 0); 00129 00130 /** 00131 * Construct a StylesheetExecutionContextDefault object 00132 * 00133 * @param theXPathEnvSupport XPath environment support class instance 00134 * @param theDOMSupport DOMSupport class instance 00135 * @param theXobjectFactory factory class instance for XObjects 00136 * @param theCurrentNode current node in the source tree 00137 * @param theContextNodeList node list for current context 00138 * @param thePrefixResolver pointer to prefix resolver to use 00139 */ 00140 explicit 00141 StylesheetExecutionContextDefault( 00142 MemoryManager& theManager, 00143 XalanNode* theCurrentNode = 0, 00144 const NodeRefListBase* theContextNodeList = 0, 00145 const PrefixResolver* thePrefixResolver = 0); 00146 00147 static StylesheetExecutionContextDefault* 00148 create( 00149 MemoryManager& theManager, 00150 XalanNode* theCurrentNode = 0, 00151 const NodeRefListBase* theContextNodeList = 0, 00152 const PrefixResolver* thePrefixResolver = 0); 00153 00154 virtual 00155 ~StylesheetExecutionContextDefault(); 00156 00157 00158 /** 00159 * Set the XPathEnvSupport instance. 00160 * 00161 * @param theSupport a reference to the instance to use. 00162 */ 00163 void 00164 setXPathEnvSupport(XPathEnvSupport* theSupport) 00165 { 00166 m_xpathExecutionContextDefault.setXPathEnvSupport(theSupport); 00167 } 00168 00169 /** 00170 * Set the DOMSupport instance. 00171 * 00172 * @param theDOMSupport a reference to the instance to use. 00173 */ 00174 void 00175 setDOMSupport(DOMSupport* theDOMSupport) 00176 { 00177 m_xpathExecutionContextDefault.setDOMSupport(theDOMSupport); 00178 } 00179 00180 /** 00181 * Set the XObjectFactory instance. 00182 * 00183 * @param theFactory a reference to the instance to use. 00184 */ 00185 void 00186 setXObjectFactory(XObjectFactory* theXObjectFactory) 00187 { 00188 m_xpathExecutionContextDefault.setXObjectFactory(theXObjectFactory); 00189 00190 m_xobjectFactory = theXObjectFactory; 00191 } 00192 00193 00194 /** 00195 * Set the DOMSupport instance. 00196 * 00197 * @param theDOMSupport a reference to the instance to use. 00198 */ 00199 void 00200 setXSLTProcessor(XSLTEngineImpl* theProcessor) 00201 { 00202 m_xsltProcessor = theProcessor; 00203 } 00204 00205 bool 00206 getUsePerInstanceDocumentFactory() const 00207 { 00208 return m_usePerInstanceDocumentFactory; 00209 } 00210 00211 void 00212 setUsePerInstanceDocumentFactory(bool fValue) 00213 { 00214 m_usePerInstanceDocumentFactory = fValue; 00215 } 00216 00217 00218 // These interfaces are inherited from StylesheetExecutionContext... 00219 00220 virtual bool 00221 getQuietConflictWarnings() const; 00222 00223 virtual bool 00224 getCopyTextNodesOnly() const; 00225 00226 virtual void 00227 pushCopyTextNodesOnly(bool copyTextNodesOnly); 00228 00229 virtual bool 00230 popCopyTextNodesOnly(); 00231 00232 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00233 virtual void 00234 pushProcessCurrentAttribute(bool processAttribute); 00235 00236 virtual bool 00237 popProcessCurrentAttribute(); 00238 00239 virtual void 00240 pushSkipElementAttributes(bool skipAttributes); 00241 00242 virtual bool 00243 getSkipElementAttributes() const; 00244 00245 virtual bool 00246 popSkipElementAttributes(); 00247 00248 virtual void 00249 pushExecuteIf(bool executeIf); 00250 00251 virtual bool 00252 popExecuteIf(); 00253 #endif 00254 00255 virtual XalanNode* 00256 getRootDocument() const; 00257 00258 virtual void 00259 setRootDocument(XalanNode* theDocument); 00260 00261 virtual void 00262 setStylesheetRoot(const StylesheetRoot* theStylesheet); 00263 00264 virtual const XalanQName* 00265 getCurrentMode() const; 00266 00267 virtual void 00268 pushCurrentMode(const XalanQName* theMode); 00269 00270 virtual void 00271 popCurrentMode(); 00272 00273 virtual const ElemTemplate* 00274 getCurrentTemplate() const; 00275 00276 virtual void 00277 pushCurrentTemplate(const ElemTemplate* theTemplate); 00278 00279 virtual void 00280 popCurrentTemplate(); 00281 00282 virtual bool 00283 isElementPending() const; 00284 00285 virtual void 00286 replacePendingAttribute( 00287 const XalanDOMChar* theName, 00288 const XalanDOMChar* theNewType, 00289 const XalanDOMChar* theNewValue); 00290 00291 virtual void 00292 pushOutputContext(FormatterListener* flistener = 0); 00293 00294 virtual void 00295 popOutputContext(); 00296 00297 virtual void 00298 addResultAttribute( 00299 const XalanDOMString& aname, 00300 const XalanDOMString& value); 00301 00302 virtual void 00303 addResultAttribute( 00304 const XalanDOMString& aname, 00305 const XalanDOMChar* value); 00306 00307 virtual void 00308 copyNamespaceAttributes(const XalanNode& src); 00309 00310 virtual const XalanDOMString* 00311 getResultPrefixForNamespace(const XalanDOMString& theNamespace) const; 00312 00313 virtual const XalanDOMString* 00314 getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const; 00315 00316 virtual bool 00317 isPendingResultPrefix(const XalanDOMString& thePrefix); 00318 00319 virtual void 00320 getUniqueNamespaceValue(XalanDOMString& theValue) const; 00321 00322 virtual FormatterListener* 00323 getFormatterListener() const; 00324 00325 virtual void 00326 setFormatterListener(FormatterListener* flistener); 00327 00328 virtual int 00329 getIndent() const; 00330 00331 virtual void 00332 setIndent(int indentAmount); 00333 00334 virtual const XPath* 00335 createMatchPattern( 00336 const XalanDOMString& str, 00337 const PrefixResolver& resolver); 00338 00339 virtual void 00340 returnXPath(const XPath* xpath); 00341 00342 virtual void 00343 pushTopLevelVariables(const ParamVectorType& topLevelParams); 00344 00345 00346 virtual const XObjectPtr 00347 createVariable( 00348 const XPath& xpath, 00349 XalanNode* contextNode, 00350 const PrefixResolver& resolver); 00351 00352 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00353 virtual const XObjectPtr 00354 createVariable( 00355 const ElemTemplateElement& templateChild, 00356 XalanNode* sourceNode); 00357 #endif 00358 00359 virtual void 00360 pushVariable( 00361 const XalanQName& name, 00362 const ElemTemplateElement* element, 00363 const XalanDOMString& str, 00364 XalanNode* contextNode, 00365 const PrefixResolver& resolver); 00366 00367 virtual void 00368 pushVariable( 00369 const XalanQName& name, 00370 const XObjectPtr val, 00371 const ElemTemplateElement* element); 00372 00373 virtual void 00374 pushVariable( 00375 const XalanQName& name, 00376 const ElemVariable* var, 00377 const ElemTemplateElement* element); 00378 00379 virtual void 00380 pushVariable( 00381 const XalanQName& name, 00382 const ElemTemplateElement* element, 00383 const XPath& xpath, 00384 XalanNode* contextNode, 00385 const PrefixResolver& resolver); 00386 00387 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00388 virtual void 00389 pushVariable( 00390 const XalanQName& name, 00391 const ElemTemplateElement* element, 00392 const ElemTemplateElement& templateChild, 00393 XalanNode* sourceNode); 00394 #endif 00395 00396 00397 virtual void 00398 pushContextMarker(); 00399 00400 virtual void 00401 popContextMarker(); 00402 00403 virtual void 00404 resolveTopLevelParams(); 00405 00406 virtual void 00407 clearTopLevelParams(); 00408 00409 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00410 virtual void beginParams(); 00411 00412 virtual void endParams(); 00413 00414 virtual void pushParam(const XalanQName& qName,const XObjectPtr& theValue); 00415 #else 00416 virtual void 00417 pushParams(const ElemTemplateElement& xslCallTemplateElement); 00418 #endif 00419 00420 virtual const XObjectPtr 00421 getParamVariable(const XalanQName& theName); 00422 00423 virtual void 00424 pushElementFrame(const ElemTemplateElement* elem); 00425 00426 virtual void 00427 popElementFrame(); 00428 00429 virtual int 00430 getGlobalStackFrameIndex() const; 00431 00432 virtual int 00433 getCurrentStackFrameIndex() const; 00434 00435 virtual void 00436 pushCurrentStackFrameIndex(int currentStackFrameIndex = -1); 00437 00438 virtual void 00439 popCurrentStackFrameIndex(); 00440 00441 virtual void 00442 startDocument(); 00443 00444 virtual void 00445 endDocument(); 00446 00447 virtual void 00448 startElement(const XalanDOMChar* name); 00449 00450 virtual void 00451 endElement(const XalanDOMChar* name); 00452 00453 virtual void 00454 characters( 00455 const XalanDOMChar* ch, 00456 fl_size_type start, 00457 fl_size_type length); 00458 00459 virtual void 00460 charactersRaw( 00461 const XalanDOMChar* ch, 00462 fl_size_type start, 00463 fl_size_type length); 00464 00465 virtual void 00466 comment(const XalanDOMChar* data); 00467 00468 virtual void 00469 processingInstruction( 00470 const XalanDOMChar* target, 00471 const XalanDOMChar* data); 00472 00473 virtual void 00474 flushPending(); 00475 00476 virtual void 00477 cloneToResultTree( 00478 const XalanNode& node, 00479 const Locator* locator); 00480 00481 virtual void 00482 cloneToResultTree( 00483 const XalanNode& node, 00484 XalanNode::NodeType nodeType, 00485 bool overrideStrip, 00486 bool shouldCloneAttributes, 00487 const Locator* locator); 00488 00489 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00490 virtual void 00491 beginCreateXResultTreeFrag(XalanNode* sourceNode); 00492 00493 virtual const XObjectPtr 00494 endCreateXResultTreeFrag(); 00495 00496 virtual void 00497 beginFormatToText(XalanDOMString& theResult); 00498 00499 virtual void 00500 endFormatToText(); 00501 #endif 00502 00503 00504 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00505 virtual const XObjectPtr 00506 createXResultTreeFrag( 00507 const ElemTemplateElement& templateChild, 00508 XalanNode* sourceNode); 00509 #endif 00510 00511 virtual void 00512 outputToResultTree( 00513 const XObject& xobj, 00514 const Locator* locator); 00515 00516 virtual void 00517 outputResultTreeFragment( 00518 const XObject& theTree, 00519 const Locator* locator); 00520 00521 virtual const XalanDOMString& 00522 getXSLNameSpaceURL() const; 00523 00524 virtual const XalanDOMString& 00525 getXalanXSLNameSpaceURL() const; 00526 00527 virtual bool 00528 findOnElementRecursionStack(const ElemTemplateElement* theElement) const; 00529 00530 virtual void 00531 pushOnElementRecursionStack(const ElemTemplateElement* theElement); 00532 00533 virtual const ElemTemplateElement* 00534 popElementRecursionStack(); 00535 00536 virtual bool 00537 returnXResultTreeFrag(XResultTreeFrag* theXResultTreeFrag); 00538 00539 virtual eEscapeURLs 00540 getEscapeURLs() const; 00541 00542 virtual void 00543 setEscapeURLs(eEscapeURLs value); 00544 00545 virtual eOmitMETATag 00546 getOmitMETATag() const; 00547 00548 void 00549 setOmitMETATag(eOmitMETATag value); 00550 00551 virtual FormatterListener* 00552 createFormatterToXML( 00553 Writer& writer, 00554 const XalanDOMString& version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00555 bool doIndent = false, 00556 int indent = eDefaultXMLIndentAmount, 00557 const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00558 const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00559 const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00560 const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00561 bool xmlDecl = true, 00562 const XalanDOMString& standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr())); 00563 00564 virtual FormatterListener* 00565 createFormatterToHTML( 00566 Writer& writer, 00567 const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00568 const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00569 const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00570 const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 00571 bool doIndent = true, 00572 int indent = eDefaultHTMLIndentAmount, 00573 bool escapeURLs = true, 00574 bool omitMetaTag = false); 00575 00576 virtual FormatterListener* 00577 createFormatterToText( 00578 Writer& writer, 00579 const XalanDOMString& encoding); 00580 00581 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00582 virtual NodeSorter* 00583 getNodeSorter(); 00584 #else 00585 virtual NodeSorter* 00586 borrowNodeSorter(); 00587 00588 virtual bool 00589 returnNodeSorter(NodeSorter* theSorter); 00590 #endif 00591 00592 virtual XalanNumberFormatAutoPtr 00593 createXalanNumberFormat(); 00594 00595 // A basic class to create XalanNumberFormat instances... 00596 class XALAN_XSLT_EXPORT XalanNumberFormatFactory 00597 { 00598 public: 00599 00600 explicit 00601 XalanNumberFormatFactory(); 00602 00603 virtual 00604 ~XalanNumberFormatFactory(); 00605 00606 virtual XalanNumberFormat* 00607 create(MemoryManager& theManager); 00608 }; 00609 00610 static XalanNumberFormatFactory& 00611 getDefaultXalanNumberFormatFactory() 00612 { 00613 return s_defaultXalanNumberFormatFactory; 00614 } 00615 00616 /** 00617 * Static function to install a new XalanNumberFormatFactory. 00618 * The caller owns the XalanNumberFormatFactory instance. 00619 * 00620 * @param a pointer to the new factory instance to use. 00621 * @return a pointer to the old factory instance. 00622 */ 00623 static XalanNumberFormatFactory* 00624 installXalanNumberFormatFactory(XalanNumberFormatFactory* theFactory); 00625 00626 00627 virtual tl_size_type 00628 getTraceListeners() const; 00629 00630 virtual void 00631 fireGenerateEvent(const GenerateEvent& ge); 00632 00633 virtual void 00634 fireTraceEvent(const TracerEvent& te); 00635 00636 virtual void 00637 fireSelectEvent(const SelectionEvent& se); 00638 00639 virtual bool 00640 getTraceSelects() const; 00641 00642 virtual void 00643 traceSelect( 00644 const ElemTemplateElement& theStylesheetElement, 00645 const NodeRefListBase& nl, 00646 const XPath* xpath); 00647 00648 virtual int 00649 collationCompare( 00650 const XalanDOMString& theLHS, 00651 const XalanDOMString& theRHS, 00652 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00653 00654 virtual int 00655 collationCompare( 00656 const XalanDOMString& theLHS, 00657 const XalanDOMString& theRHS, 00658 const XalanDOMString& theLocale, 00659 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00660 00661 virtual int 00662 collationCompare( 00663 const XalanDOMChar* theLHS, 00664 const XalanDOMChar* theRHS, 00665 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00666 00667 virtual int 00668 collationCompare( 00669 const XalanDOMChar* theLHS, 00670 const XalanDOMChar* theRHS, 00671 const XalanDOMChar* theLocale, 00672 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault); 00673 00674 typedef XalanCollationServices::CollationCompareFunctor CollationCompareFunctor; 00675 00676 class XALAN_XSLT_EXPORT DefaultCollationCompareFunctor : public CollationCompareFunctor 00677 { 00678 public: 00679 00680 DefaultCollationCompareFunctor(); 00681 00682 virtual 00683 ~DefaultCollationCompareFunctor(); 00684 00685 virtual int 00686 operator()( 00687 const XalanDOMChar* theLHS, 00688 const XalanDOMChar* theRHS, 00689 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; 00690 00691 virtual int 00692 operator()( 00693 const XalanDOMChar* theLHS, 00694 const XalanDOMChar* theRHS, 00695 const XalanDOMChar* theLocale, 00696 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) const; 00697 }; 00698 00699 00700 const CollationCompareFunctor* 00701 installCollationCompareFunctor(CollationCompareFunctor* theFunctor); 00702 00703 CollationCompareFunctor* 00704 uninstallCollationCompareFunctor(); 00705 00706 00707 class XALAN_XSLT_EXPORT FormatNumberFunctor 00708 { 00709 public: 00710 00711 FormatNumberFunctor() {}; 00712 00713 virtual 00714 ~FormatNumberFunctor() {}; 00715 00716 virtual void 00717 operator() ( 00718 XPathExecutionContext& executionContext, 00719 double theNumber, 00720 const XalanDOMString& thePattern, 00721 const XalanDecimalFormatSymbols* theDFS, 00722 XalanDOMString& theResult, 00723 const XalanNode* context = 0, 00724 const Locator* locator = 0) const = 0; 00725 }; 00726 00727 virtual void 00728 formatNumber( 00729 double number, 00730 const XalanDOMString& pattern, 00731 XalanDOMString& theResult, 00732 const XalanNode* context = 0, 00733 const Locator* locator = 0); 00734 00735 virtual void 00736 formatNumber( 00737 double number, 00738 const XalanDOMString& pattern, 00739 const XalanDOMString& dfsName, 00740 XalanDOMString& theResult, 00741 const XalanNode* context = 0, 00742 const Locator* locator = 0); 00743 00744 00745 const FormatNumberFunctor* 00746 installFormatNumberFunctor(FormatNumberFunctor* formatNumberFunctor); 00747 00748 FormatNumberFunctor* 00749 uninstallFormatNumberFunctor(); 00750 00751 virtual PrintWriter* 00752 createPrintWriter(XalanOutputStream* theTextOutputStream); 00753 00754 virtual PrintWriter* 00755 createPrintWriter( 00756 const XalanDOMString& theFileName, 00757 const XalanDOMString& theEncoding); 00758 00759 virtual PrintWriter* 00760 createPrintWriter(StreamType& theStream); 00761 00762 virtual PrintWriter* 00763 createPrintWriter(FILE* theStream); 00764 00765 virtual CountersTable& 00766 getCountersTable(); 00767 00768 virtual void 00769 characters(const XalanNode& node); 00770 00771 virtual void 00772 characters(const XObjectPtr& xobject); 00773 00774 virtual void 00775 charactersRaw(const XalanNode& node); 00776 00777 virtual void 00778 charactersRaw(const XObjectPtr& xobject); 00779 00780 00781 // These interfaces are inherited from XPathExecutionContext... 00782 00783 virtual void 00784 reset(); 00785 00786 virtual XalanNode* 00787 getCurrentNode() const; 00788 00789 virtual void 00790 pushCurrentNode(XalanNode* theCurrentNode); 00791 00792 virtual void 00793 popCurrentNode(); 00794 00795 virtual bool 00796 isNodeAfter( 00797 const XalanNode& node1, 00798 const XalanNode& node2) const; 00799 00800 virtual void 00801 pushContextNodeList(const NodeRefListBase& theList); 00802 00803 virtual void 00804 popContextNodeList(); 00805 00806 virtual const NodeRefListBase& 00807 getContextNodeList() const; 00808 00809 virtual size_type 00810 getContextNodeListLength() const; 00811 00812 virtual size_type 00813 getContextNodeListPosition(const XalanNode& contextNode) const; 00814 00815 virtual bool 00816 elementAvailable(const XalanQName& theQName) const; 00817 00818 virtual bool 00819 elementAvailable( 00820 const XalanDOMString& theName, 00821 const Locator* locator) const; 00822 00823 virtual bool 00824 functionAvailable(const XalanQName& theQName) const; 00825 00826 virtual bool 00827 functionAvailable( 00828 const XalanDOMString& theName, 00829 const Locator* locator) const; 00830 00831 virtual const XObjectPtr 00832 extFunction( 00833 const XalanDOMString& theNamespace, 00834 const XalanDOMString& functionName, 00835 XalanNode* context, 00836 const XObjectArgVectorType& argVec, 00837 const Locator* locator); 00838 00839 virtual XalanDocument* 00840 parseXML( 00841 MemoryManager& theManager, 00842 const XalanDOMString& urlString, 00843 const XalanDOMString& base, 00844 ErrorHandler* theErrorHandler = 0) const; 00845 00846 virtual MutableNodeRefList* 00847 borrowMutableNodeRefList(); 00848 00849 virtual bool 00850 returnMutableNodeRefList(MutableNodeRefList* theList); 00851 00852 virtual MutableNodeRefList* 00853 createMutableNodeRefList(MemoryManager& theManager) const; 00854 00855 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00856 virtual void 00857 createUseAttributeSetIndexesOnStack(); 00858 00859 virtual UseAttributeSetIndexes& 00860 getUseAttributeSetIndexes(); 00861 00862 virtual void 00863 popUseAttributeSetIndexesFromStack(); 00864 00865 virtual void 00866 pushInvoker(const ElemTemplateElement * invoker); 00867 00868 virtual void 00869 popInvoker(); 00870 00871 virtual const ElemTemplateElement* 00872 getInvoker() const; 00873 00874 virtual MutableNodeRefList& 00875 createAndPushMutableNodeRefList(); 00876 00877 virtual void 00878 releaseAndPopMutableNodeRefList(); 00879 00880 virtual void 00881 pushXObjectPtr(const XObjectPtr& xobjectPtr); 00882 00883 virtual void 00884 popXObjectPtr(); 00885 00886 virtual void 00887 createAndPushNodesToTransformList(const NodeRefListBase* nodeList); 00888 00889 virtual XalanNode* 00890 getNextNodeToTransform(); 00891 00892 virtual void 00893 popNodesToTransformList(); 00894 00895 virtual XalanDOMString& 00896 getAndPushCachedString(); 00897 00898 virtual XalanDOMString& 00899 getLastCachedString(); 00900 00901 virtual XalanDOMString& 00902 getAndPopCachedString(); 00903 #endif 00904 00905 virtual XalanDOMString& 00906 getCachedString(); 00907 00908 virtual bool 00909 releaseCachedString(XalanDOMString& theString); 00910 00911 00912 virtual void 00913 getNodeSetByKey( 00914 XalanNode* context, 00915 const XalanQName& qname, 00916 const XalanDOMString& ref, 00917 const Locator* locator, 00918 MutableNodeRefList& nodelist); 00919 00920 virtual void 00921 getNodeSetByKey( 00922 XalanNode* context, 00923 const XalanDOMString& name, 00924 const XalanDOMString& ref, 00925 const Locator* locator, 00926 MutableNodeRefList& nodelist); 00927 00928 virtual const XObjectPtr 00929 getVariable( 00930 const XalanQName& name, 00931 const Locator* locator = 0); 00932 00933 virtual const PrefixResolver* 00934 getPrefixResolver() const; 00935 00936 virtual void 00937 setPrefixResolver(const PrefixResolver* thePrefixResolver); 00938 00939 virtual const XalanDOMString* 00940 getNamespaceForPrefix(const XalanDOMString& prefix) const; 00941 00942 virtual const XalanDOMString& 00943 findURIFromDoc(const XalanDocument* owner) const; 00944 00945 virtual const XalanDOMString& 00946 getUnparsedEntityURI( 00947 const XalanDOMString& theName, 00948 const XalanDocument& theDocument) const; 00949 00950 virtual bool 00951 shouldStripSourceNode(const XalanText& node); 00952 00953 virtual XalanDocument* 00954 getSourceDocument(const XalanDOMString& theURI) const; 00955 00956 virtual void 00957 setSourceDocument( 00958 const XalanDOMString& theURI, 00959 XalanDocument* theDocument); 00960 00961 // These interfaces are inherited from ExecutionContext... 00962 virtual void 00963 problem( 00964 eSource source, 00965 eClassification classification, 00966 const XalanDOMString& msg, 00967 const Locator* locator, 00968 const XalanNode* sourceNode); 00969 00970 virtual void 00971 problem( 00972 eSource source, 00973 eClassification classification, 00974 const XalanDOMString& msg, 00975 const XalanNode* sourceNode); 00976 00977 class XPathCacheReturnFunctor 00978 { 00979 public: 00980 00981 XPathCacheReturnFunctor(XSLTEngineImpl& xsltProcessor) : 00982 m_xsltProcessor(xsltProcessor) 00983 { 00984 } 00985 00986 void 00987 operator()(const XPathCacheMapType::value_type& theCacheEntry); 00988 00989 private: 00990 00991 XSLTEngineImpl& m_xsltProcessor; 00992 }; 00993 00994 /** 00995 * Get a XalanSourceTreeDocument, primarily for creating result 00996 * tree fragments. 00997 */ 00998 XalanSourceTreeDocument* 00999 getSourceTreeFactory(MemoryManager& theManager) const; 01000 01001 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01002 protected: 01003 01004 virtual FormatterToText* 01005 borrowFormatterToText(); 01006 01007 virtual bool 01008 returnFormatterToText(FormatterToText* theFormatter); 01009 #endif 01010 01011 private: 01012 01013 const XalanDecimalFormatSymbols* 01014 getDecimalFormatSymbols(const XalanQName& qname); 01015 01016 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01017 /** 01018 * Given a context, create the params for a template 01019 * call. 01020 * 01021 * @param xslCallTemplateElement "call-template" element 01022 * @param params The params 01023 */ 01024 void 01025 getParams( 01026 const ElemTemplateElement& xslCallTemplateElement, 01027 ParamsVectorType& params); 01028 #endif 01029 01030 /** 01031 * Determine if the XPath is one that we have cached. 01032 * 01033 * @param theXPath the XPath instance to check 01034 * @return true if the instance has been cached, false if not. 01035 */ 01036 bool 01037 isCached(const XPath* theXPath); 01038 01039 /** 01040 * Clear out the cache of XPath instances. 01041 */ 01042 void 01043 clearXPathCache(); 01044 01045 /** 01046 * Add an XPath instance to the cache, clearing out an old entry 01047 * if the cache is full. 01048 * 01049 * @param pattern the key for looking up the XPath instance in the cache. 01050 * @param theXPath the XPath instance to cache 01051 */ 01052 void 01053 addToXPathCache( 01054 const XalanDOMString& pattern, 01055 const XPath* theXPath); 01056 01057 01058 /** 01059 * Clean up anything that was created for use only during the transformation. 01060 */ 01061 void 01062 cleanUpTransients(); 01063 01064 XPathExecutionContextDefault m_xpathExecutionContextDefault; 01065 01066 XSLTEngineImpl* m_xsltProcessor; 01067 01068 XalanNode* m_rootDocument; 01069 01070 enum { eXPathCacheMax = 50, 01071 eDefaultParamsVectorSize = 10, 01072 eXResultTreeFragAllocatorBlockSize = 10, 01073 eDocumentAllocatorBlockSize = 10, 01074 eDocumentFragmentAllocatorBlockSize = 10, 01075 eDefaultAttributeAllocatorBlockSize = 10, 01076 eDefaultAttributeNSAllocatorBlockSize = 10, 01077 eDefaultCommentAllocatorBlockSize = 10, 01078 eDefaultElementAllocatorBlockSize = 10, 01079 eDefaultElementNSAllocatorBlockSize = 10, 01080 eDefaultPIAllocatorBlockSize = 10, 01081 eDefaultTextAllocatorBlockSize = 20, 01082 eDefaultTextIWSAllocatorBlockSize = 20 }; 01083 01084 ElementTemplateElementStackType m_elementRecursionStack; 01085 01086 const StylesheetRoot* m_stylesheetRoot; 01087 01088 FormatterListenerVectorType m_formatterListeners; 01089 01090 PrintWriterVectorType m_printWriters; 01091 01092 OutputStreamVectorType m_outputStreams; 01093 01094 CollationCompareFunctor* m_collationCompareFunctor; 01095 01096 FormatNumberFunctor * m_formatNumberFunctor; 01097 01098 /** 01099 * Holds all information about variables during execution. 01100 */ 01101 VariablesStack m_variablesStack; 01102 01103 ParamsVectorType m_paramsVector; 01104 01105 XPathCacheMapType m_matchPatternCache; 01106 01107 KeyTablesTableType m_keyTables; 01108 01109 CountersTable m_countersTable; 01110 01111 /** 01112 * The factory that will be used to create result tree fragments based on our 01113 * internal source tree. 01114 */ 01115 mutable XalanMemMgrAutoPtr<XalanSourceTreeDocument> m_sourceTreeResultTreeFactory; 01116 01117 // Holds the current mode. 01118 const XalanQName* m_mode; 01119 01120 CurrentTemplateStackType m_currentTemplateStack; 01121 01122 int m_indentAmount; 01123 01124 XResultTreeFragAllocator m_xresultTreeFragAllocator; 01125 01126 XalanSourceTreeDocumentFragmentAllocator m_documentFragmentAllocator; 01127 01128 XalanSourceTreeDocumentAllocator m_documentAllocator; 01129 01130 typedef XalanVector<bool> BooleanStackType; 01131 typedef XalanVector<const XalanQName*> ModeStackType; 01132 typedef XalanVector<int> IntStackType; 01133 01134 BooleanStackType m_copyTextNodesOnlyStack; 01135 ModeStackType m_modeStack; 01136 IntStackType m_currentIndexStack; 01137 01138 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01139 typedef XalanMemoryManagerObjectCacheDefault<FormatterToText> FormatterToTextCacheType; 01140 typedef XalanMemoryManagerObjectCacheDefault<FormatterToSourceTree> FormatterToSourceTreeCacheType; 01141 typedef XalanMemoryManagerObjectCacheDefault<NodeSorter> NodeSorterCacheType; 01142 01143 FormatterToTextCacheType m_formatterToTextCache; 01144 01145 FormatterToSourceTreeCacheType m_formatterToSourceTreeCache; 01146 01147 NodeSorterCacheType m_nodeSorterCache; 01148 #else 01149 01150 class FormatterToTextDOMString : public FormatterToText 01151 { 01152 public: 01153 01154 FormatterToTextDOMString(MemoryManager& theManager); 01155 01156 virtual 01157 ~FormatterToTextDOMString(); 01158 01159 void 01160 setDOMString(XalanDOMString& theString) 01161 { 01162 m_printWriter.setString(theString); 01163 } 01164 01165 private: 01166 01167 // These are not defined... 01168 FormatterToTextDOMString(const FormatterToTextDOMString&); 01169 01170 FormatterToTextDOMString& 01171 operator=(const FormatterToTextDOMString&); 01172 01173 bool 01174 operator==(const FormatterToTextDOMString&) const; 01175 01176 01177 // Data members... 01178 DOMStringPrintWriter m_printWriter; 01179 01180 static XalanDOMString s_dummyString; 01181 }; 01182 01183 typedef XalanVector<XObjectPtr> XObjectPtrStackType; 01184 typedef XalanVector<ParamsVectorType> ParamsVectorStackType; 01185 typedef XalanVector<UseAttributeSetIndexes> UseAttributeSetIndexesStackType; 01186 typedef XalanObjectStackCache<MutableNodeRefList,DefaultCacheCreateFunctorMemMgr<MutableNodeRefList> > 01187 MutableNodeRefListStackType; 01188 01189 typedef XalanObjectStackCache<XalanDOMString,DefaultCacheCreateFunctorMemMgr<XalanDOMString> > 01190 StringStackType; 01191 01192 typedef XalanObjectStackCache<FormatterToTextDOMString,DefaultCacheCreateFunctorMemMgr<FormatterToTextDOMString> > 01193 FormatterToTextStackType; 01194 typedef XalanObjectStackCache<FormatterToSourceTree,DefaultCacheCreateFunctorMemMgr<FormatterToSourceTree> > 01195 FormatterToSourceTreeStackType; 01196 01197 /* 01198 * class to maintain the list of nodes to be transformed by an element 01199 */ 01200 class NodesToTransform 01201 { 01202 public: 01203 NodesToTransform(const NodeRefListBase* nodeList) : 01204 m_nodeList(nodeList), m_index(0) 01205 { 01206 assert(m_nodeList != 0); 01207 } 01208 01209 const NodeRefListBase* operator() () 01210 { 01211 return m_nodeList; 01212 } 01213 01214 NodeRefListBase::size_type& index() 01215 { 01216 return m_index; 01217 } 01218 01219 XalanNode* next() 01220 { 01221 if (m_index < m_nodeList->getLength()) 01222 { 01223 return m_nodeList->item(m_index++); 01224 } 01225 return 0; 01226 } 01227 01228 private: 01229 const NodeRefListBase* m_nodeList; 01230 NodeRefListBase::size_type m_index; 01231 }; 01232 01233 typedef XalanVector<NodesToTransform> NodesToTransformStackType; 01234 01235 XObjectPtrStackType m_xobjectPtrStack; 01236 MutableNodeRefListStackType m_mutableNodeRefListStack; 01237 NodesToTransformStackType m_nodesToTransformStack; 01238 BooleanStackType m_processCurrentAttributeStack; 01239 BooleanStackType m_executeIfStack; 01240 StringStackType m_stringStack; 01241 FormatterToTextStackType m_formatterToTextStack; 01242 BooleanStackType m_skipElementAttributesStack; 01243 FormatterToSourceTreeStackType m_formatterToSourceTreeStack; 01244 ParamsVectorStackType m_paramsVectorStack; 01245 ElementTemplateElementStackType m_elementInvokerStack; 01246 UseAttributeSetIndexesStackType m_useAttributeSetIndexesStack; 01247 01248 NodeSorter m_nodeSorter; 01249 #endif 01250 01251 // If true, we will use a separate document factory for 01252 // result tree fragments. 01253 bool m_usePerInstanceDocumentFactory; 01254 01255 // Determines whether or not to override the property in the stylesheet. 01256 eEscapeURLs m_escapeURLs; 01257 01258 // Determines whether or not to override the property in the stylesheet. 01259 eOmitMETATag m_omitMETATag; 01260 01261 static XalanNumberFormatFactory s_defaultXalanNumberFormatFactory; 01262 01263 static XalanNumberFormatFactory* s_xalanNumberFormatFactory; 01264 01265 static const DefaultCollationCompareFunctor s_defaultCollationFunctor; 01266 }; 01267 01268 01269 01270 XALAN_CPP_NAMESPACE_END 01271 01272 01273 01274 #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.11 |
|