1. /*

  2.  * Copyright 2001-2004 The Apache Software Foundation.

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

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

  7.  *

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

  9.  *

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

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

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

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. /*

  17.  * $Id: RelationalExpr.java,v 1.19 2004/02/16 22:24:28 minchau Exp $

  18.  */

  19. 

  20. package com.sun.org.apache.xalan.internal.xsltc.compiler;

  21. 

  22. import com.sun.org.apache.bcel.internal.generic.BranchInstruction;

  23. import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;

  24. import com.sun.org.apache.bcel.internal.generic.INVOKESTATIC;

  25. import com.sun.org.apache.bcel.internal.generic.InstructionList;

  26. import com.sun.org.apache.bcel.internal.generic.PUSH;

  27. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.BooleanType;

  28. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;

  29. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;

  30. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.IntType;

  31. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;

  32. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodType;

  33. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NodeSetType;

  34. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NodeType;

  35. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.RealType;

  36. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ReferenceType;

  37. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ResultTreeType;

  38. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;

  39. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;

  40. import com.sun.org.apache.xalan.internal.xsltc.runtime.Operators;

  41. 

  42. /**

  43.  * @author Jacek Ambroziak

  44.  * @author Santiago Pericas-Geertsen

  45.  */

  46. final class RelationalExpr extends Expression implements Operators {

  47.     private int _op;

  48.     private Expression _left, _right;

  49. 		

  50.     public RelationalExpr(int op, Expression left, Expression right) {

  51. 	_op = op;

  52. 	(_left = left).setParent(this);

  53. 	(_right = right).setParent(this);

  54.     }

  55. 

  56.     public void setParser(Parser parser) {

  57. 	super.setParser(parser);

  58. 	_left.setParser(parser);

  59. 	_right.setParser(parser);

  60.     }

  61. 

  62.     /**

  63.      * Returns true if this expressions contains a call to position(). This is

  64.      * needed for context changes in node steps containing multiple predicates.

  65.      */

  66.     public boolean hasPositionCall() {

  67. 	if (_left.hasPositionCall()) return true;

  68. 	if (_right.hasPositionCall()) return true;

  69. 	return false;

  70.     }

  71. 

  72.     /**

  73.      * Returns true if this expressions contains a call to last()

  74.      */

  75.     public boolean hasLastCall() {

  76.             return (_left.hasLastCall() || _right.hasLastCall());

  77.     }

  78.     

  79.     public boolean hasReferenceArgs() {

  80. 	return _left.getType() instanceof ReferenceType ||

  81. 	    _right.getType() instanceof ReferenceType;

  82.     }

  83. 

  84.     public boolean hasNodeArgs() {

  85. 	return _left.getType() instanceof NodeType ||

  86. 	    _right.getType() instanceof NodeType;

  87.     }

  88. 

  89.     public boolean hasNodeSetArgs() {

  90. 	return _left.getType() instanceof NodeSetType ||

  91. 	    _right.getType() instanceof NodeSetType;

  92.     }

  93. 

  94.     public Type typeCheck(SymbolTable stable) throws TypeCheckError {

  95. 	Type tleft = _left.typeCheck(stable); 

  96. 	Type tright = _right.typeCheck(stable);

  97. 

  98. 	//bug fix # 2838, cast to reals if both are result tree fragments

  99. 	if (tleft instanceof ResultTreeType &&

  100. 	    tright instanceof ResultTreeType ) 

  101.   	{

  102. 	    _right = new CastExpr(_right, Type.Real);

  103. 	    _left = new CastExpr(_left, Type.Real);

  104. 	    return _type = Type.Boolean; 

  105. 	}

  106. 

  107. 	// If one is of reference type, then convert the other too

  108. 	if (hasReferenceArgs()) {

  109. 	    Type type = null;

  110. 	    Type typeL = null;

  111. 	    Type typeR = null;

  112. 	    if (tleft instanceof ReferenceType) {

  113. 		if (_left instanceof VariableRefBase) {

  114. 		    VariableRefBase ref = (VariableRefBase)_left;

  115. 		    VariableBase var = ref.getVariable();

  116. 		    typeL = var.getType();

  117. 		}

  118. 	    }

  119. 	    if (tright instanceof ReferenceType) {

  120. 		if (_right instanceof VariableRefBase) {

  121. 		    VariableRefBase ref = (VariableRefBase)_right;

  122. 		    VariableBase var = ref.getVariable();

  123. 		    typeR = var.getType();

  124. 		}

  125. 	    }

  126. 	    // bug fix # 2838 

  127. 	    if (typeL == null)

  128. 		type = typeR;

  129. 	    else if (typeR == null)

  130. 		type = typeL;

  131. 	    else {

  132. 		type = Type.Real;

  133. 	    }

  134. 	    if (type == null) type = Type.Real;

  135. 

  136. 	    _right = new CastExpr(_right, type);

  137.             _left = new CastExpr(_left, type);

  138. 	    return _type = Type.Boolean;

  139. 	}

  140. 

  141. 	if (hasNodeSetArgs()) {

  142. 	    // Ensure that the node-set is the left argument

  143. 	    if (tright instanceof NodeSetType) {

  144. 		final Expression temp = _right; _right = _left; _left = temp;

  145. 		_op = (_op == Operators.GT) ? Operators.LT :

  146. 		    (_op == Operators.LT) ? Operators.GT :

  147. 		    (_op == Operators.GE) ? Operators.LE : Operators.GE;

  148. 		tright = _right.getType();

  149. 	    }

  150. 

  151. 	    // Promote nodes to node sets

  152. 	    if (tright instanceof NodeType) {

  153. 		_right = new CastExpr(_right, Type.NodeSet);

  154. 	    }

  155. 	    // Promote integer to doubles to have fewer compares

  156. 	    if (tright instanceof IntType) {

  157. 		_right = new CastExpr(_right, Type.Real);

  158. 	    }

  159. 	    // Promote result-trees to strings

  160. 	    if (tright instanceof ResultTreeType) {

  161. 		_right = new CastExpr(_right, Type.String);

  162. 	    }

  163. 	    return _type = Type.Boolean;

  164. 	}

  165. 

  166. 	// In the node-boolean case, convert node to boolean first

  167. 	if (hasNodeArgs()) {

  168. 	    if (tleft instanceof BooleanType) {

  169. 		_right = new CastExpr(_right, Type.Boolean);

  170. 		tright = Type.Boolean;

  171. 	    }

  172. 	    if (tright instanceof BooleanType) {

  173. 		_left = new CastExpr(_left, Type.Boolean);

  174. 		tleft = Type.Boolean;

  175. 	    }

  176. 	}

  177. 

  178. 	// Lookup the table of primops to find the best match

  179. 	MethodType ptype = lookupPrimop(stable, Operators.names[_op],

  180. 					new MethodType(Type.Void, 

  181. 						       tleft, tright)); 

  182. 

  183. 	if (ptype != null) {

  184. 	    Type arg1 = (Type) ptype.argsType().elementAt(0);

  185. 	    if (!arg1.identicalTo(tleft)) {

  186. 		_left = new CastExpr(_left, arg1);

  187. 	    }

  188. 	    Type arg2 = (Type) ptype.argsType().elementAt(1);

  189. 	    if (!arg2.identicalTo(tright)) {

  190. 		_right = new CastExpr(_right, arg1);				

  191. 	    }

  192. 	    return _type = ptype.resultType();

  193. 	}

  194. 	throw new TypeCheckError(this);

  195.     }

  196. 

  197.     public void translate(ClassGenerator classGen, MethodGenerator methodGen) {

  198. 	if (hasNodeSetArgs() || hasReferenceArgs()) {

  199. 	    final ConstantPoolGen cpg = classGen.getConstantPool();

  200. 	    final InstructionList il = methodGen.getInstructionList();

  201. 

  202. 	    // Call compare() from the BasisLibrary

  203. 	    _left.translate(classGen, methodGen);

  204. 	    _left.startIterator(classGen, methodGen);

  205. 	    _right.translate(classGen, methodGen);

  206. 	    _right.startIterator(classGen, methodGen);

  207. 

  208. 	    il.append(new PUSH(cpg, _op));

  209. 	    il.append(methodGen.loadDOM());

  210. 

  211. 	    int index = cpg.addMethodref(BASIS_LIBRARY_CLASS, "compare",

  212. 					 "("

  213. 					 + _left.getType().toSignature() 

  214. 					 + _right.getType().toSignature()

  215. 					 + "I"

  216. 					 + DOM_INTF_SIG

  217. 					 + ")Z");

  218. 	    il.append(new INVOKESTATIC(index));

  219. 	}

  220. 	else {

  221. 	    translateDesynthesized(classGen, methodGen);

  222. 	    synthesize(classGen, methodGen);

  223. 	}

  224.     }

  225. 

  226.     public void translateDesynthesized(ClassGenerator classGen,

  227. 				       MethodGenerator methodGen) {

  228. 	if (hasNodeSetArgs() || hasReferenceArgs()) {

  229. 	    translate(classGen, methodGen);

  230. 	    desynthesize(classGen, methodGen);

  231. 	}

  232. 	else {

  233. 	    BranchInstruction bi = null;

  234. 	    final InstructionList il = methodGen.getInstructionList();

  235. 

  236. 	    _left.translate(classGen, methodGen);

  237. 	    _right.translate(classGen, methodGen);

  238. 

  239. 	    // TODO: optimize if one of the args is 0

  240. 

  241. 	    boolean tozero = false;

  242. 	    Type tleft = _left.getType(); 

  243. 

  244. 	    if (tleft instanceof RealType) {

  245. 		il.append(tleft.CMP(_op == LT || _op == LE));

  246. 		tleft = Type.Int;

  247. 		tozero = true;

  248. 	    }

  249. 

  250. 	    switch (_op) {

  251. 	    case LT:

  252. 		bi = tleft.GE(tozero);	

  253. 		break;

  254. 		

  255. 	    case GT:

  256. 		bi = tleft.LE(tozero);

  257. 		break;

  258. 		

  259. 	    case LE:

  260. 		bi = tleft.GT(tozero);

  261. 		break;

  262. 		

  263. 	    case GE:

  264. 		bi = tleft.LT(tozero);

  265. 		break;

  266. 		

  267. 	    default:

  268. 		ErrorMsg msg = new ErrorMsg(ErrorMsg.ILLEGAL_RELAT_OP_ERR,this);

  269. 		getParser().reportError(Constants.FATAL, msg);

  270. 	    }

  271. 

  272. 	    _falseList.add(il.append(bi));		// must be backpatched

  273. 	}

  274.     }

  275. 

  276.     public String toString() {

  277. 	return Operators.names[_op] + '(' + _left + ", " + _right + ')';

  278.     }

  279. }