/*
 * Copyright 2004-2009 The Apache Software Foundation.
 *
 * Licensed 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.
 */


 /* changes
     2009-09-10, rgf: take into account that a context thread class loader may not be 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 = Thread.currentThread().getContextClassLoader().loadClass ("java.util.EventListener");
                     EVENTLISTENER = tccl.loadClass ("java.util.EventListener");
                }
                catch(ClassNotFoundException ex01)
                {}
            }

            if (EVENTLISTENER==null)    // did not work, try to load it via the definedClassLoadre
            {
                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(Exception ex)
	  catch(Throwable ex)           // rgf, 2009-09-10
	  {
              System.err.println(ex.getMessage());
              ex.printStackTrace();
          }
	}
	return null;
  }
}
