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