repos/tabletprog: cbackend.js annotate

annotate cbackend.js @ 265:d6a4c9e7716e

Remove remapping of most operators

author	Michael Pavone <pavone@retrodev.com>
date	Mon, 14 Jul 2014 19:03:46 -0700
parents	2557ce4e671f
children	75dc7161c1ca

rev	line source
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1 var mainModule;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	2 var modules = {};
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	3
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	4 var methodIds = {};
182 ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	5 var methodNames = [];
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	6 var assignNames;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	7 function getMethodId(methodName)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	8 {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	9 if (!(methodName in methodIds)) {
182 ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	10 methodIds[methodName] = methodNames.length;
ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	11 methodNames.push(methodName);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	12 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	13 return methodIds[methodName];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	14 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	15
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	16 function getOpMethodName(opname)
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	17 {
265 d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	18 var optoMeth = {'&&':'if', '\|\|':'ifnot'};
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	19 if (opname in optoMeth) {
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	20 return optoMeth[opname];
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	21 } else {
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	22 return opname;
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	23 }
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	24 }
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	25
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	26 op.prototype.toC = function(isReceiver) {
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	27 var method = getOpMethodName(this.op);
170 18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	28 if (this.op == '\|') {
18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	29 return 'mcall(' + getMethodId(method) + '/* operator ' + method + ' /, 2, (object )' + this.right.toC() + ', ' + this.left.toC() + ')\n';
18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	30 } else {
18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	31 return 'mcall(' + getMethodId(method) + '/* operator ' + method + ' /, 2, (object )' + this.left.toC() + ', ' + this.right.toC() + ')\n';
18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	32 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	33 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	34 op.prototype.toCLLExpr = function(vars) {
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	35 var opmap = {'=': '==', 'xor': '^', 'or': '\|', 'and': '&'};
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	36 return this.left.toCLLExpr(vars) + (this.op in opmap ? opmap[this.op] : this.op) + this.right.toCLLExpr(vars);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	37 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	38 op.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	39 return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';'];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	40 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	41
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	42
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	43 function escapeCName(name)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	44 {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	45 if (name == 'self') {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	46 return name;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	47 }
172 8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	48 name = name.replace(/_/g, "UN_").replace(/:/g, "CN_").replace(/!/g, "EX_").replace(/\?/g, 'QS_').replace(/@/g, 'AT_');
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	49 name = 'tp_' + name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	50 return name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	51 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	52
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	53 function getSymbolPrefix(info, symbols)
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	54 {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	55 var pre = '';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	56 switch(info.type) {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	57 case 'self':
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	58
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	59 pre = (new symbol('self', symbols)).toC() + '->';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	60 break;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	61 case 'parent':
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	62 pre = (new symbol('self', symbols)).toC() + '->header.';
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	63 for (var i = 0; i < info.depth; ++i) {
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	64 pre += (i ? '->' : '') + 'parent';
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	65 }
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	66 pre = '((' + info.selftype + ' *)' + pre + ')->';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	67 break;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	68 case 'upvar':
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	69 pre = 'env->';
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	70 for (var i = info.startdepth; i < info.depth; ++i) {
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	71 pre += 'parent->';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	72 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	73 break;
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	74 case 'recupvar':
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	75 if (info.subtype == 'object') {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	76 pre = 'self->env->';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	77 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	78 //TODO: fill this case in if necessary
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	79 }
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	80 pre += getSymbolPrefix(info.parent);
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	81 case 'closedover':
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	82 pre = 'myenv->';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	83 }
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	84 return pre;
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	85 }
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	86
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	87 symbol.prototype.toC = function() {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	88 var name = this.cleanName();
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	89 var info = this.symbols.find(name);
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	90 if (!info) {
172 8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	91 throw new Error('symbol ' + name + ' not found in ' + assignNames.join('<-'));
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	92 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	93 if (info.type == 'toplevel') {
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	94 return toplevel.moduleVar(name);
69 ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	95 } else if (info.type == 'self' && info.def instanceof lambda) {
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	96 return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, ' + (new symbol('self', this.symbols)).toC() + ')';
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	97 } else if (info.type == 'parent' && info.def instanceof lambda) {
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	98 var obj = (new symbol('self', this.symbols)).toC() + '->header.';
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	99 for (var i = 0; i < info.depth; ++i) {
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	100 obj += (i ? '->' : '') + 'parent';
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	101 }
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	102 return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, ' + obj + ')';
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	103 }
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	104 return getSymbolPrefix(info, this.symbols) + escapeCName(name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	105 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	106 symbol.prototype.toCTypeName = function() {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	107 return this.cleanName();
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	108 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	109 symbol.prototype.toCLLExpr = function(vars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	110 var name = this.cleanName();
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	111 if (name in vars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	112 return name;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	113 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	114 if (name == 'self') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	115 return 'self';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	116 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	117 var info = this.symbols.find(name, false, true);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	118 var symbols = this.symbols;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	119 while (info && info.type == 'local') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	120 symbols = symbols.parent;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	121 info = symbols.find(name, false, true);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	122 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	123 if (!info) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	124 return name;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	125 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	126 if (info.type == 'toplevel') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	127 return toplevel.moduleVar(name);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	128 } else if (info.type == 'self') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	129 if (info.isll \|\| !(info.def instanceof lambda)) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	130 return 'self->' + name;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	131 } else {
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	132 return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, self)';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	133 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	134 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	135 throw new Error('Unsupported reference type ' + info.type + ' for variable ' + name);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	136 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	137 symbol.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	138 return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';' ];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	139 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	140
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	141 var declaredInts = {};
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	142
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	143 intlit.prototype.toC = function() {
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	144 var intType = (this.unsigned ? 'u' : '') + 'int' + this.bits;
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	145 var str = intType + '_' + (this.val < 0 ? 'neg_' + (0-this.val).toString() : this.val.toString());
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	146 if (!(str in declaredInts)) {
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	147 toplevelcode += 'obj_' + intType + ' ' + str + ' = {{&obj_' + intType + '_meta, NULL}, ' + this.val.toString() + '};\n';
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	148 declaredInts[str] = true;
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	149 }
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	150 return '((object *)&' + str + ')';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	151 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	152 intlit.prototype.toCLLExpr = function(vars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	153 return this.val.toString();
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	154 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	155 intlit.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	156 return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';' ];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	157 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	158
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	159 floatlit.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	160 return 'make_float(' + this.val.toString() + ')';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	161 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	162 floatlit.prototype.toCLLExpr = function(vars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	163 return this.val.toString();
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	164 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	165 floatlit.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	166 return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) + ';' ];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	167 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	168
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	169 var declaredStrings = {};
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	170 var nextStringId = 0;
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	171
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	172 strlit.prototype.toC = function() {
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	173 if (!(this.val in declaredStrings)) {
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	174 //TODO: get the proper byte length
146 d8f92ebf1ff6 Fix string literal escaping to allow more than one of each type of escaped character Mike Pavone <pavone@retrodev.com> parents: 143 diff changeset	175 toplevelcode += 'string str_' + nextStringId + ' = {{&string_meta, NULL}, ' + this.val.length + ', ' + this.val.length + ', "' + this.val.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r') + '"};\n';
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	176 declaredStrings[this.val] = nextStringId++;
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	177 }
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	178 return '((object *)&str_' + declaredStrings[this.val] + ')';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	179 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	180 strlit.prototype.toCLLExpr = function(vars) {
146 d8f92ebf1ff6 Fix string literal escaping to allow more than one of each type of escaped character Mike Pavone <pavone@retrodev.com> parents: 143 diff changeset	181 return '"' + this.val.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r') + '"';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	182 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	183 strlit.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	184 return [ (needsreturn ? 'return (object *)' : '' ) + this.toCLLExpr(vars) +';' ];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	185 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	186
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	187 listlit.prototype.toC = function() {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	188 var ret = 'make_list(' + this.val.length;
170 18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	189 for (var i = this.val.length-1; i >= 0; i--) {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	190 ret += ', ' + this.val[i].toC();
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	191 }
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	192 return ret + ')';
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	193 }
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	194
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	195 arraylit.prototype.toC = function() {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	196 var ret = 'make_array(' + this.val.length;
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	197 for (var i = 0; i < this.val.length; i++) {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	198 ret += ', ' + this.val[i].toC();
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	199 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	200 return ret + ')';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	201 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	202
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	203 funcall.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	204 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	205 if (name == 'foreign') {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	206 if ((this.args[0] instanceof lambda) \|\| (this.args[0] instanceof object)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	207 return null;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	208 } else if(this.args[0] instanceof symbol) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	209 return this.args[0].name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	210 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	211 throw new Error("Unexpected AST type for foreign:");
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	212 }
211 53cd9c3bcf96 Don't compile quote expressions in C backend for now Mike Pavone <pavone@retrodev.com> parents: 182 diff changeset	213 } else if(name == 'llProperty:withType' \|\| name == 'llProperty:withVars:andCode' \|\| name == 'quote') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	214 return null;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	215 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	216 var args = this.args.slice(0, this.args.length);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	217 if (this.receiver) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	218 args.splice(0, 0, this.receiver);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	219 }
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	220 var method = false;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	221 var funinfo = this.symbols.find(name);
72 ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	222 var start = 0;
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	223 if (!funinfo \|\| funinfo.def instanceof setter \|\| funinfo.type == 'toplevel') {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	224 method = true;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	225 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	226 switch(funinfo.type)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	227 {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	228 case 'self':
72 ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	229 case 'parent':
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	230 var defargs = funinfo.def.args.length;
241 c50f77de41d1 Small fix to call to method implemented on current object check Mike Pavone <pavone@retrodev.com> parents: 211 diff changeset	231 if (!defargs \|\| funinfo.def.args[0].cleanName() != 'self') {
72 ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	232 defargs ++
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	233 }
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	234 if (args.length < defargs) {
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	235 if (funinfo.type == 'self') {
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	236 args.splice(0, 0, new symbol('self', this.symbols));
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	237 } else {
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	238 var obj = (new symbol('self', this.symbols)).toC() + '->header.';
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	239 for (var i = 0; i < funinfo.depth; ++i) {
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	240 obj += (i ? '->' : '') + 'parent';
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	241 }
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	242 args.splice(0, 0, ', ' + obj);
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	243 start = 1;
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	244 }
137 101fa04ee9e1 Fix calling methods on objects that are not self when self implements the method being called Mike Pavone <pavone@retrodev.com> parents: 135 diff changeset	245 } else if(!(args[0] instanceof symbol) \|\| args[0].name != 'self') {
101fa04ee9e1 Fix calling methods on objects that are not self when self implements the method being called Mike Pavone <pavone@retrodev.com> parents: 135 diff changeset	246 funinfo = null;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	247 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	248 method = true;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	249 break;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	250 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	251 }
72 ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	252 for (var i = start; i < args.length; i++) {
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	253 args[i] = ', ' + (!i && method ? '(object *)(' : '') + args[i].toC() + (!i && method ? ')' : '');
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	254 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	255 var callpart;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	256 if (method) {
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	257 if (funinfo && funinfo.type == 'self' && funinfo.def.name) {
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	258 callpart = funinfo.def.name + '(' + (funinfo.def.symbols.parent.needsenv ? (new symbol('self', this.symbols)).toC() + '->env' : 'NULL' );
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	259 } else {
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	260 callpart = 'mcall(' + getMethodId(name) + '/* ' + name + ' */';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	261 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	262 } else {
172 8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	263 var closVar = (new symbol(name, this.symbols)).toC();
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	264 callpart = '((lambda )' + closVar + ')->func(((lambda )' + closVar + ')->env';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	265 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	266 return callpart + ', ' + args.length + args.join('') + ')';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	267 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	268 funcall.prototype.toCTypeName = function() {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	269 switch(this.name)
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	270 {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	271 case 'ptr:':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	272 case 'ptr':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	273 var receiver = this.receiver ? this.receiver : this.args[0];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	274 return receiver.toCTypeName() + ' *';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	275 break;
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	276 case 'struct:':
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	277 case 'struct':
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	278 var receiver = this.receiver ? this.receiver : this.args[0];
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	279 return 'struct ' + receiver.toCTypeName();
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	280 break;
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	281 case 'funptr:':
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	282 case 'funptr':
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	283 var rettype;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	284 var firstArg;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	285 if (this.receiver) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	286 rettype = this.receiver;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	287 firstArg = 0;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	288 } else {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	289 rettype = this.args[0];
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	290 firstArg = 1;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	291 }
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	292 var argtypes = '';
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	293 for (var i = firstArg; i < this.args.length; i++) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	294 if (argtypes) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	295 argtypes += ', '
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	296 }
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	297 argtypes += this.args[i].toCTypeName();
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	298 }
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	299 return [rettype.toCTypeName() + '(*', ')(' + argtypes + ')'];
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	300 break;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	301 default:
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	302 throw new Error('invalid use of funcall expression where a C type name is expected');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	303 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	304 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	305 funcall.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	306 var lines = [];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	307 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	308 var args = this.args.slice(0, this.args.length);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	309 if (this.receiver) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	310 args.splice(0, 0, [this.receiver]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	311 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	312 switch(name)
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	313 {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	314 case 'if':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	315 lines.push('if (' + this.args[0].toCLLExpr(vars) + ') {');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	316 var blines = this.args[1].toCLines(vars, needsreturn);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	317 for (var i in blines) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	318 lines.push('\t' + blines[i]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	319 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	320 if (needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	321 lines.push('} else {');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	322 lines.push('\t return module_false;');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	323 lines.push('}');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	324 } else {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	325 lines.push('}');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	326 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	327 break;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	328 case 'if:else':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	329 lines.push('if (' + this.args[0].toCLLExpr(vars) + ') {');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	330 var blines = this.args[1].toCLines(vars, needsreturn);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	331 for (var i in blines) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	332 lines.push('\t' + blines[i]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	333 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	334 lines.push('} else {');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	335 blines = this.args[2].toCLines(vars, needsreturn);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	336 for (var i in blines) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	337 lines.push('\t' + blines[i]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	338 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	339 lines.push('}');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	340 break;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	341 case 'while:do':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	342 if (needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	343 throw new Error("while:do can't be last statement in llMessage code block");
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	344 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	345 lines.push('while (' + this.args[0].toCLLExpr(vars) + ') {');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	346 var blines = this.args[1].toCLines(vars);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	347 for (var i in blines) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	348 lines.push('\t' + blines[i]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	349 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	350 lines.push('}');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	351 break;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	352 default:
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	353 lines.push( (needsreturn ? 'return (object *)' : '') + this.toCLLExpr(vars) + ';');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	354 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	355 return lines;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	356 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	357
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	358 funcall.prototype.toCLLExpr = function(vars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	359 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	360 var args = this.args.slice(0, this.args.length);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	361 if (this.receiver) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	362 if(this.args.length == 0) {
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	363 if (this.receiver instanceof symbol && this.receiver.name in vars && vars[this.receiver.name].substr(-1) != "*") {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	364 return this.receiver.toCLLExpr(vars) + '.' + this.name;
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	365 } else {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	366 return this.receiver.toCLLExpr(vars) + '->' + this.name;
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	367 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	368 } else if (this.args.length == 1 && name[name.length-1] == '!') {
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	369 if (this.receiver instanceof symbol && this.receiver.name in vars && vars[this.receiver.name].substr(-1) != "*") {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	370 return this.receiver.toCLLExpr(vars) + '.' + this.name.substr(0, name.length-1) + ' = ' + args[0].toCLLExpr(vars);
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	371 } else {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	372 return this.receiver.toCLLExpr(vars) + '->' + this.name.substr(0, name.length-1) + ' = ' + args[0].toCLLExpr(vars);
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	373 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	374 } else {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	375 args.splice(0, 0, this.receiver);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	376 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	377 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	378 switch(name)
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	379 {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	380 case 'if':
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	381 return '((' + args[0].toCLLExpr(vars) + ') ? (' + args[1].toCLLExpr(vars) + ') : 0)';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	382 case 'if:else':
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	383 return '((' + args[0].toCLLExpr(vars) + ') ? (' + args[1].toCLLExpr(vars) + ') : (' + args[2].toCLLExpr(vars) + '))';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	384 case 'while:do':
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	385 throw new Error('while:do not allowed in expression context in llMessage block');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	386 case 'addr_of':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	387 return '&(' + args[0].toCLLExpr(vars) + ')';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	388 case 'sizeof':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	389 return 'sizeof(' + args[0].toCTypeName() + ')';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	390 case 'get':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	391 return args[0].toCLLExpr(vars) + '[' + args[1].toCLLExpr(vars) + ']';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	392 case 'set':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	393 return args[0].toCLLExpr(vars) + '[' + args[1].toCLLExpr(vars) + '] = ' + args[2].toCLLExpr(vars);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	394 case 'not':
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	395 return '!(' + args[0].toCLLExpr(vars) + ')';
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	396 case 'castTo':
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	397 return '((' + args[1].toCTypeName() + ')(' + args[0].toCLLExpr(vars) + '))';
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	398 case 'mcall':
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	399 if (args[0] instanceof symbol) {
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	400 args[0] = new intlit(getMethodId(args[0].name));
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	401 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	402 default:
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	403 for (var i in args) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	404 args[i] = args[i].toCLLExpr(vars);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	405 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	406 return name + '(' + args.join(', ') + ')';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	407 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	408 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	409
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	410 function cObject(name) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	411 this.name = name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	412 this.slots = {};
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	413 this.properties = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	414 this.values = [];
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	415 this.slotvars = {};
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	416 this.includes = {};
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	417 this.parent = 'NULL';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	418 this.init = [];
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	419 this.initmsgadded = false;
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	420 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	421
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	422 cObject.prototype.addInclude = function(includefile) {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	423 this.includes[includefile] = true;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	424 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	425
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	426 cObject.prototype.addMessage = function(msgname, implementation) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	427 var methodid = getMethodId(msgname);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	428 var trunc = methodid & 0xF;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	429 if (!(trunc in this.slots)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	430 this.slots[trunc] = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	431 }
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	432 this.slots[trunc].push([methodid, '\t\t' + implementation.lines.join('\n\t\t') + '\n', msgname]);
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	433 if (!(trunc in this.slotvars)) {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	434 this.slotvars[trunc] = {};
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	435 }
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	436 for (var varname in implementation.vars) {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	437 this.slotvars[trunc][varname] = implementation.vars[varname];
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	438 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	439 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	440
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	441 cObject.prototype.addProperty = function(propname, value, type) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	442 if (type != undefined) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	443 this.properties.push([propname, type]);
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	444 if (value !== null) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	445 this.values.push(value);
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	446 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	447 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	448 var escaped = escapeCName(propname);
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	449 this.addMessage(propname, {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	450 vars: {},
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	451 lines: [
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	452 'return self->' + escaped + ';'
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	453 ]});
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	454 this.addMessage(propname + '!', {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	455 vars: {},
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	456 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	457 'self->' + escaped + ' = va_arg(args, object *);',
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	458 'return (object *)self;'
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	459 ]});
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	460 this.properties.push(escaped);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	461 this.values.push(value);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	462 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	463 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	464
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	465 cObject.prototype.addInit = function(statement) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	466 this.init.push(statement);
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	467 };
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	468
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	469 cObject.prototype.addImport = function(symbols, source) {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	470 this.imported.push(source);
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	471 var importNum = imported.length - 1;
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	472 if (symbols) {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	473 each(symbols, function(i, sym) {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	474 this.addMessage(sym.name, {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	475 vars: {},
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	476 lines: [
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	477 'return self->import_' + importNum + '->meta->meth_lookup[method_id & 0xF](method_id, num_args, self->import_' + importNum + ', args);'
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	478 ]
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	479 });
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	480 });
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	481 } else {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	482 //TODO: handle proxying for unimplemented methods
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	483 }
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	484 };
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	485
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	486 cObject.prototype.checkInitMsg = function() {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	487 if (!this.initmsgadded && this.init.length) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	488 var init = this.init.slice(0, this.init.length);
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	489 init.push('return (object *)self;');
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	490 this.addMessage('_init', {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	491 vars: {},
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	492 lines: init
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	493 });
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	494 this.initmsgadded = true;
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	495 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	496 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	497
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	498 cObject.prototype.populateSymbols = function() {};
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	499
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	500 cObject.prototype.toEarlyCDef = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	501 this.checkInitMsg();
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	502 var includes = '';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	503 for (var file in this.includes) {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	504 includes += '#include ' + file + '\n';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	505 }
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	506 var objdef = 'typedef struct ' + this.name + ' {\n\tobject header;\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	507 for (var i in this.properties) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	508 if (this.properties[i] instanceof Array) {
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	509 if (this.properties[i][1] instanceof Array) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	510 objdef += '\t' + this.properties[i][1][0] + this.properties[i][0] + this.properties[i][1][1] + ';\n';
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	511 } else {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	512 objdef += '\t' + this.properties[i][1] + ' ' + this.properties[i][0] + ';\n';
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	513 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	514 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	515 objdef += '\tobject * ' + this.properties[i] + ';\n'
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	516 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	517 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	518 objdef += '} ' + this.name + ';\nobj_meta ' + this.name + '_meta;\n';
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	519 return includes + objdef;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	520 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	521
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	522 cObject.prototype.toCDef = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	523 this.checkInitMsg();
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	524 var slotdefs = '';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	525 var metadef = 'obj_meta ' + this.name + '_meta = {sizeof(' + this.name +'), {';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	526 for (var i = 0; i < 16; i++) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	527 if (i) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	528 metadef += ', ';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	529 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	530 if (i in this.slots) {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	531 slotdefs += 'object * ' + this.name + '_slot_' + i + '(uint32_t method_id, uint32_t num_params, object * oself, va_list args) {\n\t' +
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	532 this.name + ' self = (' + this.name + ' )oself;\n';
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	533 for (var varname in this.slotvars[i]) {
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	534 if (this.slotvars[i][varname] instanceof Array) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	535 slotdefs += '/foo/\t' + this.slotvars[i][varname][0] + ' ' + varname + this.slotvars[i][varname][1] + ';\n';
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	536 } else {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	537 slotdefs += '/bar/\t' + this.slotvars[i][varname] + ' ' + varname + ';\n';
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	538 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	539 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	540 if (this.slots[i].length == 1) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	541 slotdefs += '\tif (method_id == ' + this.slots[i][0][0] + ') { /* ' + this.slots[i][0][2] + '*/\n' +
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	542 '\t\t' + this.slots[i][0][1] + '\n' +
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	543 '\t}\n' +
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	544 '\treturn no_impl(method_id, num_params, (object *)self, args);\n}\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	545 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	546 slotdefs += '\tswitch(method_id) {\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	547 for (j in this.slots[i]) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	548 slotdefs += '\t\tcase ' + this.slots[i][j][0] + ': /* ' + this.slots[i][j][2] + '*/\n' +
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	549 '\t\t\t' + this.slots[i][j][1] + '\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	550 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	551 slotdefs += '\t\tdefault:\n' +
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	552 '\t\t\treturn no_impl(method_id, num_params, (object *)self, args);\n\t}\n}\n';
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	553
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	554 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	555 metadef += this.name + '_slot_' + i;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	556 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	557 metadef += 'no_impl';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	558 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	559 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	560 metadef += '}};\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	561 return slotdefs + metadef;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	562 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	563
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	564 cObject.prototype.toCInstance = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	565 this.checkInitMsg();
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	566 var ret = 'make_object(&' + this.name + '_meta, ' + this.parent + ', ' + this.values.length + (this.values.length ? ', ' : '') + this.values.join(', ') + ')';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	567 if (this.initmsgadded) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	568 ret = 'mcall(' + getMethodId('_init') + ', 1, ' + ret + ')'
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	569 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	570 return ret;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	571 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	572
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	573 cObject.prototype.toC = function() {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	574 forwarddec += this.toEarlyCDef();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	575 toplevelcode += this.toCDef();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	576 return this.toCInstance();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	577 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	578
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	579 var nextobject = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	580
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	581
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	582 object.prototype.toCObject = function() {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	583 var messages = this.messages;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	584 if (!this.name) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	585 this.name = 'object_' + nextobject++;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	586 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	587 var me = new cObject(this.name);
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	588 this.symbols.typename = me.name;
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	589 if (this.symbols.needsenv) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	590 me.addProperty('env', this.symbols.envVar(), 'struct ' + this.symbols.getEnvType() + ' * ');
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	591 me.hasenv = true;
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	592 }
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	593 if (this.symbols.needsparent && !(this.symbols.parent instanceof osymbols)) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	594 me.parent = '(object *)(' + (new symbol('self', this.symbols.parent)).toC() + ')';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	595 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	596 for (var i in messages) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	597 if (messages[i] instanceof funcall) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	598 if (messages[i].name == 'import:' && messages[i].args.length == 1) {
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	599 me.addImport(false, messages[i].args[0]);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	600 } else if(messages[i].name == 'import:from:' && messages[i].args.length == 2) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	601 var importsyms = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	602 each(messages[i].args[0].val, function(i, el) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	603 if (!(el instanceof symbol)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	604 throw new Error('Names in import:from statement must be symbols');
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	605 }
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	606 importsyms.push(el);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	607 });
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	608 me.addImport(importsyms, messages[i].args[1]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	609 } else if(messages[i].name == 'llProperty:withType:' && messages[i].args.length == 2) {
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	610 me.addProperty(messages[i].args[0].name, null, messages[i].args[1].toCTypeName());
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	611 } else if(messages[i].name == 'llMessage:withVars:andCode:' && messages[i].args.length == 3) {
265 d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	612 if (messages[i].args[0] instanceof symbol) {
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	613 var msgname = messages[i].args[0].name;
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	614 } else if (messages[i].args[0] instanceof strlit) {
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	615 var msgname = messages[i].args[0].val;
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	616 } else {
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	617 throw new Error('First argument to llMessage:withVars:andCode must be a symbol or string');
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	618 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	619 var rawvars = messages[i].args[1].expressions;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	620 var vars = {};
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	621 for(var v in rawvars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	622 vars[rawvars[v].symbol.name] = rawvars[v].expression.toCTypeName();
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	623 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	624 me.addMessage(msgname, {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	625 vars: vars,
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	626 lines: messages[i].args[2].toCLines(vars, true)
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	627 });
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	628 } else if(messages[i].name == 'includeSystemHeader:' && messages[i].args.length == 1) {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	629 me.addInclude("<" + messages[i].args[0].val + ">");
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	630 } else {
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	631
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	632 throw new Error('Only import and import:from calls allowed in object context. ' + messages[i].name + 'with ' + messages[i].args.length + ' arguments found instead.');
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	633 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	634 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	635 messages[i].toCObject(me);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	636 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	637 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	638
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	639 return me;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	640 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	641
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	642 object.prototype.toC = function() {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	643 return this.toCObject().toC();
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	644 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	645
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	646 var toplevelcode;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	647 var forwarddec;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	648
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	649 function addBinaryOp(cobject, opname, cop, objtype)
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	650 {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	651 cobject.addMessage(opname, {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	652 vars: {ret: objtype + ' ', argb: objtype +' '},
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	653 lines: [
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	654 'argb = va_arg(args, ' + objtype + ' *);',
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	655 'ret = (' + objtype + ' *)make_object(&' + objtype + '_meta, NULL, 0);',
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	656 'ret->num = self->num ' + cop + ' argb->num;',
52 ab6217b8ae4c Remove some C compiler warnings due to sloppy native code Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	657 'return &(ret->header);'
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	658 ]
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	659 });
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	660 }
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	661
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	662 function addCompOp(cobject, opname, cop, objtype)
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	663 {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	664 cobject.addMessage(opname, {
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	665 vars: {argb: objtype + ' *'},
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	666 lines: [
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	667 'argb = va_arg(args, ' + objtype + ' *);',
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	668 'if (self->num ' + cop + ' argb->num) {',
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	669 ' return ' + toplevel.moduleVar('true') + ';',
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	670 '}',
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	671 'return ' + toplevel.moduleVar('false') + ';',
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	672 ]
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	673 });
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	674 }
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	675
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	676 function makeInt(bits, unsigned)
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	677 {
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	678 var typename = 'obj_' + (unsigned ? 'u' : '') + 'int' + bits;
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	679 var intObj = new cObject(typename);
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	680 intObj.addProperty('num', null, (unsigned ? 'u' : '') + 'int' + bits +'_t');
265 d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	681 addBinaryOp(intObj, '+', '+', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	682 addBinaryOp(intObj, '-', '-', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	683 addBinaryOp(intObj, '', '', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	684 addBinaryOp(intObj, '/', '/', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	685 addBinaryOp(intObj, '%', '%', typename);
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	686 addBinaryOp(intObj, 'or', '\|', typename);
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	687 addBinaryOp(intObj, 'xor', '^', typename);
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	688 addBinaryOp(intObj, 'and', '&', typename);
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	689 addBinaryOp(intObj, 'lshift:by', '<<', typename);
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	690 addBinaryOp(intObj, 'rshift:by', '>>', typename);
265 d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	691 addCompOp(intObj, '<', '<', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	692 addCompOp(intObj, '>', '>', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	693 addCompOp(intObj, '=', '==', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	694 addCompOp(intObj, '!=', '!=', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	695 addCompOp(intObj, '>=', '>=', typename);
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	696 addCompOp(intObj, '<=', '<=', typename);
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	697 intObj.addInclude('<string.h>');
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	698 //-9223372036854775808
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	699 //01234567890123456789
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	700 intObj.addMessage('string', {
43 27a2167663dd Improve compiler error reporting. Fix operator associativity. Add some more string operations and a string ops sample Mike Pavone <pavone@retrodev.com> parents: 42 diff changeset	701 vars: {str: 'string *'},
27a2167663dd Improve compiler error reporting. Fix operator associativity. Add some more string operations and a string ops sample Mike Pavone <pavone@retrodev.com> parents: 42 diff changeset	702 lines: [
27a2167663dd Improve compiler error reporting. Fix operator associativity. Add some more string operations and a string ops sample Mike Pavone <pavone@retrodev.com> parents: 42 diff changeset	703 'str = (string *)make_object(&string_meta, NULL, 0);',
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	704 'str->data = GC_MALLOC(' + (bits == 64 ? 21 : 12) + ');',
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	705 'sprintf(str->data, "%' + (bits == 64 ? 'l' : '') + (unsigned ? 'u' : 'd') + '", self->num);',
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	706 'str->len = str->bytes = strlen(str->data);',
52 ab6217b8ae4c Remove some C compiler warnings due to sloppy native code Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	707 'return &(str->header);'
43 27a2167663dd Improve compiler error reporting. Fix operator associativity. Add some more string operations and a string ops sample Mike Pavone <pavone@retrodev.com> parents: 42 diff changeset	708 ]
27a2167663dd Improve compiler error reporting. Fix operator associativity. Add some more string operations and a string ops sample Mike Pavone <pavone@retrodev.com> parents: 42 diff changeset	709 });
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	710 //7FFFFFFFFFFFFFFF
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	711 //01234567890123456789
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	712 intObj.addMessage('hex', {
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	713 vars: {str: 'string *'},
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	714 lines: [
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	715 'str = (string *)make_object(&string_meta, NULL, 0);',
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	716 'str->data = GC_MALLOC(' + (bits == 64 ? 17 : 9) + ');',
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	717 'sprintf(str->data, "%' + (bits == 64 ? 'l' : '') +'X", self->num);',
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	718 'str->len = str->bytes = strlen(str->data);',
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	719 'return &(str->header);'
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	720 ]
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	721 });
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	722 intObj.addMessage('isInteger?', {
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	723 vars: {},
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	724 lines: [
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	725 'return ' + toplevel.moduleVar('true') + ';'
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	726 ]
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	727 });
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	728 intObj.addMessage('hash', {
79 7f635666c73d Add hash and int32 messages to string. Add hash message to int32. Update compile script Mike Pavone <pavone@retrodev.com> parents: 78 diff changeset	729 vars: {},
7f635666c73d Add hash and int32 messages to string. Add hash message to int32. Update compile script Mike Pavone <pavone@retrodev.com> parents: 78 diff changeset	730 lines: [
7f635666c73d Add hash and int32 messages to string. Add hash message to int32. Update compile script Mike Pavone <pavone@retrodev.com> parents: 78 diff changeset	731 'return &(self->header);'
7f635666c73d Add hash and int32 messages to string. Add hash message to int32. Update compile script Mike Pavone <pavone@retrodev.com> parents: 78 diff changeset	732 ]
7f635666c73d Add hash and int32 messages to string. Add hash message to int32. Update compile script Mike Pavone <pavone@retrodev.com> parents: 78 diff changeset	733 });
172 8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	734 intObj.addMessage('signed?', {
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	735 vars: {},
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	736 lines: [
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	737 'return ' + toplevel.moduleVar(unsigned ? 'false' : 'true') + ';'
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	738 ]
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	739 });
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	740 var sizes = [8, 16, 32, 64];
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	741 var destunsigned = [false, true];
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	742 for (var i = 0; i < sizes.length; i++) {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	743 size = sizes[i];
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	744 for (var j = 0; j < destunsigned.length; j++) {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	745 uns = destunsigned[j];
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	746 if (uns == unsigned && size == bits) {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	747 intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	748 vars: {},
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	749 lines: [
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	750 'return &(self->header);'
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	751 ]
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	752 });
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	753 } else {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	754 var retType = 'obj_' + (uns ? 'u' : '') + 'int' + size;
161 fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	755 var retName = 'ret' + (uns ? 'u' : '') + size;
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	756 var vars = {};
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	757 vars[retName] = retType + ' *';
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	758 intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	759
161 fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	760 vars: vars,
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	761 lines: [
161 fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	762 retName + ' = ('+retType+' *)make_object(&' + retType +'_meta, NULL, 0);',
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	763 retName + '->num = self->num;',
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	764 'return &(' + retName + '->header);'
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	765 ]
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	766 });
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	767 }
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	768 }
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	769 }
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	770
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	771 return intObj;
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	772 }
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	773
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	774 function makeArray()
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	775 {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	776 var arrayfile = toplevel.names['array'];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	777 var ast = parseFile(arrayfile.path + '/' + arrayfile.file);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	778 ast.name = 'array';
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	779 ast.populateSymbols(toplevel);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	780 return ast.toCObject();
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	781 }
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	782
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	783 function makeString()
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	784 {
87 25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	785 var arrayfile = toplevel.names['string'];
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	786 var ast = parseFile(arrayfile.path + '/' + arrayfile.file);
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	787 ast.name = 'string';
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	788 ast.populateSymbols(toplevel);
25bc8a5ab41e Improve llMessage a bit and move implementation of string into string.tp module using llMessage. Update TASKS list Mike Pavone <pavone@retrodev.com> parents: 84 diff changeset	789 return ast.toCObject();
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	790 }
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	791
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	792 function makelambda()
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	793 {
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	794 var clos = new cObject('lambda');
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	795 clos.addProperty('env', null, 'void *');
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	796 clos.addProperty('func', null, 'closure_func');
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	797 clos.addMessage('while:do', {
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	798 vars: {action: 'lambda ', ret: 'object '},
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	799 lines: [
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	800 'action = va_arg(args, lambda *);',
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	801 'ret = ' + toplevel.moduleVar('true') + ';',
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	802 'while(' + toplevel.moduleVar('true') + ' == ccall(self, 0)) {',
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	803 ' ccall(action, 0);',
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	804 '}',
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	805 'return ret;'
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	806 ]
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	807 });
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	808 return clos;
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	809 }
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	810
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	811 function builtinTypes()
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	812 {
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	813 return [makeInt(64, false), makeInt(32, false), makeInt(16, false), makeInt(8, false),
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	814 makeInt(64, true) , makeInt(32, true), makeInt(16, true), makeInt(8, true),
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	815 makeArray(), makeString(), makelambda()];
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	816 }
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	817
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	818 function addBuiltinModules(toplevel)
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	819 {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	820 var os = new cObject('mod_obj_os');
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	821 os.addInclude('<sys/stat.h>');
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	822 os.addInclude('<fcntl.h>');
162 157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	823 os.addInclude('<stdlib.h>');
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	824 os.addInclude('<time.h>');
168 224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	825 os.addInclude('<unistd.h>');
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	826 os.addMessage('write', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	827 vars: {str: 'string ', intret: 'obj_int32 ', filedes: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	828 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	829 'filedes = va_arg(args, obj_int32 *);',
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	830 'str = va_arg(args, string *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	831 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	832 'intret->num = write(filedes->num, str->data, str->bytes);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	833 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	834 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	835 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	836 os.addMessage('read', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	837 vars: {str: 'string ', size: 'obj_int32 ', filedes: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	838 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	839 'filedes = va_arg(args, obj_int32 *);',
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	840 'size = va_arg(args, obj_int32 *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	841 'str = (string *)make_object(&string_meta, NULL, 0);',
78 abc6f3d644a4 Use Boehm-GC for garbage collection. Also make no_impl print on stderr rather than standard in and return a non-zero error code. Mike Pavone <pavone@retrodev.com> parents: 72 diff changeset	842 'str->data = GC_MALLOC_ATOMIC(size->num + 1);',
162 157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	843 'str->len = str->bytes = read(filedes->num, str->data, size->num);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	844 'if (str->bytes < 0) { str->bytes = str->len = 0; }',
58 7b454d100dc8 Add length method to array. Pass array of arguments to main method. Initialize parent field of environment struct for closures Mike Pavone <pavone@retrodev.com> parents: 57 diff changeset	845 'str->data[str->bytes] = 0;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	846 'return &(str->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	847 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	848 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	849 os.addMessage('open', {
49 f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	850 vars: {str: 'string ', flags: 'obj_int32 ', filedes: 'obj_int32 ', perm: 'obj_int32 '},
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	851 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	852 'str = va_arg(args, string *);',
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	853 'flags = va_arg(args, obj_int32 *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	854 'filedes = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
49 f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	855 'if (num_params == 3) {',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	856 ' filedes->num = open(str->data, flags->num);',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	857 '} else if (num_params == 4) {',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	858 ' perm = va_arg(args, obj_int32 *);',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	859 ' filedes->num = open(str->data, flags->num, perm->num);',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	860 '} else {',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	861 ' filedes->num = -1;',
f2cda2e6f70e Fix os open to optionally take a file permission bit parameter. Update example to use this parameter. Add support for hex and binary integer literals Mike Pavone <pavone@retrodev.com> parents: 48 diff changeset	862 '}',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	863 'return &(filedes->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	864 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	865 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	866 os.addMessage('close', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	867 vars: {filedes: 'obj_int32 ', intret: 'obj_int32 '},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	868 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	869 'filedes = va_arg(args, obj_int32 *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	870 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	871 'intret->num = close(filedes->num);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	872 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	873 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	874 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	875 os.addMessage('O_RDONLY', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	876 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	877 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	878 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	879 'intret->num = O_RDONLY;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	880 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	881 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	882 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	883 os.addMessage('O_WRONLY', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	884 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	885 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	886 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	887 'intret->num = O_WRONLY;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	888 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	889 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	890 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	891 os.addMessage('O_RDWR', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	892 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	893 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	894 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	895 'intret->num = O_RDWR;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	896 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	897 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	898 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	899 os.addMessage('O_CREAT', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	900 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	901 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	902 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	903 'intret->num = O_CREAT;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	904 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	905 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	906 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	907 os.addMessage('O_APPEND', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	908 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	909 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	910 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	911 'intret->num = O_APPEND;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	912 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	913 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	914 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	915 os.addMessage('O_TRUNC', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	916 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	917 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	918 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	919 'intret->num = O_TRUNC;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	920 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	921 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	922 });
162 157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	923 os.addMessage('rand', {
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	924 vars: {intret: 'obj_int32 *'},
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	925 lines: [
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	926 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	927 'intret->num = rand();',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	928 'return &(intret->header);'
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	929 ]
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	930 });
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	931 os.addMessage('rand64', {
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	932 vars: {intret64: 'obj_int64 *'},
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	933 lines: [
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	934 'intret64 = (obj_int64 *)make_object(&obj_int64_meta, NULL, 0);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	935 'intret64->num = (((int64_t)rand()) << 32 ) \| rand();',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	936 'return &(intret64->header);'
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	937 ]
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	938 });
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	939 os.addMessage('srand', {
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	940 vars: {oseed: 'object ', seed: 'obj_int32 '},
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	941 lines: [
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	942 'oseed = va_arg(args, object *);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	943 'seed = mcall(' + getMethodId("int32") + ', 1, oseed);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	944 'srand(seed->num);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	945 'return &(seed->header);'
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	946 ]
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	947 });
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	948 os.addMessage('time', {
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	949 vars: {intret64: 'obj_int64 *'},
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	950 lines: [
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	951 'intret64 = (obj_int64 *)make_object(&obj_int64_meta, NULL, 0);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	952 'intret64->num = time(NULL);',
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	953 'return &(intret64->header);'
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	954 ]
157cc497a7f1 Add rand srand and time to os module Mike Pavone <pavone@retrodev.com> parents: 161 diff changeset	955 });
168 224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	956 os.addMessage('sleep', {
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	957 vars: {osecs: 'object ', secs: 'obj_int32 ', intret: 'obj_int32 *'},
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	958 lines: [
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	959 'osecs = va_arg(args, object *);',
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	960 'secs = mcall(' + getMethodId("int32") + ', 1, osecs);',
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	961 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	962 'intret->num = sleep(secs->num);',
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	963 'return &(intret->header);'
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	964 ]
224071eed9dd Add os sleep Mike Pavone <pavone@retrodev.com> parents: 162 diff changeset	965 });
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	966 toplevel.names['os'] = os;
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	967 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	968
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	969 modulefile.prototype.toC = function(){
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	970 return this.ast.toCModuleInstance();
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	971 };
25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	972
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	973 function processUsedToplevel(toplevel)
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	974 {
170 18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	975 var alwaysused = ['true', 'false', 'list'];
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	976 var ret = '';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	977 var modulenum = 0;
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	978 var visited = {};
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	979 for (var i in alwaysused) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	980 toplevel.used[alwaysused[i]] = true;
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	981 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	982 var newused = Object.keys(toplevel.used);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	983 var allused = newused;
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	984 while (newused.length) {
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	985 for (var i in newused) {
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	986 debugprint('//---module', newused[i], '--- populate symbols');
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	987 forwarddec += 'object * ' + toplevel.moduleVar(newused[i]) + ';\n';
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	988 toplevel.names[newused[i]].populateSymbols(toplevel);
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	989 visited[newused[i]] = true;
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	990 }
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	991 newused = [];
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	992 for (var symbol in toplevel.used) {
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	993 if (!(symbol in visited)) {
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	994 debugprint('//found new usage of module', symbol);
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	995 newused.push(symbol);
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	996 allused.push(symbol);
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	997 }
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	998 }
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	999 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1000
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	1001 for (var i = allused.length-1; i >= 0; i--) {
3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	1002 var symbol = allused[i];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1003 debugprint('//---module', symbol, '(' + i +')--- compile');
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1004 assignNames.push(symbol);
68 3a169ebb3224 Change strategy for handling true and false to avoid some initialization order problems and improve performance. Add support for negative integer literals. Update samples to reflect true/false change. Mike Pavone <pavone@retrodev.com> parents: 67 diff changeset	1005 ret += '\t' + toplevel.moduleVar(symbol) + ' = ' + toplevel.names[symbol].toC() + ';\n';
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1006 assignNames.pop();
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1007 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1008 return ret;
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1009 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1010
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1011 function makeCProg(obj)
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1012 {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1013 forwarddec = toplevelcode = '';
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1014 assignNames = [];
45 2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1015 var builtins = builtinTypes();
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1016 for (var i in builtins) {
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1017 forwarddec += builtins[i].toEarlyCDef();
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1018 toplevelcode += builtins[i].toCDef();
2a9c6eed0c70 Move closure/lambda object def into compiler rather than runtime code. Add while:do method to lambda Mike Pavone <pavone@retrodev.com> parents: 43 diff changeset	1019 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1020 addBuiltinModules(toplevel);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1021 debugprint('//------POPULATING SYMBOLS-----');
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1022 obj.populateSymbols(toplevel);
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1023 var moduleinit = processUsedToplevel(toplevel);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1024 debugprint('//------COMPILING AST-----');
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1025 var rest = 'object * mainModule() {\n' + moduleinit + '\tmain_module = ' + obj.toCModuleInstance() + ';\n\treturn main_module;\n}\n';
182 ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	1026 var mnames = 'char * methodNames[] = {\n';
ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	1027 for (var i = 0; i < methodNames.length; i++) {
ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	1028 mnames += '\t"' + methodNames[i].replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n") + '",\n';
ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	1029 }
ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	1030 mnames += '};\n';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1031 return '#include "runtime/proghead.inc"\n' +
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1032 '#define METHOD_ID_MAIN ' + getMethodId('main') + '\n' +
170 18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1033 '#define METHOD_ID_EMPTY ' + getMethodId('empty') + '\n' +
18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1034 '#define METHOD_ID_CONS ' + getMethodId(getOpMethodName('\|')) + '\n' +
182 ab7c142090a0 Make method names available at runtime so they can be included in method not implemented error messages Mike Pavone <pavone@retrodev.com> parents: 177 diff changeset	1035 mnames + forwarddec + toplevelcode + rest + '#include "runtime/progfoot.inc"\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1036 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1037
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1038 object.prototype.toCModule = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1039 return makeCProg(this);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1040 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1041
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1042 object.prototype.toCModuleInstance = function() {
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1043 return this.toC();
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1044 }
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1045
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1046 lambda.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1047 var args = this.args ? this.args.slice(0, this.args.length) : [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1048 var exprs = this.expressions;
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1049 var assignPath = assignNames.join('<-');
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1050 debugprint('//', this.name, assignPath);
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1051 var addedTypeDef = false;
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1052 if (Object.keys(this.symbols.closedover).length) {
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1053 this.symbols.envtype = this.name + '_env';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1054 forwarddec += 'typedef struct ' + this.symbols.envtype + ' ' + this.symbols.envtype + ';\n'
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1055 var addedTypeDef = true;
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1056 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1057 if (this.selftype) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1058 this.symbols.defineVar('self', this.selftype);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1059 if (args[0] && args[0].cleanName() == 'self') {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1060 args.splice(0, 1);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1061 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1062 var offset = 1;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1063 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1064 var offset = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1065 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1066 for (var i = 0; i < args.length; ++i) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1067 var argname = args[i].toC();
251 2557ce4e671f Fix a couple of compiler bugs. topenv was getting initialized in multiple places. This resulted in multiple copies of modules getting created which caused problems for macro expansion. Additionally, arguments were not being marked as declared during code generation so assigning to an argument that was not closed over generated invalid C code. Michael Pavone <pavone@retrodev.com> parents: 241 diff changeset	1068 this.symbols.declareVar(args[i].cleanName());
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1069 args[i] = (argname.indexOf('->') < 0 ? '\tobject * ' : '\t') + argname + ' = va_arg(args, object *);\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1070 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1071 var compiled = []
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1072 for (var i in exprs) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1073 var js = exprs[i].toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1074 if (js) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1075 compiled.push(indent(js));
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1076 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1077 }
172 8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1078 if (compiled.length) {
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1079 if (exprs[exprs.length - 1] instanceof assignment) {
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1080 compiled.push('return ' + exprs[exprs.length - 1].symbol.toC() + ';');
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1081 } else {
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1082 compiled[compiled.length-1] = 'return (object *)(' + compiled[compiled.length-1] + ');';
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1083 }
8d466c5a7dff Fixed a few bugs. Improved the "symbol not found" error messages. Added a "signed?" method to integer objects Mike Pavone <pavone@retrodev.com> parents: 171 diff changeset	1084 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1085 exprs = compiled;
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1086
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1087 if (Object.keys(this.symbols.closedover).length) {
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1088 if (!addedTypeDef) {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1089 for (var key in this.symbols.closedover) {
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1090 print(key, ": ", this.symbols.closedover[key]);
9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1091 }
156 d6e79885bd3b Fix compiler bug involving referencing a self method in a method defined before the referenced method Mike Pavone <pavone@retrodev.com> parents: 155 diff changeset	1092 throw new Error('this.symbols.closedover is not empty, but it was when compilation of ' + this.name + ' "' + assignPath + '" started');
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1093 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1094 forwarddec += 'struct ' + this.name + '_env {\n';
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	1095 if (this.symbols.needsParentEnv) {
08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	1096 forwarddec += '\tstruct ' + this.symbols.parentEnvType() + ' * parent;\n';
08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	1097 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1098 for (var varname in this.symbols.closedover) {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1099 if (varname == 'self' && this.selftype) {
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1100 forwarddec += '\tstruct ' + this.selftype + ' * self;\n';
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1101 } else {
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1102 forwarddec += '\tobject * ' + escapeCName(varname) + ';\n';
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1103 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1104 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1105 forwarddec += '};\n'
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1106
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1107 var myenvinit = '\t' + this.name + '_env * myenv = GC_MALLOC(sizeof(' + this.name + '_env));\n';
58 7b454d100dc8 Add length method to array. Pass array of arguments to main method. Initialize parent field of environment struct for closures Mike Pavone <pavone@retrodev.com> parents: 57 diff changeset	1108 if (this.symbols.needsParentEnv) {
7b454d100dc8 Add length method to array. Pass array of arguments to main method. Initialize parent field of environment struct for closures Mike Pavone <pavone@retrodev.com> parents: 57 diff changeset	1109 myenvinit += '\tmyenv->parent = env;\n';
7b454d100dc8 Add length method to array. Pass array of arguments to main method. Initialize parent field of environment struct for closures Mike Pavone <pavone@retrodev.com> parents: 57 diff changeset	1110 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1111 this.symbols.envtype = this.name + '_env';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1112 } else {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1113 var myenvinit = '';
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1114 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1115 forwarddec += 'object ' + this.name + ' (' + this.symbols.parentEnvType() + ' env, uint32_t num_args, ...);\n';
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1116
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1117 toplevelcode += '//' + assignPath + "\n";
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1118 toplevelcode += 'object * ' + this.name + ' ( ' + this.symbols.parentEnvType() + ' * env, uint32_t num_args, ...) {\n\tva_list args;\n' + myenvinit + '\tva_start(args, num_args);\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1119 if (this.selftype) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1120 var selfvar = (new symbol('self', this.symbols)).toC();
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1121 if (selfvar == 'self') {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1122 toplevelcode += '\t' + this.selftype + ' * self = va_arg(args, ' + this.selftype + ' *);\n';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1123 } else {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1124 toplevelcode += '\t' + selfvar + ' = va_arg(args, ' + this.selftype + ' *);\n';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1125 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1126
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1127 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1128 toplevelcode += args.join('') + '\tva_end(args);\n' + exprs.join(';\n\t') + '\n}\n';
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1129
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1130 if (this.selftype) {
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1131 return this.name;
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1132 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1133 if (this.symbols.parentEnvType() != 'void') {
55 93ddb4ad6fcb Fix some nested closure bugs Mike Pavone <pavone@retrodev.com> parents: 54 diff changeset	1134 if (this.symbols.parent.passthruenv) {
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1135 var envvar = 'env';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1136 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1137 var envvar = 'myenv';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1138 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1139 debugprint('//' + this.name, 'has envvar:', envvar, 'num vars closed over:', Object.keys(this.symbols.closedover).length);
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1140 return 'make_lambda(' + envvar + ', (closure_func)' + this.name + ')';
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1141 } else {
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	1142 toplevelcode += 'lambda ' + this.name + '_obj = {{&lambda_meta, NULL}, NULL, ' + this.name + '};\n';
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1143 return '((object *)&' + this.name + '_obj)';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1144 }
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1145 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1146 };
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1147 lambda.prototype.toCModuleInstance = function() {
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1148 this.toC();
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1149 return this.name + '(NULL, 0)';
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1150 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1151 lambda.prototype.toCObject = function(typename) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1152 this.selftype = typename;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1153 return this.toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1154 };
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1155 lambda.prototype.toCModule = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1156 return makeCProg(this);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1157 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1158 lambda.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1159 var lines = [];
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1160 for (var i in this.args) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1161 var name = this.args[i].name;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1162 if (name[0] == ':') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1163 name = name.substr(1);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1164 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1165 if(name != 'self') {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1166 lines.push(name + ' = va_arg(args, ' + vars[name] + ');');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1167 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1168 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1169 for (var i in this.expressions) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1170 var exprlines = this.expressions[i].toCLines(vars, needsreturn && i == this.expressions.length - 1);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1171 for (var j in exprlines) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1172 lines.push('\t' + exprlines[j]);
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1173 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1174 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1175 return lines;
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1176 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1177 lambda.prototype.toCLLExpr = function(vars) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1178 if (this.expressions.length != 1) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1179 throw new Error('lambda in expression context must have a single statement in llMessage block');
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1180 }
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1181 return this.expressions[0].toCLLExpr(vars);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1182 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1183
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1184 assignment.prototype.toC = function() {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1185 debugprint('//assignment', this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1186 var existing = this.symbols.find(this.symbol.name);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1187 var prefix = '';
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1188 assignNames.push(this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1189 var val = this.expression.toC();
155 9de2572a34a7 Added some stuff for compiler debugging. Added unsigned integer types. Added integer size conversion methods to integer objects. Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1190 assignNames.pop(this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1191 if (val === null) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1192 return null;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1193 }
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1194 if (existing.type == 'local' && !existing.isdeclared) {
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1195 prefix = 'object *';
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1196 this.symbols.declareVar(this.symbol.name);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1197 debugprint('//declared var', this.symbol.name);
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1198 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1199 return prefix + this.symbol.toC() + ' = ' + val;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1200 };
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1201 assignment.prototype.toCObject = function(cobj) {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1202 debugprint('//message definition', this.symbol.name);
156 d6e79885bd3b Fix compiler bug involving referencing a self method in a method defined before the referenced method Mike Pavone <pavone@retrodev.com> parents: 155 diff changeset	1203 assignNames.push('#' + this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1204 if (this.expression.toCObject) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1205 var val = this.expression.toCObject(cobj.name);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1206 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1207 var val = this.expression.toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1208 }
156 d6e79885bd3b Fix compiler bug involving referencing a self method in a method defined before the referenced method Mike Pavone <pavone@retrodev.com> parents: 155 diff changeset	1209 assignNames.pop();
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1210 if (val === null) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1211 return;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1212 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1213 if (this.expression instanceof lambda) {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1214 var params = ['((object *)self)'];
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1215 var paramget = '';
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	1216 var messagevars = {};
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1217 for (var i in this.expression.args) {
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1218 var escaped = escapeCName(this.expression.args[i].cleanName());
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1219 if (escaped != 'self') {
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	1220 messagevars[escaped] = 'object *';
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1221 params.push(escaped);
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1222 paramget += escaped + ' = va_arg(args, object *); ';
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1223 }
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1224 }
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	1225 cobj.addMessage(getOpMethodName(this.symbol.name), {
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	1226 vars: messagevars,
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1227 lines: [paramget + 'return ' + val + '(' + (cobj.hasenv ? 'self->env' : 'NULL') + ', ' + params.length + (params.length ? ', ' : '') + params.join(', ') + ');']
37 a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	1228 });
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1229 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1230 cobj.addProperty(this.symbol.name, val);
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	1231 if (this.expression instanceof object && this.expression.symbols.needsparent) {
72 ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	1232 cobj.addInit('self->' + escapeCName(this.symbol.name) + '->parent = (object *)self;');
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	1233 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1234 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1235 };
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1236 assignment.prototype.toCLines = function(vars, needsreturn) {
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1237 return [(needsreturn ? 'return ' : '') + this.symbol.toCLLExpr(vars) + ' = ' + this.expression.toCLLExpr(vars) + ';']
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. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	1238 };