repos/tabletprog: cbackend.js annotate

annotate cbackend.js @ 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.

author	Michael Pavone <pavone@retrodev.com>
date	Sun, 20 Jul 2014 00:12:43 -0700
parents	bb2b4613fdc8
children	361a449a7235

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