xanascript 2.0.0

package/src/bytecode/compiler.js

@@ -0,0 +1,189 @@
+import { OP } from "./opcodes.js";
+
+export function compile(ast) {
+  const code = [];
+
+  emitNode(ast);
+
+  code.push([OP.HALT]);
+
+  return code;
+
+  function emit(op, arg = null) {
+    code.push([op, arg]);
+  }
+
+  function emitNode(node) {
+    switch (node.type) {
+
+      case "Program":
+        node.body.forEach(emitNode);
+        break;
+
+      case "Block":
+        node.body.forEach(emitNode);
+        break;
+
+      case "Num":
+        emit(OP.PUSH, node.value);
+        break;
+
+      case "Str":
+        emit(OP.PUSH, node.value);
+        break;
+
+      case "Bool":
+        emit(OP.PUSH, node.value);
+        break;
+
+      case "Nil":
+        emit(OP.PUSH, null);
+        break;
+
+      case "Ident":
+        emit(OP.LOAD, node.name);
+        break;
+
+      case "VarDecl":
+        emitNode(node.init);
+        emit(OP.STORE, node.id);
+        break;
+
+      case "Assign":
+        emitNode(node.right);
+        emit(OP.STORE, node.left.name);
+        break;
+
+      case "Binary":
+        emitNode(node.left);
+        emitNode(node.right);
+
+        switch (node.op) {
+          case "+": emit(OP.ADD); break;
+          case "-": emit(OP.SUB); break;
+          case "*": emit(OP.MUL); break;
+          case "/": emit(OP.DIV); break;
+          case "%": emit(OP.MOD); break;
+          case "==": emit(OP.EQ); break;
+          case "!=": emit(OP.NEQ); break;
+          case "<": emit(OP.LT); break;
+          case ">": emit(OP.GT); break;
+          case "<=": emit(OP.LTE); break;
+          case ">=": emit(OP.GTE); break;
+        }
+
+        break;
+
+      case "Unary":
+        emitNode(node.arg);
+        if (node.op === "!") emit(OP.NOT);
+        if (node.op === "-") emit(OP.PUSH, 0); emit(OP.SWAP); emit(OP.SUB);
+        break;
+
+      case "IfStmt": {
+        emitNode(node.test);
+        const jmpfIdx = code.length;
+        emit(OP.JMPF, 0);
+        emitNode(node.cons);
+        if (node.alt) {
+          const jmpIdx = code.length;
+          emit(OP.JMP, 0);
+          code[jmpfIdx][1] = code.length;
+          emitNode(node.alt);
+          code[jmpIdx][1] = code.length;
+        } else {
+          code[jmpfIdx][1] = code.length;
+        }
+        break;
+      }
+
+      case "ForStmt": {
+        if (node.init) emitNode(node.init);
+        const loopStart = code.length;
+        emitNode(node.test);
+        const jmpfIdx = code.length;
+        emit(OP.JMPF, 0);
+        emitNode(node.body);
+        if (node.update) emitNode(node.update);
+        emit(OP.JMP, loopStart);
+        code[jmpfIdx][1] = code.length;
+        break;
+      }
+
+      case "WhileStmt": {
+        const loopStart = code.length;
+        emitNode(node.test);
+        const jmpfIdx = code.length;
+        emit(OP.JMPF, 0);
+        emitNode(node.body);
+        emit(OP.JMP, loopStart);
+        code[jmpfIdx][1] = code.length;
+        break;
+      }
+
+      case "Call": {
+        if (
+          node.callee.type === "Ident" &&
+          node.callee.name === "SOLTA_O_GRITO"
+        ) {
+          for (const arg of node.args) {
+            emitNode(arg);
+          }
+          emit(OP.PRINT, node.args.length);
+          break;
+        }
+
+        if (
+          node.callee.type === "Ident" &&
+          node.callee.name === "FALA_BAIXO"
+        ) {
+          for (const arg of node.args) {
+            emitNode(arg);
+          }
+          emit(OP.WARN, node.args.length);
+          break;
+        }
+
+        for (const arg of node.args) {
+          emitNode(arg);
+        }
+        emitNode(node.callee);
+        emit(OP.CALL, node.args.length);
+        break;
+      }
+
+      case "Member": {
+        emitNode(node.obj);
+        emit(OP.PUSH, node.prop);
+        emit(OP.MEMBER);
+        break;
+      }
+
+      case "IndexExpr": {
+        emitNode(node.obj);
+        emitNode(node.index);
+        emit(OP.INDEX);
+        break;
+      }
+
+      case "ArrayExpr": {
+        for (const item of node.items) {
+          emitNode(item);
+        }
+        emit(OP.PUSH, node.items.length);
+        emit(OP.ARRAY);
+        break;
+      }
+
+      case "ObjectExpr": {
+        for (const p of node.props) {
+          emit(OP.PUSH, p.key);
+          emitNode(p.value);
+        }
+        emit(OP.PUSH, node.props.length * 2);
+        emit(OP.OBJECT);
+        break;
+      }
+    }
+  }
+}

package/src/bytecode/opcodes.js

@@ -0,0 +1,36 @@
+export const OP = {
+  PUSH: 0,
+
+  ADD: 1,
+  SUB: 2,
+  MUL: 3,
+  DIV: 4,
+  MOD: 5,
+
+  STORE: 6,
+  LOAD: 7,
+
+  EQ: 8,
+  NEQ: 9,
+  LT: 10,
+  GT: 11,
+  LTE: 12,
+  GTE: 13,
+  NOT: 14,
+
+  PRINT: 15,
+
+  JMP: 16,
+  JMPF: 17,
+  JMPT: 18,
+
+  CALL: 19,
+  MEMBER: 20,
+  INDEX: 21,
+  ARRAY: 22,
+  OBJECT: 23,
+  SWAP: 24,
+  WARN: 25,
+
+  HALT: 26
+};

package/src/bytecode/vm.js

@@ -0,0 +1,216 @@
+import { OP } from "./opcodes.js";
+
+export function run(code) {
+  const stack = [];
+  const globals = {};
+  let ip = 0;
+  let last = null;
+
+  while (ip < code.length) {
+    const instr = code[ip];
+    const op = instr[0];
+    const arg = instr[1];
+
+    switch (op) {
+
+      case OP.PUSH:
+        stack.push(arg);
+        break;
+
+      case OP.LOAD:
+        stack.push(globals[arg]);
+        break;
+
+      case OP.STORE: {
+        const val = stack.pop();
+        globals[arg] = val;
+        last = val;
+        break;
+      }
+
+      case OP.ADD: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a + b);
+        break;
+      }
+
+      case OP.SUB: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a - b);
+        break;
+      }
+
+      case OP.MUL: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a * b);
+        break;
+      }
+
+      case OP.DIV: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a / b);
+        break;
+      }
+
+      case OP.MOD: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a % b);
+        break;
+      }
+
+      case OP.EQ: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a == b);
+        break;
+      }
+
+      case OP.NEQ: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a != b);
+        break;
+      }
+
+      case OP.LT: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a < b);
+        break;
+      }
+
+      case OP.GT: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a > b);
+        break;
+      }
+
+      case OP.LTE: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a <= b);
+        break;
+      }
+
+      case OP.GTE: {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(a >= b);
+        break;
+      }
+
+      case OP.NOT: {
+        const a = stack.pop();
+        stack.push(!a);
+        break;
+      }
+
+      case OP.JMP:
+        ip = arg;
+        continue;
+
+      case OP.JMPF: {
+        const val = stack.pop();
+        if (!val) {
+          ip = arg;
+          continue;
+        }
+        break;
+      }
+
+      case OP.JMPT: {
+        const val = stack.pop();
+        if (val) {
+          ip = arg;
+          continue;
+        }
+        break;
+      }
+
+      case OP.SWAP: {
+        const a = stack.pop();
+        const b = stack.pop();
+        stack.push(a);
+        stack.push(b);
+        break;
+      }
+
+      case OP.CALL: {
+        const fn = stack.pop();
+        const args = [];
+        for (let i = 0; i < arg; i++) {
+          args.unshift(stack.pop());
+        }
+        last = fn(...args);
+        stack.push(last);
+        break;
+      }
+
+      case OP.MEMBER: {
+        const prop = stack.pop();
+        const obj = stack.pop();
+        stack.push(obj[prop]);
+        break;
+      }
+
+      case OP.INDEX: {
+        const idx = stack.pop();
+        const obj = stack.pop();
+        stack.push(obj[idx]);
+        break;
+      }
+
+      case OP.ARRAY: {
+        const arr = [];
+        for (let i = 0; i < arg; i++) {
+          arr.unshift(stack.pop());
+        }
+        stack.push(arr);
+        break;
+      }
+
+      case OP.OBJECT: {
+        const total = arg;
+        const obj = {};
+        const pairs = [];
+        for (let i = 0; i < total; i++) {
+          pairs.unshift(stack.pop());
+        }
+        for (let i = 0; i < pairs.length; i += 2) {
+          obj[pairs[i]] = pairs[i + 1];
+        }
+        stack.push(obj);
+        break;
+      }
+
+      case OP.PRINT: {
+        const vals = [];
+        for (let i = 0; i < arg; i++) {
+          vals.unshift(stack.pop());
+        }
+        console.log(...vals);
+        break;
+      }
+
+      case OP.WARN: {
+        const vals = [];
+        for (let i = 0; i < arg; i++) {
+          vals.unshift(stack.pop());
+        }
+        console.warn(...vals);
+        break;
+      }
+
+      case OP.HALT:
+        return last;
+    }
+
+    ip++;
+  }
+}