Improved the performance of $proceed when it represents a static method.

This change does not make any difference on WindowsXP but on Solaris/SPARC.

git-svn-id: http://anonsvn.jboss.org/repos/javassist/trunk@48 30ef5769-5b8d-40dd-aea6-55b5d6557bb3

diff --git a/src/main/javassist/compiler/Javac.java b/src/main/javassist/compiler/Javac.java
index 12d4b208af9fa8568ddc2ee0b8a6b60bc4b728f3..e0bf34288cc997f7854652dcab822d780ed04910 100644 (file)
--- a/src/main/javassist/compiler/Javac.java
+++ b/src/main/javassist/compiler/Javac.java
@@ -353,6 +353,36 @@ public class Javac {
         gen.setProceedHandler(h, proceedName);
     }
 
+    /**
+     * Prepares to use $proceed() representing a static method.
+     * If the return type of $proceed() is void, null is pushed on the
+     * stack.
+     *
+     * @param targetClass    the fully-qualified dot-separated name
+     *                         of the class declaring the method.
+     * @param method         the method name.
+     */
+    public void recordStaticProceed(String targetClass, String method)
+        throws CompileError
+    {
+        final String c = targetClass;
+        final String m = method;
+
+        ProceedHandler h = new ProceedHandler() {
+                public void doit(JvstCodeGen gen, Bytecode b, ASTList args)
+                    throws CompileError
+                {
+                    Expr expr = Expr.make(TokenId.MEMBER,
+                                          new Symbol(c), new Member(m));
+                    expr = Expr.make(TokenId.CALL, expr, args);
+                    expr.accept(gen);
+                    gen.addNullIfVoid();
+                }
+            };
+
+        gen.setProceedHandler(h, proceedName);
+    }
+
     /**
      * Prepares to use $proceed().
      */

diff --git a/src/main/javassist/compiler/MemberCodeGen.java b/src/main/javassist/compiler/MemberCodeGen.java
index 612b66416a6340abdf060929ff8b834e2b9ca3ad..3438671dd4542f76aec872a67ae4944ceca11a26 100644 (file)
--- a/src/main/javassist/compiler/MemberCodeGen.java
+++ b/src/main/javassist/compiler/MemberCodeGen.java
@@ -90,7 +90,7 @@ public class MemberCodeGen extends CodeGen {
 
             decl.setLocalVar(var);
 
-            CtClass type = lookupClass(decl.getClassName());
+            CtClass type = lookupJvmClass(decl.getClassName());
             decl.setClassName(javaToJvmName(type.getName()));
             bytecode.addExceptionHandler(start, end, bytecode.currentPc(),
                                          type);
@@ -253,7 +253,7 @@ public class MemberCodeGen extends CodeGen {
             mname = ((Symbol)e.oprand2()).get();
             int op = e.getOperator();
             if (op == MEMBER) {                 // static method
-                targetClass = lookupClass((ASTList)e.oprand1());
+                targetClass = lookupJavaClass(((Symbol)e.oprand1()).get());
                 isStatic = true;
             }
             else if (op == '.') {
@@ -277,9 +277,9 @@ public class MemberCodeGen extends CodeGen {
                 }
 
                 if (arrayDim > 0)
-                    targetClass = lookupClass2(javaLangObject);
+                    targetClass = lookupJavaClass(javaLangObject);
                 else if (exprType == CLASS /* && arrayDim == 0 */)
-                    targetClass = lookupClass(className);
+                    targetClass = lookupJvmClass(className);
                 else
                     badMethod();
             }
@@ -565,9 +565,9 @@ public class MemberCodeGen extends CodeGen {
 
                 String cname = desc.substring(i, j);
                 if (!cname.equals(argClassNames[n])) {
-                    CtClass clazz = lookupClass(argClassNames[n]);
+                    CtClass clazz = lookupJvmClass(argClassNames[n]);
                     try {
-                        if (clazz.subtypeOf(lookupClass(cname)))
+                        if (clazz.subtypeOf(lookupJvmClass(cname)))
                             result = MAYBE;
                         else
                             return NO;
@@ -786,14 +786,15 @@ public class MemberCodeGen extends CodeGen {
             Expr e = (Expr)expr;
             int op = e.getOperator();
             if (op == MEMBER) {
-                f = lookupField((ASTList)e.oprand1(), (Symbol)e.oprand2());
+                f = lookupJavaField(((Symbol)e.oprand1()).get(),
+                                    (Symbol)e.oprand2());
                 is_static = true;
             }
             else if (op == '.') {
                 try {
                     e.oprand1().accept(this);
                     if (exprType == CLASS && arrayDim == 0)
-                        f = lookupField(className, (Symbol)e.oprand2());
+                        f = lookupJvmField(className, (Symbol)e.oprand2());
                     else
                         badLvalue();
 
@@ -808,7 +809,7 @@ public class MemberCodeGen extends CodeGen {
                     Symbol fname = (Symbol)e.oprand2();
                     // it should be a static field.
                     try {
-                        f = lookupField(nfe.getField(), fname);
+                        f = lookupJvmField(nfe.getField(), fname);
                         is_static = true;
                     }
                     catch (CompileError ce) {
@@ -927,7 +928,7 @@ public class MemberCodeGen extends CodeGen {
         if (jvmName == null)
             return null;
         else
-            return javaToJvmName(lookupClass(jvmName).getName());
+            return javaToJvmName(lookupJvmClass(jvmName).getName());
     }
 
     protected CtClass lookupClass(Declarator decl) throws CompileError {
@@ -942,7 +943,7 @@ public class MemberCodeGen extends CodeGen {
         CtClass clazz;
         switch (type) {
         case CLASS :
-            clazz = lookupClass(classname);
+            clazz = lookupJvmClass(classname);
             if (dim > 0)
                 cname = clazz.getName();
             else
@@ -983,21 +984,21 @@ public class MemberCodeGen extends CodeGen {
         while (dim-- > 0)
             cname += "[]";
 
-        return lookupClass2(cname);
+        return lookupJavaClass(cname);
     }
 
     protected CtClass lookupClass(ASTList name) throws CompileError {
-        return lookupClass2(Declarator.astToClassName(name, '.'));
+        return lookupJavaClass(Declarator.astToClassName(name, '.'));
     }
 
-    protected CtClass lookupClass(String jvmName) throws CompileError {
-        return lookupClass2(jvmToJavaName(jvmName));
+    protected CtClass lookupJvmClass(String jvmName) throws CompileError {
+        return lookupJavaClass(jvmToJavaName(jvmName));
     }
 
     /**
      * @param name      a qualified class name. e.g. java.lang.String
      */
-    private CtClass lookupClass2(String name) throws CompileError {
+    private CtClass lookupJavaClass(String name) throws CompileError {
         try {
             return classPool.get(name);
         }
@@ -1015,23 +1016,23 @@ public class MemberCodeGen extends CodeGen {
     public CtField lookupField(ASTList className, Symbol fieldName)
         throws CompileError
     {
-        return lookupField2(Declarator.astToClassName(className, '.'),
+        return lookupJavaField(Declarator.astToClassName(className, '.'),
                             fieldName);
     }
 
-    public CtField lookupField(String className, Symbol fieldName)
+    public CtField lookupJvmField(String className, Symbol fieldName)
         throws CompileError
     {
-        return lookupField2(jvmToJavaName(className), fieldName);
+        return lookupJavaField(jvmToJavaName(className), fieldName);
     }
 
     /**
      * @param name      a qualified class name. e.g. java.lang.String
      */
-    private CtField lookupField2(String className, Symbol fieldName)
+    private CtField lookupJavaField(String className, Symbol fieldName)
         throws CompileError
     {
-        CtClass cc = lookupClass(className);
+        CtClass cc = lookupJavaClass(className);
         try {
             return cc.getField(fieldName.get());
         }

diff --git a/src/main/javassist/compiler/Parser.java b/src/main/javassist/compiler/Parser.java
index f18659514a0c36714b7a92485f341b98905b12b5..0e3945101bb44e3c7506a69a410cd6b4d2eaab94 100644 (file)
--- a/src/main/javassist/compiler/Parser.java
+++ b/src/main/javassist/compiler/Parser.java
@@ -958,7 +958,7 @@ public final class Parser implements TokenId {
                 else
                     throw new CompileError("missing static member name", lex);
 
-                expr = Expr.make(MEMBER, toClassName(expr, null),
+                expr = Expr.make(MEMBER, new Symbol(toClassName(expr)),
                                  new Member(str));
                 break;
             default :
@@ -991,17 +991,29 @@ public final class Parser implements TokenId {
         return Expr.make(CALL, expr, parseArgumentList(tbl));
     }
 
+    private String toClassName(ASTree name)
+        throws CompileError
+    {
+        StringBuffer sbuf = new StringBuffer();
+        toClassName(name, sbuf);
+        return sbuf.toString();
+    }
 
-    private ASTList toClassName(ASTree name, ASTList tail)
+    private void toClassName(ASTree name, StringBuffer sbuf)
         throws CompileError
     {
-        if (name instanceof Symbol)
-            return new ASTList(name, tail);
+        if (name instanceof Symbol) {
+            sbuf.append(((Symbol)name).get());
+            return;
+        }
         else if (name instanceof Expr) {
             Expr expr = (Expr)name;
-            if (expr.getOperator() == '.')
-                return toClassName(expr.oprand1(),
-                                   new ASTList(expr.oprand2(), tail));
+            if (expr.getOperator() == '.') {
+                toClassName(expr.oprand1(), sbuf);
+                sbuf.append('.');
+                toClassName(expr.oprand2(), sbuf);
+                return;
+            }
         }
 
         throw new CompileError("bad static member access", lex);

diff --git a/src/main/javassist/expr/MethodCall.java b/src/main/javassist/expr/MethodCall.java
index 281697c2896f6d4d8ab990dc66d741dea390a4db..9eee7fe9928ff20b0500a49d38ba968300160bcc 100644 (file)
--- a/src/main/javassist/expr/MethodCall.java
+++ b/src/main/javassist/expr/MethodCall.java
@@ -196,7 +196,10 @@ public class MethodCall extends Expr {
             jc.recordParams(classname, params,
                             true, paramVar, withinStatic());
             int retVar = jc.recordReturnType(retType, true);
-            jc.recordProceed(Javac.param0Name, methodname);
+            if (c == INVOKESTATIC)
+                jc.recordStaticProceed(classname, methodname);
+            else
+                jc.recordProceed(Javac.param0Name, methodname);
 
             /* Is $_ included in the source code?
              */