1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * @LastModified: Oct 2017
   4  */
   5 /*
   6  * Licensed to the Apache Software Foundation (ASF) under one or more
   7  * contributor license agreements.  See the NOTICE file distributed with
   8  * this work for additional information regarding copyright ownership.
   9  * The ASF licenses this file to You under the Apache License, Version 2.0
  10  * (the "License"); you may not use this file except in compliance with
  11  * the License.  You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21 
  22 package com.sun.org.apache.xalan.internal.xsltc.compiler;
  23 
  24 import com.sun.org.apache.bcel.internal.generic.BranchHandle;
  25 import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
  26 import com.sun.org.apache.bcel.internal.generic.GOTO_W;
  27 import com.sun.org.apache.bcel.internal.generic.IFEQ;
  28 import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
  29 import com.sun.org.apache.bcel.internal.generic.InstructionList;
  30 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.BooleanType;
  31 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
  32 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
  33 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
  34 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodType;
  35 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NodeSetType;
  36 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
  37 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
  38 import java.util.List;
  39 
  40 /**
  41  * @author Jacek Ambroziak
  42  * @author Santiago Pericas-Geertsen
  43  * @author Morten Jorgensen
  44  * @author Erwin Bolwidt <ejb@klomp.org>
  45  */
  46 abstract class Expression extends SyntaxTreeNode {
  47     /**
  48      * The type of this expression. It is set after calling
  49      * <code>typeCheck()</code>.
  50      */
  51     protected Type _type;
  52 
  53     /**
  54      * Instruction handles that comprise the true list.
  55      */
  56     protected FlowList _trueList = new FlowList();
  57 
  58     /**
  59      * Instruction handles that comprise the false list.
  60      */
  61     protected FlowList _falseList = new FlowList();
  62 
  63     public Type getType() {
  64         return _type;
  65     }
  66 
  67     public abstract String toString();
  68 
  69     public boolean hasPositionCall() {
  70         return false;           // default should be 'false' for StepPattern
  71     }
  72 
  73     public boolean hasLastCall() {
  74         return false;
  75     }
  76 
  77     /**
  78      * Returns an object representing the compile-time evaluation
  79      * of an expression. We are only using this for function-available
  80      * and element-available at this time.
  81      */
  82     public Object evaluateAtCompileTime() {
  83         return null;
  84     }
  85 
  86     /**
  87      * Type check all the children of this node.
  88      */
  89     public Type typeCheck(SymbolTable stable) throws TypeCheckError {
  90         return typeCheckContents(stable);
  91     }
  92 
  93     /**
  94      * Translate this node into JVM bytecodes.
  95      */
  96     public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
  97         ErrorMsg msg = new ErrorMsg(ErrorMsg.NOT_IMPLEMENTED_ERR,
  98                                     getClass(), this);
  99         getParser().reportError(FATAL, msg);
 100     }
 101 
 102     /**
 103      * Translate this node into a fresh instruction list.
 104      * The original instruction list is saved and restored.
 105      */
 106     public final InstructionList compile(ClassGenerator classGen,
 107                                          MethodGenerator methodGen) {
 108         final InstructionList result, save = methodGen.getInstructionList();
 109         methodGen.setInstructionList(result = new InstructionList());
 110         translate(classGen, methodGen);
 111         methodGen.setInstructionList(save);
 112         return result;
 113     }
 114 
 115     /**
 116      * Redefined by expressions of type boolean that use flow lists.
 117      */
 118     public void translateDesynthesized(ClassGenerator classGen,
 119                                        MethodGenerator methodGen) {
 120         translate(classGen, methodGen);
 121         if (_type instanceof BooleanType) {
 122             desynthesize(classGen, methodGen);
 123         }
 124     }
 125 
 126     /**
 127      * If this expression is of type node-set and it is not a variable
 128      * reference, then call setStartNode() passing the context node.
 129      */
 130     public void startIterator(ClassGenerator classGen,
 131                                    MethodGenerator methodGen) {
 132         // Ignore if type is not node-set
 133         if (_type instanceof NodeSetType == false) {
 134             return;
 135         }
 136 
 137         // setStartNode() should not be called if expr is a variable ref
 138         Expression expr = this;
 139         if (expr instanceof CastExpr) {
 140             expr = ((CastExpr) expr).getExpr();
 141         }
 142         if (expr instanceof VariableRefBase == false) {
 143             final InstructionList il = methodGen.getInstructionList();
 144             il.append(methodGen.loadContextNode());
 145             il.append(methodGen.setStartNode());
 146         }
 147     }
 148 
 149     /**
 150      * Synthesize a boolean expression, i.e., either push a 0 or 1 onto the
 151      * operand stack for the next statement to succeed. Returns the handle
 152      * of the instruction to be backpatched.
 153      */
 154     public void synthesize(ClassGenerator classGen, MethodGenerator methodGen) {
 155         final ConstantPoolGen cpg = classGen.getConstantPool();
 156         final InstructionList il = methodGen.getInstructionList();
 157         _trueList.backPatch(il.append(ICONST_1));
 158         final BranchHandle truec = il.append(new GOTO_W(null));
 159         _falseList.backPatch(il.append(ICONST_0));
 160         truec.setTarget(il.append(NOP));
 161     }
 162 
 163     public void desynthesize(ClassGenerator classGen,
 164                              MethodGenerator methodGen) {
 165         final InstructionList il = methodGen.getInstructionList();
 166         _falseList.add(il.append(new IFEQ(null)));
 167     }
 168 
 169     public FlowList getFalseList() {
 170         return _falseList;
 171     }
 172 
 173     public FlowList getTrueList() {
 174         return _trueList;
 175     }
 176 
 177     public void backPatchFalseList(InstructionHandle ih) {
 178         _falseList.backPatch(ih);
 179     }
 180 
 181     public void backPatchTrueList(InstructionHandle ih) {
 182         _trueList.backPatch(ih);
 183     }
 184 
 185     /**
 186      * Search for a primop in the symbol table that matches the method type
 187      * <code>ctype</code>. Two methods match if they have the same arity.
 188      * If a primop is overloaded then the "closest match" is returned. The
 189      * first entry in the vector of primops that has the right arity is
 190      * considered to be the default one.
 191      */
 192     public MethodType lookupPrimop(SymbolTable stable, String op,
 193                                    MethodType ctype) {
 194         MethodType result = null;
 195         final List<MethodType> primop = stable.lookupPrimop(op);
 196         if (primop != null) {
 197             final int n = primop.size();
 198             int minDistance = Integer.MAX_VALUE;
 199             for (int i = 0; i < n; i++) {
 200                 final MethodType ptype = primop.get(i);
 201                 // Skip if different arity
 202                 if (ptype.argsCount() != ctype.argsCount()) {
 203                     continue;
 204                 }
 205 
 206                 // The first method with the right arity is the default
 207                 if (result == null) {
 208                     result = ptype;             // default method
 209                 }
 210 
 211                 // Check if better than last one found
 212                 final int distance = ctype.distanceTo(ptype);
 213                 if (distance < minDistance) {
 214                     minDistance = distance;
 215                     result = ptype;
 216                 }
 217             }
 218         }
 219         return result;
 220     }
 221 }