001 /* Statement.java 002 Copyright (C) 2004, 2005, 2006, Free Software Foundation, Inc. 003 004 This file is part of GNU Classpath. 005 006 GNU Classpath is free software; you can redistribute it and/or modify 007 it under the terms of the GNU General Public License as published by 008 the Free Software Foundation; either version 2, or (at your option) 009 any later version. 010 011 GNU Classpath is distributed in the hope that it will be useful, but 012 WITHOUT ANY WARRANTY; without even the implied warranty of 013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 General Public License for more details. 015 016 You should have received a copy of the GNU General Public License 017 along with GNU Classpath; see the file COPYING. If not, write to the 018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 019 02110-1301 USA. 020 021 Linking this library statically or dynamically with other modules is 022 making a combined work based on this library. Thus, the terms and 023 conditions of the GNU General Public License cover the whole 024 combination. 025 026 As a special exception, the copyright holders of this library give you 027 permission to link this library with independent modules to produce an 028 executable, regardless of the license terms of these independent 029 modules, and to copy and distribute the resulting executable under 030 terms of your choice, provided that you also meet, for each linked 031 independent module, the terms and conditions of the license of that 032 module. An independent module is a module which is not derived from 033 or based on this library. If you modify this library, you may extend 034 this exception to your version of the library, but you are not 035 obligated to do so. If you do not wish to do so, delete this 036 exception statement from your version. */ 037 038 039 package java.beans; 040 041 import java.lang.reflect.Array; 042 import java.lang.reflect.Constructor; 043 import java.lang.reflect.Method; 044 045 /** 046 * <p>A Statement captures the execution of an object method. It stores 047 * the object, the method to call, and the arguments to the method and 048 * provides the ability to execute the method on the object, using the 049 * provided arguments.</p> 050 * 051 * @author Jerry Quinn (jlquinn@optonline.net) 052 * @author Robert Schuster (robertschuster@fsfe.org) 053 * @since 1.4 054 */ 055 public class Statement 056 { 057 private Object target; 058 private String methodName; 059 private Object[] arguments; 060 061 /** 062 * One or the other of these will get a value after execute is 063 * called once, but not both. 064 */ 065 private transient Method method; 066 private transient Constructor ctor; 067 068 /** 069 * <p>Constructs a statement representing the invocation of 070 * object.methodName(arg[0], arg[1], ...);</p> 071 * 072 * <p>If the argument array is null it is replaced with an 073 * array of zero length.</p> 074 * 075 * @param target The object to invoke the method on. 076 * @param methodName The object method to invoke. 077 * @param arguments An array of arguments to pass to the method. 078 */ 079 public Statement(Object target, String methodName, Object[] arguments) 080 { 081 this.target = target; 082 this.methodName = methodName; 083 this.arguments = (arguments != null) ? arguments : new Object[0]; 084 } 085 086 /** 087 * Execute the statement. 088 * 089 * <p>Finds the specified method in the target object and calls it with 090 * the arguments given in the constructor.</p> 091 * 092 * <p>The most specific method according to the JLS(15.11) is used when 093 * there are multiple methods with the same name.</p> 094 * 095 * <p>Execute performs some special handling for methods and 096 * parameters: 097 * <ul> 098 * <li>Static methods can be executed by providing the class as a 099 * target.</li> 100 * 101 * <li>The method name new is reserved to call the constructor 102 * new() will construct an object and return it. Not useful unless 103 * an expression :-)</li> 104 * 105 * <li>If the target is an array, get and set as defined in 106 * java.util.List are recognized as valid methods and mapped to the 107 * methods of the same name in java.lang.reflect.Array.</li> 108 * 109 * <li>The native datatype wrappers Boolean, Byte, Character, Double, 110 * Float, Integer, Long, and Short will map to methods that have 111 * native datatypes as parameters, in the same way as Method.invoke. 112 * However, these wrappers also select methods that actually take 113 * the wrapper type as an argument.</li> 114 * </ul> 115 * </p> 116 * 117 * <p>The Sun spec doesn't deal with overloading between int and 118 * Integer carefully. If there are two methods, one that takes an 119 * Integer and the other taking an int, the method chosen is not 120 * specified, and can depend on the order in which the methods are 121 * declared in the source file.</p> 122 * 123 * @throws Exception if an exception occurs while locating or 124 * invoking the method. 125 */ 126 public void execute() throws Exception 127 { 128 doExecute(); 129 } 130 131 private static Class wrappers[] = 132 { 133 Boolean.class, Byte.class, Character.class, Double.class, Float.class, 134 Integer.class, Long.class, Short.class 135 }; 136 137 private static Class natives[] = 138 { 139 Boolean.TYPE, Byte.TYPE, Character.TYPE, Double.TYPE, Float.TYPE, 140 Integer.TYPE, Long.TYPE, Short.TYPE 141 }; 142 143 /** Given a wrapper class, return the native class for it. 144 * <p>For example, if <code>c</code> is <code>Integer</code>, 145 * <code>Integer.TYPE</code> is returned.</p> 146 */ 147 private Class unwrap(Class c) 148 { 149 for (int i = 0; i < wrappers.length; i++) 150 if (c == wrappers[i]) 151 return natives[i]; 152 return null; 153 } 154 155 /** Returns <code>true</code> if all args can be assigned to 156 * <code>params</code>, <code>false</code> otherwise. 157 * 158 * <p>Arrays are guaranteed to be the same length.</p> 159 */ 160 private boolean compatible(Class[] params, Class[] args) 161 { 162 for (int i = 0; i < params.length; i++) 163 { 164 // Argument types are derived from argument values. If one of them was 165 // null then we cannot deduce its type. However null can be assigned to 166 // any type. 167 if (args[i] == null) 168 continue; 169 170 // Treat Integer like int if appropriate 171 Class nativeType = unwrap(args[i]); 172 if (nativeType != null && params[i].isPrimitive() 173 && params[i].isAssignableFrom(nativeType)) 174 continue; 175 if (params[i].isAssignableFrom(args[i])) 176 continue; 177 178 return false; 179 } 180 return true; 181 } 182 183 /** 184 * Returns <code>true</code> if the method arguments in first are 185 * more specific than the method arguments in second, i.e. all 186 * arguments in <code>first</code> can be assigned to those in 187 * <code>second</code>. 188 * 189 * <p>A method is more specific if all parameters can also be fed to 190 * the less specific method, because, e.g. the less specific method 191 * accepts a base class of the equivalent argument for the more 192 * specific one.</p> 193 * 194 * @param first a <code>Class[]</code> value 195 * @param second a <code>Class[]</code> value 196 * @return a <code>boolean</code> value 197 */ 198 private boolean moreSpecific(Class[] first, Class[] second) 199 { 200 for (int j=0; j < first.length; j++) 201 { 202 if (second[j].isAssignableFrom(first[j])) 203 continue; 204 return false; 205 } 206 return true; 207 } 208 209 final Object doExecute() throws Exception 210 { 211 Class klazz = (target instanceof Class) 212 ? (Class) target : target.getClass(); 213 Object args[] = (arguments == null) ? new Object[0] : arguments; 214 Class argTypes[] = new Class[args.length]; 215 216 // Retrieve type or use null if the argument is null. The null argument 217 // type is later used in compatible(). 218 for (int i = 0; i < args.length; i++) 219 argTypes[i] = (args[i] != null) ? args[i].getClass() : null; 220 221 if (target.getClass().isArray()) 222 { 223 // FIXME: invoke may have to be used. For now, cast to Number 224 // and hope for the best. If caller didn't behave, we go boom 225 // and throw the exception. 226 if (methodName.equals("get") && argTypes.length == 1) 227 return Array.get(target, ((Number)args[0]).intValue()); 228 if (methodName.equals("set") && argTypes.length == 2) 229 { 230 Object obj = Array.get(target, ((Number)args[0]).intValue()); 231 Array.set(target, ((Number)args[0]).intValue(), args[1]); 232 return obj; 233 } 234 throw new NoSuchMethodException("No matching method for statement " + toString()); 235 } 236 237 // If we already cached the method, just use it. 238 if (method != null) 239 return method.invoke(target, args); 240 else if (ctor != null) 241 return ctor.newInstance(args); 242 243 // Find a matching method to call. JDK seems to go through all 244 // this to find the method to call. 245 246 // if method name or length don't match, skip 247 // Need to go through each arg 248 // If arg is wrapper - check if method arg is matchable builtin 249 // or same type or super 250 // - check that method arg is same or super 251 252 if (methodName.equals("new") && target instanceof Class) 253 { 254 Constructor ctors[] = klazz.getConstructors(); 255 for (int i = 0; i < ctors.length; i++) 256 { 257 // Skip methods with wrong number of args. 258 Class ptypes[] = ctors[i].getParameterTypes(); 259 260 if (ptypes.length != args.length) 261 continue; 262 263 // Check if method matches 264 if (!compatible(ptypes, argTypes)) 265 continue; 266 267 // Use method[i] if it is more specific. 268 // FIXME: should this check both directions and throw if 269 // neither is more specific? 270 if (ctor == null) 271 { 272 ctor = ctors[i]; 273 continue; 274 } 275 Class mptypes[] = ctor.getParameterTypes(); 276 if (moreSpecific(ptypes, mptypes)) 277 ctor = ctors[i]; 278 } 279 if (ctor == null) 280 throw new InstantiationException("No matching constructor for statement " + toString()); 281 return ctor.newInstance(args); 282 } 283 284 Method methods[] = klazz.getMethods(); 285 286 for (int i = 0; i < methods.length; i++) 287 { 288 // Skip methods with wrong name or number of args. 289 if (!methods[i].getName().equals(methodName)) 290 continue; 291 Class ptypes[] = methods[i].getParameterTypes(); 292 if (ptypes.length != args.length) 293 continue; 294 295 // Check if method matches 296 if (!compatible(ptypes, argTypes)) 297 continue; 298 299 // Use method[i] if it is more specific. 300 // FIXME: should this check both directions and throw if 301 // neither is more specific? 302 if (method == null) 303 { 304 method = methods[i]; 305 continue; 306 } 307 Class mptypes[] = method.getParameterTypes(); 308 if (moreSpecific(ptypes, mptypes)) 309 method = methods[i]; 310 } 311 if (method == null) 312 throw new NoSuchMethodException("No matching method for statement " + toString()); 313 314 // If we were calling Class.forName(String) we intercept and call the 315 // forName-variant that allows a ClassLoader argument. We take the 316 // system classloader (aka application classloader) here to make sure 317 // that application defined classes can be resolved. If we would not 318 // do that the Class.forName implementation would use the class loader 319 // of java.beans.Statement which is <null> and cannot resolve application 320 // defined classes. 321 if (method.equals( 322 Class.class.getMethod("forName", new Class[] { String.class }))) 323 return Class.forName( 324 (String) args[0], true, ClassLoader.getSystemClassLoader()); 325 326 try { 327 return method.invoke(target, args); 328 } catch(IllegalArgumentException iae){ 329 System.err.println("method: " + method); 330 331 for(int i=0;i<args.length;i++){ 332 System.err.println("args[" + i + "]: " + args[i]); 333 } 334 throw iae; 335 } 336 } 337 338 339 340 /** Return the statement arguments. */ 341 public Object[] getArguments() { return arguments; } 342 343 /** Return the statement method name. */ 344 public String getMethodName() { return methodName; } 345 346 /** Return the statement object. */ 347 public Object getTarget() { return target; } 348 349 /** 350 * Returns a string representation of this <code>Statement</code>. 351 * 352 * @return A string representation of this <code>Statement</code>. 353 */ 354 public String toString() 355 { 356 StringBuffer result = new StringBuffer(); 357 358 String targetName; 359 if (target != null) 360 targetName = target.getClass().getSimpleName(); 361 else 362 targetName = "null"; 363 364 result.append(targetName); 365 result.append("."); 366 result.append(methodName); 367 result.append("("); 368 369 String sep = ""; 370 for (int i = 0; i < arguments.length; i++) 371 { 372 result.append(sep); 373 result.append( 374 ( arguments[i] == null ) ? "null" : 375 ( arguments[i] instanceof String ) ? "\"" + arguments[i] + "\"" : 376 arguments[i].getClass().getSimpleName()); 377 sep = ", "; 378 } 379 result.append(");"); 380 381 return result.toString(); 382 } 383 384 }