repos/tabletprog: interp.js comparison

comparison interp.js @ 217:adad61ea2f3a

Switched to a less hacky implementation of hygiene and exposed more AST properties to macros

author	Michael Pavone <pavone@retrodev.com>
date	Sat, 21 Dec 2013 12:07:51 -0800
parents	e00a8bc6361b
children	b70be565d54c

comparison

equal deleted inserted replaced

-:2dac67e9d18b
+:adad61ea2f3a
 		if (name in this.modules) {
 			return this.modules[name];
 		}
 		if (name in this.names) {
 			var parsed = parseFile(this.names[name]);
-			this.modules[name] = parsed.macroexpand(this).eval(this);
+			var ret = parsed.macroexpand(this).eval(this);
-			return this.modules[name];
+			if (typeof ret == 'function') {
+				ret = ret();
+			}
+			this.modules[name] = ret;
+			return ret;
 		}
 		return null;
 	},
 	findNoTop: function(name) {
 		return null;
 	} else {
 		if (name == '&&') {
 			name = 'if'
 		} else if (name == '||') {
 			name = 'ifnot'
+		} else if (name == '|') {
+			return r['tpmeth_|'](l);
 		}
 		ret = l['tpmeth_'+name](r);
 	}
 	return ret;
 };
 	var left = this.left.quote(env);
 	var right = this.right.quote(env);
 	return new op(left, this.op, right);
 };
+op.prototype.makeHygienic = function(env) {
+	var left = this.left.makeHygienic(env);
+	var right = this.right.makeHygienic(env);
+	return new op(left, this.op, right);
+};
 op.prototype.tpmeth_nodeType = function() {
 	return "op";
 };
 op.prototype.tpmeth_left = function() {
 symbol.prototype.quote = function(env) {
 	var val = env.find(this.name);
 	if (val) {
 		var newnode = makeASTNode(val);
-		if (!(newnode instanceof symbol)) {
-			if ('quote' in newnode) {
-				newnode = newnode.quote(env);
-			} else {
-				throw new Error('Symbol ' + this.name + ' is not bound to a valid AST value, instead it is bound to an object with keys ' + JSON.stringify(Object.keys(newnode)));
-			}
-		}
 		return newnode;
 	} else {
-		var hygenic = env.findQuoteTrans(this.name);
+		this.dirty = true;
-		return hygenic ? new symbol(hygenic, this.symbols) : this;
+		return this;
+	}
+};
+symbol.prototype.makeHygienic = function(env) {
+	if (this.dirty) {
+		var hygenic = env.findQuoteTrans(this.cleanName());
+		if (hygenic)
+		{
+			return new symbol(hygenic, this.symbols);
+		} else {
+			return this;
+		}
+	} else {
+		return this;
 	}
 };
 symbol.prototype.tpmeth_nodeType = function() {
 	return "symbol";
 };
 symbol.prototype.tpmeth_name = function() {
 	return this.cleanName();
+};
+symbol.prototype['tpmeth_name!'] = function(val) {
+	this.name = val;
+	return this;
 };
 intlit.prototype.eval =
 	floatlit.prototype.eval =
 	strlit.prototype.eval =
 	arraylit.prototype.eval = function(env) {
 	return this.val;
 };
+listlit.prototype.eval = function(env) {
+	var cur = tplist.tpmeth_empty();
+	for (var idx = this.val.length - 1; idx >= 0; --idx) {
+		cur = tplist['tpmeth_node:withTail'](this.val[idx].eval(env), cur);
+	}
+	return cur;
+};
 symbol.prototype.macroexpand =
 	intlit.prototype.macroexpand =
 	floatlit.prototype.macroexpand =
 	strlit.prototype.macroexpand = function(env) {
 	return this;
 intlit.prototype.quote =
 	floatlit.prototype.quote =
 	strlit.prototype.quote =
 	arraylit.prototype.quote =
 	listlit.prototype.quote = function(env) {
+	return this;
+};
+intlit.prototype.makeHygienic =
+	floatlit.prototype.makeHygienic =
+	strlit.prototype.makeHygienic =
+	arraylit.prototype.makeHygienic =
+	listlit.prototype.makeHygienic = function(env) {
 	return this;
 };
 intlit.prototype.tpmeth_nodeType = function() {
 	return "intlit";
 		args.push(this.receiver);
 	}
 	for (var i = 0; i < this.args.length; i++) {
 		args.push(this.args[i]);
 	}
-	return makeASTNode(macro.apply(null, args));
+	var ret = makeASTNode(macro.apply(null, args));
+	ret = ret.makeHygienic(env);
+	quote_prefix++;
+	return ret;
 };
 funcall.prototype.quote = function(env) {
 	var receiver = this.receiver ? this.receiver.quote(env) : null;
 	var args = [];
 			name = fun.cleanName();
 		} else if (fun instanceof lambda) {
 			throw new Error('FIXME');
 		}
 	} else {
-		var hygenic = env.findQuoteTrans(this.name);
+		this.dirty = true;
-		if (hygenic) {
-			name = hygenic;
-		}
 	}
 	var ret = new funcall(name, args);
 	ret.receiver = receiver;
 	return ret;
 };
+funcall.prototype.makeHygienic = function(env) {
+	var receiver = this.receiver ? this.receiver.makeHygienic(env) : null;
+	var args = [];
+	for (var i = 0; i < this.args.length; i++) {
+		args.push(this.args[i].makeHygienic(env));
+	}
+	var name = this.name;
+	if (name[name.length-1] == ":") {
+		name = name.substr(0, name.length-1);
+	}
+	var hygienic = env.findQuoteTrans(name);
+	if (hygienic) {
+		name = hygienic;
+	}
+	var ret = new funcall(name, args);
+	ret.receiver = receiver;
+	return ret;
+};
 funcall.prototype.tpmeth_nodeType = function() {
 	return "funcall";
+};
+funcall.prototype['tpmeth_args!'] = function(arglist) {
+	this.args = [];
+	//TODO: Finish this
 };
 object.prototype.eval = function(parentenv) {
 	var env = new environment(parentenv);
 	var obj = {env: env};
 	var env = new environment(parentenv);
 	var outmessages = [];
 	for (var i = 0; i < this.messages.length; i++) {
 		var msg = this.messages[i];
 		if (msg instanceof assignment) {
-			//Make sure method names don't get renamed for hygene
 			env.syms[msg.symbol.name] = null;
-			env.quotetrans[msg.symbol.name] = msg.symbol.name;
+			if (!(msg.expression instanceof lambda)) {
-			if (msg.expression instanceof lambda) {
 				env.syms[msg.symbol.name + '!'] = null;
-				env.quotetrans[msg.symbol.name + '!'] = msg.symbol.name + '!';
 			}
 		}
 	}
 	for (var i = 0; i < this.messages.length; i++) {
 		var msg = this.messages[i];
 		}
 	}
 	return new object(outmessages);
 };
+object.prototype.makeHygienic = function(parentenv) {
+	var env = new environment(parentenv);
+	var outmessages = [];
+	for (var i = 0; i < this.messages.length; i++) {
+		var msg = this.messages[i];
+		if (msg instanceof assignment) {
+			env.syms[msg.symbol.name] = null;
+			//make sure method names don't get translated for hygiene
+			env.quotetrans[msg.symbol.name] = null;
+			if (!(msg.expression instanceof lambda)) {
+				env.syms[msg.symbol.name + '!'] = null;
+				env.quotetrans[msg.symbol.name + '!'] = null;
+			}
+		}
+	}
+	for (var i = 0; i < this.messages.length; i++) {
+		var msg = this.messages[i];
+		if (msg instanceof assignment) {
+			outmessages.push(new assignment(msg.symbol, msg.expression.makeHygienic(env)));
+		} else {
+			outmessages.push(msg.makeHygienic(env));
+		}
+	}
+	return new object(outmessages);
+};
 object.prototype.tpmeth_nodeType = function() {
 	return "object";
+};
+object.prototype.tpmeth_addMessage = function(message) {
+	this.messages.push(makeASTNode(message));
+	return this;
 };
 lambda.prototype.eval = function(parentenv) {
 	var args = this.args;
 	var exprs = this.expressions;
 	var args = [];
 	var expressions = [];
 	var env = new environment(parentenv);
 	for (var i = 0; i < this.args.length; i++) {
 		env.syms[this.args[i].cleanName()] = null;
-		var hygenic = '' + quote_prefix + this.args[i].cleanName();
+		var sym = new symbol(this.args[i].name, this.args[i].symbols);
-		env.quotetrans[this.args[i].cleanName()] = hygenic;
+		sym.dirty = true;
-		args.push(new symbol(hygenic, this.args[i].symbols));
+		args.push(sym);
 	}
 	for (var i = 0; i < this.expressions.length; i++) {
 		expressions.push(this.expressions[i].quote(env));
+	}
+	return new lambda(args, expressions);
+};
+lambda.prototype.makeHygienic = function(parentenv) {
+	var args = [];
+	var expressions = [];
+	var env = new environment(parentenv);
+	for (var i = 0; i < this.args.length; i++) {
+		env.syms[this.args[i].cleanName()] = null;
+		if (this.args[i].dirty) {
+			var hygienic = '' + quote_prefix + this.args[i].cleanName();
+			env.quotetrans[this.args[i].cleanName()] = hygienic;
+			args.push(new symbol(hygienic, this.args[i].symbols));
+		} else {
+			args.push(this.args[i]);
+		}
+	}
+	for (var i = 0; i < this.expressions.length; i++) {
+		expressions.push(this.expressions[i].makeHygienic(env));
 	}
 	return new lambda(args, expressions);
 };
 lambda.prototype.numArgs = function() {
 lambda.prototype.tpmeth_nodeType = function() {
 	return "lambda";
 };
+lambda.prototype.tpmeth_args = function() {
+	var cur = tplist.tpmeth_empty();
+	for (var idx = this.args.length - 1; idx >= 0; --idx) {
+		cur = tplist['tpmeth_node:withTail'](this.args[idx], cur);
+	}
+	return cur;
+};
+lambda.prototype.tpmeth_expressions = function() {
+	var cur = tplist.tpmeth_empty();
+	for (var idx = this.expressions.length - 1; idx >= 0; --idx) {
+		cur = tplist['tpmeth_node:withTail'](this.expressions[idx], cur);
+	}
+	return cur;
+};
+lambda.prototype['tpmeth_expressions!'] = function(exprs) {
+	var expressions = [];
+	while (!exprs['tpmeth_empty?']().valueOf()) {
+		expressions.push(makeASTNode(exprs.tpmeth_value()));
+		exprs = exprs.tpmeth_tail();
+	}
+	this.expressions = expressions;
+	return this;
+};
+lambda.prototype.tpmeth_addExpression = function(expr) {
+	this.expressions.push(makeASTNode(expr));
+	return this;
+};
 assignment.prototype.eval = function(env) {
 	var val = this.expression.eval(env);
 	env.findSet(this.symbol.name, val);
 	return val;
 };
 	return this;
 };
 assignment.prototype.quote = function(env) {
 	var name = this.symbol.cleanName();
+	var val = env.find(name);
+	var dirty = true;
+	if (val) {
+		var node = makeASTNode(val);
+		if (!(node instanceof symbol)) {
+			throw new Error('Left hand side of assignment expression must be a symbol!');
+		}
+		name = node.cleanName();
+		dirty = node.dirty;
+	}
 	env.syms[name] = null;
-	var hygenic = '' + quote_prefix + name;
+	var sym = new symbol(name, this.symbol.symbols);
-	env.quotetrans[name] = hygenic;
+	sym.dirty = dirty;
-	return new assignment(new symbol(hygenic, this.symbol.symbols), this.expression.quote(env));
+	return new assignment(sym, this.expression.quote(env));
+};
+assignment.prototype.makeHygienic = function(env) {
+	var name = this.symbol.cleanName();
+	env.syms[name] = null;
+	if (this.symbol.dirty) {
+		name = env.quotetrans[name] = '' + quote_prefix + name;
+	}
+	return new assignment(new symbol(name, this.symbol.symbols), this.expression.makeHygienic(env));
 };
 assignment.prototype.tpmeth_nodeType = function() {
 	return "assignment";
 };
+assignment.prototype.tpmeth_symbol = function() {
+	return this.symbol;
+};
+assignment.prototype['tpmeth_symbol!'] = function(val) {
+	this.symbol = makeASTNode(val);
+	return this;
+};
+assignment.prototype.tpmeth_expression = function() {
+	return this.expression;
+};
+assignment.prototype['tpmeth_expression!'] = function(val) {
+	this.expression = makeASTNode(val);
+	return this;
+};