asm

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Byte Code » asm 
License:
URL:http://asm.objectweb.org/
Description:ASM is an all purpose Java bytecode manipulation and analysis framework.
Package NameComment
app.sec2
ch2.sec2
ch3.sec2
ch3.sec3
ch4.sec1
ch4.sec2
ch5.sec1
ch6.sec1
ch7.sec2
ch8.sec2
de.loskutov.bco
de.loskutov.bco.asm
de.loskutov.bco.compare
de.loskutov.bco.editors
de.loskutov.bco.preferences
de.loskutov.bco.ui
de.loskutov.bco.ui.actions
de.loskutov.bco.views
inner
org.apache.bcel.verifier.structurals
org.aspectj.apache.bcel.classfile
org.aspectj.apache.bcel.verifier.structurals
org.objectweb.asm Provides a small and fast bytecode manipulation framework.

The ASM framework is organized around the {@link org.objectweb.asm.ClassVisitor ClassVisitor}, {@link org.objectweb.asm.FieldVisitor FieldVisitor} and {@link org.objectweb.asm.MethodVisitor MethodVisitor} interfaces, which allow one to visit the fields and methods of a class, including the bytecode instructions of each method.

In addition to these main interfaces, ASM provides a {@link org.objectweb.asm.ClassReader ClassReader} class, that can parse an existing class and make a given visitor visit it. ASM also provides a {@link org.objectweb.asm.ClassWriter ClassWriter} class, which is a visitor that generates Java class files.

In order to generate a class from scratch, only the {@link org.objectweb.asm.ClassWriter ClassWriter} class is necessary. Indeed, in order to generate a class, one must just call its visitXXX methods with the appropriate arguments to generate the desired fields and methods. See the "helloworld" example in the ASM distribution for more details about class generation.

In order to modify existing classes, one must use a {@link org.objectweb.asm.ClassReader ClassReader} class to analyze the original class, a class modifier, and a {@link org.objectweb.asm.ClassWriter ClassWriter} to construct the modified class. The class modifier is just a {@link org.objectweb.asm.ClassVisitor ClassVisitor} that delegates most of the work to another {@link org.objectweb.asm.ClassVisitor ClassVisitor}, but that sometimes changes some parameter values, or call additional methods, in order to implement the desired modification process. In order to make it easier to implement such class modifiers, ASM provides the {@link org.objectweb.asm.ClassAdapter ClassAdapter} and {@link org.objectweb.asm.MethodAdapter MethodAdapter} classes, which implement the {@link org.objectweb.asm.ClassVisitor ClassVisitor} and {@link org.objectweb.asm.MethodVisitor MethodVisitor} interfaces by delegating all work to other visitors. See the "adapt" example in the ASM distribution for more details about class modification.

The size of the core ASM library, asm.jar, is only 42KB, which is much smaller than the size of the BCEL library (504KB), and than the size of the SERP library (150KB). ASM is also much faster than these tools. Indeed the overhead of a load time class transformation process is of the order of 60% with ASM, 700% or more with BCEL, and 1100% or more with SERP (see the test/perf directory in the ASM distribution)! @since ASM 1.3

org.objectweb.asm.attrs
org.objectweb.asm.commons Provides some useful class and method adapters. The preferred way of using these adapters is by chaining them together and to custom adapters (instead of inheriting from them). Indeed this approach provides more combination possibilities than inheritance. For instance, suppose you want to implement an adapter MyAdapter than needs sorted local variables and intermediate stack map frame values taking into account the local variables sort. By using inheritance, this would require MyAdapter to extend AnalyzerAdapter, itself extending LocalVariablesSorter. But AnalyzerAdapter is not a subclass of LocalVariablesSorter, so this is not possible. On the contrary, by using delegation, you can make LocalVariablesSorter delegate to AnalyzerAdapter, itself delegating to MyAdapter. In this case AnalyzerAdapter computes intermediate frames based on the output of LocalVariablesSorter, and MyAdapter can add new locals by calling the newLocal method on LocalVariablesSorter, and can get the stack map frame state before each instruction by reading the locals and stack fields in AnalyzerAdapter (this requires references from MyAdapter back to LocalVariablesSorter and AnalyzerAdapter).
org.objectweb.asm.depend
org.objectweb.asm.jbfc
org.objectweb.asm.optimizer
org.objectweb.asm.signature Provides support for type signatures. @since ASM 2.0
org.objectweb.asm.test.cases
org.objectweb.asm.tree

Provides an ASM visitor that constructs a tree representation of the classes it visits. This class adapter can be useful to implement "complex" class manipulation operations, i.e., operations that would be very hard to implement without using a tree representation (such as optimizing the number of local variables used by a method).

However, this class adapter has a cost: it makes ASM bigger and slower. Indeed it requires more than twenty new classes, and multiplies the time needed to transform a class by almost two (it is almost two times faster to read, "modify" and write a class with a ClassAdapter than with a ClassNode). This is why this package is bundled in an optional asm-tree.jar library that is separated from (but requires) the asm.jar library, which contains the core ASM framework. This is also why it is recommended not to use this class adapter when it is possible.

The root class is the ClassNode, that can be created from existing bytecode. For example:

  ClassReader cr = new ClassReader(source);
  ClassNode cn = new ClassNode();
  cr.accept(cn, true);

Now content of ClassNode can be modified and then serialized back into bytecode:

  ClassWriter cw = new ClassWriter(true);
  cn.accept(cw);

Using simple ClassAdapter it is possible to create MethodNode instances per-method. In this example MethodNode is acting as a buffer that is flushed out at visitEnd() call:

  ClassReader cr = new ClassReader(source);
  ClassWriter cw = new ClassWriter();
  ClassAdapter ca = new ClassAdapter(cw) {
      public MethodVisitor visitMethod(int access, String name, 
          String desc, String signature, String[] exceptions) {
        final MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        MethodNode mn = new MethodNode(access, name, desc, signature, exceptions) {
            public void visitEnd() {
              // transform or analyze method code using tree API
              accept(mv);
            }
          };
      }
    };
  cr.accept(ca, true);

Several strategies can be used to construct method code from scratch. The first option is to create a MethodNode, and then create XXXInsnNode instances and add them to the instructions list:

MethodNode m = new MethodNode(...);
m.instructions.add(new VarInsnNode(ALOAD, 0));
...

Alternatively, you can use the fact that MethodNode is a MethodVisitor, and use that to create the XXXInsnNode and add them to the instructions list through the standard MethodVisitor interface:

MethodNode m = new MethodNode(...);
m.visitVarInsn(ALOAD, 0);
...

If you cannot generate all the instructions in sequential order, i.e. if you need to save some pointer in the instruction list and then insert instructions at that place after other instructions have been generated, you can use InsnList methods insert() and insertBefore() to insert instructions at saved pointer.

MethodNode m = new MethodNode(...);
m.visitVarInsn(ALOAD, 0);
AbstractInsnNode ptr = m.instructions.getLast();
m.visitVarInsn(ALOAD, 1);
// inserts an instruction between ALOAD 0 and ALOAD 1
m.instructions.insert(ptr, new VarInsnNode(ALOAD, 0));
...

If you need to insert instructions while iterating over an existing instruction list, you can also use several strategies. The first one is to use a ListIterator over the instruction list:

ListIterator it = m.instructions.iterator();
while (it.hasNext()) {
    AbstractInsnNode n = (AbstractInsnNode) it.next();
    if (...) {
        it.add(new VarInsnNode(ALOAD, 0));
    }
}

It is also possible to convert instruction list into the array and iterate trough array elements:

AbstractInsnNode[] insns = m.instructions.toArray();
for(int i = 0; i<insns.length; i++) {
    AbstractInsnNode n = insns[i];
    if (...) {
        m.instructions.insert(n, new VarInsnNode(ALOAD, 0));
    }
}

If you want to insert these instructions through the MethodVisitor interface, you can use another instance of MethodNode as a MethodVisitor and then insert instructions collected by that instance into the instruction list. For example:

AbstractInsnNode[] insns = m.instructions.toArray();
for(int i = 0; i<insns.length; i++) {
    AbstractInsnNode n = insns[i];
    if (...) {
        MethodNode mn = new MethodNode();
        mn.visitVarInsn(ALOAD, 0);
        mn.visitVarInsn(ALOAD, 1);
        m.instructions.insert(n, mn.instructions);
    }
}

@since ASM 1.3.3

org.objectweb.asm.tree.analysis

Provides a framework for static code analysis based on the asm.tree package.

Basic usage:

ClassReader cr = new ClassReader(bytecode);
ClassNode cn = new ClassNode();
cr.accept(cn, ClassReader.SKIP_DEBUG);

List methods = cn.methods;
for (int i = 0; i < methods.size(); ++i) {
    MethodNode method = (MethodNode) methods.get(i);
    if (method.instructions.size() > 0) {
        Analyzer a = new Analyzer(new BasicInterpreter());
        a.analyze(cn.name, method);
        Frame[] frames = a.getFrames();
        // Elements of the frames arrray now contains info for each instruction 
        // from the analyzed method. BasicInterpreter creates BasicValue, that
        // is using simplified type system that distinguishes the UNINITIALZED, 
        // INT, FLOAT, LONG, DOUBLE, REFERENCE and RETURNADDRESS types.
        ...
    }
}   

@since ASM 1.4.3

org.objectweb.asm.util Provides ASM visitors that can be useful for programming and debugging purposes. These class visitors are normally not used by applications at runtime. This is why they are bundled in an optional asm-util.jar library that is separated from (but requires) the asm.jar library, which contains the core ASM framework. @since ASM 1.3.2
org.objectweb.asm.xml Provides SAX 2.0 adapters for ASM visitors to convert classes to and from XML. These adapters can be chained with other SAX compliant content handlers and filters, eg. XSLT or XQuery engines. This package is bundled as a separate asm-xml.jar library and requires asm.jar.

ASMContentHandler and SAXClassAdapter/SAXCodeAdapter are using asm-xml.dtd. Here is the example of bytecode to bytecode XSLT transformation.

    SAXTransformerFactory saxtf = ( SAXTransformerFactory) TransformerFactory.newInstance();
    Templates templates = saxtf.newTemplates( xsltSource);

    TransformerHandler handler = saxtf.newTransformerHandler( templates);
    handler.setResult( new SAXResult( new ASMContentHandler( outputStream, computeMax)));

    ClassReader cr = new ClassReader( bytecode);
    cr.accept( new SAXClassAdapter( handler, cr.getVersion(), false), false);
See JAXP and SAX documentation for more detils.

There are few illustrations of the bytecode transformation with XSLT in examples directory. The following XSLT procesors has been tested.

Engine javax.xml.transform.TransformerFactory property
jd.xslt jd.xml.xslt.trax.TransformerFactoryImpl
Saxon net.sf.saxon.TransformerFactoryImpl
Caucho com.caucho.xsl.Xsl
Xalan interpeter org.apache.xalan.processor.TransformerFactory
Xalan xsltc org.apache.xalan.xsltc.trax.TransformerFactoryImpl
@since ASM 1.4.3
pkg
util
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.