/*

 * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.sun.org.apache.xpath.internal;

import com.sun.org.apache.xalan.internal.extensions.ExpressionContext;

import com.sun.org.apache.xalan.internal.res.XSLMessages;

import com.sun.org.apache.xml.internal.dtm.Axis;

import com.sun.org.apache.xml.internal.dtm.DTM;

import com.sun.org.apache.xml.internal.dtm.DTMFilter;

import com.sun.org.apache.xml.internal.dtm.DTMIterator;

import com.sun.org.apache.xml.internal.dtm.DTMManager;

import com.sun.org.apache.xml.internal.dtm.DTMWSFilter;

import com.sun.org.apache.xml.internal.dtm.ref.sax2dtm.SAX2RTFDTM;

import com.sun.org.apache.xml.internal.utils.IntStack;

import com.sun.org.apache.xml.internal.utils.NodeVector;

import com.sun.org.apache.xml.internal.utils.ObjectStack;

import com.sun.org.apache.xml.internal.utils.PrefixResolver;

import com.sun.org.apache.xml.internal.utils.XMLString;

import com.sun.org.apache.xpath.internal.axes.SubContextList;

import com.sun.org.apache.xpath.internal.objects.DTMXRTreeFrag;

import com.sun.org.apache.xpath.internal.objects.XObject;

import com.sun.org.apache.xpath.internal.objects.XString;

import com.sun.org.apache.xpath.internal.res.XPATHErrorResources;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Stack;

import javax.xml.transform.ErrorListener;

import javax.xml.transform.SourceLocator;

import javax.xml.transform.URIResolver;

import jdk.xml.internal.JdkXmlUtils;

import org.xml.sax.XMLReader;

/**

 * Default class for the runtime execution context for XPath.

 *

 * <p>This class extends DTMManager but does not directly implement it.</p>

 * @xsl.usage advanced

 * @LastModified: Oct 2017

 */

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.

   *

   * %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 List<DTM> 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 Map<Integer, DTMXRTreeFrag> m_DTMXRTreeFrags = null;

  /**

   * state of the secure processing feature.

   */

  private boolean m_isSecureProcessing = false;

  private boolean m_overrideDefaultParser;

  /**

   * Though XPathContext context extends

   * the DTMManager, it really is a proxy for this object, which

   * is the real DTMManager.

   */

  protected DTMManager m_dtmManager = null;

  /**

   * 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 com.sun.org.apache.xpath.internal.axes.OneStepIteratorForward(Axis.SELF);

    iter.setRoot(node, this);

    return iter;

    // return m_dtmManager.createDTMIterator(node);

  }

  /**

   * Create an XPathContext instance.

   */

  public XPathContext()

  {

    this(false);

  }

  public XPathContext(boolean overrideDefaultParser) {

      init(overrideDefaultParser);

  }

  /**

   **This constructor doesn't seem to be used anywhere -- huizhe wang**

   * Create an XPathContext instance.

   * @param owner Value that can be retrieved via the getOwnerObject() method.

   * @see #getOwnerObject

   */

  public XPathContext(Object owner)

  {

    m_owner = owner;

    try {

      m_ownerGetErrorListener = m_owner.getClass().getMethod("getErrorListener", new Class<?>[] {});

    }

    catch (NoSuchMethodException nsme) {}

    init(false);

  }

  private void init(boolean overrideDefaultParser) {

    m_prefixResolvers.push(null);

    m_currentNodes.push(DTM.NULL);

    m_currentExpressionNodes.push(DTM.NULL);

    m_saxLocations.push(null);

    m_overrideDefaultParser = overrideDefaultParser;

    m_dtmManager = DTMManager.newInstance(

                   com.sun.org.apache.xpath.internal.objects.XMLStringFactoryImpl.getFactory()

                   );

  }

  /**

   * 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 (DTM dtm : m_rtfdtm_stack) {

            m_dtmManager.release(dtm, 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(

                   com.sun.org.apache.xpath.internal.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 = new VariableStack();

  /**

   * 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;