mirror of
https://github.com/jashkenas/coffeescript.git
synced 2026-02-17 11:01:25 -05:00
trying out a new organizational scheme, with a quickie 'inherits' helper function
This commit is contained in:
Jeremy Ashkenas
@@ -1,5 +1,5 @@
|
||||
(function(){
|
||||
var Expressions, Node, TAB, TRAILING_WHITESPACE, __a, compact, del, dup, flatten, statement;
|
||||
var Expressions, LiteralNode, Node, TAB, TRAILING_WHITESPACE, compact, del, dup, flatten, inherit, merge, statement;
|
||||
var __hasProp = Object.prototype.hasOwnProperty;
|
||||
// The abstract base class for all CoffeeScript nodes.
|
||||
// All nodes are implement a "compile_node" method, which performs the
|
||||
@@ -247,6 +247,21 @@
|
||||
return output;
|
||||
}
|
||||
};
|
||||
// Merge objects.
|
||||
merge = function merge(src, dest) {
|
||||
var __a, __b, key, val;
|
||||
dest[key] = (function() {
|
||||
__a = []; __b = src;
|
||||
for (key in __b) {
|
||||
val = __b[key];
|
||||
if (__hasProp.call(__b, key)) {
|
||||
__a.push(val);
|
||||
}
|
||||
}
|
||||
return __a;
|
||||
}).call(this);
|
||||
return dest;
|
||||
};
|
||||
// Delete a key from an object, returning the value.
|
||||
del = function del(obj, key) {
|
||||
var val;
|
||||
@@ -254,6 +269,28 @@
|
||||
delete obj[key];
|
||||
return val;
|
||||
};
|
||||
// Quickie inheritance convenience wrapper to reduce typing.
|
||||
inherit = function inherit(parent, props) {
|
||||
var __a, __b, __c, klass, name, prop;
|
||||
klass = props.constructor;
|
||||
delete props.constructor;
|
||||
__a = function(){};
|
||||
__a.prototype = parent.prototype;
|
||||
klass.__superClass__ = parent.prototype;
|
||||
klass.prototype = new __a();
|
||||
klass.prototype.constructor = klass;
|
||||
klass.prototype[name] = (function() {
|
||||
__b = []; __c = props;
|
||||
for (name in __c) {
|
||||
prop = __c[name];
|
||||
if (__hasProp.call(__c, name)) {
|
||||
__b.push(prop);
|
||||
}
|
||||
}
|
||||
return __b;
|
||||
}).call(this);
|
||||
return klass;
|
||||
};
|
||||
// # Provide a quick implementation of a children method.
|
||||
// children: (klass, attrs...) ->
|
||||
// klass::children: ->
|
||||
@@ -261,10 +298,10 @@
|
||||
// compact flatten nodes
|
||||
// Mark a node as a statement, or a statement only.
|
||||
statement = function statement(klass, only) {
|
||||
klass.prototype.statement = function statement() {
|
||||
klass.prototype.is_statement = function is_statement() {
|
||||
return true;
|
||||
};
|
||||
return klass.prototype.statement_only = function statement_only() {
|
||||
return klass.prototype.is_statement_only = function is_statement_only() {
|
||||
if (only) {
|
||||
return true;
|
||||
}
|
||||
@@ -288,8 +325,8 @@
|
||||
});
|
||||
this.indent = o.indent;
|
||||
top = this.top_sensitive() ? o.top : del(obj('top'));
|
||||
closure = this.statement() && !this.statement_only() && !top && !o.returns && !this instanceof CommentNode && !this.contains(function(node) {
|
||||
return node.statement_only();
|
||||
closure = this.is_statement() && !this.is_statement_only() && !top && !o.returns && !this instanceof CommentNode && !this.contains(function(node) {
|
||||
return node.is_statement_only();
|
||||
});
|
||||
return closure ? this.compile_closure(this.options) : this.compile_node(this.options);
|
||||
};
|
||||
@@ -330,85 +367,144 @@
|
||||
return this;
|
||||
};
|
||||
Node.prototype.children = [];
|
||||
Node.prototype.statement = function statement() {
|
||||
Node.prototype.is_statement = function is_statement() {
|
||||
return false;
|
||||
};
|
||||
Node.prototype.statement_only = function statement_only() {
|
||||
Node.prototype.is_statement_only = function is_statement_only() {
|
||||
return false;
|
||||
};
|
||||
Node.prototype.top_sensitive = function top_sensitive() {
|
||||
return false;
|
||||
};
|
||||
// A collection of nodes, each one representing an expression.
|
||||
Expressions = (exports.Expressions = function Expressions() {
|
||||
var __a, nodes;
|
||||
nodes = Array.prototype.slice.call(arguments, 0);
|
||||
this.expressions = flatten(nodes);
|
||||
__a = this.children = this.expressions;
|
||||
return Expressions === this.constructor ? this : __a;
|
||||
});
|
||||
__a = function(){};
|
||||
__a.prototype = Node.prototype;
|
||||
Expressions.__superClass__ = Node.prototype;
|
||||
Expressions.prototype = new __a();
|
||||
Expressions.prototype.constructor = Expressions;
|
||||
statement(Expressions);
|
||||
// Wrap up a node as an Expressions, unless it already is.
|
||||
Expressions.prototype.wrap = function wrap() {
|
||||
var nodes;
|
||||
nodes = Array.prototype.slice.call(arguments, 0);
|
||||
if (nodes.length === 1 && nodes[0] instanceof Expressions) {
|
||||
return nodes[0];
|
||||
}
|
||||
return new Expressions.apply(this, nodes);
|
||||
};
|
||||
// Tack an expression on to the end of this expression list.
|
||||
Expressions.prototype.push = function push(node) {
|
||||
this.expressions.push(node);
|
||||
return this;
|
||||
};
|
||||
// Tack an expression on to the beginning of this expression list.
|
||||
Expressions.prototype.unshift = function unshift(node) {
|
||||
this.expressions.unshift(node);
|
||||
return this;
|
||||
};
|
||||
// If this Expressions consists of a single node, pull it back out.
|
||||
Expressions.prototype.unwrap = function unwrap() {
|
||||
return this.expressions.length === 1 ? this.expressions[0] : this;
|
||||
};
|
||||
// Is this an empty block of code?
|
||||
Expressions.prototype.empty = function empty() {
|
||||
return this.expressions.length === 0;
|
||||
};
|
||||
// Is the node last in this block of expressions?
|
||||
Expressions.prototype.is_last = function is_last(node) {
|
||||
var l;
|
||||
l = this.expressions.length;
|
||||
this.last_index = this.last_index || this.expressions[l - 1] instanceof CommentNode ? -2 : -1;
|
||||
return node === this.expressions[l - this.last_index];
|
||||
};
|
||||
Expressions.prototype.compile = function compile(o) {
|
||||
return o.scope ? Expressions.__superClass__.compile.call(this, o) : this.compile_root(o);
|
||||
};
|
||||
// Compile each expression in the Expressions body.
|
||||
Expressions.prototype.compile_node = function compile_node(o) {
|
||||
var __b, __c, __d, node;
|
||||
return ((function() {
|
||||
__b = []; __c = this.expressions;
|
||||
for (__d = 0; __d < __c.length; __d++) {
|
||||
node = __c[__d];
|
||||
__b.push(this.compile_expression(node, dup(o)));
|
||||
Expressions = (exports.Expressions = inherit(Node, {
|
||||
constructor: function constructor() {
|
||||
var nodes;
|
||||
nodes = Array.prototype.slice.call(arguments, 0);
|
||||
this.expressions = flatten(nodes);
|
||||
return this.children = this.expressions;
|
||||
},
|
||||
// Wrap up a node as an Expressions, unless it already is.
|
||||
wrap: function wrap() {
|
||||
var nodes;
|
||||
nodes = Array.prototype.slice.call(arguments, 0);
|
||||
if (nodes.length === 1 && nodes[0] instanceof Expressions) {
|
||||
return nodes[0];
|
||||
}
|
||||
return __b;
|
||||
}).call(this)).join("\n");
|
||||
};
|
||||
// If this is the top-level Expressions, wrap everything in a safety closure.
|
||||
Expressions.prototype.compile_root = function compile_root(o) {
|
||||
var code, indent;
|
||||
o.indent = (this.indent = (indent = o.no_wrap ? '' : TAB));
|
||||
o.scope = new Scope(null, this, null);
|
||||
code = o.globals ? this.compile_node(o) : this.compile_with_declarations(o);
|
||||
code = code.replace(TRAILING_WHITESPACE, '');
|
||||
return o.no_wrap ? code : "(function(){\n" + code + "\n})();";
|
||||
return new Expressions.apply(this, nodes);
|
||||
},
|
||||
// Tack an expression on to the end of this expression list.
|
||||
push: function push(node) {
|
||||
this.expressions.push(node);
|
||||
return this;
|
||||
},
|
||||
// Tack an expression on to the beginning of this expression list.
|
||||
unshift: function unshift(node) {
|
||||
this.expressions.unshift(node);
|
||||
return this;
|
||||
},
|
||||
// If this Expressions consists of a single node, pull it back out.
|
||||
unwrap: function unwrap() {
|
||||
return this.expressions.length === 1 ? this.expressions[0] : this;
|
||||
},
|
||||
// Is this an empty block of code?
|
||||
empty: function empty() {
|
||||
return this.expressions.length === 0;
|
||||
},
|
||||
// Is the node last in this block of expressions?
|
||||
is_last: function is_last(node) {
|
||||
var l;
|
||||
l = this.expressions.length;
|
||||
this.last_index = this.last_index || this.expressions[l - 1] instanceof CommentNode ? -2 : -1;
|
||||
return node === this.expressions[l - this.last_index];
|
||||
},
|
||||
compile: function compile(o) {
|
||||
return o.scope ? compile.__superClass__.constructor.call(this, o) : this.compile_root(o);
|
||||
},
|
||||
// Compile each expression in the Expressions body.
|
||||
compile_node: function compile_node(o) {
|
||||
var __a, __b, __c, node;
|
||||
return ((function() {
|
||||
__a = []; __b = this.expressions;
|
||||
for (__c = 0; __c < __b.length; __c++) {
|
||||
node = __b[__c];
|
||||
__a.push(this.compile_expression(node, dup(o)));
|
||||
}
|
||||
return __a;
|
||||
}).call(this)).join("\n");
|
||||
},
|
||||
// If this is the top-level Expressions, wrap everything in a safety closure.
|
||||
compile_root: function compile_root(o) {
|
||||
var code, indent;
|
||||
o.indent = (this.indent = (indent = o.no_wrap ? '' : TAB));
|
||||
o.scope = new Scope(null, this, null);
|
||||
code = o.globals ? this.compile_node(o) : this.compile_with_declarations(o);
|
||||
code = code.replace(TRAILING_WHITESPACE, '');
|
||||
return o.no_wrap ? code : "(function(){\n" + code + "\n})();";
|
||||
},
|
||||
// Compile the expressions body, with declarations of all inner variables
|
||||
// pushed up to the top.
|
||||
compile_with_declarations: function compile_with_declarations(o) {
|
||||
var args, argv, code;
|
||||
code = this.compile_node(o);
|
||||
args = this.contains(function(node) {
|
||||
return node instanceof ValueNode && node.arguments();
|
||||
});
|
||||
argv = args && o.scope.check('arguments') ? '' : 'var ';
|
||||
if (args) {
|
||||
code = this.idt() + argv + "arguments = Array.prototype.slice.call(arguments, 0);\n" + code;
|
||||
}
|
||||
if (o.scope.has_assignments(this)) {
|
||||
code = this.idt() + 'var ' + o.scope.compiled_assignments() + ";\n" + code;
|
||||
}
|
||||
if (o.scope.has_declarations(this)) {
|
||||
code = this.idt() + 'var ' + o.scope.compiled_declarations() + ";\n" + code;
|
||||
}
|
||||
return code;
|
||||
},
|
||||
// Compiles a single expression within the expressions body.
|
||||
compile_expression: function compile_expression(node, o) {
|
||||
var returns, stmt, temp;
|
||||
this.indent = o.indent;
|
||||
stmt = node.is_statement();
|
||||
// We need to return the result if this is the last node in the expressions body.
|
||||
returns = o.returns && this.is_last(node) && !node.is_statement_only();
|
||||
delete o.returns;
|
||||
// Return the regular compile of the node, unless we need to return the result.
|
||||
if (!(returns)) {
|
||||
return (stmt ? '' : this.idt()) + node.compile(merge(o, {
|
||||
top: true
|
||||
})) + (stmt ? '' : ';');
|
||||
}
|
||||
// If it's a statement, the node knows how to return itself.
|
||||
if (node.is_statement()) {
|
||||
return node.compile(merge(o, {
|
||||
returns: true
|
||||
}));
|
||||
}
|
||||
// If it's not part of a constructor, we can just return the value of the expression.
|
||||
if (!((o.scope.function == undefined ? undefined : o.scope.function.is_constructor()))) {
|
||||
return this.idt() + 'return ' + node.compile(o);
|
||||
}
|
||||
// It's the last line of a constructor, add a safety check.
|
||||
temp = o.scope.free_variable();
|
||||
return this.idt() + temp + ' = ' + node.compile(o) + ";\n" + this.idt() + "return " + o.scope.function.name + ' === this.constructor ? this : ' + temp + ';';
|
||||
}
|
||||
}));
|
||||
statement(Expressions);
|
||||
// Literals are static values that can be passed through directly into
|
||||
// JavaScript without translation, eg.: strings, numbers, true, false, null...
|
||||
LiteralNode = (exports.LiteralNode = function LiteralNode(value) {
|
||||
var __a;
|
||||
this.value = value;
|
||||
__a = this.children = [value];
|
||||
return LiteralNode === this.constructor ? this : __a;
|
||||
});
|
||||
// Break and continue must be treated as statements -- they lose their meaning
|
||||
// when wrapped in a closure.
|
||||
LiteralNode.prototype.is_statement = function is_statement() {
|
||||
return this.value === 'break' || this.value === 'continue';
|
||||
};
|
||||
LiteralNode.prototype.is_statement_only = LiteralNode.prototype.is_statement;
|
||||
LiteralNode.prototype.compile_node = function compile_node(o) { };
|
||||
})();
|
||||
Reference in New Issue
Block a user