the parser seems too big to compile
This commit is contained in:
Jeremy Ashkenas
parent
bad50c9aee
commit
a0572f161d
|
|
@ -0,0 +1,34 @@
|
|||
(function(){
|
||||
exports.Node = function Node() {
|
||||
var __a;
|
||||
var arguments = Array.prototype.slice.call(arguments, 0);
|
||||
__a = this.values = arguments;
|
||||
return Node === this.constructor ? this : __a;
|
||||
};
|
||||
exports.Expressions = exports.Node;
|
||||
exports.LiteralNode = exports.Node;
|
||||
exports.ReturnNode = exports.Node;
|
||||
exports.CommentNode = exports.Node;
|
||||
exports.CallNode = exports.Node;
|
||||
exports.ExtendsNode = exports.Node;
|
||||
exports.ValueNode = exports.Node;
|
||||
exports.AccessorNode = exports.Node;
|
||||
exports.IndexNode = exports.Node;
|
||||
exports.RangeNode = exports.Node;
|
||||
exports.SliceNode = exports.Node;
|
||||
exports.AssignNode = exports.Node;
|
||||
exports.OpNode = exports.Node;
|
||||
exports.CodeNode = exports.Node;
|
||||
exports.SplatNode = exports.Node;
|
||||
exports.ObjectNode = exports.Node;
|
||||
exports.ArrayNode = exports.Node;
|
||||
exports.PushNode = exports.Node;
|
||||
exports.ClosureNode = exports.Node;
|
||||
exports.WhileNode = exports.Node;
|
||||
exports.ForNode = exports.Node;
|
||||
exports.TryNode = exports.Node;
|
||||
exports.ThrowNode = exports.Node;
|
||||
exports.ExistenceNode = exports.Node;
|
||||
exports.ParentheticalNode = exports.Node;
|
||||
exports.IfNode = exports.Node;
|
||||
})();
|
||||
|
|
@ -0,0 +1,564 @@
|
|||
(function(){
|
||||
var Parser, __a, __b, __c, __d, __e, __f, bnf, grammar, name, non_terminal, o, option, parser, part, tokens, unwrap;
|
||||
var __hasProp = Object.prototype.hasOwnProperty;
|
||||
Parser = require('jison').Parser;
|
||||
// DSL ===================================================================
|
||||
// Detect functions: [
|
||||
unwrap = /function\s*\(\)\s*\{\s*return\s*([\s\S]*);\s*\}/;
|
||||
// Quickie DSL for Jison access.
|
||||
o = function o(pattern_string, func) {
|
||||
var match;
|
||||
if (func) {
|
||||
func = (match = (func + "").match(unwrap)) ? match[1] : '(' + func + '())';
|
||||
return [pattern_string, '$$ = ' + func + ';'];
|
||||
} else {
|
||||
return [pattern_string, '$$ = $1;'];
|
||||
}
|
||||
};
|
||||
// Grammar ==============================================================
|
||||
grammar = {
|
||||
// All parsing will end in this rule, being the trunk of the AST.
|
||||
Root: [o("", function() {
|
||||
return new Expressions();
|
||||
}), o("Terminator", function() {
|
||||
return new Expressions();
|
||||
}), o("Expressions"), o("Block Terminator")
|
||||
],
|
||||
// Any list of expressions or method body, seperated by line breaks or semis.
|
||||
Expressions: [o("Expression", function() {
|
||||
return Expressions.wrap([$1]);
|
||||
}), o("Expressions Terminator Expression", function() {
|
||||
return $1.push($3);
|
||||
}), o("Expressions Terminator")
|
||||
],
|
||||
// All types of expressions in our language. The basic unit of CoffeeScript
|
||||
// is the expression.
|
||||
Expression: [o("Value"), o("Call"), o("Code"), o("Operation"), o("Assign"), o("If"), o("Try"), o("Throw"), o("Return"), o("While"), o("For"), o("Switch"), o("Extends"), o("Splat"), o("Existence"), o("Comment")],
|
||||
// A block of expressions. Note that the Rewriter will convert some postfix
|
||||
// forms into blocks for us, by altering the token stream.
|
||||
Block: [o("INDENT Expressions OUTDENT", function() {
|
||||
return $2;
|
||||
}), o("INDENT OUTDENT", function() {
|
||||
return new Expressions();
|
||||
})
|
||||
],
|
||||
// Tokens that can terminate an expression.
|
||||
Terminator: [o("\n"), o(";")],
|
||||
// All hard-coded values. These can be printed straight to JavaScript.
|
||||
Literal: [o("NUMBER", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("STRING", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("JS", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("REGEX", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("BREAK", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("CONTINUE", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("ARGUMENTS", function() {
|
||||
return new LiteralNode($1);
|
||||
}), o("TRUE", function() {
|
||||
return new LiteralNode(true);
|
||||
}), o("FALSE", function() {
|
||||
return new LiteralNode(false);
|
||||
}), o("YES", function() {
|
||||
return new LiteralNode(true);
|
||||
}), o("NO", function() {
|
||||
return new LiteralNode(false);
|
||||
}), o("ON", function() {
|
||||
return new LiteralNode(true);
|
||||
}), o("OFF", function() {
|
||||
return new LiteralNode(false);
|
||||
})
|
||||
],
|
||||
// Assignment to a variable (or index).
|
||||
Assign: [o("Value ASSIGN Expression", function() {
|
||||
return new AssignNode($1, $3);
|
||||
})
|
||||
],
|
||||
// Assignment within an object literal (can be quoted).
|
||||
AssignObj: [o("IDENTIFIER ASSIGN Expression", function() {
|
||||
return new AssignNode(new ValueNode($1), $3, 'object');
|
||||
}), o("STRING ASSIGN Expression", function() {
|
||||
return new AssignNode(new ValueNode(new LiteralNode($1)), $3, 'object');
|
||||
}), o("Comment")
|
||||
],
|
||||
// A return statement.
|
||||
Return: [o("RETURN Expression", function() {
|
||||
return new ReturnNode($2);
|
||||
}), o("RETURN", function() {
|
||||
return new ReturnNode(new ValueNode(new LiteralNode('null')));
|
||||
})
|
||||
],
|
||||
// A comment.
|
||||
Comment: [o("COMMENT", function() {
|
||||
return new CommentNode($1);
|
||||
})
|
||||
],
|
||||
// Arithmetic and logical operators
|
||||
// For Ruby's Operator precedence, see: [
|
||||
// https://www.cs.auckland.ac.nz/references/ruby/ProgrammingRuby/language.html
|
||||
Operation: [o("! Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("!! Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("- Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("+ Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("NOT Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("~ Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("-- Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("++ Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("DELETE Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("TYPEOF Expression", function() {
|
||||
return new OpNode($1, $2);
|
||||
}), o("Expression --", function() {
|
||||
return new OpNode($2, $1, null, true);
|
||||
}), o("Expression ++", function() {
|
||||
return new OpNode($2, $1, null, true);
|
||||
}), o("Expression * Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression / Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression % Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression + Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression - Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression << Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression >> Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression >>> Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression & Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression | Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression ^ Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression <= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression < Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression > Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression >= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression == Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression != Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression IS Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression ISNT Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression && Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression || Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression AND Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression OR Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression ? Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression -= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression += Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression /= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression *= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression %= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression ||= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression &&= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression ?= Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression INSTANCEOF Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
}), o("Expression IN Expression", function() {
|
||||
return new OpNode($2, $1, $3);
|
||||
})
|
||||
],
|
||||
// The existence operator.
|
||||
Existence: [o("Expression ?", function() {
|
||||
return new ExistenceNode($1);
|
||||
})
|
||||
],
|
||||
// Function definition.
|
||||
Code: [o("PARAM_START ParamList PARAM_END FuncGlyph Block", function() {
|
||||
return new CodeNode($2, $5, $4);
|
||||
}), o("FuncGlyph Block", function() {
|
||||
return new CodeNode([], $2, $1);
|
||||
})
|
||||
],
|
||||
// The symbols to signify functions, and bound functions.
|
||||
FuncGlyph: [o("->", function() {
|
||||
return 'func';
|
||||
}), o("=>", function() {
|
||||
return 'boundfunc';
|
||||
})
|
||||
],
|
||||
// The parameters to a function definition.
|
||||
ParamList: [o("Param", function() {
|
||||
return [$1];
|
||||
}), o("ParamList , Param", function() {
|
||||
return $1.push($3);
|
||||
})
|
||||
],
|
||||
// A Parameter (or ParamSplat) in a function definition.
|
||||
Param: [o("PARAM"), o("PARAM . . .", function() {
|
||||
return new SplatNode($1);
|
||||
})
|
||||
],
|
||||
// A regular splat.
|
||||
Splat: [o("Expression . . .", function() {
|
||||
return new SplatNode($1);
|
||||
})
|
||||
],
|
||||
// Expressions that can be treated as values.
|
||||
Value: [o("IDENTIFIER", function() {
|
||||
return new ValueNode($1);
|
||||
}), o("Literal", function() {
|
||||
return new ValueNode($1);
|
||||
}), o("Array", function() {
|
||||
return new ValueNode($1);
|
||||
}), o("Object", function() {
|
||||
return new ValueNode($1);
|
||||
}), o("Parenthetical", function() {
|
||||
return new ValueNode($1);
|
||||
}), o("Range", function() {
|
||||
return new ValueNode($1);
|
||||
}), 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($2);
|
||||
}), o("PROTOTYPE_ACCESS IDENTIFIER", function() {
|
||||
return new AccessorNode($2, 'prototype');
|
||||
}), o("SOAK_ACCESS IDENTIFIER", function() {
|
||||
return new AccessorNode($2, '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, nil, nil, $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, nil);
|
||||
}), 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, nil, {
|
||||
statement: true
|
||||
});
|
||||
}), o("LEADING_WHEN SimpleArgs Block Terminator", function() {
|
||||
return new IfNode($2, $3, nil, {
|
||||
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), nil, {
|
||||
statement: true
|
||||
});
|
||||
}), o("Expression UNLESS Expression", function() {
|
||||
return new IfNode($3, Expressions.wrap($1), nil, {
|
||||
statement: true,
|
||||
invert: true
|
||||
});
|
||||
})
|
||||
]
|
||||
};
|
||||
// Helpers ==============================================================
|
||||
// Make the Jison parser.
|
||||
bnf = {
|
||||
};
|
||||
tokens = [];
|
||||
__a = grammar;
|
||||
for (name in __a) {
|
||||
non_terminal = __a[name];
|
||||
if (__hasProp.call(__a, name)) {
|
||||
bnf[name] = (function() {
|
||||
__b = []; __c = non_terminal;
|
||||
for (__d = 0; __d < __c.length; __d++) {
|
||||
option = __c[__d];
|
||||
__b.push((function() {
|
||||
__e = option[0].split(" ");
|
||||
for (__f = 0; __f < __e.length; __f++) {
|
||||
part = __e[__f];
|
||||
!grammar[part] ? tokens.push(part) : null;
|
||||
}
|
||||
name === "Root" ? (option[1] = "return " + option[1]) : null;
|
||||
return option;
|
||||
}).call(this));
|
||||
}
|
||||
return __b;
|
||||
}).call(this);
|
||||
}
|
||||
}
|
||||
tokens = tokens.join(" ");
|
||||
parser = new Parser({
|
||||
tokens: tokens,
|
||||
bnf: bnf
|
||||
}, {
|
||||
debug: false
|
||||
});
|
||||
// Thin wrapper around the real lexer
|
||||
parser.lexer = {
|
||||
lex: function lex() {
|
||||
var token;
|
||||
token = this.tokens[this.pos] || [""];
|
||||
this.pos += 1;
|
||||
// this.yylineno: token and token[1] and token[1][1]
|
||||
this.yytext = token[1];
|
||||
return token[0];
|
||||
},
|
||||
setInput: function setInput(tokens) {
|
||||
this.tokens = tokens;
|
||||
return this.pos = 0;
|
||||
},
|
||||
upcomingInput: function upcomingInput() {
|
||||
return "";
|
||||
},
|
||||
showPosition: function showPosition() {
|
||||
return this.pos;
|
||||
}
|
||||
};
|
||||
exports.Parser = function Parser() { };
|
||||
exports.Parser.prototype.parse = function parse(tokens) {
|
||||
return parser.parse(tokens);
|
||||
};
|
||||
})();
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
exports.Node: -> this.values: arguments
|
||||
|
||||
exports.Expressions : exports.Node
|
||||
exports.LiteralNode : exports.Node
|
||||
exports.ReturnNode : exports.Node
|
||||
exports.CommentNode : exports.Node
|
||||
exports.CallNode : exports.Node
|
||||
exports.ExtendsNode : exports.Node
|
||||
exports.ValueNode : exports.Node
|
||||
exports.AccessorNode : exports.Node
|
||||
exports.IndexNode : exports.Node
|
||||
exports.RangeNode : exports.Node
|
||||
exports.SliceNode : exports.Node
|
||||
exports.AssignNode : exports.Node
|
||||
exports.OpNode : exports.Node
|
||||
exports.CodeNode : exports.Node
|
||||
exports.SplatNode : exports.Node
|
||||
exports.ObjectNode : exports.Node
|
||||
exports.ArrayNode : exports.Node
|
||||
exports.PushNode : exports.Node
|
||||
exports.ClosureNode : exports.Node
|
||||
exports.WhileNode : exports.Node
|
||||
exports.ForNode : exports.Node
|
||||
exports.TryNode : exports.Node
|
||||
exports.ThrowNode : exports.Node
|
||||
exports.ExistenceNode : exports.Node
|
||||
exports.ParentheticalNode : exports.Node
|
||||
exports.IfNode : exports.Node
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,448 @@
|
|||
Parser: require('jison').Parser
|
||||
|
||||
# DSL ===================================================================
|
||||
|
||||
# Detect functions: [
|
||||
unwrap: /function\s*\(\)\s*\{\s*return\s*([\s\S]*);\s*\}/
|
||||
|
||||
# Quickie DSL for Jison access.
|
||||
o: (pattern_string, func) ->
|
||||
if func
|
||||
func: if match: (func + "").match(unwrap) then match[1] else '(' + func + '())'
|
||||
[pattern_string, '$$ = ' + func + ';']
|
||||
else
|
||||
[pattern_string, '$$ = $1;']
|
||||
|
||||
# Grammar ==============================================================
|
||||
|
||||
grammar: {
|
||||
|
||||
# All parsing will end in this rule, being the trunk of the AST.
|
||||
Root: [
|
||||
o "", -> new Expressions()
|
||||
o "Terminator", -> new Expressions()
|
||||
o "Expressions"
|
||||
o "Block Terminator"
|
||||
]
|
||||
|
||||
# Any list of expressions or method body, seperated by line breaks or semis.
|
||||
Expressions: [
|
||||
o "Expression", -> Expressions.wrap([$1])
|
||||
o "Expressions Terminator Expression", -> $1.push($3)
|
||||
o "Expressions Terminator"
|
||||
]
|
||||
|
||||
# All types of expressions in our language. The basic unit of CoffeeScript
|
||||
# is the expression.
|
||||
Expression: [
|
||||
o "Value"
|
||||
o "Call"
|
||||
o "Code"
|
||||
o "Operation"
|
||||
o "Assign"
|
||||
o "If"
|
||||
o "Try"
|
||||
o "Throw"
|
||||
o "Return"
|
||||
o "While"
|
||||
o "For"
|
||||
o "Switch"
|
||||
o "Extends"
|
||||
o "Splat"
|
||||
o "Existence"
|
||||
o "Comment"
|
||||
]
|
||||
|
||||
# A block of expressions. Note that the Rewriter will convert some postfix
|
||||
# forms into blocks for us, by altering the token stream.
|
||||
Block: [
|
||||
o "INDENT Expressions OUTDENT", -> $2
|
||||
o "INDENT OUTDENT", -> new Expressions()
|
||||
]
|
||||
|
||||
# Tokens that can terminate an expression.
|
||||
Terminator: [
|
||||
o "\n"
|
||||
o ";"
|
||||
]
|
||||
|
||||
# All hard-coded values. These can be printed straight to JavaScript.
|
||||
Literal: [
|
||||
o "NUMBER", -> new LiteralNode($1)
|
||||
o "STRING", -> new LiteralNode($1)
|
||||
o "JS", -> new LiteralNode($1)
|
||||
o "REGEX", -> new LiteralNode($1)
|
||||
o "BREAK", -> new LiteralNode($1)
|
||||
o "CONTINUE", -> new LiteralNode($1)
|
||||
o "ARGUMENTS", -> new LiteralNode($1)
|
||||
o "TRUE", -> new LiteralNode(true)
|
||||
o "FALSE", -> new LiteralNode(false)
|
||||
o "YES", -> new LiteralNode(true)
|
||||
o "NO", -> new LiteralNode(false)
|
||||
o "ON", -> new LiteralNode(true)
|
||||
o "OFF", -> new LiteralNode(false)
|
||||
]
|
||||
|
||||
# Assignment to a variable (or index).
|
||||
Assign: [
|
||||
o "Value ASSIGN Expression", -> new AssignNode($1, $3)
|
||||
]
|
||||
|
||||
# Assignment within an object literal (can be quoted).
|
||||
AssignObj: [
|
||||
o "IDENTIFIER ASSIGN Expression", -> new AssignNode(new ValueNode($1), $3, 'object')
|
||||
o "STRING ASSIGN Expression", -> new AssignNode(new ValueNode(new LiteralNode($1)), $3, 'object')
|
||||
o "Comment"
|
||||
]
|
||||
|
||||
# A return statement.
|
||||
Return: [
|
||||
o "RETURN Expression", -> new ReturnNode($2)
|
||||
o "RETURN", -> new ReturnNode(new ValueNode(new LiteralNode('null')))
|
||||
]
|
||||
|
||||
# A comment.
|
||||
Comment: [
|
||||
o "COMMENT", -> new CommentNode($1)
|
||||
]
|
||||
|
||||
# Arithmetic and logical operators
|
||||
# For Ruby's Operator precedence, see: [
|
||||
# https://www.cs.auckland.ac.nz/references/ruby/ProgrammingRuby/language.html
|
||||
Operation: [
|
||||
o "! Expression", -> new OpNode($1, $2)
|
||||
o "!! Expression", -> new OpNode($1, $2)
|
||||
o "- Expression", -> new OpNode($1, $2)
|
||||
o "+ Expression", -> new OpNode($1, $2)
|
||||
o "NOT Expression", -> new OpNode($1, $2)
|
||||
o "~ Expression", -> new OpNode($1, $2)
|
||||
o "-- Expression", -> new OpNode($1, $2)
|
||||
o "++ Expression", -> new OpNode($1, $2)
|
||||
o "DELETE Expression", -> new OpNode($1, $2)
|
||||
o "TYPEOF Expression", -> new OpNode($1, $2)
|
||||
o "Expression --", -> new OpNode($2, $1, null, true)
|
||||
o "Expression ++", -> new OpNode($2, $1, null, true)
|
||||
|
||||
o "Expression * Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression / Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression % Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression + Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression - Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression << Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression >> Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression >>> Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression & Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression | Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression ^ Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression <= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression < Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression > Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression >= Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression == Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression != Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression IS Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression ISNT Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression && Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression || Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression AND Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression OR Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression ? Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression -= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression += Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression /= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression *= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression %= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression ||= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression &&= Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression ?= Expression", -> new OpNode($2, $1, $3)
|
||||
|
||||
o "Expression INSTANCEOF Expression", -> new OpNode($2, $1, $3)
|
||||
o "Expression IN Expression", -> new OpNode($2, $1, $3)
|
||||
]
|
||||
|
||||
# The existence operator.
|
||||
Existence: [
|
||||
o "Expression ?", -> new ExistenceNode($1)
|
||||
]
|
||||
|
||||
# Function definition.
|
||||
Code: [
|
||||
o "PARAM_START ParamList PARAM_END FuncGlyph Block", -> new CodeNode($2, $5, $4)
|
||||
o "FuncGlyph Block", -> new CodeNode([], $2, $1)
|
||||
]
|
||||
|
||||
# The symbols to signify functions, and bound functions.
|
||||
FuncGlyph: [
|
||||
o "->", -> 'func'
|
||||
o "=>", -> 'boundfunc'
|
||||
]
|
||||
|
||||
# The parameters to a function definition.
|
||||
ParamList: [
|
||||
o "Param", -> [$1]
|
||||
o "ParamList , Param", -> $1.push($3)
|
||||
]
|
||||
|
||||
# A Parameter (or ParamSplat) in a function definition.
|
||||
Param: [
|
||||
o "PARAM"
|
||||
o "PARAM . . .", -> new SplatNode($1)
|
||||
]
|
||||
|
||||
# A regular splat.
|
||||
Splat: [
|
||||
o "Expression . . .", -> new SplatNode($1)
|
||||
]
|
||||
|
||||
# Expressions that can be treated as values.
|
||||
Value: [
|
||||
o "IDENTIFIER", -> new ValueNode($1)
|
||||
o "Literal", -> new ValueNode($1)
|
||||
o "Array", -> new ValueNode($1)
|
||||
o "Object", -> new ValueNode($1)
|
||||
o "Parenthetical", -> new ValueNode($1)
|
||||
o "Range", -> new ValueNode($1)
|
||||
o "Value Accessor", -> $1.push($2)
|
||||
o "Invocation Accessor", -> new ValueNode($1, [$2])
|
||||
]
|
||||
|
||||
# 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.
|
||||
bnf: {}
|
||||
tokens: []
|
||||
for name, non_terminal of grammar
|
||||
bnf[name]: for option in non_terminal
|
||||
for part in option[0].split(" ")
|
||||
if !grammar[part]
|
||||
tokens.push(part)
|
||||
if name == "Root"
|
||||
option[1] = "return " + option[1]
|
||||
option
|
||||
tokens: tokens.join(" ")
|
||||
parser: new Parser({tokens: tokens, bnf: bnf}, {debug: false})
|
||||
|
||||
# Thin wrapper around the real lexer
|
||||
parser.lexer: {
|
||||
lex: ->
|
||||
token: this.tokens[this.pos] or [""]
|
||||
this.pos += 1
|
||||
# this.yylineno: token and token[1] and token[1][1]
|
||||
this.yytext: token[1]
|
||||
token[0]
|
||||
setInput: (tokens) ->
|
||||
this.tokens = tokens
|
||||
this.pos = 0
|
||||
upcomingInput: -> ""
|
||||
showPosition: -> this.pos
|
||||
}
|
||||
|
||||
exports.Parser: ->
|
||||
|
||||
exports.Parser::parse: (tokens) -> parser.parse(tokens)
|
||||
Loading…
Reference in New Issue