Fix switch problems. Fix issue natural#30.

liling · liling · commit d48c30a9ccce · 2007-09-28T17:48:33.000Z
diff --git a/java2python/lib/sourcetypes.py b/java2python/lib/sourcetypes.py
@@ -104,7 +104,8 @@ def __init__(self, parent=None, name=None):
         self.epilogue = []
         self.lines = []
         self.type = None
-        self.variables = set()
+        self.variables = list()
+        self.methods = list()
 
         self.postIncDecInExprFixed = False
         self.postIncDecVars = []
@@ -166,17 +167,22 @@ def addSource(self, value):
 
     def addSourceBefore(self, value, stat=None):
         """ add source code to the end of this block, before the last line
+        or the specified statement
 
         @param value string, instance of Source (or subclass), or two-tuple
+        @param stat Statement, insert source before this statement
         @return None
         """
         if len(self.lines) > 0:
-            idx = -2 if stat == None else self.lines.index(stat)
+            if isinstance(stat, int):
+                idx = stat
+            else:
+                idx = -2 if stat == None else self.lines.index(stat)
             self.lines.insert(idx, value)
         else:
             self.lines.append(value)
 
-    def addVariable(self, name, force=False):
+    def addVariable(self, var, force=False):
         """ add variable name to set for tracking
 
         Variables are only added to Class instances unless the force
@@ -186,8 +192,11 @@ def addVariable(self, name, force=False):
         @keyparam force=False, if True, always add to set
         @return None
         """
-        if force or (name and self.isClass):
-            self.variables.add(name)
+        if force or (var.name and self.isClass):
+            self.variables.append(var)
+
+    def addMethod(self, meth):
+        self.methods.append(meth)
 
     @property
     def allParents(self):
@@ -208,10 +217,39 @@ def allVars(self):
         """
         for obj in [self, ] + list(self.allParents):
             for v in obj.variables:
-                yield v
+                yield v.name
+            for v in obj.methods:
+                yield v.name
             for v in obj.extraVars:
                 yield v
 
+    @property
+    def allMembers(self):
+        """ all member variables in this class
+
+        @return yields all member names from this class
+        """
+        for obj in [self, ] + list(self.allParents):
+            if isinstance(obj, Class):
+                for v in obj.variables:
+                    yield v.name
+                for v in obj.methods:
+                    yield v.name
+                for v in obj.extraVars:
+                    yield v
+
+    @property
+    def staticMembers(self):
+        """ all static member variable in this class
+
+        @return yields static member names from this class
+        """
+        for obj in [self, ] + list(self.allParents):
+            if isinstance(obj, Class):
+                for v in obj.variables:
+                    if v.isStatic:
+                        yield v.name
+
     @property
     def extraVars(self):
         """ extra variable names; subclasses can and should reimplement
@@ -267,19 +305,32 @@ def declFormat(self):
                     return 'self.%s'
         return '%s ## ERROR'
 
+    @property
+    def className(self):
+        if isinstance(self, Class):
+            return self.name
+        elif self.parent is not None:
+            return self.parent.className
+        else:
+            return 'ERROR'
+
     def fixDecl(self, *args):
         """ fixes variable names that are class members
 
         @varparam args names to fix
         @return fixed name or names
         """
         fixed = list(args)
-        allvars = list(self.allVars)
+        allvars = list(self.allMembers)
+        staticvars = list(self.staticMembers)
         mapping = self.config.combined('variableNameMapping')
         format = self.declFormat
         if not self.isClass:
             for i, arg in enumerate(args):
-                if arg in allvars:
+                if arg in staticvars:
+                    arg = mapping.get(arg, arg)
+                    fixed[i] = "%s.%s" % (self.className, arg)
+                elif arg in allvars:
                     arg = mapping.get(arg, arg)
                     fixed[i] = format % (arg, )
                 else:
@@ -317,6 +368,7 @@ def newMethod(self, name=None):
         @return Method instance
         """
         m = Method(parent=self, name=name)
+        self.addMethod(m)
         self.addSource(m)
         return m
 
@@ -325,10 +377,13 @@ def newSwitch(self):
 
         @return Statement instance
         """
-        s = Statement(self, 'if')
+        while_stat = Statement(self, 'while')
+        while_stat.setExpression('True')
+        self.addSource(while_stat)
+        s = Statement(while_stat, 'if')
         s.expr = 'False'
-        self.addSource(s)
-        return s
+        while_stat.addSource(s)
+        return while_stat, s
 
     def newStatement(self, name):
         """ creates a new Statement as a child of this block
@@ -342,15 +397,21 @@ def newStatement(self, name):
 
     def newStatementBefore(self, name, stat=None):
         """ creates a new Statement as a child of this block before the last
+        or the specified statement.
 
         @param name name of statement
-        @param stat add statement before stat
+        @param stat add statement before this one
         @return Statement instance
         """
         s = Statement(parent=self, name=name)
         self.addSourceBefore(s, stat)
         return s
 
+    def newVariable(self, name=None):
+        var = Variable(self)
+        self.addVariable(var, True)
+        return var
+
     def formatExpression(self, expr):
         """ format an expression set by the tree walker
 
@@ -398,13 +459,13 @@ def setName(self, name):
         """
         self.name = name
 
-    def fixSwitch(self, block):
+    def fixSwitch(self, while_block, block):
         """ fixes the first clause in an generated switch statement
 
         @param block Statement instance and child of this block
         @return None
         """
-        lines = self.lines
+        lines = while_block.lines
         if (not block in lines) or (block.name != 'if'):
             return
         i = lines.index(block)
@@ -666,6 +727,20 @@ def F_0(...)
                 method.preamble.append('@%s.register(%s)' % (firstname, params))
                 method.name = '%s_%s' % (method.name, index)
 
+    def declVars(self):
+        """Declare class member vars in init method
+
+        """
+        meth = None
+        if "__init__" in list(self.allMembers):
+            meth = self.newMethod("__init_vars__")
+        elif len(self.variables) > 0:
+            meth = self.newMethod("__init__")
+        if meth:
+            for v in self.variables:
+                if not v.isStatic:
+                    meth.addSource(("self.%s = %s", (("%s", v.name), v.expr)))
+
     def writeTo(self, output, indent):
         """ writes the string representation of this block
 
@@ -877,3 +952,29 @@ def writeTo(self, output, indent):
         if (not lines) and name not in ('break', 'continue', 'raise'):
             self.addSource('pass')
         Source.writeTo(self, output, indent+1)
+
+class Variable(Source):
+    """Variable is a defined class member variable or auto variable of the
+    method.
+
+    """
+
+    def __init__(self, parent, name=None, expr=None):
+        Source.__init__(self, parent=parent, name=name)
+        self.expr = expr
+
+    def setExpression(self, expr):
+        """ sets the value of the expression for this Variable
+
+        @param value expression (see formatExpression in Source class).
+        @return None
+        """
+        self.expr = expr
+
+    @property
+    def isStatic(self):
+        """Check is this variable a static variable
+
+        @return if the variable is static return True
+        """
+        return 'static' in self.modifiers
diff --git a/java2python/lib/walker.g b/java2python/lib/walker.g
@@ -154,7 +154,7 @@ returns [clause = None]
 interface_block [block]
     :   #(OBJBLOCK
             (method_decl[block]
-                | variable_def[block]
+                | variable_def[block, False]
                 | typ = type_def[block]
             )*
         )
@@ -165,12 +165,13 @@ obj_block [block]
     :   #(OBJBLOCK
             (ctor_def[block]
                 | method_def[block]
-                | variable_def[block]
+                | variable_def[block, False]
                 | typ = type_def[block]
                 | #(STATIC_INIT statement_list[block])
                 | #(INSTANCE_INIT statement_list[block])
             )*
         )
+        { block.declVars() }
     ;
 
 
@@ -179,6 +180,9 @@ ctor_def [block]
         meth = block.newMethod()
         }
         #(CTOR_DEF
+        {
+        meth.addSource("self.__init_vars__()")
+        }
             modifiers[meth]
             method_head[meth, "__init__"]
             (statement_list[meth])?
@@ -206,7 +210,6 @@ method_head [meth, name=None]
     :   ident = identifier[meth]
         {
         meth.setName(name if name else ident)
-        meth.parent.addVariable(meth.name)
         }
         #(PARAMETERS (parameter_def[meth])*)
         (throws_clause[meth])?
@@ -229,18 +232,23 @@ method_def [block]
     ;
 
 
-variable_def [block]
-    :   #(VARIABLE_DEF
-            modifiers[block]
-            typ = type_spec[block]
-            dec = var_decl[block]
-            val = var_init[block]
+variable_def [block, append = True]
+    :   {
+        var = block.newVariable()
+        }
+        #(VARIABLE_DEF
+            modifiers[var]
+            typ = type_spec[var]
+            dec = var_decl[var]
+            val = var_init[var]
         )
         {
-        block.addVariable(dec[1])
         if val == block.emptyAssign:
             val = ("%s", block.config.combined("typeValueMap").get(typ, "%s()" % typ))
-        block.addSource( ("%s = %s", (dec, val)) )
+        var.setName(dec[1])
+        var.setExpression(val)
+        if append or var.isStatic:
+            block.addSource( ("%s = %s", (dec, val)) )
         }
     ;
 
@@ -463,13 +471,14 @@ statement [block]
 
 
     |   {
-        switch_block = block.newSwitch()
+        while_block, switch_block = block.newSwitch()
         }
         #("switch" switch_expr = expression[block, False]
-                   (c:case_group[block, switch_expr])*
+                   (c:case_group[while_block, switch_expr])*
         )
         {
-        block.fixSwitch(switch_block)
+        while_block.newStatement("break")
+        block.fixSwitch(while_block, switch_block)
         }
 
     |   {
@@ -489,7 +498,7 @@ statement [block]
 
 case_group [block, switch_expr]
     :   {
-        other = block.newStatement("elif")
+        other = block.newStatement("if")
         right = None
         }
         #(CASE_GROUP
@@ -506,19 +515,11 @@ case_group [block, switch_expr]
         )
         {
         if right is block.emptyAssign:
-            other.setName("else")
-            other.setExpression(None)
+            other.setExpression("True")
         elif right[0] == "%s":
             other.setExpression(("%s == %s", (switch_expr, right)))
         else:
             other.setExpression(("%s in (%s)", (switch_expr, right)))
-
-        /* if only one break statement in the elif block, delete it, then
-           a pass statement will be generated */
-        if len(other.lines) == 1 and \
-            hasattr(other.lines[0], "name") and \
-            other.lines[0].name == "break":
-            del other.lines[0]
         }
     ;
 
