Wiki

Ticket #275: java-jvm-2.patch

File java-jvm-2.patch, 141.1 KB (added by hopscc, 7 years ago)
  • Source/TypeProxies.cobra

     
    167167        return _actualType to ! 
    168168 
    169169    def _recommendBuiltInType 
    170         if _actualType.parentNameSpace and _actualType.parentNameSpace.fullName == 'System' 
    171             n = nil to String? 
    172             branch _actualType.name 
    173                 on 'Boolean', n = 'bool' 
    174                 on 'SByte',   n = 'int8' 
    175                 on 'Byte',    n = 'uint8' 
    176                 on 'Int16',   n = 'int16' 
    177                 on 'UInt16',  n = 'uint16' 
    178                 on 'Int32',   n = 'int32' 
    179                 on 'UInt32',  n = 'uint32' 
    180                 on 'Int64',   n = 'int64' 
    181                 on 'UInt64',  n = 'uint64' 
    182                 on 'Char',    n = 'char' 
    183                 on 'Single',  n = 'float32' 
    184                 on 'Double',  n = 'float' 
    185                 on 'Decimal', n = 'decimal' 
    186             if n, .compiler.warning(this, 'Use the builtin type "[n]" instead of the struct "[_actualType.name]".') 
    187  
     170        n = .compiler.backEnd.getRecommendedBuiltInType(_actualType.parentNameSpace, _actualType.name) 
     171        if n, .compiler.warning(this, 'Use the builtin type "[n]" instead of the struct "[_actualType.name]".') 
     172                         
    188173    def equals(other as Object?) as bool is override 
    189174        if other is nil 
    190175            return false 
  • Source/BackEndObjC/ObjcBackEnd.cobra

     
    66        base.init(compiler) 
    77        _name = 'objc'   
    88        _rtlName = 'Cobra.Lang.dll' 
     9        _rtlSrcFile = 'native.objc' # backEnd source file containing native code support for Cobra.Lang 
     10 
    911        _tagToTypeName = {  # TODO 
    1012            'Object': '', 
    1113            'Type'  : '', 
     
    1517        phases.add(GenerateObjcCodePhase(.compiler)) 
    1618        phases.add(CompileObjcCodePhase(.compiler)) 
    1719 
     20    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is override 
     21        n = nil to String? 
     22        if parentNameSpace and parentNameSpace.fullName == '???' 
     23            branch name 
     24                on '???', n = 'bool' 
     25                on '?? SByte',   n = 'int8' 
     26                on '?? Byte',    n = 'uint8' 
     27                on '?? Int16',   n = 'int16' 
     28                on '?? UInt16',  n = 'uint16' 
     29                on '?? Int32',   n = 'int32' 
     30                on '?? UInt32',  n = 'uint32' 
     31                on '?? Int64',   n = 'int64' 
     32                on '?? UInt64',  n = 'uint64' 
     33                on '?? Char',    n = 'char' 
     34                on '?? Single',  n = 'float32' 
     35                on '?? Double',  n = 'float' 
     36                on '?? Decimal', n = 'decimal' 
     37        return n 
     38 
    1839    def computeOutName as String is override 
    1940        return .compiler.computeOutNameObjc 
    2041         
     
    86107        assert false, 'ObjcBackEnd ObjcNativeType and objcTypeByName NYI' 
    87108        return ClrNativeType(.compiler.clrTypeByName(qualifiedName)) 
    88109     
    89     def addArrayInterfaces( interfaces as List<of ITypeProxy>) is override 
    90         assert false, 'ObjcBackEnd addArrayInterfaces NYI' 
     110    def prepSystemObjectClass(box as Box) is override 
     111        pass    #box.prepSystemObjectClassObjc 
    91112         
    92      
     113    def scanGenericArgs(box as Box)  is override 
     114        pass    # box.scanGenericArgsObjc 
    93115         
     116    def scanNativeType(box as Box)   is override 
     117        pass    # box.scanNativeTypeObjc 
     118 
     119    def scanNativeType(edcl as EnumDecl)     is override 
     120        pass    # edcl.scanNativeTypeObjc 
     121         
     122    def setUnderlyingType(edcl as EnumDecl)  is override 
     123        pass # edecl.setUnderlyingTypeObjc 
     124 
     125    # implement these if need override 
     126    #def determineExtnNativeType(extn as Extension, nativeType as NativeType) as NativeType 
     127    #   return extn.objcExtnNativeType(nativeType) 
     128 
     129    #def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace is override 
     130 
     131         
    94132class GenerateObjcCodePhase inherits Phase 
    95133 
    96134    cue init(c as Compiler) 
  • Source/Snapshot/Cobra.Lang/CobraCore.cobra

     
    385385                require false 
    386386                pass 
    387387 
     388            get runtimePlatform as String 
     389                return 'clr' 
     390                #return 'jvm' 
     391                # return 'objc' 
     392 
    388393            var _isRunningOnMono as bool? 
    389394             
    390395            get isRunningOnMono as bool 
  • Source/Snapshot/Cobra.Lang/Tracer.cobra

     
    1313        var _isActive = true 
    1414        var _willAutoFlush = true 
    1515        var _dest as TextWriter 
    16         var _separator = '; ' 
     16        var _separator = ';\n        -:' 
    1717        var _prefix = '    trace: ' 
    1818        var _willOutputDirectoryNames = false 
    1919 
  • Source/Compiler.cobra

     
    6464        base.init 
    6565        _name = '' 
    6666        _rtlName = 'rtl' 
     67        _rtlSrcFile = 'rtlSrc.ext' 
    6768        __compiler = compiler 
    6869 
    6970    get name from var as String 
    7071     
    7172    get cobraRuntimeLibFile from _rtlName as String  
     73        """Name of the Cobra RunTime Library file for this backend.""" 
    7274 
     75    get rtlSrcFile from _rtlSrcFile as String 
     76        """Name of the backEnd source file containing any native code support for Cobra.Lang.""" 
     77 
    7378    get compiler from __compiler as Compiler 
    7479     
    7580    get tagToTypeName from var 
     
    8893        rearrangements if necessary) for this given backend. 
    8994        """ 
    9095         
     96    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is abstract 
     97        """ 
     98        If parentNameSpace is the main system namespace and name is a backEnd builtin type  
     99        return the Cobra equivalent language type name (or nil).  
     100        """ 
     101         
    91102    def computeOutName as String is abstract 
    92103        """ 
    93         Return binary output name for compilation of files for this backend. 
     104        Return the binary file output name for compilation of files for this backend. 
    94105        """ 
    95106         
    96107    def genNativeModule(filename as String, verbosity as int) as Module? is abstract     
    97108        """ 
    98         Check if a filename is a Native module and if so return the Native module type for it 
     109        Check if a filename is a Native module and if so generate and return the Native module type for it 
    99110        otherwise return nil. 
    100111        """ 
    101112     
     
    117128     
    118129    def loadLibReference(reference as String) as bool is abstract 
    119130        """ 
    120         Load the given lib reference file  using the current backend paradigms.  
     131        Load the given library reference file  using the current backend paradigms.  
    121132        Return true if reference found and loaded correctly, false otherwise 
    122133        """ 
    123134     
    124135    def readSystemTypes is abstract 
    125136        """ Read and Load System Types for backend for Compiler to make available""" 
    126              
    127137         
    128138    def fixNilableMemberSigs is abstract 
    129139        """          
     
    167177        otherwise the qualified names are expected to conform to the platform back end naming.  
    168178        """ 
    169179     
    170     def addArrayInterfaces( interfaces as List<of ITypeProxy>) is abstract 
    171         """Add any additional interfaces the backends support that an ArrayType may need to have.""" 
    172              
     180    def prepSystemObjectClass(box as Box) is abstract 
     181        """Setup additional or convenience members on the System Object class. """ 
     182         
     183    def scanGenericArgs(box as Box) is abstract 
     184        """Scan a loaded Dll (generic) type and translate from native any generic Args.""" 
     185         
     186    def scanNativeType(box as Box) is abstract 
     187        """Scan a loaded Dll type and convert its native Type info to Cobras form """ 
     188         
     189    def scanNativeType(edcl as EnumDecl) is abstract 
     190        """Scan a loaded Dll Enum type and convert its native info to Cobras form """ 
     191         
     192    def setUnderlyingType(edcl as EnumDecl)  is abstract 
     193        """Set underlying Storage Type of the value of an Enum.""" 
     194         
     195    def determineExtnNativeType(extn as Extension, nativeType as NativeType) as NativeType 
     196        """ 
     197        The real extended type is the type of the first argument of any method. 
     198        Find and make that type from the param list. 
     199        """ 
     200        throw Exception('Need implementation of determineExtnNativeType for backend to determine type for an extension') 
     201 
     202    def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace 
     203        """  
     204            What to do if a namespace name collides with an existing symbol. 
     205            Some backends disallow this situation so its an error. 
     206            Others keep namespace and symbol tables separate so its perfectly 
     207            allowable. 
     208        """ 
     209        throw Exception('In [ns.name] there is a already non-namespace declaration named "[name]".') 
    173210     
    174211class BasicBackEnd inherits BackEnd 
    175212    """ Stub BackEnd for tests. """ 
     
    178215        base.init(compiler) 
    179216        _name = 'c#-clr(basic)' 
    180217        _rtlName = 'cobraRTL.libext' 
     218        _rtlSrcFile = 'cobraRTL.ext' 
    181219         
    182220        _tagToTypeName = { 
    183221            'Object': 'System.Object', 
     
    187225    def makePhases(phases as IList<of Phase>) is override 
    188226        pass 
    189227         
     228    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is override 
     229        return nil 
     230 
    190231    def computeOutName as String  is override 
    191232        return 'BasicOut' 
    192233         
     
    223264    def cobraNameForNativeBoxName(name as String) as String is override 
    224265        return name + '_BBE' 
    225266     
     267    def prepSystemObjectClass(box as Box) is override 
     268        pass 
     269         
     270    def scanGenericArgs(box as Box) is override 
     271        pass 
     272         
     273    def scanNativeType(box as Box) is override 
     274        pass 
     275         
     276    def scanNativeType(edcl as EnumDecl) is override 
     277        pass 
     278         
     279    def setUnderlyingType(edcl as EnumDecl)  is override 
     280        pass 
     281 
    226282    # Types 
    227283    get objectTypeProxy as AbstractTypeProxy is override 
    228284        return ClrTypeProxy(Object) # for testing 
     
    239295    def nativeTypeByName(qualifiedName as String) as NativeType is override 
    240296        return ClrNativeType(System.Object) #TODO: fix this to something non BE specific Tmp 
    241297     
    242     def addArrayInterfaces( interfaces as List<of ITypeProxy>) is override 
    243         pass 
    244          
    245298class Compiler implements ITypeProvider, IWarningRecorder, IErrorRecorder, ICompilerForNodes is partial 
    246299    """ 
    247300    General notes: 
     
    284337 
    285338 
    286339    # caches 
    287     #var _clrPrimitiveToITypeCache as IDictionary<of System.Type, IType>? 
    288     var _primitiveToITypeCache as IDictionary<of dynamic, IType>? 
     340    var _primitiveToITypeCache as IDictionary<of dynamic, IType>? # Key is backend type for a Type ( e.g System.Type) 
    289341 
    290342    cue init 
    291343        .init(0, nil) 
     
    347399        _primitiveToITypeCache = value 
    348400 
    349401    get globalNS from var 
     402        """ 
     403        Holds all topLevel decls including refs to Namespaces used and referenced. 
     404        """ 
    350405 
    351406    pro mainMethodTypeName from var as String = '' 
    352407 
     
    846901        return _nilableDynamicType to ! 
    847902# -- end of ITypeProvider 
    848903 
    849 /# 
    850 overrides replacing above for mixin of BasicTypeProvider 
    851     class Compiler ... includes BasicTypeProvider 
    852          
    853     var _nilableDynamicType as NilableType? 
    854      
    855     get numberType as AbstractNumberType is override 
    856         if _numberType is nil 
    857             branch .options['number'] to String 
    858                 on 'decimal', _numberType = .decimalType 
    859                 on 'float',   _numberType = .floatType 
    860                 on 'float32', _numberType = .floatType(32) 
    861                 on 'float64', _numberType = .floatType(64) 
    862                 else, throw FallThroughException(.options['number']) 
    863         return _numberType to ! 
    864904 
    865905 
    866     def nilableType(type as IType) as NilableType is override 
    867         if type inherits NilableType, return type 
    868         if _nilableTypes is nil 
    869             _nilableTypes = Dictionary<of INode, NilableType>() 
    870         if _nilableTypes.containsKey(type) 
    871             return _nilableTypes[type] 
    872         else 
    873             _nilableTypes[type] = nt = NilableType(type) 
    874             nt.bindInh 
    875             if not .isBindingInh, nt.bindInt 
    876             return nt 
    877  
    878     def defaultType as IType is override 
    879         return .nilableDynamicType 
    880  
    881     def nilableDynamicType as NilableType 
    882         if _nilableDynamicType is nil 
    883             _nilableDynamicType = .nilableType(.dynamicType) 
    884         return _nilableDynamicType to ! 
    885 #/       
    886  
    887  
    888906    get typeType as IType 
    889         #return _libraryType('System.Type') 
    890         #return _libraryType(.backEnd.tagToTypeName['Type']) 
    891907        return .libraryType('Type') 
    892908 
    893909    ## More type stuff 
     
    13381354        ns as IContainer = _globalNS 
    13391355        thing as IContainer? = nil 
    13401356        for name in names 
    1341             #print (thing ? ns) 
    13421357            possible = (thing ? ns).declForName(name) 
     1358            if not possible 
     1359                print thing ? ns 
    13431360            assert possible, name 
    13441361            if possible inherits IContainer 
    13451362                thing = possible 
  • Source/Boxes.cobra

     
    5656        ensure .needScanNativeType 
    5757        _nativeType = t 
    5858        _needScanNativeType = true 
    59         _callNativeScanMethod('ScanGenericArgs')     
    60  
    61     def _callNativeScanMethod(tag as String) 
    62         """ 
    63         Call a backend scan method for native type scan operation desired and backend in use. 
    64         """ 
    65         # This is icky - method to call needs to be set directly via backend somehow rather than this check and call code    
    66         # TODO: change to use strategy object set when init backend. 
    6759        assert .compiler 
    68         assert tag in ['ScanNativeType', 'ScanGenericArgs', 'prepSysObjClass'] # turn these into an Enum 
    69         backEnd = .compiler.backEnd 
    70         branch backEnd.name 
    71             on 'c#-clr' 
    72                 branch tag 
    73                     on 'ScanNativeType',  _scanNativeTypeClr 
    74                     on 'ScanGenericArgs', _scanGenericArgsClr 
    75                     on 'prepSysObjClass', _prepSystemObjectClassClr 
    76          
    77             on 'java-jvm' 
    78                 branch tag 
    79                     on 'ScanNativeType',  _scanNativeTypeJvm 
    80                     on 'ScanGenericArgs', _scanGenericArgsJvm 
    81                     on 'prepSysObjClass', _prepSystemObjectClassJvm 
    82             on 'objc' 
    83                 print 'objc back end need method for [tag]' 
    84                 assert false, 'Missing backEnd infrastructure for [backEnd.getType.name]' 
    85                     #branch on tag 
    86                     #   on 'ScanNativeType',  _scanObjcNativeType 
    87                     #   on 'ScanGenericArgs', _scanObjcGenericArgs 
    88                     #   on 'prepSysObjClass', _prepSystemObjectClassObjc 
    89             else  
    90                 throw FallThroughException('No nativeScanMethod code for backend [backEnd.name] [backEnd.getType.name]') 
     60        .compiler.backEnd.scanGenericArgs(this) # Convert any Generic args fm backend form to Cobra data structures 
    9161                 
    92          
    9362    def addMinFields 
    9463        base.addMinFields 
    9564        .addField('didBindInh', .didBindInh) 
     
    650619    ## Binding 
    651620    def _scanNativeType 
    652621        #print '_scanNativeType ', .name 
    653         _callNativeScanMethod('ScanNativeType')      
     622        assert .compiler 
     623        .compiler.backEnd.scanNativeType(this) # Convert library (native) info to Cobra data structures 
    654624         
    655625    def _stackPush 
    656626        base._stackPush 
     
    730700        # Therefore, everthing below has already happened for a constructed box's generic def. 
    731701        base._bindInt 
    732702        if .isSystemObjectClass 
    733             _callNativeScanMethod('prepSysObjClass') 
     703            assert .compiler 
     704            .compiler.backEnd.prepSystemObjectClass(this) # add any improvements to root Object 
    734705        errorCount = .compiler.errors.count 
    735706        if _needScanNativeType, _scanNativeType 
    736707        if _baseClass 
     
    11041075                    newDecls.add(nd) 
    11051076            for decl in _declsInOrder 
    11061077                if decl inherits BoxMember 
     1078                    #if not decl.didBindInt # hops: fix for crash with generics and java before changeset 2576 
     1079                    #   print 'dbg: ', decl.name 
     1080                    #   decl.bindInt 
    11071081                    nd = decl.constructedFor(this, gpToType) 
    11081082                    assert nd <> decl 
    11091083                    newDecls.add(nd) 
     
    18861860        base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), nil) 
    18871861        _initNativeType(nativeType) 
    18881862        # the real extended type is not this type, but the type of the first argument of any method 
    1889         branch backend.name 
    1890             on 'c#-clr',    nativeType = .clrExtnNativeType(nativeType)     # ScanClrType 
    1891             on 'java-jvm',  nativeType = .jvmExtnNativeType(nativeType)     # ScanJvmType 
    1892             on 'objc' 
    1893                 print 'objc back end need method objcExtnNativeType' 
    1894                 assert false, 'Missing backEnd infrastructure for [backend.getType.name]' 
    1895             else  
    1896                 throw FallThroughException('No extnNativeType code for backend [backend.name] [backend.getType.name]') 
    1897         #nativeType = backEnd.determineExtnNativeType(nativeType) 
     1863        nativeType = backend.determineExtnNativeType(this, nativeType) 
    18981864        _extendedBoxProxy = backend.nativeTypeProxy(nativeType) 
    18991865        (.compiler.curModule to AssemblyModule).addMustBindInh(this) 
    19001866 
  • Source/Cobra.Lang/Java/CobraCore.java

     
    1717    public static Boolean _willCheckAssert = true; 
    1818    public static Boolean _willCheckNil = true; 
    1919 
     20    //public static String getRuntimePlatform() { return "jvm"; } // prop 
     21    public static final String runtimePlatform =  "jvm";  
     22     
    2023    public static int noOp(/* allowNull */ Object... args) {  
    2124        /* """ 
    2225    No operation. Primarily used in Cobra's own test suite to consume a local variable to avoid undesired warnings. 
  • Source/Cobra.Lang/Java/CobraLang.jar.sig

     
    1 # PkgSig file for jarfile 'C:\home\hops\src\cobra\wkspace\Source\Cobra.Lang\java\CobraLang.jar' 
    2 # jarfile:  C:\home\hops\src\cobra\wkspace\Source\Cobra.Lang\java\CobraLang.jar 
    3  
    4 cobra.lang.CobraCore 
    5     class                          # JavaType 
    6     cobra.lang                     # package 
    7     CobraCore                      # name 
    8     java.lang.Object               # superclass 
    9     -                              # no  Interfaces 
    10     public                         # modifiers 
    11     var _willCheckInvariant 
    12         static public                  # modifiers 
    13         java.lang.Boolean              # Type 
    14     var _willCheckRequire 
    15         static public                  # modifiers 
    16         java.lang.Boolean              # Type 
    17     var _willCheckEnsure 
    18         static public                  # modifiers 
    19         java.lang.Boolean              # Type 
    20     var _willCheckAssert 
    21         static public                  # modifiers 
    22         java.lang.Boolean              # Type 
    23     var _willCheckNil 
    24         static public                  # modifiers 
    25         java.lang.Boolean              # Type 
    26     ctor cobra.lang.CobraCore 
    27         -                              # no Parameters 
    28     method noOp[V] 
    29         static public                  # modifiers 
    30         int                            # returnType 
    31         [Ljava.lang.Object;            # Parameters 
    32         -                              # no Exceptions 
    33     method runAllTests 
    34         static public                  # modifiers 
    35         void                           # returnType 
    36         -                              # no Parameters 
    37         -                              # no Exceptions 
    38     method printDebuggingTips 
    39         static public                  # modifiers 
    40         void                           # returnType 
    41         -                              # no Parameters 
    42         -                              # no Exceptions 
    43  
    44 cobra.lang.CobraImp 
    45     class                          # JavaType 
    46     cobra.lang                     # package 
    47     CobraImp                       # name 
    48     java.lang.Object               # superclass 
    49     -                              # no  Interfaces 
    50     public                         # modifiers 
    51     var _printStringMaker 
    52         static public                  # modifiers 
    53         cobra.lang.CobraImp$SimpleStringMaker # Type 
    54     ctor cobra.lang.CobraImp 
    55         -                              # no Parameters 
    56     method printLine 
    57         static public                  # modifiers 
    58         void                           # returnType 
    59         -                              # no Parameters 
    60         -                              # no Exceptions 
    61     method printLine 
    62         static public                  # modifiers 
    63         void                           # returnType 
    64         java.lang.String               # Parameters 
    65         -                              # no Exceptions 
    66     method printStop 
    67         static public                  # modifiers 
    68         void                           # returnType 
    69         -                              # no Parameters 
    70         -                              # no Exceptions 
    71     method printStop 
    72         static public                  # modifiers 
    73         void                           # returnType 
    74         java.lang.String               # Parameters 
    75         -                              # no Exceptions 
    76     method makeString 
    77         static public                  # modifiers 
    78         java.lang.String               # returnType 
    79         java.lang.String               # Parameters 
    80         -                              # no Exceptions 
    81     method makeString 
    82         static public                  # modifiers 
    83         java.lang.String               # returnType 
    84         [Ljava.lang.String;            # Parameters 
    85         -                              # no Exceptions 
    86  
    87 cobra.lang.CobraImp$SimpleStringMaker 
    88     class                          # JavaType 
    89     cobra.lang                     # package 
    90     CobraImp$SimpleStringMaker     # name 
    91     java.lang.Object               # superclass 
    92     -                              # no  Interfaces 
    93     static public                  # modifiers 
    94     ctor cobra.lang.CobraImp$SimpleStringMaker 
    95         -                              # no Parameters 
    96     method makeString 
    97         public                         # modifiers 
    98         java.lang.String               # returnType 
    99         [Ljava.lang.String;            # Parameters 
    100         -                              # no Exceptions 
    101     method makeString 
    102         public                         # modifiers 
    103         java.lang.String               # returnType 
    104         java.lang.String               # Parameters 
    105         -                              # no Exceptions 
    106     method makeString 
    107         public                         # modifiers 
    108         java.lang.String               # returnType 
    109         int                            # Parameters 
    110         -                              # no Exceptions 
    111     method makeString[V] 
    112         public                         # modifiers 
    113         java.lang.String               # returnType 
    114         [Ljava.lang.Object;            # Parameters 
    115         -                              # no Exceptions 
  • Source/Cobra.Lang/Java/PkgSig.java

     
    1515 *   
    1616 *  
    1717 * TODO  
    18  *  add cmdline flag generating pkgSig file w/o redirection:   
     18 *  add cmdline flag generating pkgSig file w/o redirection: 
    1919 *      java -cp . PkgSig -cobra <pkgname> 
    2020 *  Cleanup and javadoc this file. 
    2121 * Put a PkgSig version and timestamp in the pkgSigFile 
     
    331331    public static void usage() { 
    332332        System.out.println("Unknown usage"); 
    333333        System.out.printf("usage: pkgSig [-p] <pkgName>\n"); 
    334         System.out.printf("usage: pkgSig -j <jarfile>\n "); 
    335         System.out.printf("  Display class signatures for a package or contents of a jarfile.\n\n "); 
     334        System.out.printf("usage: pkgSig -j <jarfile>\n"); 
     335        System.out.printf("usage: pkgSig -jrt\n "); 
     336        System.out.printf("  Display class signatures for a package or contents of a jarfile.\n\n"); 
    336337        System.out.printf("A class signature is the class name, its superclass and signatures for fields and methods of the class.\n"); 
    337338        System.out.printf("Packages are searched for in files and jars in classpath.\n"); 
    338339        System.out.printf("Jarfiles are specified as relative or absolute pathnames. Relative pathname Jarfiles not found are searched for in the classpath\n"); 
     340        System.out.printf("The -jrt invocation displays class Signatures for the java runtime jarfile(s)\n"); 
    339341        System.out.printf("Output format is suitable for parsing and use by the cobra java backend (cross) compiler.\n"); 
    340342        System.exit(2); 
    341343    } 
     
    369371        return jarFile; 
    370372    } 
    371373     
     374    public static void sigForJarFile(String fileName, Set<String> suppressFilter) throws ClassNotFoundException 
     375    { 
     376        ClassLoader loader = Thread.currentThread().getContextClassLoader(); 
     377        assert loader != null; 
     378        File jarFile = PkgSig.lookForJarFile(fileName, loader); 
     379        if ( !jarFile.exists()) { 
     380            System.out.printf("File '%s' does not exist.\n", jarFile.getAbsolutePath()); 
     381            System.exit(1); 
     382        } 
     383             
     384        //System.out.printf( "DBG: jarfile=%s\n", jarFile.getAbsolutePath()); 
     385        Set<Class> clsSet = new java.util.concurrent.ConcurrentSkipListSet<Class>(new PkgSig.ClassComparator()); 
     386 
     387        System.out.printf("# PkgSig file for jarfile '%s'\n", jarFile.getAbsolutePath()); 
     388        processJarFile(jarFile.getAbsolutePath(), loader, null, suppressFilter, clsSet); 
     389         
     390        for ( Class cls : clsSet) { 
     391            new ClassSig(cls).emit(); 
     392        } 
     393    } 
    372394     
    373395    public static void main( String[] args) throws Exception { 
    374396        if (args.length ==0 ) 
    375397              usage(); 
    376398 
    377         if (args.length == 1 ) {  // default -p pkgname [...] 
    378             if ( args[0].startsWith("-")) usage(); 
    379  
     399        if (args.length == 1 && !args[0].startsWith("-") ) {  // default -p pkgname [...] 
    380400            String pkg = args[0]; 
    381401            Set<Class> clsSet = PkgSig.findClassesForPkg(pkg); 
    382402            if (clsSet.size() == 0 ) 
     
    386406            } 
    387407 
    388408            for ( Class cls : clsSet) { 
    389                     //Class cls = (Class)o; 
    390                     //System.out.println(cls.getName()); 
    391409                ClassSig classSig = new ClassSig(cls); 
    392410                classSig.emit();     
    393411            } 
     
    396414            String pkg = args[1]; 
    397415            Set<Class> clsSet = PkgSig.findClassesForPkg(pkg); 
    398416            for ( Class cls : clsSet) { 
    399                 //ClassSig classSig = new ClassSig(cls); 
    400                 //classSig.emit();     
    401417                new ClassSig(cls).emit(); 
    402418            } 
    403419        } 
    404420        else if (args[0].equals("-j")) { 
    405             ClassLoader loader = Thread.currentThread().getContextClassLoader(); 
    406             assert loader != null; 
    407             String fileName = args[1]; 
    408             File jarFile = PkgSig.lookForJarFile(fileName, loader); 
    409             if ( !jarFile.exists()) { 
    410                 System.out.printf("File '%s' does not exist.\n", jarFile.getAbsolutePath()); 
    411                 System.exit(1); 
    412             } 
     421            PkgSig.sigForJarFile(args[1], null); 
     422        } 
     423        else if (args[0].equals("-jrt")) {  // java runtime  
     424            Set<String> suppressFilter = new HashSet<String>(); 
    413425             
    414             //System.out.printf( "DBG: jarfile=%s\n", jarFile.getAbsolutePath()); 
    415         Set<Class> clsSet = new java.util.concurrent.ConcurrentSkipListSet<Class>(new PkgSig.ClassComparator()); 
    416             Set<String> suppressFilter = new HashSet<String>(); 
    417426            // Theres upwards of 8000 classes in rt.jar most of which we dont care about 
    418427            // suppress internal implementation classes which shouldnt be using anyway 
    419428            suppressFilter.add("com.sun"); 
    420429            suppressFilter.add("com.sunw"); 
    421430            suppressFilter.add("sun"); 
    422431            suppressFilter.add("sunw"); 
     432             
    423433            // suppress some biggies we 'probably' wont ever use - may want to revisit these 
    424             suppressFilter.add("org.omg"); 
    425             suppressFilter.add("javax.swing.plaf"); 
     434            suppressFilter.add("org.omg"); // Corba Sh*t - cos *everybody* needs this in the base RTL 
     435            suppressFilter.add("javax.swing.plaf"); // swing platform GUI implementations - ditto 
    426436            suppressFilter.add("javax.print.attribute.standard"); 
    427             suppressFilter.add("org.jcp.xml.dsig"); 
     437            suppressFilter.add("org.jcp.xml.dsig"); // bloat in the RTL - why should we worry about that? 
    428438 
    429             System.out.printf("# PkgSig file for jarfile '%s'\n", jarFile.getAbsolutePath()); 
    430             processJarFile(jarFile.getAbsolutePath(), loader, null, suppressFilter, clsSet); 
    431          
    432             for ( Class cls : clsSet) { 
    433                 new ClassSig(cls).emit(); 
    434             } 
     439            PkgSig.sigForJarFile("rt.jar", suppressFilter); 
    435440        } 
    436441        else { 
    437442            usage(); 
     
    448453    Class cls; 
    449454    TypeVariable<?>[] genericParams = {}; 
    450455    int indent= 0; 
    451      
     456    static String TYPE_SEP = ","; 
     457           
    452458    public ClassSig(Class cls) { 
    453459        this.cls = cls; 
    454460    }     
     
    486492        System.out.printf( "%-30s %s\n", t, "# JavaType"); 
    487493         
    488494        printIndent(); 
    489         System.out.printf("%-30s %s\n", this.cls.getPackage().getName(), "# package"); 
     495        String pkgName = this.cls.getPackage().getName(); 
     496        System.out.printf("%-30s %s\n", pkgName, "# package"); 
    490497         
    491         // Name of the class, dotNet form for Generic class 
    492         String clsName = this.cls.getSimpleName(); 
    493         Class enclClass = this.cls.getEnclosingClass(); 
    494         if ( enclClass != null) { 
    495             clsName = enclClass.getSimpleName() + "$" + this.cls.getSimpleName(); 
    496             flags += "N"; 
    497         } 
     498        // Name of the class(without pkgname), dotNet form for Generic class 
     499        String clsName = this.cls.getName(); 
     500        if (clsName.startsWith(pkgName+".")) 
     501              clsName = clsName.substring(pkgName.length()+1); 
    498502        String gName = this.dotNetGenericsName(this.cls, clsName); 
    499503        if (! gName.isEmpty()) { 
    500504            clsName = gName; 
     
    524528        //  Interfaces 
    525529        //System.out.printf("%-30s %s\n", '-', " # interfaces"); 
    526530        //Class[] interfaces = this.cls.getInterfaces(); 
    527         //emitClassList(interfaces, "interfaces"); 
    528         Type[] gInterfaces = this.cls.getGenericInterfaces(); 
     531        //emitClassList(interfaces, "nonG interfaces"); 
     532        Type[] gInterfaces = getAllGenericInterfaces(this.cls); 
     533        //Type[] gInterfaces = this.cls.getGenericInterfaces(); 
    529534        emitTypesList(gInterfaces, " Interfaces"); 
     535        //System.out.printf("### nIfcs %d, ngIfcs %d\n", interfaces.length, gInterfaces.length); 
    530536 
    531537        // Modifiers 
    532538        //System.out.printf("%-30s %s\n", '-', " # modifiers"); 
     
    709715        for (Class c : clsList) { 
    710716            sb.append(sep); 
    711717            sb.append(c.getName()); 
    712             sep = ","; 
     718            sep = TYPE_SEP;             
    713719        } 
    714720        if (clsList.length == 0 )  
    715721            sb.append("-"); 
     
    732738        for (TypeVariable<?> p : this.genericParams) { //  
    733739            sb.append(sep); 
    734740            sb.append(p.getName()); 
    735             sep = ","; 
     741            sep = TYPE_SEP;             
     742             
    736743        } 
    737744        //if (this.genericParams.length == 0 )  
    738745        //    return; //sb.append("-"); 
     
    751758            sb.append(sep); 
    752759            String tStr = this.makeTypeStr(t); 
    753760            sb.append(tStr); 
    754             sep = ","; 
     761            sep = TYPE_SEP;             
     762             
    755763        } 
    756764        if (typList.length == 0 ) { 
    757765            //if (isOptional) 
     
    774782     
    775783    /* 
    776784     * Cleanup a (Generic) Type name to be 'consistant' with class naming. 
     785     *  
     786     * @param t   Type to do name cleanup on 
     787     * @return     String representation of 'cleaned' Type  
    777788     */ 
    778789    public String makeTypeStr(Type t) { 
    779790        String tStr = t.toString(); 
     791        //System.out.printf("### %-50s \n", tStr); 
     792        tStr = tStr.replace("java.util.Map.java.util.Map", "java.util.Map");  // EntrySets screwed for some reason 
     793         
    780794        tStr = tStr.replace("class ", "");  // sometimes puts on leading 'type ' 
    781795        tStr = tStr.replace("interface ", "");   
    782796        // possibly others - enum ? 
     
    794808        } 
    795809        return tStr; 
    796810    } 
     811     
     812    /* Walk class inheritance hierachy from a class up,  accumulate and return all the  
     813     * interfaces (generic and not) supported. 
     814     * Uses getGenericInterfaces to lookup interfaces for each class. 
     815     *  
     816     * @param cls   Class to obtain all interfaces for. 
     817     * @return      Array of Types containing all generic interfaces found 
     818     */ 
     819    public Type[] getAllGenericInterfaces(Class cls) { 
     820        List<Type> ifcs = new ArrayList<Type>(); 
     821        while ( cls != null ) { 
     822            for ( Type t : cls.getGenericInterfaces() ) 
     823            ifcs.add(0, t); // insert at front so list is in superclass downwards order 
     824            cls = cls.getSuperclass(); 
     825        } 
     826 
     827        // remove any dups using a Set 
     828        Set<Type> ifcSet = new LinkedHashSet<Type>(); 
     829        for ( Type t : ifcs ) 
     830            ifcSet.add(t); 
     831        return ifcSet.toArray(new Type[0]); 
     832    } 
    797833} 
  • Source/Cobra.Lang/Java/mkjar

     
    1010[ $? == 0 ] || exit 
    1111cp CobraLang.jar ../.. 
    1212 
    13 #java -cp '.;CobraLang.jar'  PkgSig -j CobraLang.jar > CobraLang.jar.sig 
     13#echo 'pkgSig for CobraLang.jar' 
     14java -cp '.;CobraLang.jar'  PkgSig -j CobraLang.jar > CobraLang.jar.sig 
     15cp CobraLang.jar.sig  ../.. 
     16 
     17 
    1418## assume rt.jar, java.util and java.lang sigfiles already exist and are static 
    1519#cp CobraLang.jar.sig rt.jar.sig java.util.sig java.lang.sig ../.. 
  • Source/Cobra.Lang/Java/mkjarAll

     
    2020java -cp '.;CobraLang.jar'  PkgSig -j CobraLang.jar > CobraLang.jar.sig 
    2121 
    2222echo 'Gen pkgSig file for rt.jar' 
    23 java -cp .  PkgSig -j rt.jar > rt.jar.sig 
     23java -cp .  PkgSig -jrt > rt.jar.sig 
    2424echo 'Gen pkgSig file for java.lang' 
    2525java -cp .  PkgSig  java.lang > java.lang.sig 
    2626echo 'Gen pkgSig file for java.util' 
  • Source/Cobra.Lang/CobraCore.cobra

     
    385385                require false 
    386386                pass 
    387387 
     388            get runtimePlatform as String 
     389                return 'clr' 
     390                #return 'jvm' 
     391                # return 'objc' 
     392 
    388393            var _isRunningOnMono as bool? 
    389394             
    390395            get isRunningOnMono as bool 
  • Source/Cobra.Lang/Tracer.cobra

     
    1313        var _isActive = true 
    1414        var _willAutoFlush = true 
    1515        var _dest as TextWriter 
    16         var _separator = '; ' 
     16        var _separator = ';\n     -:' 
    1717        var _prefix = '    trace: ' 
    1818        var _willOutputDirectoryNames = false 
    1919 
  • Source/Node.cobra

     
    11881188    ## More types 
    11891189    # TODO: move up to ITypeProvider? 
    11901190 
    1191     #get clrPrimitiveToITypeCache as IDictionary<of System.Type, IType>? 
    11921191    get primitiveToITypeCache as IDictionary<of dynamic, IType>? 
    11931192 
    11941193    get basicTypes as IList<of PrimitiveType> 
  • Source/Module.cobra

     
    3737    var _topNameSpace as NameSpace 
    3838    var _mustBindInhList = List<of INameSpaceMember>() 
    3939 
    40     #cue init(ass as Assembly, globalNS as NameSpace) 
    41     #   .init(ass, 0, globalNS) 
    42  
    43     #cue init(ass as Assembly, verbosity as int, globalNS as NameSpace) 
    44     #   base.init(ass.location, verbosity, '') 
    45     #   _topNameSpace = NameSpace(globalNS, '(top namespace for assembly [ass])') 
    46  
    4740    cue init(location as String, globalNS as NameSpace) 
    4841        .init(location, 0, globalNS) 
    4942 
     
    6356 
    6457    def _bindInh 
    6558        base._bindInh 
    66         # .topNameSpace.bindInh - It's too expensive to scan all types in a DLL. Do them as needed. 
     59        # .topNameSpace.bindInh - It's too expensive to scan all types in a DLL. Do them as needed. (See Box._prepIfNeeded) 
    6760        for item in _mustBindInhList, item.bindInh 
    6861 
    6962    def _bindInt 
    7063        base._bindInt 
    71         # .topNameSpace.bindInt - It's too expensive to scan all types in a DLL. Do them as needed. 
     64        # .topNameSpace.bindInt - It's too expensive to scan all types in a DLL. Do them as needed. (See Box._prepIfNeeded) 
    7265 
    7366 
    7467class CobraModule inherits Module is partial 
     68    """ 
     69    Module for a cobra source File. 
     70        Holds name, docString and the topLevelNamespace as the root of the parsed AST nodes. 
     71        Also handles binding by passing bind invocation onto its namespace to action. 
     72    """ 
    7573 
    7674    cue init(fileName as String, verbosity as int, docString as String, globalNS as NameSpace) 
    7775        base.init(fileName, verbosity, docString) 
  • Source/NameSpace.cobra

     
    1313    is partial 
    1414    inherits Container<of INameSpaceMember> 
    1515    implements IParentSpace, INameSpaceMember 
    16  
     16     
     17    """ 
     18    Two flavours of NameSpace 
     19        Unified -  holds decls + NameSpaces 
     20        Non-unified - holds decls + NameSpaces and list of Use Directives done in the namespace. 
     21                    - points to its corresponding unified namespace 
     22     
     23        (Most) modules have a topLevel namespace that holds the modules contents 
     24        The compiler holds a global namespace for the program containing all top level namespaces and (system) namespaces referenced. 
     25    """ 
     26     
    1727    var _unifiedNameSpace as NameSpace? 
    1828    var _superNameSpace as NameSpace? 
    1929    var _subNameSpacesByName as Dictionary<of String, NameSpace> 
     
    131141            ns = _subNameSpacesByName[name] 
    132142        else 
    133143            if _declsByName.containsKey(name) 
    134                 throw Exception('There is a non-namespace declaration named "[name]".') 
     144                return .compiler.backEnd.handleNameSpaceNameCollision(this, token, name) 
    135145            ns = NameSpace(token, name, this) 
    136146            if not .isUnified 
    137147                # mirror in the unified namespace 
     
    267277            m = ud.extensionMemberFor(box, name) 
    268278            if m, return m 
    269279        return if(_superNameSpace, _superNameSpace._extensionMemberFromUseDirectives(box, name), nil) 
    270  
     280         
    271281    def symbolForName(name as String) as IMember? 
    272282        if not .isUnified 
    273283            x = _unifiedNameSpace.symbolForName(name) 
     
    291301            # our decl? 
    292302            # TODO: should this come before checking our name? what does C# do? 
    293303            x = .declForName(name) 
    294             if x, return x 
     304            if x 
     305                return x 
    295306/# 
    296307            # wrong. see ticket:128 
    297308            # a parent namespace? 
  • Source/Phases/BindUsePhase.cobra

     
    8787            # curNS = nil # force reference attempt 
    8888        if curNS is nil and not didAutoLoad 
    8989            if _fileName <> '' 
    90                 #if .compiler.loadReference(_fileName + '.dll') 
    9190                if .compiler.loadReference(_fileName, true) 
    9291                    _bindUse(true) 
    9392                    if .boundNameSpace is nil 
     
    9998                        return 
    10099                    .throwError('Cannot find library file "[_fileName]".') 
    101100            else 
    102                 if _fullName.endsWith('.dll') 
    103                     .throwError('Do not end a namespace name in a "use" directive with ".dll".') 
    104                 #if .compiler.loadReference(_fullName + '.dll') 
     101                if _fullName.endsWith('.dll') or _fullName.endsWith('.jar')  
     102                    .throwError('Do not end a namespace name in a "use" directive with an extension (like ".dll" or ".jar").') 
    105103                if .compiler.loadReference(_fullName, true) 
    106104                    _bindUse(true) 
    107105                    if .boundNameSpace is nil 
     
    119117                        if curNS is nil, break 
    120118                        partialName += '.' + name 
    121119                    if partialName == '' 
     120                        #assert false 
    122121                        .throwError('Cannot find namespace "[_fullName]".') 
    123122                    else 
    124123                        .throwError('Cannot find namespace "[name]" in "[partialName[1:]]".') 
  • Source/Phases/BindInterfacePhase.cobra

     
    11class BindInterfacePhase inherits Phase 
    22    """ 
     3    Set the typing of interfacing or API items.  
    34    Bind the AST nodes for var types, parameter types, return types, etc. to their actual types. 
    45    Does not look inside implementations of methods and properties; only at the interface/API of the types. 
    56    """ 
  • Source/Phases/BindRunTimeLibraryPhase.cobra

     
    3838        filesPath = Path.combine(Path.combine(.cobraExeDir, 'Cobra.Lang'), 'files.text') 
    3939        runTimePaths = c.commandLineArgParser.readFilesFile(filesPath) 
    4040        runTimePaths.reverse 
     41        rtlSrcFile = c.backEnd.rtlSrcFile   #'Native.cs' 
     42        assert rtlSrcFile.count(c'.') == 1 
    4143        for runTimePath in runTimePaths 
    42             if Path.getFileName(runTimePath) == 'Native.cs' 
     44            if Path.getFileName(runTimePath) == rtlSrcFile 
    4345                suffix = .options.embedRunTimeSuffix 
    4446                nativeCode = File.readAllText(runTimePath) 
    4547                nativeCode = nativeCode.replace('namespace Cobra.Lang', 'namespace Cobra.Lang'+suffix) 
    46                 newPath = Path.getFullPath('Native[suffix].cs') 
     48                newPath = Path.getFullPath(rtlSrcFile.before('.') + suffix + '.' + rtlSrcFile.after('.')) 
    4749                File.writeAllText(newPath, nativeCode) 
    4850                c.addIntermediateFile(newPath) 
    4951                pathsToCompile.insert(0, newPath) 
  • Source/Utils.cobra

     
    5454extend String 
    5555 
    5656    # These should go in String Extensions 
    57     def beforeL(sep as String) as String 
     57    def before(sep as String) as String 
    5858        test 
    5959            s = 'abc|de' 
    60             assert s.beforeL('|') == 'abc' 
    61             assert s.beforeL('=') == 'abc|de' 
    62             assert '|abcde'.beforeL('|') == '' 
    63             assert 'abcde|'.beforeL('|') == 'abcde' 
     60            assert s.before('|') == 'abc' 
     61            assert s.before('=') == 'abc|de' 
     62            assert '|abcde'.before('|') == '' 
     63            assert 'abcde|'.before('|') == 'abcde' 
    6464        body 
    6565            idx = .indexOf(sep) 
    6666            if idx < 0 
    6767                return this 
    6868            return this[0:idx] 
    6969 
    70     def afterL(sep as String) as String 
     70    def after(sep as String) as String 
    7171        test 
    7272            s = 'abc|de' 
    73             assert s.afterL('|') == 'de' 
    74             assert s.afterL('=') == '' 
    75             assert '|abcde'.afterL('|') == 'abcde' 
    76             assert 'abcde|'.afterL('|') == '' 
     73            assert s.after('|') == 'de' 
     74            assert s.after('=') == '' 
     75            assert '|abcde'.after('|') == 'abcde' 
     76            assert 'abcde|'.after('|') == '' 
    7777        body 
    7878            idx = .indexOf(sep) 
    7979            if idx < 0 
  • Source/BackEndClr/ClrType.cobra

     
    193193    #   clrPrimitiveToIType = Dictionary<of dynamic, IType>() 
    194194        for bt in .compiler.basicTypes 
    195195            if bt.systemAliasProxy 
    196                 key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to ClrNativeType).clrType # TODO: hops cleanup no ClrNativeType 
     196                key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to ClrNativeType).clrType 
    197197                clrPrimitiveToIType[key] = bt 
    198198        assert clrPrimitiveToIType.count == 0 or clrPrimitiveToIType.count > 9 
    199199        return clrPrimitiveToIType 
  • Source/BackEndClr/ScanClrType.cobra

     
    239239        finally 
    240240            _curModule = saveModule 
    241241 
    242     def dotNetfixNilableMemberSigs 
     242    def dotNetFixNilableMemberSigs 
     243        # Fix the listed members to be non Nilable 
    243244        # TODO: this really needs to go in a separate file that the compiler reads each time 
    244  
    245245        # TODO: look to see if what the Spec# team put together can be leveraged instead of recreating all this work! 
    246         # fix up member sigs regarding nilable 
    247246        # hard coded below. TODO: read from a Cobra config file 
    248247        _fix('System.Object', 'toString getType memberwiseClone') 
    249248            # ^ regarding .toString, not technically true, but common enough and life is too painful when the return type is nilable 
     
    433432    def isClrSystemExceptionClass as bool 
    434433        return .name == 'Exception' and .parentNameSpace and .parentNameSpace.fullName == 'System' 
    435434                 
    436     def _prepSystemObjectClassClr 
     435    def prepSystemObjectClassClr 
    437436        # Pretend .NET is a bit more OO, consistent and elegant. 
    438437        # C#'s typeof(X) is X.getType in Cobra. 
    439438        existing = .declForName('getType') to BoxMember 
     
    443442        meth.sharedMethodBacking = 'typeof' 
    444443        overload.addMember(meth) 
    445444         
    446     def _scanNativeTypeClr 
     445    def scanNativeTypeClr 
    447446        """ 
    448447        Subclasses should invoke base and then invoke the various _scanFoo methods that are appropriate for them. 
    449448        """ 
     
    452451        # print '<> _scanNativeType for [.name] in [_parentNameSpace.fullName], class is [.getType.name]' 
    453452 
    454453 
    455     def _scanGenericArgsClr 
     454    def scanGenericArgsClr 
    456455        if _clrType.isGenericType 
    457456            for genArg in _clrType.getGenericArguments 
    458457                t = (.compiler to Compiler).typeForClrType(genArg) 
     
    818817class Class 
    819818    is partial 
    820819 
    821     def _scanNativeTypeClr 
    822         base._scanNativeTypeClr 
     820    def scanNativeTypeClr 
     821        base.scanNativeTypeClr 
    823822        _scanClrIsNames 
    824823        _scanClrImplements 
    825824        _scanClrNestedTypes 
     
    835834class Interface 
    836835    is partial 
    837836 
    838     def _scanNativeTypeClr 
    839         base._scanNativeTypeClr 
     837    def scanNativeTypeClr 
     838        base.scanNativeTypeClr 
    840839        _scanClrIsNames 
    841840        _scanClrImplements 
    842841        _scanClrNestedTypes 
     
    849848class Struct 
    850849    is partial 
    851850 
    852     def _scanNativeTypeClr 
    853         base._scanNativeTypeClr 
     851    def scanNativeTypeClr 
     852        base.scanNativeTypeClr 
    854853        _scanClrIsNames 
    855854        _scanClrImplements 
    856855        _scanClrNestedTypes 
     
    863862 
    864863class Extension is partial 
    865864 
    866     def _scanNativeTypeClr 
     865    def scanNativeTypeClr 
    867866        # this only for Cobra specific extensions. Example: class Extend_String_1939 
    868         base._scanNativeTypeClr 
     867        base.scanNativeTypeClr 
    869868        _scanClrIsNames 
    870869        #_scanClrImplements 
    871870        #_scanClrNestedTypes 
     
    894893 
    895894class EnumDecl is partial 
    896895 
    897     def _setUnderlyingTypeClr 
     896    cue init(parent as IParentSpace?, nativeType as NativeType) 
     897        .init(parent, nativeType, List<of String>(), '') 
     898         
     899    def setUnderlyingTypeClr 
    898900        _storageTypeNode =  ClrTypeProxy(Enum.getUnderlyingType((_nativeType to ClrNativeType).backEndType)) 
    899901     
    900     def _scanNativeTypeClr 
     902    def scanNativeTypeClr 
    901903        # TODO: read attribs 
    902904        _needScanNativeType = false 
    903905        clrType = (_nativeType to ClrNativeType).clrType  
  • Source/BackEndClr/ClrBackEnd.cobra

     
    1313        _typeTypeProxy = ClrTypeProxy(Type) 
    1414        _name = 'c#-clr' 
    1515        _rtlName = 'Cobra.Lang.dll' 
     16        _rtlSrcFile = 'Native.cs' # backEnd source file containing native code support for Cobra.Lang 
    1617     
    1718        _tagToTypeName = {  
    1819            'Object'    :       'System.Object', 
     
    5152            'uint32': 'System.UInt32',       
    5253            'uint64': 'System.UInt64',       
    5354            } 
    54          
     55 
    5556    def makePhases(phases as IList<of Phase>) is override 
    5657        phases.add(GenerateSharpCodePhase(.compiler)) 
    5758        phases.add(CompileSharpCodePhase(.compiler)) 
    5859 
     60    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is override 
     61        n = nil to String? 
     62        if parentNameSpace and parentNameSpace.fullName == 'System' 
     63            branch name 
     64                on 'Boolean', n = 'bool' 
     65                on 'SByte',   n = 'int8' 
     66                on 'Byte',    n = 'uint8' 
     67                on 'Int16',   n = 'int16' 
     68                on 'UInt16',  n = 'uint16' 
     69                on 'Int32',   n = 'int32' 
     70                on 'UInt32',  n = 'uint32' 
     71                on 'Int64',   n = 'int64' 
     72                on 'UInt64',  n = 'uint64' 
     73                on 'Char',    n = 'char' 
     74                on 'Single',  n = 'float32' 
     75                on 'Double',  n = 'float' 
     76                on 'Decimal', n = 'decimal' 
     77        return n 
     78 
    5979    def computeOutName as String is override 
    6080        return .compiler.computeOutNameSharp 
    6181         
     
    119139        .compiler.clrReadAssembly(t.assembly) # System.dll 
    120140         
    121141    def fixNilableMemberSigs is override 
    122         .compiler.dotNetfixNilableMemberSigs # in ScanClrType 
     142        .compiler.dotNetFixNilableMemberSigs # in ScanClrType 
    123143         
    124144    # Types 
    125145    get objectTypeProxy from var  is override 
     
    160180    def installNativeMethods(box as Box, nativeType as NativeType) is override 
    161181        .compiler.installClrNativeMethods(box, nativeType) # in ScanClrType 
    162182         
    163     def addArrayInterfaces( interfaces as List<of ITypeProxy>) is override 
    164         iclone = .compiler.libraryType('ICloneable') 
    165         interfaces.insert(0, iclone to ITypeProxy) 
     183 
     184    def prepSystemObjectClass(box as Box) is override 
     185        box.prepSystemObjectClassClr 
     186         
     187    def scanGenericArgs(box as Box) is override 
     188        box.scanGenericArgsClr 
     189         
     190    def scanNativeType(box as Box) is override 
     191        """ Do scan/Load of Types from a dll """ 
     192        box.scanNativeTypeClr 
     193         
     194    def scanNativeType(edcl as EnumDecl) is override 
     195        edcl.scanNativeTypeClr 
     196         
     197    def setUnderlyingType(edcl as EnumDecl)  is override 
     198        edcl.setUnderlyingTypeClr 
    166199     
    167      
     200    def determineExtnNativeType(extn as Extension, nativeType as NativeType) as NativeType is override 
     201        return extn.clrExtnNativeType(nativeType)   # ScanClrType 
     202 
     203    def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace  is override 
     204        """Clr doesnt allow colliding names.""" 
     205        throw Exception('In [ns.name] there is a already non-namespace declaration named "[name]".') 
    168206         
     207         
     208         
    169209class GenerateSharpCodePhase inherits Phase 
    170210 
    171211    cue init(c as Compiler) 
  • Source/Types.cobra

     
    10951095            base.init(superType) 
    10961096            _size = size 
    10971097            branch size 
    1098                 on 32, _nativeType = .typeProvider.nativeType('single') 
    1099                 on 64, _nativeType = .typeProvider.nativeType('double') 
     1098                on 32, tag = 'single' 
     1099                on 64, tag = 'double' 
    11001100                else, throw FallThroughException(size) 
    1101             _systemAliasProxy = LibraryTypeProxy(_nativeType.fullName) 
     1101            _nativeType = .typeProvider.nativeType(tag) 
     1102            _systemAliasProxy = LibraryTypeProxy(tag) 
    11021103 
    11031104    def addMinFields 
    11041105        base.addMinFields 
     
    12021203            _size = size 
    12031204            if signed 
    12041205                branch size 
    1205                     on  8, _nativeType = .typeProvider.nativeType('sbyte') 
    1206                     on 16, _nativeType = .typeProvider.nativeType('int16') 
    1207                     on 32, _nativeType = .typeProvider.nativeType('int32') 
    1208                     on 64, _nativeType = .typeProvider.nativeType('int64') 
     1206                    on  8, tag = 'sbyte' 
     1207                    on 16, tag = 'int16' 
     1208                    on 32, tag = 'int32' 
     1209                    on 64, tag = 'int64' 
    12091210                    else, throw FallThroughException(size) 
    12101211            else 
    12111212                branch size 
    1212                     on  8, _nativeType = .typeProvider.nativeType('byte') 
    1213                     on 16, _nativeType = .typeProvider.nativeType('uint16') 
    1214                     on 32, _nativeType = .typeProvider.nativeType('uint32') 
    1215                     on 64, _nativeType = .typeProvider.nativeType('uint64') 
     1213                    on  8, tag = 'byte' 
     1214                    on 16, tag = 'uint16' 
     1215                    on 32, tag = 'uint32' 
     1216                    on 64, tag = 'uint64' 
    12161217                    else, throw FallThroughException(size) 
    1217             _systemAliasProxy = LibraryTypeProxy(_nativeType.fullName) 
     1218            _nativeType = .typeProvider.nativeType(tag) 
     1219            _systemAliasProxy = LibraryTypeProxy(tag) 
    12181220 
    12191221    def addMinFields 
    12201222        base.addMinFields 
     
    17311733            ienum = .compiler.enumerableOfType.constructedTypeFor([.theWrappedType]) 
    17321734            _ilistOf = .compiler.ilistOfType.constructedTypeFor([.theWrappedType]) to Interface 
    17331735            interfaces = [icoll to ITypeProxy, ienum]  # TODO:, _ilistOf]  -- problems with cobra -ert:yes hello and extension method String.split 
    1734             .compiler.backEnd.addArrayInterfaces(interfaces) 
     1736            iclone = .compiler.libraryType('ICloneable') 
     1737            interfaces.insert(0, iclone to ITypeProxy) 
    17351738            _box = Class(Token.empty, Token.empty, '[.getType.name]_[.serialNum]', List<of IType>(), List<of String>(), AttributeList(), nil, interfaces, List<of ITypeProxy>(), nil) 
    17361739            # TODO: make members based on System.Array 
    17371740            indexer = Indexer(Token.empty, Token.empty, _box, r'[]', [Param(Token('', 1, 1, 1, 'ID', 'index', nil), .compiler.intType)], _wrappedType, List<of String>(), AttributeList(), '') 
  • Source/BackEndJvm/JvmJarSig.cobra

     
    2525        var classByNameCache = Dictionary<of String, JavaClassType>() 
    2626            """All classes found in all jars keyed by canonical/full name.""" 
    2727                 
     28        def lookupClassByCobraName(fullCobraName as String) as JavaClassType 
     29            """ 
     30            This is the only way to access the JarSig classCache contents from outside this file. 
     31            """ 
     32            assert fullCobraName[0].isUpper 
     33            parts = fullCobraName.split('.') 
     34            for i in 0: parts.length-1 
     35                parts[i] = parts[i][0].toLower.toString + parts[i][1:] 
     36            fullName = parts.join('.') 
     37            #print 'Lookup "[fullCobraName]" as "[fullName]"' 
     38            return JarSig.classByNameCache[fullName] 
     39                 
    2840        def lookupClass(fullName as String) as JavaClassType 
    2941            """ Lookup class by full/canonicalName.""" 
    3042            if not JarSig.classByNameCache.containsKey(fullName) 
    31                 if fullName.startsWith(r'['),     .addArrayClass(fullName) 
    32                 else if fullName.contains(r'<'),  .addGenericInstClass(fullName) 
    33                 else if not fullName.contains('.'), .addGenericParamClass(fullName) 
     43                if fullName.startsWith(r'[')    # [a.b.c;  
     44                    .addArrayClass(fullName) 
     45                else if fullName.contains(r'<')  #  Generic a.b.c<a.b.c,..> or a.b.c<T> or a.b.c<?...> 
     46                    paramList = fullName.after('<') 
     47                    if _hasBoundParam(paramList),   .addGenericInstClass(fullName) # shld this be a genericDefn ? 
     48                    else if paramList.contains('.'), .addGenericInstClass(fullName) 
     49                    else, return .findAliasGenericDefnClass(fullName) 
     50                else if fullName.startsWith('?') or _hasBoundParam(fullName) or not fullName.contains('.') 
     51                    .addGenericParamClass(fullName)                  
    3452                else 
    35                     print 'Dbg:JarSig.lookupClass - unknown class:[fullName]' 
     53                    print 'Dbg:JarSig.lookupClass - unknown class:"[fullName]".' 
    3654            #print 'Lookup class', fullName 
    3755            return JarSig.classByNameCache[fullName] 
    3856                     
     57        # java bounded generic param '<? extends TYPE>' or '<? super TYPE>' 
     58        def _hasBoundParam(name as String) as bool 
     59            return name.contains(' extends ') or name.contains(' super ') or name.contains('?')          
     60         
    3961        def addArrayClass(aName as String) 
    4062            """Array classes are synthesized on reference assuming element class already exists.""" 
    41             print 'Dbg crt ArrayClass "[aName]"'     
     63            #print 'Dbg crt ArrayClass "[aName]"'    
    4264            elName = aName.replace(r'[','')  
    4365            branch elName 
    4466                on 'Z', elName = 'boolean' 
     
    6183            elType = JarSig.lookupClass(elName) 
    6284            arrayCls = JavaClassType(aName, elType) # ArrayType 
    6385            JarSig.classByNameCache[aName] = arrayCls 
    64             print 'Dbg: added ArrayOf_[elName] "[aName]"'    
     86            #print 'Dbg: added ArrayOf_[elName] "[aName]"'   
    6587         
    6688        def addGenericInstClass(fullName as String) 
    6789            """ 
     
    6991                e.g. com.x.MyClass<com.x.Inst, java.lang.String> 
    7092            Synthesized (here) as a result of being referenced. 
    7193            """ 
    72             print 'Dbg crt GenericInstClass "[fullName]"'  
     94            #print 'Dbg crt GenericInstClass "[fullName]"'  
    7395            assert fullName.contains('<') and fullName.endsWith('>') 
    74             canonName = fullName.beforeL('<') 
     96            canonName = fullName.before('<') 
    7597            assert canonName.contains('.') 
    7698            idx = canonName.lastIndexOf('.') 
    7799            gName = canonName[idx+1:] 
    78100            pkg = canonName[0:idx] 
    79             paramTypes = fullName.afterL('<')[0:-1] # drop end '>' 
    80             print 'Dbg: GenericInstanceClass "[pkg]" "[gName]" "[paramTypes]'    
     101            paramTypes = fullName.after('<')[0:-1] # drop end '>' 
     102            #print 'Dbg: GenericInstanceClass "[pkg]" "[gName]" "[paramTypes]'   
    81103            giCls = JavaClassType(gName, pkg, paramTypes) 
    82104            JarSig.classByNameCache[fullName] = giCls 
    83             # JarSig.registerClassType(pkg, giCls)   
    84             print 'Dbg: added GenericInstanceClass "[fullName]"'     
     105            #JarSig.registerClassType(fullName, giCls)   
     106            #print 'Dbg: added GenericInstanceClass "[fullName]"'    
    85107                 
     108        def findAliasGenericDefnClass(fullName as String) as JavaClassType 
     109            """ 
     110            Generic class being used as a param where declared with different param list 
     111            Generic class defn redeclared with a specific bound paramList 
     112                e.g. com.x.MyClass<? extends a.b.c>, com.x.MyClass<? super d.e> 
     113                     com.x.myClass<V>, vs dcl as com.x.myClass<TValue> 
     114            Synthesized (here) as a result of being referenced. 
     115            """ 
     116            assert fullName.contains('<') and fullName.endsWith('>') 
     117            canonName = fullName.before('<') 
     118            #params = fullName.after('<')[0:-1] # drop end '>' 
     119            #nParams = 1 + params.count(c',') # params.countOf(c',')   
     120            #assert canonName.contains('.') 
     121            #idx = canonName.lastIndexOf('.') 
     122            #gDefName = canonName[idx+1:] + '`[nParams]' 
     123            #pkg = canonName[0:idx] 
     124            #print 'Dbg: GenericDefnClass "[canonName]" "[params]"'      
     125            return JarSig.lookupClass(canonName) 
     126            # Shld already exist but prob with different paramNames in paramList 
     127            #gDefCls = JavaClassType(gDefName, pkg, params) 
     128            #JarSig.classByNameCache[fullName] = gDefCls 
     129            #JarSig._registerClassType(fullName, giCls)  
     130            #print 'Dbg: added GenericDefinitionClass "[fullName]"'      
     131 
    86132        def addGenericParamClass(name as String) 
    87             print 'Dbg crt Generic Param Class "[name]"'  
     133            #print 'Dbg crt Generic Param Class "[name]"'  
    88134            gparamCls = JavaClassType(name, JavaType.GenericParam, '') 
    89135            JarSig.classByNameCache[name] = gparamCls 
    90             print 'Dbg: added Generic Parameter Class "[name]"'      
     136            #print 'Dbg: added Generic Parameter Class "[name]"'     
    91137                 
    92138    def sigFile(name as String) as String is shared 
    93139        """  
     
    136182            _registerClassType(jct) 
    137183             
    138184    def _registerClassType(jct as JavaClassType) 
    139         _javaTypes.add(jct) 
    140185        canonName = jct.canonicalName 
    141186        if '`' in canonName # jct.isGeneric 
    142             canonName = canonName.beforeL('`') 
    143             #parts = canonName.split('`') 
    144             #canonName = parts[0]    
     187            canonName = canonName.before('`')   # canonName = canonName.split('`')[0] 
     188        _registerClassType(canonName, jct) 
     189     
     190    def _registerClassType(canonName as String, jct as JavaClassType) 
     191        _javaTypes.add(jct) 
    145192        JarSig.classByNameCache[canonName] = jct 
    146              
     193        #print 'Dbg: register [canonName]' 
     194         
    147195    def _aliasPrimitives 
    148196        if JarSig.classByNameCache.containsKey('void') 
    149197            return 
     
    155203        JarSig.classByNameCache['short']   = JarSig.classByNameCache['java.lang.Short']  
    156204        JarSig.classByNameCache['int']     = JarSig.classByNameCache['java.lang.Integer']  
    157205        JarSig.classByNameCache['long']    = JarSig.classByNameCache['java.lang.Long']  
     206        #l = JarSig.classByNameCache['java.lang.Long']  
     207        #l = l.copy('long','') 
     208        #JarSig.classByNameCache['long']    = l 
     209        #_javaTypes.add(l) 
    158210        JarSig.classByNameCache['float']   = JarSig.classByNameCache['java.lang.Float']  
    159211        JarSig.classByNameCache['double']  = JarSig.classByNameCache['java.lang.Double']  
    160212 
     
    196248     
    197249         
    198250    var name = '' 
    199     var package = '' 
     251    var package = '' # ->? FlyWeight this - save some string space? 
    200252    var type = JavaType.NoType #class,interface, enum 
    201253    var superclass = '' 
    202254    var modifiers as List<of String> 
    203255    var interfaceNames as List<of String> 
    204256    var _interfaces as List<of JavaClassType> = JavaClassType.emptyClassList 
     257    var _nestedTypes as List<of JavaClassType> = JavaClassType.emptyClassList 
    205258 
    206259    var _fields as List<of JavaFieldInfo> = JavaClassType._emptyFieldList   # JavaFieldInfo* 
    207260    var _props as List<of JavaFieldInfo>  = JavaClassType._emptyFieldList   # JavaFieldInfo* 
     
    262315 
    263316        # header - fixed length and format; absName, type, pkg, name, superclass, interfacesList, ModifiersList 
    264317        absName  = _popTop(lines)   # absolute class name 
    265         CobraCore.noOp(absName) 
     318        #CobraCore.noOp(absName) 
    266319        branch _popTop(lines).toLower 
    267320            on 'class',     type = JavaType.JavaClass 
    268321            on 'interface', type = JavaType.JavaInterface 
     
    273326        isGen = name.contains('`') 
    274327        super = _popTop(lines) 
    275328        if super == '-', super = '' 
    276         interfaces = _parseList(_popTop(lines), [c',']) 
     329        interfaces = _parseList(_popTop(lines)) 
    277330        modifiers  = _parseList(_popTop(lines), [c' ']) 
    278         if isGen, gParamNames = _parseList(_popTop(lines), [c',']) 
     331        if isGen, gParamNames = _parseList(_popTop(lines)) 
    279332        while true 
    280333            et = _popTop(lines) 
    281334            if et.length == 0, break 
     
    289342                # procField(et, subline, field, fieldList) 
    290343                field.modifiers = _parseList(_popTop(lines), [c' ']) 
    291344                field.typeName = _popTop(lines) 
    292                 if type == JavaType.JavaEnum  
     345                if type == JavaType.JavaEnum  and field.typeName == absName #'[pkg].[name]' 
    293346                    field.value = _popTop(lines)     
    294                 #field.attributes = _parseList(_popTop(lines), [c',']) 
     347                #field.attributes = _parseList(_popTop(lines)) 
    295348                fieldList.add(field) 
    296349 
    297350            else if et.startsWith('ctor ') 
     
    299352                ctor = JavaCtorInfo() 
    300353                ctor.name = ctorName 
    301354                assert lines.count >= 1      
    302                 ctor.paramNames = _parseList(_popTop(lines), [c',']) 
     355                ctor.paramNames = _parseList(_popTop(lines)) 
    303356                # attributes ?? 
    304357                ctorList.add(ctor) 
    305358                 
     
    313366                method.modifiers = _parseList(_popTop(lines), [c' ']) 
    314367                method.returnTypeName = _popTop(lines) 
    315368                assert method.returnTypeName <> '-' 
    316                 method.paramNames = _parseList(_popTop(lines), [c','])  
    317                 method.throwsList = _parseList(_popTop(lines), [c','])  
     369                method.paramNames = _parseList(_popTop(lines))  
     370                method.throwsList = _parseList(_popTop(lines))  
    318371                # attributes ?? 
    319372                if isVari,  method.attributes = ['IsVari'] 
    320373                methodList.add(method) 
     
    334387        jct._methods = methodList 
    335388        return jct 
    336389             
     390    def _parseList(et as String) as List<of String> is shared 
     391        return _parseList(et, [c',']) 
     392         
    337393    def _parseList(et as String, seps as List<of char> ) as List<of String> is shared 
    338         if et == '-' 
    339             l = List<of String>() 
    340         else 
    341             l = et.split(seps.toArray).toList    
     394        l = List<of String>() 
     395        if et == '-'  
     396            return l 
     397        if et.contains('<') 
     398            start = gCnt = 0 
     399            for i in 0 : et.length 
     400                c = et[i] 
     401                if c == c'<', gCnt += 1 
     402                if c == c'>', gCnt -= 1 
     403                if gCnt == 0 and c in seps  
     404                    l.add(et[start:i].trim) 
     405                    start = i+1 
     406            if start < et.length, l.add(et[start:].trim) 
     407        else     
     408            a = et.split(seps.toArray) 
     409            for s in a, l.add(s.trim) 
    342410        return l 
    343411     
    344412    def _popTop(content as List<of String>) as String is shared  
     
    373441             
    374442    # indexer: get<Propname> and has params  -  first param in paramList is index  (retType is Property Type) 
    375443    #     or  set<PropName> and more than value in paramList, 1st parameter is index and second is value to set. 
     444    # hops: this isnt goanna work - too many false positives 
     445    # may work to hard case Collections, Lists and special case Maps... recognise annotation for user written code 
    376446    def isIndexer(methodName as String, method as JavaMethodInfo, isSetProp) as bool is shared 
    377447        if methodName.startsWith('is') 
    378448            return false 
     
    392462            prop = JavaFieldInfo() # JavaPropInfo 
    393463            prop.name = propName 
    394464            prop.isProp = true 
    395             prop.isIndexer = .isIndexer(method.name, method, isSetProp) 
     465            #prop.isIndexer = .isIndexer(method.name, method, isSetProp) 
     466            prop.isIndexer = false  # TODO support indexers 
    396467            prop.isReadable = prop.isWritable = false 
    397468            props[propName] = prop 
    398469            propList.add(prop)   
     
    426497        .interfaceNames = ifcs 
    427498        .modifiers = modifiers 
    428499     
    429         _isGenericDefn = name.contains('`')  # Generic types have name suffix  `<nGenericArgs> 
     500        _isGenericDefn = name.contains('`')  # Defn Generic types have name suffix  `<nGenericArgs> 
    430501         
    431502        #print '[type] [pkg].[name]' 
    432503        assert .name.length 
     
    498569        assert .name.contains(r'[') 
    499570     
    500571    cue init(name as String, pkg as String, paramTypes as String) 
    501         """Create a Generic Instantiation Type. Like MyClass<java.Lang.String>""" 
     572        """ 
     573        Create a Generic Instantiation Type. Assumes Generic Defn Type already exists 
     574        Like MyClass<java.Lang.String> for MyClass<T>. 
     575        """ 
    502576        base.init 
    503         print 'JavaClassType.init([name])' 
     577        #print 'JavaClassType.init([name])' 
    504578        assert not name.contains('.') 
    505579        #assert pkg.contains('.') 
    506580        gPart = '[pkg].[name]' 
    507         paramList = JavaClassType._parseList(paramTypes, [c',']) 
    508         print 'Looking for Generic Class [gPart]' 
     581        paramList = JavaClassType._parseList(paramTypes) 
     582        #print 'Looking for Generic Class [gPart]' 
    509583        genType = JarSig.lookupClass(gPart) 
    510584        assert genType.isGenericTypeDefinition 
    511585 
     
    522596        _genParamNames= paramList 
    523597     
    524598        #print '[type] [pkg].[name]' 
     599        # print paramList 
    525600        assert .name.length 
    526601        assert .type <> JavaType.NoType 
    527602        assert '`' in .superclass # fake parentage to the Generic Definition 
    528603        assert .package.length 
     604        assert genType.genericArgsCount == _genParamNames.count 
    529605     
     606 
    530607    cue init(name as String, jType as JavaType, pkg as String) 
    531608        """Create a Generic Parameter Type. Like the T of MyClass<T>""" 
    532609        base.init 
    533610        assert jType == JavaType.GenericParam  
    534611        assert not name.contains("<") and not name.contains(">") 
    535         assert not name.contains(".") 
    536         #assert name[0].isUpper # ?? 
    537612         
    538613        .name = name 
    539614        .type      = jType 
     
    551626        assert .type <> JavaType.NoType 
    552627        assert 'Object' in .superclass  
    553628        assert .package.length 
    554          
     629     
     630    def copy( name as String, package as String) as JavaClassType 
     631        c = .memberwiseClone to JavaClassType 
     632        c.name = name 
     633        c.package = package 
     634        return c 
    555635 
    556636    #pro name from var  
    557637    #pro package from var 
     
    561641        """package and name""" 
    562642        assert .name.length 
    563643        return if(.package.length, '[.package].[.name]', .name) 
    564  
     644         
     645    get packageAsCobra as String 
     646        """ package name in Cobra Form - i.e each element Capitalized""" 
     647        # cache this map in a class var rather than recalc each time 
     648        parts = .package.split(c'.') 
     649        cobraParts = List<of String>() 
     650        for p in parts 
     651            cobraParts.add(p.capitalized) 
     652        return cobraParts.join('.') 
     653     
    565654    get isClass as bool 
    566655        return .type == JavaType.JavaClass 
    567656         
     
    575664        #return .flags.contains('N') 
    576665        return .name.contains('$')  and not .name.startsWith('$') # temporary hack 
    577666     
     667    def addNestedType(type as JavaClassType) 
     668        if _nestedTypes == JavaClassType.emptyClassList 
     669            _nestedTypes = List<of JavaClassType>() 
     670        _nestedTypes.add(type)   
     671             
     672    def getNestedTypes as JavaClassType* #List<of JavaClassType> 
     673        return _nestedTypes 
     674         
    578675    get declaringType as JavaClassType? 
    579676        if .isNested 
    580677            assert .name.contains('$') 
    581             declName = .name.beforeL('$') 
    582             #idx = .name.indexOf('$')  
    583             #declName = .name[:idx]  
    584             trace declName 
    585             # return JarSig.classByNameCache[declName] 
    586             return JarSig.lookupClass(declName) 
     678            lidx = .canonicalName.lastIndexOf('$') 
     679            declName = .canonicalName[:lidx] 
     680            #trace .canonicalName, declName 
     681            if  JarSig.classByNameCache.containsKey(declName) 
     682                return JarSig.lookupClass(declName) 
    587683        return nil 
    588684         
     685    get nestedName as String 
     686        require .isNested 
     687        assert .name.contains('$') 
     688        lidx = .canonicalName.lastIndexOf('$') 
     689        nestName = .canonicalName[lidx+1:] 
     690        #trace .canonicalName, declName 
     691        return nestName 
     692         
    589693    get isPublic 
    590694        return .modifiers.contains('public') 
    591695    get isProtected 
     
    607711        #return  JvmNativeType(_type.getSuperClass) 
    608712        if JarSig.classByNameCache.containsKey(.superclass) 
    609713            return JarSig.lookupClass(.superclass) 
    610             #return JarSig.classByNameCache[.superclass] 
    611714        else  
    612             #return JarSig.classByNameCache['java.lang.Object'] 
    613715            return JarSig.lookupClass('java.lang.Object') 
    614716            # e.g. Abstract base classes with default access - java.lang.AbstractStringBuilder   
    615717        #else  
     
    620722    get isValueType as bool 
    621723        return false    # TODO true for unboxed primitives... 
    622724 
    623     # TODO hops array handling 
    624725    get isArray as bool 
    625726        return _isArray  
    626727 
    627728    get arrayComponentType as JavaClassType? 
    628729        #if not .isArray, return nil 
    629730        assert .isArray 
    630         print 'JavaClassType Array support NYI [.canonicalName]' 
    631731        return _arrayComponentType 
    632732 
    633733    get arrayDimension as int 
     
    635735        assert _arrayDimension > 0 
    636736        return _arrayDimension 
    637737     
    638     # TODO hops Generics handling 
    639     # Two forms of Generic Types: Definition ( MyClass<T>) and Instantiation ( MyClass<java.lang.String>) 
     738    # Three forms of Generic Types: Definition ( MyClass<T>) and Instantiation ( MyClass<java.lang.String>) and Param ( T, java.lang.String) 
    640739    # In java with runtime generic Type instantiation all we see from the jarfile directly are definitions (:-( 
    641740    # Walking the classes and getting the class(names) referenced (params, intefaces, returnTypes,...) 
    642741    # gives us the names of the instantiations which we synthesize as Types or Params for our purposes... 
    643  
     742    # or at least thats the plan 
    644743    get isGenericType as bool 
    645         return _isGenericDefn or _isGenericInst or _isGenericParam 
     744        return _isGenericDefn or _isGenericInst #or _isGenericParam 
    646745         
    647746    get genericArgsCount as int 
    648747        assert .isGenericType 
     
    659758    get isGenericParameter as bool  
    660759        """ 
    661760        assumes generic parameters are instantiated as Types. 
    662         Things like T,U,E,.. - basically simple names not package specified - probably 1 Upcase char  
     761        Things like T,U,E,.. - basically simple names   
     762        or qualified name       java.lang.String 
     763        or bounded (possibly wildcard) type  - ? extends Type, T super Type , T extends Type 
    663764        """ 
    664765        return _isGenericParam 
    665766     
    666767    get isGenericTypeDefinition as bool 
    667768        """  
    668         Can use this generic type to create new types if this type is a template form. 
     769        Can use this generic type to create new types if this type is a template/Defn form. 
    669770        e.g myClass<T, U> defn allows creating new type like MyClass<String, int> 
     771        myClass<T, U> is a generic definition 
     772        new type like MyClass<String, int> is a generic instance 
     773        T,U and String, int  are their respective generic params 
    670774        """ 
    671775        assert  .isGenericType 
    672776        return _isGenericDefn 
    673777             
    674778    def getGenericArguments as JavaClassType* #List<of JavaClassType> 
    675779        assert .genericArgsCount 
    676         if false # tmp pending jarSig gen and loading of generic args list 
    677             assert _genParamNames.count 
     780        assert _genParamNames.count 
    678781        if _genParamNames.count and not _genParams.count  
    679782            _genParams = JavaClassType.genClassTypeList(_genParamNames)  
    680783        return _genParams 
     
    753856            print prop 
    754857         
    755858    def dumpIndexers 
    756         assert false, 'Indexers NYI' 
     859        assert false, 'dump Indexers NYI' 
    757860     
    758861class JavaMemberInfo 
    759862    var name = ''    
     
    817920    get type as JavaClassType 
    818921        assert .typeName.length 
    819922        if .typeName.length and not _type 
    820             #_type = JarSig.classByNameCache[.typeName] 
    821923            _type = JarSig.lookupClass(.typeName) 
    822924        return _type to !    
    823925 
     
    892994    def returnType as JavaClassType? 
    893995        if not .returnTypeName.length 
    894996            return nil 
    895         #return JarSig.classByNameCache[.returnTypeName] 
    896997        return JarSig.lookupClass(.returnTypeName) 
    897998 
    898999    def getGenericArguments as List<of JavaClassType> 
    899         return JavaClassType.emptyClassList # TODO: support generics 
     1000        #print 'TODO getGenArgs on method [.name]' 
     1001        return JavaClassType.emptyClassList # TODO: support generics on Method 
    9001002                 
    9011003    def toString as String is override 
    9021004        nampar = base.toString 
  • Source/BackEndJvm/JvmType.cobra

     
    55 
    66class JvmNativeType inherits NativeType 
    77 
    8     var _type as JavaClassType 
    9     #var _type as java.lang.Class 
     8    var _type as JavaClassType # java.lang.Class eventually 
     9    var nestedName as String? 
    1010     
    11     #cue init(type as java.lang.Class) 
    1211    cue init(type as JavaClassType) 
    1312        base.init 
    1413        _type = type 
     
    2827        return _type 
    2928 
    3029    get name as String is override 
    31         #return _type.getSimpleName 
    32         return _type.name 
     30        return .nestedName ? _type.name 
    3331 
    3432    get fullName as String is override 
    3533        return _type.canonicalName 
     
    146144            return .typeProvider.arrayType(_realTypeWithCache(jvmType.arrayComponentType to !)) 
    147145        else if jvmType.isNested and not jvmType.isGenericParameter 
    148146            declaringType = _realTypeWithCache(jvmType.declaringType to !) 
    149             potential = declaringType.memberForName(jvmType.name) 
     147            cobraTypeName = .cobraNameForJvmBoxName(jvmType.nestedName) 
     148            potential = declaringType.memberForName(cobraTypeName)   #(jvmType.name) 
    150149            if potential is nil 
    151                 .throwError('Cannot locate nested Jvm type "[jvmType]" (simple name is "[jvmType.name]").') 
     150                (declaringType to dynamic).dumpDeclNames 
     151                .throwError('JvmType: Cannot locate nested Jvm type "[jvmType]" (simple name is "[jvmType.name], cobraName is [cobraTypeName]").') 
    152152            else if potential inherits IType 
    153153                return potential 
    154154            else 
    155                 .throwError('Located Jvm type spec "[jvmType]" but got a [potential.englishName] instead of a type.') 
     155                .throwError('JvmType:Located Jvm type spec "[jvmType]" but got a [potential.englishName] instead of a type.') 
    156156 
    157157        # generic parameters 
    158158        if jvmType.isGenericParameter 
     
    162162        missing = false 
    163163        curNS = _computeNameSpace(jvmType, level, out missing) 
    164164        if missing 
    165             .throwError('Cannot find Jvm type "[jvmType.canonicalName]"  in package "[jvmType.package]".') 
     165            .throwError('JvmType: Cannot find Jvm type "[jvmType.canonicalName]"  in package "[jvmType.package]".') 
    166166            # since the type exists, but cannot be located in our namespaces, 
    167167            # it must be pulled from a dependent DLL that was not directly referenced 
    168168            # but maybe it was already attempted 
     
    179179                    # So we have something like ICollection<of KeyValuePair<of TKey,TValue>> which is all Generic types. 
    180180                    # We need the Cobra types of those args so we can construct the Cobra type from the generic cobra type 
    181181                    # otherwise, we would just end up returning the generic definition. 
    182                     print 'Dbg: JvmType.realTypeWithoutCache generic type [jvmType.canonicalName] [member.name].' 
    183                     #.throwError('TODO support for Generic Types in JvmType _realTypeWithoutCache') 
    184                     #member = _typeForArgsOfGeneric(jvmType, member) 
     182                    #print 'Dbg: JvmType.realTypeWithoutCache generic type [jvmType.canonicalName] [member.name].' 
     183                    member = _typeForJvmArgsOfGeneric(jvmType, member) 
    185184            return member 
    186185        else 
    187186            print '[typeName] not in [curNS.name] declsforName' 
    188             msg = 'Cannot locate jvm type "[jvmType]".' 
     187            #curNS.dumpDeclNames 
     188            msg = 'JvmType: Cannot locate jvm type "[jvmType]".' 
    189189            if jvmType.package.length and jvmType.package.startsWith('java.lang') 
    190190                if .compiler and .compiler.verbosity > 1, print msg 
    191191                # TODO: .compiler.warning(msg) 
     
    219219            assert r'[' not in typeName 
    220220            typeName = .cobraNameForJvmType(jvmType) 
    221221        else if not typeName[typeName.length-1].isLetterOrDigit 
    222             .throwError('Cannot locate JVM type "[jvmType.canonicalName]".') 
     222            .throwError('JvmType: Cannot locate JVM type "[jvmType.canonicalName]".') 
    223223        return typeName 
    224224 
    225225    def _computeNameSpace(jvmType as JavaClassType, level as int, missing as out bool) as NameSpace 
    226226        missing = false 
    227227        if not jvmType.package.length, return .compiler.globalNS 
    228         nameParts = jvmType.package.split(c'.') 
     228        nameParts = jvmType.packageAsCobra.split(c'.') 
    229229        member = .compiler.globalNS.symbolForName(nameParts[0]) 
    230230        if member inherits NameSpace, curNS = member 
    231231        else, missing = true 
     
    240240                else if possible inherits NameSpace 
    241241                    curNS = possible 
    242242                else 
    243                     .throwError('Found "[namePart]" at component [i+1] of JVM type "[jvmType.canonicalName]", but it is a [possible.englishName].') 
     243                    .throwError('JvmType: Found "[namePart]" at component [i+1] of JVM type "[jvmType.canonicalName]", but it is a [possible.englishName].') 
    244244                i += 1 
    245245        return curNS     
    246246 
     
    257257            member = boxMember.constructedTypeFor(args) 
    258258        return member    
    259259#/ 
    260     def _typeForArgsOfGeneric(jvmType as JavaClassType, member as IType) as IType 
     260    def _typeForJvmArgsOfGeneric(jvmType as JavaClassType, member as IType) as IType 
    261261        args = List<of IType>() 
    262262        for genArg in jvmType.getGenericArguments 
    263263            args.add(_realTypeWithCache(genArg)) 
    264264        boxMember = member to Box 
     265        #trace jvmType, boxMember, args 
    265266        member = boxMember.constructedTypeFor(args) 
    266267        return member    
    267268         
  • Source/BackEndJvm/to-do.text

     
    33include-tests:no - remove Test invocation call 
    44 
    55 
     6_fixNativeMethods - static method entries on box instance 
     7 
     8 
    69fixup Object namespace for X-compile so items like System.Object are rooted off 
    710java.lang namespace ( rather than .Net system) 
    811    DONE  June-2011 
     
    1922cobra namespaces capitalized (as .Net) Java all lowercase 
    2023    - convert namespaces in java code to lowcase 
    2124    DONE 31-Jan-2011 
     25    Unworkable  Jul-2011 - cobra assumptions in code 
     26    Change to cobra casing  8-Jul-2011 
    2227     
    2328 
    2429java names lowcase  
    2530    method Names  - DONE 31-Jan-2011 
    2631    var names - DONE 31-Jan-2011, corrected 10-Feb-2011 BoxField._backendName -> BoxField.{sharp,java}BackEndName 
     32    properties 
    2733    params 
    2834    events 
    2935    local variables 
     
    4248            <indexedT> getIndexer<T, indexedT>(T) and  
    4349                       setIndexer<T, indexedT>(T, indexedT) 
    4450      DONE  
    45                         
     51        
     52     codegen for props: 'propName' -> getPropName  and setPropName 
     53 
     54    AutoMap map indexers '[]' to methods X.get(idx) v = X[idx] , X.set(idx,val) and X.put(idx,val) -> X[idx] = val 
     55        - unworkable - too many false positives 
     56             
     57Handling of indexing '[]' on Maps and Lists 
     58                x[i]=v :  map: x.put(i,v)     list: x.set(i,v)  
     59                v = x[i]: map: v = map.get(i) list: v = list.get(i) 
    4660Events 
    4761    - auto add boiler plate for listener (de)registration 
    4862        - event firing 
     
    6377to the generating cobra code line. 
    6478  - start with just spew the javac lines to output 
    6579    - assemble into ErrorMessage Line and 'supporting lines associated with it - keeps error line count in sync 
    66      
     80    DONE 
    6781 
    6882 
    6983single file: 
     
    7892    Leave jar file at root of hierarchy 
    7993     
    8094 
    81 ensure support ( as builtin alternative) for jikes compiler. 
    82         https://sourceforge.net/projects/jikes/files/Jikes/     
    83  
    84  
    8595add synonym for sharp''/sharp"" -> java''/java"" 
    86     or general be''/be"" (for backend) 
     96    or general be''/be""/backend'' (for backend) 
    8797 
    8898 
    8999see http://www.25hoursaday.com/CsharpVsJava.html 
     
    95105    In Java, the same effect is achieved by appending the string "..." to the typename of the last argument to the method. 
    96106     
    97107Attributes 
    98     C# extend Atttribute - metainfo also ([AttributeUsage(AttributeTargets.Class)]) 
     108    C# extend Attribute - metainfo also ([AttributeUsage(AttributeTargets.Class)]) 
    99109    java specify with @interface and Metainfo  
    100110        e.g @Documented //we want the annotation to show up in the Javadocs  
    101111            @Retention(RetentionPolicy.RUNTIME)) 
     
    116126        x = xRef 
    117127        // use x here 
    118128 
     129    Or 
     130        in call wrap arg in a SoftRef (or make own version HardRef subclass j.l.ref.Reference) 
     131        Chg param to be a SoftRef to the arg passed (e.g. 'arg_Ref') 
     132        In the method pull it out from the softref as a local name ('arg') 
     133     
    119134 
    120 Cobra backend targetting stab language (explicitly) ?? 
    121     backend 'stab-jvm' 
     135Add new compiler directive 
     136 @platform portable|jvm|clr|objc 
     137  
     138 Where down the road, portable would be the default and would have its 
     139 own libs (which would need impls for each of the other supported 
     140 platforms). For now the default will be clr, obviously. 
     141  
     142 And then possibly rename -back-end to -platform. 
    122143 
    123  
    124144Decimal Type 
    125145    Initially wrap it as new type thats is a Double with an associated DecimalFormatter 
    126146    (giving same precision as .Net). 
    127147    Calcs are all as doubles, toString uses formatter... 
    128148     still get rounding error etc... 
    129149     Decimal Type internally and emit as BigDecimal, trap math ops and map 
     150    -> try and use BigDecimal and convert all calls (:-( 
    130151 
    131152    Maybe easier to just default to Integer and ignore Decimal (initially) 
    132153 
     
    150171        static String[] readAllLines(String path) 
    151172        static IEnumerable<of String> readLines(String path) 
    152173 
     174    Instead use google collections/Guava 
     175        - support for List, Set and Map literals 
     176        - Simple file reading API 
    153177 
     178ensure support ( as builtin alternative) for jikes compiler. 
     179        https://sourceforge.net/projects/jikes/files/Jikes/     
     180 
     181Cobra backend targetting stab language (explicitly) ?? 
     182    backend 'stab-jvm' 
     183 
     184 
     185----------------------------------------------------------------- 
     186 
     187= Decisions = 
     188 
     189Look for and use java and javax in path. 
     190    - verify version >= 1.6 
     191     
     192Loading external jars 
     193    Rely on jar or Package PkgSig files for description of Class publicly accessible contents 
     194        Structure so can revisit later (IKVM) if need be  
     195    PkgSig tool for generating pkgSig files 
     196   
     197    start: explicitly load rtl jar up front (rt.jar.sig cf mscorlib.dll)  
     198        - but vv big, contents mostly unused 
     199    ->  chg to load packages separately (separate pkgsig files) 
     200            initial default 
     201                java.lang 
     202                java.io 
     203                java.util 
     204                java.text 
     205                cobra.lang       
     206        smaller + faster ?? 
     207  
     208Java Source 
     209   Turn Cobra source file into Java Source file named per first class in file. 
     210        - possible issues with multiple public classes ( javac warn-and-quit) 
     211   -> Cobra Source file into Java Source files one for each class 
     212        -> place all generated java source in own (sub) dir ( ./java) 
     213 
     214Running Generated/compiled classfiles 
     215    Assume compiled classfiles in same cwd as cobra source,  
     216        - run java specifying -cp . so java can find rest of classfiles (if >1) 
     217             ( java -cp '.;<otherRefs...>' AppMainClass args....)     
     218    -> roll all generated source into own jar file ( cf .Net exe) with autogen manifest describing main class 
     219        - run with classpath specifying name of jarfile 
     220             ( java -cp '<otherRefs...>' -jar App.jar args....)     
     221        
     222 
     223Namespaces: 
     224    0: namespaces low cased in cobra-jvm as per java. 
     225        Unworkable with Cobra assumptions  
     226    Change to CapCase as per cobra-clr 
     227        translate case on jar load (in) and JavaGeneration (out) 
     228 
     229Testing 
     230    Implement Test support i/fstructure 
     231    Add new 'require' forms so can wire tests clr or jvm 
     232     
     233Passthrough to BackEnd 
     234    ensure java Native modules compile 
     235    -> support determination of main class/method on pure java modules 
     236 
     237    Syntax - support sharp'' as currently 
     238    add additional: 
     239         be'' or backEnd'' for any others/more, deprecate sharp'' 
     240 
     241Indexes '[]' 
     242    0:autodetect from method sig 
     243        - Unworkable, too many false positives 
     244    -> Wire Maps/Lists/... - is that sufficient? 
     245         
     246    -> For default packages generate fm internal description as per fixNilable 
     247        may need to expose this data structure for augmentation? 
     248            - allow faked/added attrib placed in pkgsig file. 
     249 
     250 
     251Vari params 
     252    Use java vari args 
     253 
     254In and Inout parameters 
     255    Inline wrap and post call unwrap - Invent java RefType class 
     256    Use java SoftRef as Param, pack and unpack in call/callee 
     257         
     258Decimal support 
     259    0: Treat default as Integer, map explicit decimal to float 
     260     
     261 
     262Delegates  
     263 
     264Events 
     265    wot to do 
     266 
     267 
     268Exception Adaption 
     269    ? See if can get any clever hack working as detailed below 
     270    ? JavaGenerater auto wrap with try/catch exception block at place of use 
     271        probably unworkable for deeply embedded expressions 
     272    ->? make call to individual adaptor that does wrapping,  
     273        autogenerate the adaptor on demand 
     274        ( see if can cobble a genera adaptor that does wrapping and pass ref 
     275            to method and args to it ... Dynamic Delegate??) 
     276 
     277------------------------------------------------------------------------- 
     278 
    154279= Issues = 
    155280 
     281 
     282RTL name mangling 
     283 
     284 
    156285How support yield and conversion to enumerator/iterator? 
    157286------------------------------------------------------------------------- 
    158287 
  • Source/BackEndJvm/ScanJvmType.cobra

     
    22 
    33class Compiler is partial 
    44 
    5     #var _didLoadJars = Set<of String>() 
    6  
    75    var _didReadJars = Set<of String>() 
    86     
    9     var _jvmTypeToType = Dictionary<of JavaClassType, IType>() 
     7    var _jvmTypeToIType = Dictionary<of JavaClassType, IType>() 
    108     
    119    var _jvmTypeCache = Dictionary<of String, JavaClassType>() 
    1210     
     
    111109        namespaceQualNameToNameSpaceObject = Dictionary<of String, NameSpace>() 
    112110        module = AssemblyModule(jSig.location, .globalNS) 
    113111        saveModule, _curModule = _curModule, module 
     112        nestedTypes = List<of JavaClassType>() 
    114113        try 
    115114            _modules.add(module) 
    116             for type in jSig.getExportedTypes 
    117                 if type.isNested #or type.declaringType 
    118                     # these will be scanned by Box._scanNestedTypes 
    119                     # print '### skipping [type.name] in [type.namespace]. isNested=[type.isNested], declaringType=[type.declaringType]' 
     115            for jvmType in jSig.getExportedTypes 
     116                if jvmType.isNested #or jvmType.declaringType 
     117                    nestedTypes.add(jvmType) 
    120118                    continue 
    121                 typeNamespace = type.package 
     119                typeNamespace = jvmType.packageAsCobra  #Capitalized 
    122120                if typeNamespace.length == 0 
    123121                    # happens for classes etc. that are not declared in a namespace 
    124122                    curNameSpace = module.topNameSpace 
     
    133131                            assert not curNameSpace.isUnified 
    134132                        namespaceQualNameToNameSpaceObject[namespaceName] = curNameSpace 
    135133                if verbosity >= 4 
    136                     print '  Reading type [type.name] in namespace "[namespaceName]"' 
    137                 jvmType = JvmNativeType(type) 
    138                 if curNameSpace.unifiedNameSpace.declForName(jvmType.name) 
    139                     .warning(CobraWarning('Already have declaration "[jvmType.name]" in namespace "[curNameSpace.fullName]".')) 
     134                    print '  Reading type [jvmType.name] in namespace "[namespaceName]"' 
     135                jvmNative = JvmNativeType(jvmType) 
     136                if curNameSpace.unifiedNameSpace.declForName(jvmNative.name) 
     137                    .warning(CobraWarning('Already have declaration "[jvmNative.name]" in namespace "[curNameSpace.fullName]".')) 
    140138                else 
    141                     if type.isClass 
    142                         if type.name.startsWith('Extend_') and type.name.count(c'_') >= 2 
     139                    if jvmType.isClass 
     140                        if jvmType.name.startsWith('Extend_') and jvmType.name.count(c'_') >= 2 
    143141                            # e.g.Extend_String - TODO  
    144                             curNameSpace.addDecl(Extension(jvmType, .backEnd)) 
     142                            curNameSpace.addDecl(Extension(jvmNative, .backEnd)) 
    145143                        else 
    146                             curNameSpace.addDecl(Class(jvmType, .backEnd)) 
    147                     else if type.isInterface 
    148                         curNameSpace.addDecl(Interface(jvmType, .backEnd)) 
    149                     else if type.isEnum 
    150                         #print jvmType.name 
    151                         curNameSpace.addDecl(EnumDecl(curNameSpace, jvmType, type.modifiers, ''))  # TODO: isNames; docString? 
    152                     else if type.isValueType 
    153                         curNameSpace.addDecl(Struct(jvmType, .backEnd)) 
     144                            curNameSpace.addDecl(Class(jvmNative, .backEnd)) 
     145                    else if jvmType.isInterface 
     146                        curNameSpace.addDecl(Interface(jvmNative, .backEnd)) 
     147                    else if jvmType.isEnum 
     148                        curNameSpace.addDecl(EnumDecl(curNameSpace, jvmNative, jvmType.modifiers, ''))  # TODO: isNames; docString? 
     149                    else if jvmType.isValueType 
     150                        curNameSpace.addDecl(Struct(jvmNative, .backEnd)) 
    154151                    else 
    155                         throw FallThroughException(type) 
     152                        throw FallThroughException(jvmType) 
    156153        finally 
     154            if nestedTypes.count 
     155                _setNestedTypes(nestedTypes)# store nestedTypes in parenting type. 
    157156            _curModule = saveModule 
    158  
     157             
     158    def _setNestedTypes(nestedTypes as List<of JavaClassType>) 
     159        for nt in nestedTypes 
     160            enclType =  nt.declaringType 
     161            if enclType  
     162                # Hack below suppressing adding nested classes in java.lang Character. (or any Primitive) 
     163                # boxes.baseBind on primitives with nested classes dies due call fm bindh 
     164                # and memberName lookup needs .didBindInt - doesnt happen in CLR. (FIXME) 
     165                if enclType.canonicalName <> 'java.lang.Character'  
     166                    enclType.addNestedType(nt) 
     167                    #if enclType.isInterface, print 'EnclINTERFACE [enclType.canonicalName] [nt.name]' 
     168            else 
     169                if .verbosity >= 3, print 'NO class found for enclosing class of nested class [nt.canonicalName]' 
     170                # just ignore/drop any nested class cant find parent for 
     171                     
     172                         
    159173    def jvmFixNilableMemberSigs 
     174        # fix the listed members below to be non Nilable 
     175        # called from bindInterface phase so this can only refer to top level Classes in a package. 
    160176        # TODO: this really needs to go in a separate file that the compiler reads each time 
    161177 
    162178        # fix up member sigs regarding methods returning nilable values 
    163179        # hard coded below. TODO: read from a Cobra config file 
    164180        # _fix is defined in ScanClrType 
    165181     
    166         # These are just reflected over from the .Net ones since I dont know what the basis for inclusion is/was 
     182        # Included by comparison from .Net ones and examination of javaDoc - INCOMPLETE 
    167183         
    168         _fix('java.lang.Object', 'toString getClass clone') 
     184        _fix('Java.Lang.Object', 'toString getClass clone') 
    169185            # ^ regarding .toString, not technically true, but common enough and life is too painful when the return type is nilable 
    170186        #_fix('java.lang.System', 'out') #stdout 
    171         _fix('java.lang.String', 'padLeft padRight remove replace substring toLower toUpper trim') 
     187        _fix('Java.Lang.String', 'concat remove replace replaceAll replaceFirst substring toLowerCase toUpperCase trim format') 
    172188        #_fix('System.Type', 'assembly name toString') 
    173189            # namespace can return nil if the Type is a generic parameter 
    174190        #_fix('System.Environment', 'commandLine currentDirectory newLine version') 
    175         _fix('java.lang.Exception', 'message') 
     191        _fix('Java.Lang.Exception', 'message') 
     192        #_fix('java.util.Enumeration<of>', r'getNext') 
     193        _fix('Java.Lang.Iterable<of>', r'iterator') 
     194        _fix('Java.Util.Iterator<of>', r'next') 
     195        _fix('Java.Util.ListIterator<of>', r'next previous') 
     196        _fix('Java.Util.Collection<of>', r'toArray') 
    176197        #_fix('System.Collections.Generic.IEnumerable<of>', r'getEnumerator') 
    177         #_fix('java.util.Enumeration<of>', r'getNext') 
    178         _fix('java.util.Iterator<of>', r'next') 
    179         _fix('java.util.ListIterator<of>', r'next previous') 
    180         _fix('java.util.Collection<of>', r'toArray') 
    181          
     198     
     199        # work out what doing with indexor and apply to [] 
    182200        #_fix('System.Collections.Generic.List<of>', r'[]') 
    183         _fix('java.util.List<of>', r'[] get set remove') 
    184         _fix('java.util.AbstractList<of>', r'[] get set remove') 
    185         _fix('java.util.AbstractSequentialList<of>', r'[] get set remove') 
    186         _fix('java.util.ArrayList<of>', r'[] get set remove') 
    187         #_fix('java.util.CopyOnWriteArrayList<of>', r'[] get set remove') 
    188         #_fix('java.util.LinkedList<of>', r'[] get set remove element getFirst getLast peek peekFirst peekLast poll pollFirst pollLast pop removeFirst removeLast') 
    189         #_fix('java.util.Vector<of>', r'[] get set elementAt firstElement lastElement remove') 
    190         #_fix('java.util.Stack<of>', r'[] peek pop push') 
     201        _fix('Java.Util.List<of>', r'[] get set remove') 
     202        _fix('Java.Util.AbstractList<of>', r'[] get set remove') 
     203        _fix('Java.Util.AbstractSequentialList<of>', r'[] get set remove') 
     204        _fix('Java.Util.ArrayList<of>', r'[] get set remove') 
     205        #_fix('Java.Util.CopyOnWriteArrayList<of>', r'[] get set remove') 
     206        #_fix('Java.Util.LinkedList<of>', r'[] get set remove element getFirst getLast peek peekFirst peekLast poll pollFirst pollLast pop removeFirst removeLast') 
     207        #_fix('Java.Util.Vector<of>', r'[] get set elementAt firstElement lastElement remove') 
     208        #_fix('Java.Util.Stack<of>', r'[] peek pop push') 
    191209         
    192210        #_fix('System.Collections.Generic.IDictionary<of,>', r'[] keys values') 
    193         _fix('java.util.Map<of,>', r'[] get') 
     211        _fix('Java.Util.Map<of,>', r'[] get') 
    194212        #    _fix('System.Collections.Generic.Dictionary<of,>', r'[]') 
    195         _fix('java.util.AbstractMap<of,>', r'[] get') 
    196         _fix('java.util.HashMap<of,>', r'[] get') 
    197         #_fix('java.util.ConcurrentHashMap<of,>', r'[] get') 
    198         #_fix('java.util.ConcurrentSkipListHashMap<of,>', r'[] get') 
    199         #_fix('java.util.EnumMap<of,>', r'[] get') 
    200         #_fix('java.util.IdentityHash<of,>', r'[] get') 
    201         #_fix('java.util.TreeMap<of,>', r'[] get') 
    202         #_fix('java.util.WeakHashMap<of,>', r'[] get') 
    203         _fix('java.util.Map.Entry<of,>', r'getKey getValue') 
    204         #_fix('java.util.AbstractMap.SimpleEntry<of,>', r'getKey getValue') 
    205         #_fix('java.util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue') 
     213        _fix('Java.Util.AbstractMap<of,>', r'[] get') 
     214        _fix('Java.Util.HashMap<of,>', r'[] get') 
     215        #_fix('Java.Util.ConcurrentHashMap<of,>', r'[] get') 
     216        #_fix('Java.Util.ConcurrentSkipListHashMap<of,>', r'[] get') 
     217        #_fix('Java.Util.EnumMap<of,>', r'[] get') 
     218        #_fix('Java.Util.IdentityHash<of,>', r'[] get') 
     219        #_fix('Java.Util.TreeMap<of,>', r'[] get') 
     220        #_fix('Java.Util.WeakHashMap<of,>', r'[] get') 
     221        _fix('Java.Util.Map.Entry<of,>', r'getKey getValue') 
     222        #_fix('Java.Util.AbstractMap.SimpleEntry<of,>', r'getKey getValue') 
     223        #_fix('Java.Util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue') 
     224        #_fix('Java.Util.Properties', r'getProperty') 
    206225         
    207226        #_fix('System.IO.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText') 
    208         #_fix('java.io.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText') 
     227        _fix('Java.Io.File', 'create createText open openRead openText openWrite readAllBytes readAllLines readAllText getPath getAbsolutePath') 
     228        ##_fixFields('Java.Io.File', 'pathSeparator separator pathSeparatorChar seperatorChar') # TODO 
    209229        #_fix('System.IO.FileSystemInfo', 'name fullName') 
    210230        #_fix('System.IO.TextWriter', 'newLine') 
    211231        #_fix('System.IO.Path', 'combine getFullPath') 
    212232        #   combine = File(strA, strB).getPath(), getFullPath = File().getAbsolutePath() 
    213233        #_fix('java.lang.StringBuilder', 'toString') # ?? 
    214         _fix('java.lang.Text.RegularExpressions.Regex', 'match replace') 
    215         _fix('System.Diagnostics.Process', 'processName') 
     234        #_fix('java.lang.Text.RegularExpressions.Regex', 'match replace') 
     235        #_fix('System.Diagnostics.Process', 'processName') 
     236        _fix('java.util.regex.Pattern', 'matches matcher pattern split compile') 
     237        _fix('java.util.regex.Matcher', 'group pattern replaceAll replaceFirst') 
     238        _fix('java.lang.ProcessBuilder', 'command start directory') 
     239        #_fix('java.lang.Process', 'getInputStream getOutputStream getErrorStream') 
    216240         
    217         _fix('System.Reflection.Assembly', 'getEntryAssembly getExecutingAssembly location') 
    218         _fix('System.Reflection.MemberInfo', 'name') 
    219         _fix('System.Reflection.FieldInfo', 'fieldType') 
    220         _fix('System.Reflection.ParameterInfo', 'parameterType') 
    221         _fix('System.Reflection.PropertyInfo', 'propertyType') 
     241        #_fix('System.Reflection.Assembly', 'getEntryAssembly getExecutingAssembly location') 
     242        #_fix('System.Reflection.MemberInfo', 'name') 
     243        #_fix('System.Reflection.FieldInfo', 'fieldType') 
     244        #_fix('System.Reflection.ParameterInfo', 'parameterType') 
     245        #_fix('System.Reflection.PropertyInfo', 'propertyType') 
    222246 
    223         # TODO: shouldn't need the following. see comment in _fixSubs 
    224         #_fix('System.IO.StringWriter', 'toString') 
    225  
    226      
    227247         
    228248    # 
    229249    # Jvm Type Cache 
     
    233253        Returns the Cobra type for a Java type if the Java type was previously scanned. 
    234254        i.e this is access to the Java Type/Class cache. 
    235255        """ 
    236         return if(_jvmTypeToType.containsKey(jvmType), _jvmTypeToType[jvmType], nil) 
     256        return if(_jvmTypeToIType.containsKey(jvmType), _jvmTypeToIType[jvmType], nil) 
    237257 
    238258    def addTypeForJvmType(type as IType, jvmType as JavaClassType) 
    239259        require .typeForJvmType(jvmType) in [nil, type] 
    240         _jvmTypeToType[jvmType] = type 
     260        _jvmTypeToIType[jvmType] = type 
    241261         
    242262    def jvmTypeByName(qualifiedName as String) as JavaClassType 
    243263        """ 
    244         Obtain the Jvm Type given by the fully qualified (cobra) name. 
     264        Obtain the Jvm Type (JavaClassType) given by the fully qualified (cobra) name. 
    245265        """ 
    246266        t as JavaClassType? 
    247267        _jvmTypeCache.tryGetValue(qualifiedName, out t) 
    248268        if t is nil 
    249             # TODO - lookup the JavaClassType by name. 
    250             t = JarSig.classByNameCache[qualifiedName] 
     269            # lookup the JavaClassType by name. 
     270            t = JarSig.lookupClassByCobraName(qualifiedName) 
    251271            _jvmTypeCache[qualifiedName] = t to passthrough  # "to passthrough" instead of "to !" to avoid non-nil check 
    252272        return t to passthrough 
    253273     
    254274     
    255275    def installJvmNativeMethods(box as Box, nativeType as NativeType)  
    256         print '++ TODO scanJvmType.installJvmNativeMethods' 
     276        """Install entries for native static methods on box instances.""" 
     277        pass 
     278        #print '++ TODO scanJvmType.installJvmNativeMethods' 
    257279/# 
    258280        meths = List<of Method>() 
    259281        _installClrNativeMethodsFrom('System', nativeType, nativeType, box, meths) 
     
    297319        return (.nativeType to JvmNativeType).backEndType 
    298320 
    299321    def isJvmSystemExceptionClass as bool 
    300         return .name == 'Exception' and .parentNameSpace and .parentNameSpace.fullName == 'java.lang' 
     322        return .name == 'Exception' and .parentNameSpace and .parentNameSpace.fullName == 'Java.Lang' 
    301323 
    302     def _scanNativeTypeJvm 
     324    def prepSystemObjectClassJvm 
     325        # TODO chk thats this has desired result. 
     326        # map method getType to java getClass 
     327        # C#'s typeof(X) is X.getType in Cobra. 
     328        #existing = .declForName('getClass') to BoxMember 
     329        #overload = MemberOverload(existing) 
     330        #.registerOverload(overload) 
     331        meth = Method(TokenFix.empty, TokenFix.empty, this, 'getType', List<of Param>(), .compiler.typeTypeProxy, nil, ['shared'], AttributeList(), 'Returns the Type instance that defines this type.') 
     332        meth.sharedMethodBacking = 'getClass'  
     333        #meth.sharedMethodBackingIsAlias = true # not static 
     334        #overload.addMember(meth) 
     335        .addDecl(meth) 
     336                 
     337    def scanNativeTypeJvm 
    303338        """ 
    304339        Subclasses should invoke base and then invoke the various _scanXXX methods that are appropriate for them. 
    305340        """ 
     
    307342        _needScanNativeType = false 
    308343        # print '<> _scanNativeType for [.name] in [_parentNameSpace.fullName], class is [.getType.name]' 
    309344         
    310     def _scanGenericArgsJvm 
     345    def scanGenericArgsJvm 
     346        #print 'scanGenericArgsJvm [.name] [_jvmType.isGenericType]' 
    311347        if _jvmType.isGenericType 
    312348            for genArg in _jvmType.getGenericArguments 
    313349                t = (.compiler to Compiler).typeForJvmType(genArg) 
     
    315351                    t = GenericParam(JvmNativeType(genArg), parentDefinition=this) 
    316352                    (.compiler to Compiler).addTypeForJvmType(t to !, genArg) 
    317353                _genericParams.add(t) 
     354            #print 'scanGenericArgsJvm', .nameWithGenericParams # _genericParams 
    318355                 
    319     def _prepSystemObjectClassJvm 
    320         # map method getType to java getClass 
    321         # C#'s typeof(X) is X.getType in Cobra. 
    322         #existing = .declForName('getClass') to BoxMember 
    323         #overload = MemberOverload(existing) 
    324         #.registerOverload(overload) 
    325         meth = Method(TokenFix.empty, TokenFix.empty, this, 'getType', List<of Param>(), .compiler.typeTypeProxy, nil, ['shared'], AttributeList(), 'Returns the Type instance that defines this type.') 
    326         meth.sharedMethodBacking = 'getClass'  
    327         #meth.sharedMethodBackingIsAlias = true # not static 
    328         #overload.addMember(meth) 
    329         .addDecl(meth) 
    330                  
    331356    def _scanJvmIsNames 
    332357        # TODO 
    333358        _isNames.add('extern')  # to make the box like the ones that were in SystemInterfaces.cobra 
     
    337362            if not _badJvmRelatedType(interf) 
    338363                _baseInterfaceProxies.add(JvmTypeProxy(interf)) 
    339364 
    340 /# 
    341365    def _scanJvmNestedTypes 
    342         # TODO: enable and fix resulting bugs 
    343         # for type in .clrType.getNestedTypes(BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic)) 
    344366        for type in _jvmType.getNestedTypes 
    345             _scanJvmNestedType(type) 
    346         #for type in _clrType.getNestedTypes(BindingFlags(Static, DeclaredOnly, NonPublic)) 
    347         for type in _jvmType.getNestedTypes 
    348             if type.isEnum and not type.isPublic 
    349                 _scanJvmNestedType(type) 
     367            assert type.isNested 
     368            nativeType = JvmNativeType(type) 
     369            nativeType.nestedName = nativeType.name.after('$') 
     370            if type.isClass 
     371                .addDecl(Class(nativeType, .compiler.backEnd)) 
     372            else if type.isInterface 
     373                .addDecl(Interface(nativeType, .compiler.backEnd)) 
     374            else if type.isEnum 
     375                .addDecl(EnumDecl(this, nativeType))  
     376            else 
     377                throw FallThroughException(type) 
     378        if .declsInOrder.count 
     379            lastDecl = .declsInOrder[.declsInOrder.count-1] to dynamic 
     380            if (lastDecl to Object).getType.getProperty('ParentBox')  # CC: if lastDecl responds to (get parentBox as Box?) 
     381                lastDecl.parentBox = this 
    350382 
    351     def _scanJvmNestedType(type as JavaClassType) 
    352         nativeType = JvmNativeType(type) 
    353         if type.isClass 
    354             .addDecl(Class(nativeType, .compiler.backEnd)) 
    355         else if type.isInterface 
    356             .addDecl(Interface(nativeType, .compiler.backEnd)) 
    357         else if type.isEnum 
    358             isNames = List<of String>() 
    359             docString ='' 
    360             .addDecl(EnumDecl(this, nativeType, isNames, docString))  # TODO: isNames; docString? 
    361         #else if type.isValueType 
    362         #   .addDecl(Struct(clrType, .compiler.backEnd)) 
    363         #else if type.isAnsiClass 
    364         #   # The Enum class is an example that returns false for .isClass but true for .isAnsiClass 
    365         #   .addDecl(Class(clrType, .compiler.backEnd)) 
    366         else 
    367             throw FallThroughException(type) 
    368         lastDecl = .declsInOrder[.declsInOrder.count-1] to dynamic 
    369         if (lastDecl to Object).getType.getProperty('ParentBox')  # CC: if lastDecl responds to (get parentBox as Box?) 
    370             lastDecl.parentBox = this 
    371              
    372 #/ 
    373383 
    374384    def _scanJvmFields 
    375385        for fieldInfo in _jvmType.getFields 
     
    462472            if propInfo.isWritable 
    463473                prop.makeSetPart(TokenFix.empty) 
    464474            if _declsByName.containsKey(prop.name) # for            # Double.naN 
    465                 print 'DUP name already exists already for property [prop.name]', _declsByName[prop.name], prop 
    466                 return # just drop the property, field or method still available 
     475                print 'DUP name exists already for property "[prop.name]" on', /#_declsByName[prop.name],#/ .name 
     476                return # just drop the property; field or method still available 
    467477            .addDecl(prop) 
    468478 
    469479 
     
    493503                .registerOverload(overload to !) 
    494504            else 
    495505                throw FallThroughException([this, indexer, other]) 
     506        #print 'Dbg: add IDXR [_jvmType.name][indexer.name] [propInfo.name]' 
    496507        if overload 
    497508            overload.addMember(indexer) 
    498509        else 
     
    601612        """ 
    602613        if t is nil  
    603614            return false 
    604  
    605615        if t.isNested and not (t.isPublic or t.isProtected)and not t.isGenericParameter  # TODO: need the generic param check? 
    606616            print 'Type t.name is nested and not public,protected' 
    607617            return true 
    608  
    609         # FYI: MS .NET 2.0 (but not Mono 1.2.6) will return true for .isNotPublic for types are "by ref" 
    610618        #if t.isByRef # TODO: or t.isArray 
    611619        #   return _badJvmRelatedType(t.getElementType) 
    612  
    613620        return false 
    614621 
    615622    def _jvmMemberTypeProxy(jvmType as JavaClassType?) as ITypeProxy 
     
    646653            notNull = member.isNonNullable 
    647654            t = JvmTypeProxy(jvmType) to ITypeProxy 
    648655            return if(notNull, t, NilableTypeProxy(t)) 
     656             
     657    # Can only do these after bindImplementation phase. Nested classes  
     658    #_fix('java.util.Map<of,>.Entry<of,>', r'getKey getValue') 
     659    #_fix('java.util.AbstractMap.SimpleEntry<of,>', r'getKey getValue') 
     660    #_fix('java.util.AbstractMap.SimpleImmutableEntry<of,>', r'getKey getValue') 
     661         
     662    def _fixNestedNilables 
     663        if .parentBox  # nested 
     664            print 'fixNest', .parentBox.name, .name 
     665                 
    649666 
    650  
    651667class Class 
    652668    is partial 
    653669 
    654     def _scanNativeTypeJvm 
    655         base._scanNativeTypeJvm 
    656         print 'scanJvmNativeType ', .name 
     670    def scanNativeTypeJvm 
     671        base.scanNativeTypeJvm 
     672        #print 'scanJvmNativeType ', .name 
    657673        _scanJvmIsNames 
    658674        _scanJvmImplements 
    659         #_scanJvmNestedTypes 
     675        _scanJvmNestedTypes 
    660676        _scanJvmFields 
    661677        _scanJvmInitializers 
    662678        _scanJvmMethods 
     
    664680        ##_scanJvmEvents TODO  
    665681        # TODO: _scanJvmEnums 
    666682        # TODO: scan all other nested types 
     683        _fixNestedNilables 
    667684         
     685         
    668686     
    669687class Interface 
    670688    is partial 
    671689 
    672     def _scanNativeTypeJvm 
    673         base._scanNativeTypeJvm 
     690    def scanNativeTypeJvm 
     691        base.scanNativeTypeJvm 
    674692        _scanJvmIsNames 
    675693        _scanJvmImplements 
    676         #_scanJvmNestedTypes 
     694        _scanJvmNestedTypes 
    677695        _scanJvmFields 
    678696        _scanJvmMethods 
    679697        _scanJvmProperties 
    680698        #_scanJvmEvents #TODO 
     699        _fixNestedNilables 
    681700 
    682701 
    683702class Struct 
    684703    is partial 
    685704 
    686     def _scanNativeTypeJvm 
    687         base._scanNativeTypeJvm 
     705    def scanNativeTypeJvm 
     706        base.scanNativeTypeJvm 
    688707        _scanJvmIsNames 
    689708        _scanJvmImplements 
    690         #_scanJvmNestedTypes 
     709        _scanJvmNestedTypes 
    691710        _scanJvmFields 
    692711        _scanJvmInitializers 
    693712        _scanJvmMethods 
     
    698717class Extension 
    699718    is partial 
    700719 
    701     def _scanNativeTypeJvm 
     720    def scanNativeTypeJvm 
    702721        # this only for Cobra specific extensions. Example: class Extend_String_1939 
    703         base._scanNativeTypeJvm 
     722        base.scanNativeTypeJvm 
    704723        _scanJvmIsNames 
    705724        #_scanJvmImplements 
    706725        #_scanJvmNestedTypes 
     
    727746class EnumDecl 
    728747    is partial 
    729748 
    730     def _setUnderlyingTypeJvm 
     749    def setUnderlyingTypeJvm 
    731750        pass 
    732751 
    733     def _scanNativeTypeJvm 
     752    def scanNativeTypeJvm 
    734753        # TODO: read attribs 
    735754        _needScanNativeType = false 
    736755        _storageType = .compiler.anyIntType # tmp ?? 
  • Source/BackEndJvm/JvmBackEnd.cobra

     
    1010        base.init(compiler) 
    1111        _name = 'java-jvm' 
    1212        _rtlName = 'CobraLang.jar' 
     13        _rtlSrcFile = 'CobraImp.java' # backEnd source file containing native code support for Cobra.Lang 
     14 
    1315         
    1416        _tagToTypeName = {  
    15             'Object': 'java.lang.Object', 
    16             'Type'  : 'java.lang.Class<of>',    # java.lang.Type is a marker interface 
    17             'String'    :       'java.lang.String', 
    18             'Exception' :       'java.lang.RuntimeException', 
     17            'Object': 'Java.Lang.Object', 
     18            'Type'  : 'Java.Lang.Class<of>',    # java.lang.Type is a marker interface 
     19            'String'    :       'Java.Lang.String', 
     20            'Exception' :       'Java.Lang.RuntimeException', 
    1921 
    2022            'Delegate'  :       'System.Delegate', #cobra.lang.Delegate 
    21             'Attribute' :       'java.lang.annotation.Annotation', 
    22             #'ICloneable':      'System.ICloneable', #cobra.lang.ICloneable 
    23             'IEnumerable':      'java.lang.Iterable', 
    24             'IEnumerator':      'java.lang.Iterator', 
    25             'IEnumerable<of>' : 'java.lang.Iterable<of>', 
    26             'IEnumerator<of>' : 'java.lang.Iterator<of>', 
    27             'IDictionaryEnumerator' : 'System.Collections.IDictionaryEnumerator', 
    28             'ICollection':      'java.util.Collection<of Object>',  # non generic collection interface 
    29             'ICollection<of>':  'java.util.Collection<of>', 
    30             'IList' :           'java.util.List<of Object>',    # non generic List interface 
    31             'IList<of>' :       'java.util.List<of>', 
    32             'List<of>':         'java.util.ArrayList<of>', 
    33             'IDictionary':      'java.util.Map<of Object,Object>', # Non Generic Map/Dict interface 
    34             'IDictionary<of,>': 'java.util.Map<of,>', 
    35             'Dictionary<of,>' : 'java.util.HashMap<of,>', 
    36             'Set<of>':          'java.lang.HashSet<of>', 
     23            'Attribute' :       'Java.Lang.Annotation.Annotation', 
     24            'ICloneable':       'Java.Lang.Cloneable',  
     25            'IEnumerable':      'Java.Lang.Iterable', 
     26            'IEnumerator':      'Java.Lang.Iterator', 
     27            'IEnumerable<of>' : 'Java.Lang.Iterable<of>', 
     28            'IEnumerator<of>' : 'Java.Lang.Iterator<of>', 
     29            'IDictionaryEnumerator' : 'Java.Lang.Iterator', 
     30            #'IDictionaryEnumerator' : 'System.Collections.IDictionaryEnumerator', 
     31            'ICollection':      'Java.Util.Collection<of Object>',  # non generic collection interface 
     32            'ICollection<of>':  'Java.Util.Collection<of>', 
     33            'IList' :           'Java.Util.List<of Object>',    # non generic List interface 
     34            'IList<of>' :       'Java.Util.List<of>', 
     35            'List<of>':         'Java.Util.ArrayList<of>', 
     36            'IDictionary':      'Java.Util.Map<of Object,Object>', # Non Generic Map/Dict interface 
     37            'IDictionary<of,>': 'Java.Util.Map<of,>', 
     38            'Dictionary<of,>' : 'Java.Util.HashMap<of,>', 
     39            'Set<of>':          'Java.Lang.HashSet<of>', 
    3740 
    38             'bool'  :  'java.lang.Boolean',  # boolean 
    39             'char'  :  'java.lang.Character',# char 
    40             'decimal': 'java.lang.Double',  # ?? 
    41             'single': 'java.lang.Float',    # float  
    42             'double': 'java.lang.Double',   # double     
    43             'sbyte' : 'java.lang.Byte',     # byte 
    44             'int16' : 'java.lang.Short',    # short  
    45             'int32' : 'java.lang.Integer',  # int        
    46             'int64' : 'java.lang.Long',     # long 
    47             'byte'  : 'java.lang.Short',    # short   # rest are unsigned - use next widest 
    48             'uint16': 'java.lang.Integer',  # int    
    49             'uint32': 'java.lang.Long',     # long 
    50             'uint64': 'java.lang.Long',     # long 
     41            'bool'  :  'Java.Lang.Boolean',  # boolean 
     42            'char'  :  'Java.Lang.Character',# char 
     43            'decimal': 'Java.Lang.Double',  # ?? 
     44            'single':  'Java.Lang.Float',   # float  
     45            'double':  'Java.Lang.Double',  # double     
     46            'sbyte' :  'Java.Lang.Byte',        # byte 
     47            'int16' :  'Java.Lang.Short',   # short  
     48            'int32' :  'Java.Lang.Integer', # int        
     49            'int64' :  'Java.Lang.Long',        # long 
     50            'byte'  :  'Java.Lang.Short',   # short   # rest are unsigned - use next widest 
     51            'uint16':  'Java.Lang.Integer', # int    
     52            'uint32':  'Java.Lang.Long',        # long 
     53            'uint64':  'Java.Lang.Long',        # long 
    5154             
    5255            } 
    5356         
     
    5861        phases.add(GenerateJavaCodePhase(.compiler)) 
    5962        phases.add(CompileJavaCodePhase(.compiler)) 
    6063         
     64    def getRecommendedBuiltInType(parentNameSpace as NameSpace?, name as String) as String? is override 
     65        n = nil to String? 
     66        if parentNameSpace and parentNameSpace.fullName == 'Java.Lang' 
     67            branch name 
     68                on 'Boolean', n = 'bool' 
     69                #on 'SByte',   n = 'int8' 
     70                on 'Byte',    n = 'uint8' 
     71                on 'Short',   n = 'int16' 
     72                #on 'UInt16',  n = 'uint16' 
     73                on 'Integer',   n = 'int32' 
     74                #on 'UInt32',  n = 'uint32' 
     75                on 'Long',    n = 'int64' 
     76                on 'UInt64',  n = 'uint64' 
     77                on 'Character',    n = 'char' 
     78                on 'Float',  n = 'float32' 
     79                on 'Double',  n = 'float' 
     80                on 'BigDecimal', n = 'decimal' 
     81        return n 
     82 
    6183    def computeOutName as String is override 
    6284        return .compiler.computeOutNameJava  
    6385         
     
    87109    def setDefaultUseDirectives(ns as NameSpace) is override 
    88110        # java packages available by default 
    89111        useToken = Token('(implicit)', 1, 1, 1, 'USE', 'use', nil) 
    90         # java uses lowercase for package names - Should Cobra stay capitalised and we remap it ?? 
    91         ns.addUseDirective(UseDirective(useToken, ['java', 'lang'])) 
     112        # java uses lowercase for package names - Cobra stay capitalised and we remap it 
     113        ns.addUseDirective(UseDirective(useToken, ['Java', 'Lang'])) 
    92114        #ns.addUseDirective(UseDirective(useToken, ['System', 'Collections', 'Generic'])) # generics built in 
    93         ns.addUseDirective(UseDirective(useToken, ['java', 'io'])) 
    94         ns.addUseDirective(UseDirective(useToken, ['java', 'util'])) 
    95         ns.addUseDirective(UseDirective(useToken, ['java', 'text'])) 
    96         ns.addUseDirective(UseDirective(useToken, ['cobra', 'lang'])) 
     115        ns.addUseDirective(UseDirective(useToken, ['Java', 'Io'])) 
     116        ns.addUseDirective(UseDirective(useToken, ['Java', 'Util'])) 
     117        ns.addUseDirective(UseDirective(useToken, ['Java', 'Text'])) 
     118        ns.addUseDirective(UseDirective(useToken, ['Cobra', 'Lang'])) 
    97119         
    98120    def fixLibExtension(libRef as String) as String is override 
    99121        """ 
     
    120142        return .compiler.jvmLoadReference(reference)   # in ScanJvmType 
    121143     
    122144    def readSystemTypes is override 
    123         #pass   # TODO 
    124145        # Initially we will rely on a external java tool to have been run to produce a precis 
    125146        # file in a known place (same as cobra compiler perhaps) containing exported types for 
    126147        # items in a jar file. 
    127148         
    128         # JarSig is a holder for jarfile extended with info on contained classes. 
     149        # JarSig is a holder for a jarfile or package extended with info on contained classes. 
    129150        # javaReadJar loads info on contained classes into Cobra 
    130151        # rt.jar is only one we need 
    131152        .compiler.javaReadJar(JarSig('rt.jar')) 
    132153     
    133154    def fixNilableMemberSigs is override 
    134         #.compiler.javafixNilableMemberSigs 
    135         print '++ TODO jvmBackEnd.fixNilableMemberSigs' 
     155        #.compiler.jvmfixNilableMemberSigs 
    136156        pass # TODO 
    137157         
    138158    def installNativeMethods(box as Box, nativeType as NativeType) is override 
    139159        #.compiler.installJvmNativeMethods(box, nativeType) 
    140         print '++ TODO jvmBackEnd.installNativeMethods' 
    141160        pass # TODO 
    142161 
    143162    def cobraNameForNativeBoxName(nativeBoxName as String) as String is override 
     
    147166    get objectTypeProxy as AbstractTypeProxy  is override 
    148167        """Type proxy for BE root of Object hierarchy.""" 
    149168        if  not _objectTypeProxy 
    150             _objectTypeProxy = JvmTypeProxy(JarSig.classByNameCache['java.lang.Object']) 
     169            _objectTypeProxy = JvmTypeProxy(JarSig.lookupClassByCobraName('Java.Lang.Object')) 
    151170        return _objectTypeProxy to ! 
    152171             
    153172    get typeTypeProxy  as AbstractTypeProxy  is override 
    154173        """Type proxy for BE notion of a class describing a Type.""" 
    155174        if  not _typeTypeProxy 
    156             _typeTypeProxy = JvmTypeProxy(JarSig.classByNameCache['java.lang.Class']) 
     175            _typeTypeProxy = JvmTypeProxy(JarSig.lookupClassByCobraName('Java.Lang.Class')) 
    157176        return _typeTypeProxy to !   
    158177         
    159178    def nativeTypeProxy(type as NativeType) as NativeTypeProxy  is override 
     
    170189        /# 
    171190        These are the type tags used directly by the compiler code. 
    172191             
    173             bool        'Java.lang.Boolean' 
    174             char        'java.lang.Char' 
     192            bool        'Java.Lang.Boolean' 
     193            char        'Java.Lang.Char' 
    175194            decimal     '??System.Decimal'   
    176             decimal     'java.lang.Float'    
    177             single      'java.lang.Float'        
    178             double      'java.lang.Double'       
    179             sbyte       'java.lang.Byte'         
    180             int16       'java.lang.Short'        
    181             int32       'java.lang.Int'      
    182             int64       'java.lang.Long'     
     195            decimal     'Java.Lang.Float'    
     196            single      'Java.Lang.Float'        
     197            double      'Java.Lang.Double'       
     198            sbyte       'Java.Lang.Byte'         
     199            int16       'Java.Lang.Short'        
     200            int32       'Java.Lang.Integer'      
     201            int64       'Java.Lang.Long'     
    183202            # java not have unsigned types (:-( use next largest signed Type 
    184             byte        'java.lang.Short' #& 0x7f        
    185             uint16      'java.lang.Int'      
    186             uint32      'java.lang.Long'         
    187             uint64      'java.lang.Long'         
     203            byte        'Java.Lang.Short' #& 0x7f        
     204            uint16      'Java.Lang.Integer'      
     205            uint32      'Java.Lang.Long'         
     206            uint64      'Java.Lang.Long'         
    188207        #/ 
    189208         
    190     def addArrayInterfaces(interfaces as List<of ITypeProxy>) is override 
    191         pass 
    192         #iclone = .compiler.libraryType('ICloneable') # ICloneable not supported 
    193         #interfaces.insert(0, iclone to ITypeProxy) 
     209    def determineExtnNativeType(extn as Extension, nativeType as NativeType) as NativeType is override 
     210        return extn.jvmExtnNativeType(nativeType)   # ScanJvmType 
     211 
     212    def handleNameSpaceNameCollision(ns as NameSpace, token as IToken, name as String) as NameSpace is override 
     213        """ 
     214        Java separates Namespaces and other symbols - Cobra architecture 
     215        (based on Clr) doesnt easily so currently we'll rename and warn that 
     216        use of the namespace needs to be changed in user code (:-). 
     217        """ 
     218        #print 'In [ns.name] there is already a non-namespace declaration named "[name]".' 
     219        #print 'Cobra doesnt allow this - a declaration must be either a Namespace or a Type' 
     220        #print 'so the namespace "[name]" is renamed within Cobra to be "[name]NS".' 
     221        #print 'Any use of the namespace in cobra code must be changed accordingly.' 
     222 
     223        #print 'Cobra name collision in namespace "[ns.name]" for child namespace "[name]" and an existing declaration. Use name "[name]NS" for java namespace/package "[name]" .' 
     224        print 'In namespace "[ns.name]" java namespace "[name]" renamed in cobra to "[name]NS". (cobra name collision)' 
     225        name = name+'NS' 
     226        return ns.getOrMakeNameSpaceNamed(token, name) # recursive 
    194227         
     228    def prepSystemObjectClass(box as Box) is override 
     229        box.prepSystemObjectClassJvm 
    195230         
     231    def scanGenericArgs(box as Box)  is override 
     232        box.scanGenericArgsJvm 
    196233         
     234    def scanNativeType(box as Box)   is override 
     235        """ Do scan/Load of Types from a dll """ 
     236        box.scanNativeTypeJvm 
     237 
     238    def scanNativeType(edcl as EnumDecl)  is override 
     239        edcl.scanNativeTypeJvm 
     240         
     241    def setUnderlyingType(edcl as EnumDecl)  is override 
     242        edcl.setUnderlyingTypeJvm 
     243         
    197244class GenerateJavaCodePhase inherits Phase 
    198245 
    199246    cue init(c as Compiler) 
  • Source/BackEndJvm/JavaCompilationMessage.cobra

     
    1111        assert msg.lineNum == 30 
    1212 
    1313    def willSkipMessage(msg as String) as bool is shared 
    14         #return not '.java:' in msg 
    15         return false  
     14        return not '.java:' in msg 
     15        #return false  
    1616         
    1717    var _fileName as String? 
    1818    var _lineNum as int? 
     
    3030            i += '.java:'.length 
    3131            j = line.indexOf(':', i) 
    3232            lineStr = line[i:j] 
    33             try 
    34                 _lineNum = int.parse(lineStr) 
    35             catch 
    36                 pass 
    37             success  
    38                 _lineNum = compiler.cobraLineNumForCurly(.fileName, _lineNum to !) 
    39                 if compiler.verbosity or Utils.isDevMachine, line += ' (javac)' 
     33            _storeLineNum(lineStr, compiler) 
     34            if compiler.verbosity or Utils.isDevMachine, line += ' (javac)' 
    4035        _message = _cleanUp(line) 
    4136 
     37    def append(line as String, compiler as Compiler) 
     38        line = line.trim 
     39        _message += '\n >: ' + line 
     40        if System.Text.RegularExpressions.Regex.isMatch(line, r'// \d+\s*$') 
     41            lidx = line.lastIndexOf('//') 
     42            if lidx > 0 
     43                lidx += 3  # after '// ' 
     44                lineStr = line[lidx:] 
     45                _storeLineNum(lineStr, compiler) 
     46 
     47    def _storeLineNum(lineStr as String, compiler as Compiler) 
     48        try 
     49            _lineNum = int.parse(lineStr) 
     50        catch 
     51            pass 
     52        success  
     53            _lineNum = compiler.cobraLineNumForCurly(.fileName, _lineNum to !) 
     54                     
    4255    def _cleanUp(line as String) as String 
    4356        line = line.replace("`double'", "`float'") 
    4457        line = line.replace("null", "nil") 
  • Source/BackEndJvm/JavaGenerator.cobra

     
    3434    def writeJava 
    3535        Node.setCompiler(this) 
    3636        try 
    37             pass 
     37            #pass 
    3838            _moduleFileName_to_curlyToCobraLineNum = Dictionary<of String, Dictionary<of int, int>>() 
    3939            for _curModule in _modules 
    4040                if not _curModule.fileName.endsWith('SystemInterfaces.cobra') 
     
    175175        return output        
    176176             
    177177    def _parseJavaCompilerOutput(output as String) 
     178        jcm as JavaCompilationMessage? = nil 
    178179        for line in output.split(c'\n') 
    179180            line = line.trim 
    180181            if not line.length, continue 
    181182            if JavaCompilationMessage.willSkipMessage(line) 
     183                if jcm, jcm.append(line, this) 
    182184                continue 
    183185            else 
    184186                if _verbosity >= 3 
    185187                    print 'javac message: [line]' 
    186                 _addMessage(JavaCompilationMessage(line, this)) 
     188                jcm = JavaCompilationMessage(line, this) 
     189                _addMessage(jcm to !) 
    187190             
    188191 
    189192    def _getFixedMainType as String 
     
    501504 
    502505class UseDirective is partial 
    503506 
     507# Dont use java imports as  
     508# -- The semantics between Cobra `use` and java `import` are (probably) different. 
     509# -- Using Cobra.Lang library type names without qualification in the generated code could lead to confusing errors if the user happens to have a type with the same name. 
     510# instead names from 'used' packages/namespaces will be fully qualified in generated java source. 
     511 
     512#   def writeJavaDef(sw as CurlyWriter) is override 
     513#       sw.write('import [.boundNameSpace.javaRef].*;\n') 
    504514    pass 
    505515 
    506516 
     
    617627class IntType is partial 
    618628 
    619629    get javaName as String is override 
     630        # should name to primitives but not prob fm JvmJarSig._aliasPrimitives 
     631        # TODO fix primitives int, long,... vs classes java.lang.Integer, java.lang.Long  
    620632        #return _nativeType.fullName 
    621         return 'int'    # java.lang.Integer 
     633        t =  _nativeType.fullName 
     634        branch t  
     635            on 'java.lang.Byte',    primName = 'byte' 
     636            on 'java.lang.Short',   primName = 'short'  
     637            on 'java.lang.Integer', primName = 'int' 
     638            on 'long',    primName = _nativeType.fullName 
     639            on 'java.lang.Long',    primName = 'long'  
     640            else  
     641                throw FallThroughException() 
     642        return primName 
    622643        # TODO byte = int8 , short = int16, int = Int32, long = int64 
    623644 
    624645class NilableType is partial 
     
    751772                sb.append(param.javaRef) 
    752773                sep = ', ' 
    753774            sb.append('>') 
    754             xjava = sb.toString 
     775            javaRef = sb.toString 
    755776        else 
    756             xjava = .javaName 
     777            javaRef = .javaName 
    757778        if .parentNameSpace and not .parentNameSpace.isRoot 
    758779            #trace .parentNameSpace.javaQualifier 
    759             xjava = .parentNameSpace.javaQualifier + xjava 
     780            javaRef = .parentNameSpace.javaQualifier + javaRef 
    760781        else if .parentBox 
    761782            trace .parentBox.javaRef 
    762             xjava = .parentBox.javaRef + '.' + xjava 
     783            javaRef = .parentBox.javaRef + '.' + javaRef 
    763784        #trace java 
    764         return xjava 
     785        return javaRef 
    765786 
    766787    def writeJavaDef(sw as CurlyWriter) 
    767788        base.writeJavaDef(sw) 
     
    10981119 
    10991120class LocalVar is partial 
    11001121 
    1101     pass 
     1122    def writeJavaDef(sw as CurlyWriter) 
     1123        base.writeSharpDef(sw) 
     1124        sw.write('[.type.javaRef] [.javaName]') 
     1125        init = .type.javaInit 
     1126        if init.length, sw.write(' = [init]') 
     1127        sw.write(';\n') 
    11021128 
    11031129 
     1130 
    11041131class ResultVar is partial 
    11051132 
    11061133    get javaName as String is override 
     
    12221249        base.writeJavaDef(sw) 
    12231250        .writeJavaAttribs(sw) 
    12241251        .writeJavaIsNames(sw) 
    1225         sw.write('const ') 
     1252        sw.write('static final ')       # const  
    12261253        sw.write(_type.javaRef) 
    12271254        sw.write(' [_javaBackEndName] = ') 
    12281255        _initExpr.writeJavaDef(sw) 
     
    16021629                sw.writeLine('}') 
    16031630 
    16041631    get javaName as String is override 
    1605         return .name #.capitalized 
     1632        return .name #./capitalized 
    16061633 
    16071634# Java, for its sins, does not have support for properties built into the language... 
    16081635# efforts to correct this stupidity seem to be mired in language navel gazing plus associated  
     
    16121639#   Its obviously too difficult to just copy C# (turnabout is fair play), accept and then evolve any edge misses  
    16131640 
    16141641class ProperDexer is partial 
     1642    # AbstractBaseClass for Property and Indexer 
     1643     
     1644    def writeJavaBody(sw as CurlyWriter) 
     1645        #sw.write(' {\n') 
     1646        #sw.indent 
     1647        if _getPart 
     1648            #if .isAbstract or not .parentBox.canHaveStatements 
     1649            #   sw.write('\tget;\n') 
     1650            #else 
     1651            #   _getPart.writeJavaDef(sw) 
     1652            _getPart.writeJavaDef(sw) 
     1653        if _setPart 
     1654            #if .isAbstract or not .parentBox.canHaveStatements 
     1655            #   sw.write('\tset;\n') 
     1656            #else 
     1657            #   _setPart.writeJavaDef(sw) 
     1658            _setPart.writeJavaDef(sw) 
     1659        #sw.dedent 
     1660        #sw.write('}\n') 
    16151661 
    1616     # TODO 
    1617     pass 
    16181662 
    1619  
    16201663class ProperDexerXetter is partial 
     1664    # BaseClass for Indexer get/set, Property get/set 
    16211665 
    1622     # TODO 
    1623     pass 
     1666    def innerWriteJavaDef(sw as CurlyWriter) 
     1667        base.innerWriteJavaDef(sw) 
     1668        sw.write(.xetPartName) 
     1669        .writeJavaImp(sw, false) 
    16241670 
    16251671 
    16261672class Property is partial 
    16271673 
    1628     # TODO 
    1629     pass 
     1674    get javaNotNullPrefix as String is override 
     1675        return '' 
    16301676 
     1677    def writeJavaDef(sw as CurlyWriter) 
     1678        base.writeJavaDef(sw) 
     1679        sw.writeLine('') 
     1680        sw.write('//Property  [_returnType.javaRef] [.name]') 
     1681        # .writeJavaImp(sw) 
     1682        getPart = .getPart 
     1683        if getPart 
     1684            .writeJavaNotNull(sw) 
     1685            .writeJavaAttribs(sw) 
     1686            .writeJavaIsNames(sw) 
     1687            sw.write('[_returnType.javaRef] get[.name.capitalized]') 
     1688            sw.write(' {\n') 
     1689            sw.indent 
     1690            getPart.writeJavaDef(sw) 
     1691            sw.dedent 
     1692            sw.write('}\n') 
     1693        setPart = .setPart 
     1694        if setPart 
     1695            .writeJavaNotNull(sw) 
     1696            .writeJavaAttribs(sw) 
     1697            .writeJavaIsNames(sw) 
     1698            sw.write('set[.name.capitalized]([_returnType.javaRef] value)') 
     1699            sw.write(' {\n') 
     1700            sw.indent 
     1701            setPart.writeJavaDef(sw) 
     1702            sw.dedent 
     1703            sw.write('}\n') 
     1704            #.writeJavaBody(sw) 
    16311705 
     1706         
     1707        if getPart 
     1708            .compiler.codeMemberStack.push(getPart) 
     1709            try 
     1710                if getPart.requirePart 
     1711                    getPart.requirePart.writeJavaMethod(sw) 
     1712                if getPart.ensurePart 
     1713                    getPart.ensurePart.writeJavaMethod(sw) 
     1714            finally 
     1715                .compiler.codeMemberStack.pop 
     1716 
     1717        if setPart 
     1718            .compiler.codeMemberStack.push(setPart) 
     1719            try 
     1720                if setPart.requirePart 
     1721                    setPart.requirePart.writeJavaMethod(sw) 
     1722                if setPart.ensurePart 
     1723                    setPart.ensurePart.writeJavaMethod(sw) 
     1724            finally 
     1725                .compiler.codeMemberStack.pop 
     1726 
     1727        if .compiler.includeTests 
     1728            .writeJavaTest(sw) 
     1729 
     1730 
    16321731class Indexer is partial 
    16331732 
    16341733    # TODO 
     
    17081807            fileName = Utils.javaStringLiteralFor(fileName) 
    17091808            return 'new cobra.lang.SourceSite([fileName], [tok.lineNum], [boxName], [memberName], [javaThis])' 
    17101809 
     1810    def javaSourceSiteArgs as String 
     1811        return .javaSourceSiteArgs(.compiler.curBox.name, .compiler.curBoxMember.name, .javaThis) 
     1812     
     1813    def javaSourceSiteArgs(boxName as String, memberName as String, javaThis as String) as String 
     1814        require 
     1815            boxName.length 
     1816            memberName.length 
     1817            javaThis.length 
     1818        body 
     1819            boxName = Utils.javaStringLiteralFor(boxName) 
     1820            memberName = Utils.javaStringLiteralFor(memberName) 
     1821            tok = .token 
     1822            fileName = tok.fileName 
     1823            if not Path.isPathRooted(fileName) 
     1824                fileName = Path.combine(Environment.currentDirectory, fileName) 
     1825            fileName = Utils.javaStringLiteralFor(fileName) 
     1826            return '[fileName], [tok.lineNum], [boxName], [memberName], [javaThis]' 
     1827     
    17111828    get javaThis as String 
    17121829        if _inInitCall  # C# won't allow 'this' in a base constructor call -- TODO 
    17131830            return '"(uninitialized [.compiler.curBox.name] instance)"' 
     
    18381955                sw.write('else ') 
    18391956                _elsePart.writeJavaDef(sw) 
    18401957        else 
    1841             # for any other kind of expression, use a Java switch 
     1958            # for any other kind of expression, use a Java switch. 
     1959            # TODO trap if expression is string and use a if-else ladder ( if not java7) 
    18421960            sw.write('switch(') 
    18431961            _expr.writeJavaDef(sw) 
    18441962            sw.write(') {\n') 
     
    23702488 
    23712489    def writeJavaDef(sw as CurlyWriter, parens as bool) is override 
    23722490        # recall that this cannot be the right side of "foo.bar" since that is a MemberExpr 
    2373         xjava = .javaQualification + .javaName 
    2374         if _requiresGetClass, xjava = xjava + '.getClass()' 
    2375         #print 'Dbg: IdExpr::', java 
    2376         sw.write(xjava) 
     2491        javaRef = .javaQualification + .javaName 
     2492        if _requiresGetClass, javaRef = javaRef + '.getClass()' 
     2493        #print 'Dbg: IdExpr::', javaRef 
     2494        sw.write(javaRef) 
    23772495 
    23782496    get javaQualification as String 
    23792497        qual = '' 
     
    26132731    def writeJavaDefForBreakdown(sw as CurlyWriter) is override 
    26142732        requiresTypeOf = _requiresTypeOf # using C# version currently - chop ? 
    26152733        if not requiresTypeOf, sw.write('typeof(') 
    2616         .writeSharpDef(sw) 
     2734        .writeJavaDef(sw) 
    26172735        if not requiresTypeOf, sw.write(')') 
    26182736 
    26192737         
     
    27632881    def asJava as String is override 
    27642882        return _name 
    27652883 
     2884class ToNilableOrNotExpr 
     2885    is partial 
     2886 
     2887    def writeJavaBreakdownItems(sw as CurlyWriter) 
     2888        base.writeJavaBreakdownItems(sw) 
     2889        _expr.writeJavaBreakdownItems(sw) 
     2890 
     2891 
     2892class ToNilableExpr 
     2893    is partial 
     2894 
     2895    def writeJavaDef(sw as CurlyWriter, parens as bool) is override 
     2896        if _expr.type.isReference 
     2897            # In C#/.NET, reference types are always "nilable" 
     2898            _expr.writeJavaDef(sw) 
     2899        else 
     2900            # ex: ((int?)x) 
     2901            # ex: ((Color?)Color.Black) 
     2902            #sw.write('(([_expr.type.javaRef]?)') 
     2903            sw.write('(([_expr.type.javaRef])') 
     2904            _expr.writeJavaDef(sw, false) 
     2905            sw.write(')') 
     2906 
     2907 
     2908class ToNonNilableExpr 
     2909    is partial 
     2910 
     2911 
     2912    def writeJavaDef(sw as CurlyWriter, parens as bool) is override 
     2913        type = _expr.type 
     2914        if type inherits NilableType and not type.nonNil.isReference 
     2915            # ex: (x).Value 
     2916            # ex: (obj.foo).Value 
     2917            sw.write('(') 
     2918            _expr.writeJavaDef(sw, false) 
     2919            #sw.write(').value') 
     2920            sw.write(')') 
     2921        else if .compiler.options.boolValue('include-nil-checks') 
     2922            sw.write('(CobraLangInternal.CobraCore._willCheckNil ? CobraLangInternal.CobraImp.CheckNonNil<[type.javaRef]>([.javaThis], [Utils.javaStringLiteralFor(_expr.toCobraSource)], ') 
     2923            _expr.writeJavaDef(sw, false) 
     2924            sw.write(', [.javaSourceSiteArgs]):') 
     2925            _expr.writeJavaDef(sw, false) 
     2926            sw.write(')') 
     2927        else 
     2928            _expr.writeJavaDef(sw, parens) 
     2929 
     2930 
    27662931         
    27672932             
    27682933## 
     
    30573222        _left.writeJavaBreakdownItems(sw) 
    30583223 
    30593224 
     3225class InheritsExpr 
     3226    is partial 
     3227                 
     3228    def _writeJavaDef(sw as CurlyWriter) is override 
     3229        _left.writeJavaDef(sw) 
     3230        sw.write(' instanceof ') 
     3231        _right.writeSharpDef(sw, false) 
    30603232 
     3233 
     3234class ToExpr is partial 
     3235 
     3236/#  def needsContextCast as bool is override 
     3237        if .type.isDynamic, return base.needsContextCast 
     3238        else, return false  # the user is already casting, so go with their cast 
     3239#/ 
     3240    def _writeJavaDef(sw as CurlyWriter) is override 
     3241        rightType = _rightTypeExpr.potentialType to !   # its not nil or _bindImp would have thrown an error 
     3242        if rightType is .compiler.passThroughType 
     3243            _left.writeJavaDef(sw) 
     3244            return 
     3245        sw.write('(') 
     3246        _right.writeJavaDef(sw, false)  # double parens would be pointless and also causes a C# error 
     3247        sw.write(')') 
     3248        if not rightType inherits NilableType and rightType.isReference and .compiler.options.boolValue('include-nil-checks') 
     3249            sw.write('CobraLangInternal.CobraImp.CheckNonNil<[_left.type.javaRef]>([.javaThis], [Utils.javaStringLiteralFor(_left.toCobraSource)], ') 
     3250            _left.writeJavaDef(sw, false) 
     3251            sw.write(', [.javaSourceSiteArgs])') 
     3252        else 
     3253            _left.writeJavaDef(sw) 
     3254 
     3255 
     3256class ToQExpr 
     3257    is partial 
     3258 
     3259    def _writeJavaDef(sw as CurlyWriter) is override 
     3260        # x to? int     --> ((x is int || x is int?) ? (int?)x : (int?)null) 
     3261        # x to? int?    --> ((x is int || x is int?) ? (int?)x : (int?)null) 
     3262        # ^ but this would cause multiple evaluation of x, so... 
     3263        # x to? int?    --> (int?)CobraLangInternal.CobraImp.ToOrNil(x) 
     3264 
     3265        # x to? string  --> (x as String) 
     3266        # x to? string? --> (x as String) 
     3267        right = .right 
     3268        t = right.definition to IType 
     3269        t = t.nonNil 
     3270        typeJavaRef = t.javaRef 
     3271        #if t.isReference 
     3272        #   sw.write('(') 
     3273        #   .left.writeJavaDef(sw) 
     3274        #   sw.write(') as [typeJavaRef]') 
     3275        #else 
     3276        #   sw.write('[typeJavaRef])CobraLangInternal.CobraImp.ToOrNil<[typeJavaRef]>(') 
     3277        #   .left.writeJavaDef(sw) 
     3278        sw.write('[typeJavaRef])CobraLangInternal.CobraImp.ToOrNil<[typeJavaRef]>(') 
     3279        .left.writeJavaDef(sw) 
     3280        sw.write(')') 
     3281 
     3282 
     3283 
    30613284class CoalesceExpr 
    30623285    is partial 
    30633286 
     
    30973320        if name is nil 
    30983321            name = _name 
    30993322        #print 'Dbg: MemberExpr::', name 
    3100         sw.write(name) 
    3101         if _definition and (_definition.isMethod or _name=='toString') and not _isReference  # TODO: axe the 'toString' check 
     3323        if _definition inherits Property 
     3324            xet='get' 
     3325            if _isLValue, xet = 'set' 
     3326            sw.write(xet+name) 
    31023327            sw.write('()') 
     3328        else 
     3329            sw.write(name) 
     3330            if _definition and (_definition.isMethod or _name=='toString') and not _isReference  # TODO: axe the 'toString' check 
     3331                sw.write('()') 
    31033332 
     3333    def _isLValue as bool 
     3334        if not (.superNode and .superNode inherits BinaryOpExpr) 
     3335            return false 
     3336        bsn0 = this to INode 
     3337        bsn  = .binarySuperNode 
     3338        while true 
     3339            if bsn inherits AssignExpr and bsn0 is bsn.left 
     3340                return true 
     3341            if not (bsn.superNode and bsn.superNode inherits BinaryOpExpr) 
     3342                return false 
     3343            bsn0 = bsn 
     3344            bsn = bsn.binarySuperNode 
     3345             
    31043346    def writeJavaBreakdownItems(sw as CurlyWriter) is override 
    31053347        pass 
    31063348 
  • Source/TestifyRunner.cobra

     
    469469                continue 
    470470 
    471471            if firstLineInsensitive.startsWith('#.require.') 
     472                rtPlatform  = CobraCore.runtimePlatform 
    472473                what = firstLineInsensitive[10:] 
    473474                branch what 
    474475                    on 'mono' 
    475                         if not CobraCore.isRunningOnMono 
     476                        if  rtPlatform <> 'clr' or not CobraCore.isRunningOnMono 
    476477                            print 'Skipping test because requirement for "mono" is not met.' 
    477478                            return 0 
    478479                    on 'dotnet' 
    479                         if CobraCore.isRunningOnMono 
     480                        if  rtPlatform <> 'clr' or CobraCore.isRunningOnMono 
    480481                            print 'Skipping test because requirement for "dotnet" is not met.' 
    481482                            return 0 
     483                    on 'clr' # mono or dotNet 
     484                        if  rtPlatform <> 'clr'  
     485                            print 'Skipping test because requirement for "clr" is not met.' 
     486                            return 0 
     487                    on 'jvm' 
     488                        if  rtPlatform <> 'jvm' 
     489                            print 'Skipping test because requirement for "jvm" is not met.' 
     490                            return 0 
    482491                    else 
    483492                        if what.endsWith('.dll') 
    484493                            try 
  • Source/Enums.cobra

     
    2626        _idToken = Token.empty 
    2727        _attribs = AttributeList() 
    2828        _nativeType = nativeType 
     29        assert .compiler 
     30        .compiler.backEnd.setUnderlyingType(this) # sets _storageTypeNode 
    2931        #_storageTypeNode = ClrTypeProxy(Enum.getUnderlyingType((_nativeType to ClrNativeType).backEndType))  # TODO: fix native 
    30         _callNativeScanMethod('UnderlyingType') 
    3132        _needScanNativeType = true 
    3233         
    33     def _callNativeScanMethod(tag as String) 
    34         """ 
    35         Call a backend scan method for native type scan operation desired and backend in use. 
    36         """ 
    37         _needScanNativeType = true 
    38         # This is icky too - method to call needs to be set directly via backend somehow rather than this check and call code    
    39         # TODO: change to use strategy object set when init backend. 
     34    def _scanNativeType 
    4035        assert .compiler 
    41         assert tag in ['ScanNativeType', 'UnderlyingType'] 
    42         backEnd = .compiler.backEnd 
    43         branch backEnd.name 
    44             on 'c#-clr' 
    45                 branch tag 
    46                     on 'UnderlyingType',  _setUnderlyingTypeClr # sets _storageTypeNode 
    47                     on 'ScanNativeType',  _scanNativeTypeClr 
    48             on 'java-jvm' 
    49                 branch tag 
    50                     on 'UnderlyingType',  _setUnderlyingTypeJvm # sets _storageTypeNode 
    51                     on 'ScanNativeType',  _scanNativeTypeJvm 
    52             on 'objc' 
    53                 print 'objc back end need method for [tag]' 
    54                 assert false, 'Missing backEnd infrastructure for [backEnd.getType.name]' 
    55                 #branch on tag 
    56                 #   on 'UnderlyingType',  _setUnderlyingTypeObjc 
    57                 #   on 'ScanNativeType',  _scancNativeTypeObjc 
    58             else  
    59                 throw FallThroughException('No nativeScanMethod code for backend [backEnd.name] [backEnd.getType.name]') 
    60         #TODO: remove all direct uses of ClrNativeType, ClrTypeProxy 
    61          
     36        .compiler.backEnd.scanNativeType(this) 
     37 
    6238    get attributes as AttributeList is override 
    6339        return _attribs 
    6440 
     
    9672            return base.isUsed 
    9773        set 
    9874            base.isUsed = value 
    99             if _needScanNativeType, _callNativeScanMethod('ScanNativeType') 
     75            if _needScanNativeType, _scanNativeType 
    10076 
    10177    get nativeType from var 
    10278     
     
    11389            _storageType = _storageTypeNode.realType 
    11490            if not _storageType.isDescendantOf(.compiler.anyIntType) 
    11591                .throwError('The enumeration storage type must be a primitive integer type such as int8, uint8, int16, uint16, int, uint, int64 or uint64.') 
    116         if _needScanNativeType, _callNativeScanMethod('ScanNativeType') 
     92                if _needScanNativeType, _scanNativeType  
    11793 
    11894    def _bindImp is override 
    11995        base._bindImp 
     
    127103        return name 
    128104 
    129105    def memberForName(name as String) as IMember? 
    130         if _needScanNativeType, _callNativeScanMethod('ScanNativeType') 
     106        if _needScanNativeType, _scanNativeType  
    131107        m = base.memberForName(name) 
    132108        if m is nil 
    133109            objClass = .compiler.objectType 
  • Tests/720-libraries/400-other/216-use-lib-with-no-ref-extension-error.cobra

     
    11 
    2 use Foo.Bar.dll # .error. Do not end a namespace name in a "use" directive with ".dll". 
     2use Foo.Bar.dll # .error. Do not end a namespace name in a "use" directive with an extension (like ".dll" or ".jar"). 
    33 
    44class X 
    55 
  • Tests/200-misc/280-custom-string-maker.cobra

     
    4848            sw = StringWriter() 
    4949            CobraCore.tracer.destination = sw 
    5050            trace s 
    51             assert sw.toString.startsWith(CobraCore.tracer.prefix + 's=-- special --; at') 
     51            assert sw.toString.startsWith(CobraCore.tracer.prefix + 's=-- special --[CobraCore.tracer.separator]at') 
    5252        finally 
    5353            CobraCore.techStringMaker = save 
    5454 
  • Tests/100-basics/030-hello-world.cobra

     
     1# .require. clr 
    12namespace Test 
    23    class Test 
    34        def main 
  • Tests/100-basics/033-get-property-instance.cobra

     
     1#.require. clr  
    12namespace Test 
    23    class Test 
    34        def main 
  • Tests/100-basics/030j-hello-world1.cobra

     
     1# .require. jvm 
     2namespace Test 
     3    class Test 
     4        def main is shared 
     5            Java.Lang.System.out.println('Hello, world.(Java.Lang.System)') 
     6            #print 'Hello, world. (print)' 
     7             
  • Tests/100-basics/032-get-property-static.cobra

     
     1# .require. clr 
    12namespace Test 
    23    class Test 
    34        def main 
  • Tests/100-basics/032j-get-property-static.cobra

     
     1#.require. jvm 
     2namespace Test 
     3    class Test 
     4        def main 
     5            is shared 
     6            #nl as String = Environment.newLine 
     7            nl as String? = System.getProperty('line.separator') 
     8            nl1 as String? = String.format('%n') 
     9            assert nl == nl1 
     10            pathSep as String? = File.pathSeparator 
     11            sep as String? = Java.Io.File.separator 
     12            print 'pathSep', pathSep 
     13            print 'DirSep', sep 
     14             
     15            CobraCore.noOp(nl, nl1, pathSep) 
     16 
     17            rt = Runtime.runtime # Runtime.getRuntime 
     18            s = rt.totalMemory to ! 
     19            print s, 'bytes' 
     20            #print s/1024/1024, 'MB' 
     21            print rt 
  • Tests/100-basics/033j-get-property-instance.cobra

     
     1# .require. jvm  
     2namespace Test 
     3    class Test 
     4        def main 
     5            is shared 
     6            p = System.getProperties 
     7            #p = System.properties # above as a prop - codegen NYI 
     8 
     9            #nl as String = p['line.separator'] # indexer NYI p.getProperty('') 
     10            nl as String? = p.getProperty('line.separator') 
     11            print '_', nl, '_' 
     12            CobraCore.noOp(nl) 
  • Tests/100-basics/600-backend-names.cobra

     
     1#.require. clr 
     2# chk for leakage from backends. 
     3# Collision or bad typing for variables named using BackEnd (system) namespaces 
     4class BE 
     5    def main 
     6        java = 'java in a string'  # not confused with 'java.lang....' namespace 
     7        #print java 
     8        #print java.typeOf 
     9        assert java.typeOf == System.String 
     10         
     11        # objc is already a reserved keyword 
     12        #objc = 'objcStr' 
     13        #print objc 
     14        #print objc.typeOf 
     15        #assert objc.typeOf == 'System.String' 
     16         
     17        objectC = 91 
     18        #print objectC 
     19        #print objectC.typeOf 
     20        assert objectC.typeOf == System.Int32 
     21     
     22        .objc1 
     23         
     24    def objc1 
     25        objectc = false 
     26        #print objectc 
     27        #print objectc.typeOf 
     28        assert objectc.typeOf == System.Boolean 
  • Tests/100-basics/030j-hello-world.cobra

     
     1# .require. jvm 
     2namespace Test 
     3    class Test 
     4        def main is shared 
     5            System.out.println('Hello, world.( System only)') 
     6            #print 'Hello, world. (print)' 
     7             
  • Tests/100-basics/034-set-property.cobra

     
     1# .require. clr 
    12namespace Test 
    23    class Test 
    34        def main