mirror of
https://github.com/renbaoshuo/S2OJ.git
synced 2024-09-21 14:15:19 +00:00
96d4a3ecf7
Due to historical reasons, the code is in subfolder "1". With SVN removal, we place the code back and remove the annoying "1" folder.
314 lines
11 KiB
JavaScript
314 lines
11 KiB
JavaScript
// AST walker module for Mozilla Parser API compatible trees
|
|
|
|
(function(mod) {
|
|
if (typeof exports == "object" && typeof module == "object") return mod(exports); // CommonJS
|
|
if (typeof define == "function" && define.amd) return define(["exports"], mod); // AMD
|
|
mod((this.acorn || (this.acorn = {})).walk = {}); // Plain browser env
|
|
})(function(exports) {
|
|
"use strict";
|
|
|
|
// A simple walk is one where you simply specify callbacks to be
|
|
// called on specific nodes. The last two arguments are optional. A
|
|
// simple use would be
|
|
//
|
|
// walk.simple(myTree, {
|
|
// Expression: function(node) { ... }
|
|
// });
|
|
//
|
|
// to do something with all expressions. All Parser API node types
|
|
// can be used to identify node types, as well as Expression,
|
|
// Statement, and ScopeBody, which denote categories of nodes.
|
|
//
|
|
// The base argument can be used to pass a custom (recursive)
|
|
// walker, and state can be used to give this walked an initial
|
|
// state.
|
|
exports.simple = function(node, visitors, base, state) {
|
|
if (!base) base = exports.base;
|
|
function c(node, st, override) {
|
|
var type = override || node.type, found = visitors[type];
|
|
base[type](node, st, c);
|
|
if (found) found(node, st);
|
|
}
|
|
c(node, state);
|
|
};
|
|
|
|
// A recursive walk is one where your functions override the default
|
|
// walkers. They can modify and replace the state parameter that's
|
|
// threaded through the walk, and can opt how and whether to walk
|
|
// their child nodes (by calling their third argument on these
|
|
// nodes).
|
|
exports.recursive = function(node, state, funcs, base) {
|
|
var visitor = funcs ? exports.make(funcs, base) : base;
|
|
function c(node, st, override) {
|
|
visitor[override || node.type](node, st, c);
|
|
}
|
|
c(node, state);
|
|
};
|
|
|
|
function makeTest(test) {
|
|
if (typeof test == "string")
|
|
return function(type) { return type == test; };
|
|
else if (!test)
|
|
return function() { return true; };
|
|
else
|
|
return test;
|
|
}
|
|
|
|
function Found(node, state) { this.node = node; this.state = state; }
|
|
|
|
// Find a node with a given start, end, and type (all are optional,
|
|
// null can be used as wildcard). Returns a {node, state} object, or
|
|
// undefined when it doesn't find a matching node.
|
|
exports.findNodeAt = function(node, start, end, test, base, state) {
|
|
test = makeTest(test);
|
|
try {
|
|
if (!base) base = exports.base;
|
|
var c = function(node, st, override) {
|
|
var type = override || node.type;
|
|
if ((start == null || node.start <= start) &&
|
|
(end == null || node.end >= end))
|
|
base[type](node, st, c);
|
|
if (test(type, node) &&
|
|
(start == null || node.start == start) &&
|
|
(end == null || node.end == end))
|
|
throw new Found(node, st);
|
|
};
|
|
c(node, state);
|
|
} catch (e) {
|
|
if (e instanceof Found) return e;
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
// Find the innermost node of a given type that contains the given
|
|
// position. Interface similar to findNodeAt.
|
|
exports.findNodeAround = function(node, pos, test, base, state) {
|
|
test = makeTest(test);
|
|
try {
|
|
if (!base) base = exports.base;
|
|
var c = function(node, st, override) {
|
|
var type = override || node.type;
|
|
if (node.start > pos || node.end < pos) return;
|
|
base[type](node, st, c);
|
|
if (test(type, node)) throw new Found(node, st);
|
|
};
|
|
c(node, state);
|
|
} catch (e) {
|
|
if (e instanceof Found) return e;
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
// Find the outermost matching node after a given position.
|
|
exports.findNodeAfter = function(node, pos, test, base, state) {
|
|
test = makeTest(test);
|
|
try {
|
|
if (!base) base = exports.base;
|
|
var c = function(node, st, override) {
|
|
if (node.end < pos) return;
|
|
var type = override || node.type;
|
|
if (node.start >= pos && test(type, node)) throw new Found(node, st);
|
|
base[type](node, st, c);
|
|
};
|
|
c(node, state);
|
|
} catch (e) {
|
|
if (e instanceof Found) return e;
|
|
throw e;
|
|
}
|
|
};
|
|
|
|
// Find the outermost matching node before a given position.
|
|
exports.findNodeBefore = function(node, pos, test, base, state) {
|
|
test = makeTest(test);
|
|
if (!base) base = exports.base;
|
|
var max;
|
|
var c = function(node, st, override) {
|
|
if (node.start > pos) return;
|
|
var type = override || node.type;
|
|
if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
|
|
max = new Found(node, st);
|
|
base[type](node, st, c);
|
|
};
|
|
c(node, state);
|
|
return max;
|
|
};
|
|
|
|
// Used to create a custom walker. Will fill in all missing node
|
|
// type properties with the defaults.
|
|
exports.make = function(funcs, base) {
|
|
if (!base) base = exports.base;
|
|
var visitor = {};
|
|
for (var type in base) visitor[type] = base[type];
|
|
for (var type in funcs) visitor[type] = funcs[type];
|
|
return visitor;
|
|
};
|
|
|
|
function skipThrough(node, st, c) { c(node, st); }
|
|
function ignore(_node, _st, _c) {}
|
|
|
|
// Node walkers.
|
|
|
|
var base = exports.base = {};
|
|
base.Program = base.BlockStatement = function(node, st, c) {
|
|
for (var i = 0; i < node.body.length; ++i)
|
|
c(node.body[i], st, "Statement");
|
|
};
|
|
base.Statement = skipThrough;
|
|
base.EmptyStatement = ignore;
|
|
base.ExpressionStatement = function(node, st, c) {
|
|
c(node.expression, st, "Expression");
|
|
};
|
|
base.IfStatement = function(node, st, c) {
|
|
c(node.test, st, "Expression");
|
|
c(node.consequent, st, "Statement");
|
|
if (node.alternate) c(node.alternate, st, "Statement");
|
|
};
|
|
base.LabeledStatement = function(node, st, c) {
|
|
c(node.body, st, "Statement");
|
|
};
|
|
base.BreakStatement = base.ContinueStatement = ignore;
|
|
base.WithStatement = function(node, st, c) {
|
|
c(node.object, st, "Expression");
|
|
c(node.body, st, "Statement");
|
|
};
|
|
base.SwitchStatement = function(node, st, c) {
|
|
c(node.discriminant, st, "Expression");
|
|
for (var i = 0; i < node.cases.length; ++i) {
|
|
var cs = node.cases[i];
|
|
if (cs.test) c(cs.test, st, "Expression");
|
|
for (var j = 0; j < cs.consequent.length; ++j)
|
|
c(cs.consequent[j], st, "Statement");
|
|
}
|
|
};
|
|
base.ReturnStatement = function(node, st, c) {
|
|
if (node.argument) c(node.argument, st, "Expression");
|
|
};
|
|
base.ThrowStatement = function(node, st, c) {
|
|
c(node.argument, st, "Expression");
|
|
};
|
|
base.TryStatement = function(node, st, c) {
|
|
c(node.block, st, "Statement");
|
|
if (node.handler) c(node.handler.body, st, "ScopeBody");
|
|
if (node.finalizer) c(node.finalizer, st, "Statement");
|
|
};
|
|
base.WhileStatement = function(node, st, c) {
|
|
c(node.test, st, "Expression");
|
|
c(node.body, st, "Statement");
|
|
};
|
|
base.DoWhileStatement = base.WhileStatement;
|
|
base.ForStatement = function(node, st, c) {
|
|
if (node.init) c(node.init, st, "ForInit");
|
|
if (node.test) c(node.test, st, "Expression");
|
|
if (node.update) c(node.update, st, "Expression");
|
|
c(node.body, st, "Statement");
|
|
};
|
|
base.ForInStatement = function(node, st, c) {
|
|
c(node.left, st, "ForInit");
|
|
c(node.right, st, "Expression");
|
|
c(node.body, st, "Statement");
|
|
};
|
|
base.ForInit = function(node, st, c) {
|
|
if (node.type == "VariableDeclaration") c(node, st);
|
|
else c(node, st, "Expression");
|
|
};
|
|
base.DebuggerStatement = ignore;
|
|
|
|
base.FunctionDeclaration = function(node, st, c) {
|
|
c(node, st, "Function");
|
|
};
|
|
base.VariableDeclaration = function(node, st, c) {
|
|
for (var i = 0; i < node.declarations.length; ++i) {
|
|
var decl = node.declarations[i];
|
|
if (decl.init) c(decl.init, st, "Expression");
|
|
}
|
|
};
|
|
|
|
base.Function = function(node, st, c) {
|
|
c(node.body, st, "ScopeBody");
|
|
};
|
|
base.ScopeBody = function(node, st, c) {
|
|
c(node, st, "Statement");
|
|
};
|
|
|
|
base.Expression = skipThrough;
|
|
base.ThisExpression = ignore;
|
|
base.ArrayExpression = function(node, st, c) {
|
|
for (var i = 0; i < node.elements.length; ++i) {
|
|
var elt = node.elements[i];
|
|
if (elt) c(elt, st, "Expression");
|
|
}
|
|
};
|
|
base.ObjectExpression = function(node, st, c) {
|
|
for (var i = 0; i < node.properties.length; ++i)
|
|
c(node.properties[i].value, st, "Expression");
|
|
};
|
|
base.FunctionExpression = base.FunctionDeclaration;
|
|
base.SequenceExpression = function(node, st, c) {
|
|
for (var i = 0; i < node.expressions.length; ++i)
|
|
c(node.expressions[i], st, "Expression");
|
|
};
|
|
base.UnaryExpression = base.UpdateExpression = function(node, st, c) {
|
|
c(node.argument, st, "Expression");
|
|
};
|
|
base.BinaryExpression = base.AssignmentExpression = base.LogicalExpression = function(node, st, c) {
|
|
c(node.left, st, "Expression");
|
|
c(node.right, st, "Expression");
|
|
};
|
|
base.ConditionalExpression = function(node, st, c) {
|
|
c(node.test, st, "Expression");
|
|
c(node.consequent, st, "Expression");
|
|
c(node.alternate, st, "Expression");
|
|
};
|
|
base.NewExpression = base.CallExpression = function(node, st, c) {
|
|
c(node.callee, st, "Expression");
|
|
if (node.arguments) for (var i = 0; i < node.arguments.length; ++i)
|
|
c(node.arguments[i], st, "Expression");
|
|
};
|
|
base.MemberExpression = function(node, st, c) {
|
|
c(node.object, st, "Expression");
|
|
if (node.computed) c(node.property, st, "Expression");
|
|
};
|
|
base.Identifier = base.Literal = ignore;
|
|
|
|
// A custom walker that keeps track of the scope chain and the
|
|
// variables defined in it.
|
|
function makeScope(prev, isCatch) {
|
|
return {vars: Object.create(null), prev: prev, isCatch: isCatch};
|
|
}
|
|
function normalScope(scope) {
|
|
while (scope.isCatch) scope = scope.prev;
|
|
return scope;
|
|
}
|
|
exports.scopeVisitor = exports.make({
|
|
Function: function(node, scope, c) {
|
|
var inner = makeScope(scope);
|
|
for (var i = 0; i < node.params.length; ++i)
|
|
inner.vars[node.params[i].name] = {type: "argument", node: node.params[i]};
|
|
if (node.id) {
|
|
var decl = node.type == "FunctionDeclaration";
|
|
(decl ? normalScope(scope) : inner).vars[node.id.name] =
|
|
{type: decl ? "function" : "function name", node: node.id};
|
|
}
|
|
c(node.body, inner, "ScopeBody");
|
|
},
|
|
TryStatement: function(node, scope, c) {
|
|
c(node.block, scope, "Statement");
|
|
if (node.handler) {
|
|
var inner = makeScope(scope, true);
|
|
inner.vars[node.handler.param.name] = {type: "catch clause", node: node.handler.param};
|
|
c(node.handler.body, inner, "ScopeBody");
|
|
}
|
|
if (node.finalizer) c(node.finalizer, scope, "Statement");
|
|
},
|
|
VariableDeclaration: function(node, scope, c) {
|
|
var target = normalScope(scope);
|
|
for (var i = 0; i < node.declarations.length; ++i) {
|
|
var decl = node.declarations[i];
|
|
target.vars[decl.id.name] = {type: "var", node: decl.id};
|
|
if (decl.init) c(decl.init, scope, "Expression");
|
|
}
|
|
}
|
|
});
|
|
|
|
});
|