| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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. |
| */ |
| |
| |
| /* |
| 2015-01-15, rgf: take into account that a context thread class loader may be null (not set) |
| |
| 2007-09-21: Rony G. Flatscher, new class loading sequence: |
| |
| - Thread's context class loader |
| - BSFManager's defining class loader |
| |
| 2007-01-29: Rony G. Flatscher: added BSF_Log[Factory] to allow BSF to run without org.apache.commons.logging present |
| */ |
| |
| package org.apache.bsf.util.event.generator; |
| |
| import org.apache.bsf.BSF_Log; |
| import org.apache.bsf.BSF_LogFactory; |
| |
| import org.apache.bsf.BSFManager; |
| |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| |
| |
| /** EventAdapterGenerator |
| * |
| * Generate an "Event Adapter" dynamically during program execution |
| * |
| **/ |
| public class EventAdapterGenerator |
| { |
| public static AdapterClassLoader ldr = new AdapterClassLoader(); |
| static Class EVENTLISTENER = null; |
| static String CLASSPACKAGE = "org/apache/bsf/util/event/adapters/"; |
| static String WRITEDIRECTORY = null; |
| |
| // starting 8 bytes of all Java Class files |
| static byte CLASSHEADER[]; |
| // constant pool items found in all event adapters |
| static short BASECPCOUNT; // number of cp items + 1 ( cp item # 0 reserved for JVM ) |
| static byte BASECP[]; // |
| // some bytes in the middle of the class file (see below) |
| static byte FIXEDCLASSBYTES[]; |
| // the initialization method, noargs constructor |
| static byte INITMETHOD[]; |
| |
| private static BSF_Log logger=null; |
| |
| /* The static initializer */ |
| static |
| { |
| // logger = LogFactory.getLog((org.apache.bsf.util.event.generator.EventAdapterGenerator.class).getName()); |
| logger = BSF_LogFactory.getLog((org.apache.bsf.util.event.generator.EventAdapterGenerator.class).getName()); |
| |
| String USERCLASSPACKAGE = System.getProperty("DynamicEventClassPackage", |
| ""); |
| |
| if (!USERCLASSPACKAGE.equals("")) |
| { |
| CLASSPACKAGE = USERCLASSPACKAGE; |
| } |
| |
| if(CLASSPACKAGE.length() > 0 ) |
| { |
| CLASSPACKAGE = CLASSPACKAGE.replace('\\','/'); |
| if(!CLASSPACKAGE.endsWith("/")) |
| { CLASSPACKAGE = CLASSPACKAGE+"/"; } |
| } |
| WRITEDIRECTORY = System.getProperty("DynamicEventClassWriteDirectory",CLASSPACKAGE); |
| if(WRITEDIRECTORY.length() > 0 ) |
| { |
| WRITEDIRECTORY = WRITEDIRECTORY.replace('\\','/'); |
| if(!WRITEDIRECTORY.endsWith("/")) |
| { WRITEDIRECTORY = WRITEDIRECTORY+"/"; } |
| } |
| try |
| // { EVENTLISTENER = Class.forName("java.util.EventListener"); } |
| { |
| // EVENTLISTENER = Thread.currentThread().getContextClassLoader().loadClass ("java.util.EventListener"); // rgf, 2006-01-05 |
| |
| // rgf, 20070917: first try context class loader, then BSFManager's defining class loader |
| EVENTLISTENER=null; |
| ClassLoader tccl=Thread.currentThread().getContextClassLoader(); |
| |
| if (tccl!=null) |
| { |
| try { |
| EVENTLISTENER = tccl.loadClass ("java.util.EventListener"); |
| } |
| catch(ClassNotFoundException ex01) |
| {} |
| } |
| |
| if (EVENTLISTENER==null) // did not work, try to load it via the definedClassLoader |
| { |
| EVENTLISTENER = BSFManager.getDefinedClassLoader().loadClass ("java.util.EventListener"); |
| } |
| |
| } |
| catch(ClassNotFoundException ex) |
| { |
| System.err.println(ex.getMessage()); |
| ex.printStackTrace(); |
| } |
| |
| |
| // start of the Java Class File |
| CLASSHEADER = ByteUtility.addBytes(CLASSHEADER,(byte)0xCA); // magic |
| CLASSHEADER = ByteUtility.addBytes(CLASSHEADER,(byte)0xFE); // magic |
| CLASSHEADER = ByteUtility.addBytes(CLASSHEADER,(byte)0xBA); // magic |
| CLASSHEADER = ByteUtility.addBytes(CLASSHEADER,(byte)0xBE); // magic |
| CLASSHEADER = ByteUtility.addBytes(CLASSHEADER,(short)3); // minor version |
| CLASSHEADER = ByteUtility.addBytes(CLASSHEADER,(short)45); // major version |
| |
| // Start the constant pool for base items in all event adapter classes |
| BASECPCOUNT = 17; // number of cp items + 1 ( cp item # 0 reserved for JVM ) |
| |
| // cp item 01 |
| BASECP = Bytecode.addUtf8(BASECP,"()V"); |
| |
| // cp item 02 |
| BASECP = Bytecode.addUtf8(BASECP,"<init>"); |
| |
| // cp item 03 |
| BASECP = Bytecode.addUtf8(BASECP,"Code"); |
| |
| // cp item 04 |
| BASECP = Bytecode.addUtf8(BASECP,"eventProcessor"); |
| |
| // cp item 05 |
| BASECP = Bytecode.addUtf8(BASECP,"java/lang/Object"); |
| |
| // cp item 06 |
| BASECP = Bytecode.addUtf8(BASECP,"org/apache/bsf/util/event/EventAdapterImpl"); |
| |
| // cp item 07 |
| BASECP = Bytecode.addUtf8(BASECP,"org/apache/bsf/util/event/EventProcessor"); |
| |
| // cp item 08 |
| BASECP = Bytecode.addUtf8(BASECP,"(Ljava/lang/String;[Ljava/lang/Object;)V"); |
| |
| // cp item 09 |
| BASECP = Bytecode.addUtf8(BASECP,"Lorg/apache/bsf/util/event/EventProcessor;"); |
| |
| // cp item 10 |
| BASECP = Bytecode.addClass(BASECP,(short)5); // Class "java/lang/Object" |
| |
| // cp item 11 |
| BASECP = Bytecode.addClass(BASECP,(short)6); // Class "org/apache/bsf/util/event/EventAdapterImpl" |
| |
| // cp item 12 |
| BASECP = Bytecode.addClass(BASECP,(short)7); // Class "org/apache/bsf/util/event/EventProcessor" |
| |
| // cp item 13 |
| BASECP = Bytecode.addNameAndType(BASECP,(short)2,(short)1); // "<init>" "()V" |
| |
| // cp item 14 |
| BASECP = Bytecode.addNameAndType(BASECP,(short)4,(short)9); // "eventProcessor" "Lorg/apache/bsf/util/event/EventProcessor;" |
| |
| // cp item 15 |
| BASECP = Bytecode.addFieldRef(BASECP,(short)11,(short)14); |
| |
| // cp item 16 |
| BASECP = Bytecode.addMethodRef(BASECP,(short)11,(short)13); |
| |
| // fixed bytes in middle of class file |
| FIXEDCLASSBYTES = ByteUtility.addBytes(FIXEDCLASSBYTES,(short)0x21); // access_flags (fixed) |
| FIXEDCLASSBYTES = ByteUtility.addBytes(FIXEDCLASSBYTES,(short)20); // this_class (fixed) |
| FIXEDCLASSBYTES = ByteUtility.addBytes(FIXEDCLASSBYTES,(short)11); // super_class (fixed) |
| FIXEDCLASSBYTES = ByteUtility.addBytes(FIXEDCLASSBYTES,(short)1); // interface_count (fixed) |
| FIXEDCLASSBYTES = ByteUtility.addBytes(FIXEDCLASSBYTES,(short)19); // interfaces (fixed) |
| FIXEDCLASSBYTES = ByteUtility.addBytes(FIXEDCLASSBYTES,(short)0); // field_count (fixed) |
| |
| // initialization method, constructor |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)1); // access_flags |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)2); // name_index "<init>" |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)1); // descriptor_index "()V" |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)1); // attribute_count |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)3); // attribute_name_index "Code" |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(long)17); // attribute_length |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)1); // max_stack |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)1); // max_locals |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(long)5); // code_length |
| //code |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(byte)0x2A); // aload_0 |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(byte)0xB7); // invokespecial |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)16); // method_ref index |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(byte)0xB1); // return |
| // exception table |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)0); // exception_table_length |
| INITMETHOD = ByteUtility.addBytes(INITMETHOD,(short)0); // attributes_count |
| |
| } |
| |
| /* methods that take an EventListener Class Type to create an EventAdapterClass */ |
| public static Class makeEventAdapterClass(Class listenerType,boolean writeClassFile) |
| { |
| logger.debug("EventAdapterGenerator"); |
| |
| 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(); |
| logger.debug("ListenerTypeName: "+listenerTypeName); |
| 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))) |
| { |
| logger.debug("cached: "+cached); |
| 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); |
| logger.debug("cpBaseIndex: " + cpBaseIndex); |
| |
| 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); |
| logger.debug("cpExceptionBaseIndex: " + cpExceptionBaseIndex); |
| |
| 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 */ |
| |
| logger.debug("adapterName: " + finalAdapterClassName); |
| logger.debug("cpCount: " + count + " = " + BASECPCOUNT + " + " + cpCount); |
| logger.debug("methodCount: " + (lms.length+1)); |
| // output to disk class file |
| /* ****************************************************************************************** */ |
| |
| // now create the class and load it |
| // return the Class. |
| |
| if (writeClassFile) |
| { |
| try |
| { |
| // removed "WRITEDIRECTORY+", as this path is already part of 'finalAdapterClassName' |
| FileOutputStream fos = new FileOutputStream(finalAdapterClassName+".class"); |
| fos.write(newClass); |
| fos.close(); |
| } |
| catch(IOException ex) |
| { |
| System.err.println(ex.getMessage()); |
| ex.printStackTrace(); |
| } |
| |
| try |
| { |
| Class ret = ldr.loadClass(finalAdapterClassName); |
| logger.debug("EventAdapterGenerator: " + |
| ret.getName() + |
| " dynamically generated"); |
| return ret; |
| } |
| catch (ClassNotFoundException ex) |
| { |
| System.err.println(ex.getMessage()); |
| ex.printStackTrace(); |
| } |
| } |
| |
| try |
| { |
| Class ret = ldr.defineClass(finalAdapterClassName,newClass); |
| logger.debug("EventAdapterGenerator: " + |
| ret.getName() + |
| " dynamically generated"); |
| return ret; |
| } |
| |
| catch(Throwable ex) // rgf, 2012-01-15 |
| { |
| System.err.println(ex.getMessage()); |
| ex.printStackTrace(); |
| } |
| } |
| return null; |
| } |
| } |
