Ticket #275: java-jvm-4.patch

Source/Members.cobra

@@ -1098 +1098 @@
 
     pro isMain from var as bool
 
+    pro hasMainParams from var as bool
+        """ Flag that this method needs main entry point params inserted. Used by BackEnd codeGen"""
+    
     get isMethod as bool is override
         return true
 

Source/Compiler.cobra

@@ -1543 +1543 @@
         branch .options.get('back-end')
             on 'none', _backEnd = ClrBackEnd(this)  # TODO-SELFHOST
             on 'clr',  _backEnd = ClrBackEnd(this)
-            on 'jvm',  _backEnd = JvmBackEnd(this)
+            on 'jvm'
+                _backEnd = JvmBackEnd(this)
+                if .options['number'] == 'decimal', .options['number'] = 'float'
             on 'objc', _backEnd = ObjcBackEnd(this)
             else, throw FallThroughException(.options.get('back-end'))
             

Source/Expr.cobra

@@ -584 +584 @@
     var _args as List<of Expr>
     var _hasParens as bool
     var _definition as IMember?
+    var _hasMainArgs as bool = false
 
     cue init(token as IToken, name as String, args as List<of Expr>, hasParens as bool)
         .init(token, name, nil, args, hasParens as bool)
@@ -612 +613 @@
     get genericArgTypes from var
 
     get hasParens from var
-
+    
+    pro hasMainArgs from var
+        """Indicate if this call needs args passed into main method inserted by backend. For MainWrapper """
+        
     get willChangeVar as bool is override
         for arg in _args, if arg.willChangeVar, return true
         for arg in _args, if arg.direction <> Direction.In, return true

Source/Cobra.Lang/Java/CobraCore.java

@@ -9 +9 @@
  */
 package cobra.lang;
 
+//interface IHasSourceSite {
+//    public SourceSite getSourceSite();
+//}
+
+
 public class CobraCore {
     
     public static Boolean _willCheckInvariant = true;
@@ -20 +25 @@
     //public static String getRuntimePlatform() { return "jvm"; } // prop
     public static final String runtimePlatform =  "jvm"; 
     
+    public static boolean getWillCheckAssert() { return _willCheckAssert; }
+    public static void    setWillCheckAssert(boolean b) { _willCheckAssert = b; }
+    
+    // Property StringMaker techStringMaker
+    /*
+     *  Used by `assert` failures, `trace` statements and .toTechString methods.
+     */
+    static public CobraImp.SimpleStringMaker getTechStringMaker() { return CobraImp._techStringMaker; }
+    static public void setTechStringMaker(CobraImp.SimpleStringMaker value) { CobraImp._techStringMaker = value; }
+    
     public static int noOp(/* allowNull */ Object... args) { 
         /* """
     No operation. Primarily used in Cobra's own test suite to consume a local variable to avoid undesired warnings.

Source/Cobra.Lang/Java/AssertException.java

@@ -1 +1 @@
 /* 
  * java code for cobra assert exception ( placeholder currently)
- * in process of Converting from cobra to java code
  * Initially using java assertion till this is working
+ * 
+ * Exceptions for Assertions, contracts, etc.
  */
 
 package cobra.lang;
 
-import java.util.List;
+import java.util.*;
 
 
-class AssertException extends Exception implements IHasSourceSite, HasAppendNonPropertyKeyValues
+class AssertException extends RuntimeException //implements IHasSourceSite, HasAppendNonPropertyKeyValues
 //      has DetailedStackTrace(false)
 {
-    Object _this;
-    Object _info;   /* dynamic */
-    SourceSite _sourceSite;
-    java.util.List<Object> _expressions;
+    protected Object _this;
+    protected Object _info;   /* dynamic */
+    protected Object /*SourceSite*/ _sourceSite;
+    protected java.util.List<Object> _expressions;
     
-    AssertException(SourceSite sourceSite, java.util.List<Object> expressions /*dynamic */, Object thiss, Object info /*dynamic? */)
+    String nl = System.getProperties().getProperty("line.separator");
+    
+    public AssertException(/*SourceSite*/ Object sourceSite, java.util.List<Object> expressions /*dynamic */, 
+              Object thiss, Object info /*dynamic? */)
     {
-        this(sourceSite, expressions, thiss, info, nil)
+        this(sourceSite, expressions, thiss, info, null);
     }
 
-    AssertException(SourceSite sourceSite, java.util.List<Object> expressions /*dynamic */, Object thiss, Object info /*as dynamic?*/, Exception innerExc)
+    public AssertException(/*SourceSite*/ Object sourceSite, java.util.List<Object> expressions /*dynamic */, 
+              Object thiss, Object info /*dynamic?*/, Exception innerExc)
     {
-        super('assert', innerExc)
-        _sourceSite = sourceSite
-        _expressions = expressions
-        _this = thiss
-        _info = info
+        super("assert", innerExc);
+        _sourceSite = sourceSite;
+        _expressions = expressions;
+        _this = thiss;
+        _info = info;
     }
-// UNFINISHED
     
-    Object getThis { return _this; }
+    // Property this
+    public Object getThis() { return _this; }
     
-    Object getInfo { return _info; }
+    // Property info
+    public Object getInfo() { return _info; }
         
-    SourceSite getSourceSite { return _sourceSite; }
+    // Property sourceSite
+    public Object /*SourceSite*/ getSourceSite() { return _sourceSite; }
     
-    List<Object> getExpressions { return _expressions; }
+    // Property expressions
+    public List<Object> getExpressions() { return _expressions; }
 
     @Override
-    String getMessage()
-    {
-            nl = System.properties.newLine
-            StringBuilder sb = new StringBuilder(nl);
-            sb.append('sourceSite = [.sourceSite][nl]');
-            sb.append('info       = [.makeString(.info)][nl]');
-            sb.append('this       = [.makeString(.this)][nl]');
-            int indentLevel = 1;
-            int i = 1;
-            List<Object> exprs = _expressions;
-            while (i < exprs.size) {
-                Object item = exprs.get(i));
-                if (item == +1) {
-                    indentLevel += 1;
-                    i += 1;
-                }
-                else if (item == -1) {
-                    indentLevel -= 1;
-                    i += 1;
-                }
-                else {
-                    String source = (String)item;
-                    Object value = exprs.get(i+1);
-                    dirStr = value to? CobraDirectString
-                    valueString = if(dirStr, dirStr.string, .makeString(value))
-                    sb.append(String(' ', indentLevel*4))
-                    sb.append('[source] = [valueString][nl]');
-                    i += 2;
-                }
-            }
-
-          return sb.toString
-      }
+    public String getMessage()  {
+    StringBuilder sb = new StringBuilder(nl);
+    sb.append(String.format("sourceSite = %s%s", this._sourceSite, nl));
+    sb.append(String.format("info       = %s%s", this.makeString(this._info), nl));
+    sb.append(String.format("this       = %s%s", this.makeString(_this), nl));
+    int indentLevel = 1;
+        int i = 1;
+        List<Object> exprs = _expressions;
+        while (i < exprs.size()) {
+            Object item = exprs.get(i);
+            if (item.equals(+1)) {
+                indentLevel++;
+                i += 1;
+            }
+            else if (item.equals(-1)) {
+                indentLevel--;
+                i += 1;
+            }
+            else {
+                String source = (String) item;
+                Object value = exprs.get(i+1);
+                String valueString = "";
+                valueString = (value instanceof CobraDirectString) ? 
+                      ((CobraDirectString)value).string  : this.makeString(value);
+                sb.append( this.replicateString(" ", indentLevel*4) );
+                sb.append( String.format("%s = %s%s", source, valueString, nl));
+                i += 2;
+            }
+        }
+        return sb.toString();
+    }
     
-      String makeString(Object obj /*dynamic? */)
-      {
-            String s;
-            try {
-                s = CobraCore.techStringMaker.makeString(obj);
-            } 
-            catch (Exception e) {
-                s = 'CobraCore.techStringMaker.makeString exception: ' + e.message;
-            }
-            return s;
-        }
+    String replicateString(String s, int count)   {
+    StringBuilder sb = new StringBuilder(s);
+        while (--count > 0) sb.append(s);
+        return sb.toString();
+    }
+    
+    String makeString(Object obj /*dynamic? */)   {
+    String s;
+    try {
+        s = CobraCore.getTechStringMaker().makeString(obj);
+    } 
+    catch (Exception e) {
+        s = "CobraCore.techStringMaker.makeString exception: " + e.getMessage();
+    }
+    return s;
+    }
 
-        def appendNonPropertyKeyValues(target as HasAppendKeyValue )
+    /*
+       def appendNonPropertyKeyValues(target as HasAppendKeyValue )
             # Invoked by the Cobra Exception Report and CobraMain-ObjectExplorer-WinForms
             # By adding the expression breakdown as entries in the view,
             # object values will be clickable which will lead to their own detailed view.
@@ -108 +120 @@
                     target.appendKeyValue(String(c' ', indentLevel*4)+source, value)
                     i += 2
 
-        def populateTreeWithExpressions(tree as ITreeBuilder)
-            # Invoked by the Object Explorer, but any tool could use this by implementing ITreeBuilder.
-            # By adding the expression breakdown as entries in the view,
-            # object values will be clickable which will lead to their own detailed view.
-            i, exprs = 1, _expressions
+    def populateTreeWithExpressions(tree as ITreeBuilder)
+        # Invoked by the Object Explorer, but any tool could use this by implementing ITreeBuilder.
+        # By adding the expression breakdown as entries in the view,
+        # object values will be clickable which will lead to their own detailed view.
+        i, exprs = 1, _expressions
             while i < exprs.count
                 item = exprs[i]
                 if item == +1
@@ -127 +139 @@
                     tree.appendKeyValue(source, value)
                     i += 2
 
+*/
 
+}
 
+class InvariantException extends AssertException 
+{
+    public InvariantException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */,  Object thiss, Object info /*dynamic? */) 
+    {
+        this(sourceSite, expressions, thiss, info, null);
+    }
+    
+    public InvariantException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */, Object thiss, Object info /*dynamic? */, 
+              Exception cause)
+    {
+        super(sourceSite, expressions, thiss, info, cause);
+    }
+}
 
+class RequireException extends AssertException
+{
+    protected RequireException _next;
 
-/*
-    ## Exceptions about dynamic
+    public RequireException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */, 
+              Object thiss, 
+              Object info /*dynamic? */) 
+    {
+        this(sourceSite, expressions, thiss, info, null);
+    }
+    
+    public RequireException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */,  
+              Object thiss, 
+              Object info /*dynamic? */,
+              Exception cause )
+          {
+              super(sourceSite, expressions, thiss, info, cause);
+          }    
+    
+    //Property RequireException next
+    public RequireException getNext() { return this._next;}
+    public void setNext(RequireException value) { this._next = value; }
+}
 
-    class DynamicOperationException inherits Exception
-        """
-        The base class for all dynamic operation exceptions.
-        """
 
-        cue init(message as String?)
-            .init(message, nil)
+class EnsureException extends AssertException
+{
 
-        cue init(message as String?, innerExc as Exception?)
-            base.init(message, innerExc)
+    public EnsureException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */, 
+              Object thiss, 
+              Object info /*dynamic? */) 
+    {
+        this(sourceSite, expressions, thiss, info, null);
+    }
 
-    class CannotEnumerateException inherits DynamicOperationException
-        
-        # CC: axe init()s
+    public EnsureException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */,  
+              Object thiss, 
+              Object info /*dynamic? */,
+              Exception cause)
+          {
+              super(sourceSite, expressions, thiss, info, cause);
+          }    
+}
 
-        cue init(message as String?)
-            .init(message, nil)
+class NonNilCastException extends AssertException
+{
 
-        cue init(message as String?, innerExc as Exception?)
-            base.init(message, innerExc)
-        
-        
-    class UnknownMemberException inherits DynamicOperationException
+    public NonNilCastException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */, 
+              Object thiss, 
+              Object info /*dynamic? */) 
+    {
+        this(sourceSite, expressions, thiss, info, null);
+    }
 
-        var _obj as Object
-        var _name as String
-        var _type as Type
 
-        cue init(obj as Object, name as String, type as Type)
-            .init(obj, name, type, nil)
+    public NonNilCastException(/*SourceSite*/ Object sourceSite, 
+              java.util.List<Object> expressions /*dynamic */,  
+              Object thiss, 
+              Object info /*dynamic? */,
+              Exception cause )
+          {
+              super(sourceSite, expressions, thiss, info, cause);
+          }    
 
-        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
-            base.init('obj=[CobraCore.toTechString(obj)], name=[CobraCore.toTechString(name)], type=[type]', innerExc)
-            _obj = obj
-            _name = name
-            _type = type
+    @Override
+    public String getMessage() {
+        return String.format("Cast to non-nil failed.%s%s", this.nl, super.getMessage() ) ;
+    }
+}
 
 
-    class CannotReadPropertyException inherits UnknownMemberException
 
-        # CC: axe init()s
+/*  ## Misc exceptions
 
-        cue init(obj as Object, name as String, type as Type)
-            .init(obj, name, type, nil)
-
-        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
-            base.init(obj, name, type, innerExc)
-
-
-    class CannotWritePropertyException inherits UnknownMemberException
-
-        # CC: axe init()s
-
-        cue init(obj as Object, name as String, type as Type)
-            .init(obj, name, type, nil)
-
-        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
-            base.init(obj, name, type, innerExc)
-
-
-    class CannotSliceTypeException inherits UnknownMemberException
-
-        # CC: axe init()s
-
-        cue init(obj as Object, name as String, type as Type)
-            .init(obj, name, type, nil)
-
-        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
-            base.init(obj, name, type, innerExc)
-
-
-    class CannotInTypeException inherits UnknownMemberException
-
-        # CC: axe init()s
-
-        cue init(obj as Object, name as String, type as Type)
-            .init(obj, name, type, nil)
-
-        cue init(obj as Object, name as String, type as Type, innerExc as Exception?)
-            base.init(obj, name, type, innerExc)
-
-
-    class CannotCompareException inherits DynamicOperationException
-
-        var _a
-        var _b
-
-        cue init(a, b)
-            .init(a, b, nil)
-
-        cue init(a, b, innerExc as Exception?)
-            base.init('a=[a], b=[b]', innerExc)
-            #base.init('a=[CobraCore.toTechString(a)], a.getType=[a.getType.name], b=[CobraCore.toTechString(b)], b.getType=[b.getType.name]', innerExc)
-            _a = a
-            _b = b
-
-
-    ## Assertions, contracts, etc.
-
-    class AssertException inherits Exception implements IHasSourceSite, HasAppendNonPropertyKeyValues
-        has DetailedStackTrace(false)
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
-            .init(sourceSite, expressions, thiss, info, nil)
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
-            base.init('assert', innerExc)
-            _sourceSite = sourceSite
-            _expressions = expressions
-            _this = thiss
-            _info = info
-
-        get this from var as Object
-    
-        get info from var as dynamic?
-        
-        get sourceSite from var as SourceSite
-    
-        get expressions from var as IList<of dynamic>
-
-        get message as String? is override
-            nl = Environment.newLine
-            sb = StringBuilder(nl)
-            sb.append('sourceSite = [.sourceSite][nl]')
-            sb.append('info       = [.makeString(.info)][nl]')
-            sb.append('this       = [.makeString(.this)][nl]')
-            i = indentLevel = 1
-            exprs = _expressions
-            while i < exprs.count
-                item = exprs[i]
-                if item == +1
-                    indentLevel += 1
-                    i += 1
-                else if item == -1
-                    indentLevel -= 1
-                    i += 1
-                else
-                    source = item to String
-                    value = exprs[i+1]
-                    dirStr = value to? CobraDirectString
-                    valueString = if(dirStr, dirStr.string, .makeString(value))
-                    sb.append(String(c' ', indentLevel*4))
-                    sb.append('[source] = [valueString][nl]')
-                    i += 2
-
-            return sb.toString
-    
-        def makeString(obj as dynamic?) as String
-            try
-                s = CobraCore.techStringMaker.makeString(obj)
-            catch e as Exception
-                s = 'CobraCore.techStringMaker.makeString exception: ' + e.message
-            return s
-
-        def appendNonPropertyKeyValues(target as HasAppendKeyValue )
-            # Invoked by the Cobra Exception Report and CobraMain-ObjectExplorer-WinForms
-            # By adding the expression breakdown as entries in the view,
-            # object values will be clickable which will lead to their own detailed view.
-            indentLevel = 0
-            target.appendKeyValue('expression breakdown:', Html(''))
-            i, exprs = 1, _expressions
-            while i < exprs.count
-                item = exprs[i]
-                if item == +1
-                    indentLevel += 1
-                    i += 1
-                else if item == -1
-                    indentLevel -= 1
-                    i += 1
-                else
-                    source = item to String
-                    value = exprs[i+1]
-                    target.appendKeyValue(String(c' ', indentLevel*4)+source, value)
-                    i += 2
-
-        def populateTreeWithExpressions(tree as ITreeBuilder)
-            # Invoked by the Object Explorer, but any tool could use this by implementing ITreeBuilder.
-            # By adding the expression breakdown as entries in the view,
-            # object values will be clickable which will lead to their own detailed view.
-            i, exprs = 1, _expressions
-            while i < exprs.count
-                item = exprs[i]
-                if item == +1
-                    tree.indent
-                    i += 1
-                else if item == -1
-                    tree.outdent
-                    i += 1
-                else
-                    source = item to String
-                    value = exprs[i+1]
-                    tree.appendKeyValue(source, value)
-                    i += 2
-
-
-    class InvariantException inherits AssertException
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
-            .init(sourceSite, expressions, thiss, info, nil)
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
-            base.init(sourceSite, expressions, thiss, info, innerExc)
-
-
-    class RequireException inherits AssertException
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
-            .init(sourceSite, expressions, thiss, info, nil)
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
-            base.init(sourceSite, expressions, thiss, info, innerExc)
-
-        pro next from var as RequireException?
-
-
-    class EnsureException inherits AssertException
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
-            .init(sourceSite, expressions, thiss, info, nil)
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
-            base.init(sourceSite, expressions, thiss, info, innerExc)
-
-
-    class NonNilCastException inherits AssertException
-
-        # it's unfortunate that we have to choose between inheriting AssertException or NullReferenceException
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?)
-            .init(sourceSite, expressions, thiss, info, nil)
-
-        cue init(sourceSite as SourceSite, expressions as IList<of dynamic>, thiss as Object, info as dynamic?, innerExc as Exception?)
-            base.init(sourceSite, expressions, thiss, info, innerExc)
-
-        get message as String? is override
-            return 'Cast to non-nil failed.[Environment.newLine][base.message]'
-
-
-    ## Misc exceptions
-
     class ExpectException inherits Exception
 
         cue init(expectedExceptionType as Type, actualException as Exception?)
@@ -420 +284 @@
         cue init(msg as String?)
             base.init
 */
-}
- No newline at end of file

Source/Cobra.Lang/Java/CobraDirectString.java

@@ +1 @@
+/*
+ * CobraDirectString Used internally for assert, require and ensure to encode strings 
+ *  that should not be passed to CobraCore.toTechString.
+ */
+package cobra.lang;
+ 
+public class CobraDirectString {
+    public String string;
+
+    // ctor
+    public CobraDirectString(String s) { this.string = s;   }
+
+    @Override
+    public String toString() {  return string; }
+}

Source/Cobra.Lang/Java/Delegate.java

@@ +1 @@
+/*
+ * Start of a Delegate baseclass for Cobra implemented for Java
+ * The cobra compiler java backend will be reponsible for mapping the construction, initialisation and 
+ *  invocation of a Delegate to the API below
+ *  construct sig delName(param as paramType0,...) as retType   -> d = new Delegate(retType, paramType0, ...)
+ *                    (  or no args and void returnType           -> d = new Delegate()  )
+ *  assign    myDelegate as delName = ref inst.method             -> d.init(inst, "method")
+ *  call      myDelegate(arg0,...)                                -> d.invoke(arg0,...)  
+ *            (or no args:  myDelegate()                          -> d.invoke()  )
+ *
+ * Doesnt support Generics.
+ * This Implementation genericised on ReturnType
+ */
+
+package cobra.lang;
+
+import java.lang.*;
+import java.io.*;
+import java.util.*;
+import java.lang.reflect.*;
+
+public class Delegate<T> {
+    Class<T> returnType;  //  method returnType
+    Class<?>[] paramTypes;  // Types of the method parameters 
+    
+    Class targetClass;
+    Object target;
+    String methodName;
+    Method method;
+    
+    protected List<Delegate<T>> multiCastList;
+    
+    /*
+     * A Delegate is a Type describing a method signature (returnType and ParamTypes) that can hold a
+     * method and target to invoke it on (instance or static). 
+     * Start with recording the signature - return Type and parameter Types
+     */
+    public Delegate(Class<T> returnType, Class<?>... paramTypes) {
+    //public Delegate(Class... paramTypes) {
+        this.returnType = returnType;
+        this.paramTypes = paramTypes;
+    }
+
+    /*
+     * Convenience for a Delegate with no params, no return type.
+     */
+    static public Delegate allVoid() {
+        return new Delegate<Void>(void.class);
+    }
+    
+    /*
+     * Initialise to a instance method on a particular target object
+     * Repeated calls will overwrite any previous settings.
+     */
+    public void init(Object target, String methodName){
+        this.target = target;
+        this.targetClass = target.getClass();
+        this.methodName = methodName;
+        matchMethod();
+    }
+
+    /*
+     * Initialise to a static method (on a target class)
+     * Repeated calls will overwrite any previous settings.
+     */
+    public void init(Class targetClass, String methodName){
+        this.target = null;
+        this.targetClass = targetClass;
+        this.methodName = methodName;
+        matchMethod();
+    }
+    
+    
+    /*
+     * Ensure that there is a match for the given method name, return type and paramtypes on the target given.
+     * Record the Method and make accessible for later invocation
+     */
+    void matchMethod() {
+        NoSuchMethodException e0 = null;
+        Class<?> mclass = this.targetClass;
+        for(;;) {
+            try {
+                this.method = mclass.getDeclaredMethod(this.methodName, this.paramTypes);
+                this.method.setAccessible(true);
+                this.targetClass = mclass;              
+                break;
+            } catch(NoSuchMethodException e) {
+                if (mclass == Object.class) {
+                    throw new RuntimeException(e0!=null ? e0 : e);
+                } else {
+                    if (e0 == null) e0 = e;
+                    mclass = mclass.getSuperclass();
+                }
+            }
+        }
+        Class methodType =  this.method.getReturnType();
+        if ( ! isCompatibleType(this.returnType, methodType)) {
+             String msg = "NoSuchMethodException "+this.methodName + ":" ;
+             msg += "method returnType " + methodType.getName() + " not compatible with Delegate returnType " + this.returnType.getClass().getName();
+             throw new RuntimeException(new NoSuchMethodException(msg));
+        }
+    }
+    
+    /** Maps primitives to their corresponding wrappers and vice versa. */
+    private static final Map<Class,Class> PRIMITIVES_MAP = new HashMap<Class,Class>();
+  
+    static {
+        PRIMITIVES_MAP.put(boolean.class, Boolean.class);
+        PRIMITIVES_MAP.put(byte.class, Byte.class);
+        PRIMITIVES_MAP.put(char.class, Character.class);
+        PRIMITIVES_MAP.put(double.class, Double.class);
+        PRIMITIVES_MAP.put(float.class, Float.class);
+        PRIMITIVES_MAP.put(int.class, Integer.class);
+        PRIMITIVES_MAP.put(long.class, Long.class);
+        PRIMITIVES_MAP.put(short.class, Short.class);
+        PRIMITIVES_MAP.put(void.class, Void.class);
+        PRIMITIVES_MAP.put(Boolean.class, boolean.class);
+        PRIMITIVES_MAP.put(Byte.class, byte.class);
+        PRIMITIVES_MAP.put(Character.class, char.class);
+        PRIMITIVES_MAP.put(Double.class, double.class);
+        PRIMITIVES_MAP.put(Float.class, float.class);
+        PRIMITIVES_MAP.put(Integer.class, int.class);
+        PRIMITIVES_MAP.put(Long.class, long.class);
+        PRIMITIVES_MAP.put(Short.class, short.class);    
+        PRIMITIVES_MAP.put(Void.class, void.class);    
+    }
+    
+    //private boolean isCompatibleType(Class<?> c1, Class<?> c2) {
+    private boolean isCompatibleType(Class<T> c1, Class<?> c2) {
+        return c1 == c2 || 
+              c1 == PRIMITIVES_MAP.get(c2) || 
+              c1.isAssignableFrom(c2) || 
+              c2.isAssignableFrom(c1);
+    }
+    
+    
+     /**
+     * Executes the method synchronously on the calling thread and returns the 
+     * result value.
+     * Any checked exceptions are caught and wrapped in a RuntimeException.
+     * MultCast Delegates are all run and the result of the last returned. 
+     * 
+     * @param arguments Values to pass to the method.
+     * @return result of calling the method.
+     */
+    @SuppressWarnings("unchecked")  // doesnt like the return cast
+    public T invoke(Object... arguments) {
+        assert !(this.method == null && this.multiCastList == null) : "Delegate.invoke: both method and multicastList null";
+        Object result = null;
+        if (this.method != null) {
+            try {            
+                result = this.method.invoke(this.target, arguments);
+            } catch(IllegalAccessException e) {
+                throw new RuntimeException(e);
+            } catch(InvocationTargetException e) {
+                throw new RuntimeException(e.getCause());
+            }
+        }
+        if ( this.multiCastList != null && ! this.multiCastList.isEmpty()) {
+            for (Delegate d : this.multiCastList) {
+                result = d.invoke(arguments);
+            }
+        }
+        return (T) result;      
+    }
+
+    /*
+     * Add an additional Delegate to make a multicast invocation List on a single Delegate.
+     * The original Delegate is not inserted in the multicast List
+     */
+    public void add(Object target, String methodName){
+        //Delegate d = new Delegate(this.returnType, this.paramTypes);
+        Delegate<T> d = new Delegate<T>(this.returnType, this.paramTypes);
+        if (target instanceof Class)
+            d.init((Class)target, methodName);
+        else
+            d.init(target, methodName);
+
+        if (this.multiCastList == null) {
+            this.multiCastList = new ArrayList<Delegate<T>>();
+        }
+        this.multiCastList.add(d);
+    }
+    
+    /*
+     * Remove an entry from a multicast invocation List.
+     */
+    public void remove(Object target, String methodName){
+        if (this.multiCastList == null || this.multiCastList.isEmpty()) {
+            return;
+        }
+        Delegate found = null;
+        for (Delegate d : this.multiCastList) {
+            if (d.target == target && d.methodName == methodName) {
+                found = d;
+                break;
+            }
+        }
+        if (found != null) {
+            this.multiCastList.remove(found);
+        }
+    }
+
+    public void clear(){
+        this.target = null;
+        this.targetClass = null;
+        this.methodName = null;
+        this.multiCastList = null;
+    }
+}    
+
+
+class TestDelegate {
+
+    public static void main(String... args) { 
+        testSimple();
+        testDiffInstances();
+        testMulticast();
+        
+        Assert.end();
+    }
+    
+    static void testSimple() {
+        String s = "Testing Java Delegate!";        
+        Delegate d = new Delegate<Void>(Void.class, String.class);
+        d.init(System.out, "println"); // d.set(System.out.println)
+        d.invoke(s);
+        
+        OutputStream os = new ByteArrayOutputStream();
+        PrintStream ps = new PrintStream(os);
+        d.init(ps, "print");  // d.set(ps.print)
+        d.invoke("xx");
+        //System.out.println("["+os.toString()+"]");
+        Assert.equals(os.toString(), "xx");
+         
+        d = Delegate.allVoid(); // no args, no return
+        //d.init(System.out, "println"); // d.set(System.out.println)
+        //d.invoke();
+        os = new ByteArrayOutputStream();
+        ps = new PrintStream(os);
+        d.init(ps, "println"); // d.set(System.out.println)
+        d.invoke();
+        Assert.equals(os.toString(), System.getProperties().getProperty("line.separator"));
+        
+    }
+    
+    static class X {
+        public String getS1() { return "S1";}
+        public String getS1x(int n) { return "S1"+n; }
+    }
+
+    static class Y {
+        public String aStr() { return "Str";}
+        public String nStr(int i) { return "" + i + "Str"; }
+    }
+
+    static void testDiffInstances() {
+        Delegate<String> d = new Delegate<String>(String.class); // no arg
+        X x = new X();
+        Y y = new Y();
+        d.init(x, "getS1"); // d.set(x.getS1)
+        String s = d.invoke();
+        Assert.equals(s, "S1"); 
+        //System.out.println("[" + s + "]");
+
+        d.init(y, "aStr");  // d.set(y.aStr)
+        s = (String) d.invoke();
+        Assert.equals(s, "Str");
+    
+        Delegate<String> d1 = new Delegate<String>(String.class, int.class);
+        d1.init(x, "getS1x"); // d.set(x.getS1x)
+        String s1 = d1.invoke(99);
+        Assert.equals(s1, "S199"); 
+    
+        d1.init(y, "nStr"); // d.set(y.nStr)
+        s1 = d1.invoke(1234);
+        Assert.equals(s1, "1234Str"); 
+    }
+
+    static void testMulticast() {
+        Delegate<String> d0 = new Delegate<String>(String.class); // no args
+        X x = new X();
+        Y y = new Y();
+        d0.add(x, "getS1"); // d.add(x.getS1)
+        String s = d0.invoke();
+        Assert.nonNull(s, "s"); 
+        Assert.equals(s, "S1"); 
+    
+        d0.add(y, "aStr"); // d.set(y.nStr)
+        String s1 = d0.invoke();
+        Assert.equals(s1, "Str"); 
+        
+
+        String nl = System.getProperties().getProperty("line.separator");
+
+        Delegate<Void> d = new Delegate<Void>(void.class, String.class);
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        PrintStream ps = new PrintStream(os);
+        d.add(ps, "println"); // d.set(ps.println)
+        d.invoke("11");
+        Assert.equals(os.toString(), "11"+nl);
+        
+        d.clear();
+        os.reset();
+        d.add(ps, "println"); // d.set(ps.println)
+        d.add(ps, "print"); // d.set(ps.print)
+        d.invoke("22");
+        Assert.equals(os.toString(), "22"+nl+"22");
+        //System.out.println(nl+os.toString());
+
+        os = new ByteArrayOutputStream();
+        ps = new PrintStream(os);
+        d.clear();
+        d.add(ps, "print"); // d.set(ps.print)
+        d.add(ps, "print"); // d.set(ps.print)
+        d.add(ps, "print"); // d.set(ps.print)
+        d.invoke("33.");
+        Assert.equals(os.toString(), "33.33.33.");
+        
+        d.add(ps, "println"); // d.set(ps.println)
+        os.reset();
+        d.invoke("33.");
+        Assert.equals(os.toString(), "33.33.33.33."+nl);
+    }
+
+}
+
+class Assert {
+   static boolean assertsEnabled = false;
+   static {
+        assert assertsEnabled = true;  // Intentional side-effect!!!
+       // Now assertsEnabled is set to the correct value, true if asserts enabled, false otherwise
+   }
+
+    
+    static void equals(Object s0, Object s1) {
+        assert s0.equals(s1) : mkAssertMsg(s0, s1);
+        if (assertsEnabled)  System.out.print(".");
+    }
+    
+    static String mkAssertMsg(Object s0, Object s1) {
+        return String.format("\"%s\".equals(\"%s\")\n   arg0=[%s]\n   arg1=[%s]", s0, s1, s0, s1);
+    }
+    
+    static void nonNull(Object o, String s0 ) {
+        assert o != null : String.format("\"%s\" not Null", s0);
+        if (assertsEnabled) System.out.print("1");
+    }
+        
+    static void end() { if (assertsEnabled) System.out.println(); }
+}

Source/Cobra.Lang/Java/CobraImp.java

@@ -3 +3 @@
  * Native java support code RTL
  *
  *  Currently only stubbed, minimal native code impl.
+ * see also Cobra.Lang/NativeExtern.cobra
  */
 package cobra.lang;
 
@@ -34 +35 @@
             return sb.toString();
     }
     }
-    //static public StringMaker _printStringMaker;
+    //static public StringMaker _printStringMaker = new StringMaker();
     static public SimpleStringMaker _printStringMaker = new SimpleStringMaker();
+    static public SimpleStringMaker _techStringMaker = new SimpleStringMaker();
     
     static {
     //  _printToStack = new Stack<TextWriter>();
     //  PushPrintTo(Console.Out);
-    //_printStringMaker = new SimpleStringMaker();
     //  _printStringMaker = new PrintStringMaker();
     //  _techStringMaker = new TechStringMaker();
     //  PromoteNumerics = NumericTypeInfo.PromoteNumerics;
@@ -71 +72 @@
     static public String makeString(String s) {
         return s;
     }
+    
+    
+    
+    
+    /* IsTrue mappings */
+    static public boolean isTrue(char c) {return c!='\0';}
 
+    static public boolean isTrue(Character c) {return c!=null && c.charValue()!='\0';}
+
+    static public boolean isTrue(int i) {return i!=0;   }
+
+    static public boolean isTrue(Integer i) {return i!=null && i.intValue() !=0;}
+
+    static public boolean isTrue(long i) {return i!=0;}
+
+    static public boolean isTrue(Long i) {return i!=null && i.longValue()!=0;}
+    static public boolean isTrue(Boolean b) {return b!=null && b.booleanValue();}
+
+    /*  
+           static public boolean IsTrue(decimal d) {return d!=0;}
+           static public boolean IsTrue(decimal? d) {return d!=null && d.Value!=0;  }
+        */   
+    static public boolean isTrue(float f) {return f!=0;}
+
+    static public boolean isTrue(Float f) {return f!=null && f.floatValue()!=0.0;}
+
+    static public boolean isTrue(double d) {return d!=0; }
+
+    static public boolean isTrue(Double d) {return d!=null && d.doubleValue() !=0;}
+
+    static public boolean isTrue(String s) {return s!=null; }
+
+    static public boolean isTrue(java.util.Collection c) {return c!=null; }
+
+    static public boolean isTrue(Object x) {  //rely on unboxing??
+        if (x==null)
+            return false;
+        if (x instanceof Boolean)
+            return (boolean)(Boolean)x;
+        if (x.equals(0))
+            return false;
+        if (x instanceof Character)
+            return (Character)x != '\0';
+        //if (x instanceof decimal)
+        //  return (decimal)x!=0;  // can't believe x.Equals(0) above doesn't work for decimal. *sigh*
+        if (x instanceof Double)
+            return (Double)x!=0;
+        if (x instanceof Float)
+            return (Float)x!=0;
+        return true;
+    }
+
+    
 }
 

Source/Phases/IdentifyMainPhase.cobra

@@ -40 +40 @@
         mainMethod = mainList[0]
         if .checkMain(mainMethod)
             mainMethod.isMain = true
+            mainMethod.hasMainParams = true
             if not mainMethod.isShared
                 _createSharedMainWrapper(mainMethod)
             else
@@ -88 +89 @@
 
         instantiate = PostCallExpr(Token.empty, TypeExpr(mainMethod.parentBox), List<of Expr>())
         mainCall = CallExpr(Token.empty, 'main', List<of Expr>(), false)
+        mainCall.hasMainArgs = true # backend insert args passed to main
         dot = DotExpr(Token.empty, 'DOT', instantiate, mainCall)
 
         method = Method(Token.empty, Token.empty, theClass, 'main', List<of Param>(), .compiler.voidType, nil, ['shared'], mainMethod.attributes, '')
+        method.hasMainParams = true  # backend insert params on main method
         method.addStmt(dot)
 
         theClass.addDecl(method)

Source/BackEndClr/SharpGenerator.cobra

@@ -2293 +2293 @@
             return
         sw.write('if (CobraLangInternal.CobraCore._willCheckAssert && !')
         _expr.writeSharpDef(sw)
-        sw.write(') ')
+        sw.write(') \n') # hops add \n for readability
         sw.indent
         sw.write('throw new CobraLangInternal.AssertException([.sharpSourceSite], ')
         _expr.writeSharpBreakdown(sw)

Source/BackEndClr/ClrBackEnd.cobra

@@ -110 +110 @@
         ns.addUseDirective(UseDirective(useToken, ['System', 'IO']))
         ns.addUseDirective(UseDirective(useToken, ['System', 'Text']))
         ns.addUseDirective(UseDirective(useToken, ['Cobra', 'Lang']))
+        #ns.addUseDirective(UseDirective(useToken, ['Cobra', 'Extn']))
     
     def fixLibExtension(libRef as String) as String is override
         """

Source/BackEndJvm/to-do.text

@@ -151 +151 @@
     -> try and use BigDecimal and convert all calls (:-(
 
     Maybe easier to just default to Integer and ignore Decimal (initially)
+        or default Decimal to Double ?? 
+            tests :050-decimal.cobra
 
-
 Add convenience methods to 
     java.io.File for
         remember
@@ -260 +261 @@
     0: Treat default as Integer, map explicit decimal to float
     
 
+Default Number type to non-decimal ( float??)
+
 Delegates 
     Need some sort of placeholder for setProperties
         Drop something into CobraCore - Cobra.Lang.Delegate? (DONE)

Source/BackEndJvm/JvmBackEnd.cobra

@@ -66 +66 @@
         if parentNameSpace and parentNameSpace.fullName == 'Java.Lang'
             branch name
                 on 'Boolean', n = 'bool'
+                on 'boolean', n = 'bool'
                 #on 'SByte',   n = 'int8'
                 on 'Byte',    n = 'uint8'
+                on 'byte',    n = 'uint8'
                 on 'Short',   n = 'int16'
+                on 'short',   n = 'int16'
                 #on 'UInt16',  n = 'uint16'
                 on 'Integer',   n = 'int32'
                 #on 'UInt32',  n = 'uint32'
                 on 'Long',    n = 'int64'
-                on 'UInt64',  n = 'uint64'
+                on 'long',    n = 'int64'
+                on 'UInt64',  n = 'int64'
                 on 'Character',    n = 'char'
                 on 'Float',  n = 'float32'
                 on 'Double',  n = 'float'
-                on 'BigDecimal', n = 'decimal'
+                on 'BigDecimal', n = 'decimal' # eventually
         return n
 
     def computeOutName as String is override

Source/BackEndJvm/JavaGenerator.cobra

@@ -606 +606 @@
 class CharType is partial
 
     get javaInit as String is override
-        return '(character)0'
+        return '(char)0'
 
 
 class DynamicType is partial
@@ -620 +620 @@
 
 class FloatType is partial
 
+    #get javaInit as String is override # where not implemeneted as a primitive
+    #   return 'null'  # 'new Float(0)'
+
     get javaName as String is override
-        #return _nativeType.fullName
-        return 'float'
+        #return _nativeType.fullName # java.lang.{Double,Float}
+        # should name to primitives but not prob with JvmJarSig._aliasPrimitives
+        # TODO fix primitives float, double... vs classes java.lang.Float, java.lang.Double
+        t =  _nativeType.fullName
+        branch t 
+            on 'java.lang.Double',    primName = 'double'
+            on 'java.lang.Float',     primName = 'float' 
+            else 
+                throw FallThroughException()
+        return primName
 
 
 class IntType is partial
 
     get javaName as String is override
-        # should name to primitives but not prob fm JvmJarSig._aliasPrimitives
+        # should name to primitives but not prob with JvmJarSig._aliasPrimitives
         # TODO fix primitives int, long,... vs classes java.lang.Integer, java.lang.Long 
         #return _nativeType.fullName
         t =  _nativeType.fullName
@@ -1018 +1029 @@
 class GenericParam is partial
 
     get javaInit as String is override
-        # TODO: ack. does Java have anything like this?
-        return 'default([_name])'
+        return 'null /*default([_name])*/' # not poss in java
 
     def writeJavaDef(sw as CurlyWriter)
         base.writeJavaDef(sw)
@@ -1121 +1131 @@
 class LocalVar is partial
 
     def writeJavaDef(sw as CurlyWriter)
-        base.writeSharpDef(sw)
+        base.writeJavaDef(sw)
         sw.write('[.type.javaRef] [.javaName]')
         init = .type.javaInit
         if init.length, sw.write(' = [init]')
@@ -1587 +1597 @@
             name = _implementsType.javaRef + '.' + name
         .writeJavaIsNames(sw)
         sw.write('[returnType.javaRef] [name][.javaGenericParams]')
-        if .isMain  
+        if .hasMainParams   # insert args for main method for this backend
             sw.write(r'(String[] args)')
         else
             .writeJavaParams(sw)
@@ -1887 +1897 @@
         #_expr.writeJavaBreakdown(sw)
         #sw.write('[.javaThis]')
         sw.write(' : ')
+        sw.write('String.format("assertion %s FAILED", ')
+        #sw.write('"assertion " + ')
+        tmpsw = CurlyWriter(StringWriter(), sw.curlyLineNumberTreatment)
+        _expr.writeJavaDef(tmpsw)
+        #sw.write(tmpsw.toString.replace('"', r'\"'))
+        sw.write(Utils.javaStringLiteralFor(tmpsw.toString))
+        #sw.write('" + " FAILED "')
+        sw.write(')')
         if _info
-            sw.write('"')
+            sw.write(' + "info="+')
             _info.writeJavaDef(sw)
-            sw.write('"')
-        else
-            sw.write('"assertion ')
-            tmpsw = CurlyWriter(StringWriter(), sw.curlyLineNumberTreatment)
-            _expr.writeJavaDef(tmpsw)
-            sw.write(tmpsw.toString.replace('"', r'\"'))
-            sw.write(' FAILED"')
         sw.write(';\n')
         sw.dedent
 
@@ -2453 +2464 @@
             sw.write(sep)
             arg.writeJavaDefInContext(sw)
             sep = ', '
+        if .hasMainArgs         # for MainWrapper - pass through args fm main method
+            sw.write('args')    # same name(s) as inserted args on main method 
         sw.write(')')
 
     def writeJavaBreakdownItems(sw as CurlyWriter) is override
@@ -2678 +2691 @@
             on Treatment.AsIs
                 _expr.writeJavaDef(sw, parens)
             on Treatment.InvokeRuntime
-                sw.write('CobraLangInternal.CobraImp.IsTrue(')
+                sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.isTrue(')
                 _expr.writeJavaDef(sw, false)
                 sw.write(')')               
             on Treatment.CompareToZero
-                sw.write('[lparen]0!=')
+                sw.write('[lparen]0 != ')
                 _expr.writeJavaDef(sw, true)
                 sw.write(rparen)
             on Treatment.CompareToZeroChar
-                sw.write("[lparen]'\\0'!=")
+                sw.write("[lparen]'\\0' != ")
                 _expr.writeJavaDef(sw, true)
                 sw.write(rparen)
             on Treatment.CompareToNull
-                sw.write('[lparen]null!=')
+                sw.write('[lparen] null!= ')
                 _expr.writeJavaDef(sw, true)
                 sw.write(rparen)
 
@@ -2790 +2803 @@
 class Literal
     is partial
 
-    def asJava as String
+    get asJava as String
         return '/* TODO_Literal */'
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
@@ -2803 +2816 @@
     get willWriteJavaBreakdownItems as bool is override
         return false
 
+
+        
+class BoolLit
+    is partial
+
+    get asJava as String is override
+        return if(_value, 'true', 'false')
+
+
+class CharLit
+    is partial
+
+    get asJava as String is override
+        if _value[0] to int == 39, return "'\\''"  # single quote
+        else, return "'" + _value.toString + "'"
+            
+        
+class DecimalLit
+    is partial
+
+    get asJava as String is override
+        return _value.toString(Utils.cultureInfoForNumbers) + '/*decimal*/'
+
+
+class FractionalLit
+    is partial
+
+    get asJava as String is override
+        if _type == .compiler.floatType(32), suffix = 'f'
+        else if _type == .compiler.floatType(64), suffix = ''
+        else if _type == .compiler.decimalType, suffix = '/*decimal*/'
+        else, throw FallThroughException(_type)
+        return _value.toString(Utils.cultureInfoForNumbers) + suffix
+
+
+class FloatLit
+    is partial
+
+    get asJava as String is override
+        # suppose you have the literal: 0.00001
+        # using 'F' format for 'fixed point' gives '0.00' which loses the original value
+        # using 'R' format for 'round trip' gives '1E-05'
+        s = _value.toString('R', Utils.cultureInfoForNumbers)
+        if s.indexOf('.') == -1 and 'E' not in s, s += '.0'
+        if (.type to FloatType).size == 32, s += 'f' 
+        else, s += 'd'
+        return s
+
 class IntegerLit is partial
 
-    def asJava as String is override
+    get asJava as String is override
         s = ''
         if (info = .token.info) inherits int
             branch info
@@ -2822 +2883 @@
             return _value.toString + s
         else
             return '([s])[_value.toString]'
-        
-class BoolLit
-    is partial
 
-    def asJava as String is override
-        return if(_value, 'true', 'false')
-
-
-class CharLit
-    is partial
-
-    def asJava as String is override
-        if _value[0] to int == 39, return "'\\''"  # single quote
-        else, return "'" + _value.toString + "'"
-            
-        
 class NilLiteral
     is partial
 
-    def asJava as String is override
+    get asJava as String is override
         return 'null'
 
 class StringLit is partial
 
-    def asJava as String is override
+    get asJava as String is override
         return Utils.javaStringLiteralFor(_string)
     
 class StringSubstLit is partial
@@ -2875 +2921 @@
 
 class BaseLit is partial
 
-    def asJava as String is override
+    get asJava as String is override
         return 'super'
 
 
 class ThisLit is partial
 
-    def asJava as String is override
+    get asJava as String is override
         return .compiler.curBox.javaThis
 
 
 class VarLit is partial
 
-    def asJava as String is override
+    get asJava as String is override
         return _name
 
 class ToNilableOrNotExpr
@@ -3042 +3088 @@
             assert _left.definition inherits IVar
             _left.definition.ifInheritsStack = Stack<of IType>(_backUpIfInheritsStack)
 
+
+class NumericPromoExpr is partial
+
+    def _writeJavaDefDynamic(sw as CurlyWriter)
+        specs = OperatorSpecs.binaryOpSpecsByCobraText
+        assert specs.containsKey(.token.text)
+        spec = specs[.token.text]
+        opText = Utils.javaStringLiteralFor(spec.opMethodName)
+        sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.DynamicOp([opText], ')
+        _left.writeJavaDef(sw)
+        sw.write(', ')
+        _right.writeJavaDef(sw)
+        sw.write(')')
+
+
+class AugAssignMathExpr is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        if .isConcated
+            _writeJavaDefConcated(sw)
+        else if _type.isDynamic
+            _writeJavaDefDynamic(sw)
+        else
+            _writeJavaDefOperation(sw)
+
+    def _writeJavaDefConcated(sw as CurlyWriter)
+        _left.writeJavaDef(sw, false)
+        sw.write(' = ')
+        sw.write('(' + _left.type.javaRef + ')')
+        sw.write('CobraLangInternal.CobraImp.Concated(')
+        _left.writeJavaDef(sw, false)
+        sw.write(', ')
+        _right.writeJavaDef(sw, false)
+        sw.write(')')
+
+    def _writeJavaDefDynamic(sw as CurlyWriter) is override
+        _left.writeJavaDef(sw)
+        sw.write(' = ')
+        specs = OperatorSpecs.binaryOpSpecsByCobraText
+        assert specs.containsKey(.token.text)
+        spec = specs[.token.text]
+        opText = Utils.javaStringLiteralFor(spec.opMethodName)
+        sw.write('CobraLangInternal.CobraImp.DynamicOp([opText], ')
+        _left.writeJavaDef(sw)  # TODO: add , false
+        sw.write(', ')
+        _right.writeJavaDef(sw)  # TODO: add , false
+        sw.write(')')
+
+    def _writeJavaDefOperation(sw as CurlyWriter)
+        op = ''
+        sep = ','  # for the method call case
+        branch _op
+            on 'PLUS_EQUALS'
+                op = '+='
+            on 'MINUS_EQUALS'
+                op = '-='
+            on 'STAR_EQUALS'
+                op = '*='
+            on 'STARSTAR_EQUALS'
+                #op = 'CobraLangInternal.CobraImp.PowerToEquals('
+                op = 'java.lang.Math.pow('
+            on 'SLASH_EQUALS'
+                op = '/='  # TODO: finish this
+            on 'SLASHSLASH_EQUALS'
+                op = '/='  # TODO: finish this
+            on 'PERCENT_EQUALS'
+                op = '%='
+            else
+                throw FallThroughException(_op)
+        assert op.length
+        if op.length==2
+            _left.writeJavaDef(sw)
+            sw.write(op)
+            _right.writeJavaDef(sw)
+        else
+            sw.write(op)  # ex: 'CobraLangInternal.CobraImp.Foo('
+            _left.writeJavaDef(sw)
+            sw.write(sep)
+            _right.writeJavaDef(sw)
+            sw.write(')')
+
+
+class AugAssignBitwiseExpr
+    is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        if _left.type.isDynamic
+            _left.writeJavaDef(sw)
+            sw.write(' = ')
+            specs = OperatorSpecs.binaryOpSpecsByCobraText
+            assert specs.containsKey(.token.text)
+            spec = specs[.token.text]
+            opText = Utils.javaStringLiteralFor(spec.opMethodName)
+            sw.write('CobraLangInternal.CobraImp.DynamicOp([opText], ')
+            _left.writeJavaDef(sw)  # TODO: add , false
+            sw.write(', ')
+            _right.writeJavaDef(sw)  # TODO: add , false
+            sw.write(')')
+            return
+        op = ''
+        branch _op
+            on 'AMPERSAND_EQUALS'
+                op = '&='
+            on 'VERTICAL_BAR_EQUALS'
+                op = '|='
+            on 'CARET_EQUALS'
+                op = '^='
+            on 'DOUBLE_LT_EQUALS'
+                op = '<<='
+            on 'DOUBLE_GT_EQUALS'
+                op = '>>='
+            else
+                throw FallThroughException(_op)
+        assert op.length
+        _left.writeJavaDef(sw)
+        sw.write(op)
+        _right.writeJavaDef(sw)
+
+
+class BinaryBoolExpr
+    is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        if _op=='IMPLIES'
+            sw.write('!')
+        _left.writeJavaDef(sw)
+        branch _op
+            on 'AND'
+                sw.write('&&')
+            on 'OR' or 'IMPLIES'
+                sw.write('||')
+        _right.writeJavaDef(sw)
+
+    def _writeJavaBreakdownItemsRight(sw as CurlyWriter) is override
+        # have to respect the short circuit otherwise something like "s and s.length" will give
+        # NullReference exception for "s.length"
+        # solution is: given L and R,
+        # write:   "R", (!(L) ? "short-circuted" : (R).ToString())
+        # that's for 'AND'. for, 'OR', remove the !, for 'IMPLIES' it's like AND
+
+        # so rather than:
+        # _right.writeJavaBreakdownItems(sw)
+        # do this:
+        src = Utils.javaStringLiteralFor(_right.toCobraSource)
+        javaNot = if(_op=='OR', '', '!')
+        sw.write(', [src], new CobraLangInternal.CobraDirectString([javaNot]')
+        _left.writeJavaDefForBreakdown(sw)
+        sw.write(' ? "(short-circuited)" : CobraLangInternal.CobraCore.ToTechString(')
+        _right.writeJavaDefForBreakdown(sw)
+        sw.write('))')
+
+        
+
+class BinaryBitwiseExpr
+    is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        if _type.isDynamic
+            _writeJavaDefDynamic(sw)
+            return
+        op = ''
+        branch _op
+            on 'AMPERSAND'
+                op = '&'
+            on 'VERTICAL_BAR'
+                op = '|'
+            on 'CARET'
+                op = '^'
+            on 'DOUBLE_LT'
+                op = '<<'
+            on 'DOUBLE_GT'
+                op = '>>'
+            else
+                throw FallThroughException(_op)
+        assert op.length
+        _left.writeJavaDef(sw)
+        sw.write(op)
+        _right.writeJavaDef(sw)
+
+
+class BinaryMathExpr is partial
+
+    def _writeJavaDef(sw as CurlyWriter) is override
+        if .isConcated
+            _writeJavaDefConcated(sw)
+        else if _type.isDynamic
+            _writeJavaDefDynamic(sw)
+        else
+            _writeJavaDefOperation(sw)
+
+    def _writeJavaDefConcated(sw as CurlyWriter)
+        sw.write('(' + _left.type.javaRef + ')')
+        sw.write('CobraLangInternal.CobraImp.Concated(')
+        _left.writeJavaDef(sw, false)
+        sw.write(', ')
+        _right.writeJavaDef(sw, false)
+        sw.write(')')
+
+    def _writeJavaDefOperation(sw as CurlyWriter)
+        intType = .compiler.anyIntType
+        left = _left
+        right = _right
+        op = ''
+        pre = ''
+        sep = ','  # for the method call case
+        branch _op
+            on 'PLUS'
+                op = '+'
+            on 'MINUS'
+                op = '-'
+            on 'STAR'
+                op = '*'
+            on 'STARSTAR'
+                #op = 'CobraLangInternal.CobraImp.PowerTo('
+                op = 'System.Math.Pow('
+                if _left.isKindOf(intType) and _right.isKindOf(intType)
+                    pre = '(' + .compiler.intType.javaRef + ')'
+            on 'SLASH'
+                op = '/'
+                if _left.isKindOf(intType) and _right.isKindOf(intType)
+                    pre = '(' + .compiler.numberType.javaRef + ')'
+            on 'SLASHSLASH'
+                if left.isKindOf(intType) and right.isKindOf(intType)
+                    op = '/'
+                else if left.isKindOf(.compiler.decimalType) or right.isKindOf(.compiler.decimalType)
+                    #op = 'System.Decimal.Floor('
+                    op = 'java.lang.Math.floor('
+                    sep = '/'
+                else if left.isKindOf(.compiler.anyFloatType) or right.isKindOf(.compiler.anyFloatType)
+                    op = 'java.lang.Math.floor('
+                    sep = '/'
+                else
+                    throw FallThroughException([left.type, right.type])
+            on 'PERCENT'
+                op = '%'
+            else
+                throw FallThroughException(_op)
+        assert op.length
+        sw.write(pre)
+        if op.length==1
+            _left.writeJavaDef(sw)
+            sw.write(op)
+            _right.writeJavaDef(sw)
+        else
+            sw.write(op)  # ex: 'CobraLangInternal.CobraImp.Foo('
+            _left.writeJavaDef(sw)
+            sw.write(sep)
+            _right.writeJavaDef(sw)
+            sw.write(')')
+
 class CompareExpr
     is partial
 
@@ -3244 +3540 @@
     def _writeJavaDef(sw as CurlyWriter) is override
         _left.writeJavaDef(sw)
         sw.write(' instanceof ')
-        _right.writeSharpDef(sw, false)
+        _right.writeJavaDef(sw, false)
 
 
 class ToExpr is partial
@@ -3508 +3804 @@
         base.writeJavaBreakdownItems(sw)
         # TODO
 
-class SharpExpr
+class SharpExpr  # should become JavaExpr or BackEndExpr
     is partial
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
@@ -3555 +3851 @@
 
 class ThisOrBaseLit is partial
 
-    def asJava as String is override
+    get asJava as String is override
         return 'this'
         
 class ContractPart is partial

Source/TestifyRunner.cobra

@@ -407 +407 @@
         options['willRunExe'] = _willRunExes # internal, specific to testify
 
         firstLine = ''
+        count0 = lines.count
         rc = _processFirstlineDirectives(baseName, fileNames, inout lines, inout options, out firstLine)
         if rc == 0, return 0
         firstLineInsensitive = firstLine.trim.replace(' ', '')
-        
+        nRemovedLines = count0 - lines.count
         # Check for inline warning and error messages that are expected.
         # (Starting in 2007-12 this is now the preferred way to specify these messages--
         #  with the actual line of code that generates them.
         #  The old method of specifying at the top will still be needed for errors
         #  and warnings that have no associated line number.)
         expectingError = false
-        inLineMessages = _getInlineMessages(lines, out expectingError)
+        inLineMessages = _getInlineMessages(lines, nRemovedLines, out expectingError)
         if inLineMessages.count > 0 #  hasInlineMessages
             return _testifyInlineMessages(inLineMessages, expectingError, 
                                             compilerVerbosity, [baseName], options, verbose )
 
         if firstLineInsensitive.startsWith('#.error.')
             # deprecated: put errors on the lines where they occur. the "hasInlineMessages" code above will detect them.
-            # note that errors that are only detected by the backend C# compiler are not detectable by testify
+            # Note that errors that are only detected by the backend C# compiler are not detectable by testify
             # CC: support split with a String extension method
             # error = firstLine.split('.error.',1)[1].trim.toLower
             index = firstLine.indexOf('.error.')
@@ -548 +549 @@
 
         return 1 # continue processing in caller
         
-    def _getInlineMessages(lines as List<of String>, expectingError as out bool) as Dictionary<of int, String>
+    def _getInlineMessages(lines as List<of String>, offset as int, expectingError as out bool) as Dictionary<of int, String>
         """ Walk lines and accumulate inline warnings and error messages. """
         inLineMessages = Dictionary<of int, String>()
-        lineNum = 1
+        firstLine = 1 + offset
+        lineNum = firstLine
         expectingError = false
         for line in lines
-            if lineNum > 1 and ('.warning.' in line or '.error.' in line)
+            if lineNum > firstLine and ('.warning.' in line or '.error.' in line)
                 if '.warning.' in line
                     message = line[line.indexOf('.warning.') + '.warning.'.length:]
                     messageType = 'w'

Tests/100-basics/050-decimal.cobra

@@ +1 @@
+#.require. clr
+# revisit this for Java when decide and implement what to do about Decimal Type 
 namespace Test
     
     class Test

Tests/100-basics/052-float.cobra

@@ +1 @@
+# .require. clr
+# This is clr specific re inheritance of literals and floats 
 namespace Test
     
     class Test

Tests/100-basics/052j-float.cobra

@@ +1 @@
+# .require. jvm
+namespace Test
+    
+    class Test
+        
+        def main
+            is shared
+            
+            f as float = 1.0f
+            assert f
+            assert f==1.0f
+            assert f==1
+    
+            sum as float = 0.1f+0.1f+0.1f+0.1f+0.1f+0.1f+0.1f+0.1f+0.1f+0.1f
+            assert sum<>1.0f
+            assert sum<>0.1f*10
+
+            ff = Float(1.0f)
+            assert ff inherits Float  # .warning. is always
+            ii = Integer(1)
+            #assert not (ii inherits Float)  # .warning. is never
+                # above also throws compiler error
+            o as Object = ii
+            assert not (o inherits Float)  
+
+            g as float = 2f
+            assert g
+            assert g == 2.0f
+            assert g == 2.00f
+            assert g == 2
+            assert g == f + f
+
+            # small numbers
+            a = 0.00001f
+            b = 0.000001f
+            assert a > b
+
+            # can assign ints to floats
+            f = 7
+
+            # can compare ints and floats
+            assert f > 0
+            assert 0 < f