Examples of org.apache.bcel.generic.ClassGen

org.apache.bcel.generic.ClassGen
Template class for building up a java class. May be initialized with an existing java class (file). @see JavaClass @version $Id: ClassGen.java 386056 2006-03-15 11:31:56Z tcurdt $ @author M. Dahm

        }


        String methodName = SystemProperties.getProperty("cfgbuilder.method");


        JavaClass jclass = new ClassParser(argv[0]).parse();
        ClassGen classGen = new ClassGen(jclass);


        Method[] methodList = jclass.getMethods();
        for (Method method : methodList) {
            if (method.isAbstract() || method.isNative()) {
                continue;
            }


            if (methodName != null && !method.getName().equals(methodName)) {
                continue;
            }


            MethodDescriptor descriptor = DescriptorFactory.instance().getMethodDescriptor(jclass, method);
            MethodGen methodGen = new MethodGen(method, jclass.getClassName(), classGen.getConstantPool());


            CFGBuilder cfgBuilder = new BetterCFGBuilder2(descriptor, methodGen);
            cfgBuilder.build();


            CFG cfg = cfgBuilder.getCFG();

View Full Code Here

 * @version $Id: HelloWorldBuilder.java 410087 2006-05-29 12:12:19Z tcurdt $
 * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
 */
public class HelloWorldBuilder {
  public static void main(String[] argv) {
    ClassGen        cg = new ClassGen("HelloWorld", "java.lang.Object",
              "<generated>", Constants.ACC_PUBLIC |
              Constants.ACC_SUPER,
              null);
    ConstantPoolGen cp = cg.getConstantPool(); // cg creates constant pool
    InstructionList il = new InstructionList();
    MethodGen       mg = new MethodGen(Constants.ACC_STATIC |
               Constants.ACC_PUBLIC,// access flags
               Type.VOID,              // return type
               new Type[] {            // argument types
           new ArrayType(Type.STRING, 1) 
               },
               new String[] { "argv" }, // arg names
               "main", "HelloWorld",    // method, class
               il, cp);
    InstructionFactory factory = new InstructionFactory(cg);


    ObjectType i_stream = new ObjectType("java.io.InputStream");
    ObjectType p_stream = new ObjectType("java.io.PrintStream");


    /* Create BufferedReader object and store it in local variable `in'.
     */
    il.append(factory.createNew("java.io.BufferedReader"));
    il.append(InstructionConstants.DUP); // Use predefined constant, i.e. flyweight
    il.append(factory.createNew("java.io.InputStreamReader"));
    il.append(InstructionConstants.DUP);
    il.append(factory.createFieldAccess("java.lang.System", "in", i_stream,
          Constants.GETSTATIC));


    /* Call constructors, i.e. BufferedReader(InputStreamReader())
     */
    il.append(factory.createInvoke("java.io.InputStreamReader", "<init>",
           Type.VOID, new Type[] { i_stream },
           Constants.INVOKESPECIAL));
    il.append(factory.createInvoke("java.io.BufferedReader", "<init>", Type.VOID,
           new Type[] { new ObjectType("java.io.Reader") },
           Constants.INVOKESPECIAL));


    /* Create local variable `in'
     */
    LocalVariableGen lg = mg.addLocalVariable("in",
                new ObjectType("java.io.BufferedReader"),
                null, null);
    int in = lg.getIndex();
    lg.setStart(il.append(new ASTORE(in))); // `i' valid from here


    /* Create local variable `name'
     */
    lg = mg.addLocalVariable("name", Type.STRING, null, null);
    int name = lg.getIndex();
    il.append(InstructionConstants.ACONST_NULL);
    lg.setStart(il.append(new ASTORE(name))); // `name' valid from here


    /* try { ...
     */
    InstructionHandle try_start =
      il.append(factory.createFieldAccess("java.lang.System", "out", p_stream,
            Constants.GETSTATIC));


    il.append(new PUSH(cp, "Please enter your name> "));
    il.append(factory.createInvoke("java.io.PrintStream", "print", Type.VOID, 
           new Type[] { Type.STRING }, Constants.INVOKEVIRTUAL));
    il.append(new ALOAD(in));
    il.append(factory.createInvoke("java.io.BufferedReader", "readLine",
           Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
    il.append(new ASTORE(name));


    /* Upon normal execution we jump behind exception handler, 
     * the target address is not known yet.
     */
    GOTO g = new GOTO(null);
    InstructionHandle try_end = il.append(g);


    /* } catch() { ... }
     * Add exception handler: print exception and return from method
     */
    InstructionHandle handler =
      il.append(factory.createFieldAccess("java.lang.System", "out", p_stream,
            Constants.GETSTATIC));
    // Little trick in order not to save exception object temporarily
    il.append(InstructionConstants.SWAP);


    il.append(factory.createInvoke("java.io.PrintStream", "println", Type.VOID, 
     new Type[] { Type.OBJECT }, Constants.INVOKEVIRTUAL));
    il.append(InstructionConstants.RETURN);
    mg.addExceptionHandler(try_start, try_end, handler,
         new ObjectType("java.io.IOException"));


    /* Normal code continues, now we can set the branch target of the GOTO
     * that jumps over the handler code.
     */
    InstructionHandle ih =
      il.append(factory.createFieldAccess("java.lang.System", "out", p_stream,
            Constants.GETSTATIC));
    g.setTarget(ih);


    /* String concatenation compiles to StringBuffer operations.
     */
    il.append(factory.createNew(Type.STRINGBUFFER));
    il.append(InstructionConstants.DUP);
    il.append(new PUSH(cp, "Hello, "));
    il.append(factory.createInvoke("java.lang.StringBuffer", "<init>",
           Type.VOID, new Type[] { Type.STRING },
           Constants.INVOKESPECIAL));
    il.append(new ALOAD(name));
    
    /* Concatenate strings using a StringBuffer and print them.
     */
    il.append(factory.createInvoke("java.lang.StringBuffer", "append",
           Type.STRINGBUFFER, new Type[] { Type.STRING },
           Constants.INVOKEVIRTUAL));
    il.append(factory.createInvoke("java.lang.StringBuffer", "toString",
           Type.STRING, Type.NO_ARGS,
           Constants.INVOKEVIRTUAL));
    
    il.append(factory.createInvoke("java.io.PrintStream", "println",
           Type.VOID, new Type[] { Type.STRING },
           Constants.INVOKEVIRTUAL));


    il.append(InstructionConstants.RETURN);


    mg.setMaxStack(5); // Needed stack size
    cg.addMethod(mg.getMethod());


    il.dispose(); // Reuse instruction handles


    /* Add public <init> method, i.e. empty constructor
     */
    cg.addEmptyConstructor(Constants.ACC_PUBLIC);


    /* Get JavaClass object and dump it to file.
     */
    try {
      cg.getJavaClass().dump("HelloWorld.class");
    } catch(java.io.IOException e) { System.err.println(e); }
  }

View Full Code Here

    ClassLoader loader = ProxyCreator.class.getClassLoader();


    // instanceof won't work here ...
    if(loader.getClass().toString().equals("class org.apache.bcel.util.ClassLoader")) {
      // Real class name will be set by the class loader
      ClassGen cg = new ClassGen("foo", "java.lang.Object", "", Constants.ACC_PUBLIC,
         new String[] {"java.awt.event.ActionListener"});
     
      // That's important, otherwise newInstance() won't work
      cg.addEmptyConstructor(Constants.ACC_PUBLIC);


      InstructionList    il      = new InstructionList();
      ConstantPoolGen    cp      = cg.getConstantPool();
      InstructionFactory factory = new InstructionFactory(cg);


      int out     = cp.addFieldref("java.lang.System", "out",
           "Ljava/io/PrintStream;");
      int println = cp.addMethodref("java.io.PrintStream", "println",
          "(Ljava/lang/Object;)V");
      MethodGen mg = new MethodGen(Constants.ACC_PUBLIC, Type.VOID,
           new Type[] {
             new ObjectType("java.awt.event.ActionEvent")
           }, null, "actionPerformed", "foo", il, cp);


      // System.out.println("actionPerformed:" + event);
      il.append(new GETSTATIC(out));
      il.append(factory.createNew("java.lang.StringBuffer"));
      il.append(InstructionConstants.DUP);
      il.append(new PUSH(cp, "actionPerformed:"));
      il.append(factory.createInvoke("java.lang.StringBuffer", "<init>", Type.VOID,
             new Type[] {Type.STRING}, Constants.INVOKESPECIAL));


      il.append(new ALOAD(1));
      il.append(factory.createAppend(Type.OBJECT));
      il.append(new INVOKEVIRTUAL(println));
      il.append(InstructionConstants.RETURN);


      mg.stripAttributes(true);
      mg.setMaxStack();
      mg.setMaxLocals();
      cg.addMethod(mg.getMethod());


      byte[] bytes = cg.getJavaClass().getBytes();


      System.out.println("Uncompressed class: " + bytes.length);


      String s = Utility.encode(bytes, true);
      System.out.println("Encoded class: " + s.length());

View Full Code Here


    if((clazz = Repository.lookupClass(argv[0])) == null) {
        clazz = new ClassParser(argv[0]).parse(); // May throw IOException
    }


    ClassGen cg = new ClassGen(clazz);


    Method[] methods = clazz.getMethods();


    for(int i=0; i < methods.length; i++) {
      MethodGen mg = new MethodGen(methods[i], cg.getClassName(), cg.getConstantPool());
      cg.replaceMethod(methods[i], mg.getMethod());
    }


    Field[] fields = clazz.getFields();


    for(int i=0; i < fields.length; i++) {
      FieldGen fg =  new FieldGen(fields[i], cg.getConstantPool());
      cg.replaceField(fields[i], fg.getField());
    }


    cg.getJavaClass().dump(clazz.getClassName() + ".clazz");
  }

View Full Code Here

    */
   public synchronized static MBeanInvoker create(final MBeanMetaData metadata)
   {
      String parentName = BCELMBeanInvoker.class.getName();
      final String name = parentName + "Generated";
      ClassGen classGen = new ClassGen(name, // Qualified class name
                                       parentName, // Qualified superclass name
                                       "<generated-on-the-fly>", // File name
                                       Constants.ACC_PUBLIC | Constants.ACC_FINAL | Constants.ACC_SUPER, // Modifiers
                                       null); // Implemented interfaces


      classGen.addEmptyConstructor(Constants.ACC_PUBLIC);
      classGen.addMethod(createInvokeImpl(metadata, classGen, name));


      // For debug purposes only
//    dump(classGen);


      final byte[] bytes = classGen.getJavaClass().getBytes();


      try
      {
         // Must shield clients, since creating a new classloader requires a permission
         return (BCELMBeanInvoker)AccessController.doPrivileged(new PrivilegedExceptionAction()

View Full Code Here

        
        this.mixInList = mixInList; 
        JavaClass jc  = 
            Reflection.classForByteArray( classfileBuffer, targetClass );
        
        cGen  = new ClassGen( jc );
        constPoolGen = cGen.getConstantPool();
   }

View Full Code Here

                    String message = LOCALISER.msg("Enhancer.FieldIsNull", className, m.getName(), field.getName(constantPoolGen));
                    JPOXLogger.ENHANCER.error(message);
                    throw new NullPointerException(message);
                }


                ClassGen cg = BCELUtils.getClassByFieldByName(field.getName(constantPoolGen), fieldJavaClass);
                BCELFieldPropertyMetaData fieldConfig = null;
                BCELClassMetaData jdoConfigClass = ((BCELClassMetaData) cmd);


                // the accessing class is not this
                if (!cg.getClassName().equals(newClass.getClassName()))
                {
                    jdoConfigClass = (BCELClassMetaData) cmd.getPackageMetaData().getFileMetaData().getMetaDataManager().getMetaDataForClass(
                        cg.getClassName(), clr);
                }
                if( jdoConfigClass != null )
                {
                    AbstractMemberMetaData apmd = jdoConfigClass.findField(f);


                    if (apmd == null)
                    {
                        //check if a property(getter,setter) exists with this field name
                        if( jdoConfigClass.findProperty(f)==null )
                        {
                            //no fields netiher properties in the class, so something is wrong
                            String message = LOCALISER.msg("Enhancer.FieldConfigIsNullError", className + "." + f.getName());
                            JPOXLogger.ENHANCER.fatal(message);
                            throw new RuntimeException(message);
                        }
                    }
                    if( apmd != null && apmd.getPersistenceModifier() != FieldPersistenceModifier.NONE )
                    {
                        // do nothing
                    }
                    if (!isFieldAccessInPersistenceCapableClass(ih, m.getConstantPool()))
                    {
                        // do nothing
                    }
                    else if (fieldConfig != null && fieldConfig.getJdoFieldFlag() == 0)
                    {
                        // do nothing
                    }
                    else if (f.isStatic() || f.isFinal())
                    {
                        // do nothing
                    }
                    else if (BCELUtils.isSynthetic(f))
                    {
                        // do nothing
                    }
                    else
                    {
                        if (isDebugEnabled)
                        {
                            JPOXLogger.ENHANCER.debug(LOCALISER.msg("Enhancer.EnhanceOriginalMethod", 
                                className + "." + m.getName(), f.getName()));
                        }
                        if( apmd != null && !apmd.isProperty() && apmd.getPersistenceModifier() != FieldPersistenceModifier.NONE)
                        {
                            //properties do not use jdoXXX methods
                            if (i instanceof GETFIELD)
                            {
                                ih.setInstruction(factory.createInvoke(cg.getClassName(), "jdo" + BCELUtils.getGetterName(f), 
                                    field.getType(constantPoolGen), new Type[]{new ObjectType(cg.getClassName())}, Constants.INVOKESTATIC));
                            }
                            else
                            {
                                ih.setInstruction(factory.createInvoke(cg.getClassName(), "jdo" + BCELUtils.getSetterName(f), 
                                    Type.VOID, new Type[]{new ObjectType(cg.getClassName()), field.getType(constantPoolGen)},
                                    Constants.INVOKESTATIC));
                            }
                            change = true;
                        }
                    }

View Full Code Here

            imd = (InterfaceMetaData) imd.getSuperAbstractClassMetaData();
        }
        while (imd != null);


        // Start the class
        this.classGen = new ClassGen(fullClassName, fullSuperclassName, className + ".java", ACC_PUBLIC | ACC_SUPER, 
            (String[])interfaces.toArray(new String[interfaces.size()]));
        this.constantPool = classGen.getConstantPool();
        this.factory = new InstructionFactory(classGen, constantPool);


        // Create fields, default ctor, and methods

View Full Code Here

            if (fieldName.equals(f[i].getName()))
            {
                return f[i];
            }
        }
        ClassGen scg = classGen;
        
        if( scg.getSuperclassName() == null )
        {
            return null;
        }      
        JavaClass jc = Repository.getRepository().findClass(scg.getSuperclassName());
        while( jc != null )
        {
            scg = new ClassGen(jc);
            f = scg.getFields();
            for (int i = 0; i < f.length; i++)
            {
                if (fieldName.equals(f[i].getName()))
                {
                    return f[i];
                }
            }          
            if( scg.getSuperclassName() == null )
            {
                return null;
            }
            else if( scg.getSuperclassName().equals("java.lang.Object") )
            {
                return null;
            }            
            jc = Repository.getRepository().findClass(scg.getSuperclassName());
        }


        
        return null;
    }

View Full Code Here

            if (nonBooleanGetterName.equals(m[i].getName()) || booleanGetterName.equals(m[i].getName()) )
            {
                return m[i];
            }
        }
        ClassGen scg = classGen;
        
        if( scg.getSuperclassName() == null )
        {
            return null;
        }      
        JavaClass jc = Repository.getRepository().findClass(scg.getSuperclassName());
        while( jc != null )
        {
            scg = new ClassGen(jc);
            m = scg.getMethods();
            for (int i = 0; i < m.length; i++)
            {
                if (nonBooleanGetterName.equals(m[i].getName()) || booleanGetterName.equals(m[i].getName()) )
                {
                    return m[i];
                }
            }          
            if( scg.getSuperclassName() == null )
            {
                return null;
            }
            else if( scg.getSuperclassName().equals("java.lang.Object") )
            {
                return null;
            }            
            jc = Repository.getRepository().findClass(scg.getSuperclassName());
        }


        
        return null;
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.bcel.generic.ClassGen

ariba.awreload.Factor

ariba.awreload.FactorNotUsed

ariba.util.fieldvalue.CompiledAccessorFactory

com.betfair.platform.ComplexObjectCreator

com.lambda.Debugger.InstrumentorForCL

de.petris.dynamicaspects.util.ClassPatcher

edu.umd.cs.findbugs.ba.BetterCFGBuilder2

edu.umd.cs.findbugs.classfile.engine.bcel.ConstantPoolGenFactory

haikuvm.pc.tools.Preprocess

HelloWorldBuilder

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.