godprotocol 1.1.32 → 1.2.0

package/Objects/Virtual_machine.js

@@ -1,376 +1,376 @@
-import Callable from "./Callable";
+import Ram from "godprotocol/repos/ram.js";
+import Callable from "./Callable.js";
 
 class Virtual_machine extends Callable {
   constructor(account) {
     super();
 
+    this.envs = new Object()
     this.account = account;
-    this.contexts = new Array();
   }
 
-  read_config = async (addr, options = {}) => {
-    if (typeof addr !== "string") {
-      return addr;
-    }
-    let oracle = this.account.manager.oracle;
-
-    let result = await oracle.read(addr, { current: true, config: true });
-
-    return result;
-  };
+  nodelist = async(config, options={}) => {
+    let {call, list} = options
+    list = list || new Array()
 
-  sync = async () => {};
+    const flatten  = async (config, no_call) =>{
+      if (typeof config === 'string'){
+        config = await this.read_config(config)
+      }
+      switch(config.type){
+        case 'module':
+          for (let b=0; b< config.body.length; b++){
+            let bdy = config.body[b]
+            config.body[b] = await flatten(bdy)
+          }
+          list.push(config)
+          return list
+          break
+        case 'function':
+          if (call && !no_call){
+            for (let p=0; p < config.parameters.length; p++){
+              let param = config.parameters[p]
+              param.location = `${config.address}/${param.identifier}`
+              config.parameters[p] = await flatten(param)
+            }
+            for (let b=0; b < config.body.length; b++){
+              let bdy = config.body[b]
+              await flatten(bdy, true)
+            }
+          }else {
+            list.push({type: 'function', _id: config._id, address: config.address, module: config.module})
+          }
+          
+          return list.length-1
+        case 'class':
+          if(call){
 
-  errors = ['MathError', 'ZeroDivision', 'RuntimeError']
+          }else {
+            list.push({type: 'class', _id: config._id, address: config.address, module: config.module})
+          }
+          return list.length-1
+        case 'return':
+          config.output = await flatten(config.output)
+          list.push(config)
+          return list.length - 1
+        case 'raise':
+          return await flatten(config.object)
+        case 'assignment':
+          let val = await flatten(config.value)
+
+          config.value = val
+          list.push(config)
+          return list.length - 1
+          break;
+        case 'nest':
+          for (let n=0; n< config.nests.length; n++){
+            let nst = config.nests[n]
+            let val = await flatten(nst)
+            config.nests[n] = val 
+          }
+          if(config.assignment){
+            config.assignment = await flatten(config.assignment)
+          }
+          list.push(config)
+          return list.length-1
+        case 'call':
+          let id = await this.read_config(config.identifier)
+          if (id && ['call', 'nest'].includes(id.type)){
+            config.identifier = await flatten(id)
+          }
+          for (let a=0; a< config.arguments.length; a++){
+            let arg = config.arguments[a]
+            config.arguments[a] = await flatten(arg)
+          }
+          list.push(config)
+          return list.length-1
+        case 'trycatch':
+          let try_index = list.length
+          let try_conf = {type:'try', alias: config.alias, location: config.location}
+          list.push(try_conf)
+          for(let i=0; i < config.try_body.length; i++){
+            let bdy = config.try_body[i]
+            let b = await flatten(bdy)
+            config.try_body[i] = b
+          }
+          let catch_index = list.length
+          try_conf.catch_index = catch_index 
+          list.push({type:'catch', objects: config.objects, try_index})
+          for (let i=0; i< config.catch_body.length; i++){
+            let bdy = config.catch_body[i]
+            config.catch_body[i] = await flatten(bdy)
+          }
+          try_conf.catch_offset = -1 + list.length - catch_index;
+          return try_index
+        case 'variable': 
+          list.push(config)
+          return list.length-1
+        case 'reference':
+          list.push(config)
+          return list.length -1
+        case 'address':
+          list.push(config)
+          return list.length -1
+        case 'loop':
+          let loop_config = {type: 'loop', kind: config.loop_type || 'while'}
+          let loop_index = list.length
+          list.push(loop_config)
+          if (config.loop_type === 'for')
+            await flatten(config.iterator)
+          loop_config.condition_index = list.length
+          let cond_index = await flatten(config.condition)
+
+          for (let b=0; b< config.body.length; b++){
+            let bdy = config.body[b]
+            await flatten(bdy)
+          }
+          if (loop_config.kind === 'while'){
+            loop_config.update_jmp = loop_config.condition_index 
+          }else loop_config.update_jmp = list.length
+          if (config.loop_type === 'for'){
+             await flatten(config.update)
+          }
+          list.push({jmp: loop_config.condition_index})
+          list[cond_index].conditional_jmp = list.length
+          list[cond_index].invert = true
+          loop_config.conditional_jmp = list.length;
+          list.push({type: 'endloop', kind: 'unloop'})
+          return loop_index
+        case 'condition':
+          let prior_index, bdys = new Array(), indexx, prior_bdy;
+          for (let b=0; b< config.blocks.length; b++){
+            let blk = config.blocks[b];
+
+            indexx = list.length
+            let index = await flatten(blk.predicate)
+            if (prior_index){
+              list[prior_index].conditional_jmp = indexx
+            }
+            prior_index = index
 
-  handle_error = async(errline, {config, chain})=>{
-    let {objects} = config;
-    for (let o=0; o< objects.length; o++){
-      let err = objects[o], caught, line = errline;
+            prior_bdy;
+            for (let d = 0; d< blk.body.length; d++){
+              let bdy = blk.body[d]
+              prior_bdy = await flatten(bdy)
+            }
 
-      if (line.value.type === 'variable'){
-        if (this.errors.includes(line.value.value)){
-          line = {value: {name: line.value.value}}
-        }else {
-          let res= await this.execute(line.value, {chain, caught: true})
-          if (res.type === 'address'){
-            res = await this.resolve_address(res.value)
+            bdys.push(blk.body.length? prior_bdy: index)
+            list.push({})
+          }
+          if (config.blocks.length === 1){
+            list[prior_index].conditional_jmp = prior_bdy + 1
+          }
+          bdys.map(dy=>{
+            list[dy+1].jmp = list.length
+          })
+          return list.length - 1
+        case 'twain':
+          for (let key in config.value){
+            let [prop, val] = config.value[key]
+            prop = await flatten(prop)
+            val = await flatten(val)
+            config.value[key][0] = prop
+            config.value[key][1] = val
+          }
+          list.push(config)
+          return list.length - 1
+        case 'array':
+          for (let i=0; i< config.value.length; i++){
+            config.value[i] = await flatten(config.value[i])
+          }
+          list.push(config)
+          return list.length - 1
+        default:
+          if (['number', 'string', 'void', 'boolean'].includes(config.type)){
+            list.push(config)
+            return list.length-1
+          }else if (['continue', 'break'].includes(config.type)){
+            list.push(config)
+            return list.length-1
           }
-          line = res;
-        }
-      }else if(typeof line.value === 'string' || line.value.type){
-        let res = await this.execute(line.value, {chain, caught: true, cloth:true})
-        line = res;
       }
+    }
+    let result = await flatten(config)
 
-      if(line){
-        if (line.type === 'instance'){
-          let classifier = await line.get('_classifier_')
-
-          caught = err === classifier
-          if (config.alias){
-            let conf = await this.read_config(config.alias);
-            let hash = await this.account.manager.oracle.hash(conf);
-            await this.execute({...conf, value: {type: 'address', value: line.value.path}}, {chain, hash})
-          }
+    return list
+  }
 
+  read_config = async (addr, options={}) => {
+    if (typeof addr !== "string") {
+      return addr;
+    }
+    addr = addr.split('/')
+    let folder = await this.account.ds.folder(addr.slice(0,-1).join('/'))
+    let result = await folder.readone({_id: addr.slice(-1)[0]})
+    
+    return result;
+  };
 
-        }else if(!line.type){
-          caught = err.endsWith(line.value.name)
-        }
-      }
+  sync = async () => {};
 
-      if(caught){
-        await this.execute_body(config.catch_body, {chain, config: {...config, caught: true}})
-        return true;
-      }
+  throw_error = async(payload)=>{
+    return {
+      __interrupt__: true, 
+      payload,
     }
   }
 
-  execute_body = async (body, options)=>{
-    let {config, chain} = options;
-    let result;
-    for (let b=0; b< body.length; b++){
-      let line = body[b];
-
-      line = await this.execute(line, {...options, line});
-
-      if (line){
-        if (line.interrupt_loop){
-          result =line
-          break;
-        }
-        else if (line.done){
-          result = line.value;
-          break;
-        }else if (line.exit){
-          result = line;
-          break
-        }else if (line.error){
-          if (config.type === 'trycatch'){
-            let res = !config.caught && await this.handle_error(line, {chain, config})
+  execute_body = async (body, options) => {
+    let res;
+    for (let b=0; b < body.length; b++){
+      let line = body[b]
 
-            if(!res){
-              result = line
-            }
-            break
-          }else {
-            result = line;
-            break
-          }
-        }
-        result = line
+      res = await this.execute(line, options)
+      if(res){
+        if (res.done || res.__interrupt__) break
       }
     }
+    return res;
+  };
 
-    return result;
-  }
+  modules = new Array()
 
-  execute = async (config, options = {}) => {
-    let prev_config = config
-    config = await this.read_config(config);
-    // console.log(config, 'EXE')
+  times = new Array()
 
-    let { chain, cloth, hash, obj, call_config } = options,
-      result;
-    hash = hash || (await this.account.manager.oracle.hash(config));
+  curr_field = ()=>{
+    let curr = this.modules.slice(-1)[0]
+    return curr && curr.address
+  }
 
-    switch (config.type) {
-      case "module":
-        result = await this.execute_body(config.body, {chain, config})
+  spawns = new Array();
 
-        break;
-      case "class":
-        if (call_config) {
-          let instance_chain = await chain.chain(call_config.location);
-          let object = {
-            content: [${config.name}],
-            _classifier_: config.address,
-            uid: this.gen_uid(),
-          };
-          for (let name in config.methods) {
-            let addr = config.methods[name];
-            object[name] = addr;
-          }
-          let res = await instance_chain.write(object, { is_instance: true });
-          result = { type: "address", value: res };
-
-          if (object._init_) {
-            await this.execute(
-              { ...call_config, object: result, identifier: object._init_ },
-              { chain }
-            );
-          }
-        }
-        break;
-      case 'adm':
-        let props = await this.execute(config.props, {chain})
-        if(config.name.includes('/')){
-          result = await this.execute({
-            type:'call',
-            identifier: config.name,
-            arguments: [{...props, position: 0}],
-            location: config.location
-          }, {chain})
-        }else {
-          result = await this.native_components(config, chain)
-          result = await this.parse_aircode(result, {config, chain})
-        }
-        break
-      case "function":
-        if (call_config) {
-          let fn_chain = await chain.chain(config.address);
-          let params = new Array();
-          for (let a = 0; a < call_config.arguments.length; a++) {
-            let arg = call_config.arguments[a];
-
-            for (let p = 0; p < config.parameters.length; p++) {
-              let param = await this.read_config(config.parameters[p]);
-
-              if (arg.identifier) {
-              } else {
-                if (p === arg.position) {
-                  param.hash = await this.account.manager.oracle.hash(param);
-                  param.value = arg;
-                  params.push(param);
-                }
-              }
-            }
-          }
-          for (let p = 0; p < params.length; p++) {
-            let param = params[p];
+  execute = async (config, options = {}) => {
+    let {chain, cloth, thread} = options
 
-            await this.execute(param, { chain: fn_chain, hash: param.hash });
-          }
-          if (call_config.object) {
-            let conf = {
-              type: "assignment",
-              identifier: "this",
-              value: call_config.object,
-            };
-            let r = await fn_chain.add_config(conf);
-
-            await this.execute(r, { chain: fn_chain });
-          }
+    config = await this.read_config(config, chain)
+    this.running_thread = thread
+    // console.log(config, 'EXE')
 
-          result = await this.execute_body(config.body, {chain: fn_chain, config})
-        }else result = {type:'address', value: prev_config}
+    let result;
 
-        break;
-      case "return":
-        let ret_value = await this.execute(config.output, { chain });
+    if (!config) return config;
 
-        result = { done: true, value: ret_value };
+    switch (config.type) {
+      case 'module':
+        let mod_chain = await chain.chain(config.location)
+        // result = await this.execute_body(config.body, {chain: mod_chain, config})
+        result = config.body
         break;
-      case "assignment":
-        let ass_chain = await chain.chain(config.identifier);
-        let value = await this.execute(config.value, { chain: ass_chain });
-
-        if (value && value.error){
-          result = value
-        }else {
-          if (value && value.account) {
-            value = { type: "address", value: value.value.path };
-          } else if (typeof value === "string")
-            value = { type: "address", value };
-          result = await ass_chain.write(value, { hash });
+      case 'class':
+        let cls_chn = await chain.chain(config.address)
+        result = await (await cls_chn.folder()).write(config, {replace: true})
+        result = {
+          type: 'function',
+          address: config.address,
+          value: config.address,
+          _id: result._id
         }
-
-        break;
-      case "call":
-        if (config.identifier.type === "nest") {
-          config.identifier = await this.execute(config.identifier.address, {
-            chain,
-          });
+        break
+      case 'function':
+        let fn_chn = await chain.chain(config.address)
+        result = await (await fn_chn.folder()).write(config, {replace: true})
+        result = {
+          type: 'function',
+          address: config.address,
+          value: config.address,
+          _id: result._id
         }
-        for (let a = 0; a < config.arguments.length; a++) {
-          let arg = await this.read_config(config.arguments[a]);
-
-          let obj = await this.execute(
-            arg.type === "assignment" ? arg.value : arg,
-            { chain }
-          );
-          if (obj.account) {
-            obj = { type: "address", value: obj.value.path };
-          }
-          if (arg.type === "assignment") {
-            obj.identifier = arg.identifier;
-          }
-          obj.position = a;
-          config.arguments[a] = obj;
+        break
+      case 'return':
+        result = {
+          __interrupt__: true,
+          type: 'return',
+          output: config.output
         }
-
-        result = await this.execute_call(config, { chain , obj});
-
         break;
       case 'loop':
-        let {loop_type } = config;
-        if (loop_type === 'for'){
-          await this.execute(config.iterator, {chain})
-        }
-        let cond = await this.execute(config.condition, {chain , cloth: true})
-        while(await cond.literal()){
-          result = await this.execute_body(config.body, {config, chain})
-
-          if (result && result.interrupt_loop){
-            if (result.interrupt_loop === 'break'){
-              result = null  
-              break;
-            } else{
-              result = null
-            }
-          }
-          if(loop_type === 'for'){
-            await this.execute(config.update, {chain})
-          }
-          cond = await this.execute(config.condition, {chain , cloth: true})
-        }
+        
+        break;
+      case 'condition':
+        
+        break
+      case 'assignment':
+        let ass_chain = await chain.chain(config.location)
+
+        result = await ass_chain.write(config.value, {addr: true})
+      
+        result = {...config.value, identifier: config.identifier}
 
         break
-      case 'trycatch':
-        result = await this.execute_body(config.try_body, {chain, config})
-        break;
-      case 'raise':
-        result = {error: true, value: config.object}
-        break;
-      case "condition":
-        for (let i = 0; i < config.blocks.length; i++) {
-          let block = config.blocks[i];
-          let pred = await this.execute(block.predicate, {
-            chain,
-            cloth: true,
-          });
-          if (await pred.literal()) {
-            result = await this.execute_body(block.body, {chain, config})
-
-            break;
-          }
-        }
-        break;
-      case "nest":
-        let prev = await this.execute(config.nests[0], { chain, cloth: true }),
-          pprev;
-
-        for (
-          let n = 1;
-          n < config.nests.length - (config.assignment ? 1 : 0);
-          n++
-        ) {
-          let nst = await this.read_config(config.nests[n]);
-          pprev = prev;
-
-          if (nst.type === "call") {
-            let conf =prev.type === 'function'? prev.value: await prev.get(nst.identifier, {obj: prev, config: nst, chain});
-            if (!conf) await this.throw_error();
-            nst.object = { value: prev.value.path, type: "address" };
-            conf.prev_name = nst.identifier
-            prev = await this.execute(
-              { ...nst, identifier: conf.type ==='function'?conf.address:conf },
-              { chain, cloth: true, obj:prev }
-            );
-            if(prev && prev.error){
-              break;
+      case 'nest':
+        let prev = await this.cloth(config.nests[0])
+        result = config.nests[0]
+        for (let i=1; i < config.nests.length - (config.assignment?1:0); i++){
+          let nst = await this.read_config(config.nests[i]), obj;
+
+          if(nst.type === 'call'){
+            obj = await this.execute({
+              type: "string",
+              value: nst.identifier,
+              location: `${nst.location}_`,
+            }, { chain, cloth: true })
+            obj = await prev.get(nst.identifier, {chain, obj, config: nst})
+            if(obj.__interrupt__){
+              result = obj
+              break
+            }else{
+              result = await this.execute({
+                ...nst, identifier: obj
+              }, {chain})
+              prev = await this.cloth(result)
             }
-          } else {
-            let res = await this.execute(nst, { chain, cloth: true });
-            let prop = await res.literal();
-
-            if(prev.type === 'address'){
-              let conf = await this.resolve_address(prev.value)
-              prev = await this.cloth_content(conf)
+          }else{
+            obj = await this.cloth(nst)
+            prev = await prev.get(await obj.literal(), {chain, obj, config: nst})
+
+            if (prev.__interrupt__){
+              result = prev
+              break
+            }else {
+              result = prev;
+              prev = await this.cloth(prev)
             }
-            prev = await prev.get(prop, {obj: res, config: nst, chain});
           }
         }
-        if (config.assignment) {
-          let ass = await this.execute(config.assignment, { chain });
-          let last = config.nests.slice(-1)[0];
-          last = await this.execute(last, { chain, cloth: true });
 
-          await prev.set(last, ass);
-        }
-
-        if (prev && prev.type !== "address") {
-          if(!prev.error)
-          prev = {
-            value: prev.value ? prev.value.path : prev,
-            type: "address",
-            object: prev.value ? null : pprev.value.path,
-          };
+        if (config.assignment){
+          let bull = thread.bullets[thread.pointer]
+          if (result && result.__interrupt__){
+          }else {
+            let last = await this.cloth(config.nests.slice(-1)[0], {just_content: true})
+            if (this.datatypes.includes(last.type)) {
+              let r = await prev.set(config.nests.slice(-1)[0], config.assignment, {chain})
+              bull.assignment_location = r
+              result = config.assignment
+            }
+          }
         }
-        result = prev;
+        break
+      case 'call':
+        result = await this.execute_call(config, {chain, thread})
         break;
       default:
-        if (["number", "string", "boolean", 'twain', 'void', 'array'].includes(config.type)) {
-          result = await this.instantiate(config, { chain, hash });
-          result = { type: "address", value: result };
-        } else if (config.type === "address") {
+        if (this.datatypes.includes(config.type)){
+          result = await this.instantiate(config, {chain})
+        } else if (config.type === 'variable' || config.type === 'reference'){
+          if (!!await this.callable(config.value) || this.datatypes.includes(config.value)){
+            result = {
+              type: 'address',
+              value: config.value,
+              _id: config.value,
+              config: true,
+            }
+          } else result = await this.variable(config.location, {chain, config})
+        } else if(["continue", "break"].includes(config.type)) {
+          config.__interrupt__ = config.type;
           result = config;
-        } else if (config.type === "variable") {
-          let var_chain = await chain.chain(config.location);
-          let res = await var_chain.read({ sibling: true });
-          if (!res) {
-            res = await this.account.manager.oracle.fs.read(
-              ${var_chain.path}/.config
-            );
-            res = { type: "address", value: res.current };
-          }
-          result = res;
-        } else if (config.type === "reference") {
-          let oracle = this.account.manager.oracle;
-          let i_chain = await chain.chain(config.value);
-          let conf = await oracle.fs.read(${i_chain.path}/.config);
-          result = { type: "address", value: conf.current };
-        }else if (['continue', 'break'].includes(config.type)){
-          result = {interrupt_loop: config.type}
         }
     }
 
-    if (result && cloth) {
-      if ( result.type === "address" && result.value.includes('/')) {
-        result = await this.resolve_address(result.value);
-      }
-      if (result && !result.error) result = await this.cloth_content(result);
+    if(result && cloth && !result.__interrupt__){
+      result = await this.cloth(result)
+    }else if (result && config.conditional_jmp){
+      result = await this.cloth(result)
     }
 
     return result;