ranger-compiler 2.1.70 → 3.0.3

package/compiler/ColorConsole.clj

@@ -1,22 +0,0 @@
-
-operators {
-    has_console_colors  cmdHasColors:boolean () {
-        templates {
-            es6 @macro(true) ( "true" ) 
-            * @macro(true) ( "false" )
-        }
-    }
-    color_print cmdPrint:void (cname:string text:string) {
-        templates {
-            es6 ("console.log( require('chalk').keyword(" ( e 1 ) ")(" (e 2) "));" )
-            * @macro(true) ( nl "print " (e 2) nl )
-        }       
-    }
-}
-
-class ColorConsole {
-
-    fn out:void (color:string str:string ) {
-        print str
-    }
-}

package/compiler/ContextOperators.clj

@@ -1,75 +0,0 @@
-
-
-operator type:RangerAppWriterContext all {
-
-  fn addUsage:void (cn:CodeNode) {
-    def ctx self
-    def currM ( ctx.getCurrentMethod())
-    if(ctx.isDefinedClass(cn.type_name)) {
-      def cl (ctx.findClass(cn.type_name))
-      currM.addClassUsage(cl ctx)
-    }
-    if(ctx.isDefinedClass(cn.eval_type_name)) {
-      def cl (ctx.findClass(cn.eval_type_name))
-      currM.addClassUsage(cl ctx)
-    }
-    if(ctx.isDefinedClass(cn.eval_array_type)) {
-      def cl (ctx.findClass(cn.eval_array_type))
-      currM.addClassUsage(cl ctx)
-    }
-  }
-
-  fn getTargetLang:string () {
-    if( has self.targetLangName ) {
-        return self.targetLangName
-    }
-    if(self.parent) {
-      return (getTargetLang (unwrap self.parent))
-    }
-    return "ranger"
-  }
-
-  fn addPluginOp( name:string ) {
-    def root (self.getRoot())
-    set self.pluginSpecificOperators name true
-  }
-
-  fn create_var:RangerAppParamDesc ( name:string type_name:string ) {
-      def fieldNode@(lives) (r.vref name type_name)
-      fieldNode.value_type = (fieldNode.typeNameAsType(self))
-      def p@(lives):RangerAppParamDesc (new RangerAppParamDesc ())
-      p.name = name
-      p.value_type = fieldNode.value_type
-      p.node = fieldNode
-      p.nameNode = fieldNode
-      p.is_optional = false
-      self.defineVariable(p.name p)
-      return p
-  }
-  
-  fn create_var:RangerAppParamDesc ( name:string usingNode:CodeNode ) {
-      def fieldNode (r.vref name)
-      def p@(lives):RangerAppParamDesc (new RangerAppParamDesc ())
-      p.name = name
-      p.value_type = usingNode.value_type
-      p.node = usingNode
-      p.nameNode = usingNode
-      p.is_optional = false
-      self.defineVariable(p.name p)
-      return p
-  }
-
-  fn create_register:RangerAppParamDesc ( name:string usingNode:CodeNode ) {
-      def fieldNode (r.vref name)
-      def p@(lives):RangerAppParamDesc (new RangerAppParamDesc ())
-      p.name = name
-      p.value_type = usingNode.value_type
-      p.node = usingNode
-      p.nameNode = usingNode
-      p.is_optional = false
-      self.defineVariable(p.name p)
-      return p
-  }
-
-  
-}

package/compiler/FlowEnterVarDef.clj

@@ -1,223 +0,0 @@
-
-operator type:RangerFlowParser all {
-
-  fn EnterVarDef:void (node@(lives):CodeNode ctx:RangerAppWriterContext wr:CodeWriter) {
-    if (ctx.isInMethod()) {
-
-      if ((size node.children) < 2) {
-        ctx.addError(node "invalid variable definition")
-        return
-      }
-
-      ; print " DEF expr level " + (ctx.expressionLevel()) + " -> " + (node.getCode())
-
-      def tName (node.getSecond())
-      self.CheckTypeAnnotationOf(tName ctx wr)
-
-      ; var x = 100   --> var (= x 100)
-      if( tName.expression ) {
-        remove node.children 1
-        tName.children.forEach({
-          if(index == 1) {
-            if( item.expression ) {
-              push node.children ( (at item.children 0 ) .copy())             
-            } {
-              push node.children ( item.copy())                           
-            }
-          }
-          if(index > 1) {
-            push node.children (item.copy())
-          }
-        })
-      }
-      
-      if ((size node.children) > 3) {
-        ctx.addError(node "invalid variable definition")
-        return
-      }
-      def cn@(lives):CodeNode (at node.children 1)
-      def p:RangerAppParamDesc (new RangerAppParamDesc ())
-      def defaultArg:CodeNode
-      def is_immutable false
-
-      cn.definedTypeClass = (TFactory.new_def_signature(cn ctx wr))
-
-      if ((size node.children) == 2) {
-        if ((cn.value_type != RangerNodeType.Array) && (cn.value_type != RangerNodeType.Hash)) {       
-          if!(cn.hasFlag('unwrap')) {
-            cn.setFlag("optional")           
-          }
-        }
-      }
-      if ((strlen cn.vref) == 0) {
-        ctx.addError(node "invalid variable definition")
-      }
-      if (cn.hasFlag("weak")) {
-        p.changeStrength(0 1 node)
-      } {
-        p.changeStrength(1 1 node)
-      }
-      node.hasVarDef = true
-      if ((size node.children) > 2) {
-        p.init_cnt = 1
-        p.def_value = (at node.children 2)
-        p.is_optional = false
-        defaultArg = (at node.children 2)
-        ctx.setInExpr()
-
-        self.WalkNode( (unwrap defaultArg) ctx wr)
-        ctx.unsetInExpr()
-
-        if (defaultArg.hasFlag("optional")) {
-          cn.setFlag("optional")
-        }
-        if (defaultArg.hasFlag("immutable")) {
-          cn.setFlag("immutable")
-        }
-        if( defaultArg.hasParamDesc ) {
-          def paramDesc (unwrap defaultArg.paramDesc)
-          if( !null? paramDesc.propertyClass) {
-            if( paramDesc.propertyClass.nameNode.hasFlag("immutable") ) {
-              ; TODO: add hash support
-              if (defaultArg.eval_type == RangerNodeType.Array || defaultArg.eval_type == RangerNodeType.Hash) {
-                is_immutable = true
-;                ctx.addError( node "creating a mutable copy of immutable array is currently not permitted")
-              }              
-            }        
-          }
-          if( paramDesc.is_immutable) {
-            is_immutable = true
-          }
-        }
-        if (defaultArg.eval_type == RangerNodeType.Array) {
-          node.op_index = 1
-        }
-        if (cn.value_type == RangerNodeType.Enum) {
-          cn.eval_type_name = (at defaultArg.ns 0)
-        }
-        if (cn.value_type == RangerNodeType.Char) {
-          if ((defaultArg.eval_type != RangerNodeType.Integer) && (defaultArg.eval_type != RangerNodeType.Char)) {
-            ctx.addError( (unwrap defaultArg) ('Char should be assigned char or integer value --> ' + (defaultArg.getCode())))
-          } {
-            defaultArg.eval_type = RangerNodeType.Char
-          }
-        }
-      } {
-        if ((cn.value_type != RangerNodeType.Hash) && (cn.value_type != RangerNodeType.Array) && (false == (cn.hasFlag("optional")))) {
-          if(cn.hasFlag('unwrap')) {
-          } {
-            cn.setFlag("optional")
-          }
-        }
-      }
-      ; simple local variable type inference
-      if ((size node.children) > 2) {
-          if( ( (strlen cn.type_name) == 0) && ( (strlen cn.array_type) == 0 ) ) {
-            cn.inferDefTypeFromValue( node )       
-            if(cn.value_type == RangerNodeType.ExpressionType) {
-              cn.eval_type = RangerNodeType.ExpressionType
-            }    
-          }
-      }      
-      
-      ctx.hadValidType(cn)
-      cn.defineNodeTypeTo(cn ctx)
-
-      p.name = cn.vref
-      if (p.value_type == RangerNodeType.NoType) {
-        if ((0 == (strlen cn.type_name)) && (!null? defaultArg)) {
-          p.value_type = defaultArg.eval_type
-          cn.type_name = defaultArg.eval_type_name
-          cn.eval_type_name = defaultArg.eval_type_name
-          cn.value_type = defaultArg.eval_type
-        }
-      } {
-        p.value_type = cn.value_type
-      }
-      p.node = node
-      p.nameNode = cn
-      p.varType = RangerContextVarType.LocalVariable
-      if is_immutable {
-        p.is_immutable = is_immutable
-      }
-      if cn.has_vref_annotation {
-        ctx.log(node "ann" "At a variable -> Found has_vref_annotation annotated reference ")
-        def ann:CodeNode cn.vref_annotation
-        if ((size ann.children) > 0) {
-          def fc:CodeNode (at ann.children 0)
-          ctx.log(node 'ann' ('value of first annotation ' + fc.vref + ' and variable name ' + cn.vref))
-        }
-      }
-      if cn.has_type_annotation {
-        ctx.log(node "ann" "At a variable -> Found annotated reference ")
-        def ann:CodeNode cn.type_annotation
-        if ((size ann.children) > 0) {
-          def fc:CodeNode (at ann.children 0)
-          ctx.log(node 'ann' ('value of first annotation ' + fc.vref + ' and variable name ' + cn.vref))
-        }
-      }
-
-      cn.hasParamDesc = true
-      cn.ownParamDesc = p
-      cn.paramDesc = p
-      node.hasParamDesc = true
-      node.paramDesc = p
-      cn.eval_type = (cn.typeNameAsType(ctx))
-      cn.eval_type_name = cn.type_name
- 
-      if ((size node.children) > 2) {        
-
-        if( has defaultArg.register_name) {
-          def rr ( ctx.getVariableDef(defaultArg.register_name) )
-          if(!null? rr.nameNode) {
-            if(!null? rr.nameNode.expression_value) {
-              cn.expression_value = ( rr.nameNode.expression_value.copy())
-            }
-          }
-        }
-        if(defaultArg.eval_type == RangerNodeType.ExpressionType) {
-          if(!null? defaultArg.expression_value) {
-            cn.expression_value = (defaultArg.expression_value.copy())
-          } {
-            if( defaultArg.hasParamDesc ) {
-              if( (!null? defaultArg.paramDesc.nameNode) && (!null? defaultArg.paramDesc.nameNode.expression_value) ) {
-                cn.eval_type = RangerNodeType.ExpressionType
-                cn.expression_value = (defaultArg.paramDesc.nameNode.expression_value.copy())
-              }
-            }
-          }
-        }
-        
-        if(!null? defaultArg) {
-          self.convertToUnion( cn.eval_type_name (unwrap defaultArg) ctx wr) 
-          if(!null? defaultArg.evalTypeClass) {
-            cn.evalTypeClass = defaultArg.evalTypeClass
-          }
-        }
-        ; TODO: enable this
-        if (cn.eval_type != defaultArg.eval_type) {
-          
-          def b1 (( cn.eval_type == RangerNodeType.Char &&  defaultArg.eval_type == RangerNodeType.Integer ))
-          def b2 ( cn.eval_type == RangerNodeType.Integer &&  defaultArg.eval_type == RangerNodeType.Char )
-          if( false == ( b1 || b2 ) )  {
-            ctx.addError(node ((('Variable was assigned an incompatible type. Types were ' + cn.eval_type) + ' vs ') + defaultArg.eval_type))
-          }          
-        }
-      } {
-        p.is_optional = true
-      }
-      ctx.defineVariable(p.name p)
-      if ((size node.children) > 2) {
-        self.shouldBeEqualTypes(cn (unwrap p.def_value) ctx "Variable was assigned an incompatible type.")
-      }
-      addUsage ctx cn
-    } {
-      def cn:CodeNode (at node.children 1)
-      cn.eval_type = (cn.typeNameAsType(ctx))
-      cn.eval_type_name = cn.type_name
-      if ((size node.children) > 2) {
-        self.shouldBeEqualTypes((at node.children 1) (at node.children 2) ctx "Variable was assigned an incompatible type.")
-      }
-    }
-  }  
-}

package/compiler/InputFileSystem.clj

@@ -1,276 +0,0 @@
-
-Import "stdops.clj"
-Import "CmdParams.clj"
-
-
-class InputFSFolder @serialize(true) {
-  def name ""
-  def data ""
-  def is_folder true
-  def base64bin false
-  def folders:[InputFSFolder]
-  def files:[InputFSFile]
-
-  fn forTree (cb:(_:void (item:InputFSFolder)) ) {
-    cb(this)
-    folders.forEach({
-      item.forTree(cb)
-    })
-  }
-}
-class InputFSFile @serialize(true) {
-  def name ""
-  def data ""
-  def is_folder false
-  def base64bin false
-}
-
-; --> the running environment for the current setup... 
-class InputEnv @serialize(true) {
-  def use_real false
-  def filesystem:InputFSFolder
-  def envVars:[string:string]
-  def commandLine:CmdParams
-
-  fn setEnv (name:string value:string) {
-    set envVars name value
-  }
-}
-
-operator type:void all {
-  fn env_var:string ( env:InputEnv name:string) {
-    if(env.use_real) {
-      if(has env.envVars name) {
-        return (unwrap (get env.envVars name))
-      }
-      def ev (env_var name)
-      if(!null? ev) {
-        return (unwrap ev)
-      }
-      return ''
-    }
-    return (?? (get env.envVars name) '')
-  }
-  fn install_directory:string (env:InputEnv) {
-    if(env.use_real) {
-      return (install_directory)
-    }
-    return '/'
-  }
-  fn current_directory:string (env:InputEnv) {
-    if(env.use_real) {
-      return (current_directory)
-    }
-    return '/'
-  }
-  fn file_exists:boolean (env:InputEnv path:string name:string) {
-    if(env.use_real) {
-      return (file_exists path name)
-    }
-    def fo (find_file env path name)
-    return (!null? fo)
-  }
-
-  fn find_file@(optional weak):InputFSFile (env:InputEnv path:string name:string) {
-    def res@(optional):InputFSFile
-    if( path == '/' ){
-      def files (filter env.filesystem.files {
-        return item.name == name
-      })
-      if( has files ) {
-        res = (at files 0) 
-      }
-      return res
-    }
-    def parts (strsplit path '/')
-    def fold (env.filesystem)
-    def i 0
-    while( ( (size parts) > i ) && (!null? fold) ) {
-      def pathName (at parts i)
-      if(has pathName) {
-        def folder (filter fold.folders {
-          return item.name == pathName
-        })
-        if( has folder ) {
-          fold = (at folder 0)
-        } {
-          return res
-        }
-      }
-      i = i + 1
-    }
-    if(!null? fold) {
-      def files (filter fold.files {
-        return item.name == name
-      })
-      if( has files ) {
-        res = (at files 0)
-      }
-    }
-    return res
-  }
-
-  fn write_file:void (env:InputEnv path:string name:string data:string) {
-    if( env.use_real ) {
-      write_file path name data
-      return
-    }
-    print data
-  }
-  
-  fn read_file@(optional):string (env:InputEnv path:string name:string) {
-    if env.use_real {
-      return (read_file path name)
-    } 
-    def resStr@(optional):string
-    def f (find_file env path name)
-    if(!null? f) {
-      resStr = f.data
-    }
-    return resStr
-  }
-  fn create_file@(optional weak):InputFSFile (fs:InputFSFolder name:string) {
-
-    def res@(weak):InputFSFile
-    def files (fs.files.filter({
-      return item.name == name
-    }))
-    def folders (fs.folders.filter({
-      return item.name == name
-    }))
-    if(!( has folders) ) {
-      if(has files) {
-        res = (at files 0)
-      } {
-        def f (new InputFSFile)
-        f.name = name
-        push fs.files f
-        res = f
-      }
-    }
-    return res
-  }
-  fn create_folder@(optional weak):InputFSFolder (fs:InputFSFolder name:string) {
-    def res@(weak):InputFSFolder
-    def files (fs.files.filter({
-      return item.name == name
-    }))
-    def folders (fs.folders.filter({
-      return item.name == name
-    }))
-    if(!( has files) )  {
-      if(has folders) {
-        res = (at folders 0)
-      } {
-        def f (new InputFSFolder)
-        f.name = name
-        push fs.folders f
-        res = f
-      }
-    }
-    return res
-  }
-  fn create_file@(optional weak):InputFSFile (fs:InputFSFolder name:string data:string) {
-    def f (create_file fs name)
-    if(!null? f) {
-      f.data = data
-    }
-    return f
-  }
-}
-
-
-class test_input_filesystem {
-  
-  static fn main() {
-
-    ; compile time pattern matching....
-
-    defn CreateFolder (folder fname) (create_folder (unwrap folder) fname)
-    defn CreateFolder (folder fname) (create_folder folder fname)
-    defn CreateFolder (fname) (create_folder (unwrap env.filesystem) fname)
-  
-    defn CreateFile (folder name data) (create_file folder name data)
-    defn CreateFile (folder name data) (create_file (unwrap folder) name data)
-    defn CreateFile (name data) (create_file (unwrap env.filesystem) name data)
-
-    print "--> started"
-    def env (new InputEnv)
-    env.filesystem = (new InputFSFolder)
-
-    CreateFile 'README2.md' 'Data of readme round here...'
-
-    create_file (unwrap env.filesystem) 'README.md' '# the readme file'
-    set env.envVars 'RANGER_DIR' '/'
-
-    def subF (CreateFolder 'lib' )
-    def someFile (create_file (unwrap subF) 'stdlib.clj' 'Contents of the standard library')
-
-    ; try to create some files...
-    CreateFile subF 'JSON.clj' 'JSON file comes round here...'
-    CreateFile subF 'DOMLib.clj' 'JSON file comes round here...'
-    
-    (CreateFile (CreateFolder subF 'etc' ) 'readme.txt' '...' )
-    (CreateFile (CreateFolder subF 'etc' ) 'notes.txt' '...' )
-
-    print (to_string (env.toDictionary()))
-
-    def data (read_file env '/' 'README.md')
-    if(!null? data) {
-      print " -> data " + (unwrap data)
-    }
-
-    def data (read_file env '/lib/' 'stdlib.clj')
-    if(!null? data) {
-      print " -> data " + (unwrap data)
-    }
-
-    if( (file_exists env '/lib/' 'stdlib.clj')) {
-      print "stdlib does exists"
-    }
-    if( (file_exists env '/lib/etc/' 'readme.txt')) {
-      print "/lib/etc/readme.txt does exists"
-    }
-
-    defn fInfo (x) {
-      def mF:InputFSFolder x
-      print ' folder -> ' + ((mF).name) 
-    }
-    defn fInfo (x) {
-      def mF:InputFSFile x
-      print ' file -> ' + (mF.name) + " size : " + (strlen mF.data)
-    }
-
-    
-    defn ShowThem (f) {
-      def myFold f
-      print "*******************************"
-      print " DIR: " + (? (has myFold.name) myFold.name '/' )
-      ForEach myFold.folders fInfo
-      ForEach myFold.files fInfo
-      ForEach (ConCat myFold.files myFold.folders) (# print '...')
-    }
-
-    defn ShowThem (f) {
-      def myFile:InputFSFile f
-      print " file " + myFile.name
-    }
-
-    env.filesystem.forTree({
-      ShowThem item
-    })
-
-    ; NOTICE: the param...it is there two times...
-
-    defn Tell (something) {
-      def s something
-      print something
-      ret s
-    }
-    ; maybe have to walk the params first or not ? 
-    Tell ( 'say: ' + ( Tell 'It is ok' ) )
-
-
-
-  }
-}

package/compiler/RangerDocs.clj

@@ -1,7 +0,0 @@
-
-
-; testing the documenation generation ideas
-docs {
-
-
-}