From 30ea2357da95ebda1d7b28fb3027bb8694b55614 Mon Sep 17 00:00:00 2001
From: chiba <chiba@30ef5769-5b8d-40dd-aea6-55b5d6557bb3>
Date: Tue, 2 Nov 2004 17:03:26 +0000
Subject: [PATCH] synchronized statement support.

git-svn-id: http://anonsvn.jboss.org/repos/javassist/trunk@146 30ef5769-5b8d-40dd-aea6-55b5d6557bb3
---
 Readme.html                                   |  6 ++
 .../javassist/bytecode/ExceptionTable.java    |  6 +-
 src/main/javassist/compiler/CodeGen.java      | 83 ++++++++++++++++++-
 tutorial/tutorial2.html                       | 12 ++-
 4 files changed, 99 insertions(+), 8 deletions(-)

diff --git a/Readme.html b/Readme.html
index 8fd543d1..61572855 100644
--- a/Readme.html
+++ b/Readme.html
@@ -255,6 +255,12 @@ see javassist.Dump.
 
 <h2>Changes</h2>
 
+<p>- version 3.0
+
+<ul>
+  <li>The compiler now supports a synchronized statement.
+</ul>
+
 <p>- version 3.0 RC1 in September 13, 2004.
 
 <ul>
diff --git a/src/main/javassist/bytecode/ExceptionTable.java b/src/main/javassist/bytecode/ExceptionTable.java
index 246b4231..e2c20c92 100644
--- a/src/main/javassist/bytecode/ExceptionTable.java
+++ b/src/main/javassist/bytecode/ExceptionTable.java
@@ -186,7 +186,8 @@ public class ExceptionTable {
      * @param type      <code>catchType</code>
      */
     public void add(int index, int start, int end, int handler, int type) {
-        entries.add(index,
+        if (start < end)
+            entries.add(index,
                     new ExceptionTableEntry(start, end, handler, type));
     }
 
@@ -199,7 +200,8 @@ public class ExceptionTable {
      * @param type      <code>catchType</code>
      */
     public void add(int start, int end, int handler, int type) {
-        entries.add(new ExceptionTableEntry(start, end, handler, type));
+        if (start < end)
+            entries.add(new ExceptionTableEntry(start, end, handler, type));
     }
 
     /**
diff --git a/src/main/javassist/compiler/CodeGen.java b/src/main/javassist/compiler/CodeGen.java
index 3308a242..7dc3d973 100644
--- a/src/main/javassist/compiler/CodeGen.java
+++ b/src/main/javassist/compiler/CodeGen.java
@@ -48,6 +48,24 @@ public abstract class CodeGen extends Visitor implements Opcode, TokenId {
 
     protected ArrayList breakList, continueList;
 
+    /**
+     * doit() in ReturnHook is called from atReturn().
+     */
+    protected static abstract class ReturnHook {
+        ReturnHook next;
+        protected abstract void doit(Bytecode b);
+        protected ReturnHook(CodeGen gen) {
+            next = gen.returnHooks;
+            gen.returnHooks = this;
+        }
+
+        protected void remove(CodeGen gen) {
+            gen.returnHooks = next;
+        }
+    }
+
+    protected ReturnHook returnHooks;
+
     /* The following fields are used by atXXX() methods
      * for returning the type of the compiled expression.
      */
@@ -63,6 +81,7 @@ public abstract class CodeGen extends Visitor implements Opcode, TokenId {
         inStaticMethod = false;
         breakList = null;
         continueList = null;
+        returnHooks = null;
     }
 
     public void setTypeChecker(TypeChecker checker) {
@@ -341,10 +360,8 @@ public abstract class CodeGen extends Visitor implements Opcode, TokenId {
             atTryStmnt(st);
         else if (op == SWITCH)
             atSwitchStmnt(st);
-        else if (op == SYNCHRONIZED) {
-            hasReturned = false;
-            throw new CompileError("sorry, synchronized is not supported");
-        }
+        else if (op == SYNCHRONIZED)
+            atSyncStmnt(st);
         else {
             // LABEL, SWITCH label stament might be null?.
             hasReturned = false;
@@ -589,6 +606,9 @@ public abstract class CodeGen extends Visitor implements Opcode, TokenId {
             }
         }
 
+        for (ReturnHook har = returnHooks; har != null; har = har.next)
+            har.doit(bytecode);
+
         bytecode.addOpcode(op);
         hasReturned = true;
     }
@@ -607,6 +627,61 @@ public abstract class CodeGen extends Visitor implements Opcode, TokenId {
         hasReturned = false;
     }
 
+    private void atSyncStmnt(Stmnt st) throws CompileError {
+        int nbreaks = getListSize(breakList);
+        int ncontinues = getListSize(continueList);
+
+        compileExpr(st.head());
+        if (exprType != CLASS && arrayDim == 0)
+            throw new CompileError("bad type expr for synchronized block");
+
+        Bytecode bc = bytecode;
+        final int var = bc.getMaxLocals();
+        bc.incMaxLocals(1);
+        bc.addOpcode(DUP);
+        bc.addAstore(var);
+        bc.addOpcode(MONITORENTER);
+
+        ReturnHook rh = new ReturnHook(this) {
+            protected void doit(Bytecode b) {
+                b.addAload(var);
+                b.addOpcode(MONITOREXIT);
+            }
+        };
+
+        int pc = bc.currentPc();
+        Stmnt body = (Stmnt)st.tail();
+        if (body != null)
+            body.accept(this);
+
+        int pc2 = bc.currentPc();
+        int pc3 = 0;
+        if (!hasReturned) {
+            rh.doit(bc);
+            bc.addOpcode(Opcode.GOTO);
+            pc3 = bc.currentPc();
+            bc.addIndex(0);
+        }
+
+        int pc4 = bc.currentPc();
+        rh.doit(bc);
+        bc.addOpcode(ATHROW);
+        bc.addExceptionHandler(pc, pc2, pc4, 0);
+        if (!hasReturned)
+            bc.write16bit(pc3, bc.currentPc() - pc3 + 1);
+
+        rh.remove(this);
+
+        if (getListSize(breakList) != nbreaks
+            || getListSize(continueList) != ncontinues)
+            throw new CompileError(
+                "sorry, cannot break/continue in synchronized block");
+    }
+
+    private static int getListSize(ArrayList list) {
+        return list == null ? 0 : list.size();
+    }
+
     private static boolean isPlusPlusExpr(ASTree expr) {
         if (expr instanceof Expr) {
             int op = ((Expr)expr).getOperator();
diff --git a/tutorial/tutorial2.html b/tutorial/tutorial2.html
index 778f44ee..7ef1fedb 100644
--- a/tutorial/tutorial2.html
+++ b/tutorial/tutorial2.html
@@ -1359,6 +1359,16 @@ value.  This source text can be any Java expression if the result type
 of the expression matches the type of the field.  Note that an expression
 does not end with a semi colon (<code>;</code>).
 
+<p>Furthermore, the above code can be rewritten into the following
+simple code:
+
+<ul><pre>
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = CtField.make("public int z = 0;", point);
+point.addField(f);
+</pre></ul>
+
+
 <p><br>
 
 <a name="runtime">
@@ -1395,8 +1405,6 @@ supported.
 
 <p><li>Inner classes or anonymous classes are not supported.
 
-<p><li><code>synchronized</code> statements are not supported yet.
-
 <p><li>Labeled <code>continue</code> and <code>break</code> statements
 are not supported.
 
-- 
2.39.5