ranger-compiler 2.1.69 → 3.0.3

package/compiler/test_types.clj

@@ -1,143 +0,0 @@
-
-Import "ng_Compiler.clj"
-
-
-class type_test {
-
-    static fn main() {
-        def o (new type_test)
-        o.run()
-    }
-
-    fn run () {
-
-        (def basicTypes ([] 'int' 'string' 'boolean' 'char' 'charbuffer' 'double') )( def enumNode (r.vref 'v_enum') )
-        
-        enumNode.type_name = 'RangerNodeType'
-        enumNode.value_type = RangerNodeType.Enum
-
-        ; function type signature, special func required...
-        def list ([]
-            (r.vref 'x' 'string')
-            (r.vref 'x' 'double')
-            (r.vref 'x' 'int')
-            (r.vref 'x' 'boolean')
-            (r.vref 'x' 'char')
-            (r.vref 'x' 'charbuffer')
-            (r.value 'foobar')
-            (r.value 123)
-            (TUtil.mk_arr ('string'))
-            (TUtil.mk_arr ('boolean'))
-            (TUtil.mk_hash ('string' 'SomeClass'))
-            enumNode
-            (TUtil.newFn ( (TUtil.fnsig('double' 'int' 'int'))) )
-            (TUtil.newFn ( (TUtil.fnsig((TUtil.fnsig('void' 'int' 'int')) 'int' 'int'))) )
-            (TUtil.newFn ( (TUtil.fnsig((TUtil.fnsig('string' 'double' 'boolean')) 'int' 'int'))) )
-            (TUtil.newFn ( (TUtil.fnsig((TUtil.fnsig('string' 'double' 'boolean')) 
-                                       (TUtil.fnsig('SomeObject' 'int' 'boolean'))
-                                       (TUtil.fnsig('Any' 'string' 'boolean'))))))
-        )
-
-        basicTypes.forEach({
-            def arrayNode (r.vref 'arr')
-            arrayNode.value_type = RangerNodeType.Array
-            arrayNode.array_type = item
-            push list arrayNode
-            def k_type item
-            
-            def hNode (r.vref 'hashObj')
-            hNode.value_type = RangerNodeType.Hash
-            hNode.array_type = item
-            hNode.key_type = 'string'
-            push list hNode
-        })
-
-        forEach list {
-            print "TFactory : " + (TFactory.baseSignature( item ))
-        }
-
-    }
-}
-
-
-class TUtil {
-
-    static fn map_node_args:CodeNode (name:string tn@(temp):CodeNode ) {
-        def fnArg (r.vref name)
-        if tn.expression {
-            fnArg = (r.vref 'fn')                
-            fnArg.expression_value = tn
-            fnArg.value_type = RangerNodeType.ExpressionType
-        } {
-            fnArg = tn
-        }
-        return fnArg
-    }
-
-    static fn mk_hash:CodeNode (kType:Any aType:Any) {
-        def aNode (r.vref 'arr')
-        aNode.value_type = RangerNodeType.Hash
-        case kType s:string {
-            aNode.key_type = s
-        }
-        case aType s:string {
-            aNode.array_type = s
-        }
-        case aType tn:CodeNode {
-            aNode = (TUtil.map_node_args ('arr' tn))
-        } 
-        return aNode
-    }
-
-    static fn mk_arr:CodeNode (aType:Any) {
-        def aNode (r.vref 'arr')
-        case aType s:string {
-            aNode.value_type = RangerNodeType.Array
-            aNode.array_type = s
-        }
-        case aType tn:CodeNode {
-            aNode = (TUtil.map_node_args ('arr' tn))
-        } 
-        return aNode
-    }
-
-    static fn newFn:CodeNode (expr@(strong):CodeNode) {
-        def lambdaNode (r.vref 'myFn')
-        lambdaNode.expression_value = expr                  
-        lambdaNode.value_type = RangerNodeType.ExpressionType
-        return lambdaNode
-    }
-
-    static fn fnsig:CodeNode ( p1:Any p2:Any p3:Any) {
-        def fnArg:CodeNode
-        def arg1:CodeNode
-        def arg2:CodeNode
-        case p1 tn:string {
-            fnArg = (r.vref 'fn' tn)
-        } 
-        case p1 tn:CodeNode {
-            fnArg = (TUtil.map_node_args ('arr' tn))
-        } 
-        case p2 tn:string {
-            arg1 = (r.vref 'xyz' tn)
-        } 
-        case p2 tn:CodeNode {
-            arg1 = (TUtil.map_node_args ('xyz' tn))
-        } 
-        case p3 tn:string {
-            arg2 = (r.vref 'yyy' tn)
-        } 
-        case p3 tn:CodeNode {
-            arg2 = (TUtil.map_node_args ('xyz' tn))
-        } 
-        def simpleLambda (r.expression
-                            (unwrap fnArg)
-                            (r.expression
-                                (unwrap arg1)
-                                (unwrap arg2)
-                            )
-                        )
-        return simpleLambda
-    }
-}
-

package/compiler/test_types2.clj

@@ -1,49 +0,0 @@
-
-
-trait MyTrait @params(T S) {
-    def name "foobar"
-    def items:[T]
-}
-
-operator type:MyTrait all {
-    fn push (item:T) {
-        push self.items item
-    }
-}
-
-class type_test {
-
-    static fn main() {
-        def o (new type_test)
-        o.run()
-    }
-
-    fn run () {
-
-        def nt:MyTrait@(int) (new MyTrait@(int))
-        print nt.name
-        push nt 200
-        nt.items.forEach({
-            print " -- " + item
-        })
-        
-        ; immutable vector usage...
-        def vv:Vector@(int) (new Vector@(int))
-        
-        vv = (push vv 1)
-        vv = (push vv 2)
-        
-        def vv2 vv
-        vv2 = (push vv2 3)
-        vv2 = (push vv2 4)
-
-        vv.forEach({
-            print " 1) " + item
-        })
-        vv2.forEach({
-            print " 2) " + item
-        })
-
-    }
-}
-

package/compiler/test_types3.clj

@@ -1,53 +0,0 @@
-
-
-trait MyTrait @params(T S) {
-    def name "foobar"
-    def items:[T]
-}
-
-operator type:MyTrait all {
-    fn push (item:T) {
-        push self.items item
-    }
-}
-
-class type_test {
-
-    static fn main() {
-        def o (new type_test)
-        o.run()
-    }
-
-    fn run () {
-
-        def nt:MyTrait@(int) (new MyTrait@(int))
-        print nt.name
-        push nt 200
-        nt.items.forEach({
-            print " -- " + item
-        })
-
-        def list ([] 1 2 3 4 5)
-        for list value:int i {
-            print "Value : " + value
-            if( value >= 3 ) {
-                break
-            }
-        }
-
-        def newList (filter list {
-;            return ( item < 4)
-            if( item < 4) {
-                return true
-            } 
-            return false
-        })
-
-        newList.forEach({
-            print " - " + item
-        })
-
-
-    }
-}
-

package/compiler/test_var.clj

@@ -1,40 +0,0 @@
-
-; new ... ? 
-operators {
-  create _:int ( BigInt@(keyword):int ) {
-    templates {
-      es6 ('10000')
-    }
-  }
-  test2 _:string ( foo@(keyword) ) {
-    templates {
-      es6 ( '"Fooo"')
-    }
-  }
-}
-
-class test_var {
-  fn value:int () {
-    return 1000
-  }
-  fn showMe (v:int idx:int) {
-    print "v == " + v
-  }
-  static fn main () {
-    var obj = (new test_var)
-    var x = 20 + (obj.value())
-    print " x = " + x
-    print " bigint == " + (create BigInt)
-    print (test2 foo)
-
-    if( x <= 400) {
-      print "x <= 400"
-    } else {
-      print "x > 400"
-    }
-
-    def list ([] 1 2 3)
-    forEach list obj.showMe
-
-  }
-}

package/compiler/tonpm.bat

@@ -1,14 +0,0 @@
-call ranger-compiler -compiler
-
-del /F /Q bin\package\*.*
-call node bin\ng_Compiler.js -compiler -npm -d="bin/package" -nodecli -o=index.ts -copysrc -operatordoc="operators.md"
-call tsc bin\package\index.ts --target es5 --lib es2015
-copy bin\package\*.* ..\..\..\tools\ranger-compiler
-copy Lang.clj ..\..\..\tools\ranger-compiler
-
-call node bin\ng_Compiler.js -compiler -npm -nodemodule -d="bin/lib" -o=index.js 
-copy bin\lib\*.* ..\..\..\tools\ranger-lib
-
-copy README.md ..\..\..\tools\ranger-compiler
-
-

package/compiler/tonpm2.bat

@@ -1,12 +0,0 @@
-rem call ranger-compiler -compiler
-
-call node compiler.js -compiler -npm -d="bin/package" -nodecli -o=index.js -copysrc
-copy bin\package\*.* ..\..\..\tools\ranger-compiler
-copy Lang.clj ..\..\..\tools\ranger-compiler
-
-call node compiler.js -compiler -npm -nodemodule -d="bin/lib" -o=index.js 
-copy bin\lib\*.* ..\..\..\tools\ranger-lib
-
-copy README.md ..\..\..\tools\ranger-compiler
-
-