godprotocol 1.0.4 → 1.0.6

package/Aircode/main.js

@@ -0,0 +1,94 @@
+import { parse_expression } from "./functions/parse_expression";
+import tokenise from "./functions/tokenise";
+import { kw_conditional } from "./keywords/conditional";
+import { kw_parse } from "./keywords/parse";
+import Global from "./native_classes/global";
+import format_instructions from "./utils/format_instructions";
+
+class Aircode {
+  constructor(account) {
+    this.account = account;
+    this.name = this.account.name;
+    this.globe = new Global(this.name);
+    this.namestack = new Array(this.globe);
+    this.expr_types = [
+      "number",
+      "string",
+      "twain",
+      "array",
+      "boolean",
+      "variable",
+    ];
+    this.open_parens = "([{";
+    this.close_parens = ")]}";
+    this.block_keywords = [
+      "if",
+      "else",
+      "else if",
+      "fn",
+      "class",
+      "for",
+      "while",
+    ];
+  }
+
+  curr_namespace = () => this.namestack.slice(-1)[0];
+
+  tokenise = (code) => {
+    this.tokens = tokenise(code);
+    this.tokens.map((t) => (t.compiler = this));
+  };
+
+  parse = (tokens) => {
+    if (!tokens) {
+      this.globe = new Global(this.name);
+      this.namestack[0] = this.globe;
+    }
+
+    tokens = tokens || this.tokens;
+    let i = 0;
+    let curr_parent = this.curr_namespace();
+
+    while (i < tokens.length) {
+      let token = tokens[i];
+
+      if (this.expr_types.includes(token.type)) {
+        let { obj, pos } = parse_expression(tokens.slice(i), curr_parent, this);
+        i += pos;
+
+        curr_parent.push(obj);
+      } else if (token.type === "keyword") {
+        if (token.value === "parse") {
+          let { obj, pos } = kw_parse(tokens, i, curr_parent, this);
+          i = pos;
+          curr_parent.push(obj);
+        } else if (token.value === "if") {
+          let res = kw_conditional(tokens, i, curr_parent, this);
+        }
+      }
+    }
+  };
+
+  compile = (obj, load) => {
+    obj = obj || this.globe;
+
+    let instructions = new Array();
+
+    obj.generate_assembly(instructions);
+
+    if (load) this.account.load({ instructions });
+
+    return format_instructions(instructions, 1);
+  };
+
+  run = (code, no_run) => {
+    this.tokenise(code);
+    this.parse();
+
+    let payload = { instructions: this.compile() };
+    !no_run && this.account.load(payload);
+    /* no_run && */ console.log(payload.instructions);
+  };
+}
+
+export default Aircode;

package/Aircode/native_classes/Variable.js

@@ -0,0 +1,36 @@
+import Native from "./native";
+
+class Variable extends Native {
+  constructor(token) {
+    super();
+
+    this.token = token;
+    this.name = this.token.value;
+  }
+
+  assign = (obj) => {
+    this.assign_obj = obj;
+  };
+
+  generate_assembly = (sequence) => {
+    sequence.push(
+      this.declaration
+        ? `link ${this.declaration.reference_path()}`
+        : `chain ${this.name}`
+    );
+
+    if (this.assign_obj) this.assign_obj.generate_assembly(sequence);
+    sequence.push(
+      ...[
+        `cursor type`,
+        "write variable",
+        "cursor value",
+        "write {file.content.output:-1}",
+      ]
+    );
+
+    sequence.push(`pop ${this.name}`);
+  };
+}
+
+export default Variable;

package/Aircode/native_classes/datatypes/Number.js

@@ -0,0 +1,20 @@
+import Native from "../native";
+
+class Num extends Native {
+  constructor(token) {
+    super();
+
+    this.token = token;
+    this.name = this.token.value;
+  }
+
+  generate_assembly = (sequence) => {
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Datatypes/Number`
+    );
+    sequence.push(`write ${this.name}`);
+    sequence.push(`pop Datatypes/Number`);
+  };
+}
+
+export default Num;

package/Aircode/native_classes/datatypes/String.js

@@ -0,0 +1,20 @@
+import Native from "../native";
+
+class Str extends Native {
+  constructor(token) {
+    super();
+
+    this.token = token;
+    this.name = this.token.value;
+  }
+
+  generate_assembly = (sequence) => {
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Datatypes/String`
+    );
+    sequence.push(`write ${this.name}`);
+    sequence.push(`pop Datatypes/String`);
+  };
+}
+
+export default Str;

package/Aircode/native_classes/global.js

@@ -0,0 +1,21 @@
+import Native from "./native";
+
+class Global extends Native {
+  constructor(name) {
+    super();
+
+    this.is_global = true;
+    this.name = name;
+    this.path = `./${this.name}`;
+  }
+
+  generate_assembly = (sequence) => {
+    // sequence.push(`chain ${this.name}`);
+
+    this.children.map((c) => c.generate_assembly(sequence));
+
+    // sequence.push(`pop ${this.name}`);
+  };
+}
+
+export default Global;

package/Aircode/native_classes/native.js

@@ -0,0 +1,23 @@
+class Native {
+  constructor() {
+    this.children = new Array();
+  }
+
+  generate_assembly = (sequence) => {};
+
+  reference_path = () => {
+    return this.path;
+  };
+
+  set_parent = (parent) => {
+    this.parent = parent;
+    this.path = `${this.parent.path}/${this.name}`;
+  };
+
+  push = (obj) => {
+    this.children.push(obj);
+    if (obj.set_parent) obj.set_parent(this);
+  };
+}
+
+export default Native;

package/Aircode/native_classes/operators.js

@@ -0,0 +1,47 @@
+import Native from "./native";
+
+let op_to_name = {
+  "+": "add",
+  "-": "subtract",
+  "/": "divide",
+  "*": "multiply",
+};
+
+class Operator extends Native {
+  constructor(token) {
+    super();
+
+    this.token = token;
+    this.name = op_to_name[this.token.value];
+  }
+
+  generate_assembly = (sequence) => {
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Opcodes/${this.name}`
+    );
+
+    sequence.push(`link Datatypes/Twain`);
+    for (let c = 0; c < this.children.length; c++) {
+      let child = this.children[c];
+      child.generate_assembly(sequence);
+      sequence.push(`cursor op${c}`);
+      sequence.push(`write {${"datapath"}:-1}`);
+    }
+    sequence.push("pop");
+
+    sequence.push(`link Datatypes/Twain`);
+    sequence.push("cursor inputs");
+    sequence.push(`write ../{metadata:-1}`);
+
+    sequence.push(this.name);
+    sequence.push(`pop Datatypes/Twain`);
+
+    sequence.push(`cursor {metadata}`);
+    sequence.push(`write {metadata:-1}`);
+
+    sequence.push(`pop Opcodes/${this.name}`);
+  };
+}
+
+export default Operator;
+export { op_to_name };

package/Aircode/native_classes/parse.js

@@ -0,0 +1,42 @@
+import Native from "./native";
+
+class Parse extends Native {
+  constructor(token, obj) {
+    super();
+
+    this.token = token;
+    this.obj = obj;
+    this.name = "stdout";
+  }
+
+  generate_assembly = (sequence) => {
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Opcodes/stdout`
+    );
+
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Datatypes/Twain`
+    );
+    this.obj.generate_assembly(sequence);
+    sequence.push(`cursor op${0}`);
+    sequence.push(`write {${"datapath"}:-1}`);
+
+    sequence.push("pop");
+
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Datatypes/Twain`
+    );
+    sequence.push("cursor inputs");
+    sequence.push(`write ../{datapath:-1}`);
+
+    sequence.push(this.name);
+    sequence.push(`pop Datatypes/Twain`);
+
+    sequence.push(`cursor {datapath}`);
+    sequence.push(`write {datapath:-1}`);
+
+    sequence.push(`pop Opcodes/stdout`);
+  };
+}
+
+export default Parse;

package/Aircode/utils/format_instructions.js

@@ -0,0 +1,36 @@
+class Tree_node {
+  constructor(value) {
+    this.value = value;
+    this.children = [];
+  }
+
+  add_child = (childNode) => {
+    this.children.push(childNode);
+  };
+}
+
+const format_instructions = (instructions, no) => {
+  if (no) return instructions;
+
+  let root = new Tree_node("air");
+  let current = root;
+  let node_stack = [];
+
+  instructions.forEach((instruction) => {
+    let [opcode, operand] = instruction.split(" ", 2);
+
+    if (opcode === "chain" || opcode === "link") {
+      let new_node = new Tree_node(instruction);
+      current.add_child(new_node);
+      node_stack.push(current);
+      current = new_node;
+    } else if (opcode === "pop") {
+      current.add_child(instruction);
+      current = node_stack.pop();
+    } else current.add_child(instruction);
+  });
+
+  return JSON.stringify(root, null, 2);
+};
+
+export default format_instructions;

package/Aircode/utils/traverse.js

@@ -0,0 +1,13 @@
+const traverse = (parent, obj) => {
+  while (true) {
+    for (let c = 0; c < parent.children.length; c++) {
+      let child = parent.children[c];
+
+      if (!child.declaration && child.name === obj.name) return child;
+    }
+    parent = parent.parent;
+    if (!parent) break;
+  }
+};
+
+export { traverse };

package/Index.js

@@ -1,31 +1,31 @@
-import http from "http";
-
 import Account from "./Objects/Account";
+import Manager from "./Objects/Manager";
 import framer from "./framer";
 import opcodes from "./opcodes";
-import Socket_server from "./Socket";
-import { manage_key_pair } from "./utils/gen_key_pair";
-import create_server, { PORT } from "./utils/create_server";
+import create_server from "./utils/create_server";
+
+let manager;
+
+const start = (name, server) => {
+  if (!manager) manager = new Manager();
 
-manage_key_pair();
+  let initiator = new Account(name, manager);
 
-const initiator = new Account(process.env.PUBLIC_KEY);
-let cli_server = process.env.SERVER;
+  create_server(initiator, server);
 
-if (cli_server) {
-  initiator.add_server(cli_server);
-} else {
-  // console.warn("set SERVER in your env.");
-  cli_server = `http://localhost:${PORT}`;
-  initiator.add_server(cli_server);
-}
+  manager.set_intiator(initiator);
 
-framer(initiator);
+  framer(initiator);
+  opcodes(initiator);
 
-opcodes(initiator);
+  return initiator;
+};
 
-create_server(initiator);
+let immanuel = start("immanuel");
 
-Socket_server();
+setTimeout(() => {
+  immanuel.compiler.run("parse 'Hello'");
+}, 2000);
 
-export { initiator };
+export default start;
+export { manager };

package/Objects/Account.js

@@ -1,132 +1,131 @@
-import { Blockchain } from "./Blockchain";
+import Aircode from "../Aircode/main";
+import { hash } from "../utils/hash";
+import { post_request } from "../utils/services";
+import Chain from "./Chain";
+import Filesystem from "./Filesystem";
 import Virtual_machine from "./Virtual_machine";
-import fs from "fs";
-import Emitter from "./Emitter";
 import Folder from "./folder";
-import Frame from "./Frame";
-import File from "./file";
 
-let emitter = new Emitter();
+class Account extends Filesystem {
+  constructor(name, manager) {
+    super();
 
-class Account {
-  constructor(name) {
     this.name = name;
+    this.hash = hash(this.name);
+    this.manager = manager;
 
-    this.path = `./Accounts/${this.name}`;
+    this.physical_address = `${this.base_address}/${this.name}`;
+    this.set_paths();
 
-    this.set_path();
-
-    emitter.listen(this.path, (payload) => {
-      let { aft } = payload;
-
-      aft && aft(this);
-    });
     this.account = this;
+    this.compiler = new Aircode(this);
 
-    this.chain = new Blockchain(this);
-    this.vm = new Virtual_machine(this.chain);
     this.accounts = new Object();
-
     this.servers = new Array();
 
-    this.column = 0;
-    this.folders = new Array();
-    this.files = new Array();
-  }
-
-  add_server = (server) => {
-    this.servers.push(server);
-  };
-
-  get_column = () => {
-    return this.column;
-  };
-
-  set_column = (value) => {
-    this.column = value;
-  };
-
-  get_active_file = () => {
-    let par = this.vm.get_context().hash;
-
-    let file = this.files.find((f) => f.name === par);
-
-    if (!file) {
-      file = new File(par, this);
-      this.files.push(file);
-      this.active_file = file;
-    }
-
-    return file;
-  };
+    this.chain = new Chain(this);
+    this.vm = new Virtual_machine(this.chain);
 
-  folder = (name) => {
-    let folder = new Folder(name, this);
-    folder.account = this;
-    this.folders.push(folder);
+    this.manager.oracle.tree[this.physical_address] = this;
 
-    folder.context = this.vm.get_context();
+    this.chain.generate_hash();
 
-    return folder;
-  };
+    this.data_tracks = new Object();
+  }
 
-  set_path = () => {
-    !fs.existsSync(this.path) && fs.mkdirSync(this.path, { recursive: true });
+  init_folder = (name) => {
+    let fold = new Folder(name, this);
+    return fold;
   };
 
-  frame = (struct) => {
-    let frame = new Frame(struct);
-    frame.to_instruction();
-
-    return frame;
+  get_account = (name) => {
+    let account = this.accounts[name];
+    return account || this;
   };
 
   load = ({ instructions, account }) => {
-    let mgr = this.get_account(account);
-
-    if (!mgr) this.err(`Account:${account} does not exists!`);
-    else mgr.vm.push(instructions);
-  };
-
-  run = (data) => {
-    let { sequence, account } = data || {};
-
     account = this.get_account(account);
 
-    account.vm.push(sequence);
+    this.manager.push({ sequence: instructions, account });
   };
 
-  parse = (data) => {
-    let { sequence, account } = data || {};
-
-    account = this.get_account(account);
+  add_server = (server) => {
+    if (
+      this.servers.find(
+        (s) => s.hostname === server.hostname && s.port === server.port
+      )
+    )
+      return;
 
-    account.vm.push(sequence);
+    this.servers.push(server);
   };
 
-  get_account = (account) => {
-    if (!account || account === this.name) return this;
+  stringify = () => {
+    let obj = {};
 
-    account = this.accounts[account];
-    if (!account) return this;
+    obj.servers = this.servers;
+    obj.name = this.name;
+    obj.data_tracks = this.data_tracks;
+  };
 
-    return account;
+  send = (data, cb, one) => {
+    if (!data) return;
+
+    let servers =
+      typeof one === "string" ? this.data_tracks[one] : this.servers;
+
+    data = data.stringify ? data.stringify() : data;
+
+    let should_break = false;
+    if (servers)
+      for (let s = 0; s < servers.length; s++) {
+        if (should_break) break;
+
+        let server = servers[s];
+
+        if (typeof one === "object")
+          if (one.hostname !== server.hostname || one.port !== server.port)
+            continue;
+
+        post_request(
+          {
+            options: {
+              ...server,
+              path: "/distribute",
+            },
+            data: JSON.stringify(data),
+          },
+          (res) => {
+            let track = this.data_tracks[data.hash];
+            if (!track) {
+              track = new Array();
+              this.data_tracks[data.hash] = track;
+            }
+            track.push(server);
+
+            this.vm.stdin(res);
+
+            if (typeof one === "boolean") {
+              should_break = true;
+            }
+          }
+        );
+
+        if (one) break;
+      }
   };
 
-  create_account = ({ public_key, server }) => {
-    let account = this.accounts[public_key];
-    if (!account) {
-      account = new Account(public_key);
+  account = (name, server) => {
+    let account = this.accounts[name];
 
+    if (!account) {
+      account = new Account(name, this);
       this.accounts[account.name] = account;
     }
-    !account.servers.includes(server) && account.servers.push(server);
+    account.add_server(server);
 
     return account;
   };
-
-  get = (opcode) => this[opcode];
 }
 
 export default Account;
-export { emitter };

package/Objects/Block.js

@@ -0,0 +1,45 @@
+class Block {
+  constructor(chain) {
+    this.chain = chain;
+    this.data = this.chain.txs;
+    this.metadata = {};
+    this.children = new Array();
+  }
+
+  store = () => {
+    let content = this.chain.buffs.splice(-1)[0];
+    if (!content) return;
+
+    let cursors = Object.keys(content).filter(
+      (c) => c.startsWith("{") && c.endsWith("}")
+    );
+    for (let c = 0; c < cursors.length; c++) {
+      let curs = cursors[c];
+
+      this.metadata[curs.slice(1, -1)] = content[curs];
+      delete content[curs];
+    }
+
+    let datapath = this.chain.parent.save(content);
+    this.datapath = datapath;
+  };
+
+  stringify = () => {
+    let obj = {};
+
+    obj.metadata = this.metadata;
+    obj.datapath = this.datapath;
+    obj.timelapse = this.timelapse;
+    obj.index = this.index;
+    obj.hash = this.hash;
+    obj.data = this.data;
+    obj.children = this.children.map(
+      (ch) => new Object({ hash: ch.hash, chain: ch.chain.hash })
+    );
+    obj.chain = this.chain.hash;
+
+    return obj;
+  };
+}
+
+export default Block;