Mercurial > repos > tabletprog

annotate ilbackend.js @ 237:dae093baf36c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Optimized implementation of character classes
author Mike Pavone <pavone@retrodev.com>
date Sun, 05 Jan 2014 17:00:33 -0800
parents 6fe9343b1400
children d1dc2d70bdfd
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
205
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1 var mainModule;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2 var modules = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4 var methodIds = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 var methodNames = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 var assignNames;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 function register(num)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 this.num = num;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 register.prototype = {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
14 valueOf: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 return 'r' + this.num;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17 get isRegister() { return true; },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18 get isArgument() { return false; }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
20
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
21 function argument(num)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
22 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
23 this.num = num;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
24 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
25
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26 argument.prototype = {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
27 valueOf: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
28 return 'a' + this.num;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
29 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
30 get isRegister() { return true; },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
31 get isArgument() { return true; }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
32 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
33
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
34 function retreg(size)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
35 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
36 this.size = size;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
37 this.reg = NULL;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
38 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
39
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
40 retreg.prototype = {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
41 valueOf: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
42 if (!this.reg) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
43 return 'retr';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 return this.reg.valueOf();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47 clobber: function(code) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 this.reg = code.getReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
49 code.addInst('mov', 'retr', this.reg, this.size);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 get isRegister() { return true; },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 get isArgument() { return false; }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
55 function indexed(base, offset, index, size)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
56 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
57 this.base = base;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
58 this.offset = offset;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
59 this.index = index;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
60 this.size = size;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
61 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
62
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
63 indexed.prototype = {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
64 valueOf: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
65 return this.offset + '[' + this.base + ' ' + this.index + '*' + this.size + ']';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
66 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
67 get isRegister() { return false; },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
68 get isArgument() { return false; }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
69 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
70
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
71 function offset(base, offset)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
72 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
73 this.base = base;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
74 this.offset = offset;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
75 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
76
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
77 offset.prototype = {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
78 valueOf: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
79 var out = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
80 if (this.offset) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
81 out += this.offset;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
82 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
83 return out + '[' + this.base + ']';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
84 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
85 get isRegister() { return false; },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
86 get isArgument() { return false; }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
87 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
88
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
89 function funCode(name)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
90 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
91 this.name = name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
92 this.instructions = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
93 this.nextReg = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
94 this.toclobber = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
95 this.envreg = null;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
96 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
97
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
98 funCode.prototype = {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
99 addInst: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
100 var inst = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
101 for (var i = 0; i < arguments.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
102 if (arguments[0] == 'call') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
103 for (var i = 0; i < this.toclobber.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
104 this.toclobber[i].clobber();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
105 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
106 this.toclobber = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
107 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
108 if (inst) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
109 inst += ' ';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
110 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
111 inst += arguments[i];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
112 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
113 this.instructions.push(inst);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
114 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
115 getReg: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
116 return new register(this.nextReg++);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
117 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
118 getRetReg: function(size) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
119 var reg = new retreg(size);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
120 this.toclobber.push(reg);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
121 return reg;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
122 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
123 getEnvReg: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
124 if (!this.envreg) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
125 this.envreg = this.getReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
126 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
127 return this.envreg;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
128 },
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
129 valueOf: function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
130 return this.name + ':\n\t' + this.instructions.join('\n\t') + '\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
131 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
132 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
133 function getMethodId(methodName)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
134 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
135 if (!(methodName in methodIds)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
136 methodIds[methodName] = methodNames.length;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
137 methodNames.push(methodName);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
138 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
139 return methodIds[methodName];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
140 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
141
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
142 function getOpMethodName(opname)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
143 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
144 var optoMeth = {'+': 'ADD_', '-': 'SUB_', '*': 'MUL_', '/': 'DIV_', '%': 'MOD_',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
145 '=': 'EQ_', '!=': 'NEQ_', '<': 'LT_', '>': 'GT_', '>=': 'GEQ_', '<=': 'LEQ_',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
146 '.': 'CAT_', '&&':'if', '||':'ifnot', '|': 'CONS_'};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
147 if (opname in optoMeth) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
148 return optoMeth[opname];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
149 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
150 return opname;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
151 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
152 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
153
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
154 var slot_arr_offset = 8;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
155 function getMethodSlot(code, base, methodid)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
156 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
157 var reg;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
158 if (!base.isRegister()) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
159 reg = code.getReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
160 code.addInst('mov', base, reg, 'q');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
161 base = reg;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
162 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
163 reg = code.getReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
164 code.addInst('mov', new offset(base, 0), reg, 'q');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
165 return new offset(reg, slot_arr_offset + (methodid & 0xF)*8);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
166 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
167
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
168 op.prototype.toIL = function(code, isReceiver) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
169 var method = getOpMethodName(this.op);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
170 var left = this.left.toIL(code);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
171 var right = this.right.toIL(code);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
172 var methId = getMethodId(method);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
173 if (this.op == '|') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
174 code.addInst('call', getMethodSlot(code, right, methId), methId, right, left);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
175 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
176 code.addInst('call', getMethodSlot(code, left, methId), methId, left, right);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
177 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
178 return code.getRetReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
179 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
180 op.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
181 var opmap = {'=': '==', 'xor': '^', 'or': '|', 'and': '&'};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
182 return this.left.toILLLExpr(vars) + (this.op in opmap ? opmap[this.op] : this.op) + this.right.toILLLExpr(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
183 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
184 op.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
185 return [ (needsreturn ? 'return (object *)' : '' ) + this.toILLLExpr(vars) + ';'];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
186 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
187
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
188
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
189 function escapeCName(name)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
190 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
191 if (name == 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
192 return name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
193 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
194 name = name.replace(/_/g, "UN_").replace(/:/g, "CN_").replace(/!/g, "EX_").replace(/\?/g, 'QS_').replace(/@/g, 'AT_');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
195 name = 'tp_' + name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
196 return name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
197 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
198
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
199 function getSymbolPrefix(info, symbols)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
200 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
201 var pre = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
202 switch(info.type) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
203 case 'self':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
204
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
205 pre = (new symbol('self', symbols)).toIL() + '->';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
206 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
207 case 'parent':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
208 pre = (new symbol('self', symbols)).toIL() + '->header.';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
209 for (var i = 0; i < info.depth; ++i) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
210 pre += (i ? '->' : '') + 'parent';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
211 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
212 pre = '((' + info.selftype + ' *)' + pre + ')->';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
213 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
214 case 'upvar':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
215 pre = 'env->';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
216 for (var i = info.startdepth; i < info.depth; ++i) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
217 pre += 'parent->';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
218 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
219 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
220 case 'recupvar':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
221 if (info.subtype == 'object') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
222 pre = 'self->env->';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
223 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
224 //TODO: fill this case in if necessary
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
225 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
226 pre += getSymbolPrefix(info.parent);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
227 case 'closedover':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
228 pre = 'myenv->';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
229 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
230 return pre;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
231 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
232
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
233 symbol.prototype.toIL = function(code) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
234 var name = this.cleanName();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
235 var info = this.symbols.find(name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
236 if (!info) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
237 throw new Error('symbol ' + name + ' not found in ' + assignNames.join('<-'));
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
238 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
239 switch (info.type)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
240 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
241 case 'toplevel':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
242 return toplevel.moduleVar(name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
243 case 'self':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
244 if (info.def instanceof lambda) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
245 var self = (new symbol('self', this.symbols)).toIL(code);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
246 var methId = getMethodId(name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
247 code.addInst('call', getMethodSlot(code, self, methId), methId, self);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
248 return code.getRetReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
249 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
250 throw new Error('implement me');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
251 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
252 case 'parent':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
253 if (info.def instanceof lambda) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
254 throw new Error('implement me');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
255 var obj = (new symbol('self', this.symbols)).toIL() + '->header.';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
256 for (var i = 0; i < info.depth; ++i) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
257 obj += (i ? '->' : '') + 'parent';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
258 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
259 return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, ' + obj + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
260 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
261 throw new Error('implement me');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
262 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
263 case 'closedover':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
264 var env = code.getEnvReg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
265 return new offset(env, info.offset)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
266 default:
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
267 throw new Error('implement ' + info.type);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
268 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
269 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
270 symbol.prototype.toILTypeName = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
271 return this.cleanName();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
272 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
273 symbol.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
274 var name = this.cleanName();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
275 if (name in vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
276 return name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
277 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
278 if (name == 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
279 return 'self';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
280 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
281 var info = this.symbols.find(name, false, true);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
282 var symbols = this.symbols;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
283 while (info && info.type == 'local') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
284 symbols = symbols.parent;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
285 info = symbols.find(name, false, true);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
286 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
287 if (!info) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
288 return name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
289 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
290 if (info.type == 'toplevel') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
291 return toplevel.moduleVar(name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
292 } else if (info.type == 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
293 if (info.isll || !(info.def instanceof lambda)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
294 return 'self->' + name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
295 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
296 return 'mcall(' + getMethodId(name) + '/* ' + name + ' */, 1, self)';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
297 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
298 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
299 throw new Error('Unsupported reference type ' + info.type + ' for variable ' + name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
300 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
301 symbol.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
302 return [ (needsreturn ? 'return (object *)' : '' ) + this.toILLLExpr(vars) + ';' ];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
303 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
304
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
305 var declaredInts = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
306
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
307 intlit.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
308 var intType = (this.unsigned ? 'u' : '') + 'int' + this.bits;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
309 var str = intType + '_' + (this.val < 0 ? 'neg_' + (0-this.val).toString() : this.val.toString());
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
310 if (!(str in declaredInts)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
311 toplevelcode += 'obj_' + intType + ' ' + str + ' = {{&obj_' + intType + '_meta, NULL}, ' + this.val.toString() + '};\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
312 declaredInts[str] = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
313 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
314 return '((object *)&' + str + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
315 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
316 intlit.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
317 return this.val.toString();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
318 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
319 intlit.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
320 return [ (needsreturn ? 'return (object *)' : '' ) + this.toILLLExpr(vars) + ';' ];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
321 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
322
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
323 floatlit.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
324 return 'make_float(' + this.val.toString() + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
325 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
326 floatlit.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
327 return this.val.toString();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
328 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
329 floatlit.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
330 return [ (needsreturn ? 'return (object *)' : '' ) + this.toILLLExpr(vars) + ';' ];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
331 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
332
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
333 var declaredStrings = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
334 var nextStringId = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
335
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
336 strlit.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
337 if (!(this.val in declaredStrings)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
338 //TODO: get the proper byte length
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
339 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';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
340 declaredStrings[this.val] = nextStringId++;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
341 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
342 return '((object *)&str_' + declaredStrings[this.val] + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
343 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
344 strlit.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
345 return '"' + this.val.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r') + '"';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
346 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
347 strlit.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
348 return [ (needsreturn ? 'return (object *)' : '' ) + this.toILLLExpr(vars) +';' ];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
349 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
350
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
351 listlit.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
352 var ret = 'make_list(' + this.val.length;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
353 for (var i = this.val.length-1; i >= 0; i--) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
354 ret += ', ' + this.val[i].toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
355 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
356 return ret + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
357 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
358
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
359 arraylit.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
360 var ret = 'make_array(' + this.val.length;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
361 for (var i = 0; i < this.val.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
362 ret += ', ' + this.val[i].toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
363 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
364 return ret + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
365 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
366
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
367 funcall.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
368 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
369 if (name == 'foreign') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
370 if ((this.args[0] instanceof lambda) || (this.args[0] instanceof object)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
371 return null;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
372 } else if(this.args[0] instanceof symbol) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
373 return this.args[0].name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
374 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
375 throw new Error("Unexpected AST type for foreign:");
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
376 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
377 } else if(name == 'llProperty:withType' || name == 'llProperty:withVars:andCode') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
378 return null;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
379 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
380 var args = this.args.slice(0, this.args.length);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
381 if (this.receiver) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
382 args.splice(0, 0, this.receiver);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
383 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
384 var method = false;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
385 var funinfo = this.symbols.find(name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
386 var start = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
387 if (!funinfo || funinfo.def instanceof setter || funinfo.type == 'toplevel') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
388 method = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
389 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
390 switch(funinfo.type)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
391 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
392 case 'self':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
393 case 'parent':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
394 var defargs = funinfo.def.args.length;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
395 if (!defargs || funinfo.def.args[0].name != 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
396 defargs ++
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
397 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
398 if (args.length < defargs) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
399 if (funinfo.type == 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
400 args.splice(0, 0, new symbol('self', this.symbols));
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
401 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
402 var obj = (new symbol('self', this.symbols)).toIL() + '->header.';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
403 for (var i = 0; i < funinfo.depth; ++i) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
404 obj += (i ? '->' : '') + 'parent';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
405 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
406 args.splice(0, 0, ', ' + obj);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
407 start = 1;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
408 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
409 } else if(!(args[0] instanceof symbol) || args[0].name != 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
410 funinfo = null;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
411 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
412 method = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
413 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
414 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
415 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
416 for (var i = start; i < args.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
417 args[i] = ', ' + (!i && method ? '(object *)(' : '') + args[i].toIL() + (!i && method ? ')' : '');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
418 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
419 var callpart;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
420 if (method) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
421 if (funinfo && funinfo.type == 'self' && funinfo.def.name) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
422 callpart = funinfo.def.name + '(' + (funinfo.def.symbols.parent.needsenv ? (new symbol('self', this.symbols)).toIL() + '->env' : 'NULL' );
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
423 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
424 callpart = 'mcall(' + getMethodId(name) + '/* ' + name + ' */';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
425 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
426 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
427 var closVar = (new symbol(name, this.symbols)).toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
428 callpart = '((lambda *)' + closVar + ')->func(((lambda *)' + closVar + ')->env';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
429 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
430 return callpart + ', ' + args.length + args.join('') + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
431 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
432 funcall.prototype.toILTypeName = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
433 switch(this.name)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
434 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
435 case 'ptr:':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
436 case 'ptr':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
437 var receiver = this.receiver ? this.receiver : this.args[0];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
438 return receiver.toILTypeName() + ' *';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
439 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
440 case 'struct:':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
441 case 'struct':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
442 var receiver = this.receiver ? this.receiver : this.args[0];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
443 return 'struct ' + receiver.toILTypeName();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
444 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
445 case 'funptr:':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
446 case 'funptr':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
447 var rettype;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
448 var firstArg;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
449 if (this.receiver) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
450 rettype = this.receiver;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
451 firstArg = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
452 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
453 rettype = this.args[0];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
454 firstArg = 1;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
455 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
456 var argtypes = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
457 for (var i = firstArg; i < this.args.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
458 if (argtypes) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
459 argtypes += ', '
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
460 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
461 argtypes += this.args[i].toILTypeName();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
462 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
463 return [rettype.toILTypeName() + '(*', ')(' + argtypes + ')'];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
464 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
465 default:
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
466 throw new Error('invalid use of funcall expression where a C type name is expected');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
467 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
468 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
469 funcall.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
470 var lines = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
471 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
472 var args = this.args.slice(0, this.args.length);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
473 if (this.receiver) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
474 args.splice(0, 0, [this.receiver]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
475 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
476 switch(name)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
477 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
478 case 'if':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
479 lines.push('if (' + this.args[0].toILLLExpr(vars) + ') {');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
480 var blines = this.args[1].toILLines(vars, needsreturn);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
481 for (var i in blines) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
482 lines.push('\t' + blines[i]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
483 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
484 if (needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
485 lines.push('} else {');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
486 lines.push('\t return module_false;');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
487 lines.push('}');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
488 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
489 lines.push('}');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
490 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
491 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
492 case 'if:else':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
493 lines.push('if (' + this.args[0].toILLLExpr(vars) + ') {');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
494 var blines = this.args[1].toILLines(vars, needsreturn);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
495 for (var i in blines) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
496 lines.push('\t' + blines[i]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
497 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
498 lines.push('} else {');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
499 blines = this.args[2].toILLines(vars, needsreturn);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
500 for (var i in blines) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
501 lines.push('\t' + blines[i]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
502 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
503 lines.push('}');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
504 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
505 case 'while:do':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
506 if (needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
507 throw new Error("while:do can't be last statement in llMessage code block");
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
508 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
509 lines.push('while (' + this.args[0].toILLLExpr(vars) + ') {');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
510 var blines = this.args[1].toILLines(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
511 for (var i in blines) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
512 lines.push('\t' + blines[i]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
513 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
514 lines.push('}');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
515 break;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
516 default:
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
517 lines.push( (needsreturn ? 'return (object *)' : '') + this.toILLLExpr(vars) + ';');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
518 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
519 return lines;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
520 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
521
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
522 funcall.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
523 var name = this.name[this.name.length-1] == ':' ? this.name.substr(0, this.name.length-1) : this.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
524 var args = this.args.slice(0, this.args.length);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
525 if (this.receiver) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
526 if(this.args.length == 0) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
527 if (this.receiver instanceof symbol && this.receiver.name in vars && vars[this.receiver.name].substr(-1) != "*") {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
528 return this.receiver.toILLLExpr(vars) + '.' + this.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
529 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
530 return this.receiver.toILLLExpr(vars) + '->' + this.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
531 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
532 } else if (this.args.length == 1 && name[name.length-1] == '!') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
533 if (this.receiver instanceof symbol && this.receiver.name in vars && vars[this.receiver.name].substr(-1) != "*") {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
534 return this.receiver.toILLLExpr(vars) + '.' + this.name.substr(0, name.length-1) + ' = ' + args[0].toILLLExpr(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
535 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
536 return this.receiver.toILLLExpr(vars) + '->' + this.name.substr(0, name.length-1) + ' = ' + args[0].toILLLExpr(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
537 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
538 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
539 args.splice(0, 0, this.receiver);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
540 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
541 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
542 switch(name)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
543 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
544 case 'if':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
545 return '((' + args[0].toILLLExpr(vars) + ') ? (' + args[1].toILLLExpr(vars) + ') : 0)';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
546 case 'if:else':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
547 return '((' + args[0].toILLLExpr(vars) + ') ? (' + args[1].toILLLExpr(vars) + ') : (' + args[2].toILLLExpr(vars) + '))';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
548 case 'while:do':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
549 throw new Error('while:do not allowed in expression context in llMessage block');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
550 case 'addr_of':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
551 return '&(' + args[0].toILLLExpr(vars) + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
552 case 'sizeof':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
553 return 'sizeof(' + args[0].toILTypeName() + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
554 case 'get':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
555 return args[0].toILLLExpr(vars) + '[' + args[1].toILLLExpr(vars) + ']';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
556 case 'set':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
557 return args[0].toILLLExpr(vars) + '[' + args[1].toILLLExpr(vars) + '] = ' + args[2].toILLLExpr(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
558 case 'not':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
559 return '!(' + args[0].toILLLExpr(vars) + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
560 case 'castTo':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
561 return '((' + args[1].toILTypeName() + ')(' + args[0].toILLLExpr(vars) + '))';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
562 case 'mcall':
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
563 if (args[0] instanceof symbol) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
564 args[0] = new intlit(getMethodId(args[0].name));
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
565 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
566 default:
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
567 for (var i in args) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
568 args[i] = args[i].toILLLExpr(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
569 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
570 return name + '(' + args.join(', ') + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
571 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
572 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
573
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
574 function cObject(name) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
575 this.name = name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
576 this.slots = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
577 this.properties = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
578 this.values = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
579 this.slotvars = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
580 this.includes = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
581 this.parent = 'NULL';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
582 this.init = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
583 this.initmsgadded = false;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
584 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
585
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
586 cObject.prototype.addInclude = function(includefile) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
587 this.includes[includefile] = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
588 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
589
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
590 cObject.prototype.addMessage = function(msgname, implementation) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
591 var methodid = getMethodId(msgname);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
592 var trunc = methodid & 0xF;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
593 if (!(trunc in this.slots)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
594 this.slots[trunc] = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
595 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
596 this.slots[trunc].push([methodid, '\t\t' + implementation.lines.join('\n\t\t') + '\n', msgname]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
597 if (!(trunc in this.slotvars)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
598 this.slotvars[trunc] = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
599 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
600 for (var varname in implementation.vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
601 this.slotvars[trunc][varname] = implementation.vars[varname];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
602 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
603 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
604
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
605 cObject.prototype.addProperty = function(propname, value, type) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
606 if (type != undefined) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
607 this.properties.push([propname, type]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
608 if (value !== null) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
609 this.values.push(value);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
610 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
611 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
612 var escaped = escapeCName(propname);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
613 this.addMessage(propname, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
614 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
615 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
616 'return self->' + escaped + ';'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
617 ]});
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
618 this.addMessage(propname + '!', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
619 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
620 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
621 'self->' + escaped + ' = va_arg(args, object *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
622 'return (object *)self;'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
623 ]});
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
624 this.properties.push(escaped);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
625 this.values.push(value);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
626 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
627 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
628
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
629 cObject.prototype.addInit = function(statement) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
630 this.init.push(statement);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
631 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
632
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
633 cObject.prototype.addImport = function(symbols, source) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
634 this.imported.push(source);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
635 var importNum = imported.length - 1;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
636 if (symbols) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
637 each(symbols, function(i, sym) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
638 this.addMessage(sym.name, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
639 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
640 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
641 'return self->import_' + importNum + '->meta->meth_lookup[method_id & 0xF](method_id, num_args, self->import_' + importNum + ', args);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
642 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
643 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
644 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
645 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
646 //TODO: handle proxying for unimplemented methods
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
647 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
648 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
649
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
650 cObject.prototype.checkInitMsg = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
651 if (!this.initmsgadded && this.init.length) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
652 var init = this.init.slice(0, this.init.length);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
653 init.push('return (object *)self;');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
654 this.addMessage('_init', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
655 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
656 lines: init
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
657 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
658 this.initmsgadded = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
659 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
660 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
661
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
662 cObject.prototype.populateSymbols = function() {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
663
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
664 cObject.prototype.toEarlyCDef = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
665 this.checkInitMsg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
666 var includes = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
667 for (var file in this.includes) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
668 includes += '#include ' + file + '\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
669 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
670 var objdef = 'typedef struct ' + this.name + ' {\n\tobject header;\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
671 for (var i in this.properties) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
672 if (this.properties[i] instanceof Array) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
673 if (this.properties[i][1] instanceof Array) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
674 objdef += '\t' + this.properties[i][1][0] + this.properties[i][0] + this.properties[i][1][1] + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
675 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
676 objdef += '\t' + this.properties[i][1] + ' ' + this.properties[i][0] + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
677 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
678 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
679 objdef += '\tobject * ' + this.properties[i] + ';\n'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
680 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
681 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
682 objdef += '} ' + this.name + ';\nobj_meta ' + this.name + '_meta;\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
683 return includes + objdef;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
684 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
685
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
686 cObject.prototype.toILDef = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
687 this.checkInitMsg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
688 var slotdefs = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
689 var metadef = 'obj_meta ' + this.name + '_meta = {sizeof(' + this.name +'), {';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
690 for (var i = 0; i < 16; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
691 if (i) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
692 metadef += ', ';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
693 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
694 if (i in this.slots) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
695 slotdefs += 'object * ' + this.name + '_slot_' + i + '(uint32_t method_id, uint32_t num_params, object * oself, va_list args) {\n\t' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
696 this.name + ' *self = (' + this.name + ' *)oself;\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
697 for (var varname in this.slotvars[i]) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
698 if (this.slotvars[i][varname] instanceof Array) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
699 slotdefs += '/*foo*/\t' + this.slotvars[i][varname][0] + ' ' + varname + this.slotvars[i][varname][1] + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
700 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
701 slotdefs += '/*bar*/\t' + this.slotvars[i][varname] + ' ' + varname + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
702 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
703 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
704 if (this.slots[i].length == 1) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
705 slotdefs += '\tif (method_id == ' + this.slots[i][0][0] + ') { /* ' + this.slots[i][0][2] + '*/\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
706 '\t\t' + this.slots[i][0][1] + '\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
707 '\t}\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
708 '\treturn no_impl(method_id, num_params, (object *)self, args);\n}\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
709 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
710 slotdefs += '\tswitch(method_id) {\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
711 for (j in this.slots[i]) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
712 slotdefs += '\t\tcase ' + this.slots[i][j][0] + ': /* ' + this.slots[i][j][2] + '*/\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
713 '\t\t\t' + this.slots[i][j][1] + '\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
714 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
715 slotdefs += '\t\tdefault:\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
716 '\t\t\treturn no_impl(method_id, num_params, (object *)self, args);\n\t}\n}\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
717
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
718 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
719 metadef += this.name + '_slot_' + i;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
720 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
721 metadef += 'no_impl';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
722 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
723 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
724 metadef += '}};\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
725 return slotdefs + metadef;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
726 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
727
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
728 cObject.prototype.toILInstance = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
729 this.checkInitMsg();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
730 var ret = 'make_object(&' + this.name + '_meta, ' + this.parent + ', ' + this.values.length + (this.values.length ? ', ' : '') + this.values.join(', ') + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
731 if (this.initmsgadded) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
732 ret = 'mcall(' + getMethodId('_init') + ', 1, ' + ret + ')'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
733 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
734 return ret;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
735 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
736
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
737 cObject.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
738 forwarddec += this.toEarlyCDef();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
739 toplevelcode += this.toILDef();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
740 return this.toILInstance();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
741 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
742
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
743 var nextobject = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
744
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
745
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
746 object.prototype.toILObject = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
747 var messages = this.messages;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
748 if (!this.name) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
749 this.name = 'object_' + nextobject++;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
750 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
751 var me = new cObject(this.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
752 this.symbols.typename = me.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
753 if (this.symbols.needsenv) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
754 me.addProperty('env', this.symbols.envVar(), 'struct ' + this.symbols.getEnvType() + ' * ');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
755 me.hasenv = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
756 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
757 if (this.symbols.needsparent && !(this.symbols.parent instanceof osymbols)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
758 me.parent = '(object *)(' + (new symbol('self', this.symbols.parent)).toIL() + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
759 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
760 for (var i in messages) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
761 if (messages[i] instanceof funcall) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
762 if (messages[i].name == 'import:' && messages[i].args.length == 1) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
763 me.addImport(false, messages[i].args[0]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
764 } else if(messages[i].name == 'import:from:' && messages[i].args.length == 2) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
765 var importsyms = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
766 each(messages[i].args[0].val, function(i, el) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
767 if (!(el instanceof symbol)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
768 throw new Error('Names in import:from statement must be symbols');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
769 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
770 importsyms.push(el);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
771 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
772 me.addImport(importsyms, messages[i].args[1]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
773 } else if(messages[i].name == 'llProperty:withType:' && messages[i].args.length == 2) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
774 me.addProperty(messages[i].args[0].name, null, messages[i].args[1].toILTypeName());
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
775 } else if(messages[i].name == 'llMessage:withVars:andCode:' && messages[i].args.length == 3) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
776 var msgname = messages[i].args[0].name
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
777 var rawvars = messages[i].args[1].expressions;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
778 var vars = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
779 for(var v in rawvars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
780 vars[rawvars[v].symbol.name] = rawvars[v].expression.toILTypeName();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
781 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
782 me.addMessage(msgname, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
783 vars: vars,
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
784 lines: messages[i].args[2].toILLines(vars, true)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
785 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
786 } else if(messages[i].name == 'includeSystemHeader:' && messages[i].args.length == 1) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
787 me.addInclude("<" + messages[i].args[0].val + ">");
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
788 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
789
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
790 throw new Error('Only import and import:from calls allowed in object context. ' + messages[i].name + 'with ' + messages[i].args.length + ' arguments found instead.');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
791 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
792 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
793 messages[i].toILObject(me);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
794 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
795 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
796
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
797 return me;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
798 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
799
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
800 object.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
801 return this.toILObject().toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
802 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
803
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
804 var toplevelcode;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
805 var forwarddec;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
806
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
807 function addBinaryOp(cobject, opname, cop, objtype)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
808 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
809 cobject.addMessage(opname, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
810 vars: {ret: objtype + ' *', argb: objtype +' *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
811 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
812 'argb = va_arg(args, ' + objtype + ' *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
813 'ret = (' + objtype + ' *)make_object(&' + objtype + '_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
814 'ret->num = self->num ' + cop + ' argb->num;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
815 'return &(ret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
816 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
817 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
818 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
819
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
820 function addCompOp(cobject, opname, cop, objtype)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
821 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
822 cobject.addMessage(opname, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
823 vars: {argb: objtype + ' *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
824 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
825 'argb = va_arg(args, ' + objtype + ' *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
826 'if (self->num ' + cop + ' argb->num) {',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
827 ' return ' + toplevel.moduleVar('true') + ';',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
828 '}',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
829 'return ' + toplevel.moduleVar('false') + ';',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
830 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
831 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
832 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
833
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
834 function makeInt(bits, unsigned)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
835 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
836 var typename = 'obj_' + (unsigned ? 'u' : '') + 'int' + bits;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
837 var intObj = new cObject(typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
838 intObj.addProperty('num', null, (unsigned ? 'u' : '') + 'int' + bits +'_t');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
839 addBinaryOp(intObj, 'ADD_', '+', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
840 addBinaryOp(intObj, 'SUB_', '-', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
841 addBinaryOp(intObj, 'MUL_', '*', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
842 addBinaryOp(intObj, 'DIV_', '/', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
843 addBinaryOp(intObj, 'MOD_', '%', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
844 addBinaryOp(intObj, 'or', '|', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
845 addBinaryOp(intObj, 'xor', '^', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
846 addBinaryOp(intObj, 'and', '&', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
847 addBinaryOp(intObj, 'lshift:by', '<<', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
848 addBinaryOp(intObj, 'rshift:by', '>>', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
849 addCompOp(intObj, 'LT_', '<', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
850 addCompOp(intObj, 'GT_', '>', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
851 addCompOp(intObj, 'EQ_', '==', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
852 addCompOp(intObj, 'NEQ_', '!=', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
853 addCompOp(intObj, 'GEQ_', '>=', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
854 addCompOp(intObj, 'LEQ_', '<=', typename);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
855 intObj.addInclude('<string.h>');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
856 //-9223372036854775808
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
857 //01234567890123456789
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
858 intObj.addMessage('string', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
859 vars: {str: 'string *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
860 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
861 'str = (string *)make_object(&string_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
862 'str->data = GC_MALLOC(' + (bits == 64 ? 21 : 12) + ');',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
863 'sprintf(str->data, "%' + (bits == 64 ? 'l' : '') + (unsigned ? 'u' : 'd') + '", self->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
864 'str->len = str->bytes = strlen(str->data);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
865 'return &(str->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
866 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
867 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
868 //7FFFFFFFFFFFFFFF
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
869 //01234567890123456789
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
870 intObj.addMessage('hex', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
871 vars: {str: 'string *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
872 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
873 'str = (string *)make_object(&string_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
874 'str->data = GC_MALLOC(' + (bits == 64 ? 17 : 9) + ');',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
875 'sprintf(str->data, "%' + (bits == 64 ? 'l' : '') +'X", self->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
876 'str->len = str->bytes = strlen(str->data);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
877 'return &(str->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
878 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
879 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
880 intObj.addMessage('isInteger?', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
881 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
882 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
883 'return ' + toplevel.moduleVar('true') + ';'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
884 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
885 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
886 intObj.addMessage('hash', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
887 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
888 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
889 'return &(self->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
890 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
891 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
892 intObj.addMessage('signed?', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
893 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
894 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
895 'return ' + toplevel.moduleVar(unsigned ? 'false' : 'true') + ';'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
896 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
897 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
898 var sizes = [8, 16, 32, 64];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
899 var destunsigned = [false, true];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
900 for (var i = 0; i < sizes.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
901 size = sizes[i];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
902 for (var j = 0; j < destunsigned.length; j++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
903 uns = destunsigned[j];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
904 if (uns == unsigned && size == bits) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
905 intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
906 vars: {},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
907 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
908 'return &(self->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
909 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
910 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
911 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
912 var retType = 'obj_' + (uns ? 'u' : '') + 'int' + size;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
913 var retName = 'ret' + (uns ? 'u' : '') + size;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
914 var vars = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
915 vars[retName] = retType + ' *';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
916 intObj.addMessage((uns ? 'u' : '') + 'int' + size, {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
917
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
918 vars: vars,
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
919 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
920 retName + ' = ('+retType+' *)make_object(&' + retType +'_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
921 retName + '->num = self->num;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
922 'return &(' + retName + '->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
923 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
924 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
925 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
926 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
927 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
928
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
929 return intObj;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
930 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
931
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
932 function makeArray()
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
933 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
934 var arrayfile = toplevel.names['array'];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
935 var ast = parseFile(arrayfile.path + '/' + arrayfile.file);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
936 ast.name = 'array';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
937 ast.populateSymbols(toplevel);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
938 return ast.toILObject();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
939 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
940
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
941 function makeString()
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
942 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
943 var arrayfile = toplevel.names['string'];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
944 var ast = parseFile(arrayfile.path + '/' + arrayfile.file);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
945 ast.name = 'string';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
946 ast.populateSymbols(toplevel);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
947 return ast.toILObject();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
948 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
949
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
950 function makelambda()
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
951 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
952 var clos = new cObject('lambda');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
953 clos.addProperty('env', null, 'void *');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
954 clos.addProperty('func', null, 'closure_func');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
955 clos.addMessage('while:do', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
956 vars: {action: 'lambda *', ret: 'object *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
957 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
958 'action = va_arg(args, lambda *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
959 'ret = ' + toplevel.moduleVar('true') + ';',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
960 'while(' + toplevel.moduleVar('true') + ' == ccall(self, 0)) {',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
961 ' ccall(action, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
962 '}',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
963 'return ret;'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
964 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
965 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
966 return clos;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
967 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
968
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
969 function builtinTypes()
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
970 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
971 return [makeInt(64, false), makeInt(32, false), makeInt(16, false), makeInt(8, false),
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
972 makeInt(64, true) , makeInt(32, true), makeInt(16, true), makeInt(8, true),
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
973 makeArray(), makeString(), makelambda()];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
974 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
975
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
976 function addBuiltinModules(toplevel)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
977 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
978 var os = new cObject('mod_obj_os');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
979 os.addInclude('<sys/stat.h>');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
980 os.addInclude('<fcntl.h>');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
981 os.addInclude('<stdlib.h>');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
982 os.addInclude('<time.h>');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
983 os.addInclude('<unistd.h>');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
984 os.addMessage('write', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
985 vars: {str: 'string *', intret: 'obj_int32 *', filedes: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
986 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
987 'filedes = va_arg(args, obj_int32 *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
988 'str = va_arg(args, string *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
989 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
990 'intret->num = write(filedes->num, str->data, str->bytes);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
991 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
992 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
993 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
994 os.addMessage('read', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
995 vars: {str: 'string *', size: 'obj_int32 *', filedes: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
996 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
997 'filedes = va_arg(args, obj_int32 *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
998 'size = va_arg(args, obj_int32 *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
999 'str = (string *)make_object(&string_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1000 'str->data = GC_MALLOC_ATOMIC(size->num + 1);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1001 'str->len = str->bytes = read(filedes->num, str->data, size->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1002 'if (str->bytes < 0) { str->bytes = str->len = 0; }',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1003 'str->data[str->bytes] = 0;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1004 'return &(str->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1005 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1006 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1007 os.addMessage('open', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1008 vars: {str: 'string *', flags: 'obj_int32 *', filedes: 'obj_int32 *', perm: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1009 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1010 'str = va_arg(args, string *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1011 'flags = va_arg(args, obj_int32 *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1012 'filedes = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1013 'if (num_params == 3) {',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1014 ' filedes->num = open(str->data, flags->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1015 '} else if (num_params == 4) {',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1016 ' perm = va_arg(args, obj_int32 *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1017 ' filedes->num = open(str->data, flags->num, perm->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1018 '} else {',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1019 ' filedes->num = -1;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1020 '}',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1021 'return &(filedes->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1022 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1023 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1024 os.addMessage('close', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1025 vars: {filedes: 'obj_int32 *', intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1026 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1027 'filedes = va_arg(args, obj_int32 *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1028 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1029 'intret->num = close(filedes->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1030 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1031 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1032 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1033 os.addMessage('O_RDONLY', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1034 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1035 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1036 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1037 'intret->num = O_RDONLY;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1038 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1039 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1040 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1041 os.addMessage('O_WRONLY', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1042 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1043 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1044 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1045 'intret->num = O_WRONLY;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1046 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1047 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1048 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1049 os.addMessage('O_RDWR', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1050 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1051 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1052 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1053 'intret->num = O_RDWR;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1054 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1055 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1056 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1057 os.addMessage('O_CREAT', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1058 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1059 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1060 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1061 'intret->num = O_CREAT;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1062 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1063 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1064 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1065 os.addMessage('O_APPEND', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1066 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1067 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1068 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1069 'intret->num = O_APPEND;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1070 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1071 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1072 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1073 os.addMessage('O_TRUNC', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1074 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1075 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1076 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1077 'intret->num = O_TRUNC;',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1078 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1079 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1080 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1081 os.addMessage('rand', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1082 vars: {intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1083 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1084 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1085 'intret->num = rand();',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1086 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1087 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1088 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1089 os.addMessage('rand64', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1090 vars: {intret64: 'obj_int64 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1091 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1092 'intret64 = (obj_int64 *)make_object(&obj_int64_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1093 'intret64->num = (((int64_t)rand()) << 32 ) | rand();',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1094 'return &(intret64->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1095 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1096 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1097 os.addMessage('srand', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1098 vars: {oseed: 'object *', seed: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1099 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1100 'oseed = va_arg(args, object *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1101 'seed = mcall(' + getMethodId("int32") + ', 1, oseed);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1102 'srand(seed->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1103 'return &(seed->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1104 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1105 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1106 os.addMessage('time', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1107 vars: {intret64: 'obj_int64 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1108 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1109 'intret64 = (obj_int64 *)make_object(&obj_int64_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1110 'intret64->num = time(NULL);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1111 'return &(intret64->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1112 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1113 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1114 os.addMessage('sleep', {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1115 vars: {osecs: 'object *', secs: 'obj_int32 *', intret: 'obj_int32 *'},
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1116 lines: [
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1117 'osecs = va_arg(args, object *);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1118 'secs = mcall(' + getMethodId("int32") + ', 1, osecs);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1119 'intret = (obj_int32 *)make_object(&obj_int32_meta, NULL, 0);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1120 'intret->num = sleep(secs->num);',
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1121 'return &(intret->header);'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1122 ]
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1123 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1124 toplevel.names['os'] = os;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1125 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1126
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1127 modulefile.prototype.toIL = function(){
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1128 return this.ast.toILModuleInstance();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1129 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1130
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1131 function processUsedToplevel(toplevel)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1132 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1133 var alwaysused = ['true', 'false', 'list'];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1134 var ret = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1135 var modulenum = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1136 var visited = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1137 for (var i in alwaysused) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1138 toplevel.used[alwaysused[i]] = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1139 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1140 var newused = Object.keys(toplevel.used);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1141 var allused = newused;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1142 while (newused.length) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1143 for (var i in newused) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1144 debugprint('//---module', newused[i], '--- populate symbols');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1145 forwarddec += 'object * ' + toplevel.moduleVar(newused[i]) + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1146 toplevel.names[newused[i]].populateSymbols(toplevel);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1147 visited[newused[i]] = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1148 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1149 newused = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1150 for (var symbol in toplevel.used) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1151 if (!(symbol in visited)) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1152 debugprint('//found new usage of module', symbol);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1153 newused.push(symbol);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1154 allused.push(symbol);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1155 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1156 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1157 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1158
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1159 for (var i = allused.length-1; i >= 0; i--) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1160 var symbol = allused[i];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1161 debugprint('//---module', symbol, '(' + i +')--- compile');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1162 assignNames.push(symbol);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1163 ret += '\t' + toplevel.moduleVar(symbol) + ' = ' + toplevel.names[symbol].toIL() + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1164 assignNames.pop();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1165 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1166 return ret;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1167 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1168
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1169 function makeCProg(obj)
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1170 {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1171 forwarddec = toplevelcode = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1172 assignNames = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1173 var builtins = builtinTypes();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1174 for (var i in builtins) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1175 forwarddec += builtins[i].toEarlyCDef();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1176 toplevelcode += builtins[i].toILDef();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1177 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1178 addBuiltinModules(toplevel);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1179 debugprint('//------POPULATING SYMBOLS-----');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1180 obj.populateSymbols(toplevel);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1181 var moduleinit = processUsedToplevel(toplevel);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1182 debugprint('//------COMPILING AST-----');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1183 var rest = 'object * mainModule() {\n' + moduleinit + '\tmain_module = ' + obj.toILModuleInstance() + ';\n\treturn main_module;\n}\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1184 var mnames = 'char * methodNames[] = {\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1185 for (var i = 0; i < methodNames.length; i++) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1186 mnames += '\t"' + methodNames[i].replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n") + '",\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1187 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1188 mnames += '};\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1189 return '#include "runtime/proghead.inc"\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1190 '#define METHOD_ID_MAIN ' + getMethodId('main') + '\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1191 '#define METHOD_ID_EMPTY ' + getMethodId('empty') + '\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1192 '#define METHOD_ID_CONS ' + getMethodId(getOpMethodName('|')) + '\n' +
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1193 mnames + forwarddec + toplevelcode + rest + '#include "runtime/progfoot.inc"\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1194 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1195
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1196 object.prototype.toILModule = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1197 return makeCProg(this);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1198 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1199
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1200 object.prototype.toILModuleInstance = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1201 return this.toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1202 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1203
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1204 lambda.prototype.toIL = function(parentcode) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1205 var code = new funCode(this.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1206 var args = this.args ? this.args.slice(0, this.args.length) : [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1207 var exprs = this.expressions;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1208 var assignPath = assignNames.join('<-');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1209 debugprint('//', this.name, assignPath);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1210 var addedTypeDef = false;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1211 if (Object.keys(this.symbols.closedover).length) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1212 this.symbols.envtype = this.name + '_env';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1213 forwarddec += 'typedef struct ' + this.symbols.envtype + ' ' + this.symbols.envtype + ';\n'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1214 var addedTypeDef = true;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1215 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1216 if (this.selftype) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1217 this.symbols.defineVar('self', this.selftype);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1218 if (args[0] && args[0].cleanName() == 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1219 args.splice(0, 1);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1220 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1221 var offset = 1;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1222 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1223 var offset = 0;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1224 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1225 for (var i = 0; i < args.length; ++i) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1226 var argname = args[i].toIL(code);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1227
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1228 args[i] = (argname.indexOf('->') < 0 ? '\tobject * ' : '\t') + argname + ' = va_arg(args, object *);\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1229 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1230 var compiled = []
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1231 for (var i in exprs) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1232 var js = exprs[i].toIL(code);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1233 if (js) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1234 compiled.push(indent(js));
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1235 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1236 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1237 if (compiled.length) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1238 if (exprs[exprs.length - 1] instanceof assignment) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1239 compiled.push('return ' + exprs[exprs.length - 1].symbol.toIL() + ';');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1240 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1241 compiled[compiled.length-1] = 'return (object *)(' + compiled[compiled.length-1] + ');';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1242 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1243 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1244 exprs = compiled;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1245
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1246 if (Object.keys(this.symbols.closedover).length) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1247 if (!addedTypeDef) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1248 for (var key in this.symbols.closedover) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1249 print(key, ": ", this.symbols.closedover[key]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1250 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1251 throw new Error('this.symbols.closedover is not empty, but it was when compilation of ' + this.name + ' "' + assignPath + '" started');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1252 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1253 forwarddec += 'struct ' + this.name + '_env {\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1254 if (this.symbols.needsParentEnv) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1255 forwarddec += '\tstruct ' + this.symbols.parentEnvType() + ' * parent;\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1256 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1257 for (var varname in this.symbols.closedover) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1258 if (varname == 'self' && this.selftype) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1259 forwarddec += '\tstruct ' + this.selftype + ' * self;\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1260 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1261 forwarddec += '\tobject * ' + escapeCName(varname) + ';\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1262 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1263 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1264 forwarddec += '};\n'
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1265
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1266 var myenvinit = '\t' + this.name + '_env * myenv = GC_MALLOC(sizeof(' + this.name + '_env));\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1267 if (this.symbols.needsParentEnv) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1268 myenvinit += '\tmyenv->parent = env;\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1269 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1270 this.symbols.envtype = this.name + '_env';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1271 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1272 var myenvinit = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1273 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1274 forwarddec += 'object *' + this.name + ' (' + this.symbols.parentEnvType() + ' * env, uint32_t num_args, ...);\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1275
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1276 toplevelcode += '//' + assignPath + "\n";
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1277 toplevelcode += 'object * ' + this.name + ' ( ' + this.symbols.parentEnvType() + ' * env, uint32_t num_args, ...) {\n\tva_list args;\n' + myenvinit + '\tva_start(args, num_args);\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1278 if (this.selftype) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1279 var selfvar = (new symbol('self', this.symbols)).toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1280 if (selfvar == 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1281 toplevelcode += '\t' + this.selftype + ' * self = va_arg(args, ' + this.selftype + ' *);\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1282 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1283 toplevelcode += '\t' + selfvar + ' = va_arg(args, ' + this.selftype + ' *);\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1284 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1285
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1286 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1287 toplevelcode += args.join('') + '\tva_end(args);\n' + exprs.join(';\n\t') + '\n}\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1288
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1289 if (this.selftype) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1290 return this.name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1291 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1292 if (this.symbols.parentEnvType() != 'void') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1293 if (this.symbols.parent.passthruenv) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1294 var envvar = 'env';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1295 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1296 var envvar = 'myenv';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1297 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1298 debugprint('//' + this.name, 'has envvar:', envvar, 'num vars closed over:', Object.keys(this.symbols.closedover).length);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1299 return 'make_lambda(' + envvar + ', (closure_func)' + this.name + ')';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1300 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1301 toplevelcode += 'lambda ' + this.name + '_obj = {{&lambda_meta, NULL}, NULL, ' + this.name + '};\n';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1302 return '((object *)&' + this.name + '_obj)';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1303 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1304 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1305 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1306 lambda.prototype.toILModuleInstance = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1307 this.toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1308 return this.name + '(NULL, 0)';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1309 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1310 lambda.prototype.toILObject = function(typename) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1311 this.selftype = typename;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1312 return this.toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1313 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1314 lambda.prototype.toILModule = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1315 return makeCProg(this);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1316 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1317 lambda.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1318 var lines = [];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1319 for (var i in this.args) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1320 var name = this.args[i].name;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1321 if (name[0] == ':') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1322 name = name.substr(1);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1323 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1324 if(name != 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1325 lines.push(name + ' = va_arg(args, ' + vars[name] + ');');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1326 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1327 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1328 for (var i in this.expressions) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1329 var exprlines = this.expressions[i].toILLines(vars, needsreturn && i == this.expressions.length - 1);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1330 for (var j in exprlines) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1331 lines.push('\t' + exprlines[j]);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1332 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1333 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1334 return lines;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1335 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1336 lambda.prototype.toILLLExpr = function(vars) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1337 if (this.expressions.length != 1) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1338 throw new Error('lambda in expression context must have a single statement in llMessage block');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1339 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1340 return this.expressions[0].toILLLExpr(vars);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1341 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1342
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1343 assignment.prototype.toIL = function() {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1344 debugprint('//assignment', this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1345 var existing = this.symbols.find(this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1346 var prefix = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1347 assignNames.push(this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1348 var val = this.expression.toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1349 assignNames.pop(this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1350 if (val === null) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1351 return null;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1352 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1353 if (existing.type == 'local' && !existing.isdeclared) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1354 prefix = 'object *';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1355 this.symbols.declareVar(this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1356 debugprint('//declared var', this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1357 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1358 return prefix + this.symbol.toIL() + ' = ' + val;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1359 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1360 assignment.prototype.toILObject = function(cobj) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1361 debugprint('//message definition', this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1362 assignNames.push('#' + this.symbol.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1363 if (this.expression.toILObject) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1364 var val = this.expression.toILObject(cobj.name);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1365 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1366 var val = this.expression.toIL();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1367 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1368 assignNames.pop();
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1369 if (val === null) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1370 return;
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1371 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1372 if (this.expression instanceof lambda) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1373 var params = ['((object *)self)'];
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1374 var paramget = '';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1375 var messagevars = {};
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1376 for (var i in this.expression.args) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1377 var escaped = escapeCName(this.expression.args[i].cleanName());
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1378 if (escaped != 'self') {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1379 messagevars[escaped] = 'object *';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1380 params.push(escaped);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1381 paramget += escaped + ' = va_arg(args, object *); ';
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1382 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1383 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1384 cobj.addMessage(getOpMethodName(this.symbol.name), {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1385 vars: messagevars,
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1386 lines: [paramget + 'return ' + val + '(' + (cobj.hasenv ? 'self->env' : 'NULL') + ', ' + params.length + (params.length ? ', ' : '') + params.join(', ') + ');']
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1387 });
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1388 } else {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1389 cobj.addProperty(this.symbol.name, val);
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1390 if (this.expression instanceof object && this.expression.symbols.needsparent) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1391 cobj.addInit('self->' + escapeCName(this.symbol.name) + '->parent = (object *)self;');
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1392 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1393 }
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1394 };
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1395 assignment.prototype.toILLines = function(vars, needsreturn) {
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1396 return [(needsreturn ? 'return ' : '') + this.symbol.toILLLExpr(vars) + ' = ' + this.expression.toILLLExpr(vars) + ';']
6fe9343b1400 Some minor work on creating an IL backend based on the C backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1397 };