repos/tabletprog: cbackend.js comparison

comparison cbackend.js @ 84:9811040704ac

Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.

author	Mike Pavone <pavone@retrodev.com>
date	Sat, 21 Jul 2012 22:30:21 -0700
parents	7f635666c73d
children	25bc8a5ab41e

comparison

equal deleted inserted replaced

-:fdb9785d2c93
+:9811040704ac
 op.prototype.toC = function(isReceiver) {
 	var optoMeth = {'+': 'ADD_', '-': 'SUB_', '*': 'MUL_', '/': 'DIV_', '%': 'MOD_', '=': 'EQ_', '!=': 'NEQ_', '<': 'LT_', '>': 'GT_', '>=': 'GEQ_', '<=': 'LEQ_', '.': 'CAT_'};
 	var method = optoMeth[this.op];
 	return 'mcall(' + getMethodId(method) + '/* ' + method + ' */, 2, (object *)' + this.left.toC() + ', ' + this.right.toC() + ')\n';
 };
+op.prototype.toCLLExpr = function(vars) {
+	return this.left.toCLLExpr(vars) + (this.op == '=' ? '==' : this.op) + this.right.toCLLExpr(vars);
+};
+op.prototype.toCLines = function(vars, needsreturn) {
+	return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';'];
+};
 function escapeCName(name)
 {
 	if (name == 'self') {
 		return name;
 		}
 		return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, ' + obj + ')';
 	}
 	return getSymbolPrefix(info, this.symbols) + escapeCName(name);
 }
+symbol.prototype.toCTypeName = function() {
+	return this.cleanName();
+};
+symbol.prototype.toCLLExpr = function(vars) {
+	var name = this.cleanName();
+	if (name in vars) {
+		return name;
+	}
+	if (name == 'self') {
+		return 'self';
+	}
+	var info = this.symbols.find(name, false, true);
+	var symbols = this.symbols;
+	while (info && info.type == 'local') {
+		symbols = symbols.parent;
+		info = symbols.find(name, false, true);
+	}
+	if (!info) {
+		return name;
+	}
+	if (info.type == 'toplevel') {
+		return toplevel.moduleVar(name);
+	} else if (info.type == 'self') {
+		if (info.isll || !(info.def instanceof lambda)) {
+			return 'self->' + name;
+		} else {
+			return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, ' + (new symbol('self', this.symbols)).toC() + ')';
+		}
+	}
+	throw new Error('Unsupported reference type ' + info.type + ' for variable ' + name);
+};
+symbol.prototype.toCLines = function(vars, needsreturn) {
+	return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';' ];
+};
 var declaredInts = {};
 intlit.prototype.toC = function() {
 	var str = this.val < 0 ? 'neg_' + (0-this.val).toString() : this.val.toString();
 		toplevelcode += 'obj_int32 int32_' + str + ' = {{&obj_int32_meta, NULL}, ' + this.val.toString() + '};\n';
 		declaredInts[this.val] = true;
 	}
 	return '((object *)&int32_' + str + ')';
 }
+intlit.prototype.toCLLExpr = function(vars) {
+	return this.val.toString();
+};
+intlit.prototype.toCLines = function(vars, needsreturn) {
+	return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';' ];
+};
 floatlit.prototype.toC = function() {
 	return 'make_float(' + this.val.toString() + ')';
 }
+floatlit.prototype.toCLLExpr = function(vars) {
+	return this.val.toString();
+};
+floatlit.prototype.toCLines = function(vars, needsreturn) {
+	return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';' ];
+};
 var declaredStrings = {};
 var nextStringId = 0;
 strlit.prototype.toC = function() {
 		//TODO: get the proper byte length
 		toplevelcode += 'string str_' + nextStringId + ' = {{&string_meta, NULL}, ' + this.val.length + ', ' + this.val.length + ', "' + this.val.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\r', '\\r') + '"};\n';
 		declaredStrings[this.val] = nextStringId++;
 	}
 	return '((object *)&str_' + declaredStrings[this.val] + ')';
-}
+};
+strlit.prototype.toCLLExpr = function(vars) {
+	return '"' + this.val.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\r', '\\r') + '"';
+};
+strlit.prototype.toCLines = function(vars, needsreturn) {
+	return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) +';' ];
+};
 listlit.prototype.toC = function() {
 	var ret = 'make_list(' + this.val.length;
 	for (var i = 0; i < this.val.length; i++) {
 		ret += ', ' + this.val[i].toC();
 		} else if(this.args[0] instanceof symbol) {
 			return this.args[0].name;
 		} else {
 			throw new Error("Unexpected AST type for foreign:");
 		}
+	} else if(name == 'llProperty:withType' || name == 'llProperty:withVars:andCode') {
+		return null;
 	}
 	var args = this.args.slice(0, this.args.length);
 	if (this.receiver) {
 		args.splice(0, 0, this.receiver);
 	}
 		callpart = 'mcall(' + getMethodId(name) + '/* ' + name + ' */';
 	} else {
 		callpart = 'ccall(' + (new symbol(name, this.symbols)).toC();
 	}
 	return callpart + ', ' + args.length + args.join('') + ')';
-}
+};
+funcall.prototype.toCTypeName = function() {
+	switch(this.name)
+	{
+	case 'ptr:':
+	case 'ptr':
+		var receiver = this.receiver ? this.receiver : this.args[0];
+		return receiver.toCTypeName() + ' *';
+		break;
+	default:
+		throw new Error('invalid use of funcall expression where a C type name is expected');
+	}
+};
+funcall.prototype.toCLines = function(vars, needsreturn) {
+	var lines = [];
+	var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
+	var args = this.args.slice(0, this.args.length);
+	if (this.receiver) {
+		args.splice(0, 0, [this.receiver]);
+	}
+	switch(name)
+	{
+	case 'if':
+		lines.push('if (' + this.args[0].toCLLExpr(vars) + ') {');
+		var blines = this.args[1].toCLines(vars, needsreturn);
+		for (var i in blines) {
+			lines.push('\t' + blines[i]);
+		}
+		if (needsreturn) {
+			lines.push('} else {');
+			lines.push('\t return module_false;');
+			lines.push('}');
+		} else {
+			lines.push('}');
+		}
+		break;
+	case 'if:else':
+		lines.push('if (' + this.args[0].toCLLExpr(vars) + ') {');
+		var blines = this.args[1].toCLines(vars, needsreturn);
+		for (var i in blines) {
+			lines.push('\t' + blines[i]);
+		}
+		lines.push('} else {');
+		blines = this.args[2].toCLines(vars, needsreturn);
+		for (var i in blines) {
+			lines.push('\t' + blines[i]);
+		}
+		lines.push('}');
+		break;
+	case 'while:do':
+		if (needsreturn) {
+			throw new Error("while:do can't be last statement in llMessage code block");
+		}
+		lines.push('while (' + this.args[0].toCLLExpr(vars) + ') {');
+		var blines = this.args[1].toCLines(vars);
+		for (var i in blines) {
+			lines.push('\t' + blines[i]);
+		}
+		lines.push('}');
+		break;
+	default:
+		lines.push( (needsreturn ? 'return (object *)' : '') + this.toCLLExpr(vars) + ';');
+	}
+	return lines;
+};
+funcall.prototype.toCLLExpr = function(vars) {
+	var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
+	var args = this.args.slice(0, this.args.length);
+	if (this.receiver) {
+		if(this.args.length == 0) {
+			return this.receiver.toCLLExpr(vars) + '->' + this.name;
+		} else if (this.args.length == 1 && name[name.length-1] == '!') {
+			return this.receiver.toCLLExpr(vars) + '->' + this.name.substr(0, name.length-1) + ' = ' + args[0].toCLLExpr(vars);
+		} else {
+			args.splice(0, 0, this.receiver);
+		}
+	}
+	switch(name)
+	{
+	case 'if':
+	case 'if:else':
+	case 'while:do':
+		throw new Error('if, if:else and while:do not allow in expression context in llMessage block');
+	case 'addr_of':
+		return '&(' + args[0].toCLLExpr(vars) + ')';
+	case 'sizeof':
+		return 'sizeof(' + args[0].toCTypeName() + ')';
+	case 'get':
+		return args[0].toCLLExpr(vars) + '[' + args[1].toCLLExpr(vars) + ']';
+	case 'set':
+		return args[0].toCLLExpr(vars) + '[' + args[1].toCLLExpr(vars) + '] = ' + args[2].toCLLExpr(vars);
+	case 'not':
+		return '!(' + args[0].toCLLExpr(vars) + ')';
+	default:
+		for (var i in args) {
+			args[i] = args[i].toCLLExpr(vars);
+		}
+		return name + '(' + args.join(', ') + ')';
+	}
+};
 function cObject(name) {
 	this.name = name;
 	this.slots = {};
 	this.properties = [];
 	return this.toCInstance();
 }
 var nextobject = 0;
-object.prototype.toC = function() {
+object.prototype.toCObject = function() {
 	var messages = this.messages;
 	var values = [];
-	var imports = []
+	var imports = [];
-	var me = new cObject('object_' + nextobject++);
+	if (!this.name) {
+		this.name = 'object_' + nextobject++;
+	}
+	var me = new cObject(this.name);
 	this.symbols.typename = me.name;
 	if (this.symbols.needsenv) {
 		me.addProperty('env', this.symbols.envVar(), 'struct ' + this.symbols.getEnvType() + ' * ');
 		me.hasenv = true;
 	}
 						throw new Error('Names in import:from statement must be symbols');
 					}
 					importsyms.push(new strlit(el.name));
 				});
 				imports.push({symbols: new listlit(importsyms), src: messages[i].args[1]});
+			} else if(messages[i].name == 'llProperty:withType:' && messages[i].args.length == 2) {
+				me.addProperty(messages[i].args[0].name, null, messages[i].args[1].toCTypeName())
+			} else if(messages[i].name == 'llMessage:withVars:andCode:' && messages[i].args.length == 3) {
+				var msgname = messages[i].args[0].name
+				var rawvars = messages[i].args[1].expressions;
+				var vars = {};
+				for(var v in rawvars) {
+					vars[rawvars[v].symbol.name] = rawvars[v].expression.toCTypeName();
+				}
+				me.addMessage(msgname, {
+					vars: vars,
+					lines: messages[i].args[2].toCLines(vars, true)
+				});
 			} else {
-				throw new Error('Only import and import:from calls allowed in object context');
+				throw new Error('Only import and import:from calls allowed in object context. ' + messages[i].name + 'with ' + messages[i].args.length + ' arguments found instead.');
 			}
 		} else {
 			messages[i].toCObject(me);
 		}
 	}
-	return me.toC();
+	return me;
-}
+};
+object.prototype.toC = function() {
+	return this.toCObject().toC();
+};
 var toplevelcode;
 var forwarddec;
 function addBinaryOp(cobject, opname, cop, objtype)
 	return int32;
 }
 function makeArray()
 {
-	var array = new cObject('array');
+	var arrayfile = toplevel.names['array'];
-	array.addProperty('size', null, 'uint32_t');
+	var ast = parseFile(arrayfile.path + '/' + arrayfile.file);
-	array.addProperty('storage', null, 'uint32_t');
+	ast.name = 'array';
-	array.addProperty('data', null, 'object **');
+	ast.populateSymbols(toplevel);
-	array.addMessage('get', {
+	return ast.toCObject();
-		vars: {index: 'obj_int32 *'},
-		lines: [
-			'index = va_arg(args, obj_int32 *);',
-			'if (index->num >= 0 && index->num < self->size) {',
-			'	return self->data[index->num];',
-			'}',
-			'return ' + toplevel.moduleVar('false') + ';'
-		]
-	});
-	array.addMessage('set', {
-		vars: {index: 'obj_int32 *'},
-		lines: [
-			'index = va_arg(args, obj_int32 *);',
-			'if (index->num >= 0 && index->num < self->size) {',
-			'	self->data[index->num] = va_arg(args, object *);',
-			'}',
-			'return &(self->header);'
-		]
-	});
-	array.addMessage('foreach', {
-		vars: {index: 'obj_int32 *', i: 'int32_t', clos: 'lambda *'},
-		lines: [
-			'clos = va_arg(args, lambda *);',
-			'for (i = 0; i < self->size; i++) {',
-			'	index = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
-			'	index->num = i;',
-			'	ccall(clos, 2, index, self->data[i]);',
-			'}',
-			'return &(self->header);'
-		]
-	});
-	array.addMessage('append', {
-		vars: {tmp: 'object **'},
-		lines: [
-			'if (self->storage == self->size) {',
-			'	self->storage *= 2;',
-			'	tmp = GC_REALLOC(self->data, self->storage * sizeof(object *));',
-			'	if (!tmp) {',
-			'		fputs("Failed to increase array size\\n", stderr);',
-			'		exit(1);',
-			'	}',
-			'	self->data = tmp;',
-			'}',
-			'self->data[self->size++] = va_arg(args, object *);',
-			'return &(self->header);'
-		]
-	});
-	array.addMessage('length', {
-		vars: {intret: 'obj_int32 *'},
-		lines: [
-			'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
-			'intret->num = self->size;',
-			'return &(intret->header);'
-		]
-	});
-	return array;
 }
 function makeString()
 {
 	var string = new cObject('string');
 function processUsedToplevel(toplevel)
 {
 	var alwaysused = ['true', 'false'];
 	var ret = '';
 	var modulenum = 0;
+	var visited = {};
+	for (var i in alwaysused) {
+		toplevel.used[alwaysused[i]] = true;
+	}
 	var newused = Object.keys(toplevel.used);
 	var allused = newused;
-	var visited = {};
-	for (var i in alwaysused) {
-		forwarddec += 'object * ' + toplevel.moduleVar(alwaysused[i]) + ';\n';
-		toplevel.names[alwaysused[i]].populateSymbols(toplevel);
-		visited[alwaysused[i]] = true;
-	}
 	while (newused.length) {
 		for (var i in newused) {
 			debugprint('//---module', newused[i], '--- populate symbols');
 			forwarddec += 'object * ' + toplevel.moduleVar(newused[i]) + ';\n';
 			toplevel.names[newused[i]].populateSymbols(toplevel);
 				newused.push(symbol);
 				allused.push(symbol);
 			}
 		}
 	}
-	for (var i in alwaysused) {
-		allused.push(alwaysused[i]);
-	}
 	for (var i = allused.length-1; i >= 0; i--) {
 		var symbol = allused[i];
-		debugprint('//---module', symbol, '--- compile');
+		debugprint('//---module', symbol, '(' + i +')--- compile');
 		ret += '\t' + toplevel.moduleVar(symbol) + ' = ' + toplevel.names[symbol].toC() + ';\n';
 	}
 	return ret;
 }
 function makeCProg(obj)
 {
+	forwarddec = toplevelcode = '';
 	var builtins = builtinTypes();
-	forwarddec = toplevelcode = '';
 	for (var i in builtins) {
 		forwarddec += builtins[i].toEarlyCDef();
 		toplevelcode += builtins[i].toCDef();
 	}
 	addBuiltinModules(toplevel);
 	this.selftype = typename;
 	return this.toC();
 };
 lambda.prototype.toCModule = function() {
 	return makeCProg(this);
+};
+lambda.prototype.toCLines = function(vars, needsreturn) {
+	var lines = [];
+	for (var i in this.args) {
+		var name = this.args[i].name;
+		if (name[0] == ':') {
+			name = name.substr(1);
+		}
+		if(name != 'self') {
+			lines.push(name + ' = va_arg(args, ' + vars[name] + ');');
+		}
+	}
+	for (var i in this.expressions) {
+		var exprlines = this.expressions[i].toCLines(vars, needsreturn && i == this.expressions.length - 1);
+		for (var j in exprlines) {
+			lines.push('\t' + exprlines[j]);
+		}
+	}
+	return lines;
+}
+lambda.prototype.toCLLExpr = function(vars) {
+	if (this.expressions.length != 1) {
+		throw new Error('lambda in expression context must have a single statement in llMessage block');
+	}
+	return this.expressions[0].toCLLExpr(vars);
 }
 assignment.prototype.toC = function() {
 	debugprint('//assignment', this.symbol.name);
 	var existing = this.symbols.find(this.symbol.name);
 		if (this.expression instanceof object && this.expression.symbols.needsparent) {
 			cobj.addInit('self->' + escapeCName(this.symbol.name) + '->parent = (object *)self;');
 		}
 	}
 };
+assignment.prototype.toCLines = function(vars, needsreturn) {
+	return [(needsreturn ? 'return ' : '') + this.symbol.toCLLExpr(vars) + ' = ' + this.expression.toCLLExpr(vars) + ';']
+};