Map None to None_ while keep null as None. Fix bugs in constructor, and make SuperCtorTest pass

liling · liling · commit 0dbe3cd649c1 · 2007-10-01T07:53:45.000Z
diff --git a/java2python/lib/defaultconfig.py b/java2python/lib/defaultconfig.py
@@ -180,6 +180,7 @@
     'or':'or_',
     'print':'print_',
     'None':'None_',
+    'null':'None',
     }
 
 
diff --git a/java2python/lib/sourcetypes.py b/java2python/lib/sourcetypes.py
@@ -177,7 +177,7 @@ def addSourceBefore(self, value, stat=None):
             if isinstance(stat, int):
                 idx = stat
             else:
-                idx = -2 if stat == None else self.lines.index(stat)
+                idx = 0 if stat == None else self.lines.index(stat)
             self.lines.insert(idx, value)
         else:
             self.lines.append(value)
@@ -224,23 +224,46 @@ def allVars(self):
                 yield v
 
     @property
-    def allMembers(self):
-        """ all member variables in this class
+    def methodVars(self):
+        """ all vars declared in the current method
 
-        @return yields all member names from this class
+        @return yeilds all vars declared in the method
+        """
+
+        for obj in [self, ] + list(self.allParents):
+            for v in obj.variables:
+                yield v.name
+            if isinstance(obj, Method): break
+
+    @property
+    def instanceMembers(self):
+        """ all instance members in this class
+
+        @return yields all instance 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
+                    if not v.isStatic:
+                        yield v.name
                 for v in obj.extraVars:
                     yield v
 
+    @property
+    def instanceMethods(self):
+        """ all instance methods in this class
+
+        @return yields all instance method names from this class
+        """
+        for obj in [self, ] + list(self.allParents):
+            if isinstance(obj, Class):
+                for v in obj.methods:
+                    if not v.isStatic:
+                        yield v.name
+
     @property
     def staticMembers(self):
-        """ all static member variable in this class
+        """ all static members in this class
 
         @return yields static member names from this class
         """
@@ -250,6 +273,18 @@ def staticMembers(self):
                     if v.isStatic:
                         yield v.name
 
+    @property
+    def staticMethods(self):
+        """ all static methods in this class
+
+        @return yields static method names from this class
+        """
+        for obj in [self, ] + list(self.allParents):
+            if isinstance(obj, Class):
+                for v in obj.methods:
+                    if v.isStatic:
+                        yield v.name
+
     @property
     def extraVars(self):
         """ extra variable names; subclasses can and should reimplement
@@ -289,6 +324,14 @@ def isMethod(self):
         """
         return isinstance(self, Method)
 
+    @property
+    def isStatic(self):
+        """ True if this instance is static
+
+        @return if the variable is static return True
+        """
+        return 'static' in self.modifiers
+
     @property
     def declFormat(self):
         """ string format for variable names in this block
@@ -324,20 +367,23 @@ def fixDecl(self, *args):
         @return fixed name or names
         """
         fixed = list(args)
-        allvars = list(self.allMembers)
-        staticvars = list(self.staticMembers)
+        methodvars = list(self.methodVars)
+        membervars = list(self.instanceMembers) + list(self.instanceMethods)
+        staticvars = list(self.staticMembers) + list(self.staticMethods)
         mapping = self.config.combined('variableNameMapping')
         format = self.declFormat
-        if not self.isClass:
-            for i, arg in enumerate(args):
-                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:
-                    fixed[i] = mapping.get(arg, arg)
+        for i, arg in enumerate(args):
+            if arg in methodvars:
+                arg = mapping.get(arg, arg)
+                fixed[i] = arg
+            elif arg in staticvars:
+                arg = mapping.get(arg, arg)
+                fixed[i] = "%s.%s" % (self.className, arg)
+            elif arg in membervars:
+                arg = mapping.get(arg, arg)
+                fixed[i] = format % (arg, )
+            else:
+                fixed[i] = mapping.get(arg, arg)
         if len(fixed) == 1:
             return fixed[0]
         else:
@@ -447,7 +493,7 @@ def formatExpression(self, expr):
         elif isinstance(first, basestring) and isinstance(second, tuple):
             return fixdecl(first) % format(second)
         elif isinstance(first, tuple) and isinstance(second, basestring):
-            return format(first) % format(second)
+            return format(first) % fixdecl(second)
         elif isinstance(first, tuple) and isinstance(second, tuple):
             return (format(first), format(second))
         else:
@@ -631,6 +677,21 @@ def addBaseClass(self, name):
             name = self.formatExpression(name)
             self.bases.append(name)
 
+    def fixDecl(self, *args):
+        """ fixes variable names that are class members
+
+        @varparam args names to fix
+        @return fixed name or names
+        """
+        ret = list(args)
+        for i, arg in enumerate(args):
+            if self.className != arg:
+                ret[i] = Source.fixDecl(self, arg)
+        if len(ret) > 1:
+            return ret
+        else:
+            return ret[0]
+
     def formatDecl(self):
         """ generates a class statement accounting for base types
 
@@ -724,19 +785,37 @@ def F_0(...)
                 method.preamble.append('@%s.register(%s)' % (firstname, params))
                 method.name = '%s_%s' % (method.name, index)
 
-    def declVars(self):
+    def fixCtor(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)))
+        found = False
+        for meth in self.methods:
+            if meth.name == '__init__':
+                found = True
+                break
+        if not found and len(list(self.instanceMembers)) > 0:
+            meth = self.newMethod('__init__')
+            meth.calledSuperCtor = False
+            meth.calledOtherCtor = False
+
+        for meth in self.methods:
+            if meth.name == '__init__':
+                if not (meth.calledSuperCtor or meth.calledOtherCtor):
+                    meth.addSourceBefore("super(%s, self).__init__()" % meth.className, 0)
+                    meth.stmtAfterSuper = meth.newStatementBefore("if", 1)
+
+                if not meth.calledOtherCtor:
+                    stmt = meth.stmtAfterSuper 
+                    meth.addSourceBefore("# begin of instance variables", stmt)
+                    for v in self.variables:
+                        if not v.isStatic:
+                            meth.addSourceBefore(
+                                ("self.%s = %s", (("%s", v.name), v.expr)),
+                                stmt)
+                    idx = meth.lines.index(stmt)
+                    meth.lines[idx] = "# end of instance variables"
+                    
 
     def writeTo(self, output, indent):
         """ writes the string representation of this block
@@ -968,10 +1047,3 @@ def setExpression(self, expr):
         """
         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
@@ -97,7 +97,7 @@ returns [typ]
 
 builtin_type [block]
 returns [typ]
-    :   "void"    {typ = "None"   }
+    :   "void"    {typ = "null"   }
     |   "boolean" {typ = "bool"   }
     |   "byte"    {typ = "str"    }
     |   "char"    {typ = "str"    }
@@ -167,22 +167,21 @@ obj_block [block]
                 | method_def[block]
                 | variable_def[block, False]
                 | typ = type_def[block]
-                | #(STATIC_INIT statement_list[block])
+                | static_init[block]
                 | #(INSTANCE_INIT statement_list[block])
             )*
         )
-        { block.declVars() }
+        { block.fixCtor() }
     ;
 
 
 ctor_def [block]
     :   {
         meth = block.newMethod()
+        meth.calledSuperCtor = False
+        meth.calledOtherCtor = False
         }
         #(CTOR_DEF
-        {
-        meth.addSource("self.__init_vars__()")
-        }
             modifiers[meth]
             method_head[meth, "__init__"]
             (statement_list[meth])?
@@ -244,14 +243,24 @@ variable_def [block, append = True]
         )
         {
         if val == block.emptyAssign:
-            val = ("%s", block.config.combined("typeValueMap").get(typ, "None"))
+            val = ("%s", block.config.combined("typeValueMap").get(typ, "null"))
         var.setName(dec[1])
         var.setExpression(val)
         if append or var.isStatic:
             block.addSource( ("%s = %s", (dec, val)) )
         }
     ;
 
+static_init [block]
+    :   #(STATIC_INIT
+          {
+            if not hasattr(block, "static_init"):
+                block.static_init = block.newMethod("__static_init__")
+                block.static_init.addModifier("static")
+                block.parent.addSource("%s.__static_init__()\n" % block.className)
+          }
+          statement_list[block.static_init])
+    ;
 
 parameter_def [meth, exc=False]
     :   #(pd0:PARAMETER_DEF
@@ -386,7 +395,7 @@ statement [block]
         }
         #("for"
             #(FOR_INIT
-                ((variable_def[for_init])+ | for_exp = expr_list[for_init])?)
+                ((variable_def[for_init])+ | for_exp = expr_list[for_init, True])?)
             #(FOR_CONDITION (for_cond = expression[for_stat, False])?)
             #(FOR_ITERATOR  (for_iter = expr_list[for_stat, False])?)
             statement[for_stat]
@@ -463,7 +472,7 @@ statement [block]
         }
         #("return" (return_value = expression[block, False])? )
         {
-        if return_value in (None, ("%s", "None")):
+        if return_value in (None, ("%s", "null")):
             block.addSource("return")
         else:
             block.addSource(("return %s", return_value))
@@ -695,15 +704,15 @@ returns [exp = block.unknownExpression]
 
     |   #(NOT_EQUAL left=expr[block] right=expr[block])
         {
-        if right in ("None", (("%s", "None"))):
+        if right in ("null", (("%s", "null"))):
             exp = ("%s is not %s", (left, right))
         else:
             exp = ("(%s != %s)", (left, right))
         }
 
     |   #(EQUAL left=expr[block] right=expr[block])
         {
-        if right in ("None", (("%s", "None"))):
+        if right in ("null", (("%s", "null"))):
             exp = ("%s is %s", (left, right))
         else:
             exp = ("(%s == %s)", (left, right))
@@ -842,7 +851,7 @@ returns [exp = block.missingValue]
     |   "true"  {exp = ("%s", "True"   )}
     |   "false" {exp = ("%s", "False"  )}
     |   "this"  {exp = ("%s", "self"   )}
-    |   "null"  {exp = ("%s", "None"   )}
+    |   "null"  {exp = ("%s", "null"   )}
     // type name used with instanceof
     |   typ = type_spec[block] {exp = ("%s", typ)}
     ;
@@ -852,8 +861,9 @@ ctor_call [block]
     :   #(cn:CTOR_CALL seq=expr_list[block, False] )
         {
         name = block.parent.name
-        call = ("super(%s, self).__init__(%s)", (("%s", name), ("%s", seq)))
+        call = ("self.__init__(%s)", ("%s", seq))
         block.addSource(call)
+        block.calledOtherCtor = True
         }
 
     |   #(SUPER_CTOR_CALL
@@ -868,6 +878,10 @@ ctor_call [block]
             block.addSource(call)
             }
         )
+        {
+        block.calledSuperCtor = True
+        block.stmtAfterSuper = block.newStatement("if")
+        }
     ;
 
 

Original file line number	Diff line number	Diff line change
`@@ -180,6 +180,7 @@`
`180`	`180`	`'or':'or_',`
`181`	`181`	`'print':'print_',`
`182`	`182`	`'None':'None_',`
	`183`	`+ 'null':'None',`
`183`	`184`	`}`
`184`	`185`
`185`	`186`