@mfjs/compiler/stmt.js

// Generated by CoffeeScript 1.10.0
(function() {
  var ActiveScope, ActiveVisitor, DisabledVisitor, Scope, Visitor, assert, commonForIter, commonWhile, isLoop, kit, policy, ref, ref1, rewriteForIter, wrapP;

  kit = require("./kit");

  ref = require("./scope"), Scope = ref.Scope, ActiveScope = ref.ActiveScope;

  policy = require("./policy");

  require("./graph");

  require("./expr");

  assert = require("assert");

  ref1 = require("./visitor"), Visitor = ref1.Visitor, ActiveVisitor = ref1.ActiveVisitor, DisabledVisitor = ref1.DisabledVisitor;

  isLoop = function(stmt) {
    return stmt.type === "ForStatement";
  };

  ActiveVisitor.prototype.LabeledStatement = function(stmt) {
    var block, name, nlab, old, res;
    name = stmt.label.name;
    if (isLoop(stmt.body)) {
      res = this.ctx.stmt(stmt.body, name);
      res.orig = stmt;
      return res;
    }
    old = this.ctx.lab;
    block = this.ctx.controlNode();
    this.ctx.lab = nlab = Object.create(old);
    block.labname = name;
    nlab[name] = {
      brk: block
    };
    block.setLabel("" + name).setBody(this.ctx.stmt(stmt.body, name));
    this.ctx.lab = old;
    return block;
  };

  ActiveVisitor.prototype.ContinueStatement = function(stmt) {
    var l, name;
    name = stmt.label != null ? stmt.label.name : "#";
    l = this.ctx.lab[name];
    if (!((l != null) && (l.cnt != null))) {
      throw new Error("no such label " + name);
    }
    return l.cnt.breakNode();
  };

  ActiveVisitor.prototype.BreakStatement = function(stmt) {
    var l, name;
    name = stmt.label != null ? stmt.label.name : "#";
    l = this.ctx.lab[name];
    if (!((l != null) && (l.brk != null))) {
      throw new Error("no such label " + name);
    }
    return l.brk.breakNode();
  };

  ActiveVisitor.prototype.BlockStatement = function(stmt) {
    return this.ctx.stmts(stmt.body);
  };

  ActiveVisitor.prototype.EmptyStatement = function(stmt) {
    return this.ctx.pureNode([stmt]);
  };

  Visitor.prototype.ExpressionStatement = function(stmt) {
    return this.ctx.expr(stmt.expression).ignoreResult().setOrig(false);
  };

  ActiveVisitor.prototype.IfStatement = function(stmt) {
    var e, i, res, t;
    i = stmt.test, t = stmt.consequent, e = stmt.alternate;
    res = this.ctx.branchedNode(function(t, e) {
      stmt.consequent = t;
      stmt.alternate = e;
      return stmt;
    }, stmt).setOrig(stmt).setDeps(this.ctx.stmt(t), e != null ? this.ctx.stmt(e) : this.ctx.emptyNode());
    return this.ctx.bindNode(res, [this.ctx.expr(i).setPosition([stmt, "test"])]);
  };

  ActiveVisitor.prototype.SwitchStatement = function(stmt) {
    var block, i, j, len, nlab, old, ref2, res, s, x;
    old = this.ctx.lab;
    this.ctx.lab = nlab = Object.create(old);
    res = this.ctx.controlNode();
    nlab["#"] = {
      brk: res
    };
    block = this.ctx.blockNode();
    s = this.ctx.sharedNode(this.ctx.expr(stmt.discriminant), block);
    res.setBody(s);
    ref2 = stmt.cases;
    for (x = j = 0, len = ref2.length; j < len; x = ++j) {
      i = ref2[x];
      if (i.test != null) {
        block.append(this.IfStatement(kit.ifte(kit.eq(s._ref, i.test), i.consequent)));
      } else {
        block.append(this.ctx.stmts(i.consequent));
      }
    }
    return res;
  };

  ActiveVisitor.prototype.ReturnStatement = function(s) {
    var a;
    a = s.argument;
    if (a == null) {
      return this.ctx.root.breakNode();
    }
    return this.ctx.root.breakNode(this.ctx.expr(a));
  };

  Visitor.prototype.postDecl = function(stmt) {
    return this.ctx.pureNode([stmt]);
  };

  ActiveVisitor.prototype.postDecl = function(stmt) {
    this.ctx.glob.decls.push(stmt);
    return this.ctx.emptyNode();
  };

  Visitor.prototype.FunctionDeclaration = function(stmt) {
    var ctx, i, j, len, ref2, ref3, v;
    ctx = this.ctx.subScope(stmt);
    if (stmt.params != null) {
      ref2 = stmt.params;
      for (j = 0, len = ref2.length; j < len; j++) {
        i = ref2[j];
        if (i.name) {
          ctx.vars[i.name] = true;
        }
      }
    }
    if (ctx == null) {
      return this.ctx.pureNode([stmt]);
    }
    ctx.policy = this.policy;
    stmt.body = ctx.prog(stmt.body);
    if (stmt.generator) {
      stmt.generator = false;
    }
    ref3 = ctx.upds;
    for (i in ref3) {
      v = ref3[i];
      if (v && !ctx.vars[i]) {
        this.ctx.refs[i] = true;
      }
    }
    return this.postDecl(stmt);
  };

  Visitor.prototype.VariableDeclaration = function(stmt) {
    var en, i, j, len, ref2;
    ref2 = stmt.declarations;
    for (j = 0, len = ref2.length; j < len; j++) {
      i = ref2[j];
      if (!i.init) {
        continue;
      }
      this.policy.nameDetails(i.id, "=");
      en = this.ctx.expr(i.init);
      assert.ok(en.pureExpr != null);
      i.init = en.pureExpr;
    }
    return this.ctx.pureNode([stmt]);
  };

  ActiveVisitor.prototype.VariableDeclaration = function(stmt) {
    var asgn, cur, declarations, e, i, j, len, orig, ref2;
    cur = this.ctx.emptyNode();
    declarations = [];
    orig = [];
    ref2 = stmt.declarations;
    for (j = 0, len = ref2.length; j < len; j++) {
      i = ref2[j];
      this.ctx.vars[i.id.name] = true;
      if (!i.id.$dm$orig) {
        this.ctx.ids[i.id.name] = true;
      }
      declarations.push({
        type: "VariableDeclarator",
        id: i.id
      });
      if (this.policy.opts.varCapt === false) {
        this.ctx.refs[i.id.name] = true;
      }
      if (i.init != null) {
        asgn = kit.assign(i.id, i.init);
        e = this.ctx.stmt(kit.exprStmt(asgn));
        cur = cur.append(e);
        orig.push(asgn);
      }
    }
    this.ctx.glob.decls.push({
      type: "VariableDeclaration",
      declarations: declarations,
      kind: "var"
    });
    if (cur.pureBlock != null) {
      cur.setOrig(kit.block(cur.pureBlock()));
    } else {
      cur.setOrig(kit.exprStmt(kit.seqExpr.apply(kit, orig)));
    }
    return cur;
  };

  ActiveVisitor.prototype.ForStatement = function(stmt, label) {
    var body, exprs, i, init, j, len, lexpr, ref2, test, update, wbody;
    wbody = [];
    init = stmt.init, test = stmt.test, update = stmt.update, body = stmt.body;
    if (test == null) {
      test = kit.lit(true);
    }
    if (init != null) {
      if (init.type === "VariableDeclaration") {
        wbody.push(init);
        exprs = [];
        ref2 = init.declarations;
        for (j = 0, len = ref2.length; j < len; j++) {
          i = ref2[j];
          if (i.init) {
            exprs.push(kit.assign(i.id, i.init));
          }
        }
        stmt.init = kit.seqExpr.apply(kit, exprs);
      } else {
        wbody.push(kit.exprStmt(init));
      }
    }
    lexpr = {
      type: "WhileStatement",
      test: test,
      body: body,
      $dm$update: update
    };
    if (label != null) {
      lexpr = {
        type: "LabeledStatement",
        body: lexpr,
        label: kit.id(label)
      };
    }
    wbody.push(lexpr);
    return this.ctx.stmts(wbody);
  };

  wrapP = function(nowrap, v) {
    if (nowrap) {
      return v;
    } else {
      return kit.call(kit.packId("p"), [v]);
    }
  };

  rewriteForIter = function(itername, stmt, label, nowrap) {
    var body, init, iterCtr, iterDecl, iterName, left, pat, resDecls, right, update;
    left = stmt.left, right = stmt.right, body = stmt.body;
    iterName = this.ctx.uniqId("iter");
    iterCtr = kit.call(kit.packId(itername), [right]);
    init = wrapP(nowrap, iterCtr);
    iterDecl = {
      type: "VariableDeclarator",
      id: iterName,
      init: init
    };
    resDecls = [iterDecl];
    init = {
      type: "VariableDeclaration",
      kind: "var",
      declarations: resDecls
    };
    if (left.type === "VariableDeclaration") {
      if (left.declarations.length !== 1) {
        throw new Error("NOT IMPLEMENTED");
      }
      stmt.left = pat = left.declarations[0].id;
      this.ctx.glob.decls.push(left);
    } else {
      pat = left;
    }
    body = kit.flatBlock(kit.exprStmt(kit.assign(pat, kit.mem(iterName, kit.id("value")))), body);
    update = kit.assign(iterName, wrapP(nowrap, kit.call(iterName, [])));
    return [
      {
        type: "ForStatement",
        init: init,
        test: iterName,
        update: update,
        body: body
      }, iterCtr
    ];
  };

  commonForIter = function(itername, stmt, label) {
    var b, bn, iterCtr, ref2;
    ref2 = rewriteForIter.call(this, itername, stmt, label), b = ref2[0], iterCtr = ref2[1];
    bn = this.ForStatement(b, label);
    return this.ctx.bindNode(bn, [this.ctx.expr(stmt.right).setPosition([iterCtr["arguments"], 0])]);
  };

  ActiveVisitor.prototype.ForInStatement = function(stmt, label) {
    return commonForIter.call(this, "forInIterator", stmt, label);
  };

  ActiveVisitor.prototype.ForOfStatement = function(stmt, label) {
    var b, name, orig;
    name = this.policy.opts.varCapt === false ? "iterator" : "iteratorBuf";
    b = commonForIter.call(this, name, stmt, label);
    if (!this.policy.opts.keepForOf) {
      orig = rewriteForIter.call(this, "iterator", stmt, label, true)[0];
      b.setOrig(orig);
    }
    return b;
  };

  commonWhile = function(pre) {
    return function(stmt, label) {
      var bexpr, body, bodyNode, bodyv, brkControl, cntControl, inner, labDef, loopBranch, nlab, old, test, testNode, upd, update;
      test = stmt.test, body = stmt.body;
      bexpr = kit.ifte(test, [], []);
      loopBranch = this.ctx.branchedNode(function(c, a) {
        bexpr.consequent = kit.flatBlock(c);
        if (a != null) {
          bexpr.alternate = kit.flatBlock(a);
        }
        return bexpr;
      }, bexpr);
      update = stmt.$dm$update;
      if (update != null) {
        upd = this.ctx.expr(update).ignoreResult();
      }
      brkControl = this.ctx.loopNode();
      cntControl = this.ctx.controlNode();
      if (label != null) {
        brkControl.setLabel(label + "Brk");
        cntControl.setLabel(label + "Cont");
      } else {
        brkControl.setLabel("brk");
        cntControl.setLabel("cont");
      }
      old = this.ctx.lab;
      this.ctx.lab = nlab = Object.create(old);
      labDef = {
        brk: brkControl,
        cnt: cntControl
      };
      nlab["#"] = labDef;
      if (label != null) {
        nlab[label] = labDef;
      }
      bodyNode = this.ctx.stmtNode(body);
      bodyv = pre ? (testNode = this.ctx.expr(test).setPosition([bexpr, "test"]), this.ctx.bindNode(loopBranch.setDeps(bodyNode, brkControl.breakNode()), [testNode])) : (bexpr.test = test = kit.not(test), testNode = this.ctx.expr(test).setPosition([bexpr, "test"]), this.ctx.blockNode().append(bodyNode, this.ctx.bindNode(loopBranch.setDeps(brkControl.breakNode(), this.ctx.emptyNode()), [testNode])));
      this.ctx.lab = old;
      if (label != null) {
        if (bodyv.name == null) {
          bodyv.name = this.ctx.uniqId("{label}Loop");
        }
      }
      inner = cntControl.setBody(bodyv);
      if (upd != null) {
        inner = inner.append(upd);
      }
      brkControl.test = testNode;
      brkControl.inner = bodyNode;
      brkControl.update = upd != null ? upd : this.ctx.emptyNode();
      brkControl.pre = pre;
      brkControl.cont = cntControl;
      return brkControl.setBody(this.ctx.repeatNode(inner));
    };
  };

  ActiveVisitor.prototype.WhileStatement = commonWhile(true);

  ActiveVisitor.prototype.DoWhileStatement = commonWhile();

  ActiveVisitor.prototype.ThrowStatement = function(stmt) {
    var e, ea;
    e = stmt.argument;
    ea = this.ctx.expr(e);
    return this.ctx.throwNode(ea);
  };

  ActiveVisitor.prototype.TryStatement = function(stmt) {
    var block, finalizer, handler, res;
    block = stmt.block, handler = stmt.handler, finalizer = stmt.finalizer;
    res = this.ctx.tryCatchNode().setBody(this.ctx.stmt(block));
    if (finalizer != null) {
      res.setFin(this.ctx.stmt(finalizer));
    }
    if (handler != null) {
      res.setHandler(handler.param, this.ctx.stmt(handler.body));
    }
    return res;
  };

  ActiveVisitor.prototype.WithStatement = function(stmt) {
    var res;
    res = this.ctx.branchedNode(function(b) {
      stmt.body = b;
      return stmt;
    }, stmt).setOrig(stmt).setDeps(this.ctx.stmt(stmt.body));
    return this.ctx.bindNode(res, [this.ctx.expr(stmt.object).setPosition([stmt, "object"])]);
  };

  Visitor.prototype.defaultStmt = function(stmt) {
    return this.ctx.pureNode([stmt]);
  };

}).call(this);