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: Type.java,v 1.15 2004/02/16 22:26:44 minchau Exp $

  18.  */

  19. 

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

  21. 

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

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

  24. import com.sun.org.apache.xalan.internal.xsltc.compiler.Constants;

  25. import com.sun.org.apache.xalan.internal.xsltc.compiler.FlowList;

  26. import com.sun.org.apache.xalan.internal.xsltc.compiler.NodeTest;

  27. 

  28. /**

  29.  * @author Jacek Ambroziak

  30.  * @author Santiago Pericas-Geertsen

  31.  * @author Morten Jorgensen

  32.  */

  33. public abstract class Type implements Constants {

  34.     public static final Type Int        = new IntType();

  35.     public static final Type Real       = new RealType();

  36.     public static final Type Boolean    = new BooleanType();

  37.     public static final Type NodeSet    = new NodeSetType();

  38.     public static final Type String     = new StringType();

  39.     public static final Type ResultTree = new ResultTreeType();

  40.     public static final Type Reference  = new ReferenceType();

  41.     public static final Type Void       = new VoidType();

  42.     

  43.     public static final Type Object       = new ObjectType(java.lang.Object.class);

  44.     public static final Type ObjectString = new ObjectType(java.lang.String.class);

  45. 

  46.     public static final Type Node       = new NodeType(NodeTest.ANODE);

  47.     public static final Type Root       = new NodeType(NodeTest.ROOT);

  48.     public static final Type Element    = new NodeType(NodeTest.ELEMENT);

  49.     public static final Type Attribute  = new NodeType(NodeTest.ATTRIBUTE);

  50.     public static final Type Text       = new NodeType(NodeTest.TEXT);

  51.     public static final Type Comment    = new NodeType(NodeTest.COMMENT);

  52.     public static final Type Processing_Instruction = new NodeType(NodeTest.PI);

  53. 

  54.     /**

  55.      * Factory method to instantiate object types. Returns a pre-defined

  56.      * instance for "java.lang.Object" and "java.lang.String".

  57.      */

  58.     public static Type newObjectType(String javaClassName) {

  59.         if (javaClassName == "java.lang.Object") {

  60.             return Type.Object;

  61.         }

  62.         else if (javaClassName == "java.lang.String") {

  63.             return Type.ObjectString;

  64.         }

  65.         else {

  66.             return new ObjectType(javaClassName);

  67.         }

  68.     }

  69.     

  70.    /**

  71.      * Factory method to instantiate object types. Returns a pre-defined

  72.      * instance for java.lang.Object.class and java.lang.String.class.

  73.      */

  74.     public static Type newObjectType(Class clazz) {

  75.         if (clazz == java.lang.Object.class) {

  76.             return Type.Object;

  77.         }

  78.         else if (clazz == java.lang.String.class) {

  79.             return Type.ObjectString;

  80.         }

  81.         else {

  82.             return new ObjectType(clazz);

  83.         }

  84.     }

  85.     

  86.     /**

  87.      * Returns a string representation of this type.	

  88.      */

  89.     public abstract String toString();

  90. 

  91.     /**

  92.      * Returns true if this and other are identical types.

  93.      */

  94.     public abstract boolean identicalTo(Type other);

  95. 

  96.     /**

  97.      * Returns true if this type is a numeric type. Redefined in NumberType.

  98.      */

  99.     public boolean isNumber() {

  100. 	return false;

  101.     }

  102. 

  103.     /**

  104.      * Returns true if this type has no object representaion. Redefined in

  105.      * ResultTreeType.

  106.      */

  107.     public boolean implementedAsMethod() {

  108. 	return false;

  109.     }

  110. 

  111.     /**

  112.      * Returns true if this type is a simple type. Redefined in NumberType,

  113.      * BooleanType and StringType.

  114.      */

  115.     public boolean isSimple() {

  116. 	return false;

  117.     }

  118. 

  119.     public abstract com.sun.org.apache.bcel.internal.generic.Type toJCType();

  120. 

  121.     /**

  122.      * Returns the distance between two types. This measure is used to select

  123.      * overloaded functions/operators. This method is typically redefined by

  124.      * the subclasses.

  125.      */

  126.     public int distanceTo(Type type) {

  127. 	return type == this ? 0 : Integer.MAX_VALUE;

  128.     }

  129. 

  130.     /**

  131.      * Returns the signature of an internal type's external representation.

  132.      */

  133.     public abstract String toSignature();

  134. 

  135.     /**

  136.      * Translates an object of this type to an object of type

  137.      * <code>type</code>. 

  138.      * Expects an object of the former type and pushes an object of the latter.

  139.      */

  140.     public void translateTo(ClassGenerator classGen, MethodGenerator methodGen, 

  141. 			    Type type) {

  142. 	ErrorMsg err = new ErrorMsg(ErrorMsg.DATA_CONVERSION_ERR,

  143. 				    toString(), type.toString());

  144. 	classGen.getParser().reportError(Constants.FATAL, err);

  145.     }

  146. 

  147.     /**

  148.      * Translates object of this type to an object of type <code>type</code>. 

  149.      * Expects an object of the former type and pushes an object of the latter

  150.      * if not boolean. If type <code>type</code> is boolean then a branchhandle

  151.      * list (to be appended to the false list) is returned.

  152.      */

  153.     public FlowList translateToDesynthesized(ClassGenerator classGen, 

  154. 					     MethodGenerator methodGen, 

  155. 					     Type type) {

  156. 	FlowList fl = null;

  157. 	if (type == Type.Boolean) {

  158. 	    fl = translateToDesynthesized(classGen, methodGen,

  159. 					  (BooleanType)type);

  160. 	}

  161. 	else {

  162. 	    translateTo(classGen, methodGen, type);

  163. 	}

  164. 	return fl;

  165.     }

  166. 

  167.     /**

  168.      * Translates an object of this type to an non-synthesized boolean. It

  169.      * does not push a 0 or a 1 but instead returns branchhandle list to be

  170.      * appended to the false list.

  171.      */ 

  172.     public FlowList translateToDesynthesized(ClassGenerator classGen, 

  173. 					     MethodGenerator methodGen, 

  174. 					     BooleanType type) {

  175. 	ErrorMsg err = new ErrorMsg(ErrorMsg.DATA_CONVERSION_ERR,

  176. 				    toString(), type.toString());

  177. 	classGen.getParser().reportError(Constants.FATAL, err);

  178. 	return null;

  179.     }

  180. 

  181.     /**

  182.      * Translates an object of this type to the external (Java) type denoted

  183.      * by <code>clazz</code>. This method is used to translate parameters 

  184.      * when external functions are called.

  185.      */ 

  186.     public void translateTo(ClassGenerator classGen, MethodGenerator methodGen, 

  187. 			    Class clazz) {

  188. 	ErrorMsg err = new ErrorMsg(ErrorMsg.DATA_CONVERSION_ERR,

  189. 				    toString(), clazz.getClass().toString());

  190. 	classGen.getParser().reportError(Constants.FATAL, err);

  191.     }

  192. 

  193.     /**

  194.      * Translates an external (Java) type denoted by <code>clazz</code> to 

  195.      * an object of this type. This method is used to translate return values 

  196.      * when external functions are called.

  197.      */ 

  198.     public void translateFrom(ClassGenerator classGen, MethodGenerator methodGen,

  199. 			      Class clazz) {

  200. 	ErrorMsg err = new ErrorMsg(ErrorMsg.DATA_CONVERSION_ERR,

  201. 				    clazz.getClass().toString(), toString());

  202. 	classGen.getParser().reportError(Constants.FATAL, err);

  203.     }

  204. 

  205.     /**

  206.      * Translates an object of this type to its boxed representation.

  207.      */ 

  208.     public void translateBox(ClassGenerator classGen,

  209. 			     MethodGenerator methodGen) {

  210. 	ErrorMsg err = new ErrorMsg(ErrorMsg.DATA_CONVERSION_ERR,

  211. 				    toString(), "["+toString()+"]");

  212. 	classGen.getParser().reportError(Constants.FATAL, err);

  213.     }

  214. 

  215.     /**

  216.      * Translates an object of this type to its unboxed representation.

  217.      */ 

  218.     public void translateUnBox(ClassGenerator classGen,

  219. 			       MethodGenerator methodGen) {

  220. 	ErrorMsg err = new ErrorMsg(ErrorMsg.DATA_CONVERSION_ERR,

  221. 				    "["+toString()+"]", toString());

  222. 	classGen.getParser().reportError(Constants.FATAL, err);

  223.     }

  224. 

  225.     /**

  226.      * Returns the class name of an internal type's external representation.

  227.      */

  228.     public String getClassName() {

  229. 	return(EMPTYSTRING);

  230.     }

  231. 

  232.     public Instruction ADD() {

  233. 	return null;		// should never be called

  234.     }

  235. 

  236.     public Instruction SUB() {

  237. 	return null;		// should never be called

  238.     }

  239. 

  240.     public Instruction MUL() {

  241. 	return null;		// should never be called

  242.     }

  243. 

  244.     public Instruction DIV() {

  245. 	return null;		// should never be called

  246.     }

  247. 

  248.     public Instruction REM() {

  249. 	return null;		// should never be called

  250.     }

  251. 

  252.     public Instruction NEG() {

  253. 	return null;		// should never be called

  254.     }

  255. 

  256.     public Instruction LOAD(int slot) {

  257. 	return null;		// should never be called

  258.     }

  259. 	

  260.     public Instruction STORE(int slot) {

  261. 	return null;		// should never be called

  262.     }

  263. 

  264.     public Instruction POP() {

  265. 	return POP;

  266.     }

  267. 

  268.     public BranchInstruction GT(boolean tozero) {

  269. 	return null;		// should never be called

  270.     }

  271. 

  272.     public BranchInstruction GE(boolean tozero) {

  273. 	return null;		// should never be called

  274.     }

  275. 

  276.     public BranchInstruction LT(boolean tozero) {

  277. 	return null;		// should never be called

  278.     }

  279. 

  280.     public BranchInstruction LE(boolean tozero) {

  281. 	return null;		// should never be called

  282.     }

  283. 

  284.     public Instruction CMP(boolean less) {

  285. 	return null;		// should never be called

  286.     }

  287. 	

  288.     public Instruction DUP() {

  289. 	return DUP;	// default

  290.     }

  291. }