示例#1
0
  /** Reset for new run. */
  public void reset() {
    releaseDTMXRTreeFrags();
    // These couldn't be disposed of earlier (see comments in release()); zap them now.
    if (m_rtfdtm_stack != null)
      for (java.util.Enumeration e = m_rtfdtm_stack.elements(); e.hasMoreElements(); )
        m_dtmManager.release((DTM) e.nextElement(), true);

    m_rtfdtm_stack = null; // drop our references too
    m_which_rtfdtm = -1;

    if (m_global_rtfdtm != null) m_dtmManager.release(m_global_rtfdtm, true);
    m_global_rtfdtm = null;

    m_dtmManager =
        DTMManager.newInstance(org.apache.xpath.objects.XMLStringFactoryImpl.getFactory());

    m_saxLocations.removeAllElements();
    m_axesIteratorStack.removeAllElements();
    m_contextNodeLists.removeAllElements();
    m_currentExpressionNodes.removeAllElements();
    m_currentNodes.removeAllElements();
    m_iteratorRoots.RemoveAllNoClear();
    m_predicatePos.removeAllElements();
    m_predicateRoots.RemoveAllNoClear();
    m_prefixResolvers.removeAllElements();

    m_prefixResolvers.push(null);
    m_currentNodes.push(DTM.NULL);
    m_currentExpressionNodes.push(DTM.NULL);
    m_saxLocations.push(null);
  }
示例#2
0
/**
 * Default class for the runtime execution context for XPath.
 *
 * <p>This class extends DTMManager but does not directly implement it.
 *
 * @xsl.usage advanced
 */
public class XPathContext extends DTMManager // implements ExpressionContext
{
  IntStack m_last_pushed_rtfdtm = new IntStack();
  /**
   * Stack of cached "reusable" DTMs for Result Tree Fragments. This is a kluge to handle the
   * problem of starting an RTF before the old one is complete.
   *
   * <p>%REVIEW% I'm using a Vector rather than Stack so we can reuse the DTMs if the problem occurs
   * multiple times. I'm not sure that's really a net win versus discarding the DTM and starting a
   * new one... but the retained RTF DTM will have been tail-pruned so should be small.
   */
  private Vector m_rtfdtm_stack = null;
  /** Index of currently active RTF DTM in m_rtfdtm_stack */
  private int m_which_rtfdtm = -1;

  /**
   * Most recent "reusable" DTM for Global Result Tree Fragments. No stack is required since we're
   * never going to pop these.
   */
  private SAX2RTFDTM m_global_rtfdtm = null;

  /**
   * HashMap of cached the DTMXRTreeFrag objects, which are identified by DTM IDs. The object are
   * just wrappers for DTMs which are used in XRTreeFrag.
   */
  private HashMap m_DTMXRTreeFrags = null;

  /** state of the secure processing feature. */
  private boolean m_isSecureProcessing = false;

  /**
   * Though XPathContext context extends the DTMManager, it really is a proxy for this object, which
   * is the real DTMManager.
   */
  protected DTMManager m_dtmManager =
      DTMManager.newInstance(org.apache.xpath.objects.XMLStringFactoryImpl.getFactory());

  /**
   * Return the DTMManager object. Though XPathContext context extends the DTMManager, it really is
   * a proxy for the real DTMManager. If a caller needs to make a lot of calls to the DTMManager, it
   * is faster if it gets the real one from this function.
   */
  public DTMManager getDTMManager() {
    return m_dtmManager;
  }

  /** Set the state of the secure processing feature */
  public void setSecureProcessing(boolean flag) {
    m_isSecureProcessing = flag;
  }

  /** Return the state of the secure processing feature */
  public boolean isSecureProcessing() {
    return m_isSecureProcessing;
  }

  /**
   * Get an instance of a DTM, loaded with the content from the specified source. If the unique flag
   * is true, a new instance will always be returned. Otherwise it is up to the DTMManager to return
   * a new instance or an instance that it already created and may be being used by someone else. (I
   * think more parameters will need to be added for error handling, and entity resolution).
   *
   * @param source the specification of the source object, which may be null, in which case it is
   *     assumed that node construction will take by some other means.
   * @param unique true if the returned DTM must be unique, probably because it is going to be
   *     mutated.
   * @param wsfilter Enables filtering of whitespace nodes, and may be null.
   * @param incremental true if the construction should try and be incremental.
   * @param doIndexing true if the caller considers it worth it to use indexing schemes.
   * @return a non-null DTM reference.
   */
  public DTM getDTM(
      javax.xml.transform.Source source,
      boolean unique,
      DTMWSFilter wsfilter,
      boolean incremental,
      boolean doIndexing) {
    return m_dtmManager.getDTM(source, unique, wsfilter, incremental, doIndexing);
  }

  /**
   * Get an instance of a DTM that "owns" a node handle.
   *
   * @param nodeHandle the nodeHandle.
   * @return a non-null DTM reference.
   */
  public DTM getDTM(int nodeHandle) {
    return m_dtmManager.getDTM(nodeHandle);
  }

  /**
   * Given a W3C DOM node, try and return a DTM handle. Note: calling this may be non-optimal.
   *
   * @param node Non-null reference to a DOM node.
   * @return a valid DTM handle.
   */
  public int getDTMHandleFromNode(org.w3c.dom.Node node) {
    return m_dtmManager.getDTMHandleFromNode(node);
  }
  //
  //
  /** %TBD% Doc */
  public int getDTMIdentity(DTM dtm) {
    return m_dtmManager.getDTMIdentity(dtm);
  }
  //
  /**
   * Creates an empty <code>DocumentFragment</code> object.
   *
   * @return A new <code>DocumentFragment handle</code>.
   */
  public DTM createDocumentFragment() {
    return m_dtmManager.createDocumentFragment();
  }
  //
  /**
   * Release a DTM either to a lru pool, or completely remove reference. DTMs without system IDs are
   * always hard deleted. State: experimental.
   *
   * @param dtm The DTM to be released.
   * @param shouldHardDelete True if the DTM should be removed no matter what.
   * @return true if the DTM was removed, false if it was put back in a lru pool.
   */
  public boolean release(DTM dtm, boolean shouldHardDelete) {
    // %REVIEW% If it's a DTM which may contain multiple Result Tree
    // Fragments, we can't discard it unless we know not only that it
    // is empty, but that the XPathContext itself is going away. So do
    // _not_ accept the request. (May want to do it as part of
    // reset(), though.)
    if (m_rtfdtm_stack != null && m_rtfdtm_stack.contains(dtm)) {
      return false;
    }

    return m_dtmManager.release(dtm, shouldHardDelete);
  }

  /**
   * Create a new <code>DTMIterator</code> based on an XPath <a
   * href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or a <a
   * href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
   *
   * @param xpathCompiler ??? Somehow we need to pass in a subpart of the expression. I hate to do
   *     this with strings, since the larger expression has already been parsed.
   * @param pos The position in the expression.
   * @return The newly created <code>DTMIterator</code>.
   */
  public DTMIterator createDTMIterator(Object xpathCompiler, int pos) {
    return m_dtmManager.createDTMIterator(xpathCompiler, pos);
  }
  //
  /**
   * Create a new <code>DTMIterator</code> based on an XPath <a
   * href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or a <a
   * href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
   *
   * @param xpathString Must be a valid string expressing a <a
   *     href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or a <a
   *     href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
   * @param presolver An object that can resolve prefixes to namespace URLs.
   * @return The newly created <code>DTMIterator</code>.
   */
  public DTMIterator createDTMIterator(String xpathString, PrefixResolver presolver) {
    return m_dtmManager.createDTMIterator(xpathString, presolver);
  }
  //
  /**
   * Create a new <code>DTMIterator</code> based only on a whatToShow and a DTMFilter. The traversal
   * semantics are defined as the descendant access.
   *
   * @param whatToShow This flag specifies which node types may appear in the logical view of the
   *     tree presented by the iterator. See the description of <code>NodeFilter</code> for the set
   *     of possible <code>SHOW_</code> values.These flags can be combined using <code>OR</code>.
   * @param filter The <code>NodeFilter</code> to be used with this <code>TreeWalker</code>, or
   *     <code>null</code> to indicate no filter.
   * @param entityReferenceExpansion The value of this flag determines whether entity reference
   *     nodes are expanded.
   * @return The newly created <code>NodeIterator</code>.
   */
  public DTMIterator createDTMIterator(
      int whatToShow, DTMFilter filter, boolean entityReferenceExpansion) {
    return m_dtmManager.createDTMIterator(whatToShow, filter, entityReferenceExpansion);
  }

  /**
   * Create a new <code>DTMIterator</code> that holds exactly one node.
   *
   * @param node The node handle that the DTMIterator will iterate to.
   * @return The newly created <code>DTMIterator</code>.
   */
  public DTMIterator createDTMIterator(int node) {
    // DescendantIterator iter = new DescendantIterator();
    DTMIterator iter = new org.apache.xpath.axes.OneStepIteratorForward(Axis.SELF);
    iter.setRoot(node, this);
    return iter;
    // return m_dtmManager.createDTMIterator(node);
  }

  /**
   * Create an XPathContext instance. This is equivalent to calling the {@link
   * #XPathContext(boolean)} constructor with the value <code>true</code>.
   */
  public XPathContext() {
    this(true);
  }

  /**
   * Create an XPathContext instance.
   *
   * @param recursiveVarContext A <code>boolean</code> value indicating whether the XPath context
   *     needs to support pushing of scopes for variable resolution
   */
  public XPathContext(boolean recursiveVarContext) {
    m_prefixResolvers.push(null);
    m_currentNodes.push(DTM.NULL);
    m_currentExpressionNodes.push(DTM.NULL);
    m_saxLocations.push(null);
    m_variableStacks = recursiveVarContext ? new VariableStack() : new VariableStack(1);
  }

  /**
   * Create an XPathContext instance. This is equivalent to calling the constructor {@link
   * #XPathContext(java.lang.Object,boolean)} with the value of the second parameter set to <code>
   * true</code>.
   *
   * @param owner Value that can be retrieved via the getOwnerObject() method.
   * @see #getOwnerObject
   */
  public XPathContext(Object owner) {
    this(owner, true);
  }

  /**
   * Create an XPathContext instance.
   *
   * @param owner Value that can be retrieved via the getOwnerObject() method.
   * @see #getOwnerObject
   * @param recursiveVarContext A <code>boolean</code> value indicating whether the XPath context
   *     needs to support pushing of scopes for variable resolution
   */
  public XPathContext(Object owner, boolean recursiveVarContext) {
    this(recursiveVarContext);
    m_owner = owner;
    try {
      m_ownerGetErrorListener = m_owner.getClass().getMethod("getErrorListener", new Class[] {});
    } catch (NoSuchMethodException nsme) {
    }
  }

  /** Reset for new run. */
  public void reset() {
    releaseDTMXRTreeFrags();
    // These couldn't be disposed of earlier (see comments in release()); zap them now.
    if (m_rtfdtm_stack != null)
      for (java.util.Enumeration e = m_rtfdtm_stack.elements(); e.hasMoreElements(); )
        m_dtmManager.release((DTM) e.nextElement(), true);

    m_rtfdtm_stack = null; // drop our references too
    m_which_rtfdtm = -1;

    if (m_global_rtfdtm != null) m_dtmManager.release(m_global_rtfdtm, true);
    m_global_rtfdtm = null;

    m_dtmManager =
        DTMManager.newInstance(org.apache.xpath.objects.XMLStringFactoryImpl.getFactory());

    m_saxLocations.removeAllElements();
    m_axesIteratorStack.removeAllElements();
    m_contextNodeLists.removeAllElements();
    m_currentExpressionNodes.removeAllElements();
    m_currentNodes.removeAllElements();
    m_iteratorRoots.RemoveAllNoClear();
    m_predicatePos.removeAllElements();
    m_predicateRoots.RemoveAllNoClear();
    m_prefixResolvers.removeAllElements();

    m_prefixResolvers.push(null);
    m_currentNodes.push(DTM.NULL);
    m_currentExpressionNodes.push(DTM.NULL);
    m_saxLocations.push(null);
  }

  /** The current stylesheet locator. */
  ObjectStack m_saxLocations = new ObjectStack(RECURSIONLIMIT);

  /**
   * Set the current locater in the stylesheet.
   *
   * @param location The location within the stylesheet.
   */
  public void setSAXLocator(SourceLocator location) {
    m_saxLocations.setTop(location);
  }

  /**
   * Set the current locater in the stylesheet.
   *
   * @param location The location within the stylesheet.
   */
  public void pushSAXLocator(SourceLocator location) {
    m_saxLocations.push(location);
  }

  /** Push a slot on the locations stack so that setSAXLocator can be repeatedly called. */
  public void pushSAXLocatorNull() {
    m_saxLocations.push(null);
  }

  /** Pop the current locater. */
  public void popSAXLocator() {
    m_saxLocations.pop();
  }

  /**
   * Get the current locater in the stylesheet.
   *
   * @return The location within the stylesheet, or null if not known.
   */
  public SourceLocator getSAXLocator() {
    return (SourceLocator) m_saxLocations.peek();
  }

  /**
   * The owner context of this XPathContext. In the case of XSLT, this will be a Transformer object.
   */
  private Object m_owner;

  /**
   * The owner context of this XPathContext. In the case of XSLT, this will be a Transformer object.
   */
  private Method m_ownerGetErrorListener;

  /**
   * Get the "owner" context of this context, which should be, in the case of XSLT, the Transformer
   * object. This is needed so that XSLT functions can get the Transformer.
   *
   * @return The owner object passed into the constructor, or null.
   */
  public Object getOwnerObject() {
    return m_owner;
  }

  // ================ VarStack ===================

  /**
   * The stack of Variable stacks. A VariableStack will be pushed onto this stack for each template
   * invocation.
   */
  private VariableStack m_variableStacks;

  /**
   * Get the variable stack, which is in charge of variables and parameters.
   *
   * @return the variable stack, which should not be null.
   */
  public final VariableStack getVarStack() {
    return m_variableStacks;
  }

  /**
   * Get the variable stack, which is in charge of variables and parameters.
   *
   * @param varStack non-null reference to the variable stack.
   */
  public final void setVarStack(VariableStack varStack) {
    m_variableStacks = varStack;
  }

  // ================ SourceTreeManager ===================

  /** The source tree manager, which associates Source objects to source tree nodes. */
  private SourceTreeManager m_sourceTreeManager = new SourceTreeManager();

  /**
   * Get the SourceTreeManager associated with this execution context.
   *
   * @return the SourceTreeManager associated with this execution context.
   */
  public final SourceTreeManager getSourceTreeManager() {
    return m_sourceTreeManager;
  }

  /**
   * Set the SourceTreeManager associated with this execution context.
   *
   * @param mgr the SourceTreeManager to be associated with this execution context.
   */
  public void setSourceTreeManager(SourceTreeManager mgr) {
    m_sourceTreeManager = mgr;
  }

  // =================================================

  /** The ErrorListener where errors and warnings are to be reported. */
  private ErrorListener m_errorListener;

  /**
   * A default ErrorListener in case our m_errorListener was not specified and our owner either does
   * not have an ErrorListener or has a null one.
   */
  private ErrorListener m_defaultErrorListener;

  /**
   * Get the ErrorListener where errors and warnings are to be reported.
   *
   * @return A non-null ErrorListener reference.
   */
  public final ErrorListener getErrorListener() {

    if (null != m_errorListener) return m_errorListener;

    ErrorListener retval = null;

    try {
      if (null != m_ownerGetErrorListener)
        retval = (ErrorListener) m_ownerGetErrorListener.invoke(m_owner, new Object[] {});
    } catch (Exception e) {
    }

    if (null == retval) {
      if (null == m_defaultErrorListener)
        m_defaultErrorListener = new org.apache.xml.utils.DefaultErrorHandler();
      retval = m_defaultErrorListener;
    }

    return retval;
  }

  /**
   * Set the ErrorListener where errors and warnings are to be reported.
   *
   * @param listener A non-null ErrorListener reference.
   */
  public void setErrorListener(ErrorListener listener) throws IllegalArgumentException {
    if (listener == null)
      throw new IllegalArgumentException(
          XSLMessages.createXPATHMessage(
              XPATHErrorResources.ER_NULL_ERROR_HANDLER, null)); // "Null error handler");
    m_errorListener = listener;
  }

  // =================================================

  /**
   * The TrAX URI Resolver for resolving URIs from the document(...) function to source tree nodes.
   */
  private URIResolver m_uriResolver;

  /**
   * Get the URIResolver associated with this execution context.
   *
   * @return a URI resolver, which may be null.
   */
  public final URIResolver getURIResolver() {
    return m_uriResolver;
  }

  /**
   * Set the URIResolver associated with this execution context.
   *
   * @param resolver the URIResolver to be associated with this execution context, may be null to
   *     clear an already set resolver.
   */
  public void setURIResolver(URIResolver resolver) {
    m_uriResolver = resolver;
  }

  // =================================================

  /** The reader of the primary source tree. */
  public XMLReader m_primaryReader;

  /**
   * Get primary XMLReader associated with this execution context.
   *
   * @return The reader of the primary source tree.
   */
  public final XMLReader getPrimaryReader() {
    return m_primaryReader;
  }

  /**
   * Set primary XMLReader associated with this execution context.
   *
   * @param reader The reader of the primary source tree.
   */
  public void setPrimaryReader(XMLReader reader) {
    m_primaryReader = reader;
  }

  // =================================================

  /** Misnamed string manager for XPath messages. */
  // private static XSLMessages m_XSLMessages = new XSLMessages();

  /**
   * Tell the user of an assertion error, and probably throw an exception.
   *
   * @param b If false, a TransformerException will be thrown.
   * @param msg The assertion message, which should be informative.
   * @throws javax.xml.transform.TransformerException if b is false.
   */
  private void assertion(boolean b, String msg) throws javax.xml.transform.TransformerException {
    if (!b) {
      ErrorListener errorHandler = getErrorListener();

      if (errorHandler != null) {
        errorHandler.fatalError(
            new TransformerException(
                XSLMessages.createMessage(
                    XPATHErrorResources.ER_INCORRECT_PROGRAMMER_ASSERTION, new Object[] {msg}),
                (SAXSourceLocator) this.getSAXLocator()));
      }
    }
  }

  // ==========================================================
  // SECTION: Execution context state tracking
  // ==========================================================

  /** The current context node list. */
  private Stack m_contextNodeLists = new Stack();

  public Stack getContextNodeListsStack() {
    return m_contextNodeLists;
  }

  public void setContextNodeListsStack(Stack s) {
    m_contextNodeLists = s;
  }

  /**
   * Get the current context node list.
   *
   * @return the <a href="http://www.w3.org/TR/xslt#dt-current-node-list">current node list</a>,
   *     also refered to here as a <term>context node list</term>.
   */
  public final DTMIterator getContextNodeList() {

    if (m_contextNodeLists.size() > 0) return (DTMIterator) m_contextNodeLists.peek();
    else return null;
  }

  /**
   * Set the current context node list.
   *
   * @param nl the <a href="http://www.w3.org/TR/xslt#dt-current-node-list">current node list</a>,
   *     also refered to here as a <term>context node list</term>.
   * @xsl.usage internal
   */
  public final void pushContextNodeList(DTMIterator nl) {
    m_contextNodeLists.push(nl);
  }

  /**
   * Pop the current context node list.
   *
   * @xsl.usage internal
   */
  public final void popContextNodeList() {
    if (m_contextNodeLists.isEmpty())
      System.err.println("Warning: popContextNodeList when stack is empty!");
    else m_contextNodeLists.pop();
  }

  /** The ammount to use for stacks that record information during the recursive execution. */
  public static final int RECURSIONLIMIT = (1024 * 4);

  /**
   * The stack of <a href="http://www.w3.org/TR/xslt#dt-current-node">current node</a> objects. Not
   * to be confused with the current node list. %REVIEW% Note that there are no bounds check and
   * resize for this stack, so if it is blown, it's all over.
   */
  private IntStack m_currentNodes = new IntStack(RECURSIONLIMIT);

  //  private NodeVector m_currentNodes = new NodeVector();

  public IntStack getCurrentNodeStack() {
    return m_currentNodes;
  }

  public void setCurrentNodeStack(IntStack nv) {
    m_currentNodes = nv;
  }

  /**
   * Get the current context node.
   *
   * @return the <a href="http://www.w3.org/TR/xslt#dt-current-node">current node</a>.
   */
  public final int getCurrentNode() {
    return m_currentNodes.peek();
  }

  /**
   * Set the current context node and expression node.
   *
   * @param cn the <a href="http://www.w3.org/TR/xslt#dt-current-node">current node</a>.
   * @param en the sub-expression context node.
   */
  public final void pushCurrentNodeAndExpression(int cn, int en) {
    m_currentNodes.push(cn);
    m_currentExpressionNodes.push(cn);
  }

  /** Set the current context node. */
  public final void popCurrentNodeAndExpression() {
    m_currentNodes.quickPop(1);
    m_currentExpressionNodes.quickPop(1);
  }

  /**
   * Push the current context node, expression node, and prefix resolver.
   *
   * @param cn the <a href="http://www.w3.org/TR/xslt#dt-current-node">current node</a>.
   * @param en the sub-expression context node.
   * @param nc the namespace context (prefix resolver.
   */
  public final void pushExpressionState(int cn, int en, PrefixResolver nc) {
    m_currentNodes.push(cn);
    m_currentExpressionNodes.push(cn);
    m_prefixResolvers.push(nc);
  }

  /** Pop the current context node, expression node, and prefix resolver. */
  public final void popExpressionState() {
    m_currentNodes.quickPop(1);
    m_currentExpressionNodes.quickPop(1);
    m_prefixResolvers.pop();
  }

  /**
   * Set the current context node.
   *
   * @param n the <a href="http://www.w3.org/TR/xslt#dt-current-node">current node</a>.
   */
  public final void pushCurrentNode(int n) {
    m_currentNodes.push(n);
  }

  /** Pop the current context node. */
  public final void popCurrentNode() {
    m_currentNodes.quickPop(1);
  }

  /** Set the current predicate root. */
  public final void pushPredicateRoot(int n) {
    m_predicateRoots.push(n);
  }

  /** Pop the current predicate root. */
  public final void popPredicateRoot() {
    m_predicateRoots.popQuick();
  }

  /** Get the current predicate root. */
  public final int getPredicateRoot() {
    return m_predicateRoots.peepOrNull();
  }

  /** Set the current location path iterator root. */
  public final void pushIteratorRoot(int n) {
    m_iteratorRoots.push(n);
  }

  /** Pop the current location path iterator root. */
  public final void popIteratorRoot() {
    m_iteratorRoots.popQuick();
  }

  /** Get the current location path iterator root. */
  public final int getIteratorRoot() {
    return m_iteratorRoots.peepOrNull();
  }

  /** A stack of the current sub-expression nodes. */
  private NodeVector m_iteratorRoots = new NodeVector();

  /** A stack of the current sub-expression nodes. */
  private NodeVector m_predicateRoots = new NodeVector();

  /** A stack of the current sub-expression nodes. */
  private IntStack m_currentExpressionNodes = new IntStack(RECURSIONLIMIT);

  public IntStack getCurrentExpressionNodeStack() {
    return m_currentExpressionNodes;
  }

  public void setCurrentExpressionNodeStack(IntStack nv) {
    m_currentExpressionNodes = nv;
  }

  private IntStack m_predicatePos = new IntStack();

  public final int getPredicatePos() {
    return m_predicatePos.peek();
  }

  public final void pushPredicatePos(int n) {
    m_predicatePos.push(n);
  }

  public final void popPredicatePos() {
    m_predicatePos.pop();
  }

  /**
   * Get the current node that is the expression's context (i.e. for current() support).
   *
   * @return The current sub-expression node.
   */
  public final int getCurrentExpressionNode() {
    return m_currentExpressionNodes.peek();
  }

  /**
   * Set the current node that is the expression's context (i.e. for current() support).
   *
   * @param n The sub-expression node to be current.
   */
  public final void pushCurrentExpressionNode(int n) {
    m_currentExpressionNodes.push(n);
  }

  /** Pop the current node that is the expression's context (i.e. for current() support). */
  public final void popCurrentExpressionNode() {
    m_currentExpressionNodes.quickPop(1);
  }

  private ObjectStack m_prefixResolvers = new ObjectStack(RECURSIONLIMIT);

  /**
   * Get the current namespace context for the xpath.
   *
   * @return the current prefix resolver for resolving prefixes to namespace URLs.
   */
  public final PrefixResolver getNamespaceContext() {
    return (PrefixResolver) m_prefixResolvers.peek();
  }

  /**
   * Get the current namespace context for the xpath.
   *
   * @param pr the prefix resolver to be used for resolving prefixes to namespace URLs.
   */
  public final void setNamespaceContext(PrefixResolver pr) {
    m_prefixResolvers.setTop(pr);
  }

  /**
   * Push a current namespace context for the xpath.
   *
   * @param pr the prefix resolver to be used for resolving prefixes to namespace URLs.
   */
  public final void pushNamespaceContext(PrefixResolver pr) {
    m_prefixResolvers.push(pr);
  }

  /**
   * Just increment the namespace contest stack, so that setNamespaceContext can be used on the
   * slot.
   */
  public final void pushNamespaceContextNull() {
    m_prefixResolvers.push(null);
  }

  /** Pop the current namespace context for the xpath. */
  public final void popNamespaceContext() {
    m_prefixResolvers.pop();
  }

  // ==========================================================
  // SECTION: Current TreeWalker contexts (for internal use)
  // ==========================================================

  /** Stack of AxesIterators. */
  private Stack m_axesIteratorStack = new Stack();

  public Stack getAxesIteratorStackStacks() {
    return m_axesIteratorStack;
  }

  public void setAxesIteratorStackStacks(Stack s) {
    m_axesIteratorStack = s;
  }

  /**
   * Push a TreeWalker on the stack.
   *
   * @param iter A sub-context AxesWalker.
   * @xsl.usage internal
   */
  public final void pushSubContextList(SubContextList iter) {
    m_axesIteratorStack.push(iter);
  }

  /**
   * Pop the last pushed axes iterator.
   *
   * @xsl.usage internal
   */
  public final void popSubContextList() {
    m_axesIteratorStack.pop();
  }

  /**
   * Get the current axes iterator, or return null if none.
   *
   * @return the sub-context node list.
   * @xsl.usage internal
   */
  public SubContextList getSubContextList() {
    return m_axesIteratorStack.isEmpty() ? null : (SubContextList) m_axesIteratorStack.peek();
  }

  /**
   * Get the <a href="http://www.w3.org/TR/xslt#dt-current-node-list">current node list</a> as
   * defined by the XSLT spec.
   *
   * @return the <a href="http://www.w3.org/TR/xslt#dt-current-node-list">current node list</a>.
   * @xsl.usage internal
   */
  public org.apache.xpath.axes.SubContextList getCurrentNodeList() {
    return m_axesIteratorStack.isEmpty() ? null : (SubContextList) m_axesIteratorStack.elementAt(0);
  }
  // ==========================================================
  // SECTION: Implementation of ExpressionContext interface
  // ==========================================================

  /**
   * Get the current context node.
   *
   * @return The current context node.
   */
  public final int getContextNode() {
    return this.getCurrentNode();
  }

  /**
   * Get the current context node list.
   *
   * @return An iterator for the current context list, as defined in XSLT.
   */
  public final DTMIterator getContextNodes() {

    try {
      DTMIterator cnl = getContextNodeList();

      if (null != cnl) return cnl.cloneWithReset();
      else return null; // for now... this might ought to be an empty iterator.
    } catch (CloneNotSupportedException cnse) {
      return null; // error reporting?
    }
  }

  XPathExpressionContext expressionContext = new XPathExpressionContext();

  /**
   * The the expression context for extensions for this context.
   *
   * @return An object that implements the ExpressionContext.
   */
  public ExpressionContext getExpressionContext() {
    return expressionContext;
  }

  public class XPathExpressionContext implements ExpressionContext {
    /**
     * Return the XPathContext associated with this XPathExpressionContext. Extensions should use
     * this judiciously and only when special processing requirements cannot be met another way.
     * Consider requesting an enhancement to the ExpressionContext interface to avoid having to call
     * this method.
     *
     * @return the XPathContext associated with this XPathExpressionContext.
     */
    public XPathContext getXPathContext() {
      return XPathContext.this;
    }

    /**
     * Return the DTMManager object. Though XPathContext context extends the DTMManager, it really
     * is a proxy for the real DTMManager. If a caller needs to make a lot of calls to the
     * DTMManager, it is faster if it gets the real one from this function.
     */
    public DTMManager getDTMManager() {
      return m_dtmManager;
    }

    /**
     * Get the current context node.
     *
     * @return The current context node.
     */
    public org.w3c.dom.Node getContextNode() {
      int context = getCurrentNode();

      return getDTM(context).getNode(context);
    }

    /**
     * Get the current context node list.
     *
     * @return An iterator for the current context list, as defined in XSLT.
     */
    public org.w3c.dom.traversal.NodeIterator getContextNodes() {
      return new org.apache.xml.dtm.ref.DTMNodeIterator(getContextNodeList());
    }

    /**
     * Get the error listener.
     *
     * @return The registered error listener.
     */
    public ErrorListener getErrorListener() {
      return XPathContext.this.getErrorListener();
    }

    /**
     * Get the value of a node as a number.
     *
     * @param n Node to be converted to a number. May be null.
     * @return value of n as a number.
     */
    public double toNumber(org.w3c.dom.Node n) {
      // %REVIEW% You can't get much uglier than this...
      int nodeHandle = getDTMHandleFromNode(n);
      DTM dtm = getDTM(nodeHandle);
      XString xobj = (XString) dtm.getStringValue(nodeHandle);
      return xobj.num();
    }

    /**
     * Get the value of a node as a string.
     *
     * @param n Node to be converted to a string. May be null.
     * @return value of n as a string, or an empty string if n is null.
     */
    public String toString(org.w3c.dom.Node n) {
      // %REVIEW% You can't get much uglier than this...
      int nodeHandle = getDTMHandleFromNode(n);
      DTM dtm = getDTM(nodeHandle);
      XMLString strVal = dtm.getStringValue(nodeHandle);
      return strVal.toString();
    }

    /**
     * Get a variable based on it's qualified name.
     *
     * @param qname The qualified name of the variable.
     * @return The evaluated value of the variable.
     * @throws javax.xml.transform.TransformerException
     */
    public final XObject getVariableOrParam(org.apache.xml.utils.QName qname)
        throws javax.xml.transform.TransformerException {
      return m_variableStacks.getVariableOrParam(XPathContext.this, qname);
    }
  }

  /**
   * Get a DTM to be used as a container for a global Result Tree Fragment. This will always be an
   * instance of (derived from? equivalent to?) SAX2DTM, since each RTF is constructed by
   * temporarily redirecting our SAX output to it. It may be a single DTM containing for multiple
   * fragments, if the implementation supports that.
   *
   * <p>Note: The distinction between this method and getRTFDTM() is that the latter allocates space
   * from the dynamic variable stack (m_rtfdtm_stack), which may be pruned away again as the
   * templates which defined those variables are exited. Global variables may be bound late (see
   * XUnresolvedVariable), and never want to be discarded, hence we need to allocate them separately
   * and don't actually need a stack to track them.
   *
   * @return a non-null DTM reference.
   */
  public DTM getGlobalRTFDTM() {
    // We probably should _NOT_ be applying whitespace filtering at this stage!
    //
    // Some magic has been applied in DTMManagerDefault to recognize this set of options
    // and generate an instance of DTM which can contain multiple documents
    // (SAX2RTFDTM). Perhaps not the optimal way of achieving that result, but
    // I didn't want to change the manager API at this time, or expose
    // too many dependencies on its internals. (Ideally, I'd like to move
    // isTreeIncomplete all the way up to DTM, so we wouldn't need to explicitly
    // specify the subclass here.)

    // If it doesn't exist, or if the one already existing is in the middle of
    // being constructed, we need to obtain a new DTM to write into. I'm not sure
    // the latter will ever arise, but I'd rather be just a bit paranoid..
    if (m_global_rtfdtm == null || m_global_rtfdtm.isTreeIncomplete()) {
      m_global_rtfdtm = (SAX2RTFDTM) m_dtmManager.getDTM(null, true, null, false, false);
    }
    return m_global_rtfdtm;
  }

  /**
   * Get a DTM to be used as a container for a dynamic Result Tree Fragment. This will always be an
   * instance of (derived from? equivalent to?) SAX2DTM, since each RTF is constructed by
   * temporarily redirecting our SAX output to it. It may be a single DTM containing for multiple
   * fragments, if the implementation supports that.
   *
   * @return a non-null DTM reference.
   */
  public DTM getRTFDTM() {
    SAX2RTFDTM rtfdtm;

    // We probably should _NOT_ be applying whitespace filtering at this stage!
    //
    // Some magic has been applied in DTMManagerDefault to recognize this set of options
    // and generate an instance of DTM which can contain multiple documents
    // (SAX2RTFDTM). Perhaps not the optimal way of achieving that result, but
    // I didn't want to change the manager API at this time, or expose
    // too many dependencies on its internals. (Ideally, I'd like to move
    // isTreeIncomplete all the way up to DTM, so we wouldn't need to explicitly
    // specify the subclass here.)

    if (m_rtfdtm_stack == null) {
      m_rtfdtm_stack = new Vector();
      rtfdtm = (SAX2RTFDTM) m_dtmManager.getDTM(null, true, null, false, false);
      m_rtfdtm_stack.addElement(rtfdtm);
      ++m_which_rtfdtm;
    } else if (m_which_rtfdtm < 0) {
      rtfdtm = (SAX2RTFDTM) m_rtfdtm_stack.elementAt(++m_which_rtfdtm);
    } else {
      rtfdtm = (SAX2RTFDTM) m_rtfdtm_stack.elementAt(m_which_rtfdtm);

      // It might already be under construction -- the classic example would be
      // an xsl:variable which uses xsl:call-template as part of its value. To
      // handle this recursion, we have to start a new RTF DTM, pushing the old
      // one onto a stack so we can return to it. This is not as uncommon a case
      // as we might wish, unfortunately, as some folks insist on coding XSLT
      // as if it were a procedural language...
      if (rtfdtm.isTreeIncomplete()) {
        if (++m_which_rtfdtm < m_rtfdtm_stack.size())
          rtfdtm = (SAX2RTFDTM) m_rtfdtm_stack.elementAt(m_which_rtfdtm);
        else {
          rtfdtm = (SAX2RTFDTM) m_dtmManager.getDTM(null, true, null, false, false);
          m_rtfdtm_stack.addElement(rtfdtm);
        }
      }
    }

    return rtfdtm;
  }

  /**
   * Push the RTFDTM's context mark, to allows discarding RTFs added after this point. (If it
   * doesn't exist we don't push, since we might still be able to get away with not creating it.
   * That requires that excessive pops be harmless.)
   */
  public void pushRTFContext() {
    m_last_pushed_rtfdtm.push(m_which_rtfdtm);
    if (null != m_rtfdtm_stack) ((SAX2RTFDTM) (getRTFDTM())).pushRewindMark();
  }

  /**
   * Pop the RTFDTM's context mark. This discards any RTFs added after the last mark was set.
   *
   * <p>If there is no RTF DTM, there's nothing to pop so this becomes a no-op. If pushes were
   * issued before this was called, we count on the fact that popRewindMark is defined such that
   * overpopping just resets to empty.
   *
   * <p>Complicating factor: We need to handle the case of popping back to a previous RTF DTM, if
   * one of the weird produce-an-RTF-to-build-an-RTF cases arose. Basically: If pop says this DTM is
   * now empty, then return to the previous if one exists, in whatever state we left it in. UGLY,
   * but hopefully the situation which forces us to consider this will arise exceedingly rarely.
   */
  public void popRTFContext() {
    int previous = m_last_pushed_rtfdtm.pop();
    if (null == m_rtfdtm_stack) return;

    if (m_which_rtfdtm == previous) {
      if (previous >= 0) // guard against none-active
      {
        boolean isEmpty = ((SAX2RTFDTM) (m_rtfdtm_stack.elementAt(previous))).popRewindMark();
      }
    } else
      while (m_which_rtfdtm != previous) {
        // Empty each DTM before popping, so it's ready for reuse
        // _DON'T_ pop the previous, since it's still open (which is why we
        // stacked up more of these) and did not receive a mark.
        boolean isEmpty = ((SAX2RTFDTM) (m_rtfdtm_stack.elementAt(m_which_rtfdtm))).popRewindMark();
        --m_which_rtfdtm;
      }
  }

  /**
   * Gets DTMXRTreeFrag object if one has already been created. Creates new DTMXRTreeFrag object and
   * adds to m_DTMXRTreeFrags HashMap, otherwise.
   *
   * @param dtmIdentity
   * @return DTMXRTreeFrag
   */
  public DTMXRTreeFrag getDTMXRTreeFrag(int dtmIdentity) {
    if (m_DTMXRTreeFrags == null) {
      m_DTMXRTreeFrags = new HashMap();
    }

    if (m_DTMXRTreeFrags.containsKey(new Integer(dtmIdentity))) {
      return (DTMXRTreeFrag) m_DTMXRTreeFrags.get(new Integer(dtmIdentity));
    } else {
      final DTMXRTreeFrag frag = new DTMXRTreeFrag(dtmIdentity, this);
      m_DTMXRTreeFrags.put(new Integer(dtmIdentity), frag);
      return frag;
    }
  }

  /** Cleans DTMXRTreeFrag objects by removing references to DTM and XPathContext objects. */
  private final void releaseDTMXRTreeFrags() {
    if (m_DTMXRTreeFrags == null) {
      return;
    }
    final Iterator iter = (m_DTMXRTreeFrags.values()).iterator();
    while (iter.hasNext()) {
      DTMXRTreeFrag frag = (DTMXRTreeFrag) iter.next();
      frag.destruct();
      iter.remove();
    }
    m_DTMXRTreeFrags = null;
  }
}