godprotocol 1.2.25 → 1.2.26

package/Objects/Virtual_machine.js

@@ -1,249 +1,263 @@
-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.envs = new Object();
     this.account = account;
   }
 
-  nodelist = async(config, options={}) => {
-    let {call, list} = options
-    list = list || new Array()
+  nodelist = async (config, options = {}) => {
+    let { call, list } = options;
+    list = list || new Array();
 
-    const flatten  = async (config, no_call) =>{
-      if (typeof config === 'string'){
-        config = await this.read_config(config)
+    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)
+      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)
+          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)
+            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})
+          } else {
+            list.push({
+              type: "function",
+              _id: config._id,
+              address: config.address,
+              module: config.module,
+            });
           }
-          
-          return list.length-1
-        case 'class':
-          if(call){
 
-          }else {
-            list.push({type: 'class', _id: config._id, address: config.address, module: config.module})
+          return list.length - 1;
+        case "class":
+          if (call) {
+          } 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
+          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 
+        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)
+          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)
+          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)
+          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
+          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)
+          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)
+          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)
+          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
+          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++){
+          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
+            indexx = list.length;
+            let index = await flatten(blk.predicate);
+            if (prior_index) {
+              list[prior_index].conditional_jmp = indexx;
             }
-            prior_index = index
+            prior_index = index;
 
             prior_bdy;
-            for (let d = 0; d< blk.body.length; d++){
-              let bdy = blk.body[d]
-              prior_bdy = await flatten(bdy)
+            for (let d = 0; d < blk.body.length; d++) {
+              let bdy = blk.body[d];
+              prior_bdy = await flatten(bdy);
             }
 
-            bdys.push(blk.body.length? prior_bdy: index)
-            list.push({})
+            bdys.push(blk.body.length ? prior_bdy : index);
+            list.push({});
           }
-          if (config.blocks.length === 1){
-            list[prior_index].conditional_jmp = prior_bdy + 1
+          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
+          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;
+        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
+          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
+          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;
           }
       }
-    }
-    let result = await flatten(config)
+    };
+    let result = await flatten(config);
 
-    return list
-  }
+    return list;
+  };
 
-  read_config = async (addr, options={}) => {
+  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]})
-    
+    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;
   };
 
   sync = async () => {};
 
-  throw_error = async(payload)=>{
+  throw_error = async (payload) => {
     return {
-      __interrupt__: true, 
+      __interrupt__: true,
       payload,
-    }
-  }
+    };
+  };
 
   execute_body = async (body, options) => {
     let res;
-    for (let b=0; b < body.length; b++){
-      let line = body[b]
+    for (let b = 0; b < body.length; b++) {
+      let line = body[b];
 
-      res = await this.execute(line, options)
-      if(res){
-        if (res.done || res.__interrupt__) break
+      res = await this.execute(line, options);
+      if (res) {
+        if (res.done || res.__interrupt__) break;
       }
     }
     return res;
   };
 
-  modules = new Array()
+  modules = new Array();
 
-  times = new Array()
+  times = new Array();
 
-  curr_field = ()=>{
-    let curr = this.modules.slice(-1)[0]
-    return curr && curr.address
-  }
+  curr_field = () => {
+    let curr = this.modules.slice(-1)[0];
+    return curr && curr.address;
+  };
 
   spawns = new Array();
 
   execute = async (config, options = {}) => {
-    let {chain, cloth, thread} = options
+    let { chain, cloth, thread } = options;
 
-    config = await this.read_config(config, chain)
-    this.running_thread = thread
+    config = await this.read_config(config, chain);
+    this.running_thread = thread;
     // console.log(config, 'EXE')
 
     let result;
@@ -251,126 +265,152 @@ class Virtual_machine extends Callable {
     if (!config) return config;
 
     switch (config.type) {
-      case 'module':
-        let mod_chain = await chain.chain(config.location)
+      case "module":
+        let mod_chain = await chain.chain(config.location);
         // result = await this.execute_body(config.body, {chain: mod_chain, config})
-        result = config.body
+        result = config.body;
         break;
-      case 'class':
-        let cls_chn = await chain.chain(config.address)
-        result = await (await cls_chn.folder()).write(config, {replace: true})
+      case "class":
+        let cls_chn = await chain.chain(config.address);
+        result = await (
+          await cls_chn.folder()
+        ).write(config, { replace: true });
         result = {
-          type: 'function',
+          type: "function",
           address: config.address,
           value: config.address,
-          _id: result._id
-        }
-        break
-      case 'function':
-        let fn_chn = await chain.chain(config.address)
-        result = await (await fn_chn.folder()).write(config, {replace: true})
+          _id: result._id,
+        };
+        break;
+      case "function":
+        let fn_chn = await chain.chain(config.address);
+        result = await (await fn_chn.folder()).write(config, { replace: true });
         result = {
-          type: 'function',
+          type: "function",
           address: config.address,
           value: config.address,
-          _id: result._id
-        }
-        break
-      case 'return':
+          _id: result._id,
+        };
+        break;
+      case "return":
         result = {
           __interrupt__: true,
-          type: 'return',
-          output: config.output
-        }
+          type: "return",
+          output: config.output,
+        };
+        break;
+      case "loop":
+        break;
+      case "condition":
         break;
-      case 'loop':
-        
+      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 '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 '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)
+      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{
-            obj = await this.cloth(nst)
-            prev = await prev.get(await obj.literal(), {chain, obj, config: nst})
-
-            if (prev.__interrupt__){
-              result = prev
-              break
-            }else {
+          } else {
+            obj = await this.cloth(nst);
+            prev = await prev.get(await obj.literal(), {
+              chain,
+              obj,
+              config: nst,
+            });
+
+            if (prev.__interrupt__) {
               result = prev;
-              prev = await this.cloth(prev)
+              break;
+            } else {
+              result = prev;
+              prev = await this.cloth(prev);
             }
           }
         }
 
-        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 (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
+              let r = await prev.set(
+                config.nests.slice(-1)[0],
+                config.assignment,
+                { chain }
+              );
+              bull.assignment_location = r;
+              result = config.assignment;
             }
           }
         }
-        break
-      case 'call':
-        result = await this.execute_call(config, {chain, thread})
+        break;
+      case "call":
+        result = await this.execute_call(config, { chain, thread });
         break;
       default:
-        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)){
+        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',
+              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)) {
+            };
+          } else
+            result = await this.variable(config.location, { chain, config });
+        } else if (["continue", "break"].includes(config.type)) {
           config.__interrupt__ = config.type;
           result = config;
         }
     }
 
-    if(result && cloth && !result.__interrupt__){
-      result = await this.cloth(result)
-    }else if (result && config.conditional_jmp){
-      result = await this.cloth(result)
+    if (result && cloth && !result.__interrupt__) {
+      result = await this.cloth(result);
+    } else if (result && config.conditional_jmp) {
+      result = await this.cloth(result);
     }
 
     return result;