@mfjs/compiler/kit.js

// Generated by CoffeeScript 1.10.0
(function() {
  var assert, config, esast, escodegen, esutils, extend, getLit, kit, matchSingleCallBlock, merge, mkAssign, mkBlock, mkExprStmt, mkFlatBlock, mkFun, mkHalt, mkId, mkIf, mkLit, mkReturn, noThisNeeded, packId, str,
    slice = [].slice;

  kit = module.exports = {};

  config = require("./config");

  escodegen = require("escodegen");

  assert = require("assert");

  esutils = require("esutils");

  esast = esutils.ast;

  kit.block = mkBlock = function(args) {
    var body, i, k, len;
    if (args.length === 1 && args[0].type === "BlockStatement") {
      return args[0];
    }
    body = Array.isArray(args) ? args : [args];
    for (k = 0, len = body.length; k < len; k++) {
      i = body[k];
      assert.ok(i.type != null);
    }
    return {
      type: "BlockStatement",
      body: body
    };
  };

  kit.flatBlock = mkFlatBlock = function() {
    var args, body, flatten, i, k, len;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    if (!args.length) {
      return null;
    }
    body = [];
    flatten = function(cur) {
      var i, k, len, results;
      if (Array.isArray(cur)) {
        results = [];
        for (k = 0, len = cur.length; k < len; k++) {
          i = cur[k];
          results.push(flatten(i));
        }
        return results;
      } else if (cur.type === "BlockStatement") {
        return flatten(cur.body);
      } else {
        return body.push(cur);
      }
    };
    flatten(args);
    if (!body.length) {
      return null;
    }
    if (body.length === 1) {
      return body[0];
    }
    for (k = 0, len = body.length; k < len; k++) {
      i = body[k];
      assert.ok(i.type != null);
    }
    return {
      type: "BlockStatement",
      body: body
    };
  };

  kit.blockStmts = function(stmt) {
    if (stmt.type === "BlockStatement") {
      return stmt.body;
    }
    return [stmt];
  };

  kit.ret = mkReturn = function(argument) {
    return {
      type: "ReturnStatement",
      argument: argument
    };
  };

  kit.call = function(callee, args) {
    if (callee.substr != null) {
      callee = kit.id(callee);
    }
    return {
      type: "CallExpression",
      callee: callee,
      "arguments": args
    };
  };

  kit.id = mkId = function(name) {
    return {
      type: "Identifier",
      name: name
    };
  };

  kit.varDecl = function(n, v) {
    return {
      type: "VariableDeclaration",
      kind: "var",
      declarations: [
        {
          type: "VariableDeclarator",
          id: n,
          init: v
        }
      ]
    };
  };

  kit.packId = packId = function(id) {
    var p;
    p = config.packageVar;
    if (p == null) {
      return id;
    }
    return kit.mem(mkId(p), mkId(id));
  };

  kit.spread = function(fun) {
    return kit.call(kit.packId("spread"), [fun]);
  };

  kit.spreadFun = function(args, fun) {
    if (args.length === 1) {
      if ((fun.$dm$argNum != null) && fun.$dm$argNum > 1 || (fun.params != null) && fun.params.length > 1) {
        return kit.spread(fun);
      }
      return fun;
    }
    if (args.length === 0) {
      return fun;
    }
    return kit.spread(fun);
  };

  kit.spreadApp = function(args, fun) {
    fun = kit.spreadFun(args, fun);
    if (args.length === 0) {
      return [kit.pure(), fun];
    }
    if (args.length === 1) {
      return [args[0], fun];
    }
    return [kit.arrM(args), fun];
  };

  kit.halt = mkHalt = function() {
    return kit.call(kit.id("halt"), []);
  };

  kit.ifte = mkIf = function(test, consequent, alternate) {
    consequent = mkFlatBlock(consequent);
    if (alternate != null) {
      alternate = mkFlatBlock(alternate);
      if ((alternate != null) && (alternate.body != null) && alternate.body.length === 0) {
        alternate = null;
      }
    }
    if (consequent == null) {
      consequent = {
        type: "BlockStatement",
        body: []
      };
    }
    return {
      type: "IfStatement",
      test: test,
      consequent: consequent,
      alternate: alternate
    };
  };

  noThisNeeded = config.noThisNeeded;

  if (noThisNeeded == null) {
    noThisNeeded = {};
  }

  kit.matchEta = function(p, b) {
    var a, c, i, j, k, len, s, x;
    x = matchSingleCallBlock(b.body);
    if (x == null) {
      return;
    }
    c = x.callee;
    if (c.type === "MemberExpression") {
      if (!(c.object.type === "Identifier" && (noThisNeeded[c.object.name] || c.object.name === config.packageVar))) {
        return;
      }
    } else {
      if (c.type !== "Identifier") {
        return;
      }
    }
    a = x["arguments"];
    if (p.length < a.length) {
      return;
    }
    for (s = k = 0, len = a.length; k < len; s = ++k) {
      j = a[s];
      i = p[s];
      if (!(i.type === j.type && j.type === "Identifier")) {
        return;
      }
      if (i.name !== j.name) {
        return;
      }
    }
    x.callee.$dm$argNum = p.length;
    return x.callee;
  };

  matchSingleCallBlock = function(x) {
    if (x.length !== 1) {
      return;
    }
    x = x[0];
    if (x.type !== "ReturnStatement") {
      return;
    }
    x = x.argument;
    if (x == null) {
      return;
    }
    if (x.type !== "CallExpression") {
      return;
    }
    return x;
  };

  kit.fun = mkFun = function(params, stmt) {
    var eta;
    stmt = mkBlock(stmt);
    eta = kit.matchEta(params, stmt);
    if (eta != null) {
      return eta;
    }
    return {
      type: "FunctionExpression",
      params: params,
      body: stmt
    };
  };

  kit.lit = mkLit = function(v) {
    return {
      type: "Literal",
      value: v
    };
  };

  kit.coerce = function(v) {
    return kit.call(packId("coerce"), [mkFun([], v)]);
  };

  kit.mem = function() {
    var i, k, len, p, ref, res;
    p = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    res = p[0];
    assert.ok(res.type != null);
    ref = p.slice(1);
    for (k = 0, len = ref.length; k < len; k++) {
      i = ref[k];
      assert.ok(i.type != null);
      res = {
        type: "MemberExpression",
        object: res,
        property: i
      };
    }
    return res;
  };

  kit.not = function(argument) {
    return {
      type: "UnaryExpression",
      prefix: true,
      operator: "!",
      argument: argument
    };
  };

  kit.eq = function(left, right) {
    return {
      type: "BinaryExpression",
      operator: "===",
      left: left,
      right: right
    };
  };

  kit.arrM = function(args) {
    return kit.call(kit.packId("arr"), [kit.arr(args)]);
  };

  kit.mbind = function(from, fun) {
    var ref;
    assert.ok(Array.isArray(from));
    ref = kit.spreadApp(from, fun), from = ref[0], fun = ref[1];
    assert.ok(fun != null);
    return kit.call(kit.mem(from, mkId("mbind")), [fun]);
  };

  kit["catch"] = function(from, arg, to) {
    var args;
    args = [];
    if (arg != null) {
      args.push(arg);
    }
    return kit.call(kit.mem(from, mkId("mhandle")), [mkFun(args, to)]);
  };

  kit["finally"] = function(from, to) {
    return kit.call(kit.mem(from, mkId("mfinally")), [mkFun([], to)]);
  };

  kit.mapply = function(from, fun) {
    var ref;
    ref = kit.spreadApp(from, fun), from = ref[0], fun = ref[1];
    return kit.call(kit.mem(from, mkId("mapply")), [fun]);
  };

  kit.pure = function() {
    var args, v;
    v = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    args = v;
    if (v.length === 1 && (v[0] == null)) {
      args = [];
    }
    return kit.call(packId("pure"), args);
  };

  kit.exprStmt = mkExprStmt = function(expression) {
    assert.ok(expression != null);
    return {
      type: "ExpressionStatement",
      expression: expression
    };
  };

  kit.assign = mkAssign = function(left, right) {
    return {
      type: "AssignmentExpression",
      operator: "=",
      left: left,
      right: right
    };
  };

  kit.arr = function(els) {
    return {
      type: "ArrayExpression",
      elements: els
    };
  };

  kit.extend = extend = function() {
    var i, j, k, len, n, other, par, pv;
    par = arguments[0], other = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    for (k = 0, len = other.length; k < len; k++) {
      i = other[k];
      if (i != null) {
        for (j in i) {
          n = i[j];
          pv = par[j];
          par[j] = n;
        }
      }
    }
    return par;
  };

  kit.merge = merge = function() {
    var i, j, k, len, n, other, par, ref;
    par = arguments[0], other = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    for (k = 0, len = other.length; k < len; k++) {
      i = other[k];
      if (i != null) {
        for (j in i) {
          n = i[j];
          if (Array.isArray(n)) {
            (ref = (par[j] != null ? par[j] : par[j] = [])).push.apply(ref, n);
          } else if (Object(n) === n && !(n instanceof Function)) {
            merge(par[j] != null ? par[j] : par[j] = {}, n);
          } else {
            par[j] = n;
          }
        }
      }
    }
    return par;
  };

  kit.exprError = function(n, e) {
    var l, res;
    if ((e.loc != null) && (e.loc.start != null)) {
      l = e.loc.start.line;
    }
    if (l != null) {
      n = "Line " + l + ": " + n;
    }
    res = new Error(n, config.filename, l);
    res.loc = e.loc;
    res.lineNumber = l;
    return res;
  };

  kit.errorPos = function(e, f) {
    var error, ex, l;
    try {
      return f();
    } catch (error) {
      ex = error;
      if ((e.loc != null) && (e.loc.start != null)) {
        l = e.loc.start.line;
      }
      ex.loc = e.loc;
      ex.lineNumber = l;
      ex.message = "Line " + l + ": " + ex.message;
      throw ex;
    }
  };

  kit.seqExpr = function() {
    var expressions;
    expressions = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    if (expressions.length === 1) {
      return expressions[0];
    }
    return {
      type: "SequenceExpression",
      expressions: expressions
    };
  };

  kit.seq = function() {
    var exprs;
    exprs = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    if (exprs.length === 1) {
      return exprs[0];
    }
    return kit.call(packId("seq"), exprs);
  };

  kit.getMembersPath = function(e) {
    var res, walk;
    res = [];
    walk = function(e) {
      if (e.type !== "MemberExpression") {
        res.unshift(e);
        return;
      }
      res.unshift(e.property);
      return walk(e.object);
    };
    walk(e);
    return res;
  };

  kit.getMembersPathIds = function(e) {
    return kit.getMembersPath(e).map(kit.getId);
  };

  kit.getId = function(e) {
    if ((e != null) && e.type === "Identifier") {
      return e.name;
    }
    return null;
  };

  kit.coerceThunk = function(block) {
    return kit.call(packId("coerce"), [mkFun([], block)]);
  };

  kit.coerceVal = function(expr) {
    return kit.call(mkId(config.packageVar), [expr]);
  };

  getLit = function(e) {
    if (e.type !== "Literal") {
      return null;
    }
    return e.value;
  };

  kit.toStr = str = function(e) {
    var r;
    r = getLit(e);
    if (!((r != null) && (r.substr != null))) {
      throw kit.exprError("expected string", e);
    }
    return r;
  };

  kit.exprToStr = function(e) {
    if (e.type === "Literal") {
      return e.value;
    }
    throw new Error("cannot convert: " + escodegen.generate(e) + " to string");
  };

  kit.shortNodeDescr = function(s) {
    var end, loc, res, start;
    if (s == null) {
      return "<NULL>";
    }
    res = "";
    res += s.type;
    loc = s.loc;
    if (loc != null) {
      start = loc.start, end = loc.end;
      if (start != null) {
        res += "@" + start.line + ":" + start.column;
      }
      if (end != null) {
        res += "-" + end.line + ":" + end.column;
      }
    }
    return res;
  };

}).call(this);