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