/**
* @return a reference to the public static serializableInstance() method of clazz, if there is
* one; otherwise, returns null.
*/
private Method serializableInstanceMethod(Class clazz) {
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if ("serializableInstance".equals(method.getName())) {
Class[] parameterTypes = method.getParameterTypes();
if (!(parameterTypes.length == 0)) {
continue;
}
if (!(Modifier.isStatic(method.getModifiers()))) {
continue;
}
if (Modifier.isAbstract(method.getModifiers())) {
continue;
}
return method;
}
}
return null;
}
/**
* Returns all public methods declared by the specified class. This excludes inherited methods.
*
* @param clazz the class from which to pull public declared methods
* @return the public methods declared in the specified class
* @see Class#getDeclaredMethods()
*/
static Method[] getMethodList(Class clazz) {
Method[] methods = null;
try {
// getDeclaredMethods may be rejected by the security manager
// but getMethods is more expensive
if (!sawSecurityException) {
methods = clazz.getDeclaredMethods();
}
} catch (SecurityException e) {
// If we get an exception once, give up on getDeclaredMethods
sawSecurityException = true;
}
if (methods == null) {
methods = clazz.getMethods();
}
int count = 0;
for (int i = 0; i < methods.length; i++) {
if (sawSecurityException
? methods[i].getDeclaringClass() != clazz
: !Modifier.isPublic(methods[i].getModifiers())) {
methods[i] = null;
} else {
count++;
}
}
Method[] result = new Method[count];
int j = 0;
for (int i = 0; i < methods.length; i++) {
if (methods[i] != null) {
result[j++] = methods[i];
}
}
return result;
}
static <T> T set(Class<T> interf, Object value) {
Properties p = new Properties();
Method ms[] = interf.getMethods();
for (Method m : ms) {
p.put(m.getName(), value);
}
return Configurable.createConfigurable(interf, (Map<Object, Object>) p);
}
/**
* This function returns the check_modified method from the class type provided.
*
* @param theClass the class in which to find the check_modified method
* @return the check_modified method if it exists
* @throws RuntimeException if check_modified does not exist.
*/
private static Method getCheckModified(Class<? extends Invariant> theClass) {
Method[] methods = theClass.getMethods();
Method currentMethod;
for (int i = 0; i < methods.length; i++) {
currentMethod = methods[i];
if (currentMethod.getName().lastIndexOf("check_modified")
!= -1) { // Method should be called check_modified
return currentMethod;
}
}
throw new RuntimeException("Cannot find check_modified method");
}
/**
* @return the method of invariant named by theClass that produces a String representation of
* the invariant.
*/
private static Method getOutputProducer(Class<? extends Invariant> theClass) {
Method[] methods = theClass.getMethods();
Method currentMethod;
for (int i = 0; i < methods.length; i++) {
currentMethod = methods[i];
// Method should be called format_using
if (currentMethod.getName().lastIndexOf("format_using") != -1) {
return currentMethod;
}
}
throw new RuntimeException("Cannot find format_using method");
}
public AnnotatedClass(Class clazz) {
this.clazz = clazz;
this.className = clazz.getName();
this.initialize();
try {
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if (method.isAnnotationPresent(RequestMapping.class)) {
this.listOfMethods.add(new AnnotatedMethod(method, this.path));
}
}
} catch (NoClassDefFoundError error) {
System.err.println("No Class Def Found Error: " + className);
}
}
public static void invokeSetMethodCaseInsensitive(Object obj, String prop, String value)
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
String alternateMethodName = null;
Class cl = obj.getClass();
String setMeth = "set" + prop;
Method[] methodsList = cl.getMethods();
boolean methodFound = false;
int i = 0;
for (i = 0; i < methodsList.length; ++i) {
if (methodsList[i].getName().equalsIgnoreCase(setMeth) == true) {
Class[] parameterTypes = methodsList[i].getParameterTypes();
if (parameterTypes.length == 1) {
if (parameterTypes[0].getName().equals("java.lang.String")) {
methodFound = true;
break;
} else alternateMethodName = methodsList[i].getName();
}
}
}
if (methodFound == true) {
Object[] params = {value};
methodsList[i].invoke(obj, params);
return;
}
if (alternateMethodName != null) {
try {
// try int method
Class[] cldef = {Integer.TYPE};
Method meth = cl.getMethod(alternateMethodName, cldef);
Object[] params = {Integer.valueOf(value)};
meth.invoke(obj, params);
return;
} catch (NoSuchMethodException nsmex) {
// try boolean method
Class[] cldef = {Boolean.TYPE};
Method meth = cl.getMethod(alternateMethodName, cldef);
Object[] params = {Boolean.valueOf(value)};
meth.invoke(obj, params);
return;
}
} else throw new NoSuchMethodException(setMeth);
}
//
// Return the methods of an interface in a deterministic
// order. Class.getMethods() does not do us this favor.
//
private Method[] sortMethods(Class iface) throws Exception {
Method[] raw = iface.getMethods();
int count = raw.length;
Method[] cooked = new Method[count];
MethodSortable[] sortables = new MethodSortable[count];
for (int i = 0; i < count; i++) {
sortables[i] = new MethodSortable(raw[i]);
}
Arrays.sort(sortables);
for (int i = 0; i < count; i++) {
cooked[i] = sortables[i].getMethod();
}
return cooked;
}
private DependencyAnnotations createDependencyAnnotations(Class ruleClass) {
DependencyAnnotations da = new DependencyAnnotations();
for (Method m : ruleClass.getMethods()) {
Consumes consumes = m.getAnnotation(Consumes.class);
if (consumes != null) {
// System.out.println("Adding consumes "+m.getName());
da.addConsumesMethod(consumes.value(), m);
} else {
Provides provides = m.getAnnotation(Provides.class);
if (provides != null) {
// System.out.println("Adding provides "+m.getName());
da.addProvidesMethod(provides.value(), m);
}
}
}
return da;
}
/**
* Enumerate the methods of the Clob interface and get the list of methods present in the
* interface
*
* @param LOB an instance of the Clob interface implementation
*/
void buildMethodList(Object LOB) throws IllegalAccessException, InvocationTargetException {
// If the given method throws the correct exception
// set this to true and add it to the
boolean valid = true;
// create a list of the methods that fail the test
Vector<Method> methodList = new Vector<Method>();
// The class whose methods are to be verified
Class clazz = Clob.class;
// The list of the methods in the class that need to be invoked
// and verified
Method[] methods = clazz.getMethods();
// Check each of the methods to ensure that
// they throw the required exception
for (int i = 0; i < methods.length; i++) {
if (!checkIfExempted(methods[i])) {
valid = checkIfMethodThrowsSQLException(LOB, methods[i]);
// add the method to the list if the method does
// not throw the required exception
if (valid == false) methodList.add(methods[i]);
// reset valid
valid = true;
}
}
if (!methodList.isEmpty()) {
int c = 0;
String failureMessage = "The Following methods don't throw " + "required exception - ";
for (Method m : methodList) {
c = c + 1;
if (c == methodList.size() && c != 1) failureMessage += " & ";
else if (c != 1) failureMessage += " , ";
failureMessage += m.getName();
}
fail(failureMessage);
}
}
public boolean handleCommand(String line, PrintWriter out) {
String[] split = line.split("[\t ]");
String commandName = split[0];
try {
Method[] methods = exportedInterface.getMethods();
for (Method method : methods) {
if (method.getName().equals(commandName) && method.getReturnType() == void.class) {
return invokeMethod(line, out, method, split);
}
}
throw new NoSuchMethodException();
} catch (NoSuchMethodException nsmex) {
out.println(fullName + ": didn't understand request \"" + line + "\".");
} catch (Exception ex) {
Log.warn(fullName + ": exception thrown while handling command \"" + line + "\".", ex);
out.println(fullName + ": request denied \"" + line + "\" (" + ex.toString() + ").");
} finally {
out.flush();
out.close();
}
return false;
}
/**
* Construct a client-side proxy that implements the named protocol, talking to a server at the
* named address.
*
* @param protocol protocol
* @param clientVersion client's version
* @param addr server address
* @param ticket security ticket
* @param conf configuration
* @param factory socket factory
* @param rpcTimeout max time for each rpc; 0 means no timeout
* @return the proxy
* @throws IOException if any error occurs
*/
@SuppressWarnings("unchecked")
public static <T extends VersionedProtocol> ProtocolProxy<T> getProtocolProxy(
Class<T> protocol,
long clientVersion,
InetSocketAddress addr,
UserGroupInformation ticket,
Configuration conf,
SocketFactory factory,
int rpcTimeout)
throws IOException {
T proxy =
(T)
Proxy.newProxyInstance(
protocol.getClassLoader(),
new Class[] {protocol},
new Invoker(addr, ticket, conf, factory, rpcTimeout, protocol));
String protocolName = protocol.getName();
try {
ProtocolSignature serverInfo =
proxy.getProtocolSignature(
protocolName, clientVersion, ProtocolSignature.getFingerprint(protocol.getMethods()));
return new ProtocolProxy<T>(protocol, proxy, serverInfo.getMethods());
} catch (RemoteException re) {
IOException ioe = re.unwrapRemoteException(IOException.class);
if (ioe.getMessage()
.startsWith(IOException.class.getName() + ": " + NoSuchMethodException.class.getName())) {
// Method getProtocolSignature not supported
long serverVersion = proxy.getProtocolVersion(protocol.getName(), clientVersion);
if (serverVersion == clientVersion) {
return new ProtocolProxy<T>(protocol, proxy, null);
}
throw new VersionMismatch(protocolName, clientVersion, serverVersion, proxy);
}
throw re;
}
}
/**
* Given class of the interface for a fluid engine, build a concrete instance of that interface
* that calls back into a Basic Engine for all methods in the interface.
*/
private static BasicEngine buildCallbackEngine(String engineInterface, Class cEngine) {
// build up list of callbacks for <engineInterface>
StringBuffer decls = new StringBuffer();
Method[] engineMethods = cEngine.getMethods();
for (int i = 0; i < engineMethods.length; i++) {
Method meth = engineMethods[i];
// skip methods that aren't declared in the interface
if (meth.getDeclaringClass() != cEngine) {
continue;
}
decls.append(
" public " + Utils.asTypeDecl(meth.getReturnType()) + " " + meth.getName() + "(");
Class[] params = meth.getParameterTypes();
for (int j = 0; j < params.length; j++) {
decls.append(Utils.asTypeDecl(params[j]) + " p" + j);
if (j != params.length - 1) {
decls.append(", ");
}
}
decls.append(") {\n");
decls.append(
" return ("
+ Utils.asTypeDecl(meth.getReturnType())
+ ")super.callNative(\""
+ meth.getName()
+ "\", new Object[] {");
for (int j = 0; j < params.length; j++) {
decls.append("p" + j);
if (j != params.length - 1) {
decls.append(", ");
}
}
decls.append("} );\n");
decls.append(" }\n\n");
}
// write template file
String engineName = "BasicEngine_" + engineInterface;
String fileName = engineName + ".java";
try {
String contents = Utils.readFile("lava/engine/basic/BasicEngineTemplate.java").toString();
// remove package name
contents = Utils.replaceAll(contents, "package lava.engine.basic;", "");
// for class decl
contents =
Utils.replaceAll(
contents, "extends BasicEngine", "extends BasicEngine implements " + engineInterface);
// for constructor
contents = Utils.replaceAll(contents, "BasicEngineTemplate", engineName);
// for methods
contents = Utils.replaceAll(contents, "// INSERT METHODS HERE", decls.toString());
Utils.writeFile(fileName, contents);
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
// compile the file
try {
Process jProcess = Runtime.getRuntime().exec("jikes " + fileName, null, null);
jProcess.waitFor();
} catch (Exception e) {
System.err.println("Error compiling auto-generated file " + fileName);
e.printStackTrace();
System.exit(1);
}
// instantiate the class
BasicEngine result = null;
try {
result = (BasicEngine) Class.forName(engineName).newInstance();
// cleanup the files we made
new File(engineName + ".java").delete();
new File(engineName + ".class").delete();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
return result;
}
/* methods that take an EventListener Class Type to create an EventAdapterClass */
public static Class makeEventAdapterClass(Class listenerType, boolean writeClassFile) {
DebugLog.stdoutPrintln("EventAdapterGenerator", DebugLog.BSF_LOG_L3);
if (EVENTLISTENER.isAssignableFrom(listenerType)) {
boolean exceptionable = false;
boolean nonExceptionable = false;
byte constantPool[] = null;
short cpBaseIndex;
short cpCount = 0;
short cpExceptionBaseIndex;
short exceptionableCount;
short nonExceptionableCount;
/* Derive Names */
String listenerTypeName = listenerType.getName();
DebugLog.stdoutPrintln(" ListenerTypeName: " + listenerTypeName, DebugLog.BSF_LOG_L3);
String adapterClassName =
CLASSPACKAGE
+ (listenerTypeName.endsWith("Listener")
? listenerTypeName.substring(0, listenerTypeName.length() - 8)
: listenerTypeName)
.replace('.', '_')
+ "Adapter";
String finalAdapterClassName = adapterClassName;
Class cached = null;
int suffixIndex = 0;
do {
if (null != (cached = ldr.getLoadedClass(finalAdapterClassName))) {
DebugLog.stdoutPrintln("cached: " + cached, DebugLog.BSF_LOG_L3);
try {
if (!listenerType.isAssignableFrom(cached))
finalAdapterClassName = adapterClassName + "_" + suffixIndex++;
else return cached;
} catch (VerifyError ex) {
System.err.println(ex.getMessage());
ex.printStackTrace();
return cached;
}
}
} while (cached != null);
String eventListenerName = listenerTypeName.replace('.', '/');
/* method stuff */
java.lang.reflect.Method lms[] = listenerType.getMethods();
/* ****************************************************************************************** */
// Listener interface
// Class name
cpCount += 4;
// cp item 17
constantPool = Bytecode.addUtf8(constantPool, eventListenerName);
// cp item 18
constantPool = Bytecode.addUtf8(constantPool, finalAdapterClassName);
// cp item 19
constantPool = Bytecode.addClass(constantPool, (short) 17);
// cp item 20
constantPool = Bytecode.addClass(constantPool, (short) 18);
// do we have nonExceptionalble event, exceptionable or both
for (int i = 0; i < lms.length; ++i) {
Class exceptionTypes[] = lms[i].getExceptionTypes();
if (0 < exceptionTypes.length) {
exceptionable = true;
} else {
nonExceptionable = true;
}
} /* End for*/
/* ****************************************************************************************** */
// optional inclusion of nonexceptional events affects exceptional events indices
nonExceptionableCount = 0;
if (nonExceptionable) {
nonExceptionableCount = 3;
cpCount += nonExceptionableCount;
// cp item 21
constantPool = Bytecode.addUtf8(constantPool, "processEvent");
// cp item 22
constantPool = Bytecode.addNameAndType(constantPool, (short) 21, (short) 8);
// cp item 23
constantPool = Bytecode.addInterfaceMethodRef(constantPool, (short) 12, (short) 22);
}
/* ****************************************************************************************** */
// optional inclusion of exceptional events affects CP Items which follow for specific methods
exceptionableCount = 0;
if (exceptionable) {
int classIndex = BASECPCOUNT + cpCount + 1;
int nameIndex = BASECPCOUNT + cpCount + 0;
int natIndex = BASECPCOUNT + cpCount + 3;
exceptionableCount = 5;
cpCount += exceptionableCount;
// cp item 24 or 21
constantPool = Bytecode.addUtf8(constantPool, "processExceptionableEvent");
// cp item 25 or 22
constantPool = Bytecode.addUtf8(constantPool, "java/lang/Exception");
// cp item 26 or 23
constantPool = Bytecode.addClass(constantPool, (short) classIndex);
// cp item 27 or 24
constantPool = Bytecode.addNameAndType(constantPool, (short) nameIndex, (short) 8);
// cp item 28 or 25
constantPool = Bytecode.addInterfaceMethodRef(constantPool, (short) 12, (short) natIndex);
}
// base index for method cp references
cpBaseIndex = (short) (BASECPCOUNT + cpCount);
DebugLog.stderrPrintln("cpBaseIndex: " + cpBaseIndex, DebugLog.BSF_LOG_L3);
for (int i = 0; i < lms.length; ++i) {
String eventMethodName = lms[i].getName();
String eventName = lms[i].getParameterTypes()[0].getName().replace('.', '/');
cpCount += 3;
// cp items for event methods
constantPool = Bytecode.addUtf8(constantPool, eventMethodName);
constantPool = Bytecode.addUtf8(constantPool, ("(L" + eventName + ";)V"));
constantPool = Bytecode.addString(constantPool, (short) (BASECPCOUNT + cpCount - 3));
} /* End for*/
boolean propertyChangeFlag[] = new boolean[lms.length];
int cpIndexPCE = 0;
for (int i = 0; i < lms.length; ++i) {
String eventName = lms[i].getParameterTypes()[0].getName().replace('.', '/');
// cp items for PropertyChangeEvent special handling
if (eventName.equalsIgnoreCase("java/beans/PropertyChangeEvent")) {
propertyChangeFlag[i] = true;
if (0 == cpIndexPCE) {
constantPool = Bytecode.addUtf8(constantPool, eventName);
constantPool = Bytecode.addUtf8(constantPool, "getPropertyName");
constantPool = Bytecode.addUtf8(constantPool, "()Ljava/lang/String;");
constantPool = Bytecode.addClass(constantPool, (short) (BASECPCOUNT + cpCount));
constantPool =
Bytecode.addNameAndType(
constantPool,
(short) (BASECPCOUNT + cpCount + 1),
(short) (BASECPCOUNT + cpCount + 2));
constantPool =
Bytecode.addMethodRef(
constantPool,
(short) (BASECPCOUNT + cpCount + 3),
(short) (BASECPCOUNT + cpCount + 4));
cpCount += 6;
cpIndexPCE = BASECPCOUNT + cpCount - 1;
}
} else {
propertyChangeFlag[i] = false;
}
} /* End for*/
cpExceptionBaseIndex = (short) (BASECPCOUNT + cpCount);
DebugLog.stderrPrintln("cpExceptionBaseIndex: " + cpExceptionBaseIndex, DebugLog.BSF_LOG_L3);
int excpIndex[][] = new int[lms.length][];
for (int i = 0; i < lms.length; ++i) {
Class exceptionTypes[] = lms[i].getExceptionTypes();
excpIndex[i] = new int[exceptionTypes.length];
for (int j = 0; j < exceptionTypes.length; j++) {
constantPool =
Bytecode.addUtf8(constantPool, exceptionTypes[j].getName().replace('.', '/'));
constantPool = Bytecode.addClass(constantPool, (short) (BASECPCOUNT + cpCount));
excpIndex[i][j] = BASECPCOUNT + cpCount + 1;
cpCount += 2;
}
} /* End for*/
/* end constant pool */
/* ************************************************************************************************ */
// put the Class byte array together
/* start */
byte newClass[] = CLASSHEADER; // magic, version (fixed)
short count = (short) (BASECPCOUNT + cpCount);
newClass = ByteUtility.addBytes(newClass, count); // constant_pool_count (variable)
newClass = ByteUtility.addBytes(newClass, BASECP); // constant_pool (fixed)
newClass = ByteUtility.addBytes(newClass, constantPool); // constant_pool (variable)
newClass = ByteUtility.addBytes(newClass, FIXEDCLASSBYTES); // see FIXEDCLASSBYTES (fixed)
newClass =
ByteUtility.addBytes(
newClass, (short) (lms.length + 1)); // method_count (variable)
newClass = ByteUtility.addBytes(newClass, INITMETHOD); // constructor <init> (fixed)
// methods
/* ****************************************************************************************** */
/* loop over listener methods from listenerType */
for (int i = 0; i < lms.length; ++i) {
newClass = ByteUtility.addBytes(newClass, (short) 1); // access_flags (fixed)
newClass =
ByteUtility.addBytes(
newClass, (short) (cpBaseIndex + 3 * i + 0)); // name_index (variable)
newClass =
ByteUtility.addBytes(
newClass, (short) (cpBaseIndex + 3 * i + 1)); // descriptor_index (variable)
newClass = ByteUtility.addBytes(newClass, (short) 1); // attribute_count (fixed)
newClass = ByteUtility.addBytes(newClass, (short) 3); // attribute_name_index code(fixed)
// Code Attribute Length
int length = 32;
if (0 < excpIndex[i].length) {
length += 5 + 8 * (1 + excpIndex[i].length);
}
if (propertyChangeFlag[i]) {
length += 2;
}
newClass =
ByteUtility.addBytes(newClass, (long) length); // attribute_length (variable)
// start code attribute
newClass = ByteUtility.addBytes(newClass, (short) 6); // max_stack (fixed)
newClass = ByteUtility.addBytes(newClass, (short) 3); // max_locals (fixed)
// Code Length
length = 20;
if (exceptionable && 0 < excpIndex[i].length) {
length += 5;
}
if (propertyChangeFlag[i]) {
length += 2;
}
newClass =
ByteUtility.addBytes(newClass, (long) length); // code_length (variable)
// start code
newClass = ByteUtility.addBytes(newClass, (byte) 0x2A); // aload_0 (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0xB4); // getfield (fixed)
newClass = ByteUtility.addBytes(newClass, (short) 15); // index (fixed)
if (propertyChangeFlag[i]) { // the propertyName is passed as the first parameter
newClass =
ByteUtility.addBytes(newClass, (byte) 0x2B); // aload_1 (fixed)
newClass =
ByteUtility.addBytes(newClass, (byte) 0xB6); // invokevirtual (fixed)
newClass =
ByteUtility.addBytes(
newClass, (short) cpIndexPCE); // methodref (variable)
} else { // the eventMethodName is passed as the first parameter
// Target for method invocation.
newClass = ByteUtility.addBytes(newClass, (byte) 0x12); // ldc (fixed)
newClass =
ByteUtility.addBytes(
newClass, (byte) (cpBaseIndex + 3 * i + 2)); // index (byte) (variable)
}
newClass = ByteUtility.addBytes(newClass, (byte) 0x04); // iconst_1 (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0xBD); // anewarray (fixed)
newClass = ByteUtility.addBytes(newClass, (short) 10); // Class java/lang/Object (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0x59); // dup (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0x03); // iconst_0 (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0x2B); // aload_1 (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0x53); // aastore (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0xB9); // invokeinterface (fixed)
// index to processEvent or processExceptionableEvent method
length = 23; // actually an index into cp
if (exceptionable && nonExceptionable) { // interface method index
if (0 < lms[i].getExceptionTypes().length) {
length += 5;
}
} else if (exceptionable) {
length += 2;
}
newClass =
ByteUtility.addBytes(newClass, (short) length); // index (process??????...) (variable)
newClass = ByteUtility.addBytes(newClass, (byte) 0x03); // iconst_0 (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0x00); // noop (fixed)
newClass = ByteUtility.addBytes(newClass, (byte) 0xB1); // return (fixed)
if (exceptionable && 0 < excpIndex[i].length) { // exception code
newClass =
ByteUtility.addBytes(newClass, (byte) 0x4D); // astore_2 (fixed)
newClass =
ByteUtility.addBytes(newClass, (byte) 0x2C); // aload_2 (fixed)
newClass =
ByteUtility.addBytes(newClass, (byte) 0xBF); // athrow (fixed)
newClass =
ByteUtility.addBytes(newClass, (byte) 0x57); // pop (fixed)
newClass =
ByteUtility.addBytes(newClass, (byte) 0xB1); // return (fixed)
// end code
// exception table
length = excpIndex[i].length;
newClass =
ByteUtility.addBytes(
newClass, (short) (1 + length)); // exception_table_length (variable)
for (int j = 0; j < length; j++) { // catch exception types and rethrow
newClass =
ByteUtility.addBytes(newClass, (short) 0); // start_pc (fixed)
if (propertyChangeFlag[i]) {
newClass =
ByteUtility.addBytes(newClass, (short) 21); // end_pc (fixed)
newClass =
ByteUtility.addBytes(newClass, (short) 22); // handler_pc (fixed)
} else {
newClass =
ByteUtility.addBytes(newClass, (short) 19); // end_pc (fixed)
newClass =
ByteUtility.addBytes(newClass, (short) 20); // handler_pc (fixed)
}
newClass =
ByteUtility.addBytes(
newClass, (short) excpIndex[i][j]); // catch_type (variable)
}
// catch "exception" and trap it
newClass = ByteUtility.addBytes(newClass, (short) 0); // start_pc (fixed)
if (propertyChangeFlag[i]) {
newClass =
ByteUtility.addBytes(newClass, (short) 21); // end_pc (fixed)
newClass =
ByteUtility.addBytes(newClass, (short) 25); // handler_pc (fixed)
} else {
newClass =
ByteUtility.addBytes(newClass, (short) 19); // end_pc (fixed)
newClass =
ByteUtility.addBytes(newClass, (short) 23); // handler_pc (fixed)
}
if (nonExceptionable) {
newClass = ByteUtility.addBytes(newClass, (short) 26);
} // catch_type (fixed)
else // or
{
newClass = ByteUtility.addBytes(newClass, (short) 23);
} // catch_type (fixed)
} else {
newClass = ByteUtility.addBytes(newClass, (short) 0);
} // exception_table_length (fixed)
// attributes on the code attribute (none)
newClass = ByteUtility.addBytes(newClass, (short) 0); // attribute_count (fixed)
// end code attribute
} /* End for*/
// Class Attributes (none for this)
newClass = ByteUtility.addBytes(newClass, (short) 0); // attribute_count (fixed)
/* done */
DebugLog.stdoutPrintln("adapterName: " + finalAdapterClassName, DebugLog.BSF_LOG_L3);
DebugLog.stdoutPrintln(
"cpCount: " + count + " = " + BASECPCOUNT + " + " + cpCount, DebugLog.BSF_LOG_L3);
DebugLog.stdoutPrintln("methodCount: " + (lms.length + 1), DebugLog.BSF_LOG_L3);
// output to disk class file
/* ****************************************************************************************** */
// now create the class and load it
// return the Class.
if (writeClassFile) {
try {
FileOutputStream fos =
new FileOutputStream(WRITEDIRECTORY + finalAdapterClassName + ".class");
fos.write(newClass);
fos.close();
} catch (IOException ex) {
System.err.println(ex.getMessage());
ex.printStackTrace();
}
try {
Class ret = ldr.loadClass(finalAdapterClassName);
DebugLog.stdoutPrintln(
"EventAdapterGenerator: " + ret.getName() + " dynamically generated",
DebugLog.BSF_LOG_L3);
return ret;
} catch (ClassNotFoundException ex) {
System.err.println(ex.getMessage());
ex.printStackTrace();
}
}
try {
Class ret = ldr.defineClass(finalAdapterClassName, newClass);
DebugLog.stdoutPrintln(
"EventAdapterGenerator: " + ret.getName() + " dynamically generated",
DebugLog.BSF_LOG_L3);
return ret;
} catch (Exception ex) {
System.err.println(ex.getMessage());
ex.printStackTrace();
}
} else {
System.err.println(
"EventAdapterGenerator ListenerType invalid: listenerType = " + listenerType);
}
return null;
}
/**
* Derive a ranking based on how "natural" the conversion is. The special value CONVERSION_NONE
* means no conversion is possible, and CONVERSION_NONTRIVIAL signals that more type conformance
* testing is required. Based on <a
* href="http://www.mozilla.org/js/liveconnect/lc3_method_overloading.html">"preferred method
* conversions" from Live Connect 3</a>
*/
static int getConversionWeight(Object fromObj, Class<?> to) {
int fromCode = getJSTypeCode(fromObj);
switch (fromCode) {
case JSTYPE_UNDEFINED:
if (to == ScriptRuntime.StringClass || to == ScriptRuntime.ObjectClass) {
return 1;
}
break;
case JSTYPE_NULL:
if (!to.isPrimitive()) {
return 1;
}
break;
case JSTYPE_BOOLEAN:
// "boolean" is #1
if (to == Boolean.TYPE) {
return 1;
} else if (to == ScriptRuntime.BooleanClass) {
return 2;
} else if (to == ScriptRuntime.ObjectClass) {
return 3;
} else if (to == ScriptRuntime.StringClass) {
return 4;
}
break;
case JSTYPE_NUMBER:
if (to.isPrimitive()) {
if (to == Double.TYPE) {
return 1;
} else if (to != Boolean.TYPE) {
return 1 + getSizeRank(to);
}
} else {
if (to == ScriptRuntime.StringClass) {
// native numbers are #1-8
return 9;
} else if (to == ScriptRuntime.ObjectClass) {
return 10;
} else if (ScriptRuntime.NumberClass.isAssignableFrom(to)) {
// "double" is #1
return 2;
}
}
break;
case JSTYPE_STRING:
if (to == ScriptRuntime.StringClass) {
return 1;
} else if (to.isInstance(fromObj)) {
return 2;
} else if (to.isPrimitive()) {
if (to == Character.TYPE) {
return 3;
} else if (to != Boolean.TYPE) {
return 4;
}
}
break;
case JSTYPE_JAVA_CLASS:
if (to == ScriptRuntime.ClassClass) {
return 1;
} else if (to == ScriptRuntime.ObjectClass) {
return 3;
} else if (to == ScriptRuntime.StringClass) {
return 4;
}
break;
case JSTYPE_JAVA_OBJECT:
case JSTYPE_JAVA_ARRAY:
Object javaObj = fromObj;
if (javaObj instanceof Wrapper) {
javaObj = ((Wrapper) javaObj).unwrap();
}
if (to.isInstance(javaObj)) {
return CONVERSION_NONTRIVIAL;
}
if (to == ScriptRuntime.StringClass) {
return 2;
} else if (to.isPrimitive() && to != Boolean.TYPE) {
return (fromCode == JSTYPE_JAVA_ARRAY) ? CONVERSION_NONE : 2 + getSizeRank(to);
}
break;
case JSTYPE_OBJECT:
// Other objects takes #1-#3 spots
if (to == fromObj.getClass()) {
// No conversion required
return 1;
}
if (to.isArray()) {
if (fromObj instanceof NativeArray) {
// This is a native array conversion to a java array
// Array conversions are all equal, and preferable to object
// and string conversion, per LC3.
return 1;
}
} else if (to == ScriptRuntime.ObjectClass) {
return 2;
} else if (to == ScriptRuntime.StringClass) {
return 3;
} else if (to == ScriptRuntime.DateClass) {
if (fromObj instanceof NativeDate) {
// This is a native date to java date conversion
return 1;
}
} else if (to.isInterface()) {
if (fromObj instanceof Function) {
// See comments in coerceType
if (to.getMethods().length == 1) {
return 1;
}
}
return 11;
} else if (to.isPrimitive() && to != Boolean.TYPE) {
return 3 + getSizeRank(to);
}
break;
}
return CONVERSION_NONE;
}