repos/tabletprog: compiler.js comparison

comparison compiler.js @ 126:a2d2d8e09291

Merge

author	Mike Pavone <pavone@retrodev.com>
date	Mon, 05 Aug 2013 23:37:17 -0700
parents	d715fb3c39ab
children	d6e79885bd3b 18598163e3ef

comparison

equal deleted inserted replaced

-:6f8d868e8da0
+:a2d2d8e09291
 function modulefile(path, file)
 {
 	this.path = path;
 	this.file = file;
+}
+modulefile.prototype.populateSymbols = function (toplevel) {
+	if (!this.ast) {
+		this.ast = parseFile(this.path + '/' + this.file);
+		this.ast.populateSymbols(toplevel);
+	}
+};
+modulefile.prototype.popuplateSymbolsAsync = function(toplevel, whenDone) {
+	if (!this.ast) {
+		var self = this;
+		get(this.path + '/' + this.file, function(data) {
+			self.ast = parser.parse(data.responseText);
+			self.ast.populateSymbols(toplevel);
+			whenDone();
+		});
+	} else {
+		whenDone();
+	}
+};
+function getfileshtml(path, data, names)
+{
+	var fakeEl = newEl("div", {
+		innerHTML: data.response
+	});
+	each(qall('a', fakeEl), function(idx, a) {
+		var tpidx = a.textContent.indexOf('.tp');
+		var modname = a.textContent.substr(0, tpidx);
+		if (tpidx > -1) {
+			names[modname] = new modulefile(path, modname + '.tp');
+		}
+	});
 }
 var toplevel = new topsymbols([]);
 function topsymbols(moduledirs)
 {
 	this.names = null;
 	this.used = {};
 	this.nextmodulenum = 0;
+	this.onready = null;
 	var self = this;
 	if (typeof window === "object") {
-		get('/src/', function(data) {
+		get('/modules/', function(data) {
-			self.names = {};
+			var names = {}
-			var fakeEl = newEl("div", {
+			getfileshtml('/modules', data, names);
-				innerHTML: data.response
+			get('/src/', function(data) {
-			});
+				getfileshtml('/src', data, names);
-			each(qall('a', fakeEl), function(idx, a) {
+				self.names = names;
-				var tpidx = a.textContent.indexOf('.tp');
+				if (self.onready) {
-				if (tpidx > -1) {
+					self.onready();
-					self.names[a.textContent.substr(0, tpidx)] = true;
 				}
 			});
 		});
 	} else {
 		this.names = {};
 			type: 'toplevel',
 			def: this.names[name]
 		};
 	}
 	return null;
-}
+};
 topsymbols.prototype.getEnvType = function() {
 	return 'void';
-}
+};
 topsymbols.prototype.moduleVar = function(name) {
 	if (!(name in this.names)) {
 		throw new Error('symbol ' + name + ' not found at toplevel');
 	}
 	if (name == 'true' || name == 'false') {
 	}
 	if (!this.names[name].modulevar) {
 		this.names[name].modulevar = 'module_' + this.nextmodulenum++
 	}
 	return this.names[name].modulevar;
-}
+};
+topsymbols.prototype.onReady = function(fun) {
+	if (this.names) {
+		fun();
+		return;
+	}
+	if (!this.onready) {
+		this.onready = fun;
+	} else {
+		var oldready = this.onready;
+		this.onready = function() {
+			oldready();
+			fun();
+		};
+	}
+};
 function osymbols(parent)
 {
 	this.parent = parent;
 	this.names = {};
+	this.llnames = {};
 	this.needsenv = false;
 	this.typename = null;
 	this.needsparent = false;
 }
-osymbols.prototype.find = function(name, nestedcall) {
+osymbols.prototype.find = function(name, nestedcall, allowll) {
 	debugprint('//osymbols.find', name + ', exists?:', name in this.names, ', nested?:', nestedcall);
 	if (name in this.names) {
 		if (this.names[name] instanceof funcall && this.names[name].name == 'foreign:') {
 			return {
 				type: 'foreign',
 				def: this.names[name]
 			};
 		}
 		var ret = {
 			type: 'self',
+			isll: false,
 			def: this.names[name],
 			selftype: this.typename
 		};
+	} else if(allowll && name in this.llnames) {
+		return {
+			type: 'self',
+			isll: true,
+			selftype: this.typename
+		};
 	} else if(this.parent) {
-		var ret = this.parent.find(name, nestedcall);
+		var ret = this.parent.find(name, nestedcall, allowll);
 		if (ret) {
 			if(ret.type == 'self') {
 				ret.type = 'parent';
 				ret.depth = 1;
 				this.needsparent = true;
 	return ret;
 };
 osymbols.prototype.defineMsg = function(name, def) {
 	this.names[name] = def;
 }
+osymbols.prototype.defineLLProperty = function(name) {
+	this.llnames[name] = true;
+}
 osymbols.prototype.parentObject = function() {
 	if (!this.parent) {
 		return 'null';
 	}
 	return 'this';
 	this.needsSelfVar = false;
 	this.passthruenv = false;
 	this.envtype = 'void';
 	this.needsParentEnv = false;
 }
-lsymbols.prototype.find = function(name, nestedcall) {
+lsymbols.prototype.find = function(name, nestedcall, allowll) {
 	debugprint('//lsymbols.find', name + ', exists?:', name in this.names, ', nested?:', nestedcall);
 	if (name in this.names) {
 		if (this.names[name] instanceof funcall && this.names[name].name == 'foreign:') {
 			var ret = {
 				type: 'foreign',
 					isdeclared: (name in this.declared)
 				};
 			}
 		}
 	} else if(this.parent) {
-		var ret = this.parent.find(name, true);
+		var ret = this.parent.find(name, true, allowll);
 		if (ret) {
 			if (ret.type == 'closedover') {
 				ret.type = 'upvar';
 				ret.depth = 0;
 			}
 var mainModule;
 function toobj(val)
 {
-	switch(typeof val)
+	return (typeof val == "boolean") ? (val ? module_true : module_false) : val;
-	{
-	case 'boolean':
-		if(val) {
-			return mainModule.strue;
-		} else {
-			return mainModule.sfalse;
-		}
-	case 'number':
-		return mainModule.snumber(val);
-	}
-	throw new Error("can't make val into object");
 }
 op.prototype.populateSymbols = function(symbols, isReceiver) {
 	this.left.populateSymbols(symbols);
+	if (this.op == '&&' || this.op == '||') {
+		//&& and || are syntactic sugar for if and ifnot with
+		//the second argument transformed into a lambda to
+		//achieve short-circuit evalutation
+		this.right = new lambda([], [this.right]);
+	}
 	this.right.populateSymbols(symbols);
 };
 symbol.prototype.populateSymbols = function(symbols) {
 	this.symbols = symbols;
 		this.val[i].populateSymbols(symbols);
 	}
 }
 funcall.prototype.populateSymbols = function(symbols) {
+	var isll = false;
 	if (this.name == 'foreign:') {
 		if ((this.args[0] instanceof lambda) || (this.args[0] instanceof object) || (this.args[0] instanceof symbol)) {
 			return;
 		} else {
 			throw new Error("Unexpected AST type for foreign:");
 		}
+	} else if (this.name == 'llProperty:withType:') {
+		if (this.args[0] instanceof symbol) {
+			if ((this.args[1] instanceof symbol) || (this.args[1] instanceof funcall)) {
+				symbols.defineLLProperty(this.args[0].name);
+				return;
+			} else {
+				throw new Error("Second argument to llProperty:withType: must be a symbol or funcall");
+			}
+		} else {
+			throw new Error("First argument to llProperty:withType: must be a symbol");
+		}
+	} else if (this.name == 'llMessage:withVars:andCode:') {
+		if (this.args[0] instanceof symbol) {
+			if (this.args[1] instanceof lambda) {
+				if (this.args[2] instanceof lambda) {
+					symbols.defineMsg(this.args[0].name, this.args[2]);
+					isll = true;
+				} else {
+					throw new Error("Third argument to llMessage:withVars:andCode: must be a lambda");
+				}
+			} else {
+				throw new Error("Second argument to llMessage:withVars:andCode: must be a lambda");
+			}
+		} else {
+			throw new Error("First argument to llMessage:withVars:andCode: must be a symbol");
+		}
 	}
 	this.symbols = symbols;
 	var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
 	var funinfo = symbols.find(name);
 	if (funinfo && (funinfo.type == 'self' || funinfo.type == 'parent')) {
 		symbols.find('self');
 	}
 	for (var i in this.args) {
-		this.args[i].populateSymbols(symbols);
+		this.args[i].populateSymbols(symbols, undefined, isll);
 	}
 	if (this.receiver) {
-		this.receiver.populateSymbols(symbols);
+		this.receiver.populateSymbols(symbols, undefined, isll);
 	}
 }
 funcall.prototype.populateSymbolsObject = function(symbols) {
-	this.populateSymbols(symbols.parent);
+	this.populateSymbols(symbols);
 }
 object.prototype.populateSymbols = function(symbols) {
-	symbols = new osymbols(symbols);
+	var symbols = new osymbols(symbols);
 	for (var i in this.messages) {
 		this.messages[i].populateSymbolsObject(symbols);
 	}
 	this.symbols = symbols;
 }
+var lambdanum = 0;
-lambda.prototype.populateSymbols = function(symbols, isobject) {
+lambda.prototype.populateSymbols = function(symbols, isobject, isll) {
+	if (!isll) {
+		this.name = 'lambda_' + lambdanum++;
+	}
 	var args = this.args ? this.args.slice(0, this.args.length) : [];
 	var exprs = this.expressions;
 	var symbols = new lsymbols(symbols);
 	for (var i in args) {
 		symbols.defineVar(args[i].cleanName(), null);
 function getter(fun)
 {
 	this.fun = fun;
 }
 getter.prototype.args = [new symbol('self')];