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.compiler;
  22 
  23 import com.sun.org.apache.xalan.internal.res.XSLMessages;
  24 import com.sun.org.apache.xml.internal.utils.ObjectVector;
  25 import com.sun.org.apache.xpath.internal.patterns.NodeTest;
  26 import com.sun.org.apache.xpath.internal.res.XPATHErrorResources;
  27 
  28 /**
  29  * This class represents the data structure basics of the XPath
  30  * object.
  31  *
  32  * @LastModified: Nov 2017
  33  */
  34 public class OpMap
  35 {
  36 
  37   /**
  38    * The current pattern string, for diagnostics purposes
  39    */
  40   protected String m_currentPattern;
  41 
  42   /**
  43    * Return the expression as a string for diagnostics.
  44    *
  45    * @return The expression string.
  46    */
  47   public String toString()
  48   {
  49     return m_currentPattern;
  50   }
  51 
  52   /**
  53    * Return the expression as a string for diagnostics.
  54    *
  55    * @return The expression string.
  56    */
  57   public String getPatternString()
  58   {
  59     return m_currentPattern;
  60   }
  61 
  62   /**
  63    * The starting size of the token queue.
  64    */
  65   static final int MAXTOKENQUEUESIZE = 500;
  66 
  67   /*
  68    * Amount to grow token queue when it becomes full
  69    */
  70   static final int BLOCKTOKENQUEUESIZE = 500;
  71 
  72   /**
  73    *  TokenStack is the queue of used tokens. The current token is the token at the
  74    * end of the m_tokenQueue. The idea is that the queue can be marked and a sequence
  75    * of tokens can be reused.
  76    */
  77   ObjectVector m_tokenQueue = new ObjectVector(MAXTOKENQUEUESIZE, BLOCKTOKENQUEUESIZE);
  78 
  79   /**
  80    * Get the XPath as a list of tokens.
  81    *
  82    * @return ObjectVector of tokens.
  83    */
  84   public ObjectVector getTokenQueue()
  85   {
  86     return m_tokenQueue;
  87   }
  88 
  89   /**
  90    * Get the XPath as a list of tokens.
  91    *
  92    * @param pos index into token queue.
  93    *
  94    * @return The token, normally a string.
  95    */
  96   public Object getToken(int pos)
  97   {
  98     return m_tokenQueue.elementAt(pos);
  99   }
 100 
 101   /**
 102    * The current size of the token queue.
 103    */
 104 //  public int m_tokenQueueSize = 0;
 105 
 106   /**
 107     * Get size of the token queue.
 108    *
 109    * @return The size of the token queue.
 110    */
 111   public int getTokenQueueSize()
 112   {
 113     return m_tokenQueue.size();
 114 
 115   }
 116 
 117   /**
 118    * An operations map is used instead of a proper parse tree.  It contains
 119    * operations codes and indexes into the m_tokenQueue.
 120    * I use an array instead of a full parse tree in order to cut down
 121    * on the number of objects created.
 122    */
 123   OpMapVector m_opMap = null;
 124 
 125   /**
 126     * Get the opcode list that describes the XPath operations.  It contains
 127    * operations codes and indexes into the m_tokenQueue.
 128    * I use an array instead of a full parse tree in order to cut down
 129    * on the number of objects created.
 130    *
 131    * @return An IntVector that is the opcode list that describes the XPath operations.
 132    */
 133   public OpMapVector getOpMap()
 134   {
 135     return m_opMap;
 136   }
 137 
 138   // Position indexes
 139 
 140   /**
 141    * The length is always the opcode position + 1.
 142    * Length is always expressed as the opcode+length bytes,
 143    * so it is always 2 or greater.
 144    */
 145   public static final int MAPINDEX_LENGTH = 1;
 146 
 147   /**
 148    * Replace the large arrays
 149    * with a small array.
 150    */
 151   void shrink()
 152   {
 153 
 154     int n = m_opMap.elementAt(MAPINDEX_LENGTH);
 155     m_opMap.setToSize(n + 4);
 156 
 157     m_opMap.setElementAt(0,n);
 158     m_opMap.setElementAt(0,n+1);
 159     m_opMap.setElementAt(0,n+2);
 160 
 161 
 162     n = m_tokenQueue.size();
 163     m_tokenQueue.setToSize(n + 4);
 164 
 165     m_tokenQueue.setElementAt(null,n);
 166     m_tokenQueue.setElementAt(null,n + 1);
 167     m_tokenQueue.setElementAt(null,n + 2);
 168   }
 169 
 170   /**
 171   * Given an operation position, return the current op.
 172    *
 173    * @param opPos index into op map.
 174    * @return the op that corresponds to the opPos argument.
 175    */
 176   public int getOp(int opPos)
 177   {
 178     return m_opMap.elementAt(opPos);
 179   }
 180 
 181   /**
 182   * Set the op at index to the given int.
 183    *
 184    * @param opPos index into op map.
 185    * @param value Value to set
 186    */
 187   public void setOp(int opPos, int value)
 188   {
 189      m_opMap.setElementAt(value,opPos);
 190   }
 191 
 192   /**
 193    * Given an operation position, return the end position, i.e. the
 194    * beginning of the next operation.
 195    *
 196    * @param opPos An op position of an operation for which there is a size
 197    *              entry following.
 198    * @return position of next operation in m_opMap.
 199    */
 200   public int getNextOpPos(int opPos)
 201   {
 202     return opPos + m_opMap.elementAt(opPos + 1);
 203   }
 204 
 205   /**
 206    * Given a location step position, return the end position, i.e. the
 207    * beginning of the next step.
 208    *
 209    * @param opPos the position of a location step.
 210    * @return the position of the next location step.
 211    */
 212   public int getNextStepPos(int opPos)
 213   {
 214 
 215     int stepType = getOp(opPos);
 216 
 217     if ((stepType >= OpCodes.AXES_START_TYPES)
 218             && (stepType <= OpCodes.AXES_END_TYPES))
 219     {
 220       return getNextOpPos(opPos);
 221     }
 222     else if ((stepType >= OpCodes.FIRST_NODESET_OP)
 223              && (stepType <= OpCodes.LAST_NODESET_OP))
 224     {
 225       int newOpPos = getNextOpPos(opPos);
 226 
 227       while (OpCodes.OP_PREDICATE == getOp(newOpPos))
 228       {
 229         newOpPos = getNextOpPos(newOpPos);
 230       }
 231 
 232       stepType = getOp(newOpPos);
 233 
 234       if (!((stepType >= OpCodes.AXES_START_TYPES)
 235             && (stepType <= OpCodes.AXES_END_TYPES)))
 236       {
 237         return OpCodes.ENDOP;
 238       }
 239 
 240       return newOpPos;
 241     }
 242     else
 243     {
 244       throw new RuntimeException(
 245         XSLMessages.createXPATHMessage(XPATHErrorResources.ER_UNKNOWN_STEP, new Object[]{String.valueOf(stepType)}));
 246       //"Programmer's assertion in getNextStepPos: unknown stepType: " + stepType);
 247     }
 248   }
 249 
 250   /**
 251    * Given an operation position, return the end position, i.e. the
 252    * beginning of the next operation.
 253    *
 254    * @param opMap The operations map.
 255    * @param opPos index to operation, for which there is a size entry following.
 256    * @return position of next operation in m_opMap.
 257    */
 258   public static int getNextOpPos(int[] opMap, int opPos)
 259   {
 260     return opPos + opMap[opPos + 1];
 261   }
 262 
 263   /**
 264    * Given an FROM_stepType position, return the position of the
 265    * first predicate, if there is one, or else this will point
 266    * to the end of the FROM_stepType.
 267    * Example:
 268    *  int posOfPredicate = xpath.getNextOpPos(stepPos);
 269    *  boolean hasPredicates =
 270    *            OpCodes.OP_PREDICATE == xpath.getOp(posOfPredicate);
 271    *
 272    * @param opPos position of FROM_stepType op.
 273    * @return position of predicate in FROM_stepType structure.
 274    */
 275   public int getFirstPredicateOpPos(int opPos)
 276      throws javax.xml.transform.TransformerException
 277   {
 278 
 279     int stepType = m_opMap.elementAt(opPos);
 280 
 281     if ((stepType >= OpCodes.AXES_START_TYPES)
 282             && (stepType <= OpCodes.AXES_END_TYPES))
 283     {
 284       return opPos + m_opMap.elementAt(opPos + 2);
 285     }
 286     else if ((stepType >= OpCodes.FIRST_NODESET_OP)
 287              && (stepType <= OpCodes.LAST_NODESET_OP))
 288     {
 289       return opPos + m_opMap.elementAt(opPos + 1);
 290     }
 291     else if(-2 == stepType)
 292     {
 293       return -2;
 294     }
 295     else
 296     {
 297       error(com.sun.org.apache.xpath.internal.res.XPATHErrorResources.ER_UNKNOWN_OPCODE,
 298             new Object[]{ String.valueOf(stepType) });  //"ERROR! Unknown op code: "+m_opMap[opPos]);
 299       return -1;
 300     }
 301   }
 302 
 303   /**
 304    * Tell the user of an error, and probably throw an
 305    * exception.
 306    *
 307    * @param msg An error msgkey that corresponds to one of the constants found
 308    *            in {@link com.sun.org.apache.xpath.internal.res.XPATHErrorResources}, which is
 309    *            a key for a format string.
 310    * @param args An array of arguments represented in the format string, which
 311    *             may be null.
 312    *
 313    * @throws TransformerException if the current ErrorListoner determines to
 314    *                              throw an exception.
 315    */
 316   public void error(String msg, Object[] args) throws javax.xml.transform.TransformerException
 317   {
 318 
 319     java.lang.String fmsg = com.sun.org.apache.xalan.internal.res.XSLMessages.createXPATHMessage(msg, args);
 320 
 321 
 322     throw new javax.xml.transform.TransformerException(fmsg);
 323   }
 324 
 325 
 326   /**
 327    * Go to the first child of a given operation.
 328    *
 329    * @param opPos position of operation.
 330    *
 331    * @return The position of the first child of the operation.
 332    */
 333   public static int getFirstChildPos(int opPos)
 334   {
 335     return opPos + 2;
 336   }
 337 
 338   /**
 339    * Get the length of an operation.
 340    *
 341    * @param opPos The position of the operation in the op map.
 342    *
 343    * @return The size of the operation.
 344    */
 345   public int getArgLength(int opPos)
 346   {
 347     return m_opMap.elementAt(opPos + MAPINDEX_LENGTH);
 348   }
 349 
 350   /**
 351    * Given a location step, get the length of that step.
 352    *
 353    * @param opPos Position of location step in op map.
 354    *
 355    * @return The length of the step.
 356    */
 357   public int getArgLengthOfStep(int opPos)
 358   {
 359     return m_opMap.elementAt(opPos + MAPINDEX_LENGTH + 1) - 3;
 360   }
 361 
 362   /**
 363    * Get the first child position of a given location step.
 364    *
 365    * @param opPos Position of location step in the location map.
 366    *
 367    * @return The first child position of the step.
 368    */
 369   public static int getFirstChildPosOfStep(int opPos)
 370   {
 371     return opPos + 3;
 372   }
 373 
 374   /**
 375    * Get the test type of the step, i.e. NODETYPE_XXX value.
 376    *
 377    * @param opPosOfStep The position of the FROM_XXX step.
 378    *
 379    * @return NODETYPE_XXX value.
 380    */
 381   public int getStepTestType(int opPosOfStep)
 382   {
 383     return m_opMap.elementAt(opPosOfStep + 3);  // skip past op, len, len without predicates
 384   }
 385 
 386   /**
 387    * Get the namespace of the step.
 388    *
 389    * @param opPosOfStep The position of the FROM_XXX step.
 390    *
 391    * @return The step's namespace, NodeTest.WILD, or null for null namespace.
 392    */
 393   public String getStepNS(int opPosOfStep)
 394   {
 395 
 396     int argLenOfStep = getArgLengthOfStep(opPosOfStep);
 397 
 398     // System.out.println("getStepNS.argLenOfStep: "+argLenOfStep);
 399     if (argLenOfStep == 3)
 400     {
 401       int index = m_opMap.elementAt(opPosOfStep + 4);
 402 
 403       if (index >= 0)
 404         return (String) m_tokenQueue.elementAt(index);
 405       else if (OpCodes.ELEMWILDCARD == index)
 406         return NodeTest.WILD;
 407       else
 408         return null;
 409     }
 410     else
 411       return null;
 412   }
 413 
 414   /**
 415    * Get the local name of the step.
 416    * @param opPosOfStep The position of the FROM_XXX step.
 417    *
 418    * @return OpCodes.EMPTY, OpCodes.ELEMWILDCARD, or the local name.
 419    */
 420   public String getStepLocalName(int opPosOfStep)
 421   {
 422 
 423     int argLenOfStep = getArgLengthOfStep(opPosOfStep);
 424 
 425     // System.out.println("getStepLocalName.argLenOfStep: "+argLenOfStep);
 426     int index;
 427 
 428     switch (argLenOfStep)
 429     {
 430     case 0 :
 431       index = OpCodes.EMPTY;
 432       break;
 433     case 1 :
 434       index = OpCodes.ELEMWILDCARD;
 435       break;
 436     case 2 :
 437       index = m_opMap.elementAt(opPosOfStep + 4);
 438       break;
 439     case 3 :
 440       index = m_opMap.elementAt(opPosOfStep + 5);
 441       break;
 442     default :
 443       index = OpCodes.EMPTY;
 444       break;  // Should assert error
 445     }
 446 
 447     // int index = (argLenOfStep == 3) ? m_opMap[opPosOfStep+5]
 448     //                                  : ((argLenOfStep == 1) ? -3 : -2);
 449     if (index >= 0)
 450       return m_tokenQueue.elementAt(index).toString();
 451     else if (OpCodes.ELEMWILDCARD == index)
 452       return NodeTest.WILD;
 453     else
 454       return null;
 455   }
 456 
 457 }
--- EOF ---