JiapiClass c = JiapiClass.createClass("HelloWorld");

        // No API to set SourceFile!

        InstructionFactory iFactory = il.getInstructionFactory();

        il.add(iFactory.aload(0));

        il.add(iFactory.invoke(0, "java/lang/Object", "<init>", emptySig));

        il.add(iFactory.returnMethod(method));

        method = c.addMethod(Modifier.PUBLIC | Modifier.STATIC, "main", mainSig);

        iFactory = il.getInstructionFactory();

        il.add(iFactory.getField(Modifier.STATIC,

                "java/lang/System",

                "out",

                "Ljava/io/PrintStream;"));

        }

        log.info("Creating method " + clazz.getName() + "." + methodName);

        try {

            Signature signature = new Signature(returnType, parameterNames);

            method = clazz.addMethod((short)modifiers, methodName, signature);

        }

        catch (MethodExistsException mee) {

            log.info("method " + clazz.getName() + "." + methodName +

                     " already exists");

            method = mee.getMethod();

        }

        if (forwardMode == FORWARD_ORIGINAL) {

            forward(il);

        }

        else if (forwardMode == FORWARD_NEW) {

        }

        else {

            // Forward both

            forward(il);

        }

        if (createReturn) {

        }

    }

        // Add an empty method for a clazz. The method signature must

        // match the method from HelloWorld interface, the only difference

        // is that we want to implement the method now so it can't be abstract.

        Signature signature = new Signature("void", new String[] {} );

                                             signature);

       

        // Then create the method body. The body will make a call to

        // System.out.println and then just return.

                                                      {"java.lang.Object"});

//         JiapiMethod println = loader.loadClass(System.out.getClass().getName()).getMethod("println", new String[] { "java.lang.String" } );

        for (int i = 0; i < parameterTypes.length; i++) {

            parameterTypeNames[i] = parameterTypes[i].getName();

        }

                                             parameterTypeNames);

    }

    public void instrument(JiapiMethod jm) {

        InstructionList il = jm.getInstructionList();

        InstructionFactory factory = il.getInstructionFactory();

        JiapiClass fep = getEventProducer();

        JiapiField jiapiField = getEventProducerField();

        try {

            fieldGet =

                fep.getDeclaredMethod("fieldGet",

    public void instrument(JiapiMethod jm) {

        InstructionList il = jm.getInstructionList();

        InstructionFactory factory = il.getInstructionFactory();

        JiapiClass mep = getEventProducer();

        JiapiField jiapiField = getEventProducerField();

        // a flag, that tells whether or not InstructionList being

        // processed is in a static method.

        boolean isStatic = Modifier.isStatic(il.getDeclaringMethod().getModifiers());

       

        // Next, create static initializer, that initializes

        // field created above.

        try {

            clinit = currentClass.getDeclaredMethod("<clinit>",new String[]{});

        }

        catch(NoSuchMethodException nsme) {

            // It did not exists, so create one

            try {

                clinit =

                    currentClass.addMethod(Modifier.STATIC, "<clinit>",

                                           new Signature("void",

                                                         new String[0]));

                // create 'return' from <clinit>

            }

            catch(MethodExistsException mee) {

                mee.printStackTrace();

            }

        }

        InstructionFactory factory = il.getInstructionFactory();

        InstructionList initializer = il.createEmptyList();

        try {

            JiapiClass er = currentClass.getLoader().loadClass("alt.jiapi.event.EventRuntime");

                er.getDeclaredMethod("getFieldValue",

                                     new String[] {"java.lang.String"});

            // Get the field value from runtime

            initializer.add(factory.pushConstant(fieldName));

                    // NOT IMPLEMENTED

                    // This needs some further thinking before implementing

                }

                else if ("getInstrumentedObject".equals(inv.getMethodName())) {

        if (Modifier.isStatic(modifiers)) {

      // Static methods do not have reference to 'this'

      //view.add(factory.pushNull());

      view.add(factory.invoke(Modifier.STATIC, "java.lang.Class", "forName", new Signature("java.lang.Class", new String[] {"java.lang.String"})));

        }

        else {

      view.add(factory.aload(0));

        }

    public void instrument(InstructionList il) {

        log.info("Instrumenting " + getCurrentClass().getName() + "." +

                 il.getDeclaringMethod().getName());

        // Native or abstract methods can't be instrumented.

        if (Modifier.isNative(modifiers) || Modifier.isAbstract(modifiers)) {

            log.info("skipping abstract or native method: " +

            forward(il);

            return;

        }

            for (int i = 0; i < pTypes.length; i++) {

                pTypes[i] = hpTypes[i].getName();

            }

           

                                                          pTypes);

            il.add(factory.invoke(hMethod));

        }

        catch(Exception e) {

            log.error("Failed to add invoke instruction: " + e);