Makes expression cast config point a callable.

Troy Melhase · Troy Melhase · commit 21f877987be6 · 2012-04-24T16:17:18.000-04:00
diff --git a/java2python/compiler/visitor.py b/java2python/compiler/visitor.py
@@ -699,21 +699,16 @@ def acceptCastExpr(self, node, memo):
         typeName = typeIdent.text
         if typeIdent.type == tokens.QUALIFIED_TYPE_IDENT:
             typeName = typeIdent.firstChild().text
-        
+
         if typeName in tokens.primitiveTypeNames:
             # Cast using the primitive type constructor
             self.fs = typeName + '(' + FS.r + ')'
         else:
-            mode = self.config.last('objCastMode')
-            if mode == 'drop':
-                # Use drop policy
-                self.fs = FS.r
-            elif mode == 'ctor':
-                # Make constructor
-                self.fs = FS.l + '(' + FS.r + ')'
+            handler = self.configHandler('Cast')
+            if handler:
+                handler(self, node)
             else:
-                warn('Couldn\'t perform cast operation. ' + typeName + \
-                    ' is not a primitive and objCastMode in the config file has wrong value.')
+                warn('No handler to perform cast of non-primitive type %s.', typeName)
         self.left, self.right = visitors = factory(parent=self), factory(parent=self)
         self.zipWalk(node.children, visitors, memo)
 
diff --git a/java2python/config/default.py b/java2python/config/default.py
@@ -168,20 +168,17 @@
 # in method declarations.  set to 0 to disable.
 #minIndentParams = 5
 
+# Specifies handler for cast operations of non-primitive types are handled
+# (primitive types are automatically handled).  Use basic.castDrop to leave
+# cast expressions out of generated source.  Use basic.castCtor to transform
+# casts into constructor calls.  Or you can specify a function of your own.
+expressionCastHandler = basic.castDrop
+
 
 # Values below are used by the handlers.  They're here for
 # convenience.
 
 
-# Specifies how cast operations of non-primitive types are handled
-# (primitive types are automatically handled)
-# Valid values:
-#     - 'drop': completely drops type and cast info
-#     - 'ctor': converts the cast in a constructor call
-#               E.g.: (Cast) x -> Cast(x)
-objCastMode = 'drop'
-
-
 # module output subs.
 moduleOutputSubs = [
     (r'System\.out\.println\((.*)\)', r'print \1'),
diff --git a/java2python/mod/basic.py b/java2python/mod/basic.py
@@ -7,6 +7,8 @@
 from os import path
 from re import sub as rxsub
 
+from java2python.lib import FS
+
 
 def shebangLine(module):
     """ yields the canonical python shebang line. """
@@ -237,3 +239,9 @@ def moveStaticExpressions(cls):
         module.adopt(newExpr, index=len(module.children))
 
 
+def castCtor(expr, node):
+    expr.fs = FS.l + '(' + FS.r + ')'
+
+
+def castDrop(expr, node):
+    expr.fs = FS.r
diff --git a/test/Cast0.java b/test/Cast0.java
@@ -0,0 +1,40 @@
+interface Something {
+    public int foo();
+}
+
+
+interface SomethingElse {
+    public int foo();
+}
+
+
+class Both implements Something {
+    public int foo() {
+        return 100;
+    }
+}
+
+class What extends Both {
+    public int foo() {
+        return 200;
+    }
+}
+
+
+class Cast0 {
+    public static void main(String[] args) {
+        int x = 33;
+        Integer ix = (Integer) x;
+        System.out.println(x);
+        System.out.println(ix);
+
+        What w = new What();
+
+        System.out.println( w.foo() );
+
+        Both b = (Both) w;
+
+        System.out.println( b.foo() );
+
+    }
+}
diff --git a/test/configs/Cast0.py b/test/configs/Cast0.py
@@ -0,0 +1,3 @@
+from java2python.mod import basic
+
+expressionCastHandler = basic.castDrop

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+from java2python.mod import basic`
	`2`	`+`
	`3`	`+expressionCastHandler = basic.castDrop`