mirror of
https://github.com/jashkenas/coffeescript.git
synced 2026-02-18 11:31:20 -05:00
nodes.coffee is continuing to roll along -- maybe a tenth implemented
This commit is contained in:
Jeremy Ashkenas
@@ -1,5 +1,5 @@
|
||||
(function(){
|
||||
var compact, dup, flatten;
|
||||
var Expressions, Node, TAB, TRAILING_WHITESPACE, __a, compact, del, dup, flatten, 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
|
||||
@@ -8,13 +8,6 @@
|
||||
// generated code should be wrapped up in a closure. An options hash is passed
|
||||
// and cloned throughout, containing messages from higher in the AST,
|
||||
// information about the current scope, and indentation level.
|
||||
exports.Node = function Node() {
|
||||
var __a;
|
||||
var arguments = Array.prototype.slice.call(arguments, 0);
|
||||
this.values = arguments;
|
||||
__a = this.name = this.constructor.name;
|
||||
return Node === this.constructor ? this : __a;
|
||||
};
|
||||
exports.Expressions = function Expressions() {
|
||||
var __a;
|
||||
var arguments = Array.prototype.slice.call(arguments, 0);
|
||||
@@ -201,139 +194,124 @@
|
||||
return this.values = values;
|
||||
};
|
||||
// Some helper functions
|
||||
// TODO -- shallow (1 deep) flatten..
|
||||
// need recursive version..
|
||||
flatten = function flatten(aggList, newList) {
|
||||
var __a, __b, item;
|
||||
__a = newList;
|
||||
for (__b = 0; __b < __a.length; __b++) {
|
||||
item = __a[__b];
|
||||
aggList.push(item);
|
||||
}
|
||||
return aggList;
|
||||
};
|
||||
compact = function compact(input) {
|
||||
var __a, __b, __c, compected, item;
|
||||
compected = [];
|
||||
__a = []; __b = input;
|
||||
// Tabs are two spaces for pretty printing.
|
||||
TAB = ' ';
|
||||
TRAILING_WHITESPACE = /\s+$/g;
|
||||
// Flatten nested arrays recursively.
|
||||
flatten = function flatten(list) {
|
||||
var __a, __b, __c, item, memo;
|
||||
memo = [];
|
||||
__a = []; __b = list;
|
||||
for (__c = 0; __c < __b.length; __c++) {
|
||||
item = __b[__c];
|
||||
__a.push((typeof item !== "undefined" && item !== null) ? compacted.push(item) : null);
|
||||
if (item instanceof Array) {
|
||||
return memo.concat(flatten(item));
|
||||
}
|
||||
memo.push(item);
|
||||
memo;
|
||||
}
|
||||
return __a;
|
||||
};
|
||||
dup = function dup(input) {
|
||||
var __a, __b, __c, key, output, val;
|
||||
output = null;
|
||||
if (input instanceof Array) {
|
||||
output = [];
|
||||
__a = input;
|
||||
for (__b = 0; __b < __a.length; __b++) {
|
||||
val = __a[__b];
|
||||
output.push(val);
|
||||
// Remove all null values from an array.
|
||||
compact = function compact(input) {
|
||||
var __a, __b, __c, item;
|
||||
__a = []; __b = input;
|
||||
for (__c = 0; __c < __b.length; __c++) {
|
||||
item = __b[__c];
|
||||
if ((typeof item !== "undefined" && item !== null)) {
|
||||
__a.push(item);
|
||||
}
|
||||
}
|
||||
return __a;
|
||||
};
|
||||
// Dup an array or object.
|
||||
dup = function dup(input) {
|
||||
var __a, __b, __c, __d, key, output, val;
|
||||
if (input instanceof Array) {
|
||||
__a = []; __b = input;
|
||||
for (__c = 0; __c < __b.length; __c++) {
|
||||
val = __b[__c];
|
||||
__a.push(val);
|
||||
}
|
||||
return __a;
|
||||
} else {
|
||||
output = {
|
||||
};
|
||||
__c = input;
|
||||
for (key in __c) {
|
||||
val = __c[key];
|
||||
if (__hasProp.call(__c, key)) {
|
||||
output.key = val;
|
||||
__d = input;
|
||||
for (key in __d) {
|
||||
val = __d[key];
|
||||
if (__hasProp.call(__d, key)) {
|
||||
((output[key] = val));
|
||||
}
|
||||
}
|
||||
output;
|
||||
return output;
|
||||
}
|
||||
return output;
|
||||
};
|
||||
exports.Node.prototype.TAB = ' ';
|
||||
// Tag this node as a statement, meaning that it can't be used directly as
|
||||
// the result of an expression.
|
||||
exports.Node.prototype.mark_as_statement = function mark_as_statement() {
|
||||
return this.is_statement = function is_statement() {
|
||||
// Delete a key from an object, returning the value.
|
||||
del = function del(obj, key) {
|
||||
var val;
|
||||
val = obj[key];
|
||||
delete obj[key];
|
||||
return val;
|
||||
};
|
||||
// # Provide a quick implementation of a children method.
|
||||
// children: (klass, attrs...) ->
|
||||
// klass::children: ->
|
||||
// nodes: this[attr] for attr in attrs
|
||||
// compact flatten nodes
|
||||
// Mark a node as a statement, or a statement only.
|
||||
statement = function statement(klass, only) {
|
||||
klass.prototype.statement = function statement() {
|
||||
return true;
|
||||
};
|
||||
};
|
||||
// Tag this node as a statement that cannot be transformed into an expression.
|
||||
// (break, continue, etc.) It doesn't make sense to try to transform it.
|
||||
exports.Node.prototype.mark_as_statement_only = function mark_as_statement_only() {
|
||||
this.mark_as_statement();
|
||||
return this.is_statement_only = function is_statement_only() {
|
||||
return true;
|
||||
return klass.prototype.statement_only = function statement_only() {
|
||||
if (only) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
};
|
||||
// This node needs to know if it's being compiled as a top-level statement,
|
||||
// in order to compile without special expression conversion.
|
||||
exports.Node.prototype.mark_as_top_sensitive = function mark_as_top_sensitive() {
|
||||
return this.is_top_sensitive = function is_top_sensitive() {
|
||||
return true;
|
||||
};
|
||||
};
|
||||
// Provide a quick implementation of a children method.
|
||||
exports.Node.prototype.children = function children(attributes) {
|
||||
var __a, __b, agg, compacted, item;
|
||||
// TODO -- are these optimal impls of flatten and compact
|
||||
// .. do better ones exist in a stdlib?
|
||||
agg = [];
|
||||
__a = attributes;
|
||||
for (__b = 0; __b < __a.length; __b++) {
|
||||
item = __a[__b];
|
||||
agg = flatten(agg, item);
|
||||
}
|
||||
compacted = compact(agg);
|
||||
return this.children = function children() {
|
||||
return compacted;
|
||||
};
|
||||
};
|
||||
exports.Node.prototype.write = function write(code) {
|
||||
// hm..
|
||||
// TODO -- should print to STDOUT in "VERBOSE" how to
|
||||
// go about this.. ? jsonify 'this'?
|
||||
// use node's puts ??
|
||||
return code;
|
||||
};
|
||||
// The abstract base class for all CoffeeScript nodes.
|
||||
// All nodes are implement a "compile_node" method, which performs the
|
||||
// code generation for that node. To compile a node, call the "compile"
|
||||
// method, which wraps "compile_node" in some extra smarts, to know when the
|
||||
// generated code should be wrapped up in a closure. An options hash is passed
|
||||
// and cloned throughout, containing messages from higher in the AST,
|
||||
// information about the current scope, and indentation level.
|
||||
Node = (exports.Node = function Node() { });
|
||||
// This is extremely important -- we convert JS statements into expressions
|
||||
// by wrapping them in a closure, only if it's possible, and we're not at
|
||||
// the top level of a block (which would be unnecessary), and we haven't
|
||||
// already been asked to return the result.
|
||||
exports.Node.prototype.compile = function compile(o) {
|
||||
var closure, opts, top;
|
||||
// TODO -- need JS dup/clone
|
||||
opts = (typeof !o !== "undefined" && !o !== null) ? {
|
||||
} : o;
|
||||
this.options = opts;
|
||||
this.indent = opts.indent;
|
||||
top = this.options.top;
|
||||
!this.is_top_sentitive() ? (this.options.top = undefined) : null;
|
||||
closure = this.is_statement() && !this.is_statement_only() && !top && typeof (this) === "CommentNode";
|
||||
closure = closure && !this.do_i_contain(function(n) {
|
||||
return n.is_statement_only();
|
||||
Node.prototype.compile = function compile(o) {
|
||||
var closure, top;
|
||||
this.options = dup(o || {
|
||||
});
|
||||
return closure ? this.compile_closure(this.options) : compile_node(this.options);
|
||||
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();
|
||||
});
|
||||
return closure ? this.compile_closure(this.options) : this.compile_node(this.options);
|
||||
};
|
||||
// Statements converted into expressions share scope with their parent
|
||||
// closure, to preserve JavaScript-style lexical scope.
|
||||
exports.Node.prototype.compile_closure = function compile_closure(o) {
|
||||
var opts;
|
||||
opts = (typeof !o !== "undefined" && !o !== null) ? {
|
||||
} : o;
|
||||
this.indent = opts.indent;
|
||||
opts.shared_scope = o.scope;
|
||||
return exports.ClosureNode.wrap(this).compile(opts);
|
||||
Node.prototype.compile_closure = function compile_closure(o) {
|
||||
this.indent = o.indent;
|
||||
o.shared_scope = o.scope;
|
||||
return ClosureNode.wrap(this).compile(o);
|
||||
};
|
||||
// Quick short method for the current indentation level, plus tabbing in.
|
||||
exports.Node.prototype.idt = function idt(tLvl) {
|
||||
var __a, __b, __c, __d, tabAmt, tabs, x;
|
||||
tabs = (typeof tLvl !== "undefined" && tLvl !== null) ? tLvl : 0;
|
||||
tabAmt = '';
|
||||
__c = 0; __d = tabs;
|
||||
for (__b=0, x=__c; (__c <= __d ? x < __d : x > __d); (__c <= __d ? x += 1 : x -= 1), __b++) {
|
||||
tabAmt = tabAmt + this.TAB;
|
||||
Node.prototype.idt = function idt(tabs) {
|
||||
var __a, __b, __c, __d, i, idt;
|
||||
idt = this.indent;
|
||||
__c = 0; __d = (tabs || 0);
|
||||
for (__b=0, i=__c; (__c <= __d ? i <= __d : i >= __d); (__c <= __d ? i += 1 : i -= 1), __b++) {
|
||||
idt += TAB;
|
||||
}
|
||||
return this.indent + tabAmt;
|
||||
return idt;
|
||||
};
|
||||
//Does this node, or any of it's children, contain a node of a certain kind?
|
||||
exports.Node.prototype.do_i_contain = function do_i_contain(block) {
|
||||
// Does this node, or any of its children, contain a node of a certain kind?
|
||||
Node.prototype.contains = function contains(block) {
|
||||
var __a, __b, node;
|
||||
__a = this.children;
|
||||
for (__b = 0; __b < __a.length; __b++) {
|
||||
@@ -341,103 +319,96 @@
|
||||
if (block(node)) {
|
||||
return true;
|
||||
}
|
||||
if (node instanceof exports.Node && node.do_i_contain(block)) {
|
||||
if (node instanceof Node && node.contains(block)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
// Default implementations of the common node methods.
|
||||
exports.Node.prototype.unwrap = function unwrap() {
|
||||
Node.prototype.unwrap = function unwrap() {
|
||||
return this;
|
||||
};
|
||||
exports.Node.prototype.children = [];
|
||||
exports.Node.prototype.is_a_statement = function is_a_statement() {
|
||||
Node.prototype.children = [];
|
||||
Node.prototype.statement = function statement() {
|
||||
return false;
|
||||
};
|
||||
exports.Node.prototype.is_a_statement_only = function is_a_statement_only() {
|
||||
Node.prototype.statement_only = function statement_only() {
|
||||
return false;
|
||||
};
|
||||
exports.Node.prototype.is_top_sensitive = function is_top_sensitive() {
|
||||
Node.prototype.top_sensitive = function top_sensitive() {
|
||||
return false;
|
||||
};
|
||||
// A collection of nodes, each one representing an expression.
|
||||
// exports.Expressions: (nodes) ->
|
||||
// this.mark_as_statement()
|
||||
// this.expressions: []
|
||||
// this.children([this.expressions])
|
||||
// for n in nodes
|
||||
// this.expressions: flatten this.expressions, n
|
||||
// exports.Expressions extends exports.Node
|
||||
exports.Expressions.prototype.TRAILING_WHITESPACE = /\s+$/;
|
||||
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.
|
||||
exports.Expressions.prototype.wrap = function wrap(nodes) {
|
||||
if (nodes.length === 1 && nodes[0] instanceof exports.Expressions) {
|
||||
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(nodes);
|
||||
return new Expressions.apply(this, nodes);
|
||||
};
|
||||
// Tack an expression on to the end of this expression list.
|
||||
exports.Expressions.prototype.push = function push(node) {
|
||||
Expressions.prototype.push = function push(node) {
|
||||
this.expressions.push(node);
|
||||
return this;
|
||||
};
|
||||
// Tack an expression on to the beginning of this expression list.
|
||||
exports.Expressions.prototype.unshift = function unshift(node) {
|
||||
Expressions.prototype.unshift = function unshift(node) {
|
||||
this.expressions.unshift(node);
|
||||
return this;
|
||||
};
|
||||
// If this Expressions consists of a single node, pull it back out.
|
||||
exports.Expressions.prototype.unwrap = function unwrap() {
|
||||
Expressions.prototype.unwrap = function unwrap() {
|
||||
return this.expressions.length === 1 ? this.expressions[0] : this;
|
||||
};
|
||||
// Is this an empty block of code?
|
||||
exports.Expressions.prototype.is_empty = function is_empty() {
|
||||
Expressions.prototype.empty = function empty() {
|
||||
return this.expressions.length === 0;
|
||||
};
|
||||
// Is the node last in this block of expressions.
|
||||
exports.Expressions.prototype.is_last = function is_last(node) {
|
||||
var arr_length;
|
||||
arr_length = this.expressions.length;
|
||||
this.last_index = this.last_index || this.expressions[arr_length - 1] instanceof exports.CommentNode ? -2 : -1;
|
||||
return node === this.expressions[arr_length - this.last_index];
|
||||
// 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];
|
||||
};
|
||||
exports.Expressions.prototype.compile = function compile(o) {
|
||||
var opts;
|
||||
opts = (typeof o !== "undefined" && o !== null) ? o : {
|
||||
};
|
||||
return opts.scope ? exports.Expressions.__superClass__.compile.call(this, dup(opts)) : this.compile_root(o);
|
||||
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.
|
||||
exports.Expressions.prototype.compile_node = function compile_node(options) {
|
||||
var __a, __b, __c, __d, __e, code, compiled, e, line, opts;
|
||||
opts = (typeof options !== "undefined" && options !== null) ? options : {
|
||||
};
|
||||
compiled = [];
|
||||
__a = this.expressions;
|
||||
for (__b = 0; __b < __a.length; __b++) {
|
||||
e = __a[__b];
|
||||
compiled.push(this.compile_expression(e, dup(options)));
|
||||
}
|
||||
code = '';
|
||||
__c = []; __d = compiled;
|
||||
for (__e = 0; __e < __d.length; __e++) {
|
||||
line = __d[__e];
|
||||
__c.push((code = code + line + '\n'));
|
||||
}
|
||||
return __c;
|
||||
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)));
|
||||
}
|
||||
return __b;
|
||||
}).call(this)).join("\n");
|
||||
};
|
||||
// If this is the top-level Expressions, wrap everything in a safety closure.
|
||||
exports.Expressions.prototype.compile_root = function compile_root(o) {
|
||||
var code, indent, opts;
|
||||
opts = (typeof o !== "undefined" && o !== null) ? o : {
|
||||
};
|
||||
indent = opts.no_wrap ? '' : this.TAB;
|
||||
this.indent = indent;
|
||||
opts.indent = indent;
|
||||
opts.scope = new Scope(null, this, null);
|
||||
code = opts.globals ? compile_node(opts) : compile_with_declarations(opts);
|
||||
code.replace(this.TRAILING_WHITESPACE, '');
|
||||
return this.write(opts.no_wrap ? code : "(function(){\n" + code + "\n})();");
|
||||
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})();";
|
||||
};
|
||||
})();
|
||||
@@ -67,7 +67,7 @@ module CoffeeScript
|
||||
@indent + (TAB * tabs)
|
||||
end
|
||||
|
||||
# Does this node, or any of it's children, contain a node of a certain kind?
|
||||
# Does this node, or any of its children, contain a node of a certain kind?
|
||||
def contains?(&block)
|
||||
children.each do |node|
|
||||
return true if yield(node)
|
||||
@@ -124,7 +124,7 @@ module CoffeeScript
|
||||
@expressions.empty?
|
||||
end
|
||||
|
||||
# Is the node last in this block of expressions.
|
||||
# Is the node last in this block of expressions?
|
||||
def last?(node)
|
||||
@last_index ||= @expressions.last.is_a?(CommentNode) ? -2 : -1
|
||||
node == @expressions[@last_index]
|
||||
@@ -135,8 +135,8 @@ module CoffeeScript
|
||||
end
|
||||
|
||||
# Compile each expression in the Expressions body.
|
||||
def compile_node(options={})
|
||||
write(@expressions.map {|n| compile_expression(n, options.dup) }.join("\n"))
|
||||
def compile_node(o={})
|
||||
write(@expressions.map {|n| compile_expression(n, o.dup) }.join("\n"))
|
||||
end
|
||||
|
||||
# If this is the top-level Expressions, wrap everything in a safety closure.
|
||||
|
||||
@@ -84,6 +84,8 @@
|
||||
return new AssignNode(new ValueNode(yytext), $3, 'object');
|
||||
}), o("STRING ASSIGN Expression", function() {
|
||||
return new AssignNode(new ValueNode(new LiteralNode(yytext)), $3, 'object');
|
||||
}), o("NUMBER ASSIGN Expression", function() {
|
||||
return new AssignNode(new ValueNode(new LiteralNode(yytext)), $3, 'object');
|
||||
}), o("Comment")
|
||||
],
|
||||
// A return statement.
|
||||
@@ -210,208 +212,264 @@
|
||||
return new ValueNode($1);
|
||||
}), o("Range", function() {
|
||||
return new ValueNode($1);
|
||||
}),
|
||||
// o "Value Accessor", -> $1.push($2)
|
||||
o("Invocation Accessor", function() {
|
||||
}), o("Value Accessor", function() {
|
||||
return $1.push($2);
|
||||
}), o("Invocation Accessor", function() {
|
||||
return new ValueNode($1, [$2]);
|
||||
})
|
||||
],
|
||||
// Accessing into an object or array, through dot or index notation.
|
||||
Accessor: [o("PROPERTY_ACCESS IDENTIFIER", function() {
|
||||
return new AccessorNode(yytext);
|
||||
}), o("PROTOTYPE_ACCESS IDENTIFIER", function() {
|
||||
return new AccessorNode(yytext, 'prototype');
|
||||
}), o("SOAK_ACCESS IDENTIFIER", function() {
|
||||
return new AccessorNode(yytext, 'soak');
|
||||
}), o("Index"), o("Slice", function() {
|
||||
return new SliceNode($1);
|
||||
})
|
||||
],
|
||||
// Indexing into an object or array.
|
||||
Index: [o("INDEX_START Expression INDEX_END", function() {
|
||||
return new IndexNode($2);
|
||||
})
|
||||
],
|
||||
// An object literal.
|
||||
Object: [o("{ AssignList }", function() {
|
||||
return new ObjectNode($2);
|
||||
})
|
||||
],
|
||||
// Assignment within an object literal (comma or newline separated).
|
||||
AssignList: [o("", function() {
|
||||
return [];
|
||||
}), o("AssignObj", function() {
|
||||
return [$1];
|
||||
}), o("AssignList , AssignObj", function() {
|
||||
return $1.push($3);
|
||||
}), o("AssignList TERMINATOR AssignObj", function() {
|
||||
return $1.push($3);
|
||||
}), o("AssignList , TERMINATOR AssignObj", function() {
|
||||
return $1.push($4);
|
||||
}), o("INDENT AssignList OUTDENT", function() {
|
||||
return $2;
|
||||
})
|
||||
],
|
||||
// All flavors of function call (instantiation, super, and regular).
|
||||
Call: [o("Invocation", function() {
|
||||
return $1;
|
||||
}), o("NEW Invocation", function() {
|
||||
return $2.new_instance();
|
||||
}), o("Super", function() {
|
||||
return $1;
|
||||
})
|
||||
],
|
||||
// Extending an object's prototype.
|
||||
Extends: [o("Value EXTENDS Value", function() {
|
||||
return new ExtendsNode($1, $3);
|
||||
})
|
||||
],
|
||||
// A generic function invocation.
|
||||
Invocation: [o("Value Arguments", function() {
|
||||
return new CallNode($1, $2);
|
||||
}), o("Invocation Arguments", function() {
|
||||
return new CallNode($1, $2);
|
||||
})
|
||||
],
|
||||
// The list of arguments to a function invocation.
|
||||
Arguments: [o("CALL_START ArgList CALL_END", function() {
|
||||
return $2;
|
||||
})
|
||||
],
|
||||
// Calling super.
|
||||
Super: [o("SUPER CALL_START ArgList CALL_END", function() {
|
||||
return new CallNode('super', $3);
|
||||
})
|
||||
],
|
||||
// The range literal.
|
||||
Range: [o("[ Expression . . Expression ]", function() {
|
||||
return new RangeNode($2, $5);
|
||||
}), o("[ Expression . . . Expression ]", function() {
|
||||
return new RangeNode($2, $6, true);
|
||||
})
|
||||
],
|
||||
// The slice literal.
|
||||
Slice: [o("INDEX_START Expression . . Expression INDEX_END", function() {
|
||||
return new RangeNode($2, $5);
|
||||
}), o("INDEX_START Expression . . . Expression INDEX_END", function() {
|
||||
return new RangeNode($2, $6, true);
|
||||
})
|
||||
],
|
||||
// The array literal.
|
||||
Array: [o("[ ArgList ]", function() {
|
||||
return new ArrayNode($2);
|
||||
})
|
||||
],
|
||||
// A list of arguments to a method call, or as the contents of an array.
|
||||
ArgList: [o("", function() {
|
||||
return [];
|
||||
}), o("Expression", function() {
|
||||
return val;
|
||||
}), o("INDENT Expression", function() {
|
||||
return [$2];
|
||||
}), o("ArgList , Expression", function() {
|
||||
return $1.push($3);
|
||||
}), o("ArgList TERMINATOR Expression", function() {
|
||||
return $1.push($3);
|
||||
}), o("ArgList , TERMINATOR Expression", function() {
|
||||
return $1.push($4);
|
||||
}), o("ArgList , INDENT Expression", function() {
|
||||
return $1.push($4);
|
||||
}), o("ArgList OUTDENT", function() {
|
||||
return $1;
|
||||
})
|
||||
],
|
||||
// Just simple, comma-separated, required arguments (no fancy syntax).
|
||||
SimpleArgs: [o("Expression", function() {
|
||||
return $1;
|
||||
}), o("SimpleArgs , Expression", function() {
|
||||
return ([$1].push($3)).reduce(function(a, b) {
|
||||
return a.concat(b);
|
||||
});
|
||||
})
|
||||
],
|
||||
// Try/catch/finally exception handling blocks.
|
||||
Try: [o("TRY Block Catch", function() {
|
||||
return new TryNode($2, $3[0], $3[1]);
|
||||
}), o("TRY Block FINALLY Block", function() {
|
||||
return new TryNode($2, null, null, $4);
|
||||
}), o("TRY Block Catch FINALLY Block", function() {
|
||||
return new TryNode($2, $3[0], $3[1], $5);
|
||||
})
|
||||
],
|
||||
// A catch clause.
|
||||
Catch: [o("CATCH IDENTIFIER Block", function() {
|
||||
return [$2, $3];
|
||||
})
|
||||
],
|
||||
// Throw an exception.
|
||||
Throw: [o("THROW Expression", function() {
|
||||
return new ThrowNode($2);
|
||||
})
|
||||
],
|
||||
// Parenthetical expressions.
|
||||
Parenthetical: [o("( Expression )", function() {
|
||||
return new ParentheticalNode($2);
|
||||
})
|
||||
],
|
||||
// The while loop. (there is no do..while).
|
||||
While: [o("WHILE Expression Block", function() {
|
||||
return new WhileNode($2, $3);
|
||||
}), o("WHILE Expression", function() {
|
||||
return new WhileNode($2, null);
|
||||
}), o("Expression WHILE Expression", function() {
|
||||
return new WhileNode($3, Expressions.wrap($1));
|
||||
})
|
||||
],
|
||||
// Array comprehensions, including guard and current index.
|
||||
// Looks a little confusing, check nodes.rb for the arguments to ForNode.
|
||||
For: [o("Expression FOR ForVariables ForSource", function() {
|
||||
return new ForNode($1, $4, $3[0], $3[1]);
|
||||
}), o("FOR ForVariables ForSource Block", function() {
|
||||
return new ForNode($4, $3, $2[0], $2[1]);
|
||||
})
|
||||
],
|
||||
// An array comprehension has variables for the current element and index.
|
||||
ForVariables: [o("IDENTIFIER", function() {
|
||||
return [$1];
|
||||
}), o("IDENTIFIER , IDENTIFIER", function() {
|
||||
return [$1, $3];
|
||||
})
|
||||
],
|
||||
// The source of the array comprehension can optionally be filtered.
|
||||
ForSource: [o("IN Expression", function() {
|
||||
return {
|
||||
source: $2
|
||||
};
|
||||
}), o("OF Expression", function() {
|
||||
return {
|
||||
source: $2,
|
||||
object: true
|
||||
};
|
||||
}), o("ForSource WHEN Expression", function() {
|
||||
$1.filter = $3;
|
||||
return $1;
|
||||
}), o("ForSource BY Expression", function() {
|
||||
$1.step = $3;
|
||||
return $1;
|
||||
})
|
||||
],
|
||||
// Switch/When blocks.
|
||||
Switch: [o("SWITCH Expression INDENT Whens OUTDENT", function() {
|
||||
return $4.rewrite_condition($2);
|
||||
}), o("SWITCH Expression INDENT Whens ELSE Block OUTDENT", function() {
|
||||
return $4.rewrite_condition($2).add_else($6);
|
||||
})
|
||||
],
|
||||
// The inner list of whens.
|
||||
Whens: [o("When", function() {
|
||||
return $1;
|
||||
}), o("Whens When", function() {
|
||||
return $1.push($2);
|
||||
})
|
||||
],
|
||||
// An individual when.
|
||||
When: [o("LEADING_WHEN SimpleArgs Block", function() {
|
||||
return new IfNode($2, $3, null, {
|
||||
statement: true
|
||||
});
|
||||
}), o("LEADING_WHEN SimpleArgs Block TERMINATOR", function() {
|
||||
return new IfNode($2, $3, null, {
|
||||
statement: true
|
||||
});
|
||||
}), o("Comment TERMINATOR When", function() {
|
||||
return $3.add_comment($1);
|
||||
})
|
||||
],
|
||||
// The most basic form of "if".
|
||||
IfBlock: [o("IF Expression Block", function() {
|
||||
return new IfNode($2, $3);
|
||||
})
|
||||
],
|
||||
// An elsif portion of an if-else block.
|
||||
ElsIf: [o("ELSE IfBlock", function() {
|
||||
return $2.force_statement();
|
||||
})
|
||||
],
|
||||
// Multiple elsifs can be chained together.
|
||||
ElsIfs: [o("ElsIf", function() {
|
||||
return $1;
|
||||
}), o("ElsIfs ElsIf", function() {
|
||||
return $1.add_else($2);
|
||||
})
|
||||
],
|
||||
// Terminating else bodies are strictly optional.
|
||||
ElseBody: [o("", function() {
|
||||
return null;
|
||||
}), o("ELSE Block", function() {
|
||||
return $2;
|
||||
})
|
||||
],
|
||||
// All the alternatives for ending an if-else block.
|
||||
IfEnd: [o("ElseBody", function() {
|
||||
return $1;
|
||||
}), o("ElsIfs ElseBody", function() {
|
||||
return $1.add_else($2);
|
||||
})
|
||||
],
|
||||
// The full complement of if blocks, including postfix one-liner ifs and unlesses.
|
||||
If: [o("IfBlock IfEnd", function() {
|
||||
return $1.add_else($2);
|
||||
}), o("Expression IF Expression", function() {
|
||||
return new IfNode($3, Expressions.wrap($1), null, {
|
||||
statement: true
|
||||
});
|
||||
}), o("Expression UNLESS Expression", function() {
|
||||
return new IfNode($3, Expressions.wrap($1), null, {
|
||||
statement: true,
|
||||
invert: true
|
||||
});
|
||||
})
|
||||
]
|
||||
// # Accessing into an object or array, through dot or index notation.
|
||||
// Accessor: [
|
||||
// o "PROPERTY_ACCESS IDENTIFIER", -> new AccessorNode($2)
|
||||
// o "PROTOTYPE_ACCESS IDENTIFIER", -> new AccessorNode($2, 'prototype')
|
||||
// o "SOAK_ACCESS IDENTIFIER", -> new AccessorNode($2, 'soak')
|
||||
// o "Index"
|
||||
// o "Slice", -> new SliceNode($1)
|
||||
// ]
|
||||
//
|
||||
// # Indexing into an object or array.
|
||||
// Index: [
|
||||
// o "INDEX_START Expression INDEX_END", -> new IndexNode($2)
|
||||
// ]
|
||||
//
|
||||
// # An object literal.
|
||||
// Object: [
|
||||
// o "{ AssignList }", -> new ObjectNode($2)
|
||||
// ]
|
||||
//
|
||||
// # Assignment within an object literal (comma or newline separated).
|
||||
// AssignList: [
|
||||
// o "", -> []
|
||||
// o "AssignObj", -> [$1]
|
||||
// o "AssignList , AssignObj", -> $1.push $3
|
||||
// o "AssignList TERMINATOR AssignObj", -> $1.push $3
|
||||
// o "AssignList , TERMINATOR AssignObj", -> $1.push $4
|
||||
// o "INDENT AssignList OUTDENT", -> $2
|
||||
// ]
|
||||
//
|
||||
// # All flavors of function call (instantiation, super, and regular).
|
||||
// Call: [
|
||||
// o "Invocation", -> $1
|
||||
// o "NEW Invocation", -> $2.new_instance()
|
||||
// o "Super", -> $1
|
||||
// ]
|
||||
//
|
||||
// # Extending an object's prototype.
|
||||
// Extends: [
|
||||
// o "Value EXTENDS Value", -> new ExtendsNode($1, $3)
|
||||
// ]
|
||||
//
|
||||
// # A generic function invocation.
|
||||
// Invocation: [
|
||||
// o "Value Arguments", -> new CallNode($1, $2)
|
||||
// o "Invocation Arguments", -> new CallNode($1, $2)
|
||||
// ]
|
||||
//
|
||||
// # The list of arguments to a function invocation.
|
||||
// Arguments: [
|
||||
// o "CALL_START ArgList CALL_END", -> $2
|
||||
// ]
|
||||
//
|
||||
// # Calling super.
|
||||
// Super: [
|
||||
// o "SUPER CALL_START ArgList CALL_END", -> new CallNode('super', $3)
|
||||
// ]
|
||||
//
|
||||
// # The range literal.
|
||||
// Range: [
|
||||
// o "[ Expression . . Expression ]", -> new RangeNode($2, $5)
|
||||
// o "[ Expression . . . Expression ]", -> new RangeNode($2, $6, true)
|
||||
// ]
|
||||
//
|
||||
// # The slice literal.
|
||||
// Slice: [
|
||||
// o "INDEX_START Expression . . Expression INDEX_END", -> new RangeNode($2, $5)
|
||||
// o "INDEX_START Expression . . . Expression INDEX_END", -> new RangeNode($2, $6, true)
|
||||
// ]
|
||||
//
|
||||
// # The array literal.
|
||||
// Array: [
|
||||
// o "[ ArgList ]", -> new ArrayNode($2)
|
||||
// ]
|
||||
//
|
||||
// # A list of arguments to a method call, or as the contents of an array.
|
||||
// ArgList: [
|
||||
// o "", -> []
|
||||
// o "Expression", -> val
|
||||
// o "INDENT Expression", -> [$2]
|
||||
// o "ArgList , Expression", -> $1.push $3
|
||||
// o "ArgList TERMINATOR Expression", -> $1.push $3
|
||||
// o "ArgList , TERMINATOR Expression", -> $1.push $4
|
||||
// o "ArgList , INDENT Expression", -> $1.push $4
|
||||
// o "ArgList OUTDENT", -> $1
|
||||
// ]
|
||||
//
|
||||
// # Just simple, comma-separated, required arguments (no fancy syntax).
|
||||
// SimpleArgs: [
|
||||
// o "Expression", -> $1
|
||||
// o "SimpleArgs , Expression", ->
|
||||
// ([$1].push($3)).reduce (a, b) -> a.concat(b)
|
||||
// ]
|
||||
//
|
||||
// # Try/catch/finally exception handling blocks.
|
||||
// Try: [
|
||||
// o "TRY Block Catch", -> new TryNode($2, $3[0], $3[1])
|
||||
// o "TRY Block FINALLY Block", -> new TryNode($2, nil, nil, $4)
|
||||
// o "TRY Block Catch FINALLY Block", -> new TryNode($2, $3[0], $3[1], $5)
|
||||
// ]
|
||||
//
|
||||
// # A catch clause.
|
||||
// Catch: [
|
||||
// o "CATCH IDENTIFIER Block", -> [$2, $3]
|
||||
// ]
|
||||
//
|
||||
// # Throw an exception.
|
||||
// Throw: [
|
||||
// o "THROW Expression", -> new ThrowNode($2)
|
||||
// ]
|
||||
//
|
||||
// # Parenthetical expressions.
|
||||
// Parenthetical: [
|
||||
// o "( Expression )", -> new ParentheticalNode($2)
|
||||
// ]
|
||||
//
|
||||
// # The while loop. (there is no do..while).
|
||||
// While: [
|
||||
// o "WHILE Expression Block", -> new WhileNode($2, $3)
|
||||
// o "WHILE Expression", -> new WhileNode($2, nil)
|
||||
// o "Expression WHILE Expression", -> new WhileNode($3, Expressions.wrap($1))
|
||||
// ]
|
||||
//
|
||||
// # Array comprehensions, including guard and current index.
|
||||
// # Looks a little confusing, check nodes.rb for the arguments to ForNode.
|
||||
// For: [
|
||||
// o "Expression FOR ForVariables ForSource", -> new ForNode($1, $4, $3[0], $3[1])
|
||||
// o "FOR ForVariables ForSource Block", -> new ForNode($4, $3, $2[0], $2[1])
|
||||
// ]
|
||||
//
|
||||
// # An array comprehension has variables for the current element and index.
|
||||
// ForVariables: [
|
||||
// o "IDENTIFIER", -> [$1]
|
||||
// o "IDENTIFIER , IDENTIFIER", -> [$1, $3]
|
||||
// ]
|
||||
//
|
||||
// # The source of the array comprehension can optionally be filtered.
|
||||
// ForSource: [
|
||||
// o "IN Expression", -> {source: $2}
|
||||
// o "OF Expression", -> {source: $2, object: true}
|
||||
// o "ForSource WHEN Expression", -> $1.filter: $3; $1
|
||||
// o "ForSource BY Expression", -> $1.step: $3; $1
|
||||
// ]
|
||||
//
|
||||
// # Switch/When blocks.
|
||||
// Switch: [
|
||||
// o "SWITCH Expression INDENT Whens OUTDENT", -> $4.rewrite_condition($2)
|
||||
// o "SWITCH Expression INDENT Whens ELSE Block OUTDENT", -> $4.rewrite_condition($2).add_else($6)
|
||||
// ]
|
||||
//
|
||||
// # The inner list of whens.
|
||||
// Whens: [
|
||||
// o "When", -> $1
|
||||
// o "Whens When", -> $1.push $2
|
||||
// ]
|
||||
//
|
||||
// # An individual when.
|
||||
// When: [
|
||||
// o "LEADING_WHEN SimpleArgs Block", -> new IfNode($2, $3, nil, {statement: true})
|
||||
// o "LEADING_WHEN SimpleArgs Block TERMINATOR", -> new IfNode($2, $3, nil, {statement: true})
|
||||
// o "Comment TERMINATOR When", -> $3.add_comment($1)
|
||||
// ]
|
||||
//
|
||||
// # The most basic form of "if".
|
||||
// IfBlock: [
|
||||
// o "IF Expression Block", -> new IfNode($2, $3)
|
||||
// ]
|
||||
//
|
||||
// # An elsif portion of an if-else block.
|
||||
// ElsIf: [
|
||||
// o "ELSE IfBlock", -> $2.force_statement()
|
||||
// ]
|
||||
//
|
||||
// # Multiple elsifs can be chained together.
|
||||
// ElsIfs: [
|
||||
// o "ElsIf", -> $1
|
||||
// o "ElsIfs ElsIf", -> $1.add_else($2)
|
||||
// ]
|
||||
//
|
||||
// # Terminating else bodies are strictly optional.
|
||||
// ElseBody: [
|
||||
// o "", -> null
|
||||
// o "ELSE Block", -> $2
|
||||
// ]
|
||||
//
|
||||
// # All the alternatives for ending an if-else block.
|
||||
// IfEnd: [
|
||||
// o "ElseBody", -> $1
|
||||
// o "ElsIfs ElseBody", -> $1.add_else($2)
|
||||
// ]
|
||||
//
|
||||
// # The full complement of if blocks, including postfix one-liner ifs and unlesses.
|
||||
// If: [
|
||||
// o "IfBlock IfEnd", -> $1.add_else($2)
|
||||
// o "Expression IF Expression", -> new IfNode($3, Expressions.wrap($1), nil, {statement: true})
|
||||
// o "Expression UNLESS Expression", -> new IfNode($3, Expressions.wrap($1), nil, {statement: true, invert: true})
|
||||
// ]
|
||||
};
|
||||
// Helpers ==============================================================
|
||||
// Make the Jison parser.
|
||||
|
||||
@@ -199,7 +199,7 @@
|
||||
last = stack.pop();
|
||||
stack[stack.length - 1] += last;
|
||||
}
|
||||
if (stack[stack.length - 1] > 0 && (IMPLICIT_END.indexOf(token[0]) >= 0 || (typeof !post !== "undefined" && !post !== null))) {
|
||||
if (stack[stack.length - 1] > 0 && (IMPLICIT_END.indexOf(token[0]) >= 0 || !(typeof post !== "undefined" && post !== null))) {
|
||||
idx = token[0] === 'OUTDENT' ? i + 1 : i;
|
||||
__k = 0; __l = stack[stack.length - 1];
|
||||
for (__j=0, tmp=__k; (__k <= __l ? tmp < __l : tmp > __l); (__k <= __l ? tmp += 1 : tmp -= 1), __j++) {
|
||||
|
||||
Reference in New Issue
Block a user