@mfjs/compiler/policy.js

// Generated by CoffeeScript 1.10.0
(function() {
  var Policy, Scope, config, directive, escodegen, esquery, hier, hierIs, kit, options, opts, path, rebuildDT, resolve, root, upStage;

  Scope = require("./scope").Scope;

  config = require("./config");

  kit = require("./kit");

  directive = require("./directives");

  esquery = require("esquery");

  escodegen = require("escodegen");

  resolve = require("resolve");

  path = require("path");

  root = module.exports = {};

  hier = {};

  hierIs = function(f, t) {
    var h, ht, i, j, len;
    (h = hier[f] != null ? hier[f] : hier[f] = [f]).push(t);
    ht = hier[t];
    if (ht != null) {
      for (j = 0, len = ht.length; j < len; j++) {
        i = ht[j];
        h.push(i);
      }
    }
  };

  hierIs("WhileStatement", ":loop");

  hierIs("DoWhileStatement", ":loop");

  hierIs("ForStatement", ":loop");

  hierIs("ForInStatement", ":loop");

  hierIs("VariableDeclaration", ":assignment");

  hierIs("FunctionExpression", "Function");

  hierIs("FunctionDeclaration", "Function");

  hierIs("AssignmentExpression", ":assignment");

  root.selector = {
    property: function(name, next) {
      var p;
      p = name.split(".");
      if (next == null) {
        next = function(v) {
          return v;
        };
      }
      return function(e) {
        var i, j, len;
        if (e == null) {
          return next();
        }
        for (j = 0, len = p.length; j < len; j++) {
          i = p[j];
          e = e[i];
          if (e == null) {
            break;
          }
        }
        return next(e);
      };
    },
    cases: function(sel) {
      return function(s) {
        var v;
        v = sel(s);
        if (v != null) {
          return this.cases[v];
        }
      };
    },
    prop: function(n) {
      return function(s) {
        var ref;
        return this.cases[(ref = s.generator) != null ? ref : false];
      };
    },
    generatorCall: function() {
      return false;
    },
    matchDeclName: function(s, x, tpref) {
      var m, n, r;
      m = this.match;
      n = kit.getId(s.id);
      r = (function() {
        var p;
        if (s.id != null) {
          if (n != null) {
            if ((m.name != null) && m.name[n]) {
              return true;
            }
            if ((m.qname != null) && m.qname[n]) {
              return true;
            }
            if ((m.postfix != null) && m.postfix[n[n.length - 1]]) {
              return true;
            }
            if ((m.prefix != null) && m.prefix[n[0]]) {
              return true;
            }
          }
        }
        if (s.type === "FunctionExpression" && (x.name != null)) {
          p = kit.getMembersPathIds(x.name);
          if (p.length) {
            n = p[p.length - 1];
            if (n != null) {
              if ((m.name != null) && m.name[n]) {
                return true;
              }
              if ((m.postfix != null) && m.postfix[n[n.length - 1]]) {
                return true;
              }
              if ((m.prefix != null) && m.prefix[n[0]]) {
                return true;
              }
              if ((m["package"] != null) && (p[0] != null) && m["package"][p[0]]) {
                return true;
              }
              if ((m.qname != null) && m.qname[p.join(".")]) {
                return true;
              }
            }
          }
        }
        return false;
      })();
      if (tpref != null) {
        console.log(tpref + ": match decl " + n + ": " + r);
      }
      if (r == null) {
        return;
      }
      return this.cases[r];
    },
    matchCallName: function(s, p, tpref) {
      var m, r;
      p = kit.getMembersPathIds(s.callee);
      m = this.match;
      r = (function() {
        var n;
        n = p[0];
        if (p.length === 1) {
          if (n != null) {
            if (m.libVar && n === config.packageVar) {
              return true;
            }
          }
        }
        if (m.libVar && p.length === 2 && n === config.packageName) {
          return false;
        }
        if (p.length > 0) {
          n = p[p.length - 1];
          if (n == null) {
            return false;
          }
          if ((m["package"] != null) && m["package"][p[0]]) {
            return true;
          }
          if ((m.name != null) && m.name[n]) {
            return true;
          }
          if ((m.postfix != null) && m.postfix[n[n.length - 1]]) {
            return true;
          }
          if ((m.prefix != null) && m.prefix[n[0]]) {
            return true;
          }
          if ((m.qname != null) && m.qname[p.join(".")]) {
            return true;
          }
        }
        return false;
      })();
      if (tpref != null) {
        console.log(tpref + ": match call " + (p.join('.')) + ": " + r);
      }
      if (r == null) {
        return;
      }
      return this.cases[r];
    }
  };

  rebuildDT = function(c) {
    var cn, copy, cv, ref, state, sv, tv, ty;
    copy = function(p, c) {
      var i, r, ref, v;
      if (!((p != null) && p.$)) {
        throw new Error("invalid transitions");
      }
      r = {};
      for (i in options) {
        if (p.$ == null) {
          throw new Error('invalid config');
        }
        v = (ref = c[i]) != null ? ref : p.$[i];
        if (v != null) {
          r[i] = v;
        }
      }
      return c.$ = r;
    };
    copy({
      $: {}
    }, c);
    for (state in c) {
      sv = c[state];
      if (!(state[0] !== '$' && !options[state])) {
        continue;
      }
      copy(c, sv);
      for (ty in sv) {
        tv = sv[ty];
        if (!(ty[0] !== '$' && !options[ty])) {
          continue;
        }
        copy(sv, tv);
        if ((tv.select != null) && (tv.select.substr != null)) {
          tv.select = upStage(root.selector, tv.select);
        }
        if (tv.cases != null) {
          ref = tv.cases;
          for (cn in ref) {
            cv = ref[cn];
            copy(tv, cv);
          }
        }
      }
    }
  };

  options = {
    bind: true,
    compile: true,
    coerce: true,
    expr: true,
    bindAssoc: true,
    block: true,
    loop: true,
    subScope: true,
    keepScope: true,
    varCapt: true,
    branch: true,
    ref: true,
    remove: true,
    keepForOf: true,
    mopt: true
  };

  Policy = (function() {
    function Policy(root1, start) {
      this.root = root1;
      if (this.root == null) {
        this.root = config.states;
      }
      this.state = start != null ? start : config.start;
      this.opts = this.root[this.state];
      this.rebuild();
    }

    Policy.prototype.transit = function(n) {
      var cur;
      if (config.policyTrace) {
        console.log("policy: transit to " + n);
      }
      this.state = n;
      cur = this.root[n];
      if (cur == null) {
        throw new Error("no state " + n + " defined");
      }
      this.opts = cur.$;
      return this;
    };

    Policy.prototype.nameDetails = function(name1, op) {
      this.name = name1;
      this.op = op;
      return this;
    };

    Policy.prototype.scope = function(f) {
      var oldRoot, oldState, res;
      oldRoot = this.root;
      this.root = kit.merge({}, oldRoot);
      oldState = this.state;
      res = f();
      this.state = oldState;
      this.root = oldRoot;
      this.opts = this.root[this.state].$;
      return res;
    };

    Policy.prototype._libRequire = function() {
      if ((this.name != null) && this.name.type === "Identifier") {
        config.packageVar = this.name.name;
        return this.transit(config.start);
      }
    };

    Policy.prototype.rebuild = function(changes) {
      if (changes != null) {
        kit.merge(this.root, changes);
      }
      rebuildDT(this.root);
      return this.opts = this.root[this.state].$;
    };

    Policy.prototype.item = function(s, fun) {
      var cur, h, i, index, j, jump, len, n, oldName, oldOp, oldOpts, oldState, ref, ref1, ref2, res, sel, selv, tpref, trace;
      trace = config.policyTrace;
      if (trace) {
        tpref = "polciy:" + (kit.shortNodeDescr(s));
        console.log(tpref + ": enter at " + this.state);
        if (this.name != null) {
          console.log(tpref + ": name " + this.name);
        }
        if (this.op != null) {
          console.log(tpref + ": op " + this.op);
        }
      }
      cur = this.root[this.state];
      h = (ref = hier[s.type]) != null ? ref : [s.type];
      for (j = 0, len = h.length; j < len; j++) {
        i = h[j];
        if (!(n = cur[i])) {
          continue;
        }
        cur = n;
        if (trace) {
          console.log(tpref + ": by type " + i + ": " + (JSON.stringify(cur)));
        }
        break;
      }
      sel = cur.select;
      if (sel != null) {
        selv = sel.call(cur, s, this, tpref);
        if (trace) {
          console.log(tpref + ": selector " + (JSON.stringify(selv)));
        }
        if (selv != null) {
          cur = selv;
        }
      }
      if (cur.move != null) {
        if (trace) {
          console.log(n + ": moving to " + cur.move);
        }
        return this.transit(cur.move).item(s, fun);
      }
      jump = (ref1 = (ref2 = cur.sub) != null ? ref2 : cur.next) != null ? ref1 : cur.inner;
      if (trace) {
        if (cur.sub) {
          console.log(tpref + ": sub-state " + cur.sub);
        }
        if (cur.inner) {
          console.log(tpref + ": inner state " + cur.inner);
        }
        if (cur.next) {
          console.log(tpref + ": next state " + cur.next);
        }
      }
      if (jump != null) {
        if (jump === cur.sub) {
          oldState = this.state;
        }
        this.state = jump;
        if (jump !== cur.inner) {
          cur = this.root[jump];
        }
      } else if (s.type === "BlockStatement") {
        oldState = this.state;
      }
      oldOp = this.op;
      oldOpts = this.opts;
      this.opts = cur.$;
      if (trace) {
        console.log(tpref + ": opts " + (JSON.stringify(this.opts)));
      }
      oldName = this.name;
      this.libVar = false;
      index = this.index;
      this.index = 0;
      res = fun();
      this.index = index + 1;
      this.name = oldName;
      this.op = oldOp;
      if (oldState != null) {
        if (trace) {
          console.log(tpref + ": restoring state " + oldState);
        }
        this.state = oldState;
      }
      this.opts = oldOpts;
      if (trace) {
        console.log(tpref + ": restoring opts " + (JSON.stringify(oldOpts)));
      }
      return res;
    };

    return Policy;

  })();

  Scope.prototype.option = function(v) {
    this.policy.rebuild(v);
    return this.updateVisitor();
  };

  Scope.prototype.profile = function(v) {
    if (v.substr != null) {
      this.policy.transit(v);
      this.updateVisitor();
      return;
    }
    throw new Error("cannot interpret profile " + v);
  };

  root.optionEnv = Object.create(root.selector);

  upStage = function(env, str) {
    var args, fun, i, v, vals;
    args = [];
    vals = [];
    for (i in env) {
      v = env[i];
      args.push(i);
      vals.push(v);
    }
    args.push("return " + str + ";");
    fun = (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Function, args, function(){});
    return fun.apply(env, vals);
  };

  opts = directive.option = function(e) {
    var i, j, len, ref;
    ref = e["arguments"];
    for (j = 0, len = ref.length; j < len; j++) {
      i = ref[j];
      if (i.type === "Literal" && (e.value != null) && (e.value.substr != null)) {
        upStage(env, e.value);
      } else if (i.type === "ObjectExpression") {
        this.option(upStage(root.optionEnv, escodegen.generate(i)));
      } else {
        throw kit.exprError("cannot interpret option " + (escodegen.generate(i)), i);
      }
    }
    return this.emptyNode();
  };

  directive.profile = function(e, arg) {
    this.profile(kit.toStr(arg));
    return this.emptyNode();
  };

  Scope.prototype.createPolicy = function() {
    return new Policy();
  };

  directive.require = function(e, c) {
    var core, cp, cs, error, f, m, n, varname;
    cs = kit.exprToStr(c);
    f = resolve.sync(cs, {
      basedir: path.dirname(config.filename)
    });
    try {
      cp = resolve.sync(config.packageName, {
        basedir: path.dirname(config.filename)
      });
      core = require(cp);
      core.compileTime = true;
    } catch (error) {
      e = error;
      console.warn("couldn't load library ", config.packageName, e);
    }
    m = require(f);
    if ((m != null) && (m._compile != null) && (m._compile.call != null)) {
      n = this.policy.name;
      if (n.type === "Identifier") {
        varname = n.name;
      }
      m._compile.call(this, [varname]);
    }
    return this.pureExprNode(kit.call(kit.id("require"), [c]));
  };

  directive.ref = function(e) {
    var a, i, j, len, ref;
    ref = e["arguments"];
    for (j = 0, len = ref.length; j < len; j++) {
      a = ref[j];
      i = kit.getId(a);
      if (i == null) {
        throw kit.exprError('expected identifiers', a);
      }
      this.refs[i] = true;
    }
    return this.emptyNode();
  };

}).call(this);