mirror of
https://github.com/samsonjs/elisp.js.git
synced 2026-03-25 09:15:49 +00:00
536 lines
12 KiB
JavaScript
536 lines
12 KiB
JavaScript
var EL = function(){};
|
|
// rhino doesn't like a C-style comment as its first input, strange
|
|
|
|
/*
|
|
* Emacs Lisp implementation in JavaScript.
|
|
*
|
|
* Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
|
|
/*************************
|
|
** Globals & Constants **
|
|
*************************/
|
|
|
|
/* EL.nil is implicitly undefined */
|
|
EL.t = true;
|
|
|
|
|
|
/************
|
|
** Parser **
|
|
************/
|
|
|
|
EL.parse = function(input) {
|
|
var parser = new EL.Parser(input);
|
|
parser.parse();
|
|
};
|
|
|
|
EL.Parser = function(data) {
|
|
this.data = data;
|
|
};
|
|
|
|
EL.Parser.Error = function(name, message) {
|
|
this.parserError = true;
|
|
this.name = name;
|
|
this.message = message;
|
|
};
|
|
|
|
EL.Parser.Error.messages = {
|
|
'eof': "no more input"
|
|
};
|
|
|
|
EL.Parser.prototype.error = function(name) {
|
|
throw(new EL.Parser.Error(name, EL.Parser.Error.messages[name]));
|
|
};
|
|
|
|
EL.Parser.prototype.peek = function() {
|
|
return this.data[this.pos];
|
|
};
|
|
|
|
EL.Parser.prototype.consumeChar = function() {
|
|
if (this.pos >= this.data.length) this.error('eof');
|
|
return this.data[this.pos++];
|
|
};
|
|
|
|
EL.Parser.prototype.consumeWhitespace = function() {
|
|
var c;
|
|
while ((c = this.peek()) && c.match(/[\s\n]/)) {
|
|
this.consumeChar();
|
|
}
|
|
};
|
|
|
|
EL.Parser.prototype.rest = function() {
|
|
return this.data.substring(this.pos, this.data.length);
|
|
};
|
|
|
|
EL.Parser.prototype.moreInput = function() {
|
|
return (this.pos < this.data.length);
|
|
};
|
|
|
|
EL.Parser.prototype.parse = function() {
|
|
this.pos = 0;
|
|
var exprs = [];
|
|
while (this.moreInput()) {
|
|
try {
|
|
exprs.push(this.parseExpression());
|
|
} catch (e) {
|
|
if (e.parserError && e.name == 'eof') {
|
|
print("error: " + e.message);
|
|
break;
|
|
}
|
|
else {
|
|
throw(e);
|
|
}
|
|
}
|
|
}
|
|
this.expressions = exprs;
|
|
print('');
|
|
EL.pp(exprs);
|
|
print('');
|
|
return exprs;
|
|
};
|
|
|
|
EL.Parser.prototype.parseUntil = function(regex, initial, next, consumeTerminator) {
|
|
var c,
|
|
token = initial,
|
|
condition = function(c){ return c.match(regex) == null; };
|
|
while ((c = this.peek()) && condition(c)) {
|
|
token = next(token, this.consumeChar());
|
|
}
|
|
if (consumeTerminator && this.peek()) this.consumeChar();
|
|
return token;
|
|
};
|
|
|
|
EL.Parser.prototype.parseList = function() {
|
|
var list = [],
|
|
expr;
|
|
// consume initial paren '('
|
|
this.consumeChar();
|
|
while ((expr = this.parseExpression()) && expr != ')') {
|
|
list.push(expr);
|
|
}
|
|
return list;
|
|
};
|
|
|
|
EL.Parser.prototype.parseCons = function() {
|
|
var cons = [],
|
|
expr;
|
|
// consume initial paren '('
|
|
this.consumeChar();
|
|
cons.push(this.parseExpression());
|
|
// ignore .
|
|
this.parseExpression();
|
|
cons.push(this.parseExpression());
|
|
return cons;
|
|
};
|
|
|
|
EL.Parser.prototype.parseString = function() {
|
|
// consume initial quotation mark
|
|
this.consumeChar();
|
|
var self = this;
|
|
return this.parseUntil(/"/, '', function(s,c){
|
|
if (c == '\\') {
|
|
c = self.consumeChar();
|
|
}
|
|
return s + c;
|
|
}, true /* consume terminator */);
|
|
};
|
|
|
|
EL.Parser.prototype.parseSymbol = function() {
|
|
var symbol = this.parseUntil(/[\s()]/, '', function(t,c){return t + c;});
|
|
return symbol;
|
|
};
|
|
|
|
// Only integers
|
|
EL.Parser.prototype.parseNumber = function() {
|
|
return this.parseUntil(/[^\d]/, 0, function(n,c){return n*10 + parseInt(c);});
|
|
var c,
|
|
num = 0;
|
|
while ((c = this.peek()) && c.match(/\d/)) {
|
|
num *= 10;
|
|
num += parseInt(this.consumeChar());
|
|
}
|
|
return num;
|
|
};
|
|
|
|
EL.Parser.prototype.lookingAtNumber = function() {
|
|
var pos = this.pos,
|
|
rest = this.rest(),
|
|
match = rest.match(/^\d+\b/) || rest.match(/^\d+$/);
|
|
return (match != null);
|
|
};
|
|
|
|
EL.Parser.prototype.lookingAtCons = function() {
|
|
this.fake = true;
|
|
var orig_pos = this.pos,
|
|
_ = this.consumeChar(),
|
|
_ = this.parseExpression(),
|
|
cdr = this.parseExpression();
|
|
this.pos = orig_pos; // rewind, like it never happened.
|
|
this.fake = false;
|
|
return cdr != null && cdr[0] == 'symbol' && cdr[1] == '.';
|
|
};
|
|
|
|
EL.Parser.prototype.parseExpression = function() {
|
|
var value,
|
|
c = this.peek();
|
|
if (c == '(' && this.lookingAtCons()) {
|
|
// print("CONS(");
|
|
value = ['cons', this.parseCons()];
|
|
}
|
|
else if (c == '(') {
|
|
// print("LIST(");
|
|
var list = this.parseList();
|
|
value = (list.length > 0) ? ['list', list] : ['symbol', 'nil'];
|
|
}
|
|
else if (c == ')') {
|
|
// print(">>> ) <<<");
|
|
return this.consumeChar();
|
|
}
|
|
else if (c == "'") {
|
|
// print("QUOTE");
|
|
this.consumeChar();
|
|
value = ['list', [['symbol', 'quote']]];
|
|
value[1].push(this.parseExpression());
|
|
}
|
|
else if (c == '"') {
|
|
// print("STRING");
|
|
value = ['string', this.parseString()];
|
|
}
|
|
else if (this.lookingAtNumber()) {
|
|
// print("NUMBER");
|
|
value = ['number', this.parseNumber()];
|
|
}
|
|
else if (c) {
|
|
// print("SYMBOL");
|
|
value = ['symbol', this.parseSymbol()];
|
|
}
|
|
this.consumeWhitespace();
|
|
return value;
|
|
};
|
|
|
|
EL.VarTable = function() {
|
|
this.t = {value: EL.t, docstring: "true"};
|
|
this.nil = {value: null, docstring: "nil"};
|
|
};
|
|
|
|
EL.FuncTable = function() {
|
|
this['+'] = {
|
|
params: ['a', 'b'],
|
|
body: function(a,b) { return ['number', a + b]; },
|
|
docstring: "add two numbers"
|
|
};
|
|
this['-'] = {
|
|
params: ['a', 'b'],
|
|
body: function(a,b) { return ['number', a - b]; },
|
|
docstring: "subtract two numbers"
|
|
};
|
|
this['*'] = {
|
|
params: ['a', 'b'],
|
|
body: function(a,b) { return ['number', a * b]; },
|
|
docstring: "multiply two numbers"
|
|
};
|
|
this['/'] = {
|
|
params: ['a', 'b'],
|
|
body: function(a,b) { return ['number', a / b]; },
|
|
docstring: "divide two numbers"
|
|
};
|
|
this['print'] = {
|
|
params: ['x'],
|
|
body: function(x) { print(x); return ['symbol', 'nil']; },
|
|
docstring: "print an expression"
|
|
};
|
|
};
|
|
|
|
|
|
/****************
|
|
** Evaluation **
|
|
****************/
|
|
|
|
EL.Evaluator = function(exprs) {
|
|
this.expressions = exprs;
|
|
this.variables = new EL.VarTable();
|
|
this.functions = new EL.FuncTable();
|
|
};
|
|
|
|
EL.Evaluator.Error = function(name, message, expr) {
|
|
this.evalError = true;
|
|
this.name = name;
|
|
this.message = message;
|
|
this.expression = expr;
|
|
};
|
|
|
|
EL.Evaluator.Error.messages = {
|
|
'not-expr': "not an expression",
|
|
'undefined-func': "undefined function",
|
|
'undefined-var': "variable not defined"
|
|
};
|
|
|
|
EL.Evaluator.prototype.error = function(name, expr) {
|
|
throw(new EL.Evaluator.Error(name, EL.Evaluator.Error.messages[name], expr));
|
|
};
|
|
|
|
EL.Evaluator.prototype.evalExpressions = function() {
|
|
var exprs = this.expressions,
|
|
i = 0,
|
|
n = exprs.length,
|
|
result;
|
|
while (i < n) {
|
|
try {
|
|
result = this.eval(exprs[i++]);
|
|
} catch (e) {
|
|
if (e.evalError) {
|
|
print('[error] ' + e.message);
|
|
if (e.expr) {
|
|
print('expr: ' + e.expr);
|
|
}
|
|
result = null;
|
|
break;
|
|
}
|
|
else {
|
|
throw(e);
|
|
}
|
|
}
|
|
}
|
|
EL.pp(result);
|
|
return result;
|
|
};
|
|
|
|
EL.Evaluator.prototype.lookupVar = function(symbol) {
|
|
return this.variables[symbol];
|
|
};
|
|
|
|
EL.Evaluator.prototype.lookupFunc = function(symbol) {
|
|
return this.functions[symbol];
|
|
};
|
|
|
|
EL.Evaluator.prototype.defineVar = function(symbol, value, docstring) {
|
|
this.variables[symbol] = {
|
|
type: 'variable',
|
|
value: value,
|
|
docstring: docstring || "(undocumented)"
|
|
};
|
|
};
|
|
|
|
EL.Evaluator.prototype.defineFunc = function(symbol, params, body, docstring) {
|
|
this.functions[symbol] = {
|
|
type: 'function',
|
|
params: params,
|
|
body: body,
|
|
docstring: docstring || "(undocumented)"
|
|
};
|
|
};
|
|
|
|
EL.Evaluator.prototype.bind = function(params, args) {
|
|
var i = 0,
|
|
n = params.length,
|
|
result = [],
|
|
value;
|
|
while (i < n && args[i]) {
|
|
result.push(this.eval(args[i++]));
|
|
}
|
|
return result;
|
|
};
|
|
|
|
EL.Evaluator.prototype.call = function(func, args) {
|
|
var result;
|
|
if (typeof func.body === 'function') {
|
|
result = func.body.apply(null, args);
|
|
}
|
|
else {
|
|
// TODO
|
|
result = null;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
EL.Evaluator.prototype.isSymbol = function(expr) {
|
|
return (expr[0] && expr[0] === 'symbol');
|
|
};
|
|
|
|
EL.Evaluator.prototype.isFunction = function(expr) {
|
|
return (expr && expr.type === 'function');
|
|
};
|
|
|
|
EL.Evaluator.prototype.eval = function(expr) {
|
|
var result, x;
|
|
switch(expr[0]) {
|
|
case 'string':
|
|
result = expr[1];
|
|
break;
|
|
case 'symbol':
|
|
x = this.lookupVar(expr[1]);
|
|
if (x == null) this.error('undefined-var', expr[1]);
|
|
result = x.value;
|
|
break;
|
|
case 'number':
|
|
result = expr[1];
|
|
break;
|
|
case 'cons':
|
|
var cons = expr[1];
|
|
result = [this.eval(cons[0]), this.eval(cons[1])];
|
|
break;
|
|
case 'list':
|
|
var list = expr[1],
|
|
i = 0,
|
|
n = list.length,
|
|
car = list[0],
|
|
cdr = list.slice(1, list.length),
|
|
func, args;
|
|
while (!(this.isFunction(car) || this.isSymbol(car))) {
|
|
car = this.eval(car);
|
|
}
|
|
if ((func = this.lookupFunc(car[1]))) {
|
|
args = this.bind(func.params, cdr);
|
|
result = this.call(func, args);
|
|
}
|
|
else {
|
|
this.error('undefined-func', car);
|
|
}
|
|
break;
|
|
default:
|
|
this.error('not-expr', expr);
|
|
break;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// hideous
|
|
EL.pp = function(x, indent, key, noprint) {
|
|
var typeOf = function(value) {
|
|
var s = typeof value;
|
|
if (s === 'object') {
|
|
if (value) {
|
|
if (typeof value.length === 'number' &&
|
|
!(value.propertyIsEnumerable('length')) &&
|
|
typeof value.splice === 'function') {
|
|
s = 'array';
|
|
}
|
|
} else {
|
|
s = 'null';
|
|
}
|
|
}
|
|
return s;
|
|
};
|
|
|
|
if (indent === undefined) {
|
|
indent = 0;
|
|
}
|
|
|
|
/* string to print at the end, the only way to print 2 strings in
|
|
* succession without a newline is to buffer them
|
|
*/
|
|
var buffer = "";
|
|
var printB = function(s, newline) {
|
|
buffer += s;
|
|
if (newline) buffer += "\n";
|
|
};
|
|
var dumpBuffer = function(b) {
|
|
if (b === undefined) b = buffer;
|
|
if (buffer.length <= 72) {
|
|
print(buffer);
|
|
}
|
|
else {
|
|
var split = 72;
|
|
var c;
|
|
while ((c = b[split]) && c.match(/[a-zA-Z0-9"'\[\]_-]/)) --split;
|
|
print(b.substring(0, split));
|
|
var next_chunk = b.substring(split, b.length);
|
|
if (next_chunk) dumpBuffer(next_chunk);
|
|
}
|
|
buffer = "";
|
|
};
|
|
|
|
var space = "";
|
|
// for (var j = 0; j < indent; j++) {
|
|
// space += " ";
|
|
// }
|
|
|
|
switch (typeOf(x)) {
|
|
case 'object':
|
|
if (key) {
|
|
printB(space + key + ': {');
|
|
}
|
|
else {
|
|
printB(space + '{');
|
|
}
|
|
for (var a in x) {
|
|
printB(EL.pp(x[a], 1+indent, a, true));
|
|
}
|
|
printB(space + "}");
|
|
break;
|
|
|
|
case 'string':
|
|
if (key) {
|
|
printB(space + key + ': "' + x + '"');
|
|
}
|
|
else {
|
|
printB(space + '"' + x + '"');
|
|
}
|
|
return buffer;
|
|
break;
|
|
|
|
case 'array':
|
|
if (key) {
|
|
printB(space + key + ': [');
|
|
}
|
|
else {
|
|
printB(space + '[');
|
|
}
|
|
var n = x.length, i = 0;
|
|
while (i < n) {
|
|
if (i > 0) printB(', ');
|
|
printB(EL.pp(x[i++], 1+indent, undefined, true));
|
|
}
|
|
printB(space + ']');
|
|
break;
|
|
|
|
case 'null':
|
|
if (key) {
|
|
printB(space + key + ': (null)');
|
|
}
|
|
else {
|
|
printB(space + '(null)');
|
|
}
|
|
return buffer;
|
|
break;
|
|
|
|
default:
|
|
if (key) {
|
|
printB(space + key + ": " + x);
|
|
}
|
|
else {
|
|
printB(space + x);
|
|
}
|
|
return buffer;
|
|
break;
|
|
}
|
|
var s = buffer;
|
|
if (!noprint) dumpBuffer();
|
|
return s;
|
|
};
|
|
|