| // Generated by CoffeeScript 1.6.3 |
| (function() { |
| var Access, Arr, Assign, Base, Block, Call, Class, Closure, Code, CodeFragment, Comment, Existence, Extends, For, IDENTIFIER, IDENTIFIER_STR, IS_STRING, If, In, Index, LEVEL_ACCESS, LEVEL_COND, LEVEL_LIST, LEVEL_OP, LEVEL_PAREN, LEVEL_TOP, Literal, METHOD_DEF, NEGATE, NO, Obj, Op, Param, Parens, RESERVED, Range, Return, SIMPLENUM, STRICT_PROSCRIBED, Scope, Slice, Splat, Switch, TAB, THIS, Throw, Try, UTILITIES, Value, While, YES, addLocationDataFn, compact, del, ends, extend, flatten, fragmentsToText, last, locationDataToString, merge, multident, some, starts, throwSyntaxError, unfoldSoak, utility, _ref, _ref1, _ref2, _ref3, |
| __hasProp = {}.hasOwnProperty, |
| __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }, |
| __slice = [].slice; |
| |
| Error.stackTraceLimit = Infinity; |
| |
| Scope = require('./scope').Scope; |
| |
| _ref = require('./lexer'), RESERVED = _ref.RESERVED, STRICT_PROSCRIBED = _ref.STRICT_PROSCRIBED; |
| |
| _ref1 = require('./helpers'), compact = _ref1.compact, flatten = _ref1.flatten, extend = _ref1.extend, merge = _ref1.merge, del = _ref1.del, starts = _ref1.starts, ends = _ref1.ends, last = _ref1.last, some = _ref1.some, addLocationDataFn = _ref1.addLocationDataFn, locationDataToString = _ref1.locationDataToString, throwSyntaxError = _ref1.throwSyntaxError; |
| |
| exports.extend = extend; |
| |
| exports.addLocationDataFn = addLocationDataFn; |
| |
| YES = function() { |
| return true; |
| }; |
| |
| NO = function() { |
| return false; |
| }; |
| |
| THIS = function() { |
| return this; |
| }; |
| |
| NEGATE = function() { |
| this.negated = !this.negated; |
| return this; |
| }; |
| |
| exports.CodeFragment = CodeFragment = (function() { |
| function CodeFragment(parent, code) { |
| var _ref2; |
| this.code = "" + code; |
| this.locationData = parent != null ? parent.locationData : void 0; |
| this.type = (parent != null ? (_ref2 = parent.constructor) != null ? _ref2.name : void 0 : void 0) || 'unknown'; |
| } |
| |
| CodeFragment.prototype.toString = function() { |
| return "" + this.code + (this.locationData ? ": " + locationDataToString(this.locationData) : ''); |
| }; |
| |
| return CodeFragment; |
| |
| })(); |
| |
| fragmentsToText = function(fragments) { |
| var fragment; |
| return ((function() { |
| var _i, _len, _results; |
| _results = []; |
| for (_i = 0, _len = fragments.length; _i < _len; _i++) { |
| fragment = fragments[_i]; |
| _results.push(fragment.code); |
| } |
| return _results; |
| })()).join(''); |
| }; |
| |
| exports.Base = Base = (function() { |
| function Base() {} |
| |
| Base.prototype.compile = function(o, lvl) { |
| return fragmentsToText(this.compileToFragments(o, lvl)); |
| }; |
| |
| Base.prototype.compileToFragments = function(o, lvl) { |
| var node; |
| o = extend({}, o); |
| if (lvl) { |
| o.level = lvl; |
| } |
| node = this.unfoldSoak(o) || this; |
| node.tab = o.indent; |
| if (o.level === LEVEL_TOP || !node.isStatement(o)) { |
| return node.compileNode(o); |
| } else { |
| return node.compileClosure(o); |
| } |
| }; |
| |
| Base.prototype.compileClosure = function(o) { |
| var jumpNode; |
| if (jumpNode = this.jumps()) { |
| jumpNode.error('cannot use a pure statement in an expression'); |
| } |
| o.sharedScope = true; |
| return Closure.wrap(this).compileNode(o); |
| }; |
| |
| Base.prototype.cache = function(o, level, reused) { |
| var ref, sub; |
| if (!this.isComplex()) { |
| ref = level ? this.compileToFragments(o, level) : this; |
| return [ref, ref]; |
| } else { |
| ref = new Literal(reused || o.scope.freeVariable('ref')); |
| sub = new Assign(ref, this); |
| if (level) { |
| return [sub.compileToFragments(o, level), [this.makeCode(ref.value)]]; |
| } else { |
| return [sub, ref]; |
| } |
| } |
| }; |
| |
| Base.prototype.cacheToCodeFragments = function(cacheValues) { |
| return [fragmentsToText(cacheValues[0]), fragmentsToText(cacheValues[1])]; |
| }; |
| |
| Base.prototype.makeReturn = function(res) { |
| var me; |
| me = this.unwrapAll(); |
| if (res) { |
| return new Call(new Literal("" + res + ".push"), [me]); |
| } else { |
| return new Return(me); |
| } |
| }; |
| |
| Base.prototype.contains = function(pred) { |
| var node; |
| node = void 0; |
| this.traverseChildren(false, function(n) { |
| if (pred(n)) { |
| node = n; |
| return false; |
| } |
| }); |
| return node; |
| }; |
| |
| Base.prototype.lastNonComment = function(list) { |
| var i; |
| i = list.length; |
| while (i--) { |
| if (!(list[i] instanceof Comment)) { |
| return list[i]; |
| } |
| } |
| return null; |
| }; |
| |
| Base.prototype.toString = function(idt, name) { |
| var tree; |
| if (idt == null) { |
| idt = ''; |
| } |
| if (name == null) { |
| name = this.constructor.name; |
| } |
| tree = '\n' + idt + name; |
| if (this.soak) { |
| tree += '?'; |
| } |
| this.eachChild(function(node) { |
| return tree += node.toString(idt + TAB); |
| }); |
| return tree; |
| }; |
| |
| Base.prototype.eachChild = function(func) { |
| var attr, child, _i, _j, _len, _len1, _ref2, _ref3; |
| if (!this.children) { |
| return this; |
| } |
| _ref2 = this.children; |
| for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| attr = _ref2[_i]; |
| if (this[attr]) { |
| _ref3 = flatten([this[attr]]); |
| for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) { |
| child = _ref3[_j]; |
| if (func(child) === false) { |
| return this; |
| } |
| } |
| } |
| } |
| return this; |
| }; |
| |
| Base.prototype.traverseChildren = function(crossScope, func) { |
| return this.eachChild(function(child) { |
| var recur; |
| recur = func(child); |
| if (recur !== false) { |
| return child.traverseChildren(crossScope, func); |
| } |
| }); |
| }; |
| |
| Base.prototype.invert = function() { |
| return new Op('!', this); |
| }; |
| |
| Base.prototype.unwrapAll = function() { |
| var node; |
| node = this; |
| while (node !== (node = node.unwrap())) { |
| continue; |
| } |
| return node; |
| }; |
| |
| Base.prototype.children = []; |
| |
| Base.prototype.isStatement = NO; |
| |
| Base.prototype.jumps = NO; |
| |
| Base.prototype.isComplex = YES; |
| |
| Base.prototype.isChainable = NO; |
| |
| Base.prototype.isAssignable = NO; |
| |
| Base.prototype.unwrap = THIS; |
| |
| Base.prototype.unfoldSoak = NO; |
| |
| Base.prototype.assigns = NO; |
| |
| Base.prototype.updateLocationDataIfMissing = function(locationData) { |
| this.locationData || (this.locationData = locationData); |
| return this.eachChild(function(child) { |
| return child.updateLocationDataIfMissing(locationData); |
| }); |
| }; |
| |
| Base.prototype.error = function(message) { |
| return throwSyntaxError(message, this.locationData); |
| }; |
| |
| Base.prototype.makeCode = function(code) { |
| return new CodeFragment(this, code); |
| }; |
| |
| Base.prototype.wrapInBraces = function(fragments) { |
| return [].concat(this.makeCode('('), fragments, this.makeCode(')')); |
| }; |
| |
| Base.prototype.joinFragmentArrays = function(fragmentsList, joinStr) { |
| var answer, fragments, i, _i, _len; |
| answer = []; |
| for (i = _i = 0, _len = fragmentsList.length; _i < _len; i = ++_i) { |
| fragments = fragmentsList[i]; |
| if (i) { |
| answer.push(this.makeCode(joinStr)); |
| } |
| answer = answer.concat(fragments); |
| } |
| return answer; |
| }; |
| |
| return Base; |
| |
| })(); |
| |
| exports.Block = Block = (function(_super) { |
| __extends(Block, _super); |
| |
| function Block(nodes) { |
| this.expressions = compact(flatten(nodes || [])); |
| } |
| |
| Block.prototype.children = ['expressions']; |
| |
| Block.prototype.push = function(node) { |
| this.expressions.push(node); |
| return this; |
| }; |
| |
| Block.prototype.pop = function() { |
| return this.expressions.pop(); |
| }; |
| |
| Block.prototype.unshift = function(node) { |
| this.expressions.unshift(node); |
| return this; |
| }; |
| |
| Block.prototype.unwrap = function() { |
| if (this.expressions.length === 1) { |
| return this.expressions[0]; |
| } else { |
| return this; |
| } |
| }; |
| |
| Block.prototype.isEmpty = function() { |
| return !this.expressions.length; |
| }; |
| |
| Block.prototype.isStatement = function(o) { |
| var exp, _i, _len, _ref2; |
| _ref2 = this.expressions; |
| for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| exp = _ref2[_i]; |
| if (exp.isStatement(o)) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| Block.prototype.jumps = function(o) { |
| var exp, _i, _len, _ref2; |
| _ref2 = this.expressions; |
| for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| exp = _ref2[_i]; |
| if (exp.jumps(o)) { |
| return exp; |
| } |
| } |
| }; |
| |
| Block.prototype.makeReturn = function(res) { |
| var expr, len; |
| len = this.expressions.length; |
| while (len--) { |
| expr = this.expressions[len]; |
| if (!(expr instanceof Comment)) { |
| this.expressions[len] = expr.makeReturn(res); |
| if (expr instanceof Return && !expr.expression) { |
| this.expressions.splice(len, 1); |
| } |
| break; |
| } |
| } |
| return this; |
| }; |
| |
| Block.prototype.compileToFragments = function(o, level) { |
| if (o == null) { |
| o = {}; |
| } |
| if (o.scope) { |
| return Block.__super__.compileToFragments.call(this, o, level); |
| } else { |
| return this.compileRoot(o); |
| } |
| }; |
| |
| Block.prototype.compileNode = function(o) { |
| var answer, compiledNodes, fragments, index, node, top, _i, _len, _ref2; |
| this.tab = o.indent; |
| top = o.level === LEVEL_TOP; |
| compiledNodes = []; |
| _ref2 = this.expressions; |
| for (index = _i = 0, _len = _ref2.length; _i < _len; index = ++_i) { |
| node = _ref2[index]; |
| node = node.unwrapAll(); |
| node = node.unfoldSoak(o) || node; |
| if (node instanceof Block) { |
| compiledNodes.push(node.compileNode(o)); |
| } else if (top) { |
| node.front = true; |
| fragments = node.compileToFragments(o); |
| if (!node.isStatement(o)) { |
| fragments.unshift(this.makeCode("" + this.tab)); |
| fragments.push(this.makeCode(";")); |
| } |
| compiledNodes.push(fragments); |
| } else { |
| compiledNodes.push(node.compileToFragments(o, LEVEL_LIST)); |
| } |
| } |
| if (top) { |
| if (this.spaced) { |
| return [].concat(this.joinFragmentArrays(compiledNodes, '\n\n'), this.makeCode("\n")); |
| } else { |
| return this.joinFragmentArrays(compiledNodes, '\n'); |
| } |
| } |
| if (compiledNodes.length) { |
| answer = this.joinFragmentArrays(compiledNodes, ', '); |
| } else { |
| answer = [this.makeCode("void 0")]; |
| } |
| if (compiledNodes.length > 1 && o.level >= LEVEL_LIST) { |
| return this.wrapInBraces(answer); |
| } else { |
| return answer; |
| } |
| }; |
| |
| Block.prototype.compileRoot = function(o) { |
| var exp, fragments, i, name, prelude, preludeExps, rest, _i, _len, _ref2; |
| o.indent = o.bare ? '' : TAB; |
| o.level = LEVEL_TOP; |
| this.spaced = true; |
| o.scope = new Scope(null, this, null); |
| _ref2 = o.locals || []; |
| for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| name = _ref2[_i]; |
| o.scope.parameter(name); |
| } |
| prelude = []; |
| if (!o.bare) { |
| preludeExps = (function() { |
| var _j, _len1, _ref3, _results; |
| _ref3 = this.expressions; |
| _results = []; |
| for (i = _j = 0, _len1 = _ref3.length; _j < _len1; i = ++_j) { |
| exp = _ref3[i]; |
| if (!(exp.unwrap() instanceof Comment)) { |
| break; |
| } |
| _results.push(exp); |
| } |
| return _results; |
| }).call(this); |
| rest = this.expressions.slice(preludeExps.length); |
| this.expressions = preludeExps; |
| if (preludeExps.length) { |
| prelude = this.compileNode(merge(o, { |
| indent: '' |
| })); |
| prelude.push(this.makeCode("\n")); |
| } |
| this.expressions = rest; |
| } |
| fragments = this.compileWithDeclarations(o); |
| if (o.bare) { |
| return fragments; |
| } |
| return [].concat(prelude, this.makeCode("(function() {\n"), fragments, this.makeCode("\n}).call(this);\n")); |
| }; |
| |
| Block.prototype.compileWithDeclarations = function(o) { |
| var assigns, declars, exp, fragments, i, post, rest, scope, spaced, _i, _len, _ref2, _ref3, _ref4; |
| fragments = []; |
| post = []; |
| _ref2 = this.expressions; |
| for (i = _i = 0, _len = _ref2.length; _i < _len; i = ++_i) { |
| exp = _ref2[i]; |
| exp = exp.unwrap(); |
| if (!(exp instanceof Comment || exp instanceof Literal)) { |
| break; |
| } |
| } |
| o = merge(o, { |
| level: LEVEL_TOP |
| }); |
| if (i) { |
| rest = this.expressions.splice(i, 9e9); |
| _ref3 = [this.spaced, false], spaced = _ref3[0], this.spaced = _ref3[1]; |
| _ref4 = [this.compileNode(o), spaced], fragments = _ref4[0], this.spaced = _ref4[1]; |
| this.expressions = rest; |
| } |
| post = this.compileNode(o); |
| scope = o.scope; |
| if (scope.expressions === this) { |
| declars = o.scope.hasDeclarations(); |
| assigns = scope.hasAssignments; |
| if (declars || assigns) { |
| if (i) { |
| fragments.push(this.makeCode('\n')); |
| } |
| fragments.push(this.makeCode("" + this.tab + "var ")); |
| if (declars) { |
| fragments.push(this.makeCode(scope.declaredVariables().join(', '))); |
| } |
| if (assigns) { |
| if (declars) { |
| fragments.push(this.makeCode(",\n" + (this.tab + TAB))); |
| } |
| fragments.push(this.makeCode(scope.assignedVariables().join(",\n" + (this.tab + TAB)))); |
| } |
| fragments.push(this.makeCode(";\n" + (this.spaced ? '\n' : ''))); |
| } else if (fragments.length && post.length) { |
| fragments.push(this.makeCode("\n")); |
| } |
| } |
| return fragments.concat(post); |
| }; |
| |
| Block.wrap = function(nodes) { |
| if (nodes.length === 1 && nodes[0] instanceof Block) { |
| return nodes[0]; |
| } |
| return new Block(nodes); |
| }; |
| |
| return Block; |
| |
| })(Base); |
| |
| exports.Literal = Literal = (function(_super) { |
| __extends(Literal, _super); |
| |
| function Literal(value) { |
| this.value = value; |
| } |
| |
| Literal.prototype.makeReturn = function() { |
| if (this.isStatement()) { |
| return this; |
| } else { |
| return Literal.__super__.makeReturn.apply(this, arguments); |
| } |
| }; |
| |
| Literal.prototype.isAssignable = function() { |
| return IDENTIFIER.test(this.value); |
| }; |
| |
| Literal.prototype.isStatement = function() { |
| var _ref2; |
| return (_ref2 = this.value) === 'break' || _ref2 === 'continue' || _ref2 === 'debugger'; |
| }; |
| |
| Literal.prototype.isComplex = NO; |
| |
| Literal.prototype.assigns = function(name) { |
| return name === this.value; |
| }; |
| |
| Literal.prototype.jumps = function(o) { |
| if (this.value === 'break' && !((o != null ? o.loop : void 0) || (o != null ? o.block : void 0))) { |
| return this; |
| } |
| if (this.value === 'continue' && !(o != null ? o.loop : void 0)) { |
| return this; |
| } |
| }; |
| |
| Literal.prototype.compileNode = function(o) { |
| var answer, code, _ref2; |
| code = this.value === 'this' ? ((_ref2 = o.scope.method) != null ? _ref2.bound : void 0) ? o.scope.method.context : this.value : this.value.reserved ? "\"" + this.value + "\"" : this.value; |
| answer = this.isStatement() ? "" + this.tab + code + ";" : code; |
| return [this.makeCode(answer)]; |
| }; |
| |
| Literal.prototype.toString = function() { |
| return ' "' + this.value + '"'; |
| }; |
| |
| return Literal; |
| |
| })(Base); |
| |
| exports.Undefined = (function(_super) { |
| __extends(Undefined, _super); |
| |
| function Undefined() { |
| _ref2 = Undefined.__super__.constructor.apply(this, arguments); |
| return _ref2; |
| } |
| |
| Undefined.prototype.isAssignable = NO; |
| |
| Undefined.prototype.isComplex = NO; |
| |
| Undefined.prototype.compileNode = function(o) { |
| return [this.makeCode(o.level >= LEVEL_ACCESS ? '(void 0)' : 'void 0')]; |
| }; |
| |
| return Undefined; |
| |
| })(Base); |
| |
| exports.Null = (function(_super) { |
| __extends(Null, _super); |
| |
| function Null() { |
| _ref3 = Null.__super__.constructor.apply(this, arguments); |
| return _ref3; |
| } |
| |
| Null.prototype.isAssignable = NO; |
| |
| Null.prototype.isComplex = NO; |
| |
| Null.prototype.compileNode = function() { |
| return [this.makeCode("null")]; |
| }; |
| |
| return Null; |
| |
| })(Base); |
| |
| exports.Bool = (function(_super) { |
| __extends(Bool, _super); |
| |
| Bool.prototype.isAssignable = NO; |
| |
| Bool.prototype.isComplex = NO; |
| |
| Bool.prototype.compileNode = function() { |
| return [this.makeCode(this.val)]; |
| }; |
| |
| function Bool(val) { |
| this.val = val; |
| } |
| |
| return Bool; |
| |
| })(Base); |
| |
| exports.Return = Return = (function(_super) { |
| __extends(Return, _super); |
| |
| function Return(expr) { |
| if (expr && !expr.unwrap().isUndefined) { |
| this.expression = expr; |
| } |
| } |
| |
| Return.prototype.children = ['expression']; |
| |
| Return.prototype.isStatement = YES; |
| |
| Return.prototype.makeReturn = THIS; |
| |
| Return.prototype.jumps = THIS; |
| |
| Return.prototype.compileToFragments = function(o, level) { |
| var expr, _ref4; |
| expr = (_ref4 = this.expression) != null ? _ref4.makeReturn() : void 0; |
| if (expr && !(expr instanceof Return)) { |
| return expr.compileToFragments(o, level); |
| } else { |
| return Return.__super__.compileToFragments.call(this, o, level); |
| } |
| }; |
| |
| Return.prototype.compileNode = function(o) { |
| var answer; |
| answer = []; |
| answer.push(this.makeCode(this.tab + ("return" + (this.expression ? " " : "")))); |
| if (this.expression) { |
| answer = answer.concat(this.expression.compileToFragments(o, LEVEL_PAREN)); |
| } |
| answer.push(this.makeCode(";")); |
| return answer; |
| }; |
| |
| return Return; |
| |
| })(Base); |
| |
| exports.Value = Value = (function(_super) { |
| __extends(Value, _super); |
| |
| function Value(base, props, tag) { |
| if (!props && base instanceof Value) { |
| return base; |
| } |
| this.base = base; |
| this.properties = props || []; |
| if (tag) { |
| this[tag] = true; |
| } |
| return this; |
| } |
| |
| Value.prototype.children = ['base', 'properties']; |
| |
| Value.prototype.add = function(props) { |
| this.properties = this.properties.concat(props); |
| return this; |
| }; |
| |
| Value.prototype.hasProperties = function() { |
| return !!this.properties.length; |
| }; |
| |
| Value.prototype.isArray = function() { |
| return !this.properties.length && this.base instanceof Arr; |
| }; |
| |
| Value.prototype.isComplex = function() { |
| return this.hasProperties() || this.base.isComplex(); |
| }; |
| |
| Value.prototype.isAssignable = function() { |
| return this.hasProperties() || this.base.isAssignable(); |
| }; |
| |
| Value.prototype.isSimpleNumber = function() { |
| return this.base instanceof Literal && SIMPLENUM.test(this.base.value); |
| }; |
| |
| Value.prototype.isString = function() { |
| return this.base instanceof Literal && IS_STRING.test(this.base.value); |
| }; |
| |
| Value.prototype.isAtomic = function() { |
| var node, _i, _len, _ref4; |
| _ref4 = this.properties.concat(this.base); |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| node = _ref4[_i]; |
| if (node.soak || node instanceof Call) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| |
| Value.prototype.isStatement = function(o) { |
| return !this.properties.length && this.base.isStatement(o); |
| }; |
| |
| Value.prototype.assigns = function(name) { |
| return !this.properties.length && this.base.assigns(name); |
| }; |
| |
| Value.prototype.jumps = function(o) { |
| return !this.properties.length && this.base.jumps(o); |
| }; |
| |
| Value.prototype.isObject = function(onlyGenerated) { |
| if (this.properties.length) { |
| return false; |
| } |
| return (this.base instanceof Obj) && (!onlyGenerated || this.base.generated); |
| }; |
| |
| Value.prototype.isSplice = function() { |
| return last(this.properties) instanceof Slice; |
| }; |
| |
| Value.prototype.unwrap = function() { |
| if (this.properties.length) { |
| return this; |
| } else { |
| return this.base; |
| } |
| }; |
| |
| Value.prototype.cacheReference = function(o) { |
| var base, bref, name, nref; |
| name = last(this.properties); |
| if (this.properties.length < 2 && !this.base.isComplex() && !(name != null ? name.isComplex() : void 0)) { |
| return [this, this]; |
| } |
| base = new Value(this.base, this.properties.slice(0, -1)); |
| if (base.isComplex()) { |
| bref = new Literal(o.scope.freeVariable('base')); |
| base = new Value(new Parens(new Assign(bref, base))); |
| } |
| if (!name) { |
| return [base, bref]; |
| } |
| if (name.isComplex()) { |
| nref = new Literal(o.scope.freeVariable('name')); |
| name = new Index(new Assign(nref, name.index)); |
| nref = new Index(nref); |
| } |
| return [base.add(name), new Value(bref || base.base, [nref || name])]; |
| }; |
| |
| Value.prototype.compileNode = function(o) { |
| var fragments, prop, props, _i, _len; |
| this.base.front = this.front; |
| props = this.properties; |
| fragments = this.base.compileToFragments(o, (props.length ? LEVEL_ACCESS : null)); |
| if ((this.base instanceof Parens || props.length) && SIMPLENUM.test(fragmentsToText(fragments))) { |
| fragments.push(this.makeCode('.')); |
| } |
| for (_i = 0, _len = props.length; _i < _len; _i++) { |
| prop = props[_i]; |
| fragments.push.apply(fragments, prop.compileToFragments(o)); |
| } |
| return fragments; |
| }; |
| |
| Value.prototype.unfoldSoak = function(o) { |
| var _this = this; |
| return this.unfoldedSoak != null ? this.unfoldedSoak : this.unfoldedSoak = (function() { |
| var fst, i, ifn, prop, ref, snd, _i, _len, _ref4, _ref5; |
| if (ifn = _this.base.unfoldSoak(o)) { |
| (_ref4 = ifn.body.properties).push.apply(_ref4, _this.properties); |
| return ifn; |
| } |
| _ref5 = _this.properties; |
| for (i = _i = 0, _len = _ref5.length; _i < _len; i = ++_i) { |
| prop = _ref5[i]; |
| if (!prop.soak) { |
| continue; |
| } |
| prop.soak = false; |
| fst = new Value(_this.base, _this.properties.slice(0, i)); |
| snd = new Value(_this.base, _this.properties.slice(i)); |
| if (fst.isComplex()) { |
| ref = new Literal(o.scope.freeVariable('ref')); |
| fst = new Parens(new Assign(ref, fst)); |
| snd.base = ref; |
| } |
| return new If(new Existence(fst), snd, { |
| soak: true |
| }); |
| } |
| return false; |
| })(); |
| }; |
| |
| return Value; |
| |
| })(Base); |
| |
| exports.Comment = Comment = (function(_super) { |
| __extends(Comment, _super); |
| |
| function Comment(comment) { |
| this.comment = comment; |
| } |
| |
| Comment.prototype.isStatement = YES; |
| |
| Comment.prototype.makeReturn = THIS; |
| |
| Comment.prototype.compileNode = function(o, level) { |
| var code; |
| code = "/*" + (multident(this.comment, this.tab)) + (__indexOf.call(this.comment, '\n') >= 0 ? "\n" + this.tab : '') + "*/\n"; |
| if ((level || o.level) === LEVEL_TOP) { |
| code = o.indent + code; |
| } |
| return [this.makeCode(code)]; |
| }; |
| |
| return Comment; |
| |
| })(Base); |
| |
| exports.Call = Call = (function(_super) { |
| __extends(Call, _super); |
| |
| function Call(variable, args, soak) { |
| this.args = args != null ? args : []; |
| this.soak = soak; |
| this.isNew = false; |
| this.isSuper = variable === 'super'; |
| this.variable = this.isSuper ? null : variable; |
| } |
| |
| Call.prototype.children = ['variable', 'args']; |
| |
| Call.prototype.newInstance = function() { |
| var base, _ref4; |
| base = ((_ref4 = this.variable) != null ? _ref4.base : void 0) || this.variable; |
| if (base instanceof Call && !base.isNew) { |
| base.newInstance(); |
| } else { |
| this.isNew = true; |
| } |
| return this; |
| }; |
| |
| Call.prototype.superReference = function(o) { |
| var accesses, method; |
| method = o.scope.namedMethod(); |
| if (method != null ? method.klass : void 0) { |
| accesses = [new Access(new Literal('__super__'))]; |
| if (method["static"]) { |
| accesses.push(new Access(new Literal('constructor'))); |
| } |
| accesses.push(new Access(new Literal(method.name))); |
| return (new Value(new Literal(method.klass), accesses)).compile(o); |
| } else if (method != null ? method.ctor : void 0) { |
| return "" + method.name + ".__super__.constructor"; |
| } else { |
| return this.error('cannot call super outside of an instance method.'); |
| } |
| }; |
| |
| Call.prototype.superThis = function(o) { |
| var method; |
| method = o.scope.method; |
| return (method && !method.klass && method.context) || "this"; |
| }; |
| |
| Call.prototype.unfoldSoak = function(o) { |
| var call, ifn, left, list, rite, _i, _len, _ref4, _ref5; |
| if (this.soak) { |
| if (this.variable) { |
| if (ifn = unfoldSoak(o, this, 'variable')) { |
| return ifn; |
| } |
| _ref4 = new Value(this.variable).cacheReference(o), left = _ref4[0], rite = _ref4[1]; |
| } else { |
| left = new Literal(this.superReference(o)); |
| rite = new Value(left); |
| } |
| rite = new Call(rite, this.args); |
| rite.isNew = this.isNew; |
| left = new Literal("typeof " + (left.compile(o)) + " === \"function\""); |
| return new If(left, new Value(rite), { |
| soak: true |
| }); |
| } |
| call = this; |
| list = []; |
| while (true) { |
| if (call.variable instanceof Call) { |
| list.push(call); |
| call = call.variable; |
| continue; |
| } |
| if (!(call.variable instanceof Value)) { |
| break; |
| } |
| list.push(call); |
| if (!((call = call.variable.base) instanceof Call)) { |
| break; |
| } |
| } |
| _ref5 = list.reverse(); |
| for (_i = 0, _len = _ref5.length; _i < _len; _i++) { |
| call = _ref5[_i]; |
| if (ifn) { |
| if (call.variable instanceof Call) { |
| call.variable = ifn; |
| } else { |
| call.variable.base = ifn; |
| } |
| } |
| ifn = unfoldSoak(o, call, 'variable'); |
| } |
| return ifn; |
| }; |
| |
| Call.prototype.compileNode = function(o) { |
| var arg, argIndex, compiledArgs, compiledArray, fragments, preface, _i, _len, _ref4, _ref5; |
| if ((_ref4 = this.variable) != null) { |
| _ref4.front = this.front; |
| } |
| compiledArray = Splat.compileSplattedArray(o, this.args, true); |
| if (compiledArray.length) { |
| return this.compileSplat(o, compiledArray); |
| } |
| compiledArgs = []; |
| _ref5 = this.args; |
| for (argIndex = _i = 0, _len = _ref5.length; _i < _len; argIndex = ++_i) { |
| arg = _ref5[argIndex]; |
| if (argIndex) { |
| compiledArgs.push(this.makeCode(", ")); |
| } |
| compiledArgs.push.apply(compiledArgs, arg.compileToFragments(o, LEVEL_LIST)); |
| } |
| fragments = []; |
| if (this.isSuper) { |
| preface = this.superReference(o) + (".call(" + (this.superThis(o))); |
| if (compiledArgs.length) { |
| preface += ", "; |
| } |
| fragments.push(this.makeCode(preface)); |
| } else { |
| if (this.isNew) { |
| fragments.push(this.makeCode('new ')); |
| } |
| fragments.push.apply(fragments, this.variable.compileToFragments(o, LEVEL_ACCESS)); |
| fragments.push(this.makeCode("(")); |
| } |
| fragments.push.apply(fragments, compiledArgs); |
| fragments.push(this.makeCode(")")); |
| return fragments; |
| }; |
| |
| Call.prototype.compileSplat = function(o, splatArgs) { |
| var answer, base, fun, idt, name, ref; |
| if (this.isSuper) { |
| return [].concat(this.makeCode("" + (this.superReference(o)) + ".apply(" + (this.superThis(o)) + ", "), splatArgs, this.makeCode(")")); |
| } |
| if (this.isNew) { |
| idt = this.tab + TAB; |
| return [].concat(this.makeCode("(function(func, args, ctor) {\n" + idt + "ctor.prototype = func.prototype;\n" + idt + "var child = new ctor, result = func.apply(child, args);\n" + idt + "return Object(result) === result ? result : child;\n" + this.tab + "})("), this.variable.compileToFragments(o, LEVEL_LIST), this.makeCode(", "), splatArgs, this.makeCode(", function(){})")); |
| } |
| answer = []; |
| base = new Value(this.variable); |
| if ((name = base.properties.pop()) && base.isComplex()) { |
| ref = o.scope.freeVariable('ref'); |
| answer = answer.concat(this.makeCode("(" + ref + " = "), base.compileToFragments(o, LEVEL_LIST), this.makeCode(")"), name.compileToFragments(o)); |
| } else { |
| fun = base.compileToFragments(o, LEVEL_ACCESS); |
| if (SIMPLENUM.test(fragmentsToText(fun))) { |
| fun = this.wrapInBraces(fun); |
| } |
| if (name) { |
| ref = fragmentsToText(fun); |
| fun.push.apply(fun, name.compileToFragments(o)); |
| } else { |
| ref = 'null'; |
| } |
| answer = answer.concat(fun); |
| } |
| return answer = answer.concat(this.makeCode(".apply(" + ref + ", "), splatArgs, this.makeCode(")")); |
| }; |
| |
| return Call; |
| |
| })(Base); |
| |
| exports.Extends = Extends = (function(_super) { |
| __extends(Extends, _super); |
| |
| function Extends(child, parent) { |
| this.child = child; |
| this.parent = parent; |
| } |
| |
| Extends.prototype.children = ['child', 'parent']; |
| |
| Extends.prototype.compileToFragments = function(o) { |
| return new Call(new Value(new Literal(utility('extends'))), [this.child, this.parent]).compileToFragments(o); |
| }; |
| |
| return Extends; |
| |
| })(Base); |
| |
| exports.Access = Access = (function(_super) { |
| __extends(Access, _super); |
| |
| function Access(name, tag) { |
| this.name = name; |
| this.name.asKey = true; |
| this.soak = tag === 'soak'; |
| } |
| |
| Access.prototype.children = ['name']; |
| |
| Access.prototype.compileToFragments = function(o) { |
| var name; |
| name = this.name.compileToFragments(o); |
| if (IDENTIFIER.test(fragmentsToText(name))) { |
| name.unshift(this.makeCode(".")); |
| } else { |
| name.unshift(this.makeCode("[")); |
| name.push(this.makeCode("]")); |
| } |
| return name; |
| }; |
| |
| Access.prototype.isComplex = NO; |
| |
| return Access; |
| |
| })(Base); |
| |
| exports.Index = Index = (function(_super) { |
| __extends(Index, _super); |
| |
| function Index(index) { |
| this.index = index; |
| } |
| |
| Index.prototype.children = ['index']; |
| |
| Index.prototype.compileToFragments = function(o) { |
| return [].concat(this.makeCode("["), this.index.compileToFragments(o, LEVEL_PAREN), this.makeCode("]")); |
| }; |
| |
| Index.prototype.isComplex = function() { |
| return this.index.isComplex(); |
| }; |
| |
| return Index; |
| |
| })(Base); |
| |
| exports.Range = Range = (function(_super) { |
| __extends(Range, _super); |
| |
| Range.prototype.children = ['from', 'to']; |
| |
| function Range(from, to, tag) { |
| this.from = from; |
| this.to = to; |
| this.exclusive = tag === 'exclusive'; |
| this.equals = this.exclusive ? '' : '='; |
| } |
| |
| Range.prototype.compileVariables = function(o) { |
| var step, _ref4, _ref5, _ref6, _ref7; |
| o = merge(o, { |
| top: true |
| }); |
| _ref4 = this.cacheToCodeFragments(this.from.cache(o, LEVEL_LIST)), this.fromC = _ref4[0], this.fromVar = _ref4[1]; |
| _ref5 = this.cacheToCodeFragments(this.to.cache(o, LEVEL_LIST)), this.toC = _ref5[0], this.toVar = _ref5[1]; |
| if (step = del(o, 'step')) { |
| _ref6 = this.cacheToCodeFragments(step.cache(o, LEVEL_LIST)), this.step = _ref6[0], this.stepVar = _ref6[1]; |
| } |
| _ref7 = [this.fromVar.match(SIMPLENUM), this.toVar.match(SIMPLENUM)], this.fromNum = _ref7[0], this.toNum = _ref7[1]; |
| if (this.stepVar) { |
| return this.stepNum = this.stepVar.match(SIMPLENUM); |
| } |
| }; |
| |
| Range.prototype.compileNode = function(o) { |
| var cond, condPart, from, gt, idx, idxName, known, lt, namedIndex, stepPart, to, varPart, _ref4, _ref5; |
| if (!this.fromVar) { |
| this.compileVariables(o); |
| } |
| if (!o.index) { |
| return this.compileArray(o); |
| } |
| known = this.fromNum && this.toNum; |
| idx = del(o, 'index'); |
| idxName = del(o, 'name'); |
| namedIndex = idxName && idxName !== idx; |
| varPart = "" + idx + " = " + this.fromC; |
| if (this.toC !== this.toVar) { |
| varPart += ", " + this.toC; |
| } |
| if (this.step !== this.stepVar) { |
| varPart += ", " + this.step; |
| } |
| _ref4 = ["" + idx + " <" + this.equals, "" + idx + " >" + this.equals], lt = _ref4[0], gt = _ref4[1]; |
| condPart = this.stepNum ? +this.stepNum > 0 ? "" + lt + " " + this.toVar : "" + gt + " " + this.toVar : known ? ((_ref5 = [+this.fromNum, +this.toNum], from = _ref5[0], to = _ref5[1], _ref5), from <= to ? "" + lt + " " + to : "" + gt + " " + to) : (cond = this.stepVar ? "" + this.stepVar + " > 0" : "" + this.fromVar + " <= " + this.toVar, "" + cond + " ? " + lt + " " + this.toVar + " : " + gt + " " + this.toVar); |
| stepPart = this.stepVar ? "" + idx + " += " + this.stepVar : known ? namedIndex ? from <= to ? "++" + idx : "--" + idx : from <= to ? "" + idx + "++" : "" + idx + "--" : namedIndex ? "" + cond + " ? ++" + idx + " : --" + idx : "" + cond + " ? " + idx + "++ : " + idx + "--"; |
| if (namedIndex) { |
| varPart = "" + idxName + " = " + varPart; |
| } |
| if (namedIndex) { |
| stepPart = "" + idxName + " = " + stepPart; |
| } |
| return [this.makeCode("" + varPart + "; " + condPart + "; " + stepPart)]; |
| }; |
| |
| Range.prototype.compileArray = function(o) { |
| var args, body, cond, hasArgs, i, idt, post, pre, range, result, vars, _i, _ref4, _ref5, _results; |
| if (this.fromNum && this.toNum && Math.abs(this.fromNum - this.toNum) <= 20) { |
| range = (function() { |
| _results = []; |
| for (var _i = _ref4 = +this.fromNum, _ref5 = +this.toNum; _ref4 <= _ref5 ? _i <= _ref5 : _i >= _ref5; _ref4 <= _ref5 ? _i++ : _i--){ _results.push(_i); } |
| return _results; |
| }).apply(this); |
| if (this.exclusive) { |
| range.pop(); |
| } |
| return [this.makeCode("[" + (range.join(', ')) + "]")]; |
| } |
| idt = this.tab + TAB; |
| i = o.scope.freeVariable('i'); |
| result = o.scope.freeVariable('results'); |
| pre = "\n" + idt + result + " = [];"; |
| if (this.fromNum && this.toNum) { |
| o.index = i; |
| body = fragmentsToText(this.compileNode(o)); |
| } else { |
| vars = ("" + i + " = " + this.fromC) + (this.toC !== this.toVar ? ", " + this.toC : ''); |
| cond = "" + this.fromVar + " <= " + this.toVar; |
| body = "var " + vars + "; " + cond + " ? " + i + " <" + this.equals + " " + this.toVar + " : " + i + " >" + this.equals + " " + this.toVar + "; " + cond + " ? " + i + "++ : " + i + "--"; |
| } |
| post = "{ " + result + ".push(" + i + "); }\n" + idt + "return " + result + ";\n" + o.indent; |
| hasArgs = function(node) { |
| return node != null ? node.contains(function(n) { |
| return n instanceof Literal && n.value === 'arguments' && !n.asKey; |
| }) : void 0; |
| }; |
| if (hasArgs(this.from) || hasArgs(this.to)) { |
| args = ', arguments'; |
| } |
| return [this.makeCode("(function() {" + pre + "\n" + idt + "for (" + body + ")" + post + "}).apply(this" + (args != null ? args : '') + ")")]; |
| }; |
| |
| return Range; |
| |
| })(Base); |
| |
| exports.Slice = Slice = (function(_super) { |
| __extends(Slice, _super); |
| |
| Slice.prototype.children = ['range']; |
| |
| function Slice(range) { |
| this.range = range; |
| Slice.__super__.constructor.call(this); |
| } |
| |
| Slice.prototype.compileNode = function(o) { |
| var compiled, compiledText, from, fromCompiled, to, toStr, _ref4; |
| _ref4 = this.range, to = _ref4.to, from = _ref4.from; |
| fromCompiled = from && from.compileToFragments(o, LEVEL_PAREN) || [this.makeCode('0')]; |
| if (to) { |
| compiled = to.compileToFragments(o, LEVEL_PAREN); |
| compiledText = fragmentsToText(compiled); |
| if (!(!this.range.exclusive && +compiledText === -1)) { |
| toStr = ', ' + (this.range.exclusive ? compiledText : SIMPLENUM.test(compiledText) ? "" + (+compiledText + 1) : (compiled = to.compileToFragments(o, LEVEL_ACCESS), "+" + (fragmentsToText(compiled)) + " + 1 || 9e9")); |
| } |
| } |
| return [this.makeCode(".slice(" + (fragmentsToText(fromCompiled)) + (toStr || '') + ")")]; |
| }; |
| |
| return Slice; |
| |
| })(Base); |
| |
| exports.Obj = Obj = (function(_super) { |
| __extends(Obj, _super); |
| |
| function Obj(props, generated) { |
| this.generated = generated != null ? generated : false; |
| this.objects = this.properties = props || []; |
| } |
| |
| Obj.prototype.children = ['properties']; |
| |
| Obj.prototype.compileNode = function(o) { |
| var answer, i, idt, indent, join, lastNoncom, node, prop, props, _i, _j, _len, _len1; |
| props = this.properties; |
| if (!props.length) { |
| return [this.makeCode(this.front ? '({})' : '{}')]; |
| } |
| if (this.generated) { |
| for (_i = 0, _len = props.length; _i < _len; _i++) { |
| node = props[_i]; |
| if (node instanceof Value) { |
| node.error('cannot have an implicit value in an implicit object'); |
| } |
| } |
| } |
| idt = o.indent += TAB; |
| lastNoncom = this.lastNonComment(this.properties); |
| answer = []; |
| for (i = _j = 0, _len1 = props.length; _j < _len1; i = ++_j) { |
| prop = props[i]; |
| join = i === props.length - 1 ? '' : prop === lastNoncom || prop instanceof Comment ? '\n' : ',\n'; |
| indent = prop instanceof Comment ? '' : idt; |
| if (prop instanceof Assign && prop.variable instanceof Value && prop.variable.hasProperties()) { |
| prop.variable.error('Invalid object key'); |
| } |
| if (prop instanceof Value && prop["this"]) { |
| prop = new Assign(prop.properties[0].name, prop, 'object'); |
| } |
| if (!(prop instanceof Comment)) { |
| if (!(prop instanceof Assign)) { |
| prop = new Assign(prop, prop, 'object'); |
| } |
| (prop.variable.base || prop.variable).asKey = true; |
| } |
| if (indent) { |
| answer.push(this.makeCode(indent)); |
| } |
| answer.push.apply(answer, prop.compileToFragments(o, LEVEL_TOP)); |
| if (join) { |
| answer.push(this.makeCode(join)); |
| } |
| } |
| answer.unshift(this.makeCode("{" + (props.length && '\n'))); |
| answer.push(this.makeCode("" + (props.length && '\n' + this.tab) + "}")); |
| if (this.front) { |
| return this.wrapInBraces(answer); |
| } else { |
| return answer; |
| } |
| }; |
| |
| Obj.prototype.assigns = function(name) { |
| var prop, _i, _len, _ref4; |
| _ref4 = this.properties; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| prop = _ref4[_i]; |
| if (prop.assigns(name)) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| return Obj; |
| |
| })(Base); |
| |
| exports.Arr = Arr = (function(_super) { |
| __extends(Arr, _super); |
| |
| function Arr(objs) { |
| this.objects = objs || []; |
| } |
| |
| Arr.prototype.children = ['objects']; |
| |
| Arr.prototype.compileNode = function(o) { |
| var answer, compiledObjs, fragments, index, obj, _i, _len; |
| if (!this.objects.length) { |
| return [this.makeCode('[]')]; |
| } |
| o.indent += TAB; |
| answer = Splat.compileSplattedArray(o, this.objects); |
| if (answer.length) { |
| return answer; |
| } |
| answer = []; |
| compiledObjs = (function() { |
| var _i, _len, _ref4, _results; |
| _ref4 = this.objects; |
| _results = []; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| obj = _ref4[_i]; |
| _results.push(obj.compileToFragments(o, LEVEL_LIST)); |
| } |
| return _results; |
| }).call(this); |
| for (index = _i = 0, _len = compiledObjs.length; _i < _len; index = ++_i) { |
| fragments = compiledObjs[index]; |
| if (index) { |
| answer.push(this.makeCode(", ")); |
| } |
| answer.push.apply(answer, fragments); |
| } |
| if (fragmentsToText(answer).indexOf('\n') >= 0) { |
| answer.unshift(this.makeCode("[\n" + o.indent)); |
| answer.push(this.makeCode("\n" + this.tab + "]")); |
| } else { |
| answer.unshift(this.makeCode("[")); |
| answer.push(this.makeCode("]")); |
| } |
| return answer; |
| }; |
| |
| Arr.prototype.assigns = function(name) { |
| var obj, _i, _len, _ref4; |
| _ref4 = this.objects; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| obj = _ref4[_i]; |
| if (obj.assigns(name)) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| return Arr; |
| |
| })(Base); |
| |
| exports.Class = Class = (function(_super) { |
| __extends(Class, _super); |
| |
| function Class(variable, parent, body) { |
| this.variable = variable; |
| this.parent = parent; |
| this.body = body != null ? body : new Block; |
| this.boundFuncs = []; |
| this.body.classBody = true; |
| } |
| |
| Class.prototype.children = ['variable', 'parent', 'body']; |
| |
| Class.prototype.determineName = function() { |
| var decl, tail; |
| if (!this.variable) { |
| return null; |
| } |
| decl = (tail = last(this.variable.properties)) ? tail instanceof Access && tail.name.value : this.variable.base.value; |
| if (__indexOf.call(STRICT_PROSCRIBED, decl) >= 0) { |
| this.variable.error("class variable name may not be " + decl); |
| } |
| return decl && (decl = IDENTIFIER.test(decl) && decl); |
| }; |
| |
| Class.prototype.setContext = function(name) { |
| return this.body.traverseChildren(false, function(node) { |
| if (node.classBody) { |
| return false; |
| } |
| if (node instanceof Literal && node.value === 'this') { |
| return node.value = name; |
| } else if (node instanceof Code) { |
| node.klass = name; |
| if (node.bound) { |
| return node.context = name; |
| } |
| } |
| }); |
| }; |
| |
| Class.prototype.addBoundFunctions = function(o) { |
| var bvar, lhs, _i, _len, _ref4; |
| _ref4 = this.boundFuncs; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| bvar = _ref4[_i]; |
| lhs = (new Value(new Literal("this"), [new Access(bvar)])).compile(o); |
| this.ctor.body.unshift(new Literal("" + lhs + " = " + (utility('bind')) + "(" + lhs + ", this)")); |
| } |
| }; |
| |
| Class.prototype.addProperties = function(node, name, o) { |
| var assign, base, exprs, func, props; |
| props = node.base.properties.slice(0); |
| exprs = (function() { |
| var _results; |
| _results = []; |
| while (assign = props.shift()) { |
| if (assign instanceof Assign) { |
| base = assign.variable.base; |
| delete assign.context; |
| func = assign.value; |
| if (base.value === 'constructor') { |
| if (this.ctor) { |
| assign.error('cannot define more than one constructor in a class'); |
| } |
| if (func.bound) { |
| assign.error('cannot define a constructor as a bound function'); |
| } |
| if (func instanceof Code) { |
| assign = this.ctor = func; |
| } else { |
| this.externalCtor = o.scope.freeVariable('class'); |
| assign = new Assign(new Literal(this.externalCtor), func); |
| } |
| } else { |
| if (assign.variable["this"]) { |
| func["static"] = true; |
| if (func.bound) { |
| func.context = name; |
| } |
| } else { |
| assign.variable = new Value(new Literal(name), [new Access(new Literal('prototype')), new Access(base)]); |
| if (func instanceof Code && func.bound) { |
| this.boundFuncs.push(base); |
| func.bound = false; |
| } |
| } |
| } |
| } |
| _results.push(assign); |
| } |
| return _results; |
| }).call(this); |
| return compact(exprs); |
| }; |
| |
| Class.prototype.walkBody = function(name, o) { |
| var _this = this; |
| return this.traverseChildren(false, function(child) { |
| var cont, exps, i, node, _i, _len, _ref4; |
| cont = true; |
| if (child instanceof Class) { |
| return false; |
| } |
| if (child instanceof Block) { |
| _ref4 = exps = child.expressions; |
| for (i = _i = 0, _len = _ref4.length; _i < _len; i = ++_i) { |
| node = _ref4[i]; |
| if (node instanceof Value && node.isObject(true)) { |
| cont = false; |
| exps[i] = _this.addProperties(node, name, o); |
| } |
| } |
| child.expressions = exps = flatten(exps); |
| } |
| return cont && !(child instanceof Class); |
| }); |
| }; |
| |
| Class.prototype.hoistDirectivePrologue = function() { |
| var expressions, index, node; |
| index = 0; |
| expressions = this.body.expressions; |
| while ((node = expressions[index]) && node instanceof Comment || node instanceof Value && node.isString()) { |
| ++index; |
| } |
| return this.directives = expressions.splice(0, index); |
| }; |
| |
| Class.prototype.ensureConstructor = function(name, o) { |
| var missing, ref, superCall; |
| missing = !this.ctor; |
| this.ctor || (this.ctor = new Code); |
| this.ctor.ctor = this.ctor.name = name; |
| this.ctor.klass = null; |
| this.ctor.noReturn = true; |
| if (missing) { |
| if (this.parent) { |
| superCall = new Literal("" + name + ".__super__.constructor.apply(this, arguments)"); |
| } |
| if (this.externalCtor) { |
| superCall = new Literal("" + this.externalCtor + ".apply(this, arguments)"); |
| } |
| if (superCall) { |
| ref = new Literal(o.scope.freeVariable('ref')); |
| this.ctor.body.unshift(new Assign(ref, superCall)); |
| } |
| this.addBoundFunctions(o); |
| if (superCall) { |
| this.ctor.body.push(ref); |
| this.ctor.body.makeReturn(); |
| } |
| return this.body.expressions.unshift(this.ctor); |
| } else { |
| return this.addBoundFunctions(o); |
| } |
| }; |
| |
| Class.prototype.compileNode = function(o) { |
| var call, decl, klass, lname, name, params, _ref4; |
| decl = this.determineName(); |
| name = decl || '_Class'; |
| if (name.reserved) { |
| name = "_" + name; |
| } |
| lname = new Literal(name); |
| this.hoistDirectivePrologue(); |
| this.setContext(name); |
| this.walkBody(name, o); |
| this.ensureConstructor(name, o); |
| this.body.spaced = true; |
| if (!(this.ctor instanceof Code)) { |
| this.body.expressions.unshift(this.ctor); |
| } |
| this.body.expressions.push(lname); |
| (_ref4 = this.body.expressions).unshift.apply(_ref4, this.directives); |
| call = Closure.wrap(this.body); |
| if (this.parent) { |
| this.superClass = new Literal(o.scope.freeVariable('super', false)); |
| this.body.expressions.unshift(new Extends(lname, this.superClass)); |
| call.args.push(this.parent); |
| params = call.variable.params || call.variable.base.params; |
| params.push(new Param(this.superClass)); |
| } |
| klass = new Parens(call, true); |
| if (this.variable) { |
| klass = new Assign(this.variable, klass); |
| } |
| return klass.compileToFragments(o); |
| }; |
| |
| return Class; |
| |
| })(Base); |
| |
| exports.Assign = Assign = (function(_super) { |
| __extends(Assign, _super); |
| |
| function Assign(variable, value, context, options) { |
| var forbidden, name, _ref4; |
| this.variable = variable; |
| this.value = value; |
| this.context = context; |
| this.param = options && options.param; |
| this.subpattern = options && options.subpattern; |
| forbidden = (_ref4 = (name = this.variable.unwrapAll().value), __indexOf.call(STRICT_PROSCRIBED, _ref4) >= 0); |
| if (forbidden && this.context !== 'object') { |
| this.variable.error("variable name may not be \"" + name + "\""); |
| } |
| } |
| |
| Assign.prototype.children = ['variable', 'value']; |
| |
| Assign.prototype.isStatement = function(o) { |
| return (o != null ? o.level : void 0) === LEVEL_TOP && (this.context != null) && __indexOf.call(this.context, "?") >= 0; |
| }; |
| |
| Assign.prototype.assigns = function(name) { |
| return this[this.context === 'object' ? 'value' : 'variable'].assigns(name); |
| }; |
| |
| Assign.prototype.unfoldSoak = function(o) { |
| return unfoldSoak(o, this, 'variable'); |
| }; |
| |
| Assign.prototype.compileNode = function(o) { |
| var answer, compiledName, isValue, match, name, val, varBase, _ref4, _ref5, _ref6, _ref7; |
| if (isValue = this.variable instanceof Value) { |
| if (this.variable.isArray() || this.variable.isObject()) { |
| return this.compilePatternMatch(o); |
| } |
| if (this.variable.isSplice()) { |
| return this.compileSplice(o); |
| } |
| if ((_ref4 = this.context) === '||=' || _ref4 === '&&=' || _ref4 === '?=') { |
| return this.compileConditional(o); |
| } |
| } |
| compiledName = this.variable.compileToFragments(o, LEVEL_LIST); |
| name = fragmentsToText(compiledName); |
| if (!this.context) { |
| varBase = this.variable.unwrapAll(); |
| if (!varBase.isAssignable()) { |
| this.variable.error("\"" + (this.variable.compile(o)) + "\" cannot be assigned"); |
| } |
| if (!(typeof varBase.hasProperties === "function" ? varBase.hasProperties() : void 0)) { |
| if (this.param) { |
| o.scope.add(name, 'var'); |
| } else { |
| o.scope.find(name); |
| } |
| } |
| } |
| if (this.value instanceof Code && (match = METHOD_DEF.exec(name))) { |
| if (match[1]) { |
| this.value.klass = match[1]; |
| } |
| this.value.name = (_ref5 = (_ref6 = (_ref7 = match[2]) != null ? _ref7 : match[3]) != null ? _ref6 : match[4]) != null ? _ref5 : match[5]; |
| } |
| val = this.value.compileToFragments(o, LEVEL_LIST); |
| if (this.context === 'object') { |
| return compiledName.concat(this.makeCode(": "), val); |
| } |
| answer = compiledName.concat(this.makeCode(" " + (this.context || '=') + " "), val); |
| if (o.level <= LEVEL_LIST) { |
| return answer; |
| } else { |
| return this.wrapInBraces(answer); |
| } |
| }; |
| |
| Assign.prototype.compilePatternMatch = function(o) { |
| var acc, assigns, code, fragments, i, idx, isObject, ivar, name, obj, objects, olen, ref, rest, splat, top, val, value, vvar, vvarText, _i, _len, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9; |
| top = o.level === LEVEL_TOP; |
| value = this.value; |
| objects = this.variable.base.objects; |
| if (!(olen = objects.length)) { |
| code = value.compileToFragments(o); |
| if (o.level >= LEVEL_OP) { |
| return this.wrapInBraces(code); |
| } else { |
| return code; |
| } |
| } |
| isObject = this.variable.isObject(); |
| if (top && olen === 1 && !((obj = objects[0]) instanceof Splat)) { |
| if (obj instanceof Assign) { |
| _ref4 = obj, (_ref5 = _ref4.variable, idx = _ref5.base), obj = _ref4.value; |
| } else { |
| idx = isObject ? obj["this"] ? obj.properties[0].name : obj : new Literal(0); |
| } |
| acc = IDENTIFIER.test(idx.unwrap().value || 0); |
| value = new Value(value); |
| value.properties.push(new (acc ? Access : Index)(idx)); |
| if (_ref6 = obj.unwrap().value, __indexOf.call(RESERVED, _ref6) >= 0) { |
| obj.error("assignment to a reserved word: " + (obj.compile(o))); |
| } |
| return new Assign(obj, value, null, { |
| param: this.param |
| }).compileToFragments(o, LEVEL_TOP); |
| } |
| vvar = value.compileToFragments(o, LEVEL_LIST); |
| vvarText = fragmentsToText(vvar); |
| assigns = []; |
| splat = false; |
| if (!IDENTIFIER.test(vvarText) || this.variable.assigns(vvarText)) { |
| assigns.push([this.makeCode("" + (ref = o.scope.freeVariable('ref')) + " = ")].concat(__slice.call(vvar))); |
| vvar = [this.makeCode(ref)]; |
| vvarText = ref; |
| } |
| for (i = _i = 0, _len = objects.length; _i < _len; i = ++_i) { |
| obj = objects[i]; |
| idx = i; |
| if (isObject) { |
| if (obj instanceof Assign) { |
| _ref7 = obj, (_ref8 = _ref7.variable, idx = _ref8.base), obj = _ref7.value; |
| } else { |
| if (obj.base instanceof Parens) { |
| _ref9 = new Value(obj.unwrapAll()).cacheReference(o), obj = _ref9[0], idx = _ref9[1]; |
| } else { |
| idx = obj["this"] ? obj.properties[0].name : obj; |
| } |
| } |
| } |
| if (!splat && obj instanceof Splat) { |
| name = obj.name.unwrap().value; |
| obj = obj.unwrap(); |
| val = "" + olen + " <= " + vvarText + ".length ? " + (utility('slice')) + ".call(" + vvarText + ", " + i; |
| if (rest = olen - i - 1) { |
| ivar = o.scope.freeVariable('i'); |
| val += ", " + ivar + " = " + vvarText + ".length - " + rest + ") : (" + ivar + " = " + i + ", [])"; |
| } else { |
| val += ") : []"; |
| } |
| val = new Literal(val); |
| splat = "" + ivar + "++"; |
| } else { |
| name = obj.unwrap().value; |
| if (obj instanceof Splat) { |
| obj.error("multiple splats are disallowed in an assignment"); |
| } |
| if (typeof idx === 'number') { |
| idx = new Literal(splat || idx); |
| acc = false; |
| } else { |
| acc = isObject && IDENTIFIER.test(idx.unwrap().value || 0); |
| } |
| val = new Value(new Literal(vvarText), [new (acc ? Access : Index)(idx)]); |
| } |
| if ((name != null) && __indexOf.call(RESERVED, name) >= 0) { |
| obj.error("assignment to a reserved word: " + (obj.compile(o))); |
| } |
| assigns.push(new Assign(obj, val, null, { |
| param: this.param, |
| subpattern: true |
| }).compileToFragments(o, LEVEL_LIST)); |
| } |
| if (!(top || this.subpattern)) { |
| assigns.push(vvar); |
| } |
| fragments = this.joinFragmentArrays(assigns, ', '); |
| if (o.level < LEVEL_LIST) { |
| return fragments; |
| } else { |
| return this.wrapInBraces(fragments); |
| } |
| }; |
| |
| Assign.prototype.compileConditional = function(o) { |
| var left, right, _ref4; |
| _ref4 = this.variable.cacheReference(o), left = _ref4[0], right = _ref4[1]; |
| if (!left.properties.length && left.base instanceof Literal && left.base.value !== "this" && !o.scope.check(left.base.value)) { |
| this.variable.error("the variable \"" + left.base.value + "\" can't be assigned with " + this.context + " because it has not been declared before"); |
| } |
| if (__indexOf.call(this.context, "?") >= 0) { |
| o.isExistentialEquals = true; |
| } |
| return new Op(this.context.slice(0, -1), left, new Assign(right, this.value, '=')).compileToFragments(o); |
| }; |
| |
| Assign.prototype.compileSplice = function(o) { |
| var answer, exclusive, from, fromDecl, fromRef, name, to, valDef, valRef, _ref4, _ref5, _ref6; |
| _ref4 = this.variable.properties.pop().range, from = _ref4.from, to = _ref4.to, exclusive = _ref4.exclusive; |
| name = this.variable.compile(o); |
| if (from) { |
| _ref5 = this.cacheToCodeFragments(from.cache(o, LEVEL_OP)), fromDecl = _ref5[0], fromRef = _ref5[1]; |
| } else { |
| fromDecl = fromRef = '0'; |
| } |
| if (to) { |
| if ((from != null ? from.isSimpleNumber() : void 0) && to.isSimpleNumber()) { |
| to = +to.compile(o) - +fromRef; |
| if (!exclusive) { |
| to += 1; |
| } |
| } else { |
| to = to.compile(o, LEVEL_ACCESS) + ' - ' + fromRef; |
| if (!exclusive) { |
| to += ' + 1'; |
| } |
| } |
| } else { |
| to = "9e9"; |
| } |
| _ref6 = this.value.cache(o, LEVEL_LIST), valDef = _ref6[0], valRef = _ref6[1]; |
| answer = [].concat(this.makeCode("[].splice.apply(" + name + ", [" + fromDecl + ", " + to + "].concat("), valDef, this.makeCode(")), "), valRef); |
| if (o.level > LEVEL_TOP) { |
| return this.wrapInBraces(answer); |
| } else { |
| return answer; |
| } |
| }; |
| |
| return Assign; |
| |
| })(Base); |
| |
| exports.Code = Code = (function(_super) { |
| __extends(Code, _super); |
| |
| function Code(params, body, tag) { |
| this.params = params || []; |
| this.body = body || new Block; |
| this.bound = tag === 'boundfunc'; |
| if (this.bound) { |
| this.context = '_this'; |
| } |
| } |
| |
| Code.prototype.children = ['params', 'body']; |
| |
| Code.prototype.isStatement = function() { |
| return !!this.ctor; |
| }; |
| |
| Code.prototype.jumps = NO; |
| |
| Code.prototype.compileNode = function(o) { |
| var answer, code, exprs, i, idt, lit, p, param, params, ref, splats, uniqs, val, wasEmpty, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _m, _ref4, _ref5, _ref6, _ref7, _ref8; |
| o.scope = new Scope(o.scope, this.body, this); |
| o.scope.shared = del(o, 'sharedScope'); |
| o.indent += TAB; |
| delete o.bare; |
| delete o.isExistentialEquals; |
| params = []; |
| exprs = []; |
| this.eachParamName(function(name) { |
| if (!o.scope.check(name)) { |
| return o.scope.parameter(name); |
| } |
| }); |
| _ref4 = this.params; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| param = _ref4[_i]; |
| if (!param.splat) { |
| continue; |
| } |
| _ref5 = this.params; |
| for (_j = 0, _len1 = _ref5.length; _j < _len1; _j++) { |
| p = _ref5[_j].name; |
| if (p["this"]) { |
| p = p.properties[0].name; |
| } |
| if (p.value) { |
| o.scope.add(p.value, 'var', true); |
| } |
| } |
| splats = new Assign(new Value(new Arr((function() { |
| var _k, _len2, _ref6, _results; |
| _ref6 = this.params; |
| _results = []; |
| for (_k = 0, _len2 = _ref6.length; _k < _len2; _k++) { |
| p = _ref6[_k]; |
| _results.push(p.asReference(o)); |
| } |
| return _results; |
| }).call(this))), new Value(new Literal('arguments'))); |
| break; |
| } |
| _ref6 = this.params; |
| for (_k = 0, _len2 = _ref6.length; _k < _len2; _k++) { |
| param = _ref6[_k]; |
| if (param.isComplex()) { |
| val = ref = param.asReference(o); |
| if (param.value) { |
| val = new Op('?', ref, param.value); |
| } |
| exprs.push(new Assign(new Value(param.name), val, '=', { |
| param: true |
| })); |
| } else { |
| ref = param; |
| if (param.value) { |
| lit = new Literal(ref.name.value + ' == null'); |
| val = new Assign(new Value(param.name), param.value, '='); |
| exprs.push(new If(lit, val)); |
| } |
| } |
| if (!splats) { |
| params.push(ref); |
| } |
| } |
| wasEmpty = this.body.isEmpty(); |
| if (splats) { |
| exprs.unshift(splats); |
| } |
| if (exprs.length) { |
| (_ref7 = this.body.expressions).unshift.apply(_ref7, exprs); |
| } |
| for (i = _l = 0, _len3 = params.length; _l < _len3; i = ++_l) { |
| p = params[i]; |
| params[i] = p.compileToFragments(o); |
| o.scope.parameter(fragmentsToText(params[i])); |
| } |
| uniqs = []; |
| this.eachParamName(function(name, node) { |
| if (__indexOf.call(uniqs, name) >= 0) { |
| node.error("multiple parameters named '" + name + "'"); |
| } |
| return uniqs.push(name); |
| }); |
| if (!(wasEmpty || this.noReturn)) { |
| this.body.makeReturn(); |
| } |
| if (this.bound) { |
| if ((_ref8 = o.scope.parent.method) != null ? _ref8.bound : void 0) { |
| this.bound = this.context = o.scope.parent.method.context; |
| } else if (!this["static"]) { |
| o.scope.parent.assign('_this', 'this'); |
| } |
| } |
| idt = o.indent; |
| code = 'function'; |
| if (this.ctor) { |
| code += ' ' + this.name; |
| } |
| code += '('; |
| answer = [this.makeCode(code)]; |
| for (i = _m = 0, _len4 = params.length; _m < _len4; i = ++_m) { |
| p = params[i]; |
| if (i) { |
| answer.push(this.makeCode(", ")); |
| } |
| answer.push.apply(answer, p); |
| } |
| answer.push(this.makeCode(') {')); |
| if (!this.body.isEmpty()) { |
| answer = answer.concat(this.makeCode("\n"), this.body.compileWithDeclarations(o), this.makeCode("\n" + this.tab)); |
| } |
| answer.push(this.makeCode('}')); |
| if (this.ctor) { |
| return [this.makeCode(this.tab)].concat(__slice.call(answer)); |
| } |
| if (this.front || (o.level >= LEVEL_ACCESS)) { |
| return this.wrapInBraces(answer); |
| } else { |
| return answer; |
| } |
| }; |
| |
| Code.prototype.eachParamName = function(iterator) { |
| var param, _i, _len, _ref4, _results; |
| _ref4 = this.params; |
| _results = []; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| param = _ref4[_i]; |
| _results.push(param.eachName(iterator)); |
| } |
| return _results; |
| }; |
| |
| Code.prototype.traverseChildren = function(crossScope, func) { |
| if (crossScope) { |
| return Code.__super__.traverseChildren.call(this, crossScope, func); |
| } |
| }; |
| |
| return Code; |
| |
| })(Base); |
| |
| exports.Param = Param = (function(_super) { |
| __extends(Param, _super); |
| |
| function Param(name, value, splat) { |
| var _ref4; |
| this.name = name; |
| this.value = value; |
| this.splat = splat; |
| if (_ref4 = (name = this.name.unwrapAll().value), __indexOf.call(STRICT_PROSCRIBED, _ref4) >= 0) { |
| this.name.error("parameter name \"" + name + "\" is not allowed"); |
| } |
| } |
| |
| Param.prototype.children = ['name', 'value']; |
| |
| Param.prototype.compileToFragments = function(o) { |
| return this.name.compileToFragments(o, LEVEL_LIST); |
| }; |
| |
| Param.prototype.asReference = function(o) { |
| var node; |
| if (this.reference) { |
| return this.reference; |
| } |
| node = this.name; |
| if (node["this"]) { |
| node = node.properties[0].name; |
| if (node.value.reserved) { |
| node = new Literal(o.scope.freeVariable(node.value)); |
| } |
| } else if (node.isComplex()) { |
| node = new Literal(o.scope.freeVariable('arg')); |
| } |
| node = new Value(node); |
| if (this.splat) { |
| node = new Splat(node); |
| } |
| return this.reference = node; |
| }; |
| |
| Param.prototype.isComplex = function() { |
| return this.name.isComplex(); |
| }; |
| |
| Param.prototype.eachName = function(iterator, name) { |
| var atParam, node, obj, _i, _len, _ref4; |
| if (name == null) { |
| name = this.name; |
| } |
| atParam = function(obj) { |
| var node; |
| node = obj.properties[0].name; |
| if (!node.value.reserved) { |
| return iterator(node.value, node); |
| } |
| }; |
| if (name instanceof Literal) { |
| return iterator(name.value, name); |
| } |
| if (name instanceof Value) { |
| return atParam(name); |
| } |
| _ref4 = name.objects; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| obj = _ref4[_i]; |
| if (obj instanceof Assign) { |
| this.eachName(iterator, obj.value.unwrap()); |
| } else if (obj instanceof Splat) { |
| node = obj.name.unwrap(); |
| iterator(node.value, node); |
| } else if (obj instanceof Value) { |
| if (obj.isArray() || obj.isObject()) { |
| this.eachName(iterator, obj.base); |
| } else if (obj["this"]) { |
| atParam(obj); |
| } else { |
| iterator(obj.base.value, obj.base); |
| } |
| } else { |
| obj.error("illegal parameter " + (obj.compile())); |
| } |
| } |
| }; |
| |
| return Param; |
| |
| })(Base); |
| |
| exports.Splat = Splat = (function(_super) { |
| __extends(Splat, _super); |
| |
| Splat.prototype.children = ['name']; |
| |
| Splat.prototype.isAssignable = YES; |
| |
| function Splat(name) { |
| this.name = name.compile ? name : new Literal(name); |
| } |
| |
| Splat.prototype.assigns = function(name) { |
| return this.name.assigns(name); |
| }; |
| |
| Splat.prototype.compileToFragments = function(o) { |
| return this.name.compileToFragments(o); |
| }; |
| |
| Splat.prototype.unwrap = function() { |
| return this.name; |
| }; |
| |
| Splat.compileSplattedArray = function(o, list, apply) { |
| var args, base, compiledNode, concatPart, fragments, i, index, node, _i, _len; |
| index = -1; |
| while ((node = list[++index]) && !(node instanceof Splat)) { |
| continue; |
| } |
| if (index >= list.length) { |
| return []; |
| } |
| if (list.length === 1) { |
| node = list[0]; |
| fragments = node.compileToFragments(o, LEVEL_LIST); |
| if (apply) { |
| return fragments; |
| } |
| return [].concat(node.makeCode("" + (utility('slice')) + ".call("), fragments, node.makeCode(")")); |
| } |
| args = list.slice(index); |
| for (i = _i = 0, _len = args.length; _i < _len; i = ++_i) { |
| node = args[i]; |
| compiledNode = node.compileToFragments(o, LEVEL_LIST); |
| args[i] = node instanceof Splat ? [].concat(node.makeCode("" + (utility('slice')) + ".call("), compiledNode, node.makeCode(")")) : [].concat(node.makeCode("["), compiledNode, node.makeCode("]")); |
| } |
| if (index === 0) { |
| node = list[0]; |
| concatPart = node.joinFragmentArrays(args.slice(1), ', '); |
| return args[0].concat(node.makeCode(".concat("), concatPart, node.makeCode(")")); |
| } |
| base = (function() { |
| var _j, _len1, _ref4, _results; |
| _ref4 = list.slice(0, index); |
| _results = []; |
| for (_j = 0, _len1 = _ref4.length; _j < _len1; _j++) { |
| node = _ref4[_j]; |
| _results.push(node.compileToFragments(o, LEVEL_LIST)); |
| } |
| return _results; |
| })(); |
| base = list[0].joinFragmentArrays(base, ', '); |
| concatPart = list[index].joinFragmentArrays(args, ', '); |
| return [].concat(list[0].makeCode("["), base, list[index].makeCode("].concat("), concatPart, (last(list)).makeCode(")")); |
| }; |
| |
| return Splat; |
| |
| })(Base); |
| |
| exports.While = While = (function(_super) { |
| __extends(While, _super); |
| |
| function While(condition, options) { |
| this.condition = (options != null ? options.invert : void 0) ? condition.invert() : condition; |
| this.guard = options != null ? options.guard : void 0; |
| } |
| |
| While.prototype.children = ['condition', 'guard', 'body']; |
| |
| While.prototype.isStatement = YES; |
| |
| While.prototype.makeReturn = function(res) { |
| if (res) { |
| return While.__super__.makeReturn.apply(this, arguments); |
| } else { |
| this.returns = !this.jumps({ |
| loop: true |
| }); |
| return this; |
| } |
| }; |
| |
| While.prototype.addBody = function(body) { |
| this.body = body; |
| return this; |
| }; |
| |
| While.prototype.jumps = function() { |
| var expressions, node, _i, _len; |
| expressions = this.body.expressions; |
| if (!expressions.length) { |
| return false; |
| } |
| for (_i = 0, _len = expressions.length; _i < _len; _i++) { |
| node = expressions[_i]; |
| if (node.jumps({ |
| loop: true |
| })) { |
| return node; |
| } |
| } |
| return false; |
| }; |
| |
| While.prototype.compileNode = function(o) { |
| var answer, body, rvar, set; |
| o.indent += TAB; |
| set = ''; |
| body = this.body; |
| if (body.isEmpty()) { |
| body = this.makeCode(''); |
| } else { |
| if (this.returns) { |
| body.makeReturn(rvar = o.scope.freeVariable('results')); |
| set = "" + this.tab + rvar + " = [];\n"; |
| } |
| if (this.guard) { |
| if (body.expressions.length > 1) { |
| body.expressions.unshift(new If((new Parens(this.guard)).invert(), new Literal("continue"))); |
| } else { |
| if (this.guard) { |
| body = Block.wrap([new If(this.guard, body)]); |
| } |
| } |
| } |
| body = [].concat(this.makeCode("\n"), body.compileToFragments(o, LEVEL_TOP), this.makeCode("\n" + this.tab)); |
| } |
| answer = [].concat(this.makeCode(set + this.tab + "while ("), this.condition.compileToFragments(o, LEVEL_PAREN), this.makeCode(") {"), body, this.makeCode("}")); |
| if (this.returns) { |
| answer.push(this.makeCode("\n" + this.tab + "return " + rvar + ";")); |
| } |
| return answer; |
| }; |
| |
| return While; |
| |
| })(Base); |
| |
| exports.Op = Op = (function(_super) { |
| var CONVERSIONS, INVERSIONS; |
| |
| __extends(Op, _super); |
| |
| function Op(op, first, second, flip) { |
| if (op === 'in') { |
| return new In(first, second); |
| } |
| if (op === 'do') { |
| return this.generateDo(first); |
| } |
| if (op === 'new') { |
| if (first instanceof Call && !first["do"] && !first.isNew) { |
| return first.newInstance(); |
| } |
| if (first instanceof Code && first.bound || first["do"]) { |
| first = new Parens(first); |
| } |
| } |
| this.operator = CONVERSIONS[op] || op; |
| this.first = first; |
| this.second = second; |
| this.flip = !!flip; |
| return this; |
| } |
| |
| CONVERSIONS = { |
| '==': '===', |
| '!=': '!==', |
| 'of': 'in' |
| }; |
| |
| INVERSIONS = { |
| '!==': '===', |
| '===': '!==' |
| }; |
| |
| Op.prototype.children = ['first', 'second']; |
| |
| Op.prototype.isSimpleNumber = NO; |
| |
| Op.prototype.isUnary = function() { |
| return !this.second; |
| }; |
| |
| Op.prototype.isComplex = function() { |
| var _ref4; |
| return !(this.isUnary() && ((_ref4 = this.operator) === '+' || _ref4 === '-')) || this.first.isComplex(); |
| }; |
| |
| Op.prototype.isChainable = function() { |
| var _ref4; |
| return (_ref4 = this.operator) === '<' || _ref4 === '>' || _ref4 === '>=' || _ref4 === '<=' || _ref4 === '===' || _ref4 === '!=='; |
| }; |
| |
| Op.prototype.invert = function() { |
| var allInvertable, curr, fst, op, _ref4; |
| if (this.isChainable() && this.first.isChainable()) { |
| allInvertable = true; |
| curr = this; |
| while (curr && curr.operator) { |
| allInvertable && (allInvertable = curr.operator in INVERSIONS); |
| curr = curr.first; |
| } |
| if (!allInvertable) { |
| return new Parens(this).invert(); |
| } |
| curr = this; |
| while (curr && curr.operator) { |
| curr.invert = !curr.invert; |
| curr.operator = INVERSIONS[curr.operator]; |
| curr = curr.first; |
| } |
| return this; |
| } else if (op = INVERSIONS[this.operator]) { |
| this.operator = op; |
| if (this.first.unwrap() instanceof Op) { |
| this.first.invert(); |
| } |
| return this; |
| } else if (this.second) { |
| return new Parens(this).invert(); |
| } else if (this.operator === '!' && (fst = this.first.unwrap()) instanceof Op && ((_ref4 = fst.operator) === '!' || _ref4 === 'in' || _ref4 === 'instanceof')) { |
| return fst; |
| } else { |
| return new Op('!', this); |
| } |
| }; |
| |
| Op.prototype.unfoldSoak = function(o) { |
| var _ref4; |
| return ((_ref4 = this.operator) === '++' || _ref4 === '--' || _ref4 === 'delete') && unfoldSoak(o, this, 'first'); |
| }; |
| |
| Op.prototype.generateDo = function(exp) { |
| var call, func, param, passedParams, ref, _i, _len, _ref4; |
| passedParams = []; |
| func = exp instanceof Assign && (ref = exp.value.unwrap()) instanceof Code ? ref : exp; |
| _ref4 = func.params || []; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| param = _ref4[_i]; |
| if (param.value) { |
| passedParams.push(param.value); |
| delete param.value; |
| } else { |
| passedParams.push(param); |
| } |
| } |
| call = new Call(exp, passedParams); |
| call["do"] = true; |
| return call; |
| }; |
| |
| Op.prototype.compileNode = function(o) { |
| var answer, isChain, _ref4, _ref5; |
| isChain = this.isChainable() && this.first.isChainable(); |
| if (!isChain) { |
| this.first.front = this.front; |
| } |
| if (this.operator === 'delete' && o.scope.check(this.first.unwrapAll().value)) { |
| this.error('delete operand may not be argument or var'); |
| } |
| if (((_ref4 = this.operator) === '--' || _ref4 === '++') && (_ref5 = this.first.unwrapAll().value, __indexOf.call(STRICT_PROSCRIBED, _ref5) >= 0)) { |
| this.error("cannot increment/decrement \"" + (this.first.unwrapAll().value) + "\""); |
| } |
| if (this.isUnary()) { |
| return this.compileUnary(o); |
| } |
| if (isChain) { |
| return this.compileChain(o); |
| } |
| if (this.operator === '?') { |
| return this.compileExistence(o); |
| } |
| answer = [].concat(this.first.compileToFragments(o, LEVEL_OP), this.makeCode(' ' + this.operator + ' '), this.second.compileToFragments(o, LEVEL_OP)); |
| if (o.level <= LEVEL_OP) { |
| return answer; |
| } else { |
| return this.wrapInBraces(answer); |
| } |
| }; |
| |
| Op.prototype.compileChain = function(o) { |
| var fragments, fst, shared, _ref4; |
| _ref4 = this.first.second.cache(o), this.first.second = _ref4[0], shared = _ref4[1]; |
| fst = this.first.compileToFragments(o, LEVEL_OP); |
| fragments = fst.concat(this.makeCode(" " + (this.invert ? '&&' : '||') + " "), shared.compileToFragments(o), this.makeCode(" " + this.operator + " "), this.second.compileToFragments(o, LEVEL_OP)); |
| return this.wrapInBraces(fragments); |
| }; |
| |
| Op.prototype.compileExistence = function(o) { |
| var fst, ref; |
| if (!o.isExistentialEquals && this.first.isComplex()) { |
| ref = new Literal(o.scope.freeVariable('ref')); |
| fst = new Parens(new Assign(ref, this.first)); |
| } else { |
| fst = this.first; |
| ref = fst; |
| } |
| return new If(new Existence(fst), ref, { |
| type: 'if' |
| }).addElse(this.second).compileToFragments(o); |
| }; |
| |
| Op.prototype.compileUnary = function(o) { |
| var op, parts, plusMinus; |
| parts = []; |
| op = this.operator; |
| parts.push([this.makeCode(op)]); |
| if (op === '!' && this.first instanceof Existence) { |
| this.first.negated = !this.first.negated; |
| return this.first.compileToFragments(o); |
| } |
| if (o.level >= LEVEL_ACCESS) { |
| return (new Parens(this)).compileToFragments(o); |
| } |
| plusMinus = op === '+' || op === '-'; |
| if ((op === 'new' || op === 'typeof' || op === 'delete') || plusMinus && this.first instanceof Op && this.first.operator === op) { |
| parts.push([this.makeCode(' ')]); |
| } |
| if ((plusMinus && this.first instanceof Op) || (op === 'new' && this.first.isStatement(o))) { |
| this.first = new Parens(this.first); |
| } |
| parts.push(this.first.compileToFragments(o, LEVEL_OP)); |
| if (this.flip) { |
| parts.reverse(); |
| } |
| return this.joinFragmentArrays(parts, ''); |
| }; |
| |
| Op.prototype.toString = function(idt) { |
| return Op.__super__.toString.call(this, idt, this.constructor.name + ' ' + this.operator); |
| }; |
| |
| return Op; |
| |
| })(Base); |
| |
| exports.In = In = (function(_super) { |
| __extends(In, _super); |
| |
| function In(object, array) { |
| this.object = object; |
| this.array = array; |
| } |
| |
| In.prototype.children = ['object', 'array']; |
| |
| In.prototype.invert = NEGATE; |
| |
| In.prototype.compileNode = function(o) { |
| var hasSplat, obj, _i, _len, _ref4; |
| if (this.array instanceof Value && this.array.isArray()) { |
| _ref4 = this.array.base.objects; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| obj = _ref4[_i]; |
| if (!(obj instanceof Splat)) { |
| continue; |
| } |
| hasSplat = true; |
| break; |
| } |
| if (!hasSplat) { |
| return this.compileOrTest(o); |
| } |
| } |
| return this.compileLoopTest(o); |
| }; |
| |
| In.prototype.compileOrTest = function(o) { |
| var cmp, cnj, i, item, ref, sub, tests, _i, _len, _ref4, _ref5, _ref6; |
| if (this.array.base.objects.length === 0) { |
| return [this.makeCode("" + (!!this.negated))]; |
| } |
| _ref4 = this.object.cache(o, LEVEL_OP), sub = _ref4[0], ref = _ref4[1]; |
| _ref5 = this.negated ? [' !== ', ' && '] : [' === ', ' || '], cmp = _ref5[0], cnj = _ref5[1]; |
| tests = []; |
| _ref6 = this.array.base.objects; |
| for (i = _i = 0, _len = _ref6.length; _i < _len; i = ++_i) { |
| item = _ref6[i]; |
| if (i) { |
| tests.push(this.makeCode(cnj)); |
| } |
| tests = tests.concat((i ? ref : sub), this.makeCode(cmp), item.compileToFragments(o, LEVEL_ACCESS)); |
| } |
| if (o.level < LEVEL_OP) { |
| return tests; |
| } else { |
| return this.wrapInBraces(tests); |
| } |
| }; |
| |
| In.prototype.compileLoopTest = function(o) { |
| var fragments, ref, sub, _ref4; |
| _ref4 = this.object.cache(o, LEVEL_LIST), sub = _ref4[0], ref = _ref4[1]; |
| fragments = [].concat(this.makeCode(utility('indexOf') + ".call("), this.array.compileToFragments(o, LEVEL_LIST), this.makeCode(", "), ref, this.makeCode(") " + (this.negated ? '< 0' : '>= 0'))); |
| if (fragmentsToText(sub) === fragmentsToText(ref)) { |
| return fragments; |
| } |
| fragments = sub.concat(this.makeCode(', '), fragments); |
| if (o.level < LEVEL_LIST) { |
| return fragments; |
| } else { |
| return this.wrapInBraces(fragments); |
| } |
| }; |
| |
| In.prototype.toString = function(idt) { |
| return In.__super__.toString.call(this, idt, this.constructor.name + (this.negated ? '!' : '')); |
| }; |
| |
| return In; |
| |
| })(Base); |
| |
| exports.Try = Try = (function(_super) { |
| __extends(Try, _super); |
| |
| function Try(attempt, errorVariable, recovery, ensure) { |
| this.attempt = attempt; |
| this.errorVariable = errorVariable; |
| this.recovery = recovery; |
| this.ensure = ensure; |
| } |
| |
| Try.prototype.children = ['attempt', 'recovery', 'ensure']; |
| |
| Try.prototype.isStatement = YES; |
| |
| Try.prototype.jumps = function(o) { |
| var _ref4; |
| return this.attempt.jumps(o) || ((_ref4 = this.recovery) != null ? _ref4.jumps(o) : void 0); |
| }; |
| |
| Try.prototype.makeReturn = function(res) { |
| if (this.attempt) { |
| this.attempt = this.attempt.makeReturn(res); |
| } |
| if (this.recovery) { |
| this.recovery = this.recovery.makeReturn(res); |
| } |
| return this; |
| }; |
| |
| Try.prototype.compileNode = function(o) { |
| var catchPart, ensurePart, placeholder, tryPart; |
| o.indent += TAB; |
| tryPart = this.attempt.compileToFragments(o, LEVEL_TOP); |
| catchPart = this.recovery ? (placeholder = new Literal('_error'), this.errorVariable ? this.recovery.unshift(new Assign(this.errorVariable, placeholder)) : void 0, [].concat(this.makeCode(" catch ("), placeholder.compileToFragments(o), this.makeCode(") {\n"), this.recovery.compileToFragments(o, LEVEL_TOP), this.makeCode("\n" + this.tab + "}"))) : !(this.ensure || this.recovery) ? [this.makeCode(' catch (_error) {}')] : []; |
| ensurePart = this.ensure ? [].concat(this.makeCode(" finally {\n"), this.ensure.compileToFragments(o, LEVEL_TOP), this.makeCode("\n" + this.tab + "}")) : []; |
| return [].concat(this.makeCode("" + this.tab + "try {\n"), tryPart, this.makeCode("\n" + this.tab + "}"), catchPart, ensurePart); |
| }; |
| |
| return Try; |
| |
| })(Base); |
| |
| exports.Throw = Throw = (function(_super) { |
| __extends(Throw, _super); |
| |
| function Throw(expression) { |
| this.expression = expression; |
| } |
| |
| Throw.prototype.children = ['expression']; |
| |
| Throw.prototype.isStatement = YES; |
| |
| Throw.prototype.jumps = NO; |
| |
| Throw.prototype.makeReturn = THIS; |
| |
| Throw.prototype.compileNode = function(o) { |
| return [].concat(this.makeCode(this.tab + "throw "), this.expression.compileToFragments(o), this.makeCode(";")); |
| }; |
| |
| return Throw; |
| |
| })(Base); |
| |
| exports.Existence = Existence = (function(_super) { |
| __extends(Existence, _super); |
| |
| function Existence(expression) { |
| this.expression = expression; |
| } |
| |
| Existence.prototype.children = ['expression']; |
| |
| Existence.prototype.invert = NEGATE; |
| |
| Existence.prototype.compileNode = function(o) { |
| var cmp, cnj, code, _ref4; |
| this.expression.front = this.front; |
| code = this.expression.compile(o, LEVEL_OP); |
| if (IDENTIFIER.test(code) && !o.scope.check(code)) { |
| _ref4 = this.negated ? ['===', '||'] : ['!==', '&&'], cmp = _ref4[0], cnj = _ref4[1]; |
| code = "typeof " + code + " " + cmp + " \"undefined\" " + cnj + " " + code + " " + cmp + " null"; |
| } else { |
| code = "" + code + " " + (this.negated ? '==' : '!=') + " null"; |
| } |
| return [this.makeCode(o.level <= LEVEL_COND ? code : "(" + code + ")")]; |
| }; |
| |
| return Existence; |
| |
| })(Base); |
| |
| exports.Parens = Parens = (function(_super) { |
| __extends(Parens, _super); |
| |
| function Parens(body) { |
| this.body = body; |
| } |
| |
| Parens.prototype.children = ['body']; |
| |
| Parens.prototype.unwrap = function() { |
| return this.body; |
| }; |
| |
| Parens.prototype.isComplex = function() { |
| return this.body.isComplex(); |
| }; |
| |
| Parens.prototype.compileNode = function(o) { |
| var bare, expr, fragments; |
| expr = this.body.unwrap(); |
| if (expr instanceof Value && expr.isAtomic()) { |
| expr.front = this.front; |
| return expr.compileToFragments(o); |
| } |
| fragments = expr.compileToFragments(o, LEVEL_PAREN); |
| bare = o.level < LEVEL_OP && (expr instanceof Op || expr instanceof Call || (expr instanceof For && expr.returns)); |
| if (bare) { |
| return fragments; |
| } else { |
| return this.wrapInBraces(fragments); |
| } |
| }; |
| |
| return Parens; |
| |
| })(Base); |
| |
| exports.For = For = (function(_super) { |
| __extends(For, _super); |
| |
| function For(body, source) { |
| var _ref4; |
| this.source = source.source, this.guard = source.guard, this.step = source.step, this.name = source.name, this.index = source.index; |
| this.body = Block.wrap([body]); |
| this.own = !!source.own; |
| this.object = !!source.object; |
| if (this.object) { |
| _ref4 = [this.index, this.name], this.name = _ref4[0], this.index = _ref4[1]; |
| } |
| if (this.index instanceof Value) { |
| this.index.error('index cannot be a pattern matching expression'); |
| } |
| this.range = this.source instanceof Value && this.source.base instanceof Range && !this.source.properties.length; |
| this.pattern = this.name instanceof Value; |
| if (this.range && this.index) { |
| this.index.error('indexes do not apply to range loops'); |
| } |
| if (this.range && this.pattern) { |
| this.name.error('cannot pattern match over range loops'); |
| } |
| if (this.own && !this.object) { |
| this.index.error('cannot use own with for-in'); |
| } |
| this.returns = false; |
| } |
| |
| For.prototype.children = ['body', 'source', 'guard', 'step']; |
| |
| For.prototype.compileNode = function(o) { |
| var body, bodyFragments, compare, compareDown, declare, declareDown, defPart, defPartFragments, down, forPartFragments, guardPart, idt1, increment, index, ivar, kvar, kvarAssign, lastJumps, lvar, name, namePart, ref, resultPart, returnResult, rvar, scope, source, step, stepNum, stepVar, svar, varPart, _ref4, _ref5; |
| body = Block.wrap([this.body]); |
| lastJumps = (_ref4 = last(body.expressions)) != null ? _ref4.jumps() : void 0; |
| if (lastJumps && lastJumps instanceof Return) { |
| this.returns = false; |
| } |
| source = this.range ? this.source.base : this.source; |
| scope = o.scope; |
| name = this.name && (this.name.compile(o, LEVEL_LIST)); |
| index = this.index && (this.index.compile(o, LEVEL_LIST)); |
| if (name && !this.pattern) { |
| scope.find(name); |
| } |
| if (index) { |
| scope.find(index); |
| } |
| if (this.returns) { |
| rvar = scope.freeVariable('results'); |
| } |
| ivar = (this.object && index) || scope.freeVariable('i'); |
| kvar = (this.range && name) || index || ivar; |
| kvarAssign = kvar !== ivar ? "" + kvar + " = " : ""; |
| if (this.step && !this.range) { |
| _ref5 = this.cacheToCodeFragments(this.step.cache(o, LEVEL_LIST)), step = _ref5[0], stepVar = _ref5[1]; |
| stepNum = stepVar.match(SIMPLENUM); |
| } |
| if (this.pattern) { |
| name = ivar; |
| } |
| varPart = ''; |
| guardPart = ''; |
| defPart = ''; |
| idt1 = this.tab + TAB; |
| if (this.range) { |
| forPartFragments = source.compileToFragments(merge(o, { |
| index: ivar, |
| name: name, |
| step: this.step |
| })); |
| } else { |
| svar = this.source.compile(o, LEVEL_LIST); |
| if ((name || this.own) && !IDENTIFIER.test(svar)) { |
| defPart += "" + this.tab + (ref = scope.freeVariable('ref')) + " = " + svar + ";\n"; |
| svar = ref; |
| } |
| if (name && !this.pattern) { |
| namePart = "" + name + " = " + svar + "[" + kvar + "]"; |
| } |
| if (!this.object) { |
| if (step !== stepVar) { |
| defPart += "" + this.tab + step + ";\n"; |
| } |
| if (!(this.step && stepNum && (down = +stepNum < 0))) { |
| lvar = scope.freeVariable('len'); |
| } |
| declare = "" + kvarAssign + ivar + " = 0, " + lvar + " = " + svar + ".length"; |
| declareDown = "" + kvarAssign + ivar + " = " + svar + ".length - 1"; |
| compare = "" + ivar + " < " + lvar; |
| compareDown = "" + ivar + " >= 0"; |
| if (this.step) { |
| if (stepNum) { |
| if (down) { |
| compare = compareDown; |
| declare = declareDown; |
| } |
| } else { |
| compare = "" + stepVar + " > 0 ? " + compare + " : " + compareDown; |
| declare = "(" + stepVar + " > 0 ? (" + declare + ") : " + declareDown + ")"; |
| } |
| increment = "" + ivar + " += " + stepVar; |
| } else { |
| increment = "" + (kvar !== ivar ? "++" + ivar : "" + ivar + "++"); |
| } |
| forPartFragments = [this.makeCode("" + declare + "; " + compare + "; " + kvarAssign + increment)]; |
| } |
| } |
| if (this.returns) { |
| resultPart = "" + this.tab + rvar + " = [];\n"; |
| returnResult = "\n" + this.tab + "return " + rvar + ";"; |
| body.makeReturn(rvar); |
| } |
| if (this.guard) { |
| if (body.expressions.length > 1) { |
| body.expressions.unshift(new If((new Parens(this.guard)).invert(), new Literal("continue"))); |
| } else { |
| if (this.guard) { |
| body = Block.wrap([new If(this.guard, body)]); |
| } |
| } |
| } |
| if (this.pattern) { |
| body.expressions.unshift(new Assign(this.name, new Literal("" + svar + "[" + kvar + "]"))); |
| } |
| defPartFragments = [].concat(this.makeCode(defPart), this.pluckDirectCall(o, body)); |
| if (namePart) { |
| varPart = "\n" + idt1 + namePart + ";"; |
| } |
| if (this.object) { |
| forPartFragments = [this.makeCode("" + kvar + " in " + svar)]; |
| if (this.own) { |
| guardPart = "\n" + idt1 + "if (!" + (utility('hasProp')) + ".call(" + svar + ", " + kvar + ")) continue;"; |
| } |
| } |
| bodyFragments = body.compileToFragments(merge(o, { |
| indent: idt1 |
| }), LEVEL_TOP); |
| if (bodyFragments && (bodyFragments.length > 0)) { |
| bodyFragments = [].concat(this.makeCode("\n"), bodyFragments, this.makeCode("\n")); |
| } |
| return [].concat(defPartFragments, this.makeCode("" + (resultPart || '') + this.tab + "for ("), forPartFragments, this.makeCode(") {" + guardPart + varPart), bodyFragments, this.makeCode("" + this.tab + "}" + (returnResult || ''))); |
| }; |
| |
| For.prototype.pluckDirectCall = function(o, body) { |
| var base, defs, expr, fn, idx, ref, val, _i, _len, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9; |
| defs = []; |
| _ref4 = body.expressions; |
| for (idx = _i = 0, _len = _ref4.length; _i < _len; idx = ++_i) { |
| expr = _ref4[idx]; |
| expr = expr.unwrapAll(); |
| if (!(expr instanceof Call)) { |
| continue; |
| } |
| val = expr.variable.unwrapAll(); |
| if (!((val instanceof Code) || (val instanceof Value && ((_ref5 = val.base) != null ? _ref5.unwrapAll() : void 0) instanceof Code && val.properties.length === 1 && ((_ref6 = (_ref7 = val.properties[0].name) != null ? _ref7.value : void 0) === 'call' || _ref6 === 'apply')))) { |
| continue; |
| } |
| fn = ((_ref8 = val.base) != null ? _ref8.unwrapAll() : void 0) || val; |
| ref = new Literal(o.scope.freeVariable('fn')); |
| base = new Value(ref); |
| if (val.base) { |
| _ref9 = [base, val], val.base = _ref9[0], base = _ref9[1]; |
| } |
| body.expressions[idx] = new Call(base, expr.args); |
| defs = defs.concat(this.makeCode(this.tab), new Assign(ref, fn).compileToFragments(o, LEVEL_TOP), this.makeCode(';\n')); |
| } |
| return defs; |
| }; |
| |
| return For; |
| |
| })(While); |
| |
| exports.Switch = Switch = (function(_super) { |
| __extends(Switch, _super); |
| |
| function Switch(subject, cases, otherwise) { |
| this.subject = subject; |
| this.cases = cases; |
| this.otherwise = otherwise; |
| } |
| |
| Switch.prototype.children = ['subject', 'cases', 'otherwise']; |
| |
| Switch.prototype.isStatement = YES; |
| |
| Switch.prototype.jumps = function(o) { |
| var block, conds, _i, _len, _ref4, _ref5, _ref6; |
| if (o == null) { |
| o = { |
| block: true |
| }; |
| } |
| _ref4 = this.cases; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| _ref5 = _ref4[_i], conds = _ref5[0], block = _ref5[1]; |
| if (block.jumps(o)) { |
| return block; |
| } |
| } |
| return (_ref6 = this.otherwise) != null ? _ref6.jumps(o) : void 0; |
| }; |
| |
| Switch.prototype.makeReturn = function(res) { |
| var pair, _i, _len, _ref4, _ref5; |
| _ref4 = this.cases; |
| for (_i = 0, _len = _ref4.length; _i < _len; _i++) { |
| pair = _ref4[_i]; |
| pair[1].makeReturn(res); |
| } |
| if (res) { |
| this.otherwise || (this.otherwise = new Block([new Literal('void 0')])); |
| } |
| if ((_ref5 = this.otherwise) != null) { |
| _ref5.makeReturn(res); |
| } |
| return this; |
| }; |
| |
| Switch.prototype.compileNode = function(o) { |
| var block, body, cond, conditions, expr, fragments, i, idt1, idt2, _i, _j, _len, _len1, _ref4, _ref5, _ref6; |
| idt1 = o.indent + TAB; |
| idt2 = o.indent = idt1 + TAB; |
| fragments = [].concat(this.makeCode(this.tab + "switch ("), (this.subject ? this.subject.compileToFragments(o, LEVEL_PAREN) : this.makeCode("false")), this.makeCode(") {\n")); |
| _ref4 = this.cases; |
| for (i = _i = 0, _len = _ref4.length; _i < _len; i = ++_i) { |
| _ref5 = _ref4[i], conditions = _ref5[0], block = _ref5[1]; |
| _ref6 = flatten([conditions]); |
| for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) { |
| cond = _ref6[_j]; |
| if (!this.subject) { |
| cond = cond.invert(); |
| } |
| fragments = fragments.concat(this.makeCode(idt1 + "case "), cond.compileToFragments(o, LEVEL_PAREN), this.makeCode(":\n")); |
| } |
| if ((body = block.compileToFragments(o, LEVEL_TOP)).length > 0) { |
| fragments = fragments.concat(body, this.makeCode('\n')); |
| } |
| if (i === this.cases.length - 1 && !this.otherwise) { |
| break; |
| } |
| expr = this.lastNonComment(block.expressions); |
| if (expr instanceof Return || (expr instanceof Literal && expr.jumps() && expr.value !== 'debugger')) { |
| continue; |
| } |
| fragments.push(cond.makeCode(idt2 + 'break;\n')); |
| } |
| if (this.otherwise && this.otherwise.expressions.length) { |
| fragments.push.apply(fragments, [this.makeCode(idt1 + "default:\n")].concat(__slice.call(this.otherwise.compileToFragments(o, LEVEL_TOP)), [this.makeCode("\n")])); |
| } |
| fragments.push(this.makeCode(this.tab + '}')); |
| return fragments; |
| }; |
| |
| return Switch; |
| |
| })(Base); |
| |
| exports.If = If = (function(_super) { |
| __extends(If, _super); |
| |
| function If(condition, body, options) { |
| this.body = body; |
| if (options == null) { |
| options = {}; |
| } |
| this.condition = options.type === 'unless' ? condition.invert() : condition; |
| this.elseBody = null; |
| this.isChain = false; |
| this.soak = options.soak; |
| } |
| |
| If.prototype.children = ['condition', 'body', 'elseBody']; |
| |
| If.prototype.bodyNode = function() { |
| var _ref4; |
| return (_ref4 = this.body) != null ? _ref4.unwrap() : void 0; |
| }; |
| |
| If.prototype.elseBodyNode = function() { |
| var _ref4; |
| return (_ref4 = this.elseBody) != null ? _ref4.unwrap() : void 0; |
| }; |
| |
| If.prototype.addElse = function(elseBody) { |
| if (this.isChain) { |
| this.elseBodyNode().addElse(elseBody); |
| } else { |
| this.isChain = elseBody instanceof If; |
| this.elseBody = this.ensureBlock(elseBody); |
| } |
| return this; |
| }; |
| |
| If.prototype.isStatement = function(o) { |
| var _ref4; |
| return (o != null ? o.level : void 0) === LEVEL_TOP || this.bodyNode().isStatement(o) || ((_ref4 = this.elseBodyNode()) != null ? _ref4.isStatement(o) : void 0); |
| }; |
| |
| If.prototype.jumps = function(o) { |
| var _ref4; |
| return this.body.jumps(o) || ((_ref4 = this.elseBody) != null ? _ref4.jumps(o) : void 0); |
| }; |
| |
| If.prototype.compileNode = function(o) { |
| if (this.isStatement(o)) { |
| return this.compileStatement(o); |
| } else { |
| return this.compileExpression(o); |
| } |
| }; |
| |
| If.prototype.makeReturn = function(res) { |
| if (res) { |
| this.elseBody || (this.elseBody = new Block([new Literal('void 0')])); |
| } |
| this.body && (this.body = new Block([this.body.makeReturn(res)])); |
| this.elseBody && (this.elseBody = new Block([this.elseBody.makeReturn(res)])); |
| return this; |
| }; |
| |
| If.prototype.ensureBlock = function(node) { |
| if (node instanceof Block) { |
| return node; |
| } else { |
| return new Block([node]); |
| } |
| }; |
| |
| If.prototype.compileStatement = function(o) { |
| var answer, body, child, cond, exeq, ifPart, indent; |
| child = del(o, 'chainChild'); |
| exeq = del(o, 'isExistentialEquals'); |
| if (exeq) { |
| return new If(this.condition.invert(), this.elseBodyNode(), { |
| type: 'if' |
| }).compileToFragments(o); |
| } |
| indent = o.indent + TAB; |
| cond = this.condition.compileToFragments(o, LEVEL_PAREN); |
| body = this.ensureBlock(this.body).compileToFragments(merge(o, { |
| indent: indent |
| })); |
| ifPart = [].concat(this.makeCode("if ("), cond, this.makeCode(") {\n"), body, this.makeCode("\n" + this.tab + "}")); |
| if (!child) { |
| ifPart.unshift(this.makeCode(this.tab)); |
| } |
| if (!this.elseBody) { |
| return ifPart; |
| } |
| answer = ifPart.concat(this.makeCode(' else ')); |
| if (this.isChain) { |
| o.chainChild = true; |
| answer = answer.concat(this.elseBody.unwrap().compileToFragments(o, LEVEL_TOP)); |
| } else { |
| answer = answer.concat(this.makeCode("{\n"), this.elseBody.compileToFragments(merge(o, { |
| indent: indent |
| }), LEVEL_TOP), this.makeCode("\n" + this.tab + "}")); |
| } |
| return answer; |
| }; |
| |
| If.prototype.compileExpression = function(o) { |
| var alt, body, cond, fragments; |
| cond = this.condition.compileToFragments(o, LEVEL_COND); |
| body = this.bodyNode().compileToFragments(o, LEVEL_LIST); |
| alt = this.elseBodyNode() ? this.elseBodyNode().compileToFragments(o, LEVEL_LIST) : [this.makeCode('void 0')]; |
| fragments = cond.concat(this.makeCode(" ? "), body, this.makeCode(" : "), alt); |
| if (o.level >= LEVEL_COND) { |
| return this.wrapInBraces(fragments); |
| } else { |
| return fragments; |
| } |
| }; |
| |
| If.prototype.unfoldSoak = function() { |
| return this.soak && this; |
| }; |
| |
| return If; |
| |
| })(Base); |
| |
| Closure = { |
| wrap: function(expressions, statement, noReturn) { |
| var args, argumentsNode, call, func, meth; |
| if (expressions.jumps()) { |
| return expressions; |
| } |
| func = new Code([], Block.wrap([expressions])); |
| args = []; |
| argumentsNode = expressions.contains(this.isLiteralArguments); |
| if (argumentsNode && expressions.classBody) { |
| argumentsNode.error("Class bodies shouldn't reference arguments"); |
| } |
| if (argumentsNode || expressions.contains(this.isLiteralThis)) { |
| meth = new Literal(argumentsNode ? 'apply' : 'call'); |
| args = [new Literal('this')]; |
| if (argumentsNode) { |
| args.push(new Literal('arguments')); |
| } |
| func = new Value(func, [new Access(meth)]); |
| } |
| func.noReturn = noReturn; |
| call = new Call(func, args); |
| if (statement) { |
| return Block.wrap([call]); |
| } else { |
| return call; |
| } |
| }, |
| isLiteralArguments: function(node) { |
| return node instanceof Literal && node.value === 'arguments' && !node.asKey; |
| }, |
| isLiteralThis: function(node) { |
| return (node instanceof Literal && node.value === 'this' && !node.asKey) || (node instanceof Code && node.bound) || (node instanceof Call && node.isSuper); |
| } |
| }; |
| |
| unfoldSoak = function(o, parent, name) { |
| var ifn; |
| if (!(ifn = parent[name].unfoldSoak(o))) { |
| return; |
| } |
| parent[name] = ifn.body; |
| ifn.body = new Value(parent); |
| return ifn; |
| }; |
| |
| UTILITIES = { |
| "extends": function() { |
| return "function(child, parent) { for (var key in parent) { if (" + (utility('hasProp')) + ".call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }"; |
| }, |
| bind: function() { |
| return 'function(fn, me){ return function(){ return fn.apply(me, arguments); }; }'; |
| }, |
| indexOf: function() { |
| return "[].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }"; |
| }, |
| hasProp: function() { |
| return '{}.hasOwnProperty'; |
| }, |
| slice: function() { |
| return '[].slice'; |
| } |
| }; |
| |
| LEVEL_TOP = 1; |
| |
| LEVEL_PAREN = 2; |
| |
| LEVEL_LIST = 3; |
| |
| LEVEL_COND = 4; |
| |
| LEVEL_OP = 5; |
| |
| LEVEL_ACCESS = 6; |
| |
| TAB = ' '; |
| |
| IDENTIFIER_STR = "[$A-Za-z_\\x7f-\\uffff][$\\w\\x7f-\\uffff]*"; |
| |
| IDENTIFIER = RegExp("^" + IDENTIFIER_STR + "$"); |
| |
| SIMPLENUM = /^[+-]?\d+$/; |
| |
| METHOD_DEF = RegExp("^(?:(" + IDENTIFIER_STR + ")\\.prototype(?:\\.(" + IDENTIFIER_STR + ")|\\[(\"(?:[^\\\\\"\\r\\n]|\\\\.)*\"|'(?:[^\\\\'\\r\\n]|\\\\.)*')\\]|\\[(0x[\\da-fA-F]+|\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\]))|(" + IDENTIFIER_STR + ")$"); |
| |
| IS_STRING = /^['"]/; |
| |
| utility = function(name) { |
| var ref; |
| ref = "__" + name; |
| Scope.root.assign(ref, UTILITIES[name]()); |
| return ref; |
| }; |
| |
| multident = function(code, tab) { |
| code = code.replace(/\n/g, '$&' + tab); |
| return code.replace(/\s+$/, ''); |
| }; |
| |
| }).call(this); |