753 lines
21 KiB
JavaScript
753 lines
21 KiB
JavaScript
var func = function parse($TEXT, exigent_mode) {
|
|
|
|
var S = {
|
|
input : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
|
|
token : null,
|
|
prev : null,
|
|
peeked : null,
|
|
in_function : 0,
|
|
in_directives : true,
|
|
in_loop : 0,
|
|
labels : []
|
|
};
|
|
|
|
S.token = next();
|
|
|
|
function is(type, value) {
|
|
return is_token(S.token, type, value);
|
|
};
|
|
|
|
function peek() { return S.peeked || (S.peeked = S.input()); };
|
|
|
|
function next() {
|
|
S.prev = S.token;
|
|
if (S.peeked) {
|
|
S.token = S.peeked;
|
|
S.peeked = null;
|
|
} else {
|
|
S.token = S.input();
|
|
}
|
|
S.in_directives = S.in_directives && (
|
|
S.token.type == "string" || is("punc", ";")
|
|
);
|
|
return S.token;
|
|
};
|
|
|
|
function prev() {
|
|
return S.prev;
|
|
};
|
|
|
|
function croak(msg, line, col, pos) {
|
|
var ctx = S.input.context();
|
|
js_error(msg,
|
|
line != null ? line : ctx.tokline,
|
|
col != null ? col : ctx.tokcol,
|
|
pos != null ? pos : ctx.tokpos);
|
|
};
|
|
|
|
function token_error(token, msg) {
|
|
croak(msg, token.line, token.col);
|
|
};
|
|
|
|
function unexpected(token) {
|
|
if (token == null)
|
|
token = S.token;
|
|
token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
|
|
};
|
|
|
|
function expect_token(type, val) {
|
|
if (is(type, val)) {
|
|
return next();
|
|
}
|
|
token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
|
|
};
|
|
|
|
function expect(punc) { return expect_token("punc", punc); };
|
|
|
|
function can_insert_semicolon() {
|
|
return !exigent_mode && (
|
|
S.token.nlb || is("eof") || is("punc", "}")
|
|
);
|
|
};
|
|
|
|
function semicolon() {
|
|
if (is("punc", ";")) next();
|
|
else if (!can_insert_semicolon()) unexpected();
|
|
};
|
|
|
|
function parenthesised() {
|
|
expect("(");
|
|
var ex = expression();
|
|
expect(")");
|
|
return ex;
|
|
};
|
|
|
|
function embed_tokens(parser) {
|
|
return function() {
|
|
var start = S.token;
|
|
var expr = parser.apply(this, arguments);
|
|
var end = prev();
|
|
expr.start = start;
|
|
expr.end = end;
|
|
return expr;
|
|
};
|
|
};
|
|
|
|
var statement = embed_tokens(function() {
|
|
if (is("operator", "/") || is("operator", "/=")) {
|
|
S.peeked = null;
|
|
S.token = S.input(S.token.value.substr(1)); // force regexp
|
|
}
|
|
switch (S.token.type) {
|
|
case "string":
|
|
var dir = S.in_directives, stat = simple_statement();
|
|
// XXXv2: decide how to fix directives
|
|
// if (dir && stat instanceof AST_String && !is("punc", ","))
|
|
// return new AST_Directive({ value: stat.value });
|
|
return stat;
|
|
case "num":
|
|
case "regexp":
|
|
case "operator":
|
|
case "atom":
|
|
return simple_statement();
|
|
|
|
case "name":
|
|
return is_token(peek(), "punc", ":")
|
|
? labeled_statement()
|
|
: simple_statement();
|
|
|
|
case "punc":
|
|
switch (S.token.value) {
|
|
case "{":
|
|
return new AST_Statement({ body: block_() });
|
|
case "[":
|
|
case "(":
|
|
return simple_statement();
|
|
case ";":
|
|
next();
|
|
return new AST_Statement();
|
|
default:
|
|
unexpected();
|
|
}
|
|
|
|
case "keyword":
|
|
switch (prog1(S.token.value, next)) {
|
|
case "break":
|
|
return break_cont(AST_Break);
|
|
|
|
case "continue":
|
|
return break_cont(AST_Continue);
|
|
|
|
case "debugger":
|
|
semicolon();
|
|
return new AST_Debugger();
|
|
|
|
case "do":
|
|
return new AST_Do({
|
|
body : in_loop(statement),
|
|
condition : (expect_token("while"), prog1(parenthesised, semicolon))
|
|
});
|
|
|
|
case "while":
|
|
return new AST_While({
|
|
condition : parenthesised(),
|
|
body : in_loop(statement)
|
|
});
|
|
|
|
case "for":
|
|
return for_();
|
|
|
|
case "function":
|
|
return function_(true);
|
|
|
|
case "if":
|
|
return if_();
|
|
|
|
case "return":
|
|
if (S.in_function == 0)
|
|
croak("'return' outside of function");
|
|
return new AST_Return({
|
|
value: ( is("punc", ";")
|
|
? (next(), null)
|
|
: can_insert_semicolon()
|
|
? null
|
|
: prog1(expression, semicolon) )
|
|
});
|
|
|
|
case "switch":
|
|
return new AST_Switch({
|
|
expression : parenthesised(),
|
|
body : switch_block_()
|
|
});
|
|
|
|
case "throw":
|
|
if (S.token.nlb)
|
|
croak("Illegal newline after 'throw'");
|
|
return new AST_Throw({
|
|
value: prog1(expression, semicolon)
|
|
});
|
|
|
|
case "try":
|
|
return try_();
|
|
|
|
case "var":
|
|
return prog1(var_, semicolon);
|
|
|
|
case "const":
|
|
return prog1(const_, semicolon);
|
|
|
|
case "with":
|
|
return new AST_With({
|
|
expression : parenthesised(),
|
|
body : statement()
|
|
});
|
|
|
|
default:
|
|
unexpected();
|
|
}
|
|
}
|
|
});
|
|
|
|
function labeled_statement() {
|
|
var label = S.token.value;
|
|
next();
|
|
expect(":");
|
|
S.labels.push(label);
|
|
var start = S.token, stat = statement();
|
|
if (exigent_mode && !(stat instanceof AST_LabeledStatement))
|
|
unexpected(start);
|
|
S.labels.pop();
|
|
stat.label = label;
|
|
return stat;
|
|
};
|
|
|
|
function simple_statement() {
|
|
return new AST_Statement({ body: prog1(expression, semicolon) });
|
|
};
|
|
|
|
function break_cont(type) {
|
|
var name = null;
|
|
if (!can_insert_semicolon()) {
|
|
name = is("name") ? S.token.value : null;
|
|
}
|
|
if (name != null) {
|
|
next();
|
|
if (!member(name, S.labels))
|
|
croak("Label " + name + " without matching loop or statement");
|
|
}
|
|
else if (S.in_loop == 0)
|
|
croak(type.TYPE + " not inside a loop or switch");
|
|
semicolon();
|
|
return new type({ label: name });
|
|
};
|
|
|
|
function for_() {
|
|
expect("(");
|
|
var init = null;
|
|
if (!is("punc", ";")) {
|
|
init = is("keyword", "var")
|
|
? (next(), var_(true))
|
|
: expression(true, true);
|
|
if (is("operator", "in")) {
|
|
if (init instanceof AST_Var && init.definitions.length > 1)
|
|
croak("Only one variable declaration allowed in for..in loop");
|
|
next();
|
|
return for_in(init);
|
|
}
|
|
}
|
|
return regular_for(init);
|
|
};
|
|
|
|
function regular_for(init) {
|
|
expect(";");
|
|
var test = is("punc", ";") ? null : expression();
|
|
expect(";");
|
|
var step = is("punc", ")") ? null : expression();
|
|
expect(")");
|
|
return new AST_For({
|
|
init : init,
|
|
condition : test,
|
|
step : step,
|
|
body : in_loop(statement)
|
|
});
|
|
};
|
|
|
|
function for_in(init) {
|
|
var lhs = init instanceof AST_Var ? init.definitions[0].name : init;
|
|
var obj = expression();
|
|
expect(")");
|
|
return new AST_ForIn({
|
|
init : init,
|
|
lhs : lhs,
|
|
object : obj,
|
|
body : in_loop(statement)
|
|
});
|
|
};
|
|
|
|
var function_ = function(in_statement) {
|
|
var name = is("name") ? as_symbol() : null;
|
|
if (in_statement && !name)
|
|
unexpected();
|
|
expect("(");
|
|
var ctor = in_statement ? AST_Defun : AST_Function;
|
|
return new ctor({
|
|
name: name,
|
|
argnames: (function(first, a){
|
|
while (!is("punc", ")")) {
|
|
if (first) first = false; else expect(",");
|
|
a.push(as_symbol());
|
|
}
|
|
next();
|
|
return a;
|
|
})(true, []),
|
|
body: embed_tokens(function(){
|
|
++S.in_function;
|
|
var loop = S.in_loop;
|
|
S.in_directives = true;
|
|
S.in_loop = 0;
|
|
var a = block_();
|
|
--S.in_function;
|
|
S.in_loop = loop;
|
|
return new AST_Bracketed({ body: a });
|
|
})()
|
|
});
|
|
};
|
|
|
|
function if_() {
|
|
var cond = parenthesised(), body = statement(), belse = null;
|
|
if (is("keyword", "else")) {
|
|
next();
|
|
belse = statement();
|
|
}
|
|
return new AST_If({
|
|
condition : cond,
|
|
consequent : body,
|
|
alternative : belse
|
|
});
|
|
};
|
|
|
|
function block_() {
|
|
expect("{");
|
|
var a = [];
|
|
while (!is("punc", "}")) {
|
|
if (is("eof")) unexpected();
|
|
a.push(statement());
|
|
}
|
|
next();
|
|
return a;
|
|
};
|
|
|
|
var switch_block_ = embed_tokens(curry(in_loop, function(){
|
|
expect("{");
|
|
var a = [], cur = null;
|
|
while (!is("punc", "}")) {
|
|
if (is("eof")) unexpected();
|
|
if (is("keyword", "case")) {
|
|
next();
|
|
cur = [];
|
|
a.push(new AST_Case({ expression: expression(), body: cur }));
|
|
expect(":");
|
|
}
|
|
else if (is("keyword", "default")) {
|
|
next();
|
|
expect(":");
|
|
cur = [];
|
|
a.push(new AST_Default({ body: cur }));
|
|
}
|
|
else {
|
|
if (!cur) unexpected();
|
|
cur.push(statement());
|
|
}
|
|
}
|
|
next();
|
|
return new AST_SwitchBlock({ body: a });
|
|
}));
|
|
|
|
function try_() {
|
|
var body = new AST_Bracketed({
|
|
body: block_()
|
|
}), bcatch = null, bfinally = null;
|
|
if (is("keyword", "catch")) {
|
|
next();
|
|
expect("(");
|
|
var name = as_symbol();
|
|
next();
|
|
expect(")");
|
|
bcatch = new AST_Catch({
|
|
argname : name,
|
|
body : new AST_Bracketed({ body: block_() })
|
|
});
|
|
}
|
|
if (is("keyword", "finally")) {
|
|
next();
|
|
bfinally = new AST_Finally({ body: block_() });
|
|
}
|
|
if (!bcatch && !bfinally)
|
|
croak("Missing catch/finally blocks");
|
|
return new AST_Try({
|
|
btry : body,
|
|
bcatch : bcatch,
|
|
bfinally : bfinally
|
|
});
|
|
};
|
|
|
|
function vardefs(no_in) {
|
|
var a = [];
|
|
for (;;) {
|
|
a.push(new AST_VarDef({
|
|
start : S.token,
|
|
name : as_symbol(),
|
|
value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
|
|
end : prev()
|
|
}));
|
|
if (!is("punc", ","))
|
|
break;
|
|
next();
|
|
}
|
|
return a;
|
|
};
|
|
|
|
var var_ = embed_tokens(function(no_in) {
|
|
return new AST_Var({
|
|
definitions: vardefs(no_in)
|
|
});
|
|
});
|
|
|
|
var const_ = embed_tokens(function() {
|
|
return new AST_Const({
|
|
definitions: vardefs()
|
|
});
|
|
});
|
|
|
|
var new_ = embed_tokens(function() {
|
|
var newexp = expr_atom(false), args;
|
|
if (is("punc", "(")) {
|
|
next();
|
|
args = expr_list(")");
|
|
} else {
|
|
args = [];
|
|
}
|
|
return subscripts(new AST_New({
|
|
expression : newexp,
|
|
args : args
|
|
}), true);
|
|
});
|
|
|
|
function as_atom_node() {
|
|
var tok = S.token, ret;
|
|
switch (tok.type) {
|
|
case "name":
|
|
return as_symbol();
|
|
case "num":
|
|
ret = new AST_Number({ start: tok, end: tok, value: tok.value });
|
|
break;
|
|
case "string":
|
|
ret = new AST_String({ start: tok, end: tok, value: tok.value });
|
|
break;
|
|
case "regexp":
|
|
ret = new AST_RegExp({ start: tok, end: tok, pattern: tok.value[0], mods: tok.value[1] });
|
|
break;
|
|
case "atom":
|
|
switch (tok.value) {
|
|
case "false":
|
|
ret = new AST_False({ start: tok, end: tok });
|
|
break;
|
|
case "true":
|
|
ret = new AST_True({ start: tok, end: tok });
|
|
break;
|
|
case "null":
|
|
ret = new AST_Null({ start: tok, end: tok });
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
next();
|
|
return ret;
|
|
};
|
|
|
|
var expr_atom = function(allow_calls) {
|
|
if (is("operator", "new")) {
|
|
next();
|
|
return new_();
|
|
}
|
|
if (is("punc")) {
|
|
switch (S.token.value) {
|
|
case "(":
|
|
next();
|
|
return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
|
|
case "[":
|
|
next();
|
|
return subscripts(array_(), allow_calls);
|
|
case "{":
|
|
next();
|
|
return subscripts(object_(), allow_calls);
|
|
}
|
|
unexpected();
|
|
}
|
|
if (is("keyword", "function")) {
|
|
var start = S.token;
|
|
next();
|
|
var func = function_(false);
|
|
func.start = start;
|
|
func.end = prev();
|
|
return subscripts(func, allow_calls);
|
|
}
|
|
if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
|
|
return subscripts(as_atom_node(), allow_calls);
|
|
}
|
|
unexpected();
|
|
};
|
|
|
|
function expr_list(closing, allow_trailing_comma, allow_empty) {
|
|
var first = true, a = [];
|
|
while (!is("punc", closing)) {
|
|
if (first) first = false; else expect(",");
|
|
if (allow_trailing_comma && is("punc", closing)) break;
|
|
if (is("punc", ",") && allow_empty) {
|
|
a.push(new AST_Undefined({ start: S.token, end: S.token }));
|
|
} else {
|
|
a.push(expression(false));
|
|
}
|
|
}
|
|
next();
|
|
return a;
|
|
};
|
|
|
|
function array_() {
|
|
return new AST_Array({
|
|
elements: expr_list("]", !exigent_mode, true)
|
|
});
|
|
};
|
|
|
|
var object_ = embed_tokens(function() {
|
|
var first = true, a = [];
|
|
while (!is("punc", "}")) {
|
|
if (first) first = false; else expect(",");
|
|
if (!exigent_mode && is("punc", "}"))
|
|
// allow trailing comma
|
|
break;
|
|
var start = S.token;
|
|
var type = start.type;
|
|
var name = as_property_name();
|
|
if (type == "name" && !is("punc", ":")) {
|
|
if (name.name == "get") {
|
|
a.push(new AST_ObjectGetter({
|
|
start : start,
|
|
name : name,
|
|
func : function_(false),
|
|
end : prev()
|
|
}));
|
|
continue;
|
|
}
|
|
if (name.name == "set") {
|
|
a.push(new AST_ObjectSetter({
|
|
start : start,
|
|
name : name,
|
|
func : function_(false),
|
|
end : prev()
|
|
}));
|
|
continue;
|
|
}
|
|
}
|
|
expect(":");
|
|
a.push(new AST_ObjectKeyVal({
|
|
start : start,
|
|
key : name,
|
|
value : expression(false),
|
|
end : prev()
|
|
}));
|
|
}
|
|
next();
|
|
return new AST_Object({ properties: a });
|
|
});
|
|
|
|
function as_property_name() {
|
|
switch (S.token.type) {
|
|
case "num":
|
|
case "string":
|
|
return as_symbol(true);
|
|
}
|
|
return as_name();
|
|
};
|
|
|
|
function as_name() {
|
|
switch (S.token.type) {
|
|
case "name":
|
|
case "operator":
|
|
case "keyword":
|
|
case "atom":
|
|
return as_symbol(true);
|
|
default:
|
|
unexpected();
|
|
}
|
|
};
|
|
|
|
function as_symbol(noerror) {
|
|
if (!noerror && !is("name")) croak("Name expected");
|
|
var sym = new AST_Symbol({
|
|
name : String(S.token.value),
|
|
start : S.token,
|
|
end : S.token
|
|
});
|
|
next();
|
|
return sym;
|
|
};
|
|
|
|
var subscripts = embed_tokens(function(expr, allow_calls) {
|
|
if (is("punc", ".")) {
|
|
next();
|
|
return subscripts(new AST_Dot({
|
|
expression : expr,
|
|
property : as_name()
|
|
}), allow_calls);
|
|
}
|
|
if (is("punc", "[")) {
|
|
next();
|
|
return subscripts(new AST_Sub({
|
|
expression : expr,
|
|
property : prog1(expression, curry(expect, "]"))
|
|
}), allow_calls);
|
|
}
|
|
if (allow_calls && is("punc", "(")) {
|
|
next();
|
|
return subscripts(new AST_Call({
|
|
expression : expr,
|
|
args : expr_list(")")
|
|
}), true);
|
|
}
|
|
return expr;
|
|
});
|
|
|
|
var maybe_unary = embed_tokens(function(allow_calls) {
|
|
if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
|
|
return make_unary(AST_UnaryPrefix,
|
|
prog1(S.token.value, next),
|
|
maybe_unary(allow_calls));
|
|
}
|
|
var val = expr_atom(allow_calls);
|
|
while (is("operator") && HOP(UNARY_POSTFIX, S.token.value) && !S.token.nlb) {
|
|
val = make_unary(AST_UnaryPostfix, S.token.value, val);
|
|
next();
|
|
}
|
|
return val;
|
|
});
|
|
|
|
function make_unary(ctor, op, expr) {
|
|
if ((op == "++" || op == "--") && !is_assignable(expr))
|
|
croak("Invalid use of " + op + " operator");
|
|
return new ctor({ operator: op, expression: expr });
|
|
};
|
|
|
|
var expr_op = embed_tokens(function(left, min_prec, no_in) {
|
|
var op = is("operator") ? S.token.value : null;
|
|
if (op == "in" && no_in) op = null;
|
|
var prec = op != null ? PRECEDENCE[op] : null;
|
|
if (prec != null && prec > min_prec) {
|
|
next();
|
|
var right = expr_op(maybe_unary(true), prec, no_in);
|
|
return expr_op(new AST_Binary({
|
|
left : left,
|
|
operator : op,
|
|
right : right
|
|
}), min_prec, no_in);
|
|
}
|
|
return left;
|
|
});
|
|
|
|
function expr_ops(no_in) {
|
|
return expr_op(maybe_unary(true), 0, no_in);
|
|
};
|
|
|
|
var maybe_conditional = embed_tokens(function(no_in) {
|
|
var expr = expr_ops(no_in);
|
|
if (is("operator", "?")) {
|
|
next();
|
|
var yes = expression(false);
|
|
expect(":");
|
|
return new AST_Conditional({
|
|
condition: expr,
|
|
consequent: yes,
|
|
alternative: expression(false, no_in)
|
|
});
|
|
}
|
|
return expr;
|
|
});
|
|
|
|
function is_assignable(expr) {
|
|
if (!exigent_mode) return true;
|
|
switch (expr[0]+"") {
|
|
case "dot":
|
|
case "sub":
|
|
case "new":
|
|
case "call":
|
|
return true;
|
|
case "name":
|
|
return expr[1] != "this";
|
|
}
|
|
};
|
|
|
|
var maybe_assign = embed_tokens(function(no_in) {
|
|
var left = maybe_conditional(no_in), val = S.token.value;
|
|
if (is("operator") && HOP(ASSIGNMENT, val)) {
|
|
if (is_assignable(left)) {
|
|
next();
|
|
return new AST_Assign({
|
|
left : left,
|
|
operator : ASSIGNMENT[val],
|
|
right : maybe_assign(no_in)
|
|
});
|
|
}
|
|
croak("Invalid assignment");
|
|
}
|
|
return left;
|
|
});
|
|
|
|
var expression = embed_tokens(function(commas, no_in) {
|
|
if (arguments.length == 0)
|
|
commas = true;
|
|
var expr = maybe_assign(no_in);
|
|
if (commas && is("punc", ",")) {
|
|
next();
|
|
return new AST_Seq({
|
|
first : expr,
|
|
second : expression(true, no_in)
|
|
});
|
|
}
|
|
return expr;
|
|
});
|
|
|
|
function in_loop(cont) {
|
|
++S.in_loop;
|
|
var ret = cont();
|
|
--S.in_loop;
|
|
return ret;
|
|
};
|
|
|
|
return new AST_Toplevel({
|
|
body: (function(a){
|
|
while (!is("eof"))
|
|
a.push(statement());
|
|
return a;
|
|
})([])
|
|
});
|
|
|
|
};
|
|
|
|
console.time("parse");
|
|
var ast = parse(func.toString());
|
|
console.timeEnd("parse");
|
|
|
|
console.log(ast);
|
|
|
|
|
|
|
|
// var moo = 1, i, man = moo + bar;
|
|
// try {
|
|
// loop: while (/foobar/.test(bar)) {
|
|
// alert(bar);
|
|
// continue loop;
|
|
// }
|
|
// } finally {
|
|
// return crap;
|
|
// }
|