/* * Copyright 2001-2004 The Apache Software Foundation. * * Licensed 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. */ /* * $Id: LogicalExpr.java,v 1.14 2004/02/16 22:24:28 minchau Exp $ */ package com.sun.org.apache.xalan.internal.xsltc.compiler; import com.sun.org.apache.bcel.internal.generic.GOTO; import com.sun.org.apache.bcel.internal.generic.InstructionHandle; import com.sun.org.apache.bcel.internal.generic.InstructionList; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodType; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError; /** * @author Jacek Ambroziak * @author Santiago Pericas-Geertsen * @author Morten Jorgensen */ final class LogicalExpr extends Expression { public static final int OR = 0; public static final int AND = 1; private final int _op; // operator private Expression _left; // first operand private Expression _right; // second operand private static final String[] Ops = { "or", "and" }; /** * Creates a new logical expression - either OR or AND. Note that the * left- and right-hand side expressions can also be logical expressions, * thus creating logical trees representing structures such as * (a and (b or c) and d), etc... */ public LogicalExpr(int op, Expression left, Expression right) { _op = op; (_left = left).setParent(this); (_right = right).setParent(this); } /** * Returns true if this expressions contains a call to position(). This is * needed for context changes in node steps containing multiple predicates. */ public boolean hasPositionCall() { return (_left.hasPositionCall() || _right.hasPositionCall()); } /** * Returns true if this expressions contains a call to last() */ public boolean hasLastCall() { return (_left.hasLastCall() || _right.hasLastCall()); } /** * Returns an object representing the compile-time evaluation * of an expression. We are only using this for function-available * and element-available at this time. */ public Object evaluateAtCompileTime() { final Object leftb = _left.evaluateAtCompileTime(); final Object rightb = _right.evaluateAtCompileTime(); // Return null if we can't evaluate at compile time if (leftb == null || rightb == null) { return null; } if (_op == AND) { return (leftb == Boolean.TRUE && rightb == Boolean.TRUE) ? Boolean.TRUE : Boolean.FALSE; } else { return (leftb == Boolean.TRUE || rightb == Boolean.TRUE) ? Boolean.TRUE : Boolean.FALSE; } } /** * Returns this logical expression's operator - OR or AND represented * by 0 and 1 respectively. */ public int getOp() { return(_op); } /** * Override the SyntaxTreeNode.setParser() method to make sure that the * parser is set for sub-expressions */ public void setParser(Parser parser) { super.setParser(parser); _left.setParser(parser); _right.setParser(parser); } /** * Returns a string describing this expression */ public String toString() { return Ops[_op] + '(' + _left + ", " + _right + ')'; } /** * Type-check this expression, and possibly child expressions. */ public Type typeCheck(SymbolTable stable) throws TypeCheckError { // Get the left and right operand types Type tleft = _left.typeCheck(stable); Type tright = _right.typeCheck(stable); // Check if the operator supports the two operand types MethodType wantType = new MethodType(Type.Void, tleft, tright); MethodType haveType = lookupPrimop(stable, Ops[_op], wantType); // Yes, the operation is supported if (haveType != null) { // Check if left-hand side operand must be type casted Type arg1 = (Type)haveType.argsType().elementAt(0); if (!arg1.identicalTo(tleft)) _left = new CastExpr(_left, arg1); // Check if right-hand side operand must be type casted Type arg2 = (Type) haveType.argsType().elementAt(1); if (!arg2.identicalTo(tright)) _right = new CastExpr(_right, arg1); // Return the result type for the operator we will use return _type = haveType.resultType(); } throw new TypeCheckError(this); } /** * Compile the expression - leave boolean expression on stack */ public void translate(ClassGenerator classGen, MethodGenerator methodGen) { translateDesynthesized(classGen, methodGen); synthesize(classGen, methodGen); } /** * Compile expression and update true/false-lists */ public void translateDesynthesized(ClassGenerator classGen, MethodGenerator methodGen) { final InstructionList il = methodGen.getInstructionList(); final SyntaxTreeNode parent = getParent(); // Compile AND-expression if (_op == AND) { // Translate left hand side - must be true _left.translateDesynthesized(classGen, methodGen); // Need this for chaining any OR-expression children InstructionHandle middle = il.append(NOP); // Translate left right side - must be true _right.translateDesynthesized(classGen, methodGen); // Need this for chaining any OR-expression children InstructionHandle after = il.append(NOP); // Append child expression false-lists to our false-list _falseList.append(_right._falseList.append(_left._falseList)); // Special case for OR-expression as a left child of AND. // The true-list of OR must point to second clause of AND. if ((_left instanceof LogicalExpr) && (((LogicalExpr)_left).getOp() == OR)) { _left.backPatchTrueList(middle); } else if (_left instanceof NotCall) { _left.backPatchTrueList(middle); } else { _trueList.append(_left._trueList); } // Special case for OR-expression as a right child of AND // The true-list of OR must point to true-list of AND. if ((_right instanceof LogicalExpr) && (((LogicalExpr)_right).getOp() == OR)) { _right.backPatchTrueList(after); } else if (_right instanceof NotCall) { _right.backPatchTrueList(after); } else { _trueList.append(_right._trueList); } } // Compile OR-expression else { // Translate left-hand side expression and produce true/false list _left.translateDesynthesized(classGen, methodGen); // This GOTO is used to skip over the code for the last test // in the case where the the first test succeeds InstructionHandle ih = il.append(new GOTO(null)); // Translate right-hand side expression and produce true/false list _right.translateDesynthesized(classGen, methodGen); _left._trueList.backPatch(ih); _left._falseList.backPatch(ih.getNext()); _falseList.append(_right._falseList); _trueList.add(ih).append(_right._trueList); } } }