godprotocol 1.1.1 → 1.1.3

package/Objects/Utils.js

@@ -0,0 +1,16 @@
+class Utils{
+  constructor(){}
+
+  resolve_addr = (addr)=>{
+    if (!addr)return addr;
+
+    if (!addr.startsWith(this.physical_address)){
+      addr = `${this.physical_address}/${addr}`
+    }
+
+    return addr;
+  }
+}
+
+
+export default Utils

package/Objects/Virtual_machine.js

@@ -1,224 +1,360 @@
-import Opcodes from "./Opcodes";
+import Callable from "./Callable";
 
-class Virtual_machine extends Opcodes {
-  constructor(context) {
+class Virtual_machine extends Callable {
+  constructor(account) {
     super();
 
-    this.account = context.account;
-    this.contexts = [context];
-    this.flags = {
-      neg: false,
-      equal: false,
-      zero: false,
-      void: false,
-    };
-
-    this.stacktrace = new Array()
-
-    this.error_manager = new Object()
-  }
-  
-  push_int = (name, payload)=>{
-    let stacks = this.error_manager[name]
-    if (!stacks){
-      stacks = new Array()
-      this.error_manager[name] = stacks;
-    }
-
-    stacks.push(payload)
+    this.account = account;
+    this.contexts = new Array();
   }
 
-  quit = (payload)=>{
-    let instruction = this.track.sequence[this.track.pointer-1]
-
-    let { opcode } = this.split_instruction(instruction);
-    if(opcode==='ret'){
-      this.account.buff({ret:payload.op0}, this.track.pid)
+  read_config = async (addr, options = {}) => {
+    if (typeof addr !== "string") {
+      return addr;
     }
-    this.track.pointer = this.track.sequence.length;
-  }
+    let oracle = this.account.manager.oracle;
 
-  stderr = (err_object)=>{
-    console.log(err_object)
-    let{name, message} = err_object;
+    let result = await oracle.read(addr, { current: true, config: true });
 
-    if (!name){
-      return this.quit(err_object)
-    }
+    return result;
+  };
 
-    let all = this.error_manager['*']
-    let stacks = this.error_manager[name]
+  sync = async () => {};
 
-    if (!stacks){
-      if(all){
-        all = all.slice(-1)[0]
-        let object = this.read_chain(`${this.error_instance_address}/${name}_`)
-        stacks = [{object, metadata: all.metadata, catch_pointer: all.catch_pointer}]
+  errors = ['MathError', 'ZeroDivision', 'RuntimeError']
 
-        if(!object)return this.quit({message: `Unknown Error instance - ${name}`})
-      }
-      
-      if (!stacks)
-      return this.quit(err_object)
-    }else if(all){
-      // Check precedence within all and stacks name, how?
-    }
+  handle_error = async(errline, {config, chain})=>{
+    let {objects} = config;
+    for (let o=0; o< objects.length; o++){
+      let err = objects[o], caught, line = errline;
 
-    let obj_payload, s;
-    for(s = this.stacktrace.length - 1; s >= 0; s--){
-      let trace = this.stacktrace[s]
-      let should_break;
-
-      for (let t = stacks.length-1; t >= 0; t--){
-        obj_payload = stacks[t]
-        if(obj_payload.metadata.namespace === trace){
-          should_break = true
-          break;
+      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)
+          }
+          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;
       }
-      if (should_break) break;
-    }
-
 
-    if (!obj_payload){
-      return this.quit(err_object)
-    }
+      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})
+          }
 
-    if(obj_payload.metadata.alias){
-      // Instantiate error message as an aircode string object.
-      let message_string = `${obj_payload.metadata.namespace}/${this.id_hash(
-        message
-      )}`;
-      this.air_object(message, {
-        location: message_string,
-        callback: () => {
-          this.exec({
-            executable: obj_payload.object.set_message,
-            location: obj_payload.metadata.alias,
-            metadata: {
-              callback: () => {
-                this.slice_trace(s+1)
-
-                this.track = this.account.manager.set_track({account: this.account.name, physical_address: obj_payload.metadata.namespace, pointer: obj_payload.catch_pointer}, true)
-              },
-            },
-            arguments: {
-              argv: [
-                {
-                  address: message_string,
-                  position: 0,
-                },
-              ],
-              argc: 1,
-            },
-          });
-        },
-      });
-     
-    }else {
-      this.slice_trace(s-3)
-      
-      this.track = this.account.manager.set_track({account: this.account.name, physical_address: obj_payload.metadata.namespace, pointer: obj_payload.catch_pointer}, true)
+          
+        }else if(!line.type){
+          caught = err.endsWith(line.value.name)
+        }
+      }
 
+      if(caught){
+        await this.execute_body(config.catch_body, {chain, config: {...config, caught: true}})
+        return true;
+      }
     }
   }
 
-  execute = (instruction, track) => {
-    this.track = track;
-
-    if (!instruction) return;
-
-    let { opcode, args } = this.split_instruction(instruction);
+  execute_body = async (body, options)=>{
+    let {config, chain} = options;
+    let result;
+    for (let b=0; b< body.length; b++){
+      let line = body[b];
 
-    let context = this.get_context(-1);
+      line = await this.execute(line, {...options, line});
 
-    if (!context || opcode === 'pass') return;
-
-    context.add_tx(instruction);
+      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})
+            
+            if(!res){
+              result = line
+            }
+            break
+          }else {
+            result = line;
+            break
+          }
+        }
+        result = line
+      }
+    }
 
-    // console.log(`(${track.pointer}/${track.sequence.length})`)
-    // console.log(`(${track.pointer}/${track.sequence.length-1})>> ${instruction}`)
-    // this.account.log_output(`>> ${instruction}`);
+    return result;
+  }
 
-    let chain;
+  execute = async (config, options = {}) => {
+    let prev_config = config
+    config = await this.read_config(config);
+    // console.log(config, 'EXE')
 
-    args = this.parse_arg(args, opcode);
+    let { chain, cloth, hash, obj, call_config } = options,
+      result;
+    hash = hash || (await this.account.manager.oracle.hash(config));
 
-    switch (opcode) {
-      case "chain":
+    switch (config.type) {
+      case "module":
+        await this.execute_body(config.body, {chain, config})
         
-        chain = this.handle_chain(args, context)
-
-        if(!chain)return this.stderr(`Chain error - ${args}`)
-       
-        this.push_context(chain);
-
-        let dim = context.folder.config.dimensions;
-        if (!dim) {
-          dim = [];
-          context.folder.config.dimensions = dim;
+        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 }
+            );
+          }
         }
-        !dim.find((d) => d === args) && dim.push(args);
+        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];
+
+            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 });
+          }
 
-        chain.append_buffer();
+          result = await this.execute_body(config.body, {chain: fn_chain, config})
+        }else result = {type:'address', value: prev_config}
 
-        process.exit()
         break;
-      case "link":
-        chain = this.handle_chain(args, context)
+      case "return":
+        let ret_value = await this.execute(config.output, { chain });
 
-        if (!chain) {
-         return this.stderr(`LINKing Failed. - ${args}`)
+        result = { done: true, value: ret_value };
+        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 });
+        }
+        
+        break;
+      case "call":
+        if (config.identifier.type === "nest") {
+          config.identifier = await this.execute(config.identifier.address, {
+            chain,
+          });
+        }
+        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;
         }
 
-        chain.append_buffer();
-
-        this.push_context(chain);
+        result = await this.execute_call(config, { chain , obj});
 
         break;
-      case "pop":
-        let blk;
-        if (context.txs.length > 1) {
-          blk = context.mine(this);
-        } else {
-          if (this.account.initiated&& this.account.is_datatype(context)){
-            blk= context.mine(this)
-          }else {
-            blk = context.get_latest_block();
-            if(!blk || context.datapath){
-              if(context.datapath){
-                blk = context.fabricate_datapath_block()
-              }else blk = this.get_voided_block()
+      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 '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})
             
-            if (blk){
-              if (blk.chain.physical_address!== `${this.account.physical_address}/Datatypes/Void`) this.flags.void = false
-
-              this.get_context(-2).connections.push(blk);
+            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;
             }
-
-            context.get_buffer()
-            context.txs = [];
+          } else {
+            let res = await this.execute(nst, { chain, cloth: true });
+            let prop = await res.literal();
+            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 });
 
-        blk && this.account.buff(blk, this.track.pid);
+          await prev.set(last, ass);
+        }
 
-        this.pop_context();
-        break;
-      case "cursor":
-        context.set_cursor(args);
-        break;
-      case "write":
-        context.account.write(args, context);
-        break;
-      case "pass":
+        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,
+          };
+        }
+        result = prev;
         break;
       default:
-        this.prepare_operation(opcode, context);
-        break;
+        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") {
+          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);
+    }
+
+    return result;
   };
 }
 

package/callables/functions/assign.js

@@ -0,0 +1,6 @@
+const assign = async (args, vm, options) => {
+  console.log(args);
+  process.exit();
+};
+
+export default assign;

package/callables/functions/display.js

@@ -0,0 +1,17 @@
+const display = async (args) => {
+  let {data}= args;
+  
+  if(!Array.isArray(data)) data = [data]
+
+  let lit= new Array()
+  for(let d =0; d < data.length; d++){
+    let tum = data[d]
+    lit.push(await tum.literal())
+  }
+
+  console.log(...lit)
+
+  return 0
+};
+
+export default display;

package/callables/functions/exit.js

@@ -0,0 +1,10 @@
+const quit = async(args, vm)=>{
+  let {code} = args;
+  if (code) code = await code.literal()
+
+  console.log(`Program exit with code:${code ||0}`)
+
+  return {exit: true, code}
+}
+
+export default quit

package/callables/functions/net.js

@@ -0,0 +1,27 @@
+import { post_request } from "../../utils/services";
+
+const net = async(args, vm, options={})=>{
+  let {chain, config} = options;
+  let {server, path, payload, callback} = args;
+  
+  server = await server.literal()
+  path = await path.literal()
+  if (!path.startsWith('/')) path = `/${path}`
+
+  payload = payload && await payload.literal()
+
+  let result;
+  if(callback){
+
+  }else {
+    result = await post_request({options: {hostname: server.ip, port: server.port, path}, data: payload})
+    
+    result = await vm.parse_dynamic(result, {chain, config})
+  }
+  
+
+  return result;
+}
+
+
+export default net;

package/callables/functions/twain.js

@@ -0,0 +1,11 @@
+const twain = async(args, vm)=>{
+  if (!args.instance){
+    return await vm.stderr({name: 'Name_error'})
+  }
+  let instance_object = args.instance;
+
+  instance_object.is_literal = true;
+  return instance_object
+}
+
+export default twain;

package/callables/register.js

@@ -0,0 +1,38 @@
+import twain from "./functions/twain";
+import display from "./functions/display";
+import net from "godprotocol/callables/functions/net";
+import quit from "godprotocol/callables/functions/exit";
+
+const register = async (account) => {
+  let set = account.vm.set;
+
+  set("display", {
+    callable: display,
+    config: {
+      parameters: [{ name: "data", position: 0, spread: true }],
+    },
+  });
+
+  set("Twain", {
+    callable: twain,
+    config: {
+      parameters: [{ name: "instance", position: 0 }],
+    },
+  });
+
+  set("net", {
+    callable: net,
+    config: {
+      parameters: [{ name: "server", position: 0 }, { name: "path", position: 0 }, { name: "payload", position: 0 }],
+    },
+  });
+
+  set("exit", {
+    callable: quit,
+    config: {
+      parameters: [{ name: "code", position: 0 }],
+    },
+  });
+};
+
+export default register;