ranger-compiler 2.1.69 → 3.0.3

package/compiler/ng_RangerAppClassDesc.clj

@@ -1,400 +0,0 @@
-
-class RangerAppMethodVariants {
-  def name:string ""
-  def variants@(weak):[RangerAppFunctionDesc]
-}
-class RangerAppInterfaceImpl {
-  def name:string ""
-  def typeParams:CodeNode
-}
-class RangerTraitParams {
-  def param_names:[string]
-  def values:[string:string]
-}
-class RangerAppClassDesc {
-  Extends (RangerAppParamDesc)
-  def name:string ""
-  def is_system:boolean false
-  def compiledName:string ""
-  def systemNames:[string:string]
-  def systemNodes@(weak):[string:CodeNode]
-  def systemInfo:CodeNode
-  
-  ; --- following could be compined into a enum -type
-  def is_interface:boolean false
-  def is_system_union:boolean false
-  def is_template:boolean false
-  def is_serialized:boolean false
-  def is_trait:boolean false
-  def is_operator_class false
-  def is_generic_instance false
-  def is_union false
-
-  def is_used_by_main false
-  def is_not_used false
-
-  def generic_params:CodeNode
-  def ctx@(weak):RangerAppWriterContext
-  def variables:[RangerAppParamDesc]
-  def capturedLocals@(weak):[RangerAppParamDesc]
-  def methods:[RangerAppFunctionDesc]
-  def defined_methods:[string:boolean]
-  def static_methods:[RangerAppFunctionDesc]
-  def defined_static_methods:[string:boolean]
-  def defined_variants:[string]
-  def method_variants:[string:RangerAppMethodVariants]
-  def has_constructor:boolean false
-  def constructor_node@(weak):CodeNode
-  def constructor_fn:RangerAppFunctionDesc
-  def has_destructor:boolean false
-  def destructor_node:CodeNode
-  def destructor_fn:RangerAppFunctionDesc
-  def extends_classes:[string]
-  def implements_interfaces:[string]
-  def consumes_traits:[string]
-  def trait_params:[string:RangerTraitParams]
-  def is_union_of:[string]
-  def nameNode@(weak):CodeNode
-  def classNode@(weak):CodeNode
-  def contr_writers:[CodeWriter]
-  def is_inherited:boolean false
-
-  fn isClass:boolean () {
-    return true
-  }
-  fn isProperty:boolean () {
-    return false
-  }
-  fn doesInherit:boolean () {
-    return is_inherited
-  }    
-  fn isNormalClass:boolean () {
-    def special ( is_operator_class || is_trait || is_system || is_generic_instance || is_system_union || is_union )
-    return (special == false)
-  }
-  fn hasTrait@(optional weak):RangerAppClassDesc (class_name:string ctx@(weak):RangerAppWriterContext) {
-    def res@(optional):RangerAppClassDesc
-    for consumes_traits c_name:string i {
-      def c:RangerAppClassDesc (ctx.findClass(c_name))
-      if( c_name == class_name) {
-        res = c
-        return res
-      }
-    }
-    return res
-  }
-
-  doc isSameOrParentClass "
-Tests if the `class name` is either
-- same class than the tested class
-- belongs to the same union
-- is either parent or child class of this class
-- implements same trait (interface) than this class
-  "
-  fn isSameOrParentClass:boolean (class_name:string ctx@(weak):RangerAppWriterContext) {
-
-    if(ctx.isPrimitiveType(class_name)) {
-      if ((indexOf is_union_of class_name) >= 0) {
-        return true
-      }    
-      return false      
-    }
-
-    if (class_name == name) {
-      return true
-    }
-    if ((indexOf extends_classes class_name) >= 0) {
-      return true
-    }
-    if ((indexOf consumes_traits class_name) >= 0) {
-      return true
-    }
-    if ((indexOf implements_interfaces class_name) >= 0) {
-      return true
-    }    
-    if ((indexOf is_union_of class_name) >= 0) {
-      return true
-    }    
-    for extends_classes c_name:string i {
-      def c:RangerAppClassDesc (ctx.findClass(c_name))
-      if (c.isSameOrParentClass(class_name ctx)) {
-        return true
-      }
-    }
-    for consumes_traits c_name:string i {
-      def c:RangerAppClassDesc (ctx.findClass(c_name))
-      if (c.isSameOrParentClass(class_name ctx)) {
-        return true
-      }
-    }
-    for implements_interfaces i_name:string i {
-      def c:RangerAppClassDesc (ctx.findClass(i_name))
-      if (c.isSameOrParentClass(class_name ctx)) {
-        return true
-      }      
-    }
-    for is_union_of i_name:string i {
-      ;def c:RangerAppClassDesc (ctx.findClass(i_name))
-      ;if (c.isSameOrParentClass(class_name ctx)) {
-      ;  return true
-      ;}
-      if (ctx.isDefinedClass(i_name)) {
-        def c:RangerAppClassDesc (ctx.findClass(i_name))
-        if (c.isSameOrParentClass(class_name ctx)) {
-          return true
-        }      
-      } {
-        ; print "did not find union class " + i_name
-      }
-    }    
-    return false
-  }
-  fn hasOwnMethod:boolean (m_name:string) {
-    if (has defined_methods m_name) {
-      return true
-    }
-    return false
-  }  
-  fn hasMethod:boolean (m_name:string) {
-    if (has defined_methods m_name) {
-      return true
-    }
-    for extends_classes cname:string i {
-      def cDesc:RangerAppClassDesc (ctx.findClass(cname))
-      if (cDesc.hasMethod(m_name)) {
-        return (cDesc.hasMethod(m_name))
-      }
-    }
-    return false
-  }
-  fn findMethod@(optional weak):RangerAppFunctionDesc (f_name:string) {
-    def res@(weak lives):RangerAppFunctionDesc    
-    def vNames (keys method_variants)
-    for vNames mname:string i {
-      if(mname == f_name) {
-        def list (unwrap (get method_variants mname))
-        res = (itemAt list.variants 0)
-        return res
-      }
-    }
-    for extends_classes cname:string i {
-      def cDesc:RangerAppClassDesc (ctx.findClass(cname))
-      if (cDesc.hasMethod(f_name)) {
-        return (cDesc.findMethod(f_name))
-      }
-    }
-    return res
-  }
-  fn hasStaticMethod:boolean (m_name:string) {
-    return (has defined_static_methods m_name)
-  }
-  fn findStaticMethod@(weak optional):RangerAppFunctionDesc (f_name:string) {
-    def e@(weak lives):RangerAppFunctionDesc
-    for static_methods m:RangerAppFunctionDesc i {
-      if (m.name == f_name) {
-        e = m
-        return e
-      }
-    }
-    for extends_classes cname:string i {
-      def cDesc:RangerAppClassDesc (ctx.findClass(cname))
-      if (cDesc.hasStaticMethod(f_name)) {
-        return (cDesc.findStaticMethod(f_name))
-      }
-    }
-    return e
-  }
-  
-  fn findVariable@(optional weak):RangerAppParamDesc (f_name:string) {
-
-    def e:RangerAppParamDesc
-    for variables m:RangerAppParamDesc i {
-      if (m.name == f_name) {
-        e = m
-        return e
-      }
-    }
-    for extends_classes cname:string i {
-      def cDesc:RangerAppClassDesc (ctx.findClass(cname))
-      return (cDesc.findVariable(f_name))
-    }
-    return e
-  }
-  fn addParentClass:void (p_name:string) {
-    push extends_classes p_name
-  }
-
-  fn createVariable ( node:CodeNode ctx:RangerAppWriterContext wr:CodeWriter ) {
-
-    try {
-
-      def parser (ctx.getParser())
-      def s:string (node.getVRefAt(1))
-      def vDef@(lives):CodeNode (itemAt node.children 1)
-      def p@(temp):RangerAppParamDesc (new RangerAppParamDesc ())
-
-      if(vDef.has_type_annotation) {
-        parser.CheckTypeAnnotationOf( vDef ctx wr )
-      }
-      if( s != ((ctx.transformWord(s)))) {
-        ; ctx.addError( node "Can not use reserved word " + s + " as class propery")
-      }
-      def currC this
-
-      ; immutable classes have only weak properties
-      if currC.is_immutable {
-        vDef.setFlag("weak")
-        if( vDef.value_type == RangerNodeType.Array) {
-          def initNode (node.newExpressionNode())
-          initNode.push( (node.newVRefNode("new")) )
-          def tDef (node.newVRefNode("Vector"))
-          
-          ; Vector@(string)
-          def vAnn (node.newExpressionNode())
-          vAnn.push( (node.newVRefNode(vDef.array_type)))
-          tDef.has_vref_annotation = true
-          tDef.vref_annotation = vAnn
-          initNode.push(tDef)
-
-          set node.children 2 (initNode)
-
-          vDef.value_type = RangerNodeType.VRef
-          vDef.type_name = "Vector"
-          ; def obj:Vector@(string)
-          def tAnn (node.newExpressionNode())
-          tAnn.push( (node.newVRefNode(vDef.array_type)))
-          vDef.has_type_annotation = true
-          vDef.type_annotation = tAnn
-
-          parser.CheckTypeAnnotationOf( vDef ctx wr )
-          parser.CheckVRefTypeAnnotationOf( tDef ctx wr )
-          
-        }
-        if( vDef.value_type == RangerNodeType.Hash) {
-          def initNode (node.newExpressionNode())
-          initNode.push( (node.newVRefNode("new")) )
-          def tDef (node.newVRefNode("Map"))
-          
-          ; Vector@(string)
-          def vAnn (node.newExpressionNode())
-          vAnn.push( (node.newVRefNode(vDef.key_type)))
-          vAnn.push( (node.newVRefNode(vDef.array_type)))
-          tDef.has_vref_annotation = true
-          tDef.vref_annotation = vAnn
-          initNode.push(tDef)
-          set node.children 2 (initNode)
-
-          vDef.value_type = RangerNodeType.VRef
-          vDef.type_name = "Map"
-          ; def obj:Vector@(string)
-          def tAnn (node.newExpressionNode())
-          tAnn.push( (node.newVRefNode(vDef.key_type)))
-          tAnn.push( (node.newVRefNode(vDef.array_type)))
-          vDef.has_type_annotation = true
-          vDef.type_annotation = tAnn
-
-          parser.CheckTypeAnnotationOf( vDef ctx wr )
-          parser.CheckVRefTypeAnnotationOf( tDef ctx wr )
-
-        }
-      }      
-
-      ; transforming reserved words here 
-      p.name = s
-      p.value_type = vDef.value_type
-      p.node = node
-      p.is_class_variable = true
-      p.varType = RangerContextVarType.Property
-      p.node = node
-      p.nameNode = vDef
-      vDef.hasParamDesc = true
-      vDef.ownParamDesc = p
-      vDef.paramDesc = p
-      node.hasParamDesc = true
-      node.paramDesc = p
-
-      if (vDef.hasFlag("weak")) {
-          p.changeStrength(0 2 (unwrap p.nameNode))
-      } {
-          p.changeStrength(2 2 (unwrap p.nameNode))
-      }    
-
-      if ((array_length node.children) > 2) {
-        p.set_cnt = 1
-        p.init_cnt = 1
-        p.def_value = (itemAt node.children 2)
-        p.is_optional = false
-        if(p.def_value.value_type == RangerNodeType.String) {
-          vDef.type_name = "string"
-        }
-        if(p.def_value.value_type == RangerNodeType.Integer) {
-          vDef.type_name = "int"
-        }
-        if(p.def_value.value_type == RangerNodeType.Double) {
-          vDef.type_name = "double"
-        }
-        if(p.def_value.value_type == RangerNodeType.Boolean) {
-          vDef.type_name = "boolean"
-        }
-        def valueNode (itemAt node.children 2)
-        if( (array_length valueNode.children) > 0) {
-          def fc (valueNode.getFirst())
-          if(fc.vref == "new") {
-            def second (valueNode.getSecond())
-            parser.CheckVRefTypeAnnotationOf( second ctx wr )
-          }
-        }
-      } {
-        p.is_optional = true
-        if (false == ((vDef.value_type == RangerNodeType.Array) || (vDef.value_type == RangerNodeType.Hash))) {         
-          vDef.setFlag("optional")
-        }
-      }
-      currC.addVariable(p)
-      def subCtx:RangerAppWriterContext currC.ctx
-      subCtx.defineVariable(p.name p)
-      p.is_class_variable = true
-;      print "^^^^ added variable " + p.name + " to class " + currC.name
-    } {
-      ctx.addError( node ('Could not add variable into class ' + this.name) )
-    }
-  }
-
-  fn addVariable:void (desc@(strong):RangerAppParamDesc) {
-    push variables desc
-    desc.propertyClass = this
-  }
-  fn addMethod:void (desc@(strong):RangerAppFunctionDesc) {
-    set defined_methods desc.name true
-    push methods desc
-
-    def defVs:RangerAppMethodVariants (get method_variants desc.name)
-    if (null? defVs) {
-      def new_v:RangerAppMethodVariants (new RangerAppMethodVariants ())
-      set method_variants desc.name new_v
-      push defined_variants desc.name
-      push new_v.variants desc
-    } {
-      def new_v2:RangerAppMethodVariants (unwrap defVs)
-      push new_v2.variants desc
-    }
-    desc.container_class = this
-  
-  }
-  fn addStaticMethod:void (desc@(strong):RangerAppFunctionDesc) {
-    set defined_static_methods desc.name true
-    push static_methods desc
-
-    if(desc.name == "main") {
-      def nn (desc.nameNode)
-      if(nn.has_vref_annotation == false) {
-        def vAnn (node.newExpressionNode())
-        nn.has_vref_annotation = true
-        nn.vref_annotation = vAnn
-      } 
-      push nn.vref_annotation.children  (nn.vref_annotation.newVRefNode("main"))
-
-    }
-  }
-}
-

package/compiler/ng_RangerAppEnums.clj

@@ -1,86 +0,0 @@
-
-Enum RangerAnnType:int (
-  None
-  Expression
-  Type
-  VRef
-)
-
-Enum RangerMethodCallType:int (
-  None
-  Method
-  Static  
-)
-
-Enum RangerWrap:int (
-  None
-  Optional
-  Unwrap
-)
-
-Enum RangerVForce:int (
-  None
-  Weak
-  Strong
-)
-
-Enum RangerNodeType:int (
-  NoType
-  InvalidType
-  Double
-  Integer
-  String     
-  Boolean      ; 5
-  Array
-  Hash
-  ImmutableArray
-  ImmutableHash
-  Object      ; 10
-  VRef        ; 11
-  Comment
-  Enum
-  Char
-  CharBuffer
-  Expression
-  ExpressionType
-  Lambda
-  XMLNode
-  XMLText
-  XMLAttr
-  XMLCDATA
-  Dictionary
-  Any
-  Class       ; 25
-  GenericClass
-  ClassRef
-  Method
-  ClassVar
-  Function
-  Literal
-  Quasiliteral
-  Null
-  ArrayLiteral
-)
-
-Enum RangerNodeRefType:int (
-  NoType
-  Weak
-  Strong
-  Shared
-  StrongImmutable
-)
-
-Enum RangerContextVarType (
-  NoType
-  This
-  ThisProperty
-  NewObject
-  FunctionParameter
-  LocalVariable
-  Array
-  Object
-  Property
-  Class
-  Function
-)
-

package/compiler/ng_RangerAppFunctionDesc.clj

@@ -1,127 +0,0 @@
-
-operator type:void all {
-  fn r.funcdesc:RangerAppFunctionDesc ( node:CodeNode ctx:RangerAppWriterContext ) {
-    def m@(lives temp):RangerAppFunctionDesc (new RangerAppFunctionDesc ())
-    def cn:CodeNode (node.getSecond())
-    m.name = cn.vref
-    m.compiledName = (ctx.transformWord(cn.vref))
-    m.node = node
-    m.nameNode = (itemAt node.children 1)
-    if (node.hasBooleanProperty("strong")) {
-      m.refType = RangerNodeRefType.Strong
-    } {
-      m.refType = RangerNodeRefType.Weak
-    }
-    return m    
-  }
-}
-class RangerAppFunctionDesc {
-  Extends (RangerAppParamDesc)
-  def name:string ""
-  def ref_cnt:int 0
-  def node@(weak):CodeNode
-  def nameNode@(weak):CodeNode
-  def fnBody@(weak):CodeNode
-  def params:[RangerAppParamDesc]
-  def return_value:RangerAppParamDesc
-  def is_method:boolean false
-  def is_static:boolean false
-  def is_lambda false
-  def is_unsed false
-  def is_called_from_main false
-  def container_class:RangerAppClassDesc
-  def refType:RangerNodeRefType RangerNodeRefType.NoType
-  def fnCtx:RangerAppWriterContext
-
-  def insideFn@(weak):RangerAppFunctionDesc
-  def call_graph_done false
-  def isCalling@(weak):[RangerAppFunctionDesc]
-  def isCalledBy@(weak):[RangerAppFunctionDesc]
-  def isUsingClasses@(weak):[RangerAppClassDesc]
-  def isDirectlyUsingClasses@(weak):[RangerAppClassDesc]
-
-  def myLambdas@(weak):[RangerAppFunctionDesc]
-
-  fn addCallTo( m@(weak):RangerAppFunctionDesc) {
-    if( (indexOf m.isCalledBy this) < 0 ) {
-      push m.isCalledBy this
-      push isCalling m
-    }
-  }
-
-  fn addIndirectClassUsage( m@(weak):RangerAppClassDesc  ctx:RangerAppWriterContext ) {
-    if( (indexOf this.isUsingClasses m) < 0 ) {
-      push this.isUsingClasses m
-      m.variables.forEach({
-        def nn item.nameNode
-        if( ctx.isDefinedClass( nn.type_name )) {
-          def cc (ctx.findClass(nn.type_name))
-          this.addIndirectClassUsage( cc ctx )
-        }
-        if( ctx.isDefinedClass( nn.array_type )) {
-          def cc (ctx.findClass(nn.array_type))
-          this.addIndirectClassUsage( cc ctx )
-        }
-      })      
-    }
-  }
-  
-
-  fn addClassUsage( m@(weak):RangerAppClassDesc  ctx:RangerAppWriterContext ) {
-    if( (indexOf this.isUsingClasses m) < 0 ) {
-      push this.isUsingClasses m
-      push this.isDirectlyUsingClasses m
-      m.variables.forEach({
-        def nn item.nameNode
-        if( ctx.isDefinedClass( nn.type_name )) {
-          def cc (ctx.findClass(nn.type_name))
-          this.addIndirectClassUsage( cc ctx )
-        }
-        if( ctx.isDefinedClass( nn.array_type )) {
-          def cc (ctx.findClass(nn.array_type))
-          this.addIndirectClassUsage( cc ctx )
-        }
-      })      
-    } {
-      if( (indexOf this.isDirectlyUsingClasses m) < 0 ) {
-        push this.isDirectlyUsingClasses m
-      }    
-    }
-  }
-  
-
-  fn forOtherVersions ( ctx:RangerAppWriterContext cb:(_:void (item:RangerAppFunctionDesc))) {
-    if(null? this.container_class) {
-      return
-    }
-    def f this
-    def cc (unwrap f.container_class)
-    cc.extends_classes.forEach({
-      def otherClass (ctx.findClass(item))
-      if(otherClass.hasMethod(f.name)) {
-        def m (otherClass.findMethod(f.name))
-        cb( m )
-      }
-    })
-    def root (ctx.getRoot())
-    root.definedClasses.forEach({
-      if( (indexOf item.extends_classes f.container_class.name) >= 0 ) {
-        if(item.hasMethod(f.name)) {
-          def m (item.findMethod(f.name))
-          cb( m )                
-        }
-      }
-    })
-  }
-
-  fn isFunction:boolean () {
-    return true
-  }  
-  fn isClass:boolean () {
-    return false
-  }
-  fn isProperty:boolean () {
-    return false
-  }  
-}
-

package/compiler/ng_RangerAppMessages.clj

@@ -1,15 +0,0 @@
-Import "ng_RangerAppEnums.clj"
-
-class RangerAppTodo {
-  def description:string ""
-  def todonode@(weak):CodeNode
-}
-
-class RangerCompilerMessage {
-  def error_level:int 0
-  def code_line:int 0
-  def fileName:string ""
-  def description:string ""
-  def node@(weak):CodeNode
-}
-

package/compiler/ng_RangerAppOperatorDesc.clj

@@ -1,20 +0,0 @@
-
-class RangerAppOperatorDesc {
-
-  Extends (RangerAppParamDesc)
-  def name:string ""
-  def ref_cnt:int 0
-  def node@(weak):CodeNode
-  def nameNode@(weak):CodeNode
-  def fnBody@(weak):CodeNode
-  def op_params@(weak):[CodeNode]
-  def firstArg:CodeNode
-
-  fn isOperator:boolean () {
-    return true
-  }  
-  fn isProperty:boolean () {
-    return false
-  }  
-}
-