repos/tabletprog: cbackend.js annotate

annotate cbackend.js @ 326:50760ba52b11

Added basic rendering of strings to freetype demo

author	Michael Pavone <pavone@retrodev.com>
date	Tue, 24 Mar 2015 21:50:28 -0700
parents	4a79311dbd29
children	eef8a5cea812

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) {
267 d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	96 return 'mcall(' + getMethodId(name) + '/* ' + name + ' /, 1, (object )' + (new symbol('self', this.symbols)).toC() + ')';
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	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 };
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	109 symbol.prototype.cSafeName = function() {
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	110 var name = this.cleanName();
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	111 if (name[0] >= "0" && name[0] <= "9") {
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	112 name = '_tp_' + name;
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	113 }
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	114 return name;
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	115 };
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	116 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	117 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	118 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	119 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	120 }
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 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	122 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	123 }
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 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	125 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	126 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	127 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	128 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	129 }
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 if (!info) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	131 return this.cSafeName();
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	132 }
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 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	134 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	135 } 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	136 if (info.isll \|\| !(info.def instanceof lambda)) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	137 return 'self->' + this.cSafeName();
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	138 } 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	139 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	140 }
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	141 }
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	142 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	143 };
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	144 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	145 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	146 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	147
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	148 var declaredInts = {};
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	149
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	150 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	151 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	152 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	153 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	154 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	155 declaredInts[str] = true;
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	156 }
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	157 return '((object *)&' + str + ')';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	158 }
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	159 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	160 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	161 };
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 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	163 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	164 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	165
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	166 floatlit.prototype.toC = function() {
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	167 var floatType = this.bits == 32 ? 'float' : 'double';
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	168 var str = floatType + '_' + (this.val < 0 ? 'neg_' + (0-this.val).toString() : this.val.toString()).replace('.', '_');
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	169 if (!(str in declaredInts)) {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	170 toplevelcode += 'obj_float' + this.bits + ' ' + str + ' = {{&obj_float' + this.bits + '_meta, NULL}, ' + this.val.toString() + '};\n';
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	171 declaredInts[str] = true;
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	172 }
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	173 return '((object *)&' + str + ')';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	174 }
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	175 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	176 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	177 };
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	178 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	179 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	180 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	181
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	182 var declaredStrings = {};
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	183 var nextStringId = 0;
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	184
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	185 strlit.prototype.toC = function() {
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	186 if (!(this.val in declaredStrings)) {
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	187 //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	188 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	189 declaredStrings[this.val] = nextStringId++;
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	190 }
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	191 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	192 };
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	193 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	194 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	195 };
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	196 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	197 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	198 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	199
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	200 listlit.prototype.toC = function() {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	201 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	202 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	203 ret += ', ' + this.val[i].toC();
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	204 }
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	205 return ret + ')';
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	206 }
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	207
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	208 arraylit.prototype.toC = function() {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	209 var ret = 'make_array(' + this.val.length;
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	210 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	211 ret += ', ' + this.val[i].toC();
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	212 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	213 return ret + ')';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	214 }
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 funcall.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	217 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	218 if (name == 'foreign') {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	219 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	220 return null;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	221 } else if(this.args[0] instanceof symbol) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	222 return this.args[0].name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	223 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	224 throw new Error("Unexpected AST type for foreign:");
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	225 }
211 53cd9c3bcf96 Don't compile quote expressions in C backend for now Mike Pavone <pavone@retrodev.com> parents: 182 diff changeset	226 } 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	227 return null;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	228 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	229 var args = this.args.slice(0, this.args.length);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	230 if (this.receiver) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	231 args.splice(0, 0, this.receiver);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	232 }
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	233 var method = false;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	234 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	235 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	236 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	237 method = true;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	238 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	239 switch(funinfo.type)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	240 {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	241 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	242 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	243 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	244 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	245 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	246 }
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	247 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	248 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	249 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	250 } 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	251 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	252 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	253 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	254 }
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	255 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	256 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	257 }
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	258 } 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	259 funinfo = null;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	260 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	261 method = true;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	262 break;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	263 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	264 }
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	265 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	266 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	267 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	268 var callpart;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	269 if (method) {
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	270 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	271 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	272 } else {
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	273 callpart = 'mcall(' + getMethodId(name) + '/* ' + name + ' */';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	274 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	275 } 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	276 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	277 callpart = '((lambda )' + closVar + ')->func(((lambda )' + closVar + ')->env';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	278 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	279 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	280 };
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	281 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	282 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	283 {
285 bb1539decd62 Fix const warning in sdl module Michael Pavone <pavone@retrodev.com> parents: 282 diff changeset	284 case 'const:':
bb1539decd62 Fix const warning in sdl module Michael Pavone <pavone@retrodev.com> parents: 282 diff changeset	285 case 'const':
bb1539decd62 Fix const warning in sdl module Michael Pavone <pavone@retrodev.com> parents: 282 diff changeset	286 var receiver = this.receiver ? this.receiver : this.args[0];
bb1539decd62 Fix const warning in sdl module Michael Pavone <pavone@retrodev.com> parents: 282 diff changeset	287 return 'const ' + receiver.toCTypeName();
bb1539decd62 Fix const warning in sdl module Michael Pavone <pavone@retrodev.com> parents: 282 diff changeset	288 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	289 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	290 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	291 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	292 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	293 break;
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	294 case 'struct:':
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	295 case 'struct':
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	296 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	297 return 'struct ' + receiver.toCTypeName();
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	298 break;
177 76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	299 case 'funptr:':
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	300 case 'funptr':
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	301 var rettype;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	302 var firstArg;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	303 if (this.receiver) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	304 rettype = this.receiver;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	305 firstArg = 0;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	306 } else {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	307 rettype = this.args[0];
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	308 firstArg = 1;
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	309 }
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	310 var argtypes = '';
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	311 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	312 if (argtypes) {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	313 argtypes += ', '
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	314 }
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	315 argtypes += this.args[i].toCTypeName();
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	316 }
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	317 return [rettype.toCTypeName() + '(*', ')(' + argtypes + ')'];
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	318 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	319 default:
316 df4b67d8d2bc Minor improvement to error message about invalid c type expressions Michael Pavone <pavone@retrodev.com> parents: 294 diff changeset	320 throw new Error('invalid use of funcall expression where a C type name is expected: ' + this.name);
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	321 }
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 };
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 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	324 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	325 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	326 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	327 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	328 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	329 }
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 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	331 {
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 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	333 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	334 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	335 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	336 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	337 }
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 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	339 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	340 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	341 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	342 } 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	343 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	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 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	346 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	347 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	348 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	349 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	350 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	351 }
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 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	353 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	354 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	355 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	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 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	358 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	359 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	360 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	361 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	362 }
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	363 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	364 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	365 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	366 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	367 }
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 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	369 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	370 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	371 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	372 }
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	373 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	374 };
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
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 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	377 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	378 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	379 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	380 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	381 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	382 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	383 } else {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	384 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	385 }
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 } 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	387 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	388 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	389 } else {
282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	390 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	391 }
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	392 } 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	393 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	394 }
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 }
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	396 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	397 {
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	398 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	399 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	400 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	401 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	402 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	403 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	404 case 'addr_of':
282 361a449a7235 Add some extra parens in addr_of translation and fix cleaning of names in llMessage parameters Michael Pavone <pavone@retrodev.com> parents: 273 diff changeset	405 return '(&(' + args[0].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	406 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	407 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	408 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	409 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	410 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	411 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	412 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	413 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	414 case 'castTo':
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	415 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	416 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	417 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	418 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	419 }
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	420 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	421 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	422 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	423 }
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	424 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	425 }
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	426 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	427
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	428 function cObject(name) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	429 this.name = name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	430 this.slots = {};
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	431 this.properties = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	432 this.values = [];
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	433 this.slotvars = {};
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	434 this.includes = {};
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	435 this.parent = 'NULL';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	436 this.init = [];
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	437 this.initmsgadded = false;
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	438 this.imported = [];
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	439 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	440
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	441 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	442 this.includes[includefile] = true;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	443 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	444
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	445 cObject.prototype.addMessage = function(msgname, implementation) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	446 var methodid = getMethodId(msgname);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	447 var trunc = methodid & 0xF;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	448 if (!(trunc in this.slots)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	449 this.slots[trunc] = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	450 }
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	451 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	452 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	453 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	454 }
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	455 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	456 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	457 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	458 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	459
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	460 cObject.prototype.addProperty = function(propname, value, type) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	461 if (type != undefined) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	462 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	463 if (value !== null) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	464 this.values.push(value);
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	465 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	466 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	467 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	468 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	469 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	470 lines: [
267 d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	471 'return (object *)self->' + escaped + ';'
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	472 ]});
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	473 this.addMessage(propname + '!', {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	474 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	475 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	476 '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	477 '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	478 ]});
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	479 this.properties.push(escaped);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	480 this.values.push(value);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	481 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	482 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	483
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	484 cObject.prototype.addInit = function(statement) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	485 this.init.push(statement);
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	486 };
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	487
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	488 cObject.prototype.addImport = function(symbols, source) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	489 var importNum = this.imported.indexOf(source);
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	490 if (importNum < 0) {
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	491 var importNum = this.imported.length;
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	492 this.imported.push(source);
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	493 this.addInit('self->import_' + importNum + ' = ' + source.toC() + ';');
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	494 }
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	495 if (symbols) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	496 var self = this;
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	497 each(symbols, function(i, sym) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	498 self.addMessage(sym.name, {
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	499 vars: {},
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	500 lines: [
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	501 'return self->import_' + importNum + '->meta->meth_lookup[method_id & 0xF](method_id, num_params, self->import_' + importNum + ', args);'
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	502 ]
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	503 });
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	504 });
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	505 } else {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	506 //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	507 }
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	508 };
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	509
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	510 cObject.prototype.checkInitMsg = function() {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	511 if (!this.initmsgadded && this.init.length) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	512 var init = this.init.slice(0, this.init.length);
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	513 init.push('return (object *)self;');
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	514 this.addMessage('_init', {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	515 vars: {},
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	516 lines: init
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	517 });
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	518 this.initmsgadded = true;
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	519 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	520 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	521
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	522 cObject.prototype.populateSymbols = function() {};
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	523
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	524 cObject.prototype.toEarlyCDef = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	525 this.checkInitMsg();
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	526 var includes = '';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	527 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	528 includes += '#include ' + file + '\n';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	529 }
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	530 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	531 for (var i in this.properties) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	532 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	533 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	534 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	535 } else {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	536 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	537 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	538 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	539 objdef += '\tobject * ' + this.properties[i] + ';\n'
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	540 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	541 }
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	542 for (var i in this.imported) {
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	543 objdef += '\tobject * import_' + i + ';\n';
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	544 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	545 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	546 return includes + objdef;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	547 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	548
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	549 cObject.prototype.toCDef = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	550 this.checkInitMsg();
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	551 var slotdefs = '';
266 75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	552 var methlists = '';
75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	553 var methdict = '}, {'
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	554 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	555 for (var i = 0; i < 16; i++) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	556 if (i) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	557 metadef += ', ';
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 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	560 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	561 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	562 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	563 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	564 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	565 } else {
76e3d4ae1746 Support more bitwise operations and function pointers in llMessages Mike Pavone <pavone@retrodev.com> parents: 172 diff changeset	566 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	567 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	568 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	569 if (this.slots[i].length == 1) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	570 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	571 '\t\t' + this.slots[i][0][1] + '\n' +
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	572 '\t}\n' +
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	573 '\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	574 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	575 slotdefs += '\tswitch(method_id) {\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	576 for (j in this.slots[i]) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	577 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	578 '\t\t\t' + this.slots[i][j][1] + '\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	579 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	580 slotdefs += '\t\tdefault:\n' +
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	581 '\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	582
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	583 }
266 75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	584 methlists += 'uint32_t ' + this.name + '_methods_' + i + '[] = {'
75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	585 for (j in this.slots[i]) {
75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	586 methlists += this.slots[i][j][0] + ', ';
75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	587 }
75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	588 methlists += 'LAST_METHOD};';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	589 metadef += this.name + '_slot_' + i;
266 75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	590 methdict += (i ? ', ' : '') + this.name + '_methods_' + i;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	591 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	592 metadef += 'no_impl';
266 75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	593 methdict += (i ? ', ' : '') + 'NULL';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	594 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	595 }
266 75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	596 metadef += methdict + '}};\n';
75dc7161c1ca Added object module which provides some basic reflection capabilities Michael Pavone <pavone@retrodev.com> parents: 265 diff changeset	597 return slotdefs + methlists + metadef;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	598 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	599
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	600 cObject.prototype.toCInstance = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	601 this.checkInitMsg();
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	602 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	603 if (this.initmsgadded) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	604 ret = 'mcall(' + getMethodId('_init') + ', 1, ' + ret + ')'
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	605 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	606 return ret;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	607 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	608
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	609 cObject.prototype.toC = function() {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	610 forwarddec += this.toEarlyCDef();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	611 toplevelcode += this.toCDef();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	612 return this.toCInstance();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	613 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	614
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	615 var nextobject = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	616
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	617
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	618 object.prototype.toCObject = function() {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	619 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	620 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	621 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	622 }
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 var me = new cObject(this.name);
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	624 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	625 if (this.symbols.needsenv) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	626 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	627 me.hasenv = true;
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	628 }
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	629 if (this.symbols.needsparent && !(this.symbols.parent instanceof osymbols)) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	630 me.parent = '(object *)(' + (new symbol('self', this.symbols.parent)).toC() + ')';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	631 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	632 for (var i in messages) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	633 if (messages[i] instanceof funcall) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	634 var msgname = messages[i].name;
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	635 if (msgname[msgname.length-1] == ':') {
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	636 msgname = msgname.substr(0, msgname.length-1);
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	637 }
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	638 if (msgname == '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	639 me.addImport(false, messages[i].args[0]);
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	640 } else if(msgname == 'import:from' && messages[i].args.length == 2) {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	641 var importsyms = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	642 each(messages[i].args[0].val, function(i, el) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	643 if (!(el instanceof symbol)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	644 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	645 }
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	646 importsyms.push(el);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	647 });
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	648 me.addImport(importsyms, messages[i].args[1]);
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	649 } else if(msgname == '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	650 me.addProperty(messages[i].args[0].name, null, messages[i].args[1].toCTypeName());
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	651 } else if(msgname == 'llMessage:withVars:andCode' && messages[i].args.length == 3) {
265 d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	652 if (messages[i].args[0] instanceof symbol) {
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	653 var msgname = messages[i].args[0].name;
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	654 } else if (messages[i].args[0] instanceof strlit) {
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	655 var msgname = messages[i].args[0].val;
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	656 } else {
d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	657 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	658 }
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	659 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	660 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	661 for(var v in rawvars) {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	662 vars[rawvars[v].symbol.cSafeName()] = rawvars[v].expression.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	663 }
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	664 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	665 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	666 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	667 });
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	668 } else if(msgname == 'includeSystemHeader' && messages[i].args.length == 1) {
320 1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	669 if (messages[i].args[0] instanceof strlit) {
1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	670 me.addInclude("<" + messages[i].args[0].val + ">");
1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	671 } else if(messages[i].args[0] instanceof symbol) {
1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	672 me.addInclude(messages[i].args[0].name);
1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	673 } else {
1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	674 throw new Error('Argument to includeSystemHeader must be a string literal or symbol');
1debeb21dd47 Allow symbol expressions in includeSystemHeader calls Michael Pavone <pavone@retrodev.com> parents: 316 diff changeset	675 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	676 } else {
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	677
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	678 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	679 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	680 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	681 messages[i].toCObject(me);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	682 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	683 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	684
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	685 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	686 };
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	687
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	688 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	689 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	690 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	691
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	692 var toplevelcode;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	693 var forwarddec;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	694
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	695 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	696 {
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	697 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	698 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	699 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	700 '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	701 '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	702 '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	703 '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	704 ]
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	705 });
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	706 }
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	707
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	708 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	709 {
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	710 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	711 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	712 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	713 '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	714 '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	715 ' 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	716 '}',
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	717 '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	718 ]
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	719 });
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	720 }
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	721
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	722 function addNumberOps(obj, typename)
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	723 {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	724 addBinaryOp(obj, '+', '+', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	725 addBinaryOp(obj, '-', '-', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	726 addBinaryOp(obj, '', '', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	727 addBinaryOp(obj, '/', '/', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	728 addCompOp(obj, '<', '<', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	729 addCompOp(obj, '>', '>', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	730 addCompOp(obj, '=', '==', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	731 addCompOp(obj, '!=', '!=', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	732 addCompOp(obj, '>=', '>=', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	733 addCompOp(obj, '<=', '<=', typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	734
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	735 obj.addMessage('jsonEncode', {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	736 vars: {},
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	737 lines: [
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	738 'return mcall(' + getMethodId('string') + ', 1, &self->header);'
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	739 ]
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	740 });
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	741 }
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	742
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	743 function makeInt(bits, unsigned)
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	744 {
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	745 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	746 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	747 intObj.addProperty('num', null, (unsigned ? 'u' : '') + 'int' + bits +'_t');
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	748 addNumberOps(intObj, typename);
265 d6a4c9e7716e Remove remapping of most operators Michael Pavone <pavone@retrodev.com> parents: 251 diff changeset	749 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	750 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	751 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	752 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	753 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	754 addBinaryOp(intObj, 'rshift:by', '>>', typename);
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	755
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	756 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	757 //-9223372036854775808
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	758 //01234567890123456789
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	759 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	760 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	761 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	762 '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	763 '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	764 '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	765 '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	766 '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	767 ]
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	768 });
288 a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	769 intObj.addMessage('utf8', {
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	770 vars: {str: 'string *', norm: 'uint32_t'},
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	771 lines: [
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	772 'str = (string *)make_object(&string_meta, NULL, 0);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	773 'str->len = 1;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	774 'norm = self->num;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	775 'if (norm < 0x80) {',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	776 ' str->bytes = 1;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	777 ' str->data = GC_MALLOC(2);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	778 ' str->data[0] = norm;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	779 '} else if(norm < 0x800) {',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	780 ' str->bytes = 2;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	781 ' str->data = GC_MALLOC(3);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	782 ' str->data[0] = 0xC0 \| norm >> 6;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	783 ' str->data[1] = 0x80 \| (norm & 0x3F);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	784 '} else if(norm < 0x10000) {',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	785 ' str->bytes = 3;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	786 ' str->data = GC_MALLOC(4);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	787 ' str->data[0] = 0xE0 \| norm >> 12;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	788 ' str->data[1] = 0x80 \| ((norm >> 6) & 0x3F);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	789 ' str->data[2] = 0x80 \| (norm & 0x3F);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	790 '} else if(norm < 0x10FFFF) {',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	791 ' str->bytes = 4;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	792 ' str->data = GC_MALLOC(5);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	793 ' str->data[0] = 0xF0 \| norm >> 18;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	794 ' str->data[1] = 0x80 \| ((norm >> 12) & 0x3F);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	795 ' str->data[2] = 0x80 \| ((norm >> 6) & 0x3F);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	796 ' str->data[3] = 0x80 \| (norm & 0x3F);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	797 '} else {',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	798 ' str->len = str->bytes = 0;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	799 ' str->data = GC_MALLOC(1);',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	800 '}',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	801 'str->data[str->bytes] = 0;',
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	802 'return &(str->header);'
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	803 ]
a4c2b31acba7 Add utf8 method to integer types for converting a number into a utf8 string made up of the corresponding character code Michael Pavone <pavone@retrodev.com> parents: 286 diff changeset	804 });
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	805 //7FFFFFFFFFFFFFFF
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	806 //01234567890123456789
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	807 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	808 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	809 lines: [
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	810 '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	811 '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	812 '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	813 '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	814 '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	815 ]
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	816 });
f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	817 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	818 vars: {},
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	819 lines: [
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	820 '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	821 ]
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	822 });
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	823 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	824 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	825 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	826 '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	827 ]
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	828 });
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	829 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	830 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	831 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	832 '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	833 ]
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	834 });
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	835 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	836 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	837 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	838 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	839 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	840 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	841 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	842 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	843 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	844 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	845 '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	846 ]
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	847 });
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	848 } 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	849 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	850 var retName = 'ret' + (uns ? 'u' : '') + size;
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	851 var vars = {};
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	852 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	853 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	854
161 fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	855 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	856 lines: [
161 fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	857 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	858 retName + '->num = self->num;',
fc8eecad71e6 Fix variable name collision in integer objects Mike Pavone <pavone@retrodev.com> parents: 156 diff changeset	859 '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	860 ]
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	861 });
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	862 }
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	863 }
325 4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	864 if (size > 16) {
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	865 var retType = 'obj_float' + size;
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	866 var retName = 'retfloat' + size;
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	867 var vars = {};
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	868 vars[retName] = retType + ' *';
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	869 intObj.addMessage((size > bits ? 'f' : 'truncF') + size, {
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	870 vars: vars,
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	871 lines: [
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	872 retName + ' = make_object(&' + retType + '_meta, NULL, 0);',
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	873 retName + '->num = self->num;',
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	874 'return &(' + retName + '->header);'
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	875 ]
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	876 })
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	877 }
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	878 }
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	879
135 f98790d8a53d Add int64, int16 and int8. Also add hex method to integer types. Mike Pavone <pavone@retrodev.com> parents: 134 diff changeset	880 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	881 }
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	882
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	883 function makeFloat(bits)
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	884 {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	885 var typename = 'obj_float' + bits;
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	886 var floatObj = new cObject(typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	887 floatObj.addProperty('num', null, bits == 32 ? 'float' : 'double');
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	888 addNumberOps(floatObj, typename);
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	889
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	890 floatObj.addInclude('<string.h>');
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	891 floatObj.addMessage('string', {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	892 vars: {str: 'string *'},
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	893 lines: [
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	894 'str = (string *)make_object(&string_meta, NULL, 0);',
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	895 //probably overkill, but lets play it safe for now
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	896 'str->data = GC_MALLOC(128);',
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	897 'sprintf(str->data, "%f", self->num);',
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	898 'str->len = str->bytes = strlen(str->data);',
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	899 'return &(str->header);'
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	900 ]
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	901 });
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	902 floatObj.addMessage('f' + bits, {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	903 vars: {},
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	904 lines: [
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	905 'return &(self->header);'
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	906 ]
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	907 });
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	908
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	909 floatObj.addMessage('f' + (bits == 32 ? 64 : 32), {
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	910 vars: {trans: 'obj_float' + (bits == 32 ? 64 : 32) + ' *'},
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	911 lines: [
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	912 'trans = make_object(&obj_float' + (bits == 32 ? 64 : 32) + '_meta, NULL, 0);',
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	913 'trans->num = self->num;',
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	914 'return &(trans->header);'
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	915 ]
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	916 });
325 4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	917 var sizes = [8, 16, 32, 64];
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	918 var prefixes = ['U', ''];
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	919 for (var i = 0; i < sizes.length; i++) {
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	920 for (var j = 0; j < prefixes.length; j++) {
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	921 var ret = 'ret' + i + j;
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	922 var vars = {};
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	923 var retType = 'obj_' + prefixes[j].toLowerCase() + 'int' + sizes[i];
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	924 vars[ret] = retType + ' *';
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	925 floatObj.addMessage('trunc' + prefixes[j] + 'Int' + sizes[i], {
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	926 vars: vars,
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	927 lines: [
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	928 ret + ' = make_object(&' + retType + '_meta, NULL, 0);',
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	929 ret + '->num = self->num;',
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	930 'return &(' + ret + '->header);'
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	931 ]
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	932 });
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	933 }
4a79311dbd29 Added conversion methods between integer and float types Michael Pavone <pavone@retrodev.com> parents: 320 diff changeset	934 }
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	935 return floatObj;
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	936 }
ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	937
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	938 function makeCPointer()
282 361a449a7235 Add some extra parens in addr_of translation and fix cleaning of names in llMessage parameters Michael Pavone <pavone@retrodev.com> parents: 273 diff changeset	939 {
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	940 var cptr = new cObject('cpointer');
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	941 cptr.addProperty('val', null, 'void *');
282 361a449a7235 Add some extra parens in addr_of translation and fix cleaning of names in llMessage parameters Michael Pavone <pavone@retrodev.com> parents: 273 diff changeset	942 //cpointer:
273 0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	943 //1234567890
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	944 cptr.addMessage('string', {
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	945 vars: {ret: 'string *'},
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	946 lines: [
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	947 'ret = make_object(&string_meta, NULL, 0);',
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	948 //22 digits for worst case sensible representation
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	949 //10 chars for prefix
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	950 //4 for slop
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	951 //1 for null terminator
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	952 'ret->data = GC_MALLOC_ATOMIC(22+10+4+1);',
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	953 'snprintf(ret->data, 22+10+4, "cpointer: %p", self->val);',
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	954 'ret->data[22+10+4] = 0;',
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	955 'return (object *)ret;'
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	956 ]
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	957 });
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	958 return cptr;
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	959 }
0dc7322590da Make import:from actually work. Fix some macro bugs. Add a cpointer primitive type for storing an opaque pointer to a C object. Michael Pavone <pavone@retrodev.com> parents: 272 diff changeset	960
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	961 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	962 {
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	963 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	964 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	965 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	966 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	967 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	968 }
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	969
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	970 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	971 {
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	972 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	973 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	974 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	975 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	976 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	977 }
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	978
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	979 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	980 {
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	981 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	982 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	983 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	984 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	985 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	986 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	987 '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	988 '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	989 '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	990 ' 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	991 '}',
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	992 '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	993 ]
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	994 });
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	995 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	996 }
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	997
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	998 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	999 {
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	1000 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	1001 makeInt(64, true) , makeInt(32, true), makeInt(16, true), makeInt(8, true),
286 ddf38b66b2e2 Finish support for floating point numbers in C backend Michael Pavone <pavone@retrodev.com> parents: 285 diff changeset	1002 makeFloat(32), makeFloat(64), makeArray(), makeString(), makelambda(), makeCPointer()];
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	1003 }
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	1004
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	1005 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	1006 return this.ast.toCModuleInstance();
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	1007 };
25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	1008
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1009 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	1010 {
289 befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1011 var alwaysused = ['list', 'true', 'false'];
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1012 var ret = '';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1013 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	1014 var visited = {};
289 befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1015 var 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	1016 for (var i in alwaysused) {
289 befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1017 delete toplevel.used[alwaysused[i]];
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1018 visited[alwaysused[i]] = true;
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	1019 }
289 befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1020 var addedAlways = false;
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	1021 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	1022 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	1023 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	1024 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	1025 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	1026 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	1027 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	1028 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	1029 }
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	1030 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	1031 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	1032 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	1033 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	1034 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	1035 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	1036 }
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	1037 }
289 befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1038 if (!newused.length && !addedAlways) {
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1039 addedAlways = true;
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1040 for (var i in alwaysused) {
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1041 toplevel.used[alwaysused[i]] = true;
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1042 newused.push(alwaysused[i]);
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1043 allused.push(alwaysused[i]);
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1044 }
befaefdfcd8a Make sure that true and false modules are initialized before anything else and that the list module is initialized before any modules besides true and false Michael Pavone <pavone@retrodev.com> parents: 288 diff changeset	1045 }
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	1046 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1047
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	1048 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	1049 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	1050 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	1051 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	1052 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	1053 assignNames.pop();
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1054 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1055 return ret;
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1056 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1057
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	1058 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	1059 {
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	1060 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	1061 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	1062 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	1063 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	1064 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	1065 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	1066 }
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1067 debugprint('//------POPULATING SYMBOLS-----');
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1068 obj.populateSymbols(toplevel);
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	1069 var moduleinit = processUsedToplevel(toplevel);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1070 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	1071 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	1072 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	1073 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	1074 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	1075 }
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	1076 mnames += '};\n';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1077 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	1078 '#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	1079 '#define METHOD_ID_EMPTY ' + getMethodId('empty') + '\n' +
18598163e3ef Add linked list implementation and cons operator Mike Pavone <pavone@retrodev.com> parents: 146 diff changeset	1080 '#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	1081 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	1082 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1083
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1084 object.prototype.toCModule = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1085 return makeCProg(this);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1086 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1087
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1088 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	1089 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	1090 }
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1091
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1092 lambda.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1093 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	1094 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	1095 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	1096 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	1097 var addedTypeDef = false;
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1098 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	1099 this.symbols.envtype = this.name + '_env';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1100 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	1101 var addedTypeDef = true;
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1102 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1103 if (this.selftype) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1104 this.symbols.defineVar('self', this.selftype);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1105 if (args[0] && args[0].cleanName() == 'self') {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1106 args.splice(0, 1);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1107 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1108 var offset = 1;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1109 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1110 var offset = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1111 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1112 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	1113 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	1114 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	1115 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	1116 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1117 var compiled = []
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1118 for (var i in exprs) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1119 var js = exprs[i].toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1120 if (js) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1121 compiled.push(indent(js));
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1122 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1123 }
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	1124 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	1125 if (exprs[exprs.length - 1] instanceof assignment) {
267 d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1126 compiled.push('return (object *)' + exprs[exprs.length - 1].symbol.toC() + ';');
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	1127 } 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	1128 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	1129 }
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	1130 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1131 exprs = compiled;
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1132
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1133 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	1134 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	1135 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	1136 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	1137 }
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	1138 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	1139 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1140 forwarddec += 'struct ' + this.name + '_env {\n';
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	1141 if (this.symbols.needsParentEnv) {
08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	1142 forwarddec += '\tstruct ' + this.symbols.parentEnvType() + ' * parent;\n';
08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	1143 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1144 for (var varname in this.symbols.closedover) {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1145 if (varname == 'self' && this.selftype) {
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1146 forwarddec += '\tstruct ' + this.selftype + ' * self;\n';
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1147 } else {
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1148 forwarddec += '\tobject * ' + escapeCName(varname) + ';\n';
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1149 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1150 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1151 forwarddec += '};\n'
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1152
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1153 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	1154 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	1155 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	1156 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1157 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	1158 } else {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1159 var myenvinit = '';
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1160 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1161 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	1162
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	1163 toplevelcode += '//' + assignPath + "\n";
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1164 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	1165 if (this.selftype) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1166 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	1167 if (selfvar == 'self') {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1168 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	1169 } else {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1170 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	1171 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	1172
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1173 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1174 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	1175
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1176 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	1177 return this.name;
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1178 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1179 if (this.symbols.parentEnvType() != 'void') {
55 93ddb4ad6fcb Fix some nested closure bugs Mike Pavone <pavone@retrodev.com> parents: 54 diff changeset	1180 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	1181 var envvar = 'env';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1182 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1183 var envvar = 'myenv';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1184 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	1185 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	1186 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	1187 } else {
143 282b8056b702 Lambda bugfix and some improvments to the llMessage support Mike Pavone <pavone@retrodev.com> parents: 142 diff changeset	1188 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	1189 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	1190 }
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	1191 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1192 };
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1193 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	1194 this.toC();
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	1195 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	1196 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1197 lambda.prototype.toCObject = function(typename) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1198 this.selftype = typename;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1199 return this.toC();
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 lambda.prototype.toCModule = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1202 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	1203 };
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	1204 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	1205 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	1206 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	1207 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	1208 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	1209 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	1210 }
282 361a449a7235 Add some extra parens in addr_of translation and fix cleaning of names in llMessage parameters Michael Pavone <pavone@retrodev.com> parents: 273 diff changeset	1211 if (name[0] >= "0" && name[0] <= "9") {
361a449a7235 Add some extra parens in addr_of translation and fix cleaning of names in llMessage parameters Michael Pavone <pavone@retrodev.com> parents: 273 diff changeset	1212 name = '_tp_' + name;
361a449a7235 Add some extra parens in addr_of translation and fix cleaning of names in llMessage parameters Michael Pavone <pavone@retrodev.com> parents: 273 diff changeset	1213 }
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	1214 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	1215 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	1216 }
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	1217 }
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	1218 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	1219 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	1220 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	1221 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	1222 }
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	1223 }
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	1224 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	1225 }
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	1226 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	1227 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	1228 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	1229 }
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	1230 return this.expressions[0].toCLLExpr(vars);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1231 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1232
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1233 assignment.prototype.toC = function() {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1234 debugprint('//assignment', this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1235 var existing = this.symbols.find(this.symbol.name);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1236 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	1237 assignNames.push(this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1238 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	1239 assignNames.pop(this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1240 if (val === null) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1241 return null;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1242 }
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1243 if (existing.type == 'local' && !existing.isdeclared) {
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1244 prefix = 'object *';
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1245 this.symbols.declareVar(this.symbol.name);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1246 debugprint('//declared var', this.symbol.name);
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1247 }
267 d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1248 var cast = '';
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1249 if (this.symbol.name == 'self') {
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1250 //ugly hack alert
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1251 cast = '(void *)';
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1252 } else {
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1253 cast = '(object *)';
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1254 }
d2b70cba661e Warning cleanup Michael Pavone <pavone@retrodev.com> parents: 266 diff changeset	1255 return prefix + this.symbol.toC() + ' = ' + cast + val;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1256 };
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1257 assignment.prototype.toCObject = function(cobj) {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1258 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	1259 assignNames.push('#' + this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1260 if (this.expression.toCObject) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1261 var val = this.expression.toCObject(cobj.name);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1262 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1263 var val = this.expression.toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1264 }
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	1265 assignNames.pop();
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1266 if (val === null) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1267 return;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1268 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1269 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	1270 var params = ['((object *)self)'];
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1271 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	1272 var messagevars = {};
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1273 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	1274 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	1275 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	1276 messagevars[escaped] = 'object *';
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1277 params.push(escaped);
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1278 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	1279 }
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1280 }
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	1281 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	1282 vars: messagevars,
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1283 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	1284 });
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1285 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1286 cobj.addProperty(this.symbol.name, val);
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	1287 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	1288 cobj.addInit('self->' + escapeCName(this.symbol.name) + '->parent = (object *)self;');
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	1289 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1290 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1291 };
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	1292 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	1293 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	1294 };