]> source.dussan.org Git - javassist.git/commitdiff
Added javassist.expr.ConstructorCall
authorchiba <chiba@30ef5769-5b8d-40dd-aea6-55b5d6557bb3>
Fri, 15 Jul 2005 10:08:22 +0000 (10:08 +0000)
committerchiba <chiba@30ef5769-5b8d-40dd-aea6-55b5d6557bb3>
Fri, 15 Jul 2005 10:08:22 +0000 (10:08 +0000)
git-svn-id: http://anonsvn.jboss.org/repos/javassist/trunk@189 30ef5769-5b8d-40dd-aea6-55b5d6557bb3

src/main/javassist/expr/ConstructorCall.java [new file with mode: 0644]
src/main/javassist/expr/ExprEditor.java
src/main/javassist/expr/MethodCall.java

diff --git a/src/main/javassist/expr/ConstructorCall.java b/src/main/javassist/expr/ConstructorCall.java
new file mode 100644 (file)
index 0000000..fb50b6a
--- /dev/null
@@ -0,0 +1,54 @@
+package javassist.expr;
+
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+import javassist.NotFoundException;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.MethodInfo;
+
+/**
+ * Constructor call such as <code>this()</code> and <code>super()</code>
+ * within a constructor body.
+ *
+ * @see NewExpr
+ */
+public class ConstructorCall extends MethodCall {
+    /**
+     * Undocumented constructor.  Do not use; internal-use only.
+     */
+    protected ConstructorCall(int pos, CodeIterator i, CtClass decl, MethodInfo m) {
+        super(pos, i, decl, m);
+    }
+
+    /**
+     * Returns <code>"super"</code> or "<code>"this"</code>.
+     */
+    public String getMethodName() {
+        return isSuper() ? "super" : "this";
+    }
+
+    /**
+     * Always throws a <code>NotFoundException</code>.
+     *
+     * @see #getConstructor()
+     */
+    public CtMethod getMethod() throws NotFoundException {
+        throw new NotFoundException("this is a constructor call.  Call getConstructor().");
+    }
+
+    /**
+     * Returns the called constructor.
+     */
+    public CtConstructor getConstructor() throws NotFoundException {
+        return getCtClass().getConstructor(getMethodDesc());
+    }
+
+    /**
+     * Returns true if the called constructor is not <code>this()</code>
+     * but <code>super()</code> (a constructor declared in the super class).
+     */
+    public boolean isSuper() {
+        return super.isSuper();
+    }
+}
index 340644737a54be2dff703d168d582e1304be3d02..475ab69254deb31f0dfb558b37989ca2d672ad03 100644 (file)
@@ -137,11 +137,16 @@ public class ExprEditor {
                             newList = newList.next;
                         }
                         else {
-                            expr = new MethodCall(pos, iterator, clazz, minfo);
-                            MethodCall mcall = (MethodCall)expr;
-                            if (!mcall.getMethodName().equals(
-                                                MethodInfo.nameInit))
+                            MethodCall mcall = new MethodCall(pos, iterator, clazz, minfo);
+                            if (mcall.getMethodName().equals(MethodInfo.nameInit)) {
+                                ConstructorCall ccall = new ConstructorCall(pos, iterator, clazz, minfo);
+                                expr = ccall;
+                                edit(ccall);
+                            }
+                            else {
+                                expr = mcall;
                                 edit(mcall);
+                            }
                         }
                     }
                 }
@@ -211,10 +216,23 @@ public class ExprEditor {
 
     /**
      * Edits a method call (overridable).
+     *
      * The default implementation performs nothing.
      */
     public void edit(MethodCall m) throws CannotCompileException {}
 
+    /**
+     * Edits a constructor call (overridable).
+     * The constructor call is either
+     * <code>super()</code> or <code>this()</code>
+     * included in a constructor body.
+     *
+     * The default implementation performs nothing.
+     *
+     * @see #edit(NewExpr)
+     */
+    public void edit(ConstructorCall c) throws CannotCompileException {}
+
     /**
      * Edits a field-access expression (overridable).
      * Field access means both read and write.
index 26e83e790c16eff86c9f9622a9ed78b2d93e54c0..ecb6ee863b3422b5352851fede0caefe0014092e 100644 (file)
@@ -71,7 +71,7 @@ public class MethodCall extends Expr {
      * Returns the class of the target object,
      * which the method is called on.
      */
-    private CtClass getCtClass() throws NotFoundException {
+    protected CtClass getCtClass() throws NotFoundException {
         return thisClass.getClassPool().get(getClassName());
     }
 
@@ -99,7 +99,7 @@ public class MethodCall extends Expr {
     }
 
     /**
-     * Returns the name of the called method.
+     * Returns the name of the called method. 
      */
     public String getMethodName() {
         ConstPool cp = getConstPool();
@@ -114,7 +114,10 @@ public class MethodCall extends Expr {
         return getCtClass().getMethod(getMethodName(), getMethodDesc());
     }
 
-    private String getMethodDesc() {
+    /**
+     * Returns the descriptor of the called method.
+     */
+    protected String getMethodDesc() {
         ConstPool cp = getConstPool();
         int nt = getNameAndType(cp);
         return cp.getUtf8Info(cp.getNameAndTypeDescriptor(nt));