ranger-compiler 2.1.70 → 3.0.4

package/compiler/TFactory.clj

@@ -1,146 +0,0 @@
-
-Import "TTypes.clj"
-
-; vref annontation:
-;   node@(something)
-; type annotation:
-;   node:Vector@(string)
-
-class TFactory {
-
-  static fn new_class_signature:RangerTypeClass ( node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter ) {
-      def sig node.vref
-      def tc (ctx.getTypeClass (sig))
-      if(null? tc) {
-        def newTC (ctx.addTypeClass (sig))
-        newTC.value_type = node.value_type
-        newTC.is_class = true
-        newTC.name = sig
-        return newTC
-      } 
-      return (unwrap tc)
-  }
-
-  static fn new_lambda_signature:RangerTypeClass ( node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter ) {
-      def sig (TFactory.lambdaSignature(node))
-      def tc (ctx.getTypeClass (sig))
-      if(null? tc) {
-        def newTC (ctx.addTypeClass (sig))
-        newTC.value_type = node.value_type
-        newTC.is_lambda = true
-        newTC.name = sig
-        return newTC
-      } 
-      return (unwrap tc)
-  }
-
-  static fn new_def_signature_from_simple_string:RangerTypeClass ( sig:string ctx:RangerAppWriterContext wr:CodeWriter ) {
-      def tc (ctx.getTypeClass (sig))
-      if(null? tc) {
-        def newTC (ctx.addTypeClass (sig))
-        newTC.is_primitive = (TTypes.isPrimitive( (TTypes.nameToValue(sig)) ))
-        newTC.value_type = (TTypes.nameToValue(sig))
-        newTC.name = sig
-        if( (has sig) == false ) {
-          newTC.is_empty = true
-        }
-        return newTC
-      } 
-      return (unwrap tc)
-  }
-
-  static fn sig:RangerTypeClass ( sig:string ctx:RangerAppWriterContext wr:CodeWriter ) {
-    return (TFactory.new_def_signature_from_simple_string( sig ctx wr ))
-  }
-  
-
-  static fn new_def_signature:RangerTypeClass ( node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter ) {
-      def sig (TFactory.baseSignature(node))
-      def tc (ctx.getTypeClass (sig))
-      if(null? tc) {
-        def newTC (ctx.addTypeClass (sig))
-        newTC.value_type = node.value_type
-        newTC.is_primitive = (TTypes.isPrimitive(node.value_type))
-        if(node.value_type == RangerNodeType.ExpressionType) {
-          newTC.is_lambda = true
-        }
-        if(node.value_type == RangerNodeType.Array) {
-          newTC.arrayType = (TFactory.new_def_signature_from_simple_string(node.array_type ctx wr))
-        }
-        if(node.value_type == RangerNodeType.Hash) {
-          newTC.keyType = (TFactory.new_def_signature_from_simple_string(node.key_type ctx wr))
-          newTC.arrayType = (TFactory.new_def_signature_from_simple_string(node.array_type ctx wr))
-        }
-        newTC.name = sig
-        if( (has sig) == false ) {
-          newTC.is_empty = true
-        }
-        return newTC
-      } 
-      return (unwrap tc)
-  }
-
-  static fn new_scalar_signature:RangerTypeClass ( node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter ) {
-      def sig (TFactory.baseSignature(node))
-      def tc (ctx.getTypeClass (sig))
-      if(null? tc) {
-        def newTC (ctx.addTypeClass (sig))
-        newTC.is_primitive = true
-        newTC.value_type = node.value_type
-        newTC.name = sig
-        return newTC
-      } 
-      return (unwrap tc)
-  }
-
-  static fn type_annotation:string ( node:CodeNode ) {
-    if node.has_type_annotation {
-      return ('@(' + (TFactory.baseSignature( (unwrap node.type_annotation)) ) + ')' )
-    } 
-    return ""
-  }
-
-  static fn lambdaSignature:string (node:CodeNode) {
-    def fnNode (node.getFirst())
-    def argNode (node.getSecond())
-    def s ""
-    s = s + "(_:" + (TFactory.baseSignature( fnNode))
-    s = s + " ("  + (join (map argNode.children {
-        return ("_:" + (TFactory.baseSignature( item )) )
-    } to:[string]) " ") + "))"
-    return s    
-  }
-    
-  static fn baseSignature:string ( node:CodeNode ) {   
-    if( TTypes.isPrimitive( node.value_type ) ) {
-      return (TTypes.valueAsString(node.value_type))
-    }
-    def s:string ""
-    if (node.value_type == RangerNodeType.Array) {
-      s = (s + "[")
-      s = (s + node.array_type)
-      s = (s + "]")
-      return s
-    }
-    if (node.value_type == RangerNodeType.Hash) {
-      s = (s + "[")
-      s = (s + node.key_type)
-      s = (s + ":")
-      s = (s + node.array_type)
-      s = (s + "]")
-      return s
-    }
-    if (node.value_type == RangerNodeType.ExpressionType) {
-      def fnNode (node.expression_value.getFirst())
-      def argNode (node.expression_value.getSecond())
-      s = s + "(_:" + (TFactory.baseSignature( fnNode))
-      s = s + " ("  + (join (map argNode.children {
-          return ("_:" + (TFactory.baseSignature( item )) )
-      } to:[string]) " ") + "))"
-      return s
-    }
-    s = ( node.type_name + (TFactory.type_annotation(node)) )
-    return s
-  }
-    
-}

package/compiler/TFiles.clj

@@ -1,23 +0,0 @@
-
-
-class TFiles {
-
-  static fn searchEnv:string ( env:InputEnv paths:[string] fileName:string) {
-      for paths path:string i {
-          if( file_exists env path fileName ) {
-              return path 
-          }
-      }
-      return ""
-  }   
-
-  static fn search:string (paths:[string] fileName:string) {
-      for paths path:string i {
-          if( file_exists path fileName ) {
-              return path 
-          }
-      }
-      return ""
-  }   
-    
-}

package/compiler/TFlow.clj

@@ -1,39 +0,0 @@
-
-
-class TFlow {
-
-  static fn walkFunctionBody (m@(lives):RangerAppFunctionDesc fnBody:CodeNode subCtx:RangerAppWriterContext wr:CodeWriter) {
-    def pref_fnc subCtx.function_level_context 
-    subCtx.function_level_context = true
-    subCtx.currentMethod = m
-    for m.params v:RangerAppParamDesc i {
-      v.nameNode.eval_type = (v.nameNode.typeNameAsType(subCtx))
-      v.nameNode.eval_type_name = v.nameNode.type_name
-      ctx.hadValidType( (unwrap v.nameNode) )
-    }
-    subCtx.setInMethod()
-    this.WalkNodeChildren(fnBody subCtx wr)
-    subCtx.unsetInMethod()
-    if (fnBody.didReturnAtIndex == -1) {
-      if (cn.type_name != "void") {
-          if( false == (ctx.getFlag("in_task")) ) {
-            ctx.addError(node "Function does not return any values!")
-          }
-      }
-    }
-    for subCtx.localVarNames n:string i {
-      def p:RangerAppParamDesc (get subCtx.localVariables n)
-      if (p.set_cnt > 0) {
-          if(p.is_immutable) {
-            ctx.addError( (unwrap p.nameNode) "Immutable variable was assigned a value")
-          }        
-          def defNode:CodeNode p.node
-          defNode.setFlag("mutable")
-          def nNode:CodeNode p.nameNode
-          nNode.setFlag("mutable")
-      }
-    }      
-    subCtx.function_level_context = pref_fnc
-  }
-
-}

package/compiler/TNodeFactory.clj

@@ -1,84 +0,0 @@
-
-operators {
-    r.op _:CodeNode ( n:string ) {
-        templates {
-            * @macro(true) ("CodeNode.op(" (e 1) ")")
-        }
-    }    
-    r.op _:CodeNode ( n:string v:CodeNode ) {
-        templates {
-            * @macro(true) ("CodeNode.op2(" (e 1) " " (e 2) ")")
-        }
-    }    
-    r.op _@(expands):CodeNode ( n:string v:CodeNode ) {
-        templates {
-            * @macro(true) ("(CodeNode.op3( " (e 1)  "([] _:CodeNode (" nl I
-                ( repeat 2 ( nl (e 1) nl ) ) i nl
-                "))))")
-        }
-    }    
-    r.vref _:CodeNode ( n:string t:string ) {
-        templates {
-            * @macro(true) ("CodeNode.vref2(" (e 1) " " (e 2) ")")
-        }
-    }    
-    r.vref _:CodeNode ( n:string ) {
-        templates {
-            * @macro(true) ("CodeNode.vref1(" (e 1) ")")
-        }
-    }    
-    r.value _:CodeNode ( n:string ) {
-        templates {
-            * @macro(true) ("CodeNode.newStr(" (e 1) ")")
-        }
-    }    
-    r.value _:CodeNode ( n:double ) {
-        templates {
-            * @macro(true) ("CodeNode.newDouble(" (e 1) ")")
-        }
-    }    
-    r.value _:CodeNode ( n:int ) {
-        templates {
-            * @macro(true) ("CodeNode.newInt(" (e 1) ")")
-        }
-    }    
-    r.value _:CodeNode ( n:boolean ) {
-        templates {
-            * @macro(true) ("CodeNode.newBool(" (e 1) ")")
-        }
-    }    
-    r.expression _@(expands):CodeNode ( ) {
-        templates {
-            * @macro(true) ('(CodeNode.expressionNode())')
-        }
-    }   
-    r.expression _:CodeNode ( v:[CodeNode] ) {
-        templates {
-            * @macro(true) ("(CodeNode.fromList( (" (e 1) ") )")
-        }
-    }   
-    r.expression _@(expands):CodeNode ( v:CodeNode ) {
-        templates {
-            * @macro(true) ("(CodeNode.fromList( ([] _:CodeNode (" nl I
-                ( repeat 1 ( nl (e 1) nl ) ) i nl
-                "))))")
-        }
-    }   
-    r.block _@(expands):CodeNode ( ) {
-        templates {
-            * @macro(true) ('(CodeNode.blockNode())')
-        }
-    }   
-    r.block _:CodeNode ( v:[CodeNode]  ) {
-        templates {
-            * @macro(true) ("(CodeNode.blockFromList( (" (e 1) ") ))")
-        }
-    }   
-    r.block _@(expands):CodeNode ( v:CodeNode  ) {
-        templates {
-            * @macro(true) ("(CodeNode.blockFromList( ([] _:CodeNode (" nl I
-                ( repeat 1 ( nl (e 1) nl ) ) i nl
-                "))))")
-        }
-    }   
-}

package/compiler/TTypes.clj

@@ -1,188 +0,0 @@
-class TTypes {
-
-    static fn nameToValue:RangerNodeType (name:string) {
-        switch name {
-            case "double" {
-                return RangerNodeType.Double
-            }
-            case "int" {
-                return RangerNodeType.Integer
-            }
-            case "string" {
-                return RangerNodeType.String
-            }   
-            case "boolean" {
-                return RangerNodeType.Boolean
-            }         
-            case "char" {
-                return RangerNodeType.Char
-            }
-            case "charbuffer" {
-                return RangerNodeType.CharBuffer
-            }
-        }
-        return RangerNodeType.NoType
-    }
-
-;    static fn isNodePrimitive:boolean (node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter) {
-;
-;    }
-
-    static fn isPrimitive:boolean (valueType:RangerNodeType) {
-        switch valueType {
-            case RangerNodeType.Double {
-                return true
-            }
-            case RangerNodeType.String {
-                return true
-            }
-            case RangerNodeType.Integer {
-                return true
-            }
-            case RangerNodeType.Boolean {
-                return true
-            }
-            case RangerNodeType.Char {
-                return true
-            }
-            case RangerNodeType.CharBuffer {
-                return true
-            }
-            case RangerNodeType.Enum {
-                return true
-            }
-        }        
-        return false
-    }
-
-    static fn valueAsString:string (valueType:RangerNodeType) {
-        switch valueType {
-            case RangerNodeType.Double {
-                return "double"
-            }
-            case RangerNodeType.String {
-                return "string"
-            }
-            case RangerNodeType.Integer {
-                return "int"
-            }
-            case RangerNodeType.Boolean {
-                return "boolean"
-            }
-            case RangerNodeType.Char {
-                return "char"
-            }
-            case RangerNodeType.CharBuffer {
-                return "charbuffer"
-            }
-            case RangerNodeType.NoType {
-                return "<no type>"
-            }
-            case RangerNodeType.InvalidType {
-                return "<invalid type>"
-            }
-            case RangerNodeType.Array {
-                return "[]"
-            }
-            case RangerNodeType.Hash {
-                return "[:]"
-            }
-            case RangerNodeType.ImmutableArray {
-                return "ImmutableArray"
-            }
-            case RangerNodeType.ImmutableHash {
-                return "ImmutableHash"
-            }
-            case RangerNodeType.Object {
-                return "Object"
-            }
-            case RangerNodeType.VRef {
-                return "VRef"
-            }
-            case RangerNodeType.Enum {
-                return "Enum"
-            }
-            case RangerNodeType.Comment {
-                return "Comment"
-            }
-            case RangerNodeType.Expression {
-                return "Expression"
-            }
-            case RangerNodeType.ExpressionType {
-                return "ExpressionType"
-            }
-            case RangerNodeType.Lambda {
-                return "Lambda"
-            }
-            case RangerNodeType.XMLNode {
-                return "XMLNode"
-            }
-            case RangerNodeType.XMLText {
-                return "XMLText"
-            }
-            case RangerNodeType.XMLAttr {
-                return "XMLAttr"
-            }
-            case RangerNodeType.XMLCDATA {
-                return "XMLAttr"
-            }
-            case RangerNodeType.Dictionary {
-                return "Dictionary"
-            }
-            case RangerNodeType.Any {
-                return "Any"
-            }
-            case RangerNodeType.Class {
-                return "Class"
-            }
-            case RangerNodeType.GenericClass {
-                return "GenericClass"
-            }
-            case RangerNodeType.ClassRef {
-                return "ClassRef"
-            }
-            case RangerNodeType.Method {
-                return "Method"
-            }
-            case RangerNodeType.ClassVar {
-                return "ClassVar"
-            }
-            case RangerNodeType.Function {
-                return "ClassVar"
-            }
-            case RangerNodeType.Literal {
-                return "Literal"
-            }
-            case RangerNodeType.Quasiliteral {
-                return "Quasiliteral"
-            }
-            case RangerNodeType.Null {
-                return "Null"
-            }
-            case RangerNodeType.ArrayLiteral {
-                return "ArrayLiteral"
-            }
-            default {
-                return "InvalidValueTypeEnum"
-            }
-
-        }        
-        return ""
-    }
-
-    static fn baseTypeAsEval (node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter) {  
-        def vType node.value_type      
-        node.eval_type = vType
-        if( TTypes.isPrimitive( node.value_type) ) {
-            node.eval_type_name = (TTypes.valueAsString(node.value_type))
-        } {
-            def vType node.type_name      
-            node.eval_type_name = vType
-        }
-        def vType1 node.array_type      
-        def vType2 node.key_type      
-        node.eval_array_type = vType1
-        node.eval_key_type = vType2
-    }
-
-}