repos/tabletprog: cbackend.js comparison

comparison cbackend.js @ 171:869399ff7faa

Merge

author	Mike Pavone <pavone@retrodev.com>
date	Tue, 13 Aug 2013 22:01:00 -0700
parents	18598163e3ef 224071eed9dd
children	8d466c5a7dff

comparison

equal deleted inserted replaced

-:18598163e3ef
+:869399ff7faa
 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;
+				var retName = 'ret' + (uns ? 'u' : '') + size;
+				var vars = {};
+				vars[retName] = retType + ' *';
+				intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
+					vars: vars,
+					lines: [
+						retName + ' = ('+retType+' *)make_object(&' + retType +'_meta, NULL, 0);',
+						retName + '->num = self->num;',
+						'return &(' + retName + '->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');
 	os.addInclude('<sys/stat.h>');
 	os.addInclude('<fcntl.h>');
+	os.addInclude('<stdlib.h>');
+	os.addInclude('<time.h>');
+	os.addInclude('<unistd.h>');
 	os.addMessage('write', {
 		vars: {str: 'string *', intret: 'obj_int32 *', filedes: 'obj_int32 *'},
 		lines: [
 			'filedes = va_arg(args, obj_int32 *);',
 			'str = va_arg(args, string *);',
 		lines: [
 			'filedes = va_arg(args, obj_int32 *);',
 			'size = va_arg(args, obj_int32 *);',
 			'str = (string *)make_object(&string_meta, NULL, 0);',
 			'str->data = GC_MALLOC_ATOMIC(size->num + 1);',
-			'str->length = str->bytes = read(filedes->num, str->data, size->num);',
+			'str->len = str->bytes = read(filedes->num, str->data, size->num);',
-			'if (str->bytes < 0) { str->bytes = str->length = 0; }',
+			'if (str->bytes < 0) { str->bytes = str->len = 0; }',
 			'str->data[str->bytes] = 0;',
 			'return &(str->header);'
 		]
 	});
 	os.addMessage('open', {
 			'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
 			'intret->num = O_TRUNC;',
 			'return &(intret->header);'
 		]
 	});
+	os.addMessage('rand', {
+		vars: {intret: 'obj_int32 *'},
+		lines: [
+			'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
+			'intret->num = rand();',
+			'return &(intret->header);'
+		]
+	});
+	os.addMessage('rand64', {
+		vars: {intret64: 'obj_int64 *'},
+		lines: [
+			'intret64 = (obj_int64 *)make_object(&obj_int64_meta, NULL, 0);',
+			'intret64->num = (((int64_t)rand()) << 32 ) | rand();',
+			'return &(intret64->header);'
+		]
+	});
+	os.addMessage('srand', {
+		vars: {oseed: 'object *', seed: 'obj_int32 *'},
+		lines: [
+			'oseed = va_arg(args, object *);',
+			'seed = mcall(' + getMethodId("int32") + ', 1, oseed);',
+			'srand(seed->num);',
+			'return &(seed->header);'
+		]
+	});
+	os.addMessage('time', {
+		vars: {intret64: 'obj_int64 *'},
+		lines: [
+			'intret64 = (obj_int64 *)make_object(&obj_int64_meta, NULL, 0);',
+			'intret64->num = time(NULL);',
+			'return &(intret64->header);'
+		]
+	});
+	os.addMessage('sleep', {
+		vars: {osecs: 'object *', secs: 'obj_int32 *', intret: 'obj_int32 *'},
+		lines: [
+			'osecs = va_arg(args, object *);',
+			'secs = mcall(' + getMethodId("int32") + ', 1, osecs);',
+			'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
+			'intret->num = sleep(secs->num);',
+			'return &(intret->header);'
+		]
+	});
 	toplevel.names['os'] = os;
 }
 modulefile.prototype.toC = function(){
 	return this.ast.toCModuleInstance();
 	}
 	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 ' + this.name + ' "' + assignPath + '" 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 *';
 	}
 	return prefix + this.symbol.toC() + ' = ' + val;
 };
 assignment.prototype.toCObject = function(cobj) {
 	debugprint('//message definition', this.symbol.name);
+	assignNames.push('#' + this.symbol.name);
 	if (this.expression.toCObject) {
 		var val = this.expression.toCObject(cobj.name);
 	} else {
 		var val = this.expression.toC();
 	}
+	assignNames.pop();
 	if (val === null) {
 		return;
 	}
 	if (this.expression instanceof lambda) {
 		var params = ['((object *)self)'];