semicolon

#!/usr/bin/env node

var ops = {
  ';;;': { code: 'push', arg: 'signed'},
  ';;⁏': { code: 'dup' },
  ';⁏;': { code: 'swap' },
  ';⁏⁏': { code: 'discard' },
  '⁏;;': { code: 'add' },
  '⁏;⁏': { code: 'sub' },
  '⁏⁏;': { code: 'mul' },
  '⁏⁏⁏': { code: 'div' },
  '⁏  ': { code: 'mod' },
  '; ;': { code: 'store' },
  '; ⁏': { code: 'retrieve' },
  ' ;;': { code: 'label', arg: 'unsigned' },
  ' ;⁏': { code: 'call', arg: 'unsigned' },
  ' ; ': { code: 'ret' },
  ' ⁏ ': { code: 'jump', arg: 'unsigned' },
  ' ⁏;': { code: 'jz', arg: 'unsigned' },
  ' ⁏⁏': { code: 'jn', arg: 'unsigned' },
  '  ;': { code: 'exit' },
  '⁏ ;;': { code: 'outchar' },
  '⁏ ;⁏': { code: 'outnum' },
  '⁏ ⁏;': { code: 'readchar' },
  '⁏ ⁏⁏': { code: 'readnum' },
};

var code = null, tokens = [], labels = [];

var error = function (msg) {
  console.log(msg);
  process.exit(1);
};

var mkInt = function (str) {
  var ret = '';
  for (var i=0; i<str.length; i++) {
    if (str[i] == ";") {
      ret+= "0";
    } else {
      ret+= "1";
    }
  };
  return parseInt(ret, 2);
};

var scanjumps = function () {
    for (var i=0; i<tokens.length; i++) {
      if (tokens[i][0] == "label") {
        labels[tokens[i][1]] = i;
      }
    }
  }

var tokenize = function () {
  var keys = Object.keys(ops);
  for (var i=0; i<keys.length; i++) {
    var key = keys[i];
    var match = code.match(new RegExp("^" + key + (ops[key].arg ? "([;⁏]*)\\n" : "()") + "([^]*)$"));
    if (match) {
      code = match[2];
      switch(ops[key].arg) {
      case "unsigned":
        return [ops[key].code, mkInt(match[1])];
      case "signed":
        var value = mkInt(match[1].slice(1));
        if (match[1][0] == '⁏') value*= -1;
        return [ops[key].code, value];
      default:
        return [ops[key].code];
      }
    }
  }
  error("Unknown command: " + require('util').inspect(code));
};

var execute = function () {
  var op, arg, stdin = process.openStdin(),
      pc = 0, stack = [], heap = {}, callStack = [];

  process.stdin.setRawMode(true);

  function binOp(s) {
    var a = stack.pop();
    var b = stack.pop();
    stack.push(eval("a"+s+"b"));
  }

  function jump(c) {
    pc = labels[c];
  }

  function run() {
    var running = true;
    while (running) {
      if (tokens[pc]) {
        op = tokens[pc][0];
        arg = tokens[pc][1];
        pc += 1;
      } else {
        op = "exit";
      }

      switch (op) {
      case "push":
        stack.push(arg);
        break;
      case "label":
        break;
      case "dup":
        stack.push(stack[stack.length - 1]);
        break;
      case "outnum":
        process.stdout.write(String(stack.pop()));
        break;
      case "outchar":
        process.stdout.write(new Buffer([stack.pop()]).toString());
        break;
      case "add":
        binOp("+");
        break;
      case "sub":
        binOp("-");
        break;
      case "mul":
        binOp("*");
        break;
      case "div":
        binOp("/");
        break;
      case "mod":
        binOp("%");
        break;
      case "jz":
        if (stack.pop() == 0) jump(arg);
        break;
      case "jn":
        if (stack.pop() < 0) jump(arg);
        break;
      case "jump":
        jump(arg);
        break;
      case "discard":
        stack.pop();
        break;
      case "exit":
        running = false;
        break;
      case "store":
        var value = stack.pop();
        var addr = stack.pop();
        heap[addr] = value;
        break;
      case "call":
        callStack.push(pc);
        jump(arg);
        break;
      case "retrieve":
        stack.push(heap[stack.pop()] || 0);
        break;
      case "ret":
        callStack.pop();
        break;
      case "readchar":
        var charRead = false;
        stdin.on('keypress', function (chunk, key) {
          heap[stack.pop()] = chunk;
          charRead = true;
        });
        while (!charRead) { };
        break;
      case "readnum":
        var numRead = false;
        stdin.on('keypress', function (chunk, key) {
          heap[stack.pop()] = parseInt(chunk);
          numRead = true;
        });
        while (!numRead) { };
        break;
      case "swap":
        var len = stack.length;
        var tmp = stack[len-1];
        stack[len-1] = stack[len-2];
        stack[len-2] = tmp;
        break;
      default:
        error("Unknown opcode: " + op);
        break;
      }
    }
  }

  if (tokens.length > 0) {
    run();
  } 
  process.exit(0);
};

if (process.argv.length == 3) {
  code = require('fs').readFileSync(process.argv[2], 'utf8');
  code = code.replace(/^\/\/[^\n]*\n/gm, '');
  code = code.replace(/[^;⁏ \n]/g, '');

  while (code != "" && code != "\n") {
    tokens.push(tokenize());
  }

  scanjumps();
  execute();
} else {
  error("Usage: semicolon [FILE]");
}