sjs/elisp.js
1
0
Fork 0
mirror of https://github.com/samsonjs/elisp.js.git synced 2026-03-25 09:15:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Renamed EL to elisp. Use absolute path to spidermonkey (till CommonJS conversion).

Browse source
This commit is contained in:
Sami Samhuri 2009-12-14 09:47:29 -08:00
parent f87cfe33d2
commit fdfca00fe4
16 changed files with 508 additions and 507 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
el.sh
View file

@ -1,3 +0,0 @@
#!/bin/sh
rlwrap js el.js

103
el/list.js
View file

@ -1,103 +0,0 @@
////
// Emacs Lisp implementation in JavaScript.
//
// Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
//
// Released under the terms of the MIT license. See the included file
// LICENSE.
EL.consPair = function(pair) {
var cons = ['cons', pair];
cons.isList = true;
return cons;
};
EL.cons = function(car, cdr) {
return EL.consPair([car, cdr]);
};
EL.car = function(cons) {
return EL.isNil(cons) ? cons : EL.val(cons)[0];
};
EL.cdr = function(cons) {
return EL.isNil(cons) ? cons : EL.val(cons)[1];
};
EL.cadr = function(cons) {
return EL.car(EL.cdr(cons));
};
EL.caddr = function(cons) {
return EL.car(EL.cdr(EL.cdr(cons)));
};
EL.cadddr = function(cons) {
return EL.car(EL.cdr(EL.cdr(EL.cdr(cons))));
};
EL.listLength = function(cons) {
var n = 0;
while (!EL.isNil(cons)) {
cons = EL.cdr(cons);
++n;
}
return n;
};
EL.listLast = function(cons) {
var last;
while (!EL.isNil(cons)) {
last = cons;
cons = EL.cdr(cons);
}
return EL.car(last);
};
EL.listMap = function(cons, fn) {
var list = [],
i = 0;
while (!EL.isNil(cons)) {
list.push(fn(EL.car(cons), i));
cons = EL.cdr(cons);
++i;
}
return list.length > 0 ? EL.list(list) : EL.nil;
};
EL.listReduce = function(fn, accum, cons) {
var i = 0,
n = EL.listLength(cons);
while (i < n) {
accum = fn(accum, EL.nth(i++, cons));
}
return accum;
};
EL.idFunction = function(x){return x;};
EL.unlist = function(cons) {
return EL.listReduce(EL.idFunction, [], cons);
};
EL.nth = function(n, cons) {
var i = 0,
e;
while (i <= n && !EL.isNil(cons)) {
e = EL.car(cons);
cons = EL.cdr(cons);
++i;
}
return n > --i ? EL.nil : e;
};
EL.nthcdr = function(n, cons) {
var e = EL.cdr(cons),
i = 0;
while (i < n && !EL.isNil(e)) {
e = EL.cdr(e);
++i;
}
return n > i ? EL.nil : e;
};

131
el/primitives.js
View file

@ -1,131 +0,0 @@
////
// Emacs Lisp implementation in JavaScript.
//
// Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
//
// Released under the terms of the MIT license. See the included file
// LICENSE.
EL.PrimitiveVariables = [
['t', {
type: 'variable',
value: ['symbol', 't'],
docstring: "true"
}],
['nil', {
type: 'variable',
value: ['symbol', 'nil'],
docstring: "nil"
}]
];
EL.PrimitiveFunctions = [];
// 'this' is bound to the EL.Evaluator object when executing primitve functions
EL.definePrimitive = function(name, params, body, docstring) {
EL.PrimitiveFunctions.push([name, {
type: 'primitive',
name: name,
params: params, // unused right now but should be checked
docstring: docstring,
body: body
}]);
};
EL.notFunc = function(fn) {
return function(x){ return !fn(x); };
};
EL.makePrimitiveBooleanFunc = function(fn) {
return function(x){ return fn(x) ? EL.t : EL.nil; };
};
EL._definePrimitives = function() {
EL.definePrimitive('consp', ['symbol'], EL.makePrimitiveBooleanFunc(EL.isCons),
"Return T if symbol is a cons, nil otherwise.");
EL.definePrimitive('atom', ['symbol'], EL.makePrimitiveBooleanFunc(EL.isAtom),
"Return T if symbol is not a cons or is nil, nil otherwise.");
EL.definePrimitive('symbol-name', ['symbol'],
function(symbol) { return EL.string(EL.val(symbol)); },
"Return a symbol's name, a string.");
EL.definePrimitive('string-match', ['regex', 'string', '&optional', 'start'],
function(regex, string, start) {
var index = start ? EL.val(start) : 0,
s = EL.val(string).substring(index),
match = s.match(new RegExp(EL.val(regex))),
found = match ? EL.number(s.indexOf(match[0])) : EL.nil;
return found;},
"Return the index of the char matching regex in string, beginning from start if available.");
// Right now a single string in the arg list will cause all the arguments
// to be converted to strings similar to JavaScript. These
// semantics suck and should change, not only for real emacs lisp compatibility.
EL.definePrimitive('+', [/*...*/],
function() {
var args = EL.Util.shallowCopy(arguments),
initial = EL.inferType(args),
type = initial[0];
return EL.Util.reduce(function(sum, n) {
return [type, EL.val(sum) + EL.val(n)];
}, initial, args);},
"add two numbers");
EL.definePrimitive('-', [/*...*/],
function() {
return EL.Util.foldr(function(diff, n) {
return EL.number(EL.val(diff) - EL.val(n));
}, EL.number(0), EL.Util.shallowCopy(arguments));},
"subtract two numbers");
EL.definePrimitive('*', [/*...*/],
function() {
return EL.Util.reduce(function(prod, n) {
return EL.number(EL.val(prod) * EL.val(n));
}, EL.number(1), EL.Util.shallowCopy(arguments));},
"multiply two numbers");
EL.definePrimitive('/', [/*...*/],
function() {
return EL.Util.foldr(function(quot, n) {
return EL.number(EL.val(quot) / EL.val(n));
}, EL.number(1), EL.Util.shallowCopy(arguments));
},
"divide two numbers");
EL.definePrimitive('print', ['x'],
function(x, tostring) {
var buffer = "",
tag = EL.tag(x);
function p(s) {
if (tostring) buffer += s;
else print(s);
}
if (tag == 'number' || tag == 'symbol' || tag == 'string') {
p(EL.val(x));
}
else if (tag == 'lambda') {
var fn = EL.val(x);
p('(lambda ' + fn.name + ' (' + fn.params + ')\n');
p(fn.body); // TODO lisp pretty print
p(')');
}
else if (tag == 'list') {
var recurse = arguments.callee; // far easier to remember than Y
print('(', El.val(x).map(function(e){return (recurse(e, true) + ' ');}), ")");
}
else {
print('unknown type: ' + x);
}
return EL.nil;
},
"print an expression");
EL.definePrimitive('hide-prompt', ['yes-or-no'],
function(bool){ EL.hidePrompt = !EL.isNil(bool); },
"Call with T to hide the prompt or nil to show it.");
};
EL.initHook(EL._definePrimitives);

113
el/types.js
View file

@ -1,113 +0,0 @@
////
// Emacs Lisp implementation in JavaScript.
//
// Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
//
// Released under the terms of the MIT license. See the included file
// LICENSE.
// data types are simple tags
EL._defineTags = function() {
EL.tags = ['symbol', 'string', 'number', 'cons', 'lambda', 'regex'];
EL.tags.each = Array.prototype.each;
// define constructors for the primitive types (box values)
// e.g. EL.symbol('foo') => ['symbol', 'foo']
EL.tags.each(function(tag) {
// don't clobber custom constructors
if (EL[tag] === undefined) {
EL[tag] = function(value) {
return [tag, value];
};
}
// tag type tests
var isTag = function(expr) {
return (EL.tag(expr) == tag);
};
EL['is' + tag.camelize()] = isTag;
});
};
EL.initHook(EL._defineTags);
// shorthands to save my fingers
EL._defineConstants = function() {
EL.nil = EL.symbol('nil');
EL.t = EL.symbol('t');
};
EL.initHook(EL._defineConstants);
// retrieve the tag from a value
EL.tag = function(expr) {
EL.assert(function() { var f='tag'; return EL.typeOf(expr) == 'array'; }, expr);
return expr[0];
};
// unbox a value
EL.val = function(expr) {
EL.assert(function() { var f='val'; return EL.typeOf(expr) == 'array'; }, expr);
return expr[1];
};
EL.symbolName = function(symbol) {
// EL.Util.pp(symbol);
EL.assert(function(){ var f='symbolName'; return EL.isSymbol(symbol); }, symbol);
return EL.val(symbol);
};
EL.isNilSymbol = function(expr) {
return (EL.isSymbol(expr) && EL.symbolName(expr) == 'nil');
};
EL.isNil = function(expr) {
return EL.isNilSymbol(expr);
};
EL.list = function(exprs) {
var list = EL.nil,
i = exprs.length;
while (--i >= 0) {
list = EL.cons(exprs[i], list);
}
return list;
};
EL.isList = function(expr) {
return (EL.isNil(expr) || EL.isCons(expr));
};
EL.isAtom = function(expr) {
return !EL.isCons(expr);
};
EL.inferType = function(exprs) {
var type = 'number',
initial = 0,
i = exprs.length-1;
while(i >= 0) {
if (EL.isString(exprs[i--])) {
type = 'string';
initial = '';
break;
}
}
return EL[type](initial);
};
// special forms
EL.isSpecialForm = function(name, expr) {
var tag = EL.tag(expr),
car = EL.typeOf(expr) == 'array' && EL.val(expr)[0],
thisName = car && EL.symbolName(car);
return (tag == 'cons' && thisName == name);
};
EL.isQuote = function(expr){return EL.isSpecialForm('quote', expr);};
EL.isDefVar = function(expr){return EL.isSpecialForm('defvar', expr);};
EL.isDefFunc = function(expr){return EL.isSpecialForm('defun', expr);};
EL.isSet = function(expr){return EL.isSpecialForm('set', expr);};
EL.isSetq = function(expr){return EL.isSpecialForm('setq', expr);};
EL.isCond = function(expr){return EL.isSpecialForm('cond', expr);};
EL.isIf = function(expr){return EL.isSpecialForm('if', expr);};

27
el.js → elisp.js
View file

@ -25,23 +25,24 @@
// our namespace
var EL = function(){};
var elisp = function(){};
load('el/init.js'); // simple init system
load('el/jsExt.js'); // a few extensions to native types
load('el/util.js'); // utilities
load('elisp/init.js'); // simple init system
load('elisp/jsExt.js'); // a few extensions to native types
load('elisp/util.js'); // utilities
// main lisp system
load('el/types.js');
load('el/list.js');
load('el/symtab.js');
load('el/parser.js');
load('el/evaluator.js');
load('el/primitives.js');
load('el/repl.js');
load('elisp/types.js');
load('elisp/list.js');
load('elisp/symtab.js');
load('elisp/parser.js');
load('elisp/evaluator.js');
load('elisp/primitives.js');
load('elisp/repl.js');
// everything is defined, initialize
EL.init();
elisp.init();
// q to quit
EL.repl();
elisp.repl();

3
elisp.sh Executable file
View file

@ -0,0 +1,3 @@
#!/bin/sh
rlwrap /opt/local/bin/js elisp.js

136
el/evaluator.js → elisp/evaluator.js
View file

@ -7,30 +7,30 @@
// LICENSE.
EL.Evaluator = function(exprs) {
elisp.Evaluator = function(exprs) {
this.expressions = exprs;
this.variables = new EL.SymbolTable(EL.PrimitiveVariables);
this.functions = new EL.SymbolTable(EL.PrimitiveFunctions);
this.variables = new elisp.SymbolTable(elisp.PrimitiveVariables);
this.functions = new elisp.SymbolTable(elisp.PrimitiveFunctions);
};
EL.Evaluator.Error = function(name, message, expr) {
elisp.Evaluator.Error = function(name, message, expr) {
this.evalError = true;
this.name = name;
this.message = message;
this.expression = expr;
};
EL.Evaluator.Error.messages = {
elisp.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));
elisp.Evaluator.prototype.error = function(name, expr) {
throw(new elisp.Evaluator.Error(name, elisp.Evaluator.Error.messages[name], expr));
};
EL.Evaluator.prototype.evalExpressions = function(expressions) {
elisp.Evaluator.prototype.evalExpressions = function(expressions) {
var exprs = expressions || this.expressions,
i = 0,
n = exprs.length,
@ -44,7 +44,7 @@ EL.Evaluator.prototype.evalExpressions = function(expressions) {
if (e.expression) {
print("got: " + e.expression);
}
result = EL.nil;
result = elisp.nil;
break;
}
else {
@ -52,39 +52,39 @@ EL.Evaluator.prototype.evalExpressions = function(expressions) {
}
}
}
// EL.Util.pp(result);
// elisp.Util.pp(result);
return result;
};
EL.Evaluator.prototype.lookupVar = function(symbol) {
elisp.Evaluator.prototype.lookupVar = function(symbol) {
return this.variables.lookup(symbol);
};
EL.Evaluator.prototype.lookupFunc = function(symbol) {
elisp.Evaluator.prototype.lookupFunc = function(symbol) {
return this.functions.lookup(symbol);
};
EL.Evaluator.prototype.apply = function(func, args) {
elisp.Evaluator.prototype.apply = function(func, args) {
var result;
if (func.type === 'primitive') {
// print('APPLY: ');
// EL.print(func);
// elisp.print(func);
// print('WITH: ');
// EL.print(args);
// elisp.print(args);
// print('------');
result = func.body.apply(this, args);
}
else {
this.functions.pushScope();
this.variables.pushScope(EL.listMap(func.params, function(e, i){
var name = EL.symbolName(e),
this.variables.pushScope(elisp.listMap(func.params, function(e, i){
var name = elisp.symbolName(e),
value = {
type: 'variable',
value: this.eval(args[i])
};
return [name, value];
}));
result = EL.listLast(EL.listMap(func.body,
result = elisp.listLast(elisp.listMap(func.body,
function(e) {return this.eval(e); }));
this.functions.popScope();
this.variables.popScope();
@ -92,16 +92,16 @@ EL.Evaluator.prototype.apply = function(func, args) {
return result;
};
EL.Evaluator.prototype.eval = function(expr) {
// print("EVAL: " + EL.typeOf(expr));
// EL.print(expr);
elisp.Evaluator.prototype.eval = function(expr) {
// print("EVAL: " + elisp.typeOf(expr));
// elisp.print(expr);
var result, x,
tag = EL.tag(expr);
if (EL.isAtom(expr)) {
tag = elisp.tag(expr);
if (elisp.isAtom(expr)) {
result = expr;
}
else if (EL.isSymbol(expr)) {
var name = EL.val(expr);
else if (elisp.isSymbol(expr)) {
var name = elisp.val(expr);
x = this.lookupVar(name);
if (x == null) this.error('undefined-var', name);
result = x.value;
@ -112,72 +112,72 @@ EL.Evaluator.prototype.eval = function(expr) {
///////////////////
// (many could be in lisp when there are macros) //
else if (EL.isQuote(expr)) {
result = EL.cdr(expr);
else if (elisp.isQuote(expr)) {
result = elisp.cdr(expr);
}
else if (EL.isDefVar(expr)) {
var name = EL.symbolName(EL.cadr(expr)), // 2nd param
value = this.eval(EL.caddr(expr)), // 3rd param
docstring = EL.cadddr(expr); // 4th param
else if (elisp.isDefVar(expr)) {
var name = elisp.symbolName(elisp.cadr(expr)), // 2nd param
value = this.eval(elisp.caddr(expr)), // 3rd param
docstring = elisp.cadddr(expr); // 4th param
// TODO check for re-definitions
this.defineVar(name, value, docstring);
result = EL.nil;
result = elisp.nil;
}
else if (EL.isDefFunc(expr)) {
var name = EL.symbolName(EL.nth(1, expr)),
params = EL.nth(2, expr),
d = EL.nth(3, expr),
docstring = EL.isString(d) && d,
body = EL.nthcdr(docstring ? 3 : 2, expr);
else if (elisp.isDefFunc(expr)) {
var name = elisp.symbolName(elisp.nth(1, expr)),
params = elisp.nth(2, expr),
d = elisp.nth(3, expr),
docstring = elisp.isString(d) && d,
body = elisp.nthcdr(docstring ? 3 : 2, expr);
this.defineFunc(name, params, body, docstring);
result = EL.nil;
result = elisp.nil;
}
else if (EL.isSet(expr)) {
var val = EL.val(expr),
name = EL.symbolName(val[1]),
else if (elisp.isSet(expr)) {
var val = elisp.val(expr),
name = elisp.symbolName(val[1]),
value = this.eval(val[2]);
this.setVar(name, value);
result = value;
}
else if (EL.isSetq(expr)) {
else if (elisp.isSetq(expr)) {
var i = 1,
n = EL.listLength(expr),
n = elisp.listLength(expr),
e;
while (i < n && EL.isSymbol((e=EL.nth(i,expr)))) {
var name = EL.symbolName(EL.nth(i, expr)),
value = this.eval(EL.nth(i+1, expr));
while (i < n && elisp.isSymbol((e=elisp.nth(i,expr)))) {
var name = elisp.symbolName(elisp.nth(i, expr)),
value = this.eval(elisp.nth(i+1, expr));
this.setVar(name, value, true);
result = value;
i += 2;
}
}
else if (EL.isIf(expr)) {
var val = EL.val(expr),
else if (elisp.isIf(expr)) {
var val = elisp.val(expr),
condition = this.eval(val[1]),
trueBlock = val[2],
nilBlock = val[3];
result = this.doIf(condition, trueBlock, nilBlock);
}
else if (EL.isCond(expr)) {
var val = EL.val(expr),
else if (elisp.isCond(expr)) {
var val = elisp.val(expr),
list = val[1],
condition = EL.car(list),
body = EL.cdr(list),
condition = elisp.car(list),
body = elisp.cdr(list),
rest = val.slice(2);
result = this.doCond(exprs);
}
// function application
else if (EL.isCons(expr)) {
var name = EL.car(expr),
rest = EL.cdr(expr),
else if (elisp.isCons(expr)) {
var name = elisp.car(expr),
rest = elisp.cdr(expr),
func, args;
while (!EL.isSymbol(name)) {
while (!elisp.isSymbol(name)) {
name = this.eval(name);
}
if ((func = this.lookupFunc(EL.symbolName(name)))) {
if ((func = this.lookupFunc(elisp.symbolName(name)))) {
var self = this;
args = EL.listReduce(function(a,e){
args = elisp.listReduce(function(a,e){
a.push(self.eval(e));
return a;
}, [], rest);
@ -195,7 +195,7 @@ EL.Evaluator.prototype.eval = function(expr) {
};
EL.Evaluator.prototype.defineVar = function(symbol, value, docstring) {
elisp.Evaluator.prototype.defineVar = function(symbol, value, docstring) {
this.variables.define(symbol, {
type: 'variable',
value: value,
@ -203,11 +203,11 @@ EL.Evaluator.prototype.defineVar = function(symbol, value, docstring) {
});
};
EL.Evaluator.prototype.setVar = function(symbol, value, create) {
elisp.Evaluator.prototype.setVar = function(symbol, value, create) {
var valueObject = this.lookupVar(symbol);
if (!valueObject) {
if (create) {
this.defineVar(symbol, EL.nil);
this.defineVar(symbol, elisp.nil);
valueObject = this.lookupVar(symbol);
}
else {
@ -218,7 +218,7 @@ EL.Evaluator.prototype.setVar = function(symbol, value, create) {
this.variables.set(symbol, valueObject);
};
EL.Evaluator.prototype.defineFunc = function(symbol, params, body, docstring) {
elisp.Evaluator.prototype.defineFunc = function(symbol, params, body, docstring) {
this.functions.define(symbol, {
type: 'lambda',
name: symbol,
@ -228,14 +228,14 @@ EL.Evaluator.prototype.defineFunc = function(symbol, params, body, docstring) {
});
};
EL.Evaluator.prototype.doIf = function(condition, trueBlock, nilBlock) {
return EL.isNil(condition) ? this.eval(nilBlock) : this.eval(trueBlock);
elisp.Evaluator.prototype.doIf = function(condition, trueBlock, nilBlock) {
return elisp.isNil(condition) ? this.eval(nilBlock) : this.eval(trueBlock);
};
EL.Evaluator.prototype.doCond = function(exprs) {
elisp.Evaluator.prototype.doCond = function(exprs) {
print('----- COND (doCond) -----');
EL.print(exprs);
return EL.nil;
elisp.print(exprs);
return elisp.nil;
};

12
el/init.js → elisp/init.js
View file

@ -10,14 +10,14 @@
// of the file we call init when everything is defined, regardless of
// the order it appears in the file. The order of the hooks still
// matters though, it's not fool-proof.
EL._initHooks = [];
EL.initHook = function(hook) {
EL._initHooks.push(hook);
elisp._initHooks = [];
elisp.initHook = function(hook) {
elisp._initHooks.push(hook);
};
EL.init = function() {
elisp.init = function() {
var i = 0,
n = EL._initHooks.length;
n = elisp._initHooks.length;
while (i < n) {
EL._initHooks[i++].call();
elisp._initHooks[i++].call();
}
};

6
el/jsExt.js → elisp/jsExt.js
View file

@ -7,7 +7,7 @@
// LICENSE.
// Just a little sugar
EL.initHook(function() {
elisp.initHook(function() {
Array.prototype.each = function(fn) {
var i = 0,
n = this.length;
@ -35,7 +35,7 @@ EL.initHook(function() {
// A typeOf function that distinguishes between objects, arrays,
// and null.
EL.typeOf = function(value) {
elisp.typeOf = function(value) {
var s = typeof value;
if (s === 'object') {
if (value) {
@ -52,7 +52,7 @@ EL.initHook(function() {
};
// TODO throw something more informative
EL.assert = function(condition, message) {
elisp.assert = function(condition, message) {
if (!condition()) {
throw("assertion failed: " + condition + " (" + message + ")");
}

103
elisp/list.js Normal file
View file

@ -0,0 +1,103 @@
////
// Emacs Lisp implementation in JavaScript.
//
// Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
//
// Released under the terms of the MIT license. See the included file
// LICENSE.
elisp.consPair = function(pair) {
var cons = ['cons', pair];
cons.isList = true;
return cons;
};
elisp.cons = function(car, cdr) {
return elisp.consPair([car, cdr]);
};
elisp.car = function(cons) {
return elisp.isNil(cons) ? cons : elisp.val(cons)[0];
};
elisp.cdr = function(cons) {
return elisp.isNil(cons) ? cons : elisp.val(cons)[1];
};
elisp.cadr = function(cons) {
return elisp.car(elisp.cdr(cons));
};
elisp.caddr = function(cons) {
return elisp.car(elisp.cdr(elisp.cdr(cons)));
};
elisp.cadddr = function(cons) {
return elisp.car(elisp.cdr(elisp.cdr(elisp.cdr(cons))));
};
elisp.listLength = function(cons) {
var n = 0;
while (!elisp.isNil(cons)) {
cons = elisp.cdr(cons);
++n;
}
return n;
};
elisp.listLast = function(cons) {
var last;
while (!elisp.isNil(cons)) {
last = cons;
cons = elisp.cdr(cons);
}
return elisp.car(last);
};
elisp.listMap = function(cons, fn) {
var list = [],
i = 0;
while (!elisp.isNil(cons)) {
list.push(fn(elisp.car(cons), i));
cons = elisp.cdr(cons);
++i;
}
return list.length > 0 ? elisp.list(list) : elisp.nil;
};
elisp.listReduce = function(fn, accum, cons) {
var i = 0,
n = elisp.listLength(cons);
while (i < n) {
accum = fn(accum, elisp.nth(i++, cons));
}
return accum;
};
elisp.idFunction = function(x){return x;};
elisp.unlist = function(cons) {
return elisp.listReduce(elisp.idFunction, [], cons);
};
elisp.nth = function(n, cons) {
var i = 0,
e;
while (i <= n && !elisp.isNil(cons)) {
e = elisp.car(cons);
cons = elisp.cdr(cons);
++i;
}
return n > --i ? elisp.nil : e;
};
elisp.nthcdr = function(n, cons) {
var e = elisp.cdr(cons),
i = 0;
while (i < n && !elisp.isNil(e)) {
e = elisp.cdr(e);
++i;
}
return n > i ? elisp.nil : e;
};

66
el/parser.js → elisp/parser.js
View file

@ -7,53 +7,53 @@
// LICENSE.
EL.Parser = function(data) {
elisp.Parser = function(data) {
this.data = data || '';
};
EL.Parser.Error = function(name, message) {
elisp.Parser.Error = function(name, message) {
this.parserError = true;
this.name = name;
this.message = message;
};
EL.Parser.Error.messages = {
elisp.Parser.Error.messages = {
'eof': "no more input"
};
EL.Parser.prototype.error = function(name) {
throw(new EL.Parser.Error(name, EL.Parser.Error.messages[name]));
elisp.Parser.prototype.error = function(name) {
throw(new elisp.Parser.Error(name, elisp.Parser.Error.messages[name]));
};
EL.Parser.prototype.peek = function() {
elisp.Parser.prototype.peek = function() {
return this.data[this.pos];
};
EL.Parser.prototype.consumeChar = function() {
elisp.Parser.prototype.consumeChar = function() {
if (this.pos >= this.data.length) this.error('eof');
return this.data[this.pos++];
};
EL.Parser.prototype.consumeWhitespace = function() {
elisp.Parser.prototype.consumeWhitespace = function() {
var c;
while ((c = this.peek()) && c.match(/[\s\n]/)) {
this.consumeChar();
}
};
EL.Parser.prototype.rewind = function() {
elisp.Parser.prototype.rewind = function() {
this.pos = 0;
};
EL.Parser.prototype.rest = function() {
elisp.Parser.prototype.rest = function() {
return this.data.substring(this.pos);
};
EL.Parser.prototype.moreInput = function() {
elisp.Parser.prototype.moreInput = function() {
return (this.pos < this.data.length);
};
EL.Parser.prototype.parse = function(string) {
elisp.Parser.prototype.parse = function(string) {
if (string) this.data = string;
this.rewind();
var exprs = [];
@ -72,16 +72,16 @@ EL.Parser.prototype.parse = function(string) {
}
this.expressions = exprs;
// print('');
// EL.Util.pp(exprs);
// elisp.Util.pp(exprs);
// print('');
return exprs;
};
EL.Parser.prototype.parseOne = function(string) {
elisp.Parser.prototype.parseOne = function(string) {
return this.parse(string)[0];
};
EL.Parser.prototype.parseUntil = function(regex, initial, next, consumeTerminator) {
elisp.Parser.prototype.parseUntil = function(regex, initial, next, consumeTerminator) {
var c,
token = initial,
condition = function(c){ return c.match(regex) == null; };
@ -92,7 +92,7 @@ EL.Parser.prototype.parseUntil = function(regex, initial, next, consumeTerminato
return token;
};
EL.Parser.prototype.parseList = function() {
elisp.Parser.prototype.parseList = function() {
var list = [],
expr;
// consume initial paren '('
@ -103,7 +103,7 @@ EL.Parser.prototype.parseList = function() {
return list;
};
EL.Parser.prototype.parseCons = function() {
elisp.Parser.prototype.parseCons = function() {
var cons = [],
expr;
// consume initial paren '('
@ -115,7 +115,7 @@ EL.Parser.prototype.parseCons = function() {
return cons;
};
EL.Parser.prototype.parseString = function() {
elisp.Parser.prototype.parseString = function() {
// consume initial quotation mark
this.consumeChar();
var self = this;
@ -127,13 +127,13 @@ EL.Parser.prototype.parseString = function() {
}, true /* consume terminator */);
};
EL.Parser.prototype.parseSymbol = function() {
elisp.Parser.prototype.parseSymbol = function() {
var symbol = this.parseUntil(/[\s()]/, '', function(t,c){return t + c;});
return symbol;
};
// Probably easy to break
EL.Parser.prototype.parseRegex = function() {
elisp.Parser.prototype.parseRegex = function() {
// consume initial slash
this.consumeChar();
var self = this;
@ -159,7 +159,7 @@ EL.Parser.prototype.parseRegex = function() {
//
// Binary, octal, hex, or arbitrary radix integers not yet parsed.
// (e.g. #x100 == #o400 == #b100000000 == #24rag
EL.Parser.prototype.parseNumber = function() {
elisp.Parser.prototype.parseNumber = function() {
var value = this.parseIntOrFloat(),
exponentAllowed = value === parseInt(value),
exp;
@ -179,7 +179,7 @@ EL.Parser.prototype.parseNumber = function() {
};
// Pack int and float parsing together for simplicity's sake.
EL.Parser.prototype.parseIntOrFloat = function() {
elisp.Parser.prototype.parseIntOrFloat = function() {
this.exponentAllowed = true;
var sign = this.peek() == '-' || this.peek() == '+' ? this.consumeChar() : '+',
value;
@ -217,7 +217,7 @@ EL.Parser.prototype.parseIntOrFloat = function() {
// string or some chars in the same regex.
//
// TODO: pick up Friedl and find a way to consolidate these.
EL.Parser.prototype.lookingAtNumber = function() {
elisp.Parser.prototype.lookingAtNumber = function() {
var pos = this.pos,
rest = this.rest(),
match = rest.match(/^[+-]?\d+(\.\d*)?[)\s\n]/)
@ -229,46 +229,46 @@ EL.Parser.prototype.lookingAtNumber = function() {
return (match != null);
};
EL.Parser.prototype.lookingAtCons = function() {
elisp.Parser.prototype.lookingAtCons = function() {
var orig_pos = this.pos,
_ = this.consumeChar(),
__ = _ && this.peek() && this.parseExpression(),
cdr = __ && this.peek() &&this.parseExpression();
this.pos = orig_pos; // rewind, like it never happened.
return _ == ')' || cdr && EL.typeOf(cdr) == 'array' && EL.isSymbol(cdr) && EL.val(cdr) == '.';
return _ == ')' || cdr && elisp.typeOf(cdr) == 'array' && elisp.isSymbol(cdr) && elisp.val(cdr) == '.';
};
EL.Parser.prototype.parseExpression = function() {
elisp.Parser.prototype.parseExpression = function() {
var value,
c = this.peek();
if (c == '(' && this.lookingAtCons()) {
value = EL.consPair(this.parseCons());
value = elisp.consPair(this.parseCons());
}
else if (c == '(') {
var list = this.parseList();
value = (list.length > 0) ? EL.list(list) : EL.nil;
value = (list.length > 0) ? elisp.list(list) : elisp.nil;
}
else if (c == ')') {
return this.consumeChar();
}
else if (c == "'") {
this.consumeChar();
value = EL.cons(EL.symbol('quote'), this.parseExpression());
value = elisp.cons(elisp.symbol('quote'), this.parseExpression());
}
else if (c == '"') {
value = EL.string(this.parseString());
value = elisp.string(this.parseString());
}
else if (this.lookingAtNumber()) {
value = EL.number(this.parseNumber());
value = elisp.number(this.parseNumber());
}
else if (c) {
value = EL.symbol(this.parseSymbol());
value = elisp.symbol(this.parseSymbol());
}
else {
if (this.pos == this.data.length) {
print('[error] no more input. unterminated string or list? (continuing anyway)');
}
print('[warning] in EL.Parser.parseExpression: unrecognized char "' + c + '"');
print('[warning] in elisp.Parser.parseExpression: unrecognized char "' + c + '"');
print('this.pos = ' + this.pos);
print('this.data.length = ' + this.data.length);
print('this.rest = ' + this.rest());

131
elisp/primitives.js Normal file
View file

@ -0,0 +1,131 @@
////
// Emacs Lisp implementation in JavaScript.
//
// Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
//
// Released under the terms of the MIT license. See the included file
// LICENSE.
elisp.PrimitiveVariables = [
['t', {
type: 'variable',
value: ['symbol', 't'],
docstring: "true"
}],
['nil', {
type: 'variable',
value: ['symbol', 'nil'],
docstring: "nil"
}]
];
elisp.PrimitiveFunctions = [];
// 'this' is bound to the elisp.Evaluator object when executing primitve functions
elisp.definePrimitive = function(name, params, body, docstring) {
elisp.PrimitiveFunctions.push([name, {
type: 'primitive',
name: name,
params: params, // unused right now but should be checked
docstring: docstring,
body: body
}]);
};
elisp.notFunc = function(fn) {
return function(x){ return !fn(x); };
};
elisp.makePrimitiveBooleanFunc = function(fn) {
return function(x){ return fn(x) ? elisp.t : elisp.nil; };
};
elisp._definePrimitives = function() {
elisp.definePrimitive('consp', ['symbol'], elisp.makePrimitiveBooleanFunc(elisp.isCons),
"Return T if symbol is a cons, nil otherwise.");
elisp.definePrimitive('atom', ['symbol'], elisp.makePrimitiveBooleanFunc(elisp.isAtom),
"Return T if symbol is not a cons or is nil, nil otherwise.");
elisp.definePrimitive('symbol-name', ['symbol'],
function(symbol) { return elisp.string(elisp.val(symbol)); },
"Return a symbol's name, a string.");
elisp.definePrimitive('string-match', ['regex', 'string', '&optional', 'start'],
function(regex, string, start) {
var index = start ? elisp.val(start) : 0,
s = elisp.val(string).substring(index),
match = s.match(new RegExp(elisp.val(regex))),
found = match ? elisp.number(s.indexOf(match[0])) : elisp.nil;
return found;},
"Return the index of the char matching regex in string, beginning from start if available.");
// Right now a single string in the arg list will cause all the arguments
// to be converted to strings similar to JavaScript. These
// semantics suck and should change, not only for real emacs lisp compatibility.
elisp.definePrimitive('+', [/*...*/],
function() {
var args = elisp.Util.shallowCopy(arguments),
initial = elisp.inferType(args),
type = initial[0];
return elisp.Util.reduce(function(sum, n) {
return [type, elisp.val(sum) + elisp.val(n)];
}, initial, args);},
"add two numbers");
elisp.definePrimitive('-', [/*...*/],
function() {
return elisp.Util.foldr(function(diff, n) {
return elisp.number(elisp.val(diff) - elisp.val(n));
}, elisp.number(0), elisp.Util.shallowCopy(arguments));},
"subtract two numbers");
elisp.definePrimitive('*', [/*...*/],
function() {
return elisp.Util.reduce(function(prod, n) {
return elisp.number(elisp.val(prod) * elisp.val(n));
}, elisp.number(1), elisp.Util.shallowCopy(arguments));},
"multiply two numbers");
elisp.definePrimitive('/', [/*...*/],
function() {
return elisp.Util.foldr(function(quot, n) {
return elisp.number(elisp.val(quot) / elisp.val(n));
}, elisp.number(1), elisp.Util.shallowCopy(arguments));
},
"divide two numbers");
elisp.definePrimitive('print', ['x'],
function(x, tostring) {
var buffer = "",
tag = elisp.tag(x);
function p(s) {
if (tostring) buffer += s;
else print(s);
}
if (tag == 'number' || tag == 'symbol' || tag == 'string') {
p(elisp.val(x));
}
else if (tag == 'lambda') {
var fn = elisp.val(x);
p('(lambda ' + fn.name + ' (' + fn.params + ')\n');
p(fn.body); // TODO lisp pretty print
p(')');
}
else if (tag == 'list') {
var recurse = arguments.callee; // far easier to remember than Y
print('(', El.val(x).map(function(e){return (recurse(e, true) + ' ');}), ")");
}
else {
print('unknown type: ' + x);
}
return elisp.nil;
},
"print an expression");
elisp.definePrimitive('hide-prompt', ['yes-or-no'],
function(bool){ elisp.hidePrompt = !elisp.isNil(bool); },
"Call with T to hide the prompt or nil to show it.");
};
elisp.initHook(elisp._definePrimitives);

32
el/repl.js → elisp/repl.js
View file

@ -6,32 +6,32 @@
// Released under the terms of the MIT license. See the included file
// LICENSE.
EL.eval = function(exprs) {
var e = new EL.Evaluator();
elisp.eval = function(exprs) {
var e = new elisp.Evaluator();
return e.evalExpressions(exprs);
};
EL.parse = function(string) {
var p = new EL.Parser();
elisp.parse = function(string) {
var p = new elisp.Parser();
return p.parse(string);
};
EL.parseOne = function(string) {
return EL.parse(string)[0];
elisp.parseOne = function(string) {
return elisp.parse(string)[0];
};
EL.read = EL.parseOne;
EL.print = EL.Util.pp;
elisp.read = elisp.parseOne;
elisp.print = elisp.Util.pp;
EL.rep = function(string) {
EL.print(EL.eval(EL.parse(string)));
elisp.rep = function(string) {
elisp.print(elisp.eval(elisp.parse(string)));
};
EL.repl = function() {
var p = new EL.Parser(),
e = new EL.Evaluator();
elisp.repl = function() {
var p = new elisp.Parser(),
e = new elisp.Evaluator();
while (true) {
if (!EL.hidePrompt) {
if (!elisp.hidePrompt) {
print("elisp> "); // i don't want a newline, grrrr
}
try {
@ -40,11 +40,11 @@ EL.repl = function() {
line = readline();
}
if (line.substring(0,1).toLowerCase() == 'q') return;
EL.print(e.eval(p.parseOne(line)));
elisp.print(e.eval(p.parseOne(line)));
} catch (x) {
if (x.evalError) {
print('[error] ' + x.message + ': ' + x.expression);
EL.print(x);
elisp.print(x);
}
else throw(x);
}

16
el/symtab.js → elisp/symtab.js
View file

@ -10,13 +10,13 @@
**** Symbol Table **********************************************
****************************************************************/
EL.SymbolTable = function(bindings) {
elisp.SymbolTable = function(bindings) {
this.symbols = [[]];
this.level = 0;
if (bindings) this.define(bindings);
};
EL.SymbolTable.prototype.lookupWithScope = function(name) {
elisp.SymbolTable.prototype.lookupWithScope = function(name) {
var i = this.level,
symbol;
while (i >= 0) {
@ -29,14 +29,14 @@ EL.SymbolTable.prototype.lookupWithScope = function(name) {
return null;
};
EL.SymbolTable.prototype.lookup = function(name) {
elisp.SymbolTable.prototype.lookup = function(name) {
var pair = this.lookupWithScope(name);
return pair && pair[1];
};
// store the given symbol/value pair in the symbol table at the current level.
EL.SymbolTable.prototype.define = function(name, value) {
if (value === undefined && EL.typeOf(name) == 'array') {
elisp.SymbolTable.prototype.define = function(name, value) {
if (value === undefined && elisp.typeOf(name) == 'array') {
var bindings = name,
i = 0,
n = bindings.length,
@ -55,7 +55,7 @@ EL.SymbolTable.prototype.define = function(name, value) {
}
};
EL.SymbolTable.prototype.pushScope = function(bindings) {
elisp.SymbolTable.prototype.pushScope = function(bindings) {
// print('>>> pushing scope <<<');
// print('>>> level going from ' + this.level + ' to ' + (1+this.level));
// print(bindings);
@ -63,11 +63,11 @@ EL.SymbolTable.prototype.pushScope = function(bindings) {
if (bindings) this.define(bindings);
};
EL.SymbolTable.prototype.popScope = function() {
elisp.SymbolTable.prototype.popScope = function() {
--this.level;
};
EL.SymbolTable.prototype.set = function(name, value) {
elisp.SymbolTable.prototype.set = function(name, value) {
var pair = this.lookupWithScope(name),
level = pair[0];
this.symbols[level][name] = value;

113
elisp/types.js Normal file
View file

@ -0,0 +1,113 @@
////
// Emacs Lisp implementation in JavaScript.
//
// Copyright (c) 2009 Sami Samhuri - sami.samhuri@gmail.com
//
// Released under the terms of the MIT license. See the included file
// LICENSE.
// data types are simple tags
elisp._defineTags = function() {
elisp.tags = ['symbol', 'string', 'number', 'cons', 'lambda', 'regex'];
elisp.tags.each = Array.prototype.each;
// define constructors for the primitive types (box values)
// e.g. elisp.symbol('foo') => ['symbol', 'foo']
elisp.tags.each(function(tag) {
// don't clobber custom constructors
if (elisp[tag] === undefined) {
elisp[tag] = function(value) {
return [tag, value];
};
}
// tag type tests
var isTag = function(expr) {
return (elisp.tag(expr) == tag);
};
elisp['is' + tag.camelize()] = isTag;
});
};
elisp.initHook(elisp._defineTags);
// shorthands to save my fingers
elisp._defineConstants = function() {
elisp.nil = elisp.symbol('nil');
elisp.t = elisp.symbol('t');
};
elisp.initHook(elisp._defineConstants);
// retrieve the tag from a value
elisp.tag = function(expr) {
elisp.assert(function() { var f='tag'; return elisp.typeOf(expr) == 'array'; }, expr);
return expr[0];
};
// unbox a value
elisp.val = function(expr) {
elisp.assert(function() { var f='val'; return elisp.typeOf(expr) == 'array'; }, expr);
return expr[1];
};
elisp.symbolName = function(symbol) {
// elisp.Util.pp(symbol);
elisp.assert(function(){ var f='symbolName'; return elisp.isSymbol(symbol); }, symbol);
return elisp.val(symbol);
};
elisp.isNilSymbol = function(expr) {
return (elisp.isSymbol(expr) && elisp.symbolName(expr) == 'nil');
};
elisp.isNil = function(expr) {
return elisp.isNilSymbol(expr);
};
elisp.list = function(exprs) {
var list = elisp.nil,
i = exprs.length;
while (--i >= 0) {
list = elisp.cons(exprs[i], list);
}
return list;
};
elisp.isList = function(expr) {
return (elisp.isNil(expr) || elisp.isCons(expr));
};
elisp.isAtom = function(expr) {
return !elisp.isCons(expr);
};
elisp.inferType = function(exprs) {
var type = 'number',
initial = 0,
i = exprs.length-1;
while(i >= 0) {
if (elisp.isString(exprs[i--])) {
type = 'string';
initial = '';
break;
}
}
return elisp[type](initial);
};
// special forms
elisp.isSpecialForm = function(name, expr) {
var tag = elisp.tag(expr),
car = elisp.typeOf(expr) == 'array' && elisp.val(expr)[0],
thisName = car && elisp.symbolName(car);
return (tag == 'cons' && thisName == name);
};
elisp.isQuote = function(expr){return elisp.isSpecialForm('quote', expr);};
elisp.isDefVar = function(expr){return elisp.isSpecialForm('defvar', expr);};
elisp.isDefFunc = function(expr){return elisp.isSpecialForm('defun', expr);};
elisp.isSet = function(expr){return elisp.isSpecialForm('set', expr);};
elisp.isSetq = function(expr){return elisp.isSpecialForm('setq', expr);};
elisp.isCond = function(expr){return elisp.isSpecialForm('cond', expr);};
elisp.isIf = function(expr){return elisp.isSpecialForm('if', expr);};

20
el/util.js → elisp/util.js
View file

@ -10,10 +10,10 @@
**** Utilities *************************************************
****************************************************************/
EL.Util = function(){};
elisp.Util = function(){};
// aka foldl
EL.Util.reduce = function(fn, accum, list) {
elisp.Util.reduce = function(fn, accum, list) {
var i = 0,
n = list.length;
while (i < n) {
@ -22,7 +22,7 @@ EL.Util.reduce = function(fn, accum, list) {
return accum;
};
EL.Util.foldr = function(fn, end, list) {
elisp.Util.foldr = function(fn, end, list) {
var i = list.length-1;
while (i >= 0) {
end = fn(list[i--], end);
@ -30,7 +30,7 @@ EL.Util.foldr = function(fn, end, list) {
return end;
};
EL.Util.shallowCopy = function(list) {
elisp.Util.shallowCopy = function(list) {
var i = 0,
n = list.length,
result = [];
@ -42,7 +42,7 @@ EL.Util.shallowCopy = function(list) {
// i'm sorry
EL.Util.pp = function(x, indent, key, noprint) {
elisp.Util.pp = function(x, indent, key, noprint) {
if (indent === undefined) {
indent = 0;
}
@ -76,7 +76,7 @@ EL.Util.pp = function(x, indent, key, noprint) {
// space += " ";
// }
switch (EL.typeOf(x)) {
switch (elisp.typeOf(x)) {
case 'object':
if (key) {
printB(space + key + ': {');
@ -85,7 +85,7 @@ EL.Util.pp = function(x, indent, key, noprint) {
printB(space + ' {');
}
for (var a in x) {
printB(EL.Util.pp(x[a], 1+indent, a, true));
printB(elisp.Util.pp(x[a], 1+indent, a, true));
printB(', ');
}
printB(space + "} ");
@ -102,8 +102,8 @@ EL.Util.pp = function(x, indent, key, noprint) {
case 'array':
// nil special case
if (x.length == 2 && EL.tag(x) == 'symbol' && EL.val(x) == 'nil') {
return EL.Util.pp(null, indent, key);
if (x.length == 2 && elisp.tag(x) == 'symbol' && elisp.val(x) == 'nil') {
return elisp.Util.pp(null, indent, key);
}
if (key) {
@ -115,7 +115,7 @@ EL.Util.pp = function(x, indent, key, noprint) {
var n = x.length, i = 0;
while (i < n) {
if (i > 0) printB(', ');
printB(EL.Util.pp(x[i++], 1+indent, undefined, true));
printB(elisp.Util.pp(x[i++], 1+indent, undefined, true));
}
printB(space + ']');
break;