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