repos/tabletprog: cbackend.js annotate

annotate cbackend.js @ 141:15aac5334b64

Started work on replacing nodes with a symbol when a symbol button is clicked

author	Mike Pavone <pavone@retrodev.com>
date	Fri, 09 Aug 2013 01:36:53 -0700
parents	bf8f75b69048
children	833624457b81

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 nextmethodId = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	5 var methodIds = {};
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	6 function getMethodId(methodName)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	7 {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	8 if (!(methodName in methodIds)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	9 methodIds[methodName] = nextmethodId++;
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	10
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	11 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	12 return methodIds[methodName];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	13 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	14
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	15 function getOpMethodName(opname)
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	16 {
97 59a94f3ad56f Added short-circuit && and \|\| operators Mike Pavone <pavone@retrodev.com> parents: 96 diff changeset	17 var optoMeth = {'+': 'ADD_', '-': 'SUB_', '*': 'MUL_', '/': 'DIV_', '%': 'MOD_', '=': 'EQ_', '!=': 'NEQ_', '<': 'LT_', '>': 'GT_', '>=': 'GEQ_', '<=': 'LEQ_', '.': 'CAT_', '&&':'if', '\|\|':'ifnot'};
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	18 if (opname in optoMeth) {
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	19 return optoMeth[opname];
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	20 } else {
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	21 return opname;
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	22 }
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 op.prototype.toC = function(isReceiver) {
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	26 var method = getOpMethodName(this.op);
9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	27 return 'mcall(' + getMethodId(method) + '/* operator ' + method + ' /, 2, (object )' + this.left.toC() + ', ' + this.right.toC() + ')\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	28 };
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	29 op.prototype.toCLLExpr = function(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	30 var opmap = {'=': '==', 'xor': '^'};
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	31 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	32 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	33 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	34 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	35 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	36
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	37
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	38 function escapeCName(name)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	39 {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	40 if (name == 'self') {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	41 return name;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	42 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	43 name = name.replace("_", "UN_").replace(":", "CN_").replace("!", "EX_").replace('?', 'QS_').replace('@', 'AT_');
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	44 name = 'tp_' + name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	45 return name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	46 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	47
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	48 function getSymbolPrefix(info, symbols)
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	49 {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	50 var pre = '';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	51 switch(info.type) {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	52 case 'self':
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	53
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	54 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	55 break;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	56 case 'parent':
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	57 pre = (new symbol('self', symbols)).toC() + '->header.';
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	58 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	59 pre += (i ? '->' : '') + 'parent';
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	60 }
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	61 pre = '((' + info.selftype + ' *)' + pre + ')->';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	62 break;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	63 case 'upvar':
32 64f1d516fbfd Tiny bit of work on closures Mike Pavone <pavone@retrodev.com> parents: 31 diff changeset	64 pre = 'env->';
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	65 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	66 pre += 'parent->';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	67 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	68 break;
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	69 case 'recupvar':
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	70 if (info.subtype == 'object') {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	71 pre = 'self->env->';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	72 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	73 //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	74 }
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	75 pre += getSymbolPrefix(info.parent);
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	76 case 'closedover':
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	77 pre = 'myenv->';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	78 }
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	79 return pre;
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	80 }
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	81
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	82 symbol.prototype.toC = function() {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	83 var name = this.cleanName();
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	84 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	85 if (!info) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	86 throw new Error('symbol ' + name + ' not found');
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	87 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	88 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	89 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	90 } else if (info.type == 'self' && info.def instanceof lambda) {
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	91 return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, ' + (new symbol('self', this.symbols)).toC() + ')';
ba032565c7a5 Fix handling of variable style access to self and parent object messages defined with lambdas. Improve test case for this bug to include parent object access as well as self object access. Mike Pavone <pavone@retrodev.com> parents: 68 diff changeset	92 } 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	93 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	94 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	95 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	96 }
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 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	98 }
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	99 return getSymbolPrefix(info, this.symbols) + escapeCName(name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	100 }
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	101 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	102 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	103 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	104 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	105 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	106 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	107 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	108 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	109 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	110 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	111 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	112 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	113 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	114 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	115 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	116 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	117 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 (!info) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	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 (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	122 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	123 } 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	124 if (info.isll \|\| !(info.def instanceof lambda)) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	125 return 'self->' + name;
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	126 } 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	127 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	128 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	131 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	133 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	134 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	135
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	136 var declaredInts = {};
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	137
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	138 intlit.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	139 var str = this.val < 0 ? 'neg_' + (0-this.val).toString() : this.val.toString();
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	140 if (!(this.val in declaredInts)) {
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	141 toplevelcode += 'obj_int32 int32_' + str + ' = {{&obj_int32_meta, NULL}, ' + this.val.toString() + '};\n';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	142 declaredInts[this.val] = true;
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	143 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	144 return '((object *)&int32_' + str + ')';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	145 }
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	146 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	147 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	148 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	149 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	150 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	151 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	152
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	153 floatlit.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	154 return 'make_float(' + this.val.toString() + ')';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	155 }
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	156 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	157 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	158 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	160 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	161 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	162
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	163 var declaredStrings = {};
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	164 var nextStringId = 0;
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	165
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	166 strlit.prototype.toC = function() {
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	167 if (!(this.val in declaredStrings)) {
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	168 //TODO: get the proper byte length
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	169 toplevelcode += 'string str_' + nextStringId + ' = {{&string_meta, NULL}, ' + this.val.length + ', ' + this.val.length + ', "' + this.val.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\r', '\\r') + '"};\n';
41 0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	170 declaredStrings[this.val] = nextStringId++;
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	171 }
0558dad9d061 Add basic string support Mike Pavone <pavone@retrodev.com> parents: 40 diff changeset	172 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	173 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 strlit.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	175 return '"' + this.val.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\r', '\\r') + '"';
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	176 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	177 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	178 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	179 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	180
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	181 listlit.prototype.toC = function() {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	182 var ret = 'make_list(' + this.val.length;
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	183 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	184 ret += ', ' + this.val[i].toC();
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	185 }
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	186 return ret + ')';
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	187 }
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	188
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	189 arraylit.prototype.toC = function() {
40 927fd7911a01 Add append message to array Mike Pavone <pavone@retrodev.com> parents: 39 diff changeset	190 var ret = 'make_array(' + this.val.length;
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	191 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	192 ret += ', ' + this.val[i].toC();
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	193 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	194 return ret + ')';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	195 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	196
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	197 funcall.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	198 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	199 if (name == 'foreign') {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	200 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	201 return null;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	202 } else if(this.args[0] instanceof symbol) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	203 return this.args[0].name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	204 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	205 throw new Error("Unexpected AST type for foreign:");
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	206 }
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	207 } else if(name == 'llProperty:withType' \|\| name == 'llProperty:withVars:andCode') {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	208 return null;
31 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 var args = this.args.slice(0, this.args.length);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	211 if (this.receiver) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	212 args.splice(0, 0, this.receiver);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	213 }
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	214 var method = false;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	215 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	216 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	217 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	218 method = true;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	219 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	220 switch(funinfo.type)
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	221 {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	222 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	223 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	224 var defargs = funinfo.def.args.length;
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	225 if (!defargs \|\| funinfo.def.args[0].name != '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	226 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	227 }
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	228 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	229 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	230 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	231 } 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	232 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	233 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	234 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	235 }
ab6f24d6945d Fix determination of whether a method call has an implicit self argument or not. Cleanup C warnings in output. Mike Pavone <pavone@retrodev.com> parents: 69 diff changeset	236 args.splice(0, 0, ', ' + 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	237 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	238 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	239 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	240 method = true;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	241 break;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	242 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	243 }
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	244 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	245 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	246 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	247 var callpart;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	248 if (method) {
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	249 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	250 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	251 } else {
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	252 callpart = 'mcall(' + getMethodId(name) + '/* ' + name + ' */';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	253 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	254 } else {
55 93ddb4ad6fcb Fix some nested closure bugs Mike Pavone <pavone@retrodev.com> parents: 54 diff changeset	255 callpart = 'ccall(' + (new symbol(name, this.symbols)).toC();
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	256 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	257 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	258 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	259 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	260 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	261 {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	262 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	263 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	264 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	265 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	266 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	267 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	268 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	269 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	270 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	271 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	272 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	273 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	274 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	275 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	276 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	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 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	279 {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	281 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	282 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	283 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	284 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	285 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	286 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	287 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	288 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	289 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	290 } 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	291 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	292 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	293 break;
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	294 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	295 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	296 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	297 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	298 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	299 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	300 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	301 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	302 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	303 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	304 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	305 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	306 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	307 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	308 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	309 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	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 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	312 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	313 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	314 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	315 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	317 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	318 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	319 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	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 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	322 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	323
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	325 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	326 var args = this.args.slice(0, this.args.length);
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	327 if (this.receiver) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	328 if(this.args.length == 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	329 return this.receiver.toCLLExpr(vars) + '->' + 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	330 } else if (this.args.length == 1 && name[name.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	331 return this.receiver.toCLLExpr(vars) + '->' + this.name.substr(0, name.length-1) + ' = ' + 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	332 } 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	333 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	334 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having 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 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	337 {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	338 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	339 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	340 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	341 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	342 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	343 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	344 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	345 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	346 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	347 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	348 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	349 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	350 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	351 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	352 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	353 return '!(' + 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	354 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	355 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	356 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	357 }
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	358 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	359 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	360 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	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 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	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 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	365
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	366 function cObject(name) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	367 this.name = name;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	368 this.slots = {};
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	369 this.properties = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	370 this.values = [];
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	371 this.slotvars = {};
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	372 this.includes = {};
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	373 this.parent = 'NULL';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	374 this.init = [];
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	375 this.initmsgadded = false;
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	376 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	377
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	378 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	379 this.includes[includefile] = true;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	380 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	381
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	382 cObject.prototype.addMessage = function(msgname, implementation) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	383 var methodid = getMethodId(msgname);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	384 var trunc = methodid & 0xF;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	385 if (!(trunc in this.slots)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	386 this.slots[trunc] = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	387 }
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	388 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	389 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	390 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	391 }
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	392 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	393 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	394 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	395 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	396
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	397 cObject.prototype.addProperty = function(propname, value, type) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	398 if (type != undefined) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	399 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	400 if (value !== null) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	401 this.values.push(value);
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	402 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	403 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	404 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	405 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	406 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	407 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	408 'return self->' + escaped + ';'
a6bf4869fcbe Small refactor of built-in int32 type and added support for more operators on said type Mike Pavone <pavone@retrodev.com> parents: 35 diff changeset	409 ]});
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	410 this.addMessage(propname + '!', {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	411 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	412 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	413 '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	414 '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	415 ]});
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	416 this.properties.push(escaped);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	417 this.values.push(value);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	418 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	419 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	420
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	421 cObject.prototype.addInit = function(statement) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	422 this.init.push(statement);
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	423 };
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	424
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	425 cObject.prototype.addImport = function(symbols, source) {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	426 this.imported.push(source);
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	427 var importNum = imported.length - 1;
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	428 if (symbols) {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	429 each(symbols, function(i, sym) {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	430 this.addMessage(sym.name, {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	431 vars: {},
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	432 lines: [
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	433 'return self->import_' + importNum + '->meta->meth_lookup[method_id & 0xF](method_id, num_args, self->import_' + importNum + ', args);'
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	434 ]
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	435 });
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	436 });
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	437 } else {
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	438 //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	439 }
bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	440 };
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	441
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	442 cObject.prototype.checkInitMsg = function() {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	443 if (!this.initmsgadded && this.init.length) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	444 var init = this.init.slice(0, this.init.length);
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	445 init.push('return (object *)self;');
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	446 this.addMessage('_init', {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	447 vars: {},
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	448 lines: init
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	449 });
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	450 this.initmsgadded = true;
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	451 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	452 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	453
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	454 cObject.prototype.populateSymbols = function() {};
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	455
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	456 cObject.prototype.toEarlyCDef = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	457 this.checkInitMsg();
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	458 var includes = '';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	459 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	460 includes += '#include ' + file + '\n';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	461 }
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	462 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	463 for (var i in this.properties) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	464 if (this.properties[i] instanceof Array) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	465 objdef += '\t' + this.properties[i][1] + ' ' + this.properties[i][0] + ';\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	466 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	467 objdef += '\tobject * ' + this.properties[i] + ';\n'
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	468 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	469 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	470 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	471 return includes + objdef;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	472 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	473
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	474 cObject.prototype.toCDef = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	475 this.checkInitMsg();
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	476 var slotdefs = '';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	477 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	478 for (var i = 0; i < 16; i++) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	479 if (i) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	480 metadef += ', ';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	481 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	482 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	483 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	484 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	485 for (var varname in this.slotvars[i]) {
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	486 slotdefs += '\t' + this.slotvars[i][varname] + ' ' + varname + ';\n';
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	487 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	488 if (this.slots[i].length == 1) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	489 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	490 '\t\t' + this.slots[i][0][1] + '\n' +
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	491 '\t}\n' +
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	492 '\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	493 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	494 slotdefs += '\tswitch(method_id) {\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	495 for (j in this.slots[i]) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	496 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	497 '\t\t\t' + this.slots[i][j][1] + '\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	498 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	499 slotdefs += '\t\tdefault:\n' +
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	500 '\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	501
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	502 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	503 metadef += this.name + '_slot_' + i;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	504 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	505 metadef += 'no_impl';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	506 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	507 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	508 metadef += '}};\n';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	509 return slotdefs + metadef;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	510 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	511
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	512 cObject.prototype.toCInstance = function() {
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	513 this.checkInitMsg();
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	514 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	515 if (this.initmsgadded) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	516 ret = 'mcall(' + getMethodId('_init') + ', 1, ' + ret + ')'
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	517 }
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	518 return ret;
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	519 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	520
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	521 cObject.prototype.toC = function() {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	522 forwarddec += this.toEarlyCDef();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	523 toplevelcode += this.toCDef();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	524 return this.toCInstance();
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	525 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	526
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	527 var nextobject = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	528
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	529
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	530 object.prototype.toCObject = function() {
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	531 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	532 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	533 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	534 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	535 var me = new cObject(this.name);
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	536 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	537 if (this.symbols.needsenv) {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	538 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	539 me.hasenv = true;
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	540 }
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	541 if (this.symbols.needsparent && !(this.symbols.parent instanceof osymbols)) {
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	542 me.parent = '(object *)(' + (new symbol('self', this.symbols.parent)).toC() + ')';
0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	543 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	544 for (var i in messages) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	545 if (messages[i] instanceof funcall) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	546 if (messages[i].name == 'import:' && messages[i].args.length == 1) {
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	547 me.addImport(false, messages[i].args[0]);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	548 } else if(messages[i].name == 'import:from:' && messages[i].args.length == 2) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	549 var importsyms = [];
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	550 each(messages[i].args[0].val, function(i, el) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	551 if (!(el instanceof symbol)) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	552 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	553 }
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	554 importsyms.push(el);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	555 });
140 bf8f75b69048 Minor progress towards supporting imports in the C backend Mike Pavone <pavone@retrodev.com> parents: 122 diff changeset	556 me.addImport(importsyms, messages[i].args[1]);
84 9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	557 } else if(messages[i].name == 'llProperty:withType:' && messages[i].args.length == 2) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	558 me.addProperty(messages[i].args[0].name, null, messages[i].args[1].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	559 } else if(messages[i].name == 'llMessage:withVars:andCode:' && messages[i].args.length == 3) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	560 var msgname = messages[i].args[0].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	561 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	562 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	563 for(var v in rawvars) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	564 vars[rawvars[v].symbol.name] = rawvars[v].expression.toCTypeName();
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	565 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	566 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	567 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	568 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	569 });
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	570 } else {
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	571
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	572 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	573 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	574 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	575 messages[i].toCObject(me);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	576 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	577 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	578
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	579 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	580 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	581
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	582 object.prototype.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	583 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	584 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	585
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	586 var toplevelcode;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	587 var forwarddec;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	588
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	589 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	590 {
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	591 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	592 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	593 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	594 '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	595 '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	596 '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	597 '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	598 ]
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	599 });
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	600 }
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	601
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	602 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	603 {
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	604 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	605 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	606 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	607 '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	608 '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	609 ' 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	610 '}',
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	611 '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	612 ]
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	613 });
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	614 }
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	615
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	616 function makeInt32()
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	617 {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	618 var int32 = new cObject('obj_int32');
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	619 int32.addProperty('num', null, 'int32_t');
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	620 addBinaryOp(int32, 'ADD_', '+', 'obj_int32');
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	621 addBinaryOp(int32, 'SUB_', '-', 'obj_int32');
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	622 addBinaryOp(int32, 'MUL_', '*', 'obj_int32');
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	623 addBinaryOp(int32, 'DIV_', '/', 'obj_int32');
67 42d5660b30b4 added remainder operator William Morgan <bill@mrgn.org> parents: 66 diff changeset	624 addBinaryOp(int32, 'MOD_', '%', 'obj_int32');
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	625 addCompOp(int32, 'LT_', '<', 'obj_int32');
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	626 addCompOp(int32, 'GT_', '>', 'obj_int32');
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	627 addCompOp(int32, 'EQ_', '==', 'obj_int32');
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	628 addCompOp(int32, 'NEQ_', '!=', 'obj_int32');
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	629 addCompOp(int32, 'GEQ_', '>=', 'obj_int32');
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	630 addCompOp(int32, 'LEQ_', '<=', 'obj_int32');
52 ab6217b8ae4c Remove some C compiler warnings due to sloppy native code Mike Pavone <pavone@retrodev.com> parents: 49 diff changeset	631 int32.addInclude('<string.h>');
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	632 int32.addMessage('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	633 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	634 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	635 '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	636 'str->data = GC_MALLOC(12);',
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	637 'sprintf(str->data, "%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	638 '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	639 '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	640 ]
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	641 });
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	642 int32.addMessage('isInteger?', {
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	643 vars: {},
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	644 lines: [
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	645 '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	646 ]
1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	647 });
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	648 int32.addMessage('hash', {
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	649 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	650 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	651 '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	652 ]
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	653 });
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	654 return int32;
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	655 }
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	656
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	657 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	658 {
84 9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	659 var 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	660 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	661 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	662 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	663 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	664 }
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	665
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	666 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	667 {
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	668 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	669 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	670 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	671 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	672 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	673 }
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	674
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	675 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	676 {
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	677 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	678 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	679 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	680 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	681 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	682 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	683 '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	684 '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	685 '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	686 ' 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	687 '}',
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	688 '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	689 ]
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	690 });
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	691 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	692 }
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	693
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	694 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	695 {
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	696 return [makeInt32(), makeArray(), makeString(), 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	697 }
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	698
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	699 function addBuiltinModules(toplevel)
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	700 {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	701 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	702 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	703 os.addInclude('<fcntl.h>');
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	704 os.addMessage('write', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	705 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	706 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	707 '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	708 'str = va_arg(args, string *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	709 '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	710 'intret->num = write(filedes->num, str->data, str->bytes);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	711 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	712 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	713 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	714 os.addMessage('read', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	715 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	716 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	717 '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	718 'size = va_arg(args, obj_int32 *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	719 '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	720 'str->data = GC_MALLOC_ATOMIC(size->num + 1);',
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	721 'str->length = str->bytes = read(filedes->num, str->data, size->num);',
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	722 'if (str->bytes < 0) { str->bytes = str->length = 0; }',
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	723 'str->data[str->bytes] = 0;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	724 'return &(str->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	725 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	726 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	727 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	728 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	729 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	730 '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	731 'flags = va_arg(args, obj_int32 *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	732 '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	733 '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	734 ' 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	735 '} 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	736 ' 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	737 ' 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	738 '} 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	739 ' 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	740 '}',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	741 'return &(filedes->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	742 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	743 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	744 os.addMessage('close', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	745 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	746 lines: [
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	747 'filedes = va_arg(args, obj_int32 *);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	748 '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	749 'intret->num = close(filedes->num);',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	750 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	751 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	752 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	753 os.addMessage('O_RDONLY', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	754 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	755 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	756 '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	757 'intret->num = O_RDONLY;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	758 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	759 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	760 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	761 os.addMessage('O_WRONLY', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	762 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	763 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	764 '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	765 'intret->num = O_WRONLY;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	766 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	767 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	768 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	769 os.addMessage('O_RDWR', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	770 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	771 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	772 '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	773 'intret->num = O_RDWR;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	774 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	775 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	776 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	777 os.addMessage('O_CREAT', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	778 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	779 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	780 '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	781 'intret->num = O_CREAT;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	782 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	783 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	784 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	785 os.addMessage('O_APPEND', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	786 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	787 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	788 '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	789 'intret->num = O_APPEND;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	790 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	791 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	792 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	793 os.addMessage('O_TRUNC', {
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	794 vars: {intret: 'obj_int32 *'},
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	795 lines: [
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	796 '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	797 'intret->num = O_TRUNC;',
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	798 'return &(intret->header);'
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	799 ]
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	800 });
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	801 toplevel.names['os'] = os;
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	802 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	803
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	804 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	805 return this.ast.toCModuleInstance();
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	806 };
25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	807
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	808 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	809 {
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	810 var alwaysused = ['true', 'false'];
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	811 var ret = '';
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	812 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	813 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	814 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	815 toplevel.used[alwaysused[i]] = true;
66 25b697c91629 Finish implementation of external module access Mike Pavone <pavone@retrodev.com> parents: 61 diff changeset	816 }
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	817 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	818 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	819 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	820 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	821 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	822 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	823 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	824 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	825 }
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	826 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	827 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	828 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	829 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	830 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	831 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	832 }
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	833 }
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	834 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	835
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	836 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	837 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	838 debugprint('//---module', symbol, '(' + i +')--- compile');
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	839 ret += '\t' + toplevel.moduleVar(symbol) + ' = ' + toplevel.names[symbol].toC() + ';\n';
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	840 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	841 return ret;
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	842 }
18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	843
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	844 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	845 {
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	846 forwarddec = toplevelcode = '';
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	847 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	848 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	849 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	850 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	851 }
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	852 addBuiltinModules(toplevel);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	853 debugprint('//------POPULATING SYMBOLS-----');
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	854 obj.populateSymbols(toplevel);
48 18ab96287c3a Add builtin module os containing some baisc POSIX file IO Mike Pavone <pavone@retrodev.com> parents: 45 diff changeset	855 var moduleinit = processUsedToplevel(toplevel);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	856 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	857 var rest = 'object * mainModule() {\n' + moduleinit + '\tmain_module = ' + obj.toCModuleInstance() + ';\n\treturn main_module;\n}\n';
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	858 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	859 '#define METHOD_ID_MAIN ' + getMethodId('main') + '\n' +
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	860 forwarddec + toplevelcode + rest + '#include "runtime/progfoot.inc"\n';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	861 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	862
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	863 object.prototype.toCModule = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	864 return makeCProg(this);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	865 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	866
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	867 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	868 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	869 }
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	870
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	871 lambda.prototype.toC = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	872 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	873 var exprs = this.expressions;
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	874 debugprint('//', this.name);
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	875 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	876 this.symbols.envtype = this.name + '_env';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	877 forwarddec += 'typedef struct ' + this.symbols.envtype + ' ' + this.symbols.envtype + ';\n'
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	878 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	879 if (this.selftype) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	880 this.symbols.defineVar('self', this.selftype);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	881 if (args[0] && args[0].cleanName() == 'self') {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	882 args.splice(0, 1);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	883 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	884 var offset = 1;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	885 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	886 var offset = 0;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	887 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	888 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	889 var argname = args[i].toC();
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	890
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	891 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	892 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	893 var compiled = []
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	894 for (var i in exprs) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	895 var js = exprs[i].toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	896 if (js) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	897 compiled.push(indent(js));
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	898 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	899 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	900 exprs = compiled;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	901 if (exprs.length) {
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	902 exprs[exprs.length-1] = 'return (object *)(' + exprs[exprs.length-1] + ');';
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	903 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	904
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	905 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	906 forwarddec += 'struct ' + this.name + '_env {\n';
57 08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	907 if (this.symbols.needsParentEnv) {
08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	908 forwarddec += '\tstruct ' + this.symbols.parentEnvType() + ' * parent;\n';
08ae75d90dc2 Add != operator. Fix more closure bugs. Mike Pavone <pavone@retrodev.com> parents: 55 diff changeset	909 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	910 for (var varname in this.symbols.closedover) {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	911 if (varname == 'self' && this.selftype) {
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	912 forwarddec += '\tstruct ' + this.selftype + ' * self;\n';
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	913 } else {
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	914 forwarddec += '\tobject * ' + escapeCName(varname) + ';\n';
976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	915 }
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	916 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	917 forwarddec += '};\n'
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	918
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	919 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	920 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	921 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	922 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	923 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	924 } else {
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	925 var myenvinit = '';
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	926 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	927 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	928
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	929 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	930 if (this.selftype) {
34 a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	931 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	932 if (selfvar == 'self') {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	933 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	934 } else {
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	935 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	936 }
121 1a4446f573d3 Add isInteger? method to the int32 type in the C backend Mike Pavone <pavone@retrodev.com> parents: 97 diff changeset	937
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	938 }
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	939 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	940
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	941 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	942 return this.name;
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	943 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	944 if (this.symbols.parentEnvType() != 'void') {
55 93ddb4ad6fcb Fix some nested closure bugs Mike Pavone <pavone@retrodev.com> parents: 54 diff changeset	945 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	946 var envvar = 'env';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	947 } else {
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	948 var envvar = 'myenv';
4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	949 }
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	950 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	951 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	952 } else {
96 84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	953 toplevelcode += 'lambda ' + this.name + '_obj = {{&lambda_meta, NULL}, NULL, lambda_' + mynum + '};\n';
84b65ee8b78b Optimize self method calls into static function calls Mike Pavone <pavone@retrodev.com> parents: 95 diff changeset	954 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	955 }
a10f1b049193 Working closures, but need to rethink method call strategy Mike Pavone <pavone@retrodev.com> parents: 32 diff changeset	956 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	957 };
60 ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	958 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	959 this.toC();
ef3b34c2c0a4 Fix populatesymbols for parent property references. Fix lambda-style modules in cbackend. Mike Pavone <pavone@retrodev.com> parents: 59 diff changeset	960 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	961 };
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	962 lambda.prototype.toCObject = function(typename) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	963 this.selftype = typename;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	964 return this.toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	965 };
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	966 lambda.prototype.toCModule = function() {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	967 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	968 };
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	969 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	970 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	971 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	972 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	973 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	974 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	975 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	976 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	977 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	978 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	979 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	980 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	981 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	982 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	983 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	984 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	985 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	986 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	987 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	988 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	989 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	990 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	991 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature. Mike Pavone <pavone@retrodev.com> parents: 79 diff changeset	992 return this.expressions[0].toCLLExpr(vars);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	993 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	994
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	995 assignment.prototype.toC = function() {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	996 debugprint('//assignment', this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	997 var existing = this.symbols.find(this.symbol.name);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	998 var prefix = '';
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	999 var val = this.expression.toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1000 if (val === null) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1001 return null;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1002 }
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1003 if (existing.type == 'local' && !existing.isdeclared) {
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1004 prefix = 'object *';
e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1005 this.symbols.declareVar(this.symbol.name);
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1006 debugprint('//declared var', this.symbol.name);
38 e7be612fd3ae Very basic array support Mike Pavone <pavone@retrodev.com> parents: 37 diff changeset	1007 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1008 return prefix + this.symbol.toC() + ' = ' + val;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1009 };
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1010 assignment.prototype.toCObject = function(cobj) {
54 976a0924e1d4 Fix closure over self var Mike Pavone <pavone@retrodev.com> parents: 52 diff changeset	1011 debugprint('//message definition', this.symbol.name);
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1012 if (this.expression.toCObject) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1013 var val = this.expression.toCObject(cobj.name);
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1014 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1015 var val = this.expression.toC();
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1016 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1017 if (val === null) {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1018 return;
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1019 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1020 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	1021 var params = ['((object *)self)'];
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1022 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	1023 var messagevars = {};
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1024 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	1025 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	1026 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	1027 messagevars[escaped] = 'object *';
35 bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1028 params.push(escaped);
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1029 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	1030 }
bf5e88f6419d Use a function/method call strategy that actually works Mike Pavone <pavone@retrodev.com> parents: 34 diff changeset	1031 }
122 9820ecd4eed4 Add support for implementing operators on user defined objects Mike Pavone <pavone@retrodev.com> parents: 121 diff changeset	1032 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	1033 vars: messagevars,
42 4e983fe32047 Fix closures as methods so that private vars work Mike Pavone <pavone@retrodev.com> parents: 41 diff changeset	1034 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	1035 });
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1036 } else {
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1037 cobj.addProperty(this.symbol.name, val);
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	1038 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	1039 cobj.addInit('self->' + escapeCName(this.symbol.name) + '->parent = (object *)self;');
59 0fd06e077afe Fix object parent Mike Pavone <pavone@retrodev.com> parents: 58 diff changeset	1040 }
31 668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1041 }
668f533e5284 Add initial version of C backend Mike Pavone <pavone@retrodev.com> parents: diff changeset	1042 };
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	1043 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	1044 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	1045 };