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

   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xpath.internal.axes;
  22 
  23 import com.sun.org.apache.xml.internal.dtm.Axis;
  24 import com.sun.org.apache.xml.internal.dtm.DTM;
  25 import com.sun.org.apache.xml.internal.dtm.DTMAxisTraverser;
  26 import com.sun.org.apache.xml.internal.dtm.DTMIterator;
  27 import com.sun.org.apache.xpath.internal.XPathContext;
  28 import com.sun.org.apache.xpath.internal.compiler.Compiler;
  29 import com.sun.org.apache.xpath.internal.compiler.OpMap;
  30 import com.sun.org.apache.xpath.internal.objects.XObject;
  31 import com.sun.org.apache.xpath.internal.patterns.NodeTest;
  32 import com.sun.org.apache.xpath.internal.patterns.StepPattern;
  33 
  34 /**
  35  * This class treats a
  36  * <a href="http://www.w3.org/TR/xpath#location-paths">LocationPath</a> as a
  37  * filtered iteration over the tree, evaluating each node in a super axis
  38  * traversal against the LocationPath interpreted as a match pattern.  This
  39  * class is useful to find nodes in document order that are complex paths
  40  * whose steps probably criss-cross each other.
  41  *
  42  * @LastModified: Oct 2017
  43  */
  44 public class MatchPatternIterator extends LocPathIterator
  45 {
  46     static final long serialVersionUID = -5201153767396296474L;
  47 
  48   /** This is the select pattern, translated into a match pattern. */
  49   protected StepPattern m_pattern;
  50 
  51   /** The traversal axis from where the nodes will be filtered. */
  52   protected int m_superAxis = -1;
  53 
  54   /** The DTM inner traversal class, that corresponds to the super axis. */
  55   protected DTMAxisTraverser m_traverser;
  56 
  57   /** DEBUG flag for diagnostic dumps. */
  58   private static final boolean DEBUG = false;
  59 
  60 //  protected int m_nsElemBase = DTM.NULL;
  61 
  62   /**
  63    * Create a LocPathIterator object, including creation
  64    * of step walkers from the opcode list, and call back
  65    * into the Compiler to create predicate expressions.
  66    *
  67    * @param compiler The Compiler which is creating
  68    * this expression.
  69    * @param opPos The position of this iterator in the
  70    * opcode list from the compiler.
  71    * @param analysis Analysis bits that give general information about the
  72    * LocationPath.
  73    *
  74    * @throws javax.xml.transform.TransformerException
  75    */
  76   MatchPatternIterator(Compiler compiler, int opPos, int analysis)
  77           throws javax.xml.transform.TransformerException
  78   {
  79 
  80     super(compiler, opPos, analysis, false);
  81 
  82     int firstStepPos = OpMap.getFirstChildPos(opPos);
  83 
  84     m_pattern = WalkerFactory.loadSteps(this, compiler, firstStepPos, 0);
  85 
  86     boolean fromRoot = false;
  87     boolean walkBack = false;
  88     boolean walkDescendants = false;
  89     boolean walkAttributes = false;
  90 
  91     if (0 != (analysis & (WalkerFactory.BIT_ROOT |
  92                           WalkerFactory.BIT_ANY_DESCENDANT_FROM_ROOT)))
  93       fromRoot = true;
  94 
  95     if (0 != (analysis
  96               & (WalkerFactory.BIT_ANCESTOR
  97                  | WalkerFactory.BIT_ANCESTOR_OR_SELF
  98                  | WalkerFactory.BIT_PRECEDING
  99                  | WalkerFactory.BIT_PRECEDING_SIBLING
 100                  | WalkerFactory.BIT_FOLLOWING
 101                  | WalkerFactory.BIT_FOLLOWING_SIBLING
 102                  | WalkerFactory.BIT_PARENT | WalkerFactory.BIT_FILTER)))
 103       walkBack = true;
 104 
 105     if (0 != (analysis
 106               & (WalkerFactory.BIT_DESCENDANT_OR_SELF
 107                  | WalkerFactory.BIT_DESCENDANT
 108                  | WalkerFactory.BIT_CHILD)))
 109       walkDescendants = true;
 110 
 111     if (0 != (analysis
 112               & (WalkerFactory.BIT_ATTRIBUTE | WalkerFactory.BIT_NAMESPACE)))
 113       walkAttributes = true;
 114 
 115     if(false || DEBUG)
 116     {
 117       System.out.print("analysis: "+Integer.toBinaryString(analysis));
 118       System.out.println(", "+WalkerFactory.getAnalysisString(analysis));
 119     }
 120 
 121     if(fromRoot || walkBack)
 122     {
 123       if(walkAttributes)
 124       {
 125         m_superAxis = Axis.ALL;
 126       }
 127       else
 128       {
 129         m_superAxis = Axis.DESCENDANTSFROMROOT;
 130       }
 131     }
 132     else if(walkDescendants)
 133     {
 134       if(walkAttributes)
 135       {
 136         m_superAxis = Axis.ALLFROMNODE;
 137       }
 138       else
 139       {
 140         m_superAxis = Axis.DESCENDANTORSELF;
 141       }
 142     }
 143     else
 144     {
 145       m_superAxis = Axis.ALL;
 146     }
 147     if(false || DEBUG)
 148     {
 149       System.out.println("axis: "+Axis.getNames(m_superAxis));
 150     }
 151 
 152   }
 153 
 154 
 155   /**
 156    * Initialize the context values for this expression
 157    * after it is cloned.
 158    *
 159    * @param context The XPath runtime context for this
 160    * transformation.
 161    */
 162   public void setRoot(int context, Object environment)
 163   {
 164     super.setRoot(context, environment);
 165     m_traverser = m_cdtm.getAxisTraverser(m_superAxis);
 166   }
 167 
 168   /**
 169    *  Detaches the iterator from the set which it iterated over, releasing
 170    * any computational resources and placing the iterator in the INVALID
 171    * state. After<code>detach</code> has been invoked, calls to
 172    * <code>nextNode</code> or<code>previousNode</code> will raise the
 173    * exception INVALID_STATE_ERR.
 174    */
 175   public void detach()
 176   {
 177     if(m_allowDetach)
 178     {
 179       m_traverser = null;
 180 
 181       // Always call the superclass detach last!
 182       super.detach();
 183     }
 184   }
 185 
 186   /**
 187    * Get the next node via getNextXXX.  Bottlenecked for derived class override.
 188    * @return The next node on the axis, or DTM.NULL.
 189    */
 190   protected int getNextNode()
 191   {
 192     m_lastFetched = (DTM.NULL == m_lastFetched)
 193                      ? m_traverser.first(m_context)
 194                      : m_traverser.next(m_context, m_lastFetched);
 195     return m_lastFetched;
 196   }
 197 
 198   /**
 199    *  Returns the next node in the set and advances the position of the
 200    * iterator in the set. After a NodeIterator is created, the first call
 201    * to nextNode() returns the first node in the set.
 202    * @return  The next <code>Node</code> in the set being iterated over, or
 203    *   <code>null</code> if there are no more members in that set.
 204    */
 205   public int nextNode()
 206   {
 207         if(m_foundLast)
 208                 return DTM.NULL;
 209 
 210     int next;
 211 
 212     com.sun.org.apache.xpath.internal.VariableStack vars;
 213     int savedStart;
 214     if (-1 != m_stackFrame)
 215     {
 216       vars = m_execContext.getVarStack();
 217 
 218       // These three statements need to be combined into one operation.
 219       savedStart = vars.getStackFrame();
 220 
 221       vars.setStackFrame(m_stackFrame);
 222     }
 223     else
 224     {
 225       // Yuck.  Just to shut up the compiler!
 226       vars = null;
 227       savedStart = 0;
 228     }
 229 
 230     try
 231     {
 232       if(DEBUG)
 233         System.out.println("m_pattern"+m_pattern.toString());
 234 
 235       do
 236       {
 237         next = getNextNode();
 238 
 239         if (DTM.NULL != next)
 240         {
 241           if(DTMIterator.FILTER_ACCEPT == acceptNode(next, m_execContext))
 242             break;
 243           else
 244             continue;
 245         }
 246         else
 247           break;
 248       }
 249       while (next != DTM.NULL);
 250 
 251       if (DTM.NULL != next)
 252       {
 253         if(DEBUG)
 254         {
 255           System.out.println("next: "+next);
 256           System.out.println("name: "+m_cdtm.getNodeName(next));
 257         }
 258         incrementCurrentPos();
 259 
 260         return next;
 261       }
 262       else
 263       {
 264         m_foundLast = true;
 265 
 266         return DTM.NULL;
 267       }
 268     }
 269     finally
 270     {
 271       if (-1 != m_stackFrame)
 272       {
 273         // These two statements need to be combined into one operation.
 274         vars.setStackFrame(savedStart);
 275       }
 276     }
 277 
 278   }
 279 
 280   /**
 281    *  Test whether a specified node is visible in the logical view of a
 282    * TreeWalker or NodeIterator. This function will be called by the
 283    * implementation of TreeWalker and NodeIterator; it is not intended to
 284    * be called directly from user code.
 285    * @param n  The node to check to see if it passes the filter or not.
 286    * @return  a constant to determine whether the node is accepted,
 287    *   rejected, or skipped, as defined  above .
 288    */
 289   public short acceptNode(int n, XPathContext xctxt)
 290   {
 291 
 292     try
 293     {
 294       xctxt.pushCurrentNode(n);
 295       xctxt.pushIteratorRoot(m_context);
 296       if(DEBUG)
 297       {
 298         System.out.println("traverser: "+m_traverser);
 299         System.out.print("node: "+n);
 300         System.out.println(", "+m_cdtm.getNodeName(n));
 301         // if(m_cdtm.getNodeName(n).equals("near-east"))
 302         System.out.println("pattern: "+m_pattern.toString());
 303         NodeTest.debugWhatToShow(m_pattern.getWhatToShow());
 304       }
 305 
 306       XObject score = m_pattern.execute(xctxt);
 307 
 308       if(DEBUG)
 309       {
 310         // System.out.println("analysis: "+Integer.toBinaryString(m_analysis));
 311         System.out.println("score: "+score);
 312         System.out.println("skip: "+(score == NodeTest.SCORE_NONE));
 313       }
 314 
 315       // System.out.println("\n::acceptNode - score: "+score.num()+"::");
 316       return (score == NodeTest.SCORE_NONE) ? DTMIterator.FILTER_SKIP
 317                     : DTMIterator.FILTER_ACCEPT;
 318     }
 319     catch (javax.xml.transform.TransformerException se)
 320     {
 321 
 322       // TODO: Fix this.
 323       throw new RuntimeException(se.getMessage());
 324     }
 325     finally
 326     {
 327       xctxt.popCurrentNode();
 328       xctxt.popIteratorRoot();
 329     }
 330 
 331   }
 332 
 333 }
--- EOF ---