mirror of
https://github.com/Jermolene/TiddlyWiki5
synced 2024-11-19 08:14:50 +00:00
f6338d9109
It preserves comments and text positions, enabling us to do syntax highlighting. Hopefully.
732 lines
24 KiB
JavaScript
732 lines
24 KiB
JavaScript
/* vim: set sw=4 ts=4 et tw=78: */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is the Narcissus JavaScript engine.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Brendan Eich <brendan@mozilla.org>.
|
|
* Portions created by the Initial Developer are Copyright (C) 2004
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Tom Austin <taustin@ucsc.edu>
|
|
* Brendan Eich <brendan@mozilla.org>
|
|
* Shu-Yu Guo <shu@rfrn.org>
|
|
* Dave Herman <dherman@mozilla.com>
|
|
* Dimitris Vardoulakis <dimvar@ccs.neu.edu>
|
|
* Patrick Walton <pcwalton@mozilla.com>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
/*
|
|
* Narcissus - JS implemented in JS.
|
|
*
|
|
* Well-known constants and lookup tables. Many consts are generated from the
|
|
* tokens table via eval to minimize redundancy, so consumers must be compiled
|
|
* separately to take advantage of the simple switch-case constant propagation
|
|
* done by SpiderMonkey.
|
|
*/
|
|
|
|
(function() {
|
|
|
|
var narcissus = {
|
|
options: {
|
|
version: 185,
|
|
// Global variables to hide from the interpreter
|
|
hiddenHostGlobals: { Narcissus: true },
|
|
// Desugar SpiderMonkey language extensions?
|
|
desugarExtensions: false,
|
|
// Allow HTML comments?
|
|
allowHTMLComments: false
|
|
},
|
|
hostSupportsEvalConst: (function() {
|
|
try {
|
|
return eval("(function(s) { eval(s); return x })('const x = true;')");
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
})(),
|
|
hostGlobal: this
|
|
};
|
|
Narcissus = narcissus;
|
|
})();
|
|
|
|
Narcissus.definitions = (function() {
|
|
|
|
var tokens = [
|
|
// End of source.
|
|
"END",
|
|
|
|
// Operators and punctuators. Some pair-wise order matters, e.g. (+, -)
|
|
// and (UNARY_PLUS, UNARY_MINUS).
|
|
"\n", ";",
|
|
",",
|
|
"=",
|
|
"?", ":", "CONDITIONAL",
|
|
"||",
|
|
"&&",
|
|
"|",
|
|
"^",
|
|
"&",
|
|
"==", "!=", "===", "!==",
|
|
"<", "<=", ">=", ">",
|
|
"<<", ">>", ">>>",
|
|
"+", "-",
|
|
"*", "/", "%",
|
|
"!", "~", "UNARY_PLUS", "UNARY_MINUS",
|
|
"++", "--",
|
|
".",
|
|
"[", "]",
|
|
"{", "}",
|
|
"(", ")",
|
|
|
|
// Nonterminal tree node type codes.
|
|
"SCRIPT", "BLOCK", "LABEL", "FOR_IN", "CALL", "NEW_WITH_ARGS", "INDEX",
|
|
"ARRAY_INIT", "OBJECT_INIT", "PROPERTY_INIT", "GETTER", "SETTER",
|
|
"GROUP", "LIST", "LET_BLOCK", "ARRAY_COMP", "GENERATOR", "COMP_TAIL",
|
|
|
|
// Terminals.
|
|
"IDENTIFIER", "NUMBER", "STRING", "REGEXP",
|
|
|
|
// Keywords.
|
|
"break",
|
|
"case", "catch", "const", "continue",
|
|
"debugger", "default", "delete", "do",
|
|
"else", "export",
|
|
"false", "finally", "for", "function",
|
|
"if", "import", "in", "instanceof",
|
|
"let", "module",
|
|
"new", "null",
|
|
"return",
|
|
"switch",
|
|
"this", "throw", "true", "try", "typeof",
|
|
"var", "void",
|
|
"yield",
|
|
"while", "with",
|
|
];
|
|
|
|
var statementStartTokens = [
|
|
"break",
|
|
"const", "continue",
|
|
"debugger", "do",
|
|
"for",
|
|
"if",
|
|
"return",
|
|
"switch",
|
|
"throw", "try",
|
|
"var",
|
|
"yield",
|
|
"while", "with",
|
|
];
|
|
|
|
// Whitespace characters (see ECMA-262 7.2)
|
|
var whitespaceChars = [
|
|
// normal whitespace:
|
|
"\u0009", "\u000B", "\u000C", "\u0020", "\u00A0", "\uFEFF",
|
|
|
|
// high-Unicode whitespace:
|
|
"\u1680", "\u180E",
|
|
"\u2000", "\u2001", "\u2002", "\u2003", "\u2004", "\u2005", "\u2006",
|
|
"\u2007", "\u2008", "\u2009", "\u200A",
|
|
"\u202F", "\u205F", "\u3000"
|
|
];
|
|
|
|
var whitespace = {};
|
|
for (var i = 0; i < whitespaceChars.length; i++) {
|
|
whitespace[whitespaceChars[i]] = true;
|
|
}
|
|
|
|
// Operator and punctuator mapping from token to tree node type name.
|
|
// NB: because the lexer doesn't backtrack, all token prefixes must themselves
|
|
// be valid tokens (e.g. !== is acceptable because its prefixes are the valid
|
|
// tokens != and !).
|
|
var opTypeNames = {
|
|
'\n': "NEWLINE",
|
|
';': "SEMICOLON",
|
|
',': "COMMA",
|
|
'?': "HOOK",
|
|
':': "COLON",
|
|
'||': "OR",
|
|
'&&': "AND",
|
|
'|': "BITWISE_OR",
|
|
'^': "BITWISE_XOR",
|
|
'&': "BITWISE_AND",
|
|
'===': "STRICT_EQ",
|
|
'==': "EQ",
|
|
'=': "ASSIGN",
|
|
'!==': "STRICT_NE",
|
|
'!=': "NE",
|
|
'<<': "LSH",
|
|
'<=': "LE",
|
|
'<': "LT",
|
|
'>>>': "URSH",
|
|
'>>': "RSH",
|
|
'>=': "GE",
|
|
'>': "GT",
|
|
'++': "INCREMENT",
|
|
'--': "DECREMENT",
|
|
'+': "PLUS",
|
|
'-': "MINUS",
|
|
'*': "MUL",
|
|
'/': "DIV",
|
|
'%': "MOD",
|
|
'!': "NOT",
|
|
'~': "BITWISE_NOT",
|
|
'.': "DOT",
|
|
'[': "LEFT_BRACKET",
|
|
']': "RIGHT_BRACKET",
|
|
'{': "LEFT_CURLY",
|
|
'}': "RIGHT_CURLY",
|
|
'(': "LEFT_PAREN",
|
|
')': "RIGHT_PAREN"
|
|
};
|
|
|
|
// Hash of keyword identifier to tokens index. NB: we must null __proto__ to
|
|
// avoid toString, etc. namespace pollution.
|
|
var keywords = {__proto__: null};
|
|
|
|
// Define const END, etc., based on the token names. Also map name to index.
|
|
var tokenIds = {};
|
|
|
|
// Building up a string to be eval'd in different contexts.
|
|
var consts = Narcissus.hostSupportsEvalConst ? "const " : "var ";
|
|
for (var i = 0, j = tokens.length; i < j; i++) {
|
|
if (i > 0)
|
|
consts += ", ";
|
|
var t = tokens[i];
|
|
var name;
|
|
if (/^[a-z]/.test(t)) {
|
|
name = t.toUpperCase();
|
|
keywords[t] = i;
|
|
} else {
|
|
name = (/^\W/.test(t) ? opTypeNames[t] : t);
|
|
}
|
|
consts += name + " = " + i;
|
|
tokenIds[name] = i;
|
|
tokens[t] = i;
|
|
}
|
|
consts += ";";
|
|
|
|
var isStatementStartCode = {__proto__: null};
|
|
for (i = 0, j = statementStartTokens.length; i < j; i++)
|
|
isStatementStartCode[keywords[statementStartTokens[i]]] = true;
|
|
|
|
// Map assignment operators to their indexes in the tokens array.
|
|
var assignOps = ['|', '^', '&', '<<', '>>', '>>>', '+', '-', '*', '/', '%'];
|
|
|
|
for (i = 0, j = assignOps.length; i < j; i++) {
|
|
t = assignOps[i];
|
|
assignOps[t] = tokens[t];
|
|
}
|
|
|
|
function defineGetter(obj, prop, fn, dontDelete, dontEnum) {
|
|
Object.defineProperty(obj, prop,
|
|
{ get: fn, configurable: !dontDelete, enumerable: !dontEnum });
|
|
}
|
|
|
|
function defineGetterSetter(obj, prop, getter, setter, dontDelete, dontEnum) {
|
|
Object.defineProperty(obj, prop, {
|
|
get: getter,
|
|
set: setter,
|
|
configurable: !dontDelete,
|
|
enumerable: !dontEnum
|
|
});
|
|
}
|
|
|
|
function defineMemoGetter(obj, prop, fn, dontDelete, dontEnum) {
|
|
Object.defineProperty(obj, prop, {
|
|
get: function() {
|
|
var val = fn();
|
|
defineProperty(obj, prop, val, dontDelete, true, dontEnum);
|
|
return val;
|
|
},
|
|
configurable: true,
|
|
enumerable: !dontEnum
|
|
});
|
|
}
|
|
|
|
function defineProperty(obj, prop, val, dontDelete, readOnly, dontEnum) {
|
|
Object.defineProperty(obj, prop,
|
|
{ value: val, writable: !readOnly, configurable: !dontDelete,
|
|
enumerable: !dontEnum });
|
|
}
|
|
|
|
// Returns true if fn is a native function. (Note: SpiderMonkey specific.)
|
|
function isNativeCode(fn) {
|
|
// Relies on the toString method to identify native code.
|
|
return ((typeof fn) === "function") && fn.toString().match(/\[native code\]/);
|
|
}
|
|
|
|
var Fpapply = Function.prototype.apply;
|
|
|
|
function apply(f, o, a) {
|
|
return Fpapply.call(f, [o].concat(a));
|
|
}
|
|
|
|
var applyNew;
|
|
|
|
// ES5's bind is a simpler way to implement applyNew
|
|
if (Function.prototype.bind) {
|
|
applyNew = function applyNew(f, a) {
|
|
return new (f.bind.apply(f, [,].concat(a)))();
|
|
};
|
|
} else {
|
|
applyNew = function applyNew(f, a) {
|
|
switch (a.length) {
|
|
case 0:
|
|
return new f();
|
|
case 1:
|
|
return new f(a[0]);
|
|
case 2:
|
|
return new f(a[0], a[1]);
|
|
case 3:
|
|
return new f(a[0], a[1], a[2]);
|
|
default:
|
|
var argStr = "a[0]";
|
|
for (var i = 1, n = a.length; i < n; i++)
|
|
argStr += ",a[" + i + "]";
|
|
return eval("new f(" + argStr + ")");
|
|
}
|
|
};
|
|
}
|
|
|
|
function getPropertyDescriptor(obj, name) {
|
|
while (obj) {
|
|
if (({}).hasOwnProperty.call(obj, name))
|
|
return Object.getOwnPropertyDescriptor(obj, name);
|
|
obj = Object.getPrototypeOf(obj);
|
|
}
|
|
}
|
|
|
|
function getPropertyNames(obj) {
|
|
var table = Object.create(null, {});
|
|
while (obj) {
|
|
var names = Object.getOwnPropertyNames(obj);
|
|
for (var i = 0, n = names.length; i < n; i++)
|
|
table[names[i]] = true;
|
|
obj = Object.getPrototypeOf(obj);
|
|
}
|
|
return Object.keys(table);
|
|
}
|
|
|
|
function getOwnProperties(obj) {
|
|
var map = {};
|
|
for (var name in Object.getOwnPropertyNames(obj))
|
|
map[name] = Object.getOwnPropertyDescriptor(obj, name);
|
|
return map;
|
|
}
|
|
|
|
function blacklistHandler(target, blacklist) {
|
|
var mask = Object.create(null, {});
|
|
var redirect = StringMap.create(blacklist).mapObject(function(name) { return mask; });
|
|
return mixinHandler(redirect, target);
|
|
}
|
|
|
|
function whitelistHandler(target, whitelist) {
|
|
var catchall = Object.create(null, {});
|
|
var redirect = StringMap.create(whitelist).mapObject(function(name) { return target; });
|
|
return mixinHandler(redirect, catchall);
|
|
}
|
|
|
|
function mirrorHandler(target, writable) {
|
|
var handler = makePassthruHandler(target);
|
|
|
|
var defineProperty = handler.defineProperty;
|
|
handler.defineProperty = function(name, desc) {
|
|
if (!desc.enumerable)
|
|
throw new Error("mirror property must be enumerable");
|
|
if (!desc.configurable)
|
|
throw new Error("mirror property must be configurable");
|
|
if (desc.writable !== writable)
|
|
throw new Error("mirror property must " + (writable ? "" : "not ") + "be writable");
|
|
defineProperty(name, desc);
|
|
};
|
|
|
|
handler.fix = function() { };
|
|
handler.getOwnPropertyDescriptor = handler.getPropertyDescriptor;
|
|
handler.getOwnPropertyNames = getPropertyNames.bind(handler, target);
|
|
handler.keys = handler.enumerate;
|
|
handler["delete"] = function() { return false; };
|
|
handler.hasOwn = handler.has;
|
|
return handler;
|
|
}
|
|
|
|
/*
|
|
* Mixin proxies break the single-inheritance model of prototypes, so
|
|
* the handler treats all properties as own-properties:
|
|
*
|
|
* X
|
|
* |
|
|
* +------------+------------+
|
|
* | O |
|
|
* | | |
|
|
* | O O O |
|
|
* | | | | |
|
|
* | O O O O |
|
|
* | | | | | |
|
|
* | O O O O O |
|
|
* | | | | | | |
|
|
* +-(*)--(w)--(x)--(y)--(z)-+
|
|
*/
|
|
|
|
function mixinHandler(redirect, catchall) {
|
|
function targetFor(name) {
|
|
return hasOwn(redirect, name) ? redirect[name] : catchall;
|
|
}
|
|
|
|
function getMuxPropertyDescriptor(name) {
|
|
var desc = getPropertyDescriptor(targetFor(name), name);
|
|
if (desc)
|
|
desc.configurable = true;
|
|
return desc;
|
|
}
|
|
|
|
function getMuxPropertyNames() {
|
|
var names1 = Object.getOwnPropertyNames(redirect).filter(function(name) {
|
|
return name in redirect[name];
|
|
});
|
|
var names2 = getPropertyNames(catchall).filter(function(name) {
|
|
return !hasOwn(redirect, name);
|
|
});
|
|
return names1.concat(names2);
|
|
}
|
|
|
|
function enumerateMux() {
|
|
var result = Object.getOwnPropertyNames(redirect).filter(function(name) {
|
|
return name in redirect[name];
|
|
});
|
|
for (name in catchall) {
|
|
if (!hasOwn(redirect, name))
|
|
result.push(name);
|
|
};
|
|
return result;
|
|
}
|
|
|
|
function hasMux(name) {
|
|
return name in targetFor(name);
|
|
}
|
|
|
|
return {
|
|
getOwnPropertyDescriptor: getMuxPropertyDescriptor,
|
|
getPropertyDescriptor: getMuxPropertyDescriptor,
|
|
getOwnPropertyNames: getMuxPropertyNames,
|
|
defineProperty: function(name, desc) {
|
|
Object.defineProperty(targetFor(name), name, desc);
|
|
},
|
|
"delete": function(name) {
|
|
var target = targetFor(name);
|
|
return delete target[name];
|
|
},
|
|
// FIXME: ha ha ha
|
|
fix: function() { },
|
|
has: hasMux,
|
|
hasOwn: hasMux,
|
|
get: function(receiver, name) {
|
|
var target = targetFor(name);
|
|
return target[name];
|
|
},
|
|
set: function(receiver, name, val) {
|
|
var target = targetFor(name);
|
|
target[name] = val;
|
|
return true;
|
|
},
|
|
enumerate: enumerateMux,
|
|
keys: enumerateMux
|
|
};
|
|
}
|
|
|
|
function makePassthruHandler(obj) {
|
|
// Handler copied from
|
|
// http://wiki.ecmascript.org/doku.php?id=harmony:proxies&s=proxy%20object#examplea_no-op_forwarding_proxy
|
|
return {
|
|
getOwnPropertyDescriptor: function(name) {
|
|
var desc = Object.getOwnPropertyDescriptor(obj, name);
|
|
|
|
// a trapping proxy's properties must always be configurable
|
|
desc.configurable = true;
|
|
return desc;
|
|
},
|
|
getPropertyDescriptor: function(name) {
|
|
var desc = getPropertyDescriptor(obj, name);
|
|
|
|
// a trapping proxy's properties must always be configurable
|
|
desc.configurable = true;
|
|
return desc;
|
|
},
|
|
getOwnPropertyNames: function() {
|
|
return Object.getOwnPropertyNames(obj);
|
|
},
|
|
defineProperty: function(name, desc) {
|
|
Object.defineProperty(obj, name, desc);
|
|
},
|
|
"delete": function(name) { return delete obj[name]; },
|
|
fix: function() {
|
|
if (Object.isFrozen(obj)) {
|
|
return getOwnProperties(obj);
|
|
}
|
|
|
|
// As long as obj is not frozen, the proxy won't allow itself to be fixed.
|
|
return undefined; // will cause a TypeError to be thrown
|
|
},
|
|
|
|
has: function(name) { return name in obj; },
|
|
hasOwn: function(name) { return ({}).hasOwnProperty.call(obj, name); },
|
|
get: function(receiver, name) { return obj[name]; },
|
|
|
|
// bad behavior when set fails in non-strict mode
|
|
set: function(receiver, name, val) { obj[name] = val; return true; },
|
|
enumerate: function() {
|
|
var result = [];
|
|
for (name in obj) { result.push(name); };
|
|
return result;
|
|
},
|
|
keys: function() { return Object.keys(obj); }
|
|
};
|
|
}
|
|
|
|
var hasOwnProperty = ({}).hasOwnProperty;
|
|
|
|
function hasOwn(obj, name) {
|
|
return hasOwnProperty.call(obj, name);
|
|
}
|
|
|
|
function StringMap(table, size) {
|
|
this.table = table || Object.create(null, {});
|
|
this.size = size || 0;
|
|
}
|
|
|
|
StringMap.create = function(table) {
|
|
var init = Object.create(null, {});
|
|
var size = 0;
|
|
var names = Object.getOwnPropertyNames(table);
|
|
for (var i = 0, n = names.length; i < n; i++) {
|
|
var name = names[i];
|
|
init[name] = table[name];
|
|
size++;
|
|
}
|
|
return new StringMap(init, size);
|
|
};
|
|
|
|
StringMap.prototype = {
|
|
has: function(x) { return hasOwnProperty.call(this.table, x); },
|
|
set: function(x, v) {
|
|
if (!hasOwnProperty.call(this.table, x))
|
|
this.size++;
|
|
this.table[x] = v;
|
|
},
|
|
get: function(x) { return this.table[x]; },
|
|
getDef: function(x, thunk) {
|
|
if (!hasOwnProperty.call(this.table, x)) {
|
|
this.size++;
|
|
this.table[x] = thunk();
|
|
}
|
|
return this.table[x];
|
|
},
|
|
forEach: function(f) {
|
|
var table = this.table;
|
|
for (var key in table)
|
|
f.call(this, key, table[key]);
|
|
},
|
|
map: function(f) {
|
|
var table1 = this.table;
|
|
var table2 = Object.create(null, {});
|
|
this.forEach(function(key, val) {
|
|
table2[key] = f.call(this, val, key);
|
|
});
|
|
return new StringMap(table2, this.size);
|
|
},
|
|
mapObject: function(f) {
|
|
var table1 = this.table;
|
|
var table2 = Object.create(null, {});
|
|
this.forEach(function(key, val) {
|
|
table2[key] = f.call(this, val, key);
|
|
});
|
|
return table2;
|
|
},
|
|
toObject: function() {
|
|
return this.mapObject(function(val) { return val; });
|
|
},
|
|
choose: function() {
|
|
return Object.getOwnPropertyNames(this.table)[0];
|
|
},
|
|
remove: function(x) {
|
|
if (hasOwnProperty.call(this.table, x)) {
|
|
this.size--;
|
|
delete this.table[x];
|
|
}
|
|
},
|
|
copy: function() {
|
|
var table = Object.create(null, {});
|
|
for (var key in this.table)
|
|
table[key] = this.table[key];
|
|
return new StringMap(table, this.size);
|
|
},
|
|
keys: function() {
|
|
return Object.keys(this.table);
|
|
},
|
|
toString: function() { return "[object StringMap]" }
|
|
};
|
|
|
|
// an object-key table with poor asymptotics (replace with WeakMap when possible)
|
|
function ObjectMap(array) {
|
|
this.array = array || [];
|
|
}
|
|
|
|
function searchMap(map, key, found, notFound) {
|
|
var a = map.array;
|
|
for (var i = 0, n = a.length; i < n; i++) {
|
|
var pair = a[i];
|
|
if (pair.key === key)
|
|
return found(pair, i);
|
|
}
|
|
return notFound();
|
|
}
|
|
|
|
ObjectMap.prototype = {
|
|
has: function(x) {
|
|
return searchMap(this, x, function() { return true }, function() { return false });
|
|
},
|
|
set: function(x, v) {
|
|
var a = this.array;
|
|
searchMap(this, x,
|
|
function(pair) { pair.value = v },
|
|
function() { a.push({ key: x, value: v }) });
|
|
},
|
|
get: function(x) {
|
|
return searchMap(this, x,
|
|
function(pair) { return pair.value },
|
|
function() { return null });
|
|
},
|
|
getDef: function(x, thunk) {
|
|
var a = this.array;
|
|
return searchMap(this, x,
|
|
function(pair) { return pair.value },
|
|
function() {
|
|
var v = thunk();
|
|
a.push({ key: x, value: v });
|
|
return v;
|
|
});
|
|
},
|
|
forEach: function(f) {
|
|
var a = this.array;
|
|
for (var i = 0, n = a.length; i < n; i++) {
|
|
var pair = a[i];
|
|
f.call(this, pair.key, pair.value);
|
|
}
|
|
},
|
|
choose: function() {
|
|
return this.array[0].key;
|
|
},
|
|
get size() {
|
|
return this.array.length;
|
|
},
|
|
remove: function(x) {
|
|
var a = this.array;
|
|
searchMap(this, x,
|
|
function(pair, i) { a.splice(i, 1) },
|
|
function() { });
|
|
},
|
|
copy: function() {
|
|
return new ObjectMap(this.array.map(function(pair) {
|
|
return { key: pair.key, value: pair.value }
|
|
}));
|
|
},
|
|
clear: function() {
|
|
this.array = [];
|
|
},
|
|
toString: function() { return "[object ObjectMap]" }
|
|
};
|
|
|
|
// non-destructive stack
|
|
function Stack(elts) {
|
|
this.elts = elts || null;
|
|
}
|
|
|
|
Stack.prototype = {
|
|
push: function(x) {
|
|
return new Stack({ top: x, rest: this.elts });
|
|
},
|
|
top: function() {
|
|
if (!this.elts)
|
|
throw new Error("empty stack");
|
|
return this.elts.top;
|
|
},
|
|
isEmpty: function() {
|
|
return this.top === null;
|
|
},
|
|
find: function(test) {
|
|
for (var elts = this.elts; elts; elts = elts.rest) {
|
|
if (test(elts.top))
|
|
return elts.top;
|
|
}
|
|
return null;
|
|
},
|
|
has: function(x) {
|
|
return Boolean(this.find(function(elt) { return elt === x }));
|
|
},
|
|
forEach: function(f) {
|
|
for (var elts = this.elts; elts; elts = elts.rest) {
|
|
f(elts.top);
|
|
}
|
|
}
|
|
};
|
|
|
|
if (!Array.prototype.copy) {
|
|
Array.prototype.copy = function() {
|
|
var result = [];
|
|
for (var i = 0, n = this.length; i < n; i++)
|
|
result[i] = this[i];
|
|
return result;
|
|
};
|
|
}
|
|
|
|
return {
|
|
tokens: tokens,
|
|
whitespace: whitespace,
|
|
opTypeNames: opTypeNames,
|
|
keywords: keywords,
|
|
isStatementStartCode: isStatementStartCode,
|
|
tokenIds: tokenIds,
|
|
consts: consts,
|
|
assignOps: assignOps,
|
|
defineGetter: defineGetter,
|
|
defineGetterSetter: defineGetterSetter,
|
|
defineMemoGetter: defineMemoGetter,
|
|
defineProperty: defineProperty,
|
|
isNativeCode: isNativeCode,
|
|
apply: apply,
|
|
applyNew: applyNew,
|
|
mirrorHandler: mirrorHandler,
|
|
mixinHandler: mixinHandler,
|
|
whitelistHandler: whitelistHandler,
|
|
blacklistHandler: blacklistHandler,
|
|
makePassthruHandler: makePassthruHandler,
|
|
StringMap: StringMap,
|
|
ObjectMap: ObjectMap,
|
|
Stack: Stack
|
|
};
|
|
}());
|