repos/tabletprog: cbackend.js comparison

comparison cbackend.js @ 155:9de2572a34a7

Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects.

author	Mike Pavone <pavone@retrodev.com>
date	Sat, 10 Aug 2013 14:19:38 -0700
parents	d8f92ebf1ff6
children	d6e79885bd3b

comparison

equal deleted inserted replaced

-:6e579a75a0a9
+:9de2572a34a7
 var mainModule;
 var modules = {};
 var nextmethodId = 0;
 var methodIds = {};
+var assignNames;
 function getMethodId(methodName)
 {
 	if (!(methodName in methodIds)) {
 		methodIds[methodName] = nextmethodId++;
 };
 var declaredInts = {};
 intlit.prototype.toC = function() {
-	var intType = 'int' + this.bits;
+	var intType = (this.unsigned ? 'u' : '') + 'int' + this.bits;
 	var str =  intType + '_' + (this.val < 0 ? 'neg_' + (0-this.val).toString() : this.val.toString());
 	if (!(str in declaredInts)) {
 		toplevelcode += 'obj_' + intType + ' ' + str + ' = {{&obj_' + intType + '_meta, NULL}, ' + this.val.toString() + '};\n';
 		declaredInts[str] = true;
 	}
 			'return ' + toplevel.moduleVar('false') + ';',
 		]
 	});
 }
-function makeInt(bits)
+function makeInt(bits, unsigned)
 {
-	var typename = 'obj_int' + bits;
+	var typename = 'obj_' + (unsigned ? 'u' : '') + 'int' + bits;
 	var intObj = new cObject(typename);
-	intObj.addProperty('num', null, 'int' + bits +'_t');
+	intObj.addProperty('num', null, (unsigned ? 'u' : '') + 'int' + bits +'_t');
 	addBinaryOp(intObj, 'ADD_', '+', typename);
 	addBinaryOp(intObj, 'SUB_', '-', typename);
 	addBinaryOp(intObj, 'MUL_', '*', typename);
 	addBinaryOp(intObj, 'DIV_', '/', typename);
 	addBinaryOp(intObj, 'MOD_', '%', typename);
 	intObj.addMessage('string', {
 		vars: {str: 'string *'},
 		lines: [
 			'str = (string *)make_object(&string_meta, NULL, 0);',
 			'str->data = GC_MALLOC(' + (bits == 64 ? 21 : 12) + ');',
-			'sprintf(str->data, "%' + (bits == 64 ? 'l' : '') +'d", self->num);',
+			'sprintf(str->data, "%' + (bits == 64 ? 'l' : '') + (unsigned ? 'u' : 'd') + '", self->num);',
 			'str->len = str->bytes = strlen(str->data);',
 			'return &(str->header);'
 		]
 	});
 	//7FFFFFFFFFFFFFFF
 		vars: {},
 		lines: [
 			'return &(self->header);'
 		]
 	});
+	var sizes = [8, 16, 32, 64];
+	var destunsigned = [false, true];
+	for (var i = 0; i < sizes.length; i++) {
+		size = sizes[i];
+		for (var j = 0; j < destunsigned.length; j++) {
+			uns = destunsigned[j];
+			if (uns == unsigned && size == bits) {
+				intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
+					vars: {},
+					lines: [
+						'return &(self->header);'
+					]
+				});
+			} else {
+				var retType = 'obj_' + (uns ? 'u' : '') + 'int' + size;
+				intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
+					vars: {ret: retType + ' *'},
+					lines: [
+						'ret = ('+retType+' *)make_object(&' + retType +'_meta, NULL, 0);',
+						'ret->num = self->num;',
+						'return &(ret->header);'
+					]
+				});
+			}
+		}
+	}
 	return intObj;
 }
 function makeArray()
 {
 	return clos;
 }
 function builtinTypes()
 {
-	return [makeInt(64), makeInt(32), makeInt(16), makeInt(8), makeArray(), makeString(), makelambda()];
+	return [makeInt(64, false), makeInt(32, false), makeInt(16, false), makeInt(8, false),
+	        makeInt(64, true) , makeInt(32, true),  makeInt(16, true),  makeInt(8, true),
+	        makeArray(), makeString(), makelambda()];
 }
 function addBuiltinModules(toplevel)
 {
 	var os = new cObject('mod_obj_os');
 	}
 	for (var i = allused.length-1; i >= 0; i--) {
 		var symbol = allused[i];
 		debugprint('//---module', symbol, '(' + i +')--- compile');
+		assignNames.push(symbol);
 		ret += '\t' + toplevel.moduleVar(symbol) + ' = ' + toplevel.names[symbol].toC() + ';\n';
+		assignNames.pop();
 	}
 	return ret;
 }
 function makeCProg(obj)
 {
 	forwarddec = toplevelcode = '';
+	assignNames = [];
 	var builtins = builtinTypes();
 	for (var i in builtins) {
 		forwarddec += builtins[i].toEarlyCDef();
 		toplevelcode += builtins[i].toCDef();
 	}
 }
 lambda.prototype.toC = function() {
 	var args = this.args ? this.args.slice(0, this.args.length) : [];
 	var exprs = this.expressions;
-	debugprint('//', this.name);
+	var assignPath = assignNames.join('<-');
+	debugprint('//', this.name, assignPath);
+	var addedTypeDef = false;
 	if (Object.keys(this.symbols.closedover).length) {
 		this.symbols.envtype = this.name + '_env';
 		forwarddec += 'typedef struct ' + this.symbols.envtype + '  ' + this.symbols.envtype + ';\n'
+		var addedTypeDef = true;
 	}
 	if (this.selftype) {
 		this.symbols.defineVar('self', this.selftype);
 		if (args[0] && args[0].cleanName() == 'self') {
 			args.splice(0, 1);
 	if (exprs.length) {
 		exprs[exprs.length-1] = 'return (object *)(' + exprs[exprs.length-1] + ');';
 	}
 	if (Object.keys(this.symbols.closedover).length) {
+		if (!addedTypeDef) {
+			for (var key in this.symbols.closedover) {
+				print(key, ": ", this.symbols.closedover[key]);
+			}
+			throw new Error('this.symbols.closedover is not empty, but it was when compilation of "' + assignPaths + '" started');
+		}
 		forwarddec += 'struct ' + this.name + '_env {\n';
 		if (this.symbols.needsParentEnv) {
 			forwarddec += '\tstruct ' + this.symbols.parentEnvType() + ' * parent;\n';
 		}
 		for (var varname in this.symbols.closedover) {
 	} else {
 		var myenvinit = '';
 	}
 	forwarddec += 'object *' + this.name + ' (' + this.symbols.parentEnvType() + ' * env, uint32_t num_args, ...);\n';
+	toplevelcode += '//' + assignPath + "\n";
 	toplevelcode +=  'object * ' + this.name + ' ( ' + this.symbols.parentEnvType() + ' * env, uint32_t num_args, ...) {\n\tva_list args;\n' + myenvinit + '\tva_start(args, num_args);\n';
 	if (this.selftype) {
 		var selfvar = (new symbol('self', this.symbols)).toC();
 		if (selfvar == 'self') {
 			toplevelcode += '\t' + this.selftype + ' * self = va_arg(args, ' + this.selftype + ' *);\n';
 assignment.prototype.toC = function() {
 	debugprint('//assignment', this.symbol.name);
 	var existing = this.symbols.find(this.symbol.name);
 	var prefix = '';
+	assignNames.push(this.symbol.name);
 	var val = this.expression.toC();
+	assignNames.pop(this.symbol.name);
 	if (val === null) {
 		return null;
 	}
 	if (existing.type == 'local' && !existing.isdeclared) {
 		prefix = 'object *';