コード例 #1
0
  /* The static initializer */
  static {
    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");
    } 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
  }
コード例 #2
0
  /* 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;
  }