Ticket #275: java-jvm-5.patch

Source/BackEndObjC/ObjcBackEnd.cobra

@@ -77 +77 @@
     def readSystemTypes is override
         pass
     
-    def fixNilableMemberSigs is override
+    def fixMemberSigs is override
         pass
 
     def installNativeMethods(box as Box, nativeType as NativeType) is override

Source/Compiler.cobra

@@ -134 +134 @@
     def readSystemTypes is abstract
         """ Read and Load System Types for backend for Compiler to make available"""
         
-    def fixNilableMemberSigs is abstract
+    def fixMemberSigs is abstract
         """         
         Most backends dont natively support nilablility, this marks/fixes the common backend
         class signatures that should be marked nilable.
@@ -253 +253 @@
     def readSystemTypes is override
         pass
     
-    def fixNilableMemberSigs is override
+    def fixMemberSigs is override
         pass
     
     def installNativeMethods(box as Box, nativeType as NativeType) is override
@@ -1053 +1053 @@
             if .referenceVerbosity, print '[lre] in _loadReference("[reference]")'
             return false
 
-    def fixNilableMemberSigs
-        .backEnd.fixNilableMemberSigs
+    def fixMemberSigs
+        .backEnd.fixMemberSigs
     
     def installNativeMethods(box as Box, nativeType as NativeType) 
         .backEnd.installNativeMethods(box, nativeType)
@@ -1354 +1354 @@
         thing as IContainer? = nil
         for name in names
             possible = (thing ? ns).declForName(name)
+            #print name
             assert possible, name
             if possible inherits IContainer
                 thing = possible

Source/Expr.cobra

@@ -162 +162 @@
         body
             return .isKindOf(.compiler.collectionType) or .isKindOf(.compiler.collectionOfType)
 
+    def isKindOfNonNil(type as IType) as bool
+        require
+            .type
+            .compiler
+        body
+            return .type.nonNil.isDescendantOf(type)
+        
     get isObjectLiteral as bool
         return false
 
@@ -1408 +1415 @@
             if arg.canBeAssignedTo(param.type)
                 arg.contextType = param.type
             else
-                if false
+                if true
                     print '<> arg = ' stop
                     arg.writeDeepString
                     print '<> param = ' stop

Source/Boxes.cobra

@@ -1235 +1235 @@
         base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)
         if nativeType.baseType
             _baseNode = backend.nativeTypeProxy(nativeType.baseType to !)
+        else if nativeType.name <> 'Object'
+            print 'No baseType for [nativeType.name]'
         _initNativeType(nativeType)
         
     def addRefFields

Source/Cobra.Lang/Java/CobraCore.java

@@ -9 +9 @@
  */
 package cobra.lang;
 
+import java.util.*;
+
 //interface IHasSourceSite {
 //    public SourceSite getSourceSite();
 //}
@@ -25 +27 @@
     //public static String getRuntimePlatform() { return "jvm"; } // prop
     public static final String runtimePlatform =  "jvm"; 
     
+    // property willCheckAssert
     public static boolean getWillCheckAssert() { return _willCheckAssert; }
     public static void    setWillCheckAssert(boolean b) { _willCheckAssert = b; }
     
+    public static List<String> commandLineArgs = new ArrayList<String>();
+
+    // Compiler inserts calls to this to initialize commandLineArgs
+    public static void _recordCommandLine(String[] args) {
+        commandLineArgs.addAll(java.util.Arrays.asList(args));
+        StackTraceElement[] stack = Thread.currentThread ().getStackTrace();
+        StackTraceElement main = stack[stack.length - 1];
+        String mainClass = main.getClassName();    
+        commandLineArgs.add(0, mainClass);
+    }
+    
+    public static void exit(int exitCode) {
+        //""" Exits the process. """
+    System.exit(exitCode);
+    }
+            
+    public static String newLine =  System.getProperty("line.separator");
+    //""" Returns the newline for the current environment/platform. """
+
     // Property StringMaker techStringMaker
     /*
      *  Used by `assert` failures, `trace` statements and .toTechString methods.
@@ -35 +57 @@
     static public CobraImp.SimpleStringMaker getTechStringMaker() { return CobraImp._techStringMaker; }
     static public void setTechStringMaker(CobraImp.SimpleStringMaker value) { CobraImp._techStringMaker = value; }
     
+    static public String toTechString(Object x) 
+    {
+    return CobraImp.toTechString(x);
+    }
+    
     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/PkgSig.java

@@ -492 +492 @@
         System.out.printf( "%-30s %s\n", t, "# JavaType");
         
         printIndent();
-        String pkgName = this.cls.getPackage().getName();
+        String pkgName = "";
+        if (this.cls.getPackage() != null)
+            pkgName = this.cls.getPackage().getName();
         System.out.printf("%-30s %s\n", pkgName, "# package");
         
         // Name of the class(without pkgname), dotNet form for Generic class

Source/Cobra.Lang/Java/mkjar

@@ -1 @@
-#!bash
+#!/bin/bash
 # Build script for java sources for cobra
 # Compile java source classes for java cobra RTL
 # copy them and std sig files to Source dir 
 
 [ -d classes ] || mkdir classes
-javac -d classes CobraImp.java CobraCore.java Delegate.java
+[ -d classes/cobra/lang ] && rm -rf classes/cobra/lang/*
+javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java AssertException.java CobraDirectString.java
 [ $? == 0 ] || exit
 jar cvf CobraLang.jar -C classes .
 [ $? == 0 ] || exit

Source/Cobra.Lang/Java/DynamicOperationException.java

@@ +1 @@
+/*
+*  Dynamic Operations Exceptions
+*/
+package cobra.lang;
+
+import java.util.*;
+
+
+    //## Exceptions about dynamic
+
+public class DynamicOperationException extends RuntimeException
+{ 
+   //"""
+   // The base class for all dynamic operation exceptions.
+   //"""
+
+    public DynamicOperationException(String message) { this(message, nil); }
+    public DynamicOperationException(String message, cause as Exception ) {super(message, cause); }
+}
+
+class CannotEnumerateException extends DynamicOperationException 
+{
+    public CannotEnumerateException (String message) {this(message, nil); }
+    public CannotEnumerateException (String message, Exception cause) {super(message, cause); }
+}       
+        
+class UnknownMemberException extends DynamicOperationException
+{
+    protected Object _obj;
+    protected String _name;
+    Class _type;
+
+    public UnknownMemberException(Object obj, String name as String, Class type) {  this(obj, name, type, nil);}
+    public UnknownMemberException(Object obj, String name as String, Class type, Exception cause) 
+    {
+    super(String.format("obj=%s, name=%s, type=%s", 
+                  CobraCore.toTechString(obj), CobraCore.toTechString(name), type),
+              cause);
+        this._obj = obj;
+        this._name = name;
+        this.type = type;
+    }
+}
+
+/*
+ * Missing, unreadable Member Exceptions
+ * / 
+class CannotReadPropertyException 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 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
+
+
+
+*/

Source/Cobra.Lang/Java/SourceSite.java

@@ +1 @@
+/*
+ * Sourcesite.java
+ */
+ 
+package cobra.lang;
+
+import java.io.*;
+
+public class SourceSite {
+    /* 
+     * See Cobra.Lang.SourceSite.cobra
+     * 
+     *  A SourceSite instance captures the source location of a statement or expression, as in the
+     *  filename, line number, declaring class name, method name and run-time object. The Cobra
+     *  compiler generates SourceSite instances in various circumstances; for example, the `trace`
+     *  statement.
+     */
+
+    protected String _fileName; 
+    protected int    _lineNum;
+    protected String _className;
+        protected String _memberName;
+        protected Object _object;
+
+    public SourceSite(String fileName, int lineNum, String className, String memberName, Object obj ) {
+            this._fileName = fileName;
+            this._lineNum = lineNum;
+        this._className = className;
+            this._memberName = memberName;
+            this._object = obj;
+        }
+
+        @Override
+        public String toString() {
+            //  test
+            //      si = SourceSite('Foo.cobra', 10, 'Object', 'bar', BadToString())
+            //      assert 'Foo.cobra' in si.toString
+            //      assert 'exception on' in si.toString
+            Object obj;
+            try {
+                obj = CobraCore.toTechString(this._object);
+            }
+            catch (Exception exc) {
+                obj = String.format("(.toTechString or .toString exception on a %s: %s: %s)", _object.getClass().getName(), exc.getClass().getName(), exc.getMessage() );
+            }
+            return String.format("%s:%d in %s.%s for object %s", this._fileName, this._lineNum, this._className,this._memberName, obj);
+        }
+
+        // Property fileName
+        public String getFileName() { return this._fileName; }
+            
+        // Property lineNum
+        public int getLineNum()  { return this._lineNum; }
+
+        // Property className
+    public String getClassName()  { return this._className; }
+
+        // Property memberName
+    public String getMemberName()  { return this._memberName; }
+
+        // Property object
+    public Object getObject()  { return this._object; }
+
+        // Property runTimeClassName
+        public  String getRunTimeClassname() {  return this._object.getClass().getName(); }
+
+        public String oneLiner(String sep ) {
+            return oneLiner(sep, true);
+        }
+
+        public String oneLiner(String sep, boolean  willOutputDirectoryNames) {
+            //test
+        //  si = SourceSite('Foo.cobra', 10, 'Object', 'bar', Object())
+            //  assert si.oneLiner('; ', true) == 'at Foo.cobra:10; in Object.bar'
+        //  si = SourceSite('Foo.cobra', 10, 'Foo', 'bar', Object())
+        //  assert si.oneLiner('; ', true) == 'at Foo.cobra:10; in Foo.bar; subclass Object'
+        //body
+        StringBuilder sb = new StringBuilder();
+            String fileName = this._fileName;
+            if ( _fileName.length()>0 && ! willOutputDirectoryNames) 
+                fileName = (new File((this._fileName)).getName());
+            sb.append( String.format("at %s:%d%sin %s.%s", 
+                      fileName, this._lineNum, sep, this._className, this._memberName));
+            if ( ! (this._object instanceof Class)) {
+                String name = this.getClass().getName();
+            if ( name != _className) 
+                    sb.append( String.format("%ssubclass %s", sep, name));
+            }
+            return sb.toString();
+        }
+
+        public String htmlForAt() {
+            return htmlForAtArgs(this._fileName, this._lineNum);
+        }
+
+        static public String htmlForAtArgs(String fileName, int lineNum ) {
+            //"""
+            // Returns the HTML for the row labeled "at" in the Cobra Exception Report.
+            // This will be an actual link if the environment variable COBRA_EDIT_LINK is set.
+            // That's what enables clicking on sources in the report to jump to their location in a text editor.
+            //"""
+            File f = new File(fileName);
+            String baseName = f.getName();
+            String dirName = f.getParent();
+            if (dirName.length() != 0)
+                dirName = " in " + dirName;
+            String s = "line " + lineNum + "of " + baseName + dirName;
+            String editLink = System.getenv("COBRA_EDIT_LINK");
+            if (editLink != null && editLink.length() >0) {
+                editLink = editLink.replace("FILE", fileName); //  # TODO: url encode the file name
+                editLink = editLink.replace("LINE", "" + lineNum);
+                s = "<a href=\""+ editLink + "\">[s]</a>";
+            }
+            return s;
+        }
+}

Source/Cobra.Lang/Java/mkjarOnly

@@ +1 @@
+#!/bin/bash
+# Build script for java sources for cobra
+# Compile java source classes for java cobra RTL
+# copy them and std sig files to Source dir 
+
+[ -d classes ] || mkdir classes
+[ -d classes/cobra/lang ] && rm -rf classes/cobra/lang/*
+javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java AssertException.java CobraDirectString.java
+[ $? == 0 ] || exit
+jar cvf CobraLang.jar -C classes .
+[ $? == 0 ] || exit
+cp CobraLang.jar ../..
+
+#echo 'pkgSig for CobraLang.jar'
+#java -cp '.;CobraLang.jar'  PkgSig -j CobraLang.jar > CobraLang.jar.sig
+#cp CobraLang.jar.sig  ../..
+
+
+## assume rt.jar, java.util and java.lang sigfiles already exist and are static
+#cp CobraLang.jar.sig rt.jar.sig java.util.sig java.lang.sig ../..

Source/Cobra.Lang/Java/CobraImp.java

@@ -17 +17 @@
         
         public String makeString(String[] args) {
             StringBuilder sb = new StringBuilder();
-        for (Object arg : args)
-        sb.append(arg);
+            for (Object arg : args)
+                sb.append(arg);
             return sb.toString();
-    }
+        }
         public String makeString(String s) {
             return s;
-    }
+        }
         public String makeString(int i) {
             return new Integer(i).toString();
-    }
+        }
         
+        public String makeString(char i) {
+            return new Character(i).toString();
+        }
+        
         public String makeString(Object... args) {
             StringBuilder sb = new StringBuilder();
-        for (Object arg : args)
-        sb.append(arg.toString());
+            for (Object arg : args)
+                sb.append(arg.toString());
             return sb.toString();
-    }
+        }
     }
     //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 PrintStringMaker();
-    //  _techStringMaker = new TechStringMaker();
-    //  PromoteNumerics = NumericTypeInfo.PromoteNumerics;
-    }
+        //  _printToStack = new Stack<TextWriter>();
+        //  PushPrintTo(Console.Out);
+        //  _printStringMaker = new PrintStringMaker();
+        //  _techStringMaker = new TechStringMaker();
+        //  PromoteNumerics = NumericTypeInfo.PromoteNumerics;
+        }
     
     static public void printLine() {
-    //_printToStack.Peek().WriteLine();
+        //_printToStack.Peek().WriteLine();
         System.out.println();
     }
 
     static public void printLine(String s) {
-    //  _printToStack.Peek().WriteLine(s);
+        //      _printToStack.Peek().WriteLine(s);
         System.out.println(s);
     }
 
@@ -61 +65 @@
     }
 
     static public void printStop(String s) {
-    //  _printToStack.Peek().Write(s);
+        //      _printToStack.Peek().Write(s);
         System.out.print(s);
     }
 
@@ -73 +77 @@
         return s;
     }
     
+    static public Object checkNonNil(Object obj, String sourceCode, Object value, /* SourceSite */ String fileName, int lineNum, String className, String memberName, Object thiss) 
+    {
+        // used for "x to !" and "someNilable to SomethingNotNilable"
+        if (value == null) {
+            List<Object> l = new ArrayList<Object>();
+            l.add(0);
+            l.add(sourceCode);
+            l.add(value);
+            throw new NonNilCastException( new SourceSite(fileName, lineNum, className, memberName, thiss),
+                      l, obj, null  );
+        }
+        return value;
+    }
     
+ /*   
+    static public String toTechString(boolean x) 
+    { 
+        return x ? "true" : "false";
+    }
     
+    static public String toTechString(byte x) 
+    { 
+        return "" + x;
+    }
+    static public String toTechString(int x) 
+    { 
+        return "" + x;
+    }
+    static public String toTechString(short x) 
+    { 
+        return "" + x;
+    }
+    static public String toTechString(long x) 
+    { 
+        return "" + x;
+    }
+   */ 
+    static public String toTechString(Object x) 
+    {
+        if (x == null)
+            return "nil";
+        if (x instanceof Boolean)
+            return String.format("%b", (Boolean)x ? "true" : "false");
+        if (x instanceof String) 
+        {  // TODO: handle double backslash
+            String s = (String)x;
+            s = s.replace("\n", "\\n");
+            s = s.replace("\r", "\\r");
+            s = s.replace("\t", "\\t");
+            s = "'" + s + "'";  // TODO: could be more sophisticated with respect to ' and "
+            return s;
+        }
+        if (x instanceof java.util.List) 
+        {
+            // TODO: should not go into infinite loop for circular references
+            StringBuilder sb = new StringBuilder();
+            sb.append(x.getClass().getName() );
+            sb.append("[");          
+            String sep = "";
+            for (Object item : (java.util.List)x) 
+            {
+                sb.append(sep);
+                sb.append( toTechString(item) );
+                sep = ", ";
+            }
+            sb.append("]");
+            return sb.toString();
+        }
+        if (x instanceof java.util.Map) 
+        {
+            // TODO: should not go into infinite loop for circular references
+            Map idict = (java.util.Map)x;
+            StringBuilder sb = new StringBuilder();
+            sb.append( x.getClass().getName()); 
+            sb.append("{");
+            String sep = "";
+            for (Object key : idict.keySet()) {
+                 sb.append( String.format("$1s%2$s: %3$s", sep, toTechString(key), toTechString(idict.get(key))) );
+                 sep = ", ";
+            }
+            sb.append("}");
+            return sb.toString();
+        }
+        if (x instanceof java.lang.Iterable)
+        {
+            // TODO: should not go into infinite loop for circular references
+            java.lang.Iterable iter = (java.lang.Iterable)x;
+            StringBuilder sb = new StringBuilder();
+            sb.append(x.getClass().getName());
+            sb.append("[");
+            String sep = "";
+            for (Object item : iter) 
+            {
+                sb.append(String.format("%1$s%2$s", sep, toTechString(item)));
+                sep = ", ";
+            }
+            sb.append("]");
+            return sb.toString();
+        }
+        if (x instanceof java.lang.Enum) 
+        {
+            return x.getClass().getName() + "." + x.toString() + " enum";
+        }
+
+        // TODO: For StringBuilder, return StringBuilder'aoeu'
+        String tts = x.toString();
+        if (isInterestingClass(x.getClass())) 
+        {
+            String typeName = x.getClass().getName();
+            if (!tts.contains(typeName) && !(x instanceof CobraDirectString))
+                tts = String.format("%1$s (%2$s)", tts, typeName);
+        }
+        return tts;
+    }
+
+    static boolean isInterestingClass(Class t) 
+    {
+        if (t == java.lang.Integer.class)
+            return false;
+        if (t == java.lang.Character.class)
+            return false;
+        if (t == java.lang.Boolean.class)
+           return false;
+        return true;
+   }
     
+    
+    
     /* IsTrue mappings */
-    static public boolean isTrue(char c) {return c!='\0';}
+    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(Character c) {return c!=null && c.charValue()!='\0';}
 
-    static public boolean isTrue(int i) {return i!=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(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!=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(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(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!=0;}
 
-    static public boolean isTrue(Float f) {return f!=null && f.floatValue()!=0.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!=0; }
 
-    static public boolean isTrue(Double d) {return d!=null && d.doubleValue() !=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(String s) {return s!=null; }
 
-    static public boolean isTrue(java.util.Collection c) {return c!=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;
-    }
-
+    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;
+    }
     
+    static public boolean referenceEquals(Object o, Object o1) { return o == o1; }
+    
+    
 }
 

Source/Cobra.Lang/Java/mkjarAll

@@ -5 +5 @@
 
 echo 'making RTL from java sources'
 [ -d classes ] || mkdir classes
-javac -d classes CobraImp.java CobraCore.java Delegate.java
+[ -d classes/cobra/lang ] && rm -rf classes/cobra/lang/*
+javac -d classes SourceSite.java CobraImp.java CobraCore.java Delegate.java AssertException.java CobraDirectString.java
 [ $? == 0 ] || exit
 jar cvf CobraLang.jar -C classes .
 [ $? == 0 ] || exit

Source/Cobra.Lang/Java/read-me.text

@@ -19 +19 @@
     - a script to build and copy the various supporting pieces the java backend needs to the compiler Source directory.
     
 
-The base java version supported is 1.6.
+The base java version supported is currently 1.6.
 This one specifically
 java version "1.6.0_24"
 Java(TM) SE Runtime Environment (build 1.6.0_24-b07)
 Java HotSpot(TM) Client VM (build 19.1-b02, mixed mode, sharing)
+
+This will move up to at least 1.7 as the port/code generation progresses
+and will probably stabilise on 1.8 eventually.
  
 = Caveats =
 
@@ -58 +61 @@
  happens, good for you.
  This is what you will need to do
 
-    1) Apply the patches providing the java backend to the Source tree
+    1) If necessary 
+       Apply the patches providing the java backend to the Source tree
         - get the modified compiler subsequently rebuilt
+
+       As on Nov 2011 (and touch wood) all the jvm patches posted have been 
+       applied to the code repository source so it should be enough to pull down the latest compiler source and build it.
+       
         Patch should be on the cobra website http://cobra-language.com
         Ticket 275: More support for java backend
             http://cobra-language.com/trac/cobra/ticket/275
         
-    2) Ensure java and javac executables (1.6) are in your PATH and work.
+    2) Ensure java and javac executables (1.6 or later) are in your PATH and work.
     
     3) Go into this dir and run ./mkJarAll 
         ( its a bash script - you will need bash or to port the script, 
-            or run the command contents manually) - this builds the 
-        tool and uses that to create the class description info and copies 
-        it to the  right places in the  cobra source tree)
+            or run the command contents manually) - this builds the cobra RTL and  
+        package signature tool and uses that to create the class description info and copies 
+        them to the  right places in the  cobra source tree)
     4) find a test cobra script and compile it
 
 - How to build and run a cobra program generating a java app -
@@ -82 +90 @@
     -kif - leave the generated java files around after compilation
     file.cobra - the cobra source file to compile
     
-If you are lucky you'dll get a whole lot of compiler output at the end of 
+If you are lucky you'll get a whole lot of compiler output at the end of 
 which you'll see a javac invocation followed by a successful execution 
 of the translated cobra program.
 
@@ -100 +108 @@
         Maybe more but thats what I've tried so far)
     We seem to be understanding references to java classes in library (jar) files. 
 
+ Dec-2011 - building and running more simple programs
+    (Up to about 080-* of the files in Tests/100-*)
+    Have properties and Indexers, Casting, reading Commandline ...     
+
 - Other -
 
 Post issues/questions/comments/etc if you have them to Cobra Programming Language Forum

Source/Node.cobra

@@ -845 +845 @@
             tag = 'mi' # for minimal
 
         sb = StringBuilder('[.getType.name]-[tag]([.serialNum]')
-
+        indSep = ','
+        if Environment.getEnvironmentVariable('COBRA_INDENT_TECHSTRING')
+            indSep = ',\n\t  '
         if doMin
             __curFields = List<of Field>()
             try
                 .addMinFields
                 for field in __curFields
                     if field.name.length
-                        sb.append(', [field.name]=[field.value]')
+                        sb.append('[indSep] [field.name]=[field.value]')
                     else
-                        sb.append(', [field.value]')
+                        sb.append('[indSep] [field.value]')
             finally
                 __curFields = nil
 
@@ -868 +870 @@
                         value = (field.value to Node).minimalString
                     else
                         value = field.value
-                    sb.append(', [field.name]=[value]')
+                    sb.append('[indSep] [field.name]=[value]')
             finally
                 __curFields = nil
 
@@ -882 +884 @@
                         value = (field.value to Node).minimalString
                     else
                         value = field.value
-                    sb.append(', [field.name]=[field.value]')
+                    sb.append('[indSep] [field.name]=[field.value]')
             finally
                 __curFields = nil
 

Source/Phases/BindInterfacePhase.cobra

@@ -13 +13 @@
 
     def innerRun is override
         c = .compiler
-        c.fixNilableMemberSigs
+        c.fixMemberSigs
         for basicType in c.basicTypes
             basicType.bindInt
         c.objectType.bindInt

Source/Indexer.cobra

@@ -16 +16 @@
     cue init(token as IToken, idToken as IToken, box as Box, name as String, paramsList as List<of Param>, returnTypeOrNode as INode, isNames as List<of String>, attribs as AttributeList, docString as String)
         base.init(token, idToken, box, name, returnTypeOrNode, isNames, attribs, docString)
         _params = paramsList
-
+        
     get params as IList<of Param> is override
         return _params
 

Source/BackEndClr/ClrBackEnd.cobra

@@ -139 +139 @@
         #.compiler.readAssembly(t.assembly) # System.dll
         .compiler.clrReadAssembly(t.assembly) # System.dll
         
-    def fixNilableMemberSigs is override
+    def fixMemberSigs is override
         .compiler.dotNetFixNilableMemberSigs # in ScanClrType
         
     # Types

Source/CobraParser.cobra

@@ -453 +453 @@
                     .throwError('Compiler directive "number": unrecognized type "[typeName.text]". Must be one of "decimal", "float", "float32" or "float64".')
                 .expect('EOL')
                 .backEnd.compiler.numberTypeName = typeName.text
+            on 'platform'
+                plaf = .grab    
+                if not plaf.text.isOneOf('any.portable.clr.jvm.objc.')
+                    .throwError('Compiler directive "platform": unrecognized platform name "[plaf.text]". Must be one of "portable" or "any", "clr", "jvm" or "objc".')
+                .expect('EOL')
+                if plaf.text in[ 'portable', 'any']
+                    pass
+                else if not .backEnd.name.endsWith(plaf.text)
+                    .throwError('This file is marked as platform specific to "[plaf.text]"  but this compile is using "[.backEnd.name]" backend.')
             on 'ref'
                 pathToken = .grab
                 if not pathToken.which.isOneOf('ID.STRING_SINGLE.STRING_DOUBLE.')

Source/Types.cobra

@@ -1340 +1340 @@
 
     def isDescendantOf(type as IType) as bool
         return base.isDescendantOf(type) and _wrappedType.isDescendantOf(type)
-
+        # shouldnt the above conjunction be an 'or' ??
+        
     def isEquatableTo(b as IType) as bool is override
         if b inherits NilType
             return true

Source/BackEndJvm/JvmJarSig.cobra

@@ -24 +24 @@
     shared
         var classByNameCache = Dictionary<of String, JavaClassType>()
             """All classes found in all jars keyed by canonical/full name."""
-                
+            
+    
+        var nameRemaps = {
+            'java.lang.Decimal' : 'java.lang.Double', # BigDecimal eventually with (lotta) codegen support
+            'java.lang.UByte'   : 'java.lang.Short',
+            'java.lang.UShort'  : 'java.lang.Integer',
+            'java.lang.UInteger': 'java.lang.Long',
+            'java.lang.ULong'   : 'java.lang.Long',
+        }
+            """
+            Remap unique virtualised java class name to an actual existing Java class name.
+            """
+
         def lookupClassByCobraName(fullCobraName as String) as JavaClassType
             """
-            This is the only way to access the JarSig classCache contents from outside this file.
+            This is intended to be the only way to access the JarSig classCache contents from outside this file.
             """
             assert fullCobraName[0].isUpper
+            #fullCobraName = .nameRemaps.get(fullCobraName, fullCobraName)
             parts = fullCobraName.split('.')
             for i in 0: parts.length-1
                 parts[i] = parts[i][0].toLower.toString + parts[i][1:]
             fullName = parts.join('.')
             #print 'Lookup "[fullCobraName]" as "[fullName]"'
+            if not JarSig.classByNameCache.containsKey(fullName) # dbg
+                print 'Class [fullName] not in JarSig ClassName cache'
+                throw Exception('Cannot find class [fullName]')
             return JarSig.classByNameCache[fullName]
                 
         def lookupClass(fullName as String) as JavaClassType
-            """ Lookup class by full/canonicalName."""
+            """ 
+            Lookup class by full/canonicalName. 
+            Used only for class resolution from within this file.
+            """
             if not JarSig.classByNameCache.containsKey(fullName)
                 if fullName.startsWith(r'[')    # [a.b.c; 
                     .addArrayClass(fullName)
@@ -78 +97 @@
                         print 'Unknown arrayName [elName]'  
                         assert false, 'arrayName [elName]'
             if not JarSig.classByNameCache.containsKey(elName)
-                print 'Dbg: class "[elName]" not in classByNameCache "[aName]"'     
+                if elName.contains('<') # a generic
+                    elNameRaw = elName.before('<')
+                    if JarSig.classByNameCache.containsKey(elNameRaw) 
+                        elName = elNameRaw # rawType is superclass of Generic so find that
+                    else    
+                        print 'Dbg: neither class "[elName]" nor class "[elNameRaw]" are in classByNameCache - element for "[aName]"'   
+                else    
+                    print 'Dbg: class "[elName]" not in classByNameCache - element for "[aName]"'   
             #elType = JarSig.classByNameCache[elName]
             elType = JarSig.lookupClass(elName)
             arrayCls = JavaClassType(aName, elType) # ArrayType
@@ -209 +235 @@
         #_javaTypes.add(l)
         JarSig.classByNameCache['float']   = JarSig.classByNameCache['java.lang.Float'] 
         JarSig.classByNameCache['double']  = JarSig.classByNameCache['java.lang.Double'] 
+            
+        # these name remaps will probably need some codegen special handling. 
+        _dupVirtuals
+        _nonGenericCommon
 
+    def _dupVirtuals
+        for dupName in .nameRemaps.keys
+            dupOf = .nameRemaps[dupName]
+            _dupClassTo(dupOf, dupName)
+            
+    def _nonGenericCommon       
+        #pass
+        #   'java.util.Collection'   : 'java.util.Collection<Object>',
+        #_dupClassTo( 'java.util.Collection', 'java.util.Collection<Object>')
+        _makeGenericInstance('java.util.Collection<Object>')  # for ICollection/Java.Util.Collection<of Object>
+        # probably others yet
+                
+    def _dupClassTo(dupOfName as String, asName as String)
+        ct = JarSig.classByNameCache[dupOfName] 
+        parts = asName.split('.')
+        name = parts[parts.length-1]
+        package = parts[0:-1].join('.') # all but last
+        ct = ct.copy(name, package)
+        JarSig.classByNameCache[asName] = ct
+        _javaTypes.add(ct)
         
-                
+    def _makeGenericInstance(fullName as String)
+        # cached AND exposed to namespace
+        assert fullName.contains('<')
+        .addGenericInstClass(fullName)
+        giCls = JarSig.classByNameCache[fullName]
+        print giCls.canonicalName
+        _javaTypes.add(giCls)
+            #_registerClassType(giCls)  
+        
     def getExportedTypes as JavaClassType*
         return _javaTypes
         
@@ -223 +281 @@
     
 #
 # Below are classes describing JavaTypes (class), JavaFields, Java Ctors and JavaMethods    
-# They are temporary placeholders until can get a native implementation and direct access to Java RTL equivalents.
+# They are temporary placeholders until get a native implementation and direct access to Java RTL equivalents.
 
 enum JavaType
     NoType, JavaClass, JavaInterface, JavaEnum, GenericParam
@@ -260 +318 @@
     var _props as List<of JavaFieldInfo>  = JavaClassType._emptyFieldList   # JavaFieldInfo*
     var _ctors as List<of JavaCtorInfo>   = JavaClassType._emptyCtorList    # JavaCtorInfo*
     var _methods as List<of JavaMethodInfo> = JavaClassType._emptyMethodList # JavaMethodInfo*
+    var _indexer as JavaFieldInfo?
+    
 
     # TODO split these out as subclass
     var _isGenericDefn = false  
@@ -385 +445 @@
         jct._props  = propList
         jct._ctors  = ctorList
         jct._methods = methodList
+        jct._fixIdxr
         return jct
             
     def _parseList(et as String) as List<of String> is shared
@@ -439 +500 @@
             return methodName[2:]
         return nil  
             
-    # indexer: get<Propname> and has params  -  first param in paramList is index  (retType is Property Type)
-    #     or  set<PropName> and more than value in paramList, 1st parameter is index and second is value to set.
-    # hops: this isnt goanna work - too many false positives
-    # may work to hard case Collections, Lists and special case Maps... recognise annotation for user written code
-    def isIndexer(methodName as String, method as JavaMethodInfo, isSetProp) as bool is shared
-        if methodName.startsWith('is')
-            return false
-        assert methodName.startsWith('get') or methodName.startsWith('set')
-        isGetProp = not isSetProp
-        return  (isGetProp and method.paramNames.count) or (isSetProp and method.paramNames.count > 1)
-
-    def _genProp(method as JavaMethodInfo, propName as String, propList as List<of JavaFieldInfo>, props as Dictionary<of String, JavaFieldInfo>) as JavaFieldInfo is shared
-        """ Create or update property fm getter/setter method and update given List and Dict. """
+    # unused old obsolete
+    def _genProp0(method as JavaMethodInfo, propName as String, propList as List<of JavaFieldInfo>, props as Dictionary<of String, JavaFieldInfo>) as JavaFieldInfo is shared
+        """ Create or update property fm getter/setter method and update the given List and Dict. """
         assert method.name.startsWith('get') or method.name.startsWith('set') or method.name.startsWith('is')   
         isSetProp = method.name.startsWith('set')
         isGetProp = not isSetProp
@@ -462 +513 @@
             prop = JavaFieldInfo() # JavaPropInfo
             prop.name = propName
             prop.isProp = true
-            #prop.isIndexer = .isIndexer(method.name, method, isSetProp)
-            prop.isIndexer = false  # TODO support indexers
+            prop.isIndexer = false  
             prop.isReadable = prop.isWritable = false
             props[propName] = prop
             propList.add(prop)  
@@ -486 +536 @@
         assert prop.typeName.length
         return prop
             
+    def _genProp(method as JavaMethodInfo, propName as String, propList as List<of JavaFieldInfo>, props as Dictionary<of String, JavaFieldInfo>) as JavaFieldInfo is shared
+        """ Create or update property fm getter/setter method and update the given List and Dict. """
+        assert method.name.startsWith('get') or method.name.startsWith('set') or method.name.startsWith('is')   
+        isSetProp = method.name.startsWith('set')
+        isGetProp = not isSetProp
+        #print method.name, propName
+        if not props.containsKey(propName) # No existing property
+            prop = _genAProp(propName, if(isGetProp, method, nil), if(isSetProp, method, nil), false)
+            props[propName] = prop
+            propList.add(prop)  
+            #print '-- new Prop'
+        else
+            prop = props[propName]
+            if isGetProp 
+                prop.isReadable = true
+                prop.getter = method
+                if not prop.typeName.length and method.returnTypeName.length
+                    prop.typeName = method.returnTypeName
+                #prop.name0 = method.name
+                #print '-- isGetProp'
+            else #isSetProp 
+                prop.isWritable = true
+                prop.setter = method
+                #print '-- isSetProp'
+                if not prop.typeName.length and method.paramNames.count
+                    prop.typeName = method.paramNames[0]
+        assert prop.name.length
+        assert prop.typeName.length
+        return prop
+        
+    def _genAProp(name as String, getMethod as JavaMethodInfo?, setMethod as JavaMethodInfo?, isIndexer as bool ) as JavaFieldInfo is shared
+        """ Create a property given either or both getter/setter methods. """
+        prop = JavaFieldInfo() # JavaPropInfo
+        prop.name = name
+        prop.isProp = true
+        prop.isIndexer = isIndexer
+        if getMethod 
+            prop.isReadable = true
+            prop.getter = getMethod
+            if getMethod.returnTypeName.length, prop.typeName = getMethod.returnTypeName
+            getMethod.prop = prop
+            if not prop.modifiers.count or not prop.modifiers[0].length, prop.modifiers = getMethod.modifiers
+            if not prop.attributes.count,    prop.attributes = getMethod.attributes
+        if setMethod
+            prop.isWritable = true
+            prop.setter = setMethod
+            if not prop.typeName.length 
+                if isIndexer 
+                    if setMethod.paramNames.count > 1, prop.typeName = setMethod.paramNames[1]
+                else
+                    if setMethod.paramNames.count,  prop.typeName = setMethod.paramNames[0]
+            setMethod.prop = prop
+            if not prop.modifiers.count or not prop.modifiers[0].length, prop.modifiers = setMethod.modifiers
+            if not prop.attributes.count,    prop.attributes = setMethod.attributes
+        assert prop.name.length
+        assert prop.typeName.length
+        return prop
+        
+        
+    # support Indexers on Strings and things supporting (java.util.) Map and List Interfaces
+    def _fixIdxr
+        # assumed Default name for indexer methods
+        getterName, setterName = 'getItem', 'setItem'
+        # special case naming weirdnesses of Java lib classes
+        if .canonicalName == 'java.lang.String'
+            getterName, setterName = 'charAt', ''
+        else 
+            for ifcName in .interfaceNames # TODO also chase up interface inheritance tree
+                if ifcName.startsWith('java.util.List')
+                    getterName, setterName = 'get', 'set'
+                else if ifcName.startsWith('java.util.Map')
+                    getterName, setterName = 'get', 'put'
+
+        #TODO also check for specially annotated methods
+            
+        assert getterName.length
+        getMethod, setMethod = _lookForMethods(getterName, setterName)
+        if getMethod or setMethod
+            idxrProp = _genAProp('_synthesizedIdxr', getMethod, setMethod, true)
+            _props.add(idxrProp)
+            _indexer = idxrProp
+            print 'dbg: [.canonicalName] has IndexerMethods [getterName] and [setterName] '
+        #else
+        #   print 'dbg: No IndexerMethods [getterName]/[setterName] on [.canonicalName]'
+                
+    def _lookForMethods( getterName as String, setterName as String) as List<of JavaMethodInfo?>
+        getter as JavaMethodInfo? = nil
+        setter as JavaMethodInfo? = nil
+        for m in _methods
+            if m.name == getterName, getter = m
+            if m.name == setterName, setter = m
+        return [getter, setter] 
+                
+        
     cue init(name as String, pkg as String, type as JavaType, super as String, ifcs as List<of String>, modifiers as List<of String> )
         """Create a normal Class or GenericClass Defn.   MyClass or MyClass<T>"""
         base.init
@@ -810 +954 @@
     get props  from var
     get ctors  from var
     get methods from var
+    get indexer from var
 
     #dbg
     def toMinString as String

Source/BackEndJvm/JvmType.cobra

@@ -5 +5 @@
 
 class JvmNativeType inherits NativeType
 
+    shared
+        def nativeType(t0 as IType?) as JavaClassType?
+            """Obtain Jvm backEnd Native type from given IType (nonnil Box)."""
+            assert t0
+            t = t0 to !
+            if t inherits Box
+                tn = t.nativeType
+                if tn
+                    assert tn inherits JvmNativeType
+                    return  (tn to JvmNativeType).backEndType
+            return nil
+            
     var _type as JavaClassType # java.lang.Class eventually
     var nestedName as String?
-    
+
+        
     cue init(type as JavaClassType)
         base.init
         _type = type
@@ -51 +64 @@
     get isSystemTypeClass as bool is override
         return /# _type and #/ .fullName == 'java.lang.Class'
         
+    def toString as String is override
+        return 'JvmNativeType([_type])'
+    
+    def toTechString as String
+        return .toString
         
 class JvmTypeProxy inherits NativeTypeProxy
     """
@@ -83 +101 @@
                 
         def cobraNameForJvmBoxName(name as String) as String
             """
-            Assunmed we've mangled java generics typenames a la .Net ( i.e TypeName`<nGenericTypeParams>) 
+            Assumed we've mangled java generics typenames a la .Net ( i.e TypeName`<nGenericTypeParams>) 
             Returns 'Foo' for 'Foo' and 'Foo<of,>' for 'Foo`2'
             Works on generic and non-generic classes, structs and interfaces.
             Does *not* work for arrays etc.
@@ -105 +123 @@
 
     cue init(nativeType as NativeType)
         .init((nativeType to JvmNativeType).backEndType)
-
+        
     cue init(jvmType as JavaClassType)
         base.init
         _jvmType = jvmType
@@ -194 +212 @@
                 .throwError(msg)
         return .compiler.intType  # CC: to make C# code gen happy.
     
+    # make dict same as PrimitiveTypesDict but keyed by dynamic so not typed to nativeType/JavaClassType
+    # and set to Compiler.
     def _initPrimToITypeCache
         typeToIType = _makePrimitiveTypesDict
         jvmPrimitiveToIType = Dictionary<of dynamic, IType>()
@@ -201 +221 @@
             jvmPrimitiveToIType[key] = typeToIType[key]
         (.compiler to Compiler).primitiveCache  = jvmPrimitiveToIType #to !
 
+    # primitiveTypes java/nativeClassType: cobraBasicType
+    # like Byte: IntType(signed,8), ... Long: IntType(signed, 64)
+    # implies 1:1 nativeClassType: cobraBasicType -  needs fixing
     def _makePrimitiveTypesDict as IDictionary<of JavaClassType, IType>
         primitiveToIType = Dictionary<of JavaClassType, IType>()
         for bt in .compiler.basicTypes
@@ -208 +231 @@
                 # lookup by qualified name (includes translation) and pull out (jvm) NativeType
                 key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to JvmNativeType).backEndType
                 primitiveToIType[key] = bt
+                #print '<.', key.name, bt
+        #print '<..', primitiveToIType.count
         assert primitiveToIType.count == 0 or primitiveToIType.count >=8
         return primitiveToIType
     

Source/BackEndJvm/to-do.text

@@ -1 +1 @@
 = Java Backend Gen TODO =
 
+Require Base version Java to be java7
+    gain strings in case stmt for free (!)
+
+
 include-tests:no - remove Test invocation call
 
 
@@ -52 +56 @@
      codegen for props: 'propName' -> getPropName  (DONE)
                                       setPropName   convert propName = a.b.c -> setPropName(a.b.c) (DONE - minimally at least)
 
+     codegen for is<bool> property accessor  isPropName
+
+    Indexers:
     AutoMap map indexers '[]' to methods X.get(idx) v = X[idx] , X.set(idx,val) and X.put(idx,val) -> X[idx] = val
         - unworkable - too many false positives
             
-Handling of indexing '[]' on Maps and Lists
-                x[i]=v :  map: x.put(i,v)     list: x.set(i,v) 
-                v = x[i]: map: v = map.get(i) list: v = list.get(i)
+    Handling of indexing '[]' on Strings, Maps and Lists
+                x[i]=v :  String: -                    map: x.put(i,v)     list: x.set(i,v) 
+                v = x[i]: String: v = x.charAt(i)      map: v = map.get(i) list: v = list.get(i)
+        DONE  Nov-2011
+        
+    codegen for user code indexers
+    pro/get/set [index as idxT] as T
+        get
+            return _data[index]
+        set
+            _data[index] = value
+
+        accessor: T getIndexer(idxT index) { return _data[index]; }
+        mutator:  void setIndexer(idxT index, T value) { _data[index] = value; } 
+
+String Substitutions:
+    format handling: 
+        e.g.  m=42  
+              assert '[m:N]' == '42.00'
+    1) ignore initially
+    2) either map .Net fmt to java equiv (shudder)
+      or treat as java specific form  - 
+        m=42.0
+        assert '[m:%.2f]' == '42.00'
+      
+
+Arrays
+    Array init from Array literal
+    Array indexing
+
+
 Events
     - auto add boiler plate for listener (de)registration
         - event firing
 
 
 partial classes
-    Add extra phase to aggregate partial classes together into first Module
+    Add extra phase to aggregate partial classes together into first Module or AST Tree
     (Chk if cobra is doing sommat like this or relying on C# compiler)
     
 Extensions
@@ -131 +166 @@
         in call wrap arg in a SoftRef (or make own version HardRef subclass j.l.ref.Reference)
         Chg param to be a SoftRef to the arg passed (e.g. 'arg_Ref')
         In the method pull it out from the softref as a local name ('arg')
-    
 
+nilable/nonNilable
+    enforcement nonNilable - require use of Java7 and use Objects.requireNonNull() call
+        
+
 Add new compiler directive
  @platform portable|jvm|clr|objc
  
@@ -154 +192 @@
         or default Decimal to Double ?? 
             tests :050-decimal.cobra
 
+Java7 adds java.nio Files and (interface) Path - modify codegen/handling to use that ( wire to >java7)
+    use Paths to create Path and Files to convert Path for use
+        legacy Path p = fileInst.toPath(); // java.io.File to java.nio.Path
+
 Add convenience methods to 
     java.io.File for
         remember

Source/BackEndJvm/ScanJvmType.cobra

@@ -198 +198 @@
     
         # work out what doing with indexor and apply to []
         #_fix('System.Collections.Generic.List<of>', r'[]')
-        _fix('Java.Util.List<of>', r'[] get set remove')
-        _fix('Java.Util.AbstractList<of>', r'[] get set remove')
+        _fix('Java.Util.List<of>', r'[] get set remove size')
+        _fix('Java.Util.AbstractList<of>', r'[] get set remove size')
         _fix('Java.Util.AbstractSequentialList<of>', r'[] get set remove')
         _fix('Java.Util.ArrayList<of>', r'[] get set remove')
         #_fix('Java.Util.CopyOnWriteArrayList<of>', r'[] get set remove')
@@ -218 +218 @@
         #_fix('Java.Util.IdentityHash<of,>', r'[] get')
         #_fix('Java.Util.TreeMap<of,>', r'[] get')
         #_fix('Java.Util.WeakHashMap<of,>', r'[] get')
-        _fix('Java.Util.Map.Entry<of,>', r'getKey getValue')
+
+        # Nested classes need to be handled when enclosing class is loaded
+        # see Box._nestedUnNil below
+        #_fix('Java.Util.Map.Entry<of,>', r'getKey getValue')
         #_fix('Java.Util.AbstractMap.SimpleEntry<of,>', r'getKey getValue')
         #_fix('Java.Util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue')
-        #_fix('Java.Util.Properties', r'getProperty')
+        _fix('Java.Util.Properties', r'getProperty')
         
         #_fix('System.IO.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText')
         _fix('Java.Io.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText getPath getAbsolutePath')
@@ -233 +236 @@
         #_fix('java.lang.StringBuilder', 'toString') # ??
         #_fix('java.lang.Text.RegularExpressions.Regex', 'match replace')
         #_fix('System.Diagnostics.Process', 'processName')
-        _fix('java.util.regex.Pattern', 'matches matcher pattern split compile')
-        _fix('java.util.regex.Matcher', 'group pattern replaceAll replaceFirst')
-        _fix('java.lang.ProcessBuilder', 'command start directory')
+        _fix('Java.Util.Regex.Pattern', 'matches matcher pattern split compile')
+        _fix('Java.Util.Regex.Matcher', 'group pattern replaceAll replaceFirst')
+        _fix('Java.Lang.ProcessBuilder', 'command start directory')
         #_fix('java.lang.Process', 'getInputStream getOutputStream getErrorStream')
         
         #_fix('System.Reflection.Assembly', 'getEntryAssembly getExecutingAssembly location')
@@ -244 +247 @@
         #_fix('System.Reflection.ParameterInfo', 'parameterType')
         #_fix('System.Reflection.PropertyInfo', 'propertyType')
 
+    def jvmFixIndexerMemberSigs
+        # Mapping for (simple) Indexers to  java methods.
+        # Fix the listed classes to support Indexors using specified members as accessors and mutators.
+        # called from bindInterface phase so this can only refer to top level Classes in a package.
+
+        # Initially and currently hard coded in JvmJarSig. 
+        # TODO: fixup to specify here like nilableMemberSigs 
+        # TODO: this really needs to go in a separate file that the compiler reads each time
+        #print 'fixing Indexers'
+        #Format below is 
+        #_AddIdxr('FullClassName', 'accessorMethod mutatorMethod')  --  Mutator is optional 
+        #_addIdxr('Java.Lang.String', 'charAt')
+        #_addIdxr('Java.Util.Map', 'get put')
+        #_addIdxr('Java.Util.List', 'get set')
+        pass
         
     #
     # Jvm Type Cache
@@ -419 +437 @@
                     skip = true
                     break
             if skip, continue
-            params = _scanJvmParams(ctorInfo.getParameters, ctorInfo.isVari)
+            params = _scanJvmParams(ctorInfo.getParameters, ctorInfo.isVari, false)
             isNames = _isNamesForJavaMemberInfo(ctorInfo)
             attribs = _attribsForJavaMemberInfo(ctorInfo)
             docString = ''  # TODO: get doc string for class?
@@ -481 +499 @@
         for paramInfo in propInfo.getIndexParameters
             if _badJvmRelatedType(paramInfo)
                 return
-        params = _scanJvmParams(propInfo.getIndexParameters, false)
+        params = _scanJvmParams(propInfo.getIndexParameters, false, true)
         attribs = _attribsForJavaMemberInfo(propInfo)
         docString = ''
         if propInfo.isReadable
@@ -529 +547 @@
             genericParams = List<of IType>()
             for genArg in methInfo.getGenericArguments
                 genericParams.add(GenericParam(JvmNativeType(genArg)))
-            params = _scanJvmParams(methInfo.getParameters, methInfo.isVari)
+            params = _scanJvmParams(methInfo.getParameters, methInfo.isVari, false)
             isNames = _isNamesForJavaMemberInfo(methInfo)
             if methInfo.isOverride,  isNames.add('override')    # only on methods
             attribs = _attribsForJavaMemberInfo(methInfo)
@@ -553 +571 @@
             else
                 .addDecl(method)
 
-    def _scanJvmParams(jparams as List<of JavaClassType>?, isVariMethod as bool) as List<of Param>
+    def _scanJvmParams(jparams as List<of JavaClassType>?, isVariMethod as bool, isNotNullable as bool) as List<of Param>
         """
         Returns a list of Cobra Params given a list of Java ClassTypes (presumably a java parameterList)
         """
@@ -572 +590 @@
             # To support nilable on params need change representation to a javaParamType containing type + attributes (for param) ( + direction possibly)
             # Java not support nilable directly so ignore for moment
             #isNotNull = javaParam.isNonNullable
-            isNotNullable = false # can be null
+            #isNotNullable = false # indexer params not be null others can be
             parameterType = javaParam
             type = _jvmMemberTypeProxy(parameterType, isNotNullable)
+            #if isNotNullable, print '>>', javaParam, ' ', type
             if isVari, type = VariTypeProxy(type)
             name = 'unkname' # java not keep names of given formal parameters
             param = Param(name, type)
+            #if isNotNullable 
+            #   print '>>>' stop
+            #   param.writeDeepString
             param.direction = Direction.In # Java doesnt have Out or InOut equivs
             params.add(param)
         return params
@@ -658 +680 @@
     #_fix('java.util.Map<of,>.Entry<of,>', r'getKey getValue')
     #_fix('java.util.AbstractMap.SimpleEntry<of,>', r'getKey getValue')
     #_fix('java.util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue')
-        
+    var _nestedUnNil as Dictionary<of String, String> =  { 
+        'Java.Util.Map<of,>.Entry<of,>' :                   r'getKey getValue',
+        'Java.Util.AbstractMap.SimpleEntry<of,>':           r'getKey getValue',
+        'Java.Util.AbstractMap.SimpleImmutableEntry<of,>':  r'getKey getValue'
+    }
+
     def _fixNestedNilables
         if .parentBox  # nested
-            print 'fixNest', .parentBox.name, .name
-                
+            query = '[.parentBox.qualifiedName].[.name]'
+            print 'fixNest', query
+            memberNames = _nestedUnNil.get(query, '')
+            if memberNames.length
+                .parentBox.membersToUnNil = memberNames
+                #print '  unNil', memberNames
 
 class Class
     is partial
@@ -729 +760 @@
         _scanJvmMethods
         #_scanJvmEvents
 
-    def _scanJvmParams(jparams as List<of JavaClassType>?, isVariMethod as bool) as List<of Param> is override
+    def _scanJvmParams(jparams as List<of JavaClassType>?, isVariMethod as bool, isNotNullable as bool) as List<of Param> is override
         # the first argument is implicit in an Extension
-        results = base._scanJvmParams(jparams, isVariMethod)
+        results = base._scanJvmParams(jparams, isVariMethod, isNotNullable)
         return results[1:]
         
     def jvmExtnNativeType(nativeType as NativeType) as NativeType

Source/BackEndJvm/JvmBackEnd.cobra

@@ -28 +28 @@
             'IEnumerator<of>' : 'Java.Lang.Iterator<of>',
             'IDictionaryEnumerator' : 'Java.Lang.Iterator',
             #'IDictionaryEnumerator' : 'System.Collections.IDictionaryEnumerator',
-            'ICollection':      'Java.Util.Collection<of Object>',  # non generic collection interface
+            'ICollection':      'Java.Util.Collection', # non generic collection interface
             'ICollection<of>':  'Java.Util.Collection<of>',
             'IList' :           'Java.Util.List<of Object>',    # non generic List interface
             'IList<of>' :       'Java.Util.List<of>',
@@ -40 +40 @@
 
             'bool'  :  'Java.Lang.Boolean',  # boolean
             'char'  :  'Java.Lang.Character',# char
-            'decimal': 'Java.Lang.Double',  # ??
+            'decimal': 'Java.Lang.Decimal', #  virtualised -> Double
             'single':  'Java.Lang.Float',   # float 
             'double':  'Java.Lang.Double',  # double    
-            'sbyte' :  'Java.Lang.Byte',        # byte
+            'sbyte' :  'Java.Lang.Byte',    # byte
             'int16' :  'Java.Lang.Short',   # short 
             'int32' :  'Java.Lang.Integer', # int       
-            'int64' :  'Java.Lang.Long',        # long
-            'byte'  :  'Java.Lang.Short',   # short   # rest are unsigned - use next widest
-            'uint16':  'Java.Lang.Integer', # int   
-            'uint32':  'Java.Lang.Long',        # long
-            'uint64':  'Java.Lang.Long',        # long
+            'int64' :  'Java.Lang.Long',    # long
+            'int'   :  'Java.Lang.Integer', # int primitive (struct) - need same for other primitives??     
+            # rest are unsigned, n/a in Java. But still need to be distinct.
+            # Invent  some fake names and remap at javaClass level
+            'byte'  :  'Java.Lang.UByte',   # virtualised -> Short 
+            'uint16':  'Java.Lang.UShort',  # virtualised -> Integer    
+            'uint32':  'Java.Lang.UInteger',# virtualised -> Long
+            'uint64':  'Java.Lang.ULong',   # virtualised -> Long
             
             }
         
@@ -155 +158 @@
         # rt.jar is only one we need
         .compiler.javaReadJar(JarSig('rt.jar'))
     
-    def fixNilableMemberSigs is override
-        #.compiler.jvmfixNilableMemberSigs
-        pass # TODO
+    def fixMemberSigs is override
+        .compiler.jvmFixNilableMemberSigs
+        .compiler.jvmFixIndexerMemberSigs
         
     def installNativeMethods(box as Box, nativeType as NativeType) is override
-        #.compiler.installJvmNativeMethods(box, nativeType)
-        pass # TODO
+        .compiler.installJvmNativeMethods(box, nativeType)
+        #pass # TODO
 
     def cobraNameForNativeBoxName(nativeBoxName as String) as String is override
         return JvmTypeProxy.cobraNameForJvmBoxName(nativeBoxName)

Source/BackEndJvm/JavaGenerator.cobra

@@ -370 +370 @@
         sw.writeAndIndent(r'static public void main(String[] args) {')
         sw.writeLine
         sw.bumpLineNum
-        sw.writeLine('//cobra.lang.CobraCore.setCommandLineArgs(args); ')
+        sw.writeLine('cobra.lang.CobraCore._recordCommandLine(args); ')
         sw.writeLine('(new [mainMethod.parentBox.javaRef]()).main(args);')
         sw.bumpLineNum
         sw.dedentAndWrite('} // end MainWrapper.main\n\n')
@@ -1195 +1195 @@
     pro javaExtraIsNames from var
     
     get javaThis as String
-        return if(.isShared, 'typeof([.parentBox.javaName])', .parentBox.javaThis)
+        #return if(.isShared, 'typeof([.parentBox.javaName])', .parentBox.javaThis)
+        return if(.isShared, '([.parentBox.javaName].class)', .parentBox.javaThis)
 
     def writeJavaNotNull(sw as CurlyWriter)
         if .resultType.isReference and not .resultType inherits NilableType
@@ -1665 +1666 @@
                 sw.indent
         if .isMain and .compiler.options.boolValue('include-tests')
             sw.writeLine('cobra.lang.CobraCore.runAllTests();  // turn off with -include-tests:no (see cobra -h)')
+        if .isMain and .hasMainParams
+            sw.writeLine('cobra.lang.CobraCore._recordCommandLine(args); ')
 
     def writeJavaImpFooter(sw as CurlyWriter)
         base.writeJavaImpFooter(sw)
@@ -1785 +1788 @@
 
 class Indexer is partial
 
-    # TODO
-    pass
+    get javaNotNullPrefix as String is override
+        return ''
 
+    def writeJavaDef(sw as CurlyWriter) is override
+        #base.writeJavaDef(sw)
+        assert _name==r'[]'
+        sw.write('// Indexer ')
+        #.writeJavaNotNull(sw)
+        #.writeJavaAttribs(sw)
+        #.writeJavaIsNames(sw)
+        sw.write(' [_returnType.javaRef] this')
+        .writeJavaParams(sw, r'[]')
+        #.writeSharpBody(sw)
+        # TODO: finish correctly (method with special attribute???
 
 class MemberOverload is partial
 
@@ -2669 +2683 @@
                 handled = true
         if not handled
             _target.writeJavaDef(sw)
-        sw.write(r'[')
+
+        ntIdxr = _lookupReadIndexer
+        if ntIdxr
+            assert ntIdxr.getter
+            assert ntIdxr.getter.name.length
+            _writeIndexer(sw, '.[ntIdxr.getter.name](', ')')
+        else
+            _writeIndexer(sw, r'[', r']')
+        
+        if parens, sw.write(')')
+
+    def _lookupReadIndexer as JavaFieldInfo?
+        nt = JvmNativeType.nativeType(_target.type)
+        if nt 
+            ntIdxr = nt.indexer
+            if ntIdxr and ntIdxr.isReadable
+                return ntIdxr
+        #TODO: check for Indexer attribute for a Cobra user written version
+        return nil      
+                
+    def _writeIndexer(sw as CurlyWriter, prefix as String, suffix as String)
+        sw.write(prefix) 
+        _writeIdxArgs(sw)
+        sw.write(suffix)
+
+    def _writeIdxArgs(sw as CurlyWriter)
         sep = ''
         for expr in _args
             sw.write(sep)
             expr.writeJavaDefInContext(sw)
             sep = ', '
-        sw.write(']')
-        if parens, sw.write(')')
 
     def writeJavaBreakdownItems(sw as CurlyWriter)
         base.writeJavaBreakdownItems(sw)
@@ -2758 +2795 @@
         # C# chokes on it because the first "X" is considered to be the type
         #if .curBox.name + '.' in javaRef
         #   javaRef = 'global::' + javaRef
-        if _requiresTypeOf()
-            sw.write('typeof(')
+        if _requiresGetClass() # was _requiresTypeOf
+            #sw.write('typeof(')
+            sw.write('(')
             sw.write(javaRef)
+            sw.write('.getClass()')
             sw.write(')')
         else
             sw.write(javaRef)
 
+    def _requiresGetClass as bool
+        return false    # may need to extend later
+        
 /#  def _requiresTypeOf as bool
         # Cobra never requires that you wrap a type reference in typeof(Foo).
         # C# requires typeof() in a variety of circumstances and won't accept it in a variety of others.
@@ -2787 +2829 @@
             #/
             
     def writeJavaDefForBreakdown(sw as CurlyWriter) is override
-        requiresTypeOf = _requiresTypeOf # using C# version currently - chop ?
-        if not requiresTypeOf, sw.write('typeof(')
+        #requiresTypeOf = _requiresTypeOf # using C# version currently - chop ?
+        #if not requiresTypeOf, sw.write('typeof(')
         .writeJavaDef(sw)
-        if not requiresTypeOf, sw.write(')')
+        #if not requiresTypeOf, sw.write(')')
 
         
 class UnaryOpExpr
@@ -2809 +2851 @@
             assert specs.containsKey(.token.text)
             spec = specs[.token.text]
             opText = Utils.javaStringLiteralFor(spec.opMethodName)
-            sw.write('CobraLangInternal.CobraImp.DynamicOp([opText], ')
+            sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.dynamicOp([opText], ')
             _expr.writeJavaDef(sw, false)
             sw.write(')')
             return
@@ -3010 +3052 @@
             #sw.write(').value')
             sw.write(')')
         else if .compiler.options.boolValue('include-nil-checks')
-            sw.write('(CobraLangInternal.CobraCore._willCheckNil ? CobraLangInternal.CobraImp.CheckNonNil<[type.javaRef]>([.javaThis], [Utils.javaStringLiteralFor(_expr.toCobraSource)], ')
+            #sw.write('(cobra.lang.CobraCore._willCheckNil ? cobra.lang./*CobraLangInternal.*/CobraImp.checkNonNil<[type.javaRef]>([.javaThis], [Utils.javaStringLiteralFor(_expr.toCobraSource)], ')
+            sw.write('(cobra.lang.CobraCore._willCheckNil ? cobra.lang./*CobraLangInternal.*/CobraImp.checkNonNil([.javaThis], [Utils.javaStringLiteralFor(_expr.toCobraSource)], ')
             _expr.writeJavaDef(sw, false)
-            sw.write(', [.javaSourceSiteArgs]):')
+            sw.write(', [.javaSourceSiteArgs]) :')
             _expr.writeJavaDef(sw, false)
             sw.write(')')
         else
@@ -3054 +3097 @@
 
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
         if _trackLocal
-            sw.write('CobraLangInternal.CobraImp.SetLocal("[_trackName]", ')
+            sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.setLocal("[_trackName]", ')
         else if parens
             sw.write('(')
         _writeJavaDef(sw)
@@ -3073 +3116 @@
         if _left inherits IndexExpr
             if _left.target.type.isDynamic
                 # assigning to an indexer of a dynamically typed target requires special code gen
-                sw.write('CobraLangInternal.CobraImp.SetIndexerValue(')
+                sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.setIndexerValue(')
                 _left.target.writeJavaDef(sw, false)
                 sw.write(', ')
                 _right.writeJavaDef(sw, false)
@@ -3100 +3143 @@
             if _left inherits DotExpr
                 if _left.left.type.isDynamic
                     assert _left.right inherits MemberExpr
-                    sw.write('CobraLangInternal.CobraImp.setPropertyValue(')
+                    sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.setPropertyValue(')
                     _left.left.writeJavaDef(sw, false)
                     sw.write(', ')
                     sw.write(Utils.javaStringLiteralFor((_left.right to MemberExpr).name))
@@ -3153 +3196 @@
         _left.writeJavaDef(sw, false)
         sw.write(' = ')
         sw.write('(' + _left.type.javaRef + ')')
-        sw.write('CobraLangInternal.CobraImp.Concated(')
+        sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.concated(')
         _left.writeJavaDef(sw, false)
         sw.write(', ')
         _right.writeJavaDef(sw, false)
@@ -3166 +3209 @@
         assert specs.containsKey(.token.text)
         spec = specs[.token.text]
         opText = Utils.javaStringLiteralFor(spec.opMethodName)
-        sw.write('CobraLangInternal.CobraImp.DynamicOp([opText], ')
+        sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.dynamicOp([opText], ')
         _left.writeJavaDef(sw)  # TODO: add , false
         sw.write(', ')
         _right.writeJavaDef(sw)  # TODO: add , false
@@ -3217 +3260 @@
             assert specs.containsKey(.token.text)
             spec = specs[.token.text]
             opText = Utils.javaStringLiteralFor(spec.opMethodName)
-            sw.write('CobraLangInternal.CobraImp.DynamicOp([opText], ')
+            sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.dynamicOp([opText], ')
             _left.writeJavaDef(sw)  # TODO: add , false
             sw.write(', ')
             _right.writeJavaDef(sw)  # TODO: add , false
@@ -3269 +3312 @@
         # do this:
         src = Utils.javaStringLiteralFor(_right.toCobraSource)
         javaNot = if(_op=='OR', '', '!')
-        sw.write(', [src], new CobraLangInternal.CobraDirectString([javaNot]')
+        sw.write(', [src], new cobra.lang.CobraDirectString([javaNot]')
         _left.writeJavaDefForBreakdown(sw)
-        sw.write(' ? "(short-circuited)" : CobraLangInternal.CobraCore.ToTechString(')
+        sw.write(' ? "(short-circuited)" : cobra.lang.CobraCore.ToTechString(')
         _right.writeJavaDefForBreakdown(sw)
         sw.write('))')
 
@@ -3316 +3359 @@
 
     def _writeJavaDefConcated(sw as CurlyWriter)
         sw.write('(' + _left.type.javaRef + ')')
-        sw.write('CobraLangInternal.CobraImp.Concated(')
+        sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.concated(')
         _left.writeJavaDef(sw, false)
         sw.write(', ')
         _right.writeJavaDef(sw, false)
@@ -3392 +3435 @@
         left = _left
         right = _right
         op = _op
+        wrapLeft = wrapRight = ''
         # Compute the java operation which will be an operator or method call
         if op=='EQ' or op=='NE'
             if not left.type.isReference and not right.type.isReference
@@ -3406 +3450 @@
             else
                 done = false
                 stringType = .compiler.stringType
-                if left.isKindOf(stringType) and right.isKindOf(stringType)  # TODO: check for static comparison operations instead
-                    op = _cobraToJava[_op]
+                charType = .compiler.charType
+                if left.isKindOfNonNil(stringType) and right.isKindOfNonNil(stringType)  # TODO: check for static comparison operations instead
+                    op = if(op in ['EQ', 'NE'], '.equals(', '.compareTo(')
                     done = true
+                else if left.isKindOfNonNil(charType) and right.isKindOfNonNil(stringType)
+                    op = if(op in ['EQ', 'NE'], '.equals(', '.compareTo(')
+                    wrapLeft = 'String.valueOf('
+                    done = true
+                else if left.isKindOfNonNil(stringType) and right.isKindOfNonNil(charType)
+                    op = if(op in ['EQ', 'NE'], '.equals(', '.compareTo(')
+                    wrapRight = 'String.valueOf('
+                    done = true
                 else if left.type inherits Box  # TODO: try skipping on requiring that the type is a Box
                     leftBox = left.type to Box
                     compareTo = leftBox.memberForName('compareTo')
@@ -3423 +3476 @@
             if left.type inherits PrimitiveType and right.type inherits PrimitiveType
                 op = _cobraToJava[_op]
             else if left.type.isReference and right.type.isReference
-                op = if(op=='IS', ' instanceof ', '! instanceof ')
+                op = _cobraToJava[_op]
+                #op = if(op=='IS', ' instanceof ', '! instanceof ')
             else
                 # non-trivial situation.. fall back to runtime support
-                op = if(op=='IS', 'CobraLangInternal.CobraImp.Is(', 'CobraLangInternal.CobraImp.IsNot(')
+                op = if(op=='IS', 'cobra.lang./*CobraLangInternal.*/CobraImp.is(', 'cobra.lang./*CobraLangInternal.*/CobraImp.isNot(')
         else
             if left.type.isDynamic or right.type.isDynamic
-                sw.write('CobraLangInternal.CobraImp.DynamicCompare(')
+                sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.dynamicCompare(')
                 left.writeJavaDef(sw, false)
                 sw.write(', ')
                 right.writeJavaDef(sw, false)
@@ -3445 +3499 @@
                         done = true
                 if not done
                     op = _cobraToJava[_op]
+
         # Write the Java code
         if op.length <= 2
-            left.writeJavaDef(sw)
+            _writeWrapped(sw, wrapLeft, left)
             sw.write(op)
-            right.writeJavaDef(sw)
+            _writeWrapped(sw, wrapRight, right)
         else if op == '.equals('
             if _op == 'NE', sw.write('!(')
-            left.writeJavaDef(sw)
+            _writeWrapped(sw, wrapLeft, left)
             sw.write(op)
-            right.writeJavaDef(sw, false)
+            _writeWrapped(sw, wrapRight, right)
             sw.write(')')
             if _op == 'NE', sw.write(')')
         else if op == '.compareTo('
-            left.writeJavaDef(sw)
+            _writeWrapped(sw, wrapLeft, left)
             sw.write(op)
-            right.writeJavaDef(sw, false)
+            _writeWrapped(sw, wrapRight, right)
             sw.write(') [_cobraToJava[_op]] 0')
         else if op.endsWith('(')
             sw.write(op)
-            left.writeJavaDef(sw)
+            _writeWrapped(sw, wrapLeft, left)
             sw.write(',')
-            right.writeJavaDef(sw)
+            _writeWrapped(sw, wrapRight, right)
             sw.write(')')
         else
+            print op
             throw FallThroughException(op)
-
+            
+    def _writeWrapped( sw as CurlyWriter, wrap as String, e as Expr)
+        if wrap.length
+            sw.write(wrap)
+            e.writeJavaDef(sw)
+            sw.write(')')
+        else
+            e.writeJavaDef(sw)
+            
 class ChainedCompareExpr is partial
     
     def writeJavaDef(sw as CurlyWriter, parens as bool) is override
@@ -3479 +3543 @@
         if parens, sw.write(')')
     
     def writeJavaDef(sw as CurlyWriter) is override
-        sw.write('CobraLangInternal.CobraCore.ChainedComparison(')
+        sw.write('cobra.lang./*CobraLangInternal.*/CobraCore.chainedComparison(')
         _items[0].writeJavaDef(sw)
         itemIndex = 1
         for operation in _operations
@@ -3509 +3573 @@
             if _dotRightExpr.definition
                 sw.write('(' + _dotRightExpr.type.javaRef + ')')
             if _right inherits MemberExpr
-                sw.write('CobraLangInternal.CobraImp.GetPropertyValue(')
+                sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.getPropertyValue(')
                 _left.writeJavaDef(sw, not _left inherits DotExpr)
                 sw.write(', ')
                 sw.write(Utils.javaStringLiteralFor(_right.name)) # was .capitalized
                 sw.write(')')
             else if _right inherits CallExpr
-                sw.write('CobraLangInternal.CobraImp.InvokeMethod(')
+                sw.write('cobra.lang.CobraImp.invokeMethod(')
                 _left.writeJavaDef(sw, not _left inherits DotExpr)
                 sw.write(', ')
                 sw.write(Utils.javaStringLiteralFor(_right.name))   # was .capitalized
@@ -3591 +3655 @@
             _left.writeJavaDef(sw)
             return
         sw.write('(')
-        _right.writeJavaDef(sw, false)  # double parens would be pointless and also causes a C# error
+        _right.writeJavaDef(sw, false)
         sw.write(')')
         if not rightType inherits NilableType and rightType.isReference and .compiler.options.boolValue('include-nil-checks')
-            sw.write('CobraLangInternal.CobraImp.CheckNonNil<[_left.type.javaRef]>([.javaThis], [Utils.javaStringLiteralFor(_left.toCobraSource)], ')
+            sw.write('cobra.lang./*CobraLangInternal.*/CobraImp.checkNonNil([.javaThis], [Utils.javaStringLiteralFor(_left.toCobraSource)], ')
             _left.writeJavaDef(sw, false)
             sw.write(', [.javaSourceSiteArgs])')
         else
@@ -3623 +3687 @@
         #else
         #   sw.write('[typeJavaRef])CobraLangInternal.CobraImp.ToOrNil<[typeJavaRef]>(')
         #   .left.writeJavaDef(sw)
-        sw.write('[typeJavaRef])CobraLangInternal.CobraImp.ToOrNil<[typeJavaRef]>(')
+        sw.write('[typeJavaRef])cobra.lang.CobraImp.toOrNil<[typeJavaRef]>(')
         .left.writeJavaDef(sw)
         sw.write(')')
 
@@ -3764 +3828 @@
                     sw.write('new [expr.receiverType.javaRef](')
                     .writeJavaArgs(sw)
                     sw.write(')')
-                else if expr.type.nonNil.isDescendantOf(.compiler.delegateType)
+                else if expr.isKindOfNonNil(.compiler.delegateType)
                     isMethodSig = true
                 else if expr.type.isSystemTypeClass or _type.isDynamic
                     isDynamic = true
                 else
                     assert false, expr
             else if expr inherits IndexExpr
-                if expr.type.nonNil.isDescendantOf(.compiler.delegateType)
+                if expr.isKindOfNonNil(.compiler.delegateType)
                     isMethodSig = true
                 else if expr.type.isSystemTypeClass or _type.isDynamic
                     isDynamic = true

Tests/200-misc/870-platform-directive/030-platform-directive-jvm.cobra

@@ +1 @@
+#.require. clr
+#.error. platform specific to "jvm"
+@platform jvm 
+
+class Plaf
+
+    def main is shared
+        System.out.println('Hello')

Tests/200-misc/870-platform-directive/020-platform-directive-clr.cobra

@@ +1 @@
+#.require. clr
+@platform clr 
+
+class Plaf
+
+    def main is shared
+        Console.writeLine('Hello')

Tests/200-misc/870-platform-directive/060-platform-directive-jvm.cobra

@@ +1 @@
+#.require. jvm
+@platform jvm 
+
+class Plaf
+
+    def main is shared
+        System.out.println('Hello')

Tests/200-misc/870-platform-directive/040-platform-directive-any.cobra

@@ +1 @@
+@platform any
+
+class Plaf
+
+    def main is shared
+        print 'Hello'

Tests/200-misc/870-platform-directive/010-platform-directive-wrong.cobra

@@ +1 @@
+#.error. unrecognized platform name 
+@platform unk 
+
+class Plaf
+
+    def main is shared
+        Console.writeLine('Hello')

Tests/200-misc/870-platform-directive/050-platform-directive-portable.cobra

@@ +1 @@
+@platform portable
+
+class Plaf
+
+    def main is shared
+        print 'Hello'

Tests/100-basics/060-string.cobra

@@ +1 @@
+#.require. clr
 namespace Test
 
     class Test

Tests/100-basics/062j-string-substitution-fmt.cobra

@@ +1 @@
+#.require. jvm
+# some simple string subst formatting tests - java format descriptions
+namespace Test
+
+    class Test
+
+        def main
+            is shared
+
+            # formatting
+            #mol as float = 42.0
+            #print '[mol:%.2d]'
+            ## TODO This not yet working as formatting on makeString in java version NYI
+            #assert '[mol:%.2d]'=='42.00'
+        
+            a = 99
+            # test some using format substitution without the escape syntax.
+            t = String.format('a = %0$s[a]]', c'[')
+            assert t == r'a = [99]'
+            
+            s10 = 'FMT:a = '+ ns'[' +'[a]]'
+            assert s10 == r'FMT:a = [99]'
+    
+            a1 = String.format('%0$s[a]]', ns'[')
+            s11 = 'a = [a1]'
+            assert s11 == r'a = [99]'
+    
+            
+            

Tests/100-basics/062-string-substitution.cobra

@@ -23 +23 @@
             # nested brackets
             s as String = 'abc'
             i = 1
-            assert 'the letter at [i] is [s[i]].'=='the letter at 1 is b.'
+            #print 'the letter at [i] is [s[i]].'
+            #assert 'the letter at [i] is [s[i]].'=='the letter at 1 is b.'
+            si = s[i]
+            assert 'the letter at [i] is [si].'=='the letter at 1 is b.'
 
             # substitution works with double quotes
             i = 3
@@ -42 +45 @@
             assert 'foo \[bar] [foo]' == r'foo [bar] 1'
             assert 'foo [bar] \[foo]' == r'foo 2 [foo]'
 
-            # formatting
-            mol as int = 42
-            assert '[mol:N]'=='42.00'
-            assert "[mol:N]"=='42.00'
+            # formatting - moved to 062-string-substitution-fmt
+            #mol as int = 42
+            #assert '[mol:N]'=='42.00'
+            #assert "[mol:N]"=='42.00'
+            #assert '[mol:%2d]'=='42.00' # jvm
 
             # the ns prefix means "no sub" or "no substitution"
             assert ns'aoeu'=='aoeu'

Tests/100-basics/060j-string.cobra

@@ +1 @@
+#.require. jvm
+namespace Test
+
+    class Test
+
+        def main
+            is shared
+
+            s as String = ''
+            assert not s.length
+            s = 'aoeu'
+            assert 'aoeu'.length
+            assert s.length==4
+
+            assert 'aoeu'=='aoeu'
+            assert s=='aoeu'
+            assert s<>'asdf'
+
+            assert s.equals('aoeu')
+            # assert s.getHashCode<>0 # clr method name
+            assert s.hashCode<>0  # java method
+
+            s = "aoeu"  # double quotes
+
+            assert 'aoeu'.length==4
+            #assert '\a'.length==1 # illegal escape chars in java
+            #assert '\b'.length==1
+            #assert '\f'.length==1
+            assert '\n'.length==1
+            assert '\t'.length==1
+            assert '\\'.length==1
+            assert '\r'.length==1
+            assert '\0'.length==1
+            assert '\\t'.length==2
+            assert '\\t'[1]=='t'    
+            assert '\\t'[1]==c't'   
+
+            # concat
+            assert 'a' + 'b' == 'ab'
+            assert 'a' + '' == 'a'
+            assert 'a' + 'b' + 'c' == 'abc'
+
+            # try some methods
+            assert 'abc'.indexOf('b')==1
+            assert 'abc'.indexOf('d')==-1
+            assert 'abc'.endsWith('c')
+
+            # comparisons to chars
+            assert 'x'==c'x'
+            assert c'x'=='x'
+            assert '\0'==c'\0'
+            assert '\0'==String.valueOf(c'\0')
+
+            # +=
+            s = 'x'
+            s += 'y'
+            assert s=='xy'
+            
+
+            # concat with valueOf(char) - toString not available on char
+            s = 'aoeu'
+            #s = s[0].toString + 'b'
+            s = String.valueOf(s[0]) + 'b'
+            assert s=='ab'
+
+            # chars
+            assert 'a'[0] == c'a'
+            assert '"'[0] == c'"'
+            assert "'"[0] == c"'"
+
+            # backslashes
+            assert 'cobra\'s lair' == "cobra's lair"
+            assert '"' == "\""
+            assert '\'' == "'"
+            assert '\''[0] == c"'"
+            assert "\""[0] == c'"'

Tests/100-basics/070-is-and-is-not.cobra

@@ +1 @@
+#.require. clr
 namespace Test
 
     class Test

Tests/100-basics/063-string-substitution-escaped.cobra

@@ -1 +1 @@
 # Tests/100-basics/063-esc-string-subst.cobra
 # Tests for escaping of substitution syntax in strings
 # By hopscc
+#.require. clr
 class Test
 
     def main is shared
@@ -45 +46 @@
         assert s9 == r"8:a = \[[a]]"
     
     
-        # test some the old way without the escape syntax.
-        t = String.format('a = {0}[a]]', c'[')
-        assert t == r'a = [99]'
         s10 = 'FMT:a = '+ ns'[' +'[a]]'
         assert s10 == r'FMT:a = [99]'
     
-        a1 = String.format('{0}[a]]', ns'[')
-        s11 = 'a = [a1]'
-        assert s11 == r'a = [99]'
         
         s12 = 'a = [c'['][a]]'
         assert s12 == r'a = [99]'