eldridge.cam
+49
-16
trilogy-llvm/core/trilogy_callable.c
+49
-16
trilogy-llvm/core/trilogy_callable.c
···
8
#include <stdint.h>
9
#include <stdlib.h>
10
11
trilogy_value* prepare_closure(uint32_t closure_size) {
12
return calloc_safe(closure_size, sizeof(trilogy_value));
13
}
···
37
trilogy_value* return_to, trilogy_value* yield_to, trilogy_value* cancel_to,
38
trilogy_value* resume_to, trilogy_value* break_to,
39
trilogy_value* continue_to, trilogy_value* next_to, trilogy_value* done_to,
40
-
trilogy_value* closure, void* p
41
) {
42
assert(closure == NO_CLOSURE || closure->tag == TAG_ARRAY);
43
callable->rc = 1;
···
89
*closure = trilogy_undefined;
90
}
91
callable->function = p;
92
TRACE("Initialized callable (%d): %p\n", callable->tag, callable);
93
return callable;
94
}
···
99
malloc_safe(sizeof(trilogy_callable_value));
100
trilogy_callable_value_init(
101
callable, CALLABLE_FUNCTION, 1, NULL, NULL, NULL, NULL, NULL, NULL,
102
-
NULL, NULL, closure, p
103
);
104
return trilogy_callable_init(t, callable);
105
}
···
111
malloc_safe(sizeof(trilogy_callable_value));
112
trilogy_callable_value_init(
113
callable, CALLABLE_PROCEDURE, arity, NULL, NULL, NULL, NULL, NULL, NULL,
114
-
NULL, NULL, closure, p
115
);
116
return trilogy_callable_init(t, callable);
117
}
···
123
malloc_safe(sizeof(trilogy_callable_value));
124
trilogy_callable_value_init(
125
callable, CALLABLE_RULE, arity, NULL, NULL, NULL, NULL, NULL, NULL,
126
-
NULL, NULL, closure, p
127
);
128
return trilogy_callable_init(t, callable);
129
}
130
131
-
trilogy_callable_value*
132
-
trilogy_callable_init_proc(trilogy_value* t, uint32_t arity, void* p) {
133
-
return trilogy_callable_init_do(t, arity, NO_CLOSURE, p);
134
}
135
136
-
trilogy_callable_value* trilogy_callable_init_func(trilogy_value* t, void* p) {
137
-
return trilogy_callable_init_fn(t, NO_CLOSURE, p);
138
}
139
140
-
trilogy_callable_value*
141
-
trilogy_callable_init_rule(trilogy_value* t, uint32_t arity, void* p) {
142
-
return trilogy_callable_init_qy(t, arity, NO_CLOSURE, p);
143
}
144
145
trilogy_callable_value* trilogy_callable_init_cont(
146
trilogy_value* t, trilogy_value* return_to, trilogy_value* yield_to,
147
trilogy_value* cancel_to, trilogy_value* resume_to, trilogy_value* break_to,
148
trilogy_value* continue_to, trilogy_value* next_to, trilogy_value* done_to,
149
-
trilogy_value* closure, void* p
150
) {
151
assert(closure != NO_CLOSURE);
152
assert(closure->tag == TAG_ARRAY);
···
154
malloc_safe(sizeof(trilogy_callable_value));
155
trilogy_callable_value_init(
156
callable, CALLABLE_CONTINUATION, 1, return_to, yield_to, cancel_to,
157
-
resume_to, break_to, continue_to, next_to, done_to, closure, p
158
);
159
return trilogy_callable_init(t, callable);
160
}
···
171
malloc_safe(sizeof(trilogy_callable_value));
172
trilogy_callable_value_init(
173
callable, CALLABLE_RESUME, 1, return_to, yield_to, cancel_to, resume_to,
174
-
break_to, continue_to, next_to, done_to, closure, p
175
);
176
return trilogy_callable_init(t, callable);
177
}
···
188
malloc_safe(sizeof(trilogy_callable_value));
189
trilogy_callable_value_init(
190
callable, CALLABLE_CONTINUE, 1, return_to, yield_to, cancel_to,
191
-
resume_to, break_to, continue_to, next_to, done_to, closure, p
192
);
193
return trilogy_callable_init(t, callable);
194
}
···
8
#include <stdint.h>
9
#include <stdlib.h>
10
11
+
static const char* CALLABLE_NAME_FN = "<fn>";
12
+
static const char* CALLABLE_NAME_DO = "<do>";
13
+
static const char* CALLABLE_NAME_QY = "<qy>";
14
+
static const char* CALLABLE_NAME_RETURN = "<return>";
15
+
static const char* CALLABLE_NAME_CANCEL = "<cancel>";
16
+
static const char* CALLABLE_NAME_RESUME = "<resume>";
17
+
static const char* CALLABLE_NAME_BREAK = "<break>";
18
+
static const char* CALLABLE_NAME_CONTINUE = "<continue>";
19
+
20
trilogy_value* prepare_closure(uint32_t closure_size) {
21
return calloc_safe(closure_size, sizeof(trilogy_value));
22
}
···
46
trilogy_value* return_to, trilogy_value* yield_to, trilogy_value* cancel_to,
47
trilogy_value* resume_to, trilogy_value* break_to,
48
trilogy_value* continue_to, trilogy_value* next_to, trilogy_value* done_to,
49
+
trilogy_value* closure, void* p, const char* name
50
) {
51
assert(closure == NO_CLOSURE || closure->tag == TAG_ARRAY);
52
callable->rc = 1;
···
98
*closure = trilogy_undefined;
99
}
100
callable->function = p;
101
+
callable->name = name;
102
TRACE("Initialized callable (%d): %p\n", callable->tag, callable);
103
return callable;
104
}
···
109
malloc_safe(sizeof(trilogy_callable_value));
110
trilogy_callable_value_init(
111
callable, CALLABLE_FUNCTION, 1, NULL, NULL, NULL, NULL, NULL, NULL,
112
+
NULL, NULL, closure, p, CALLABLE_NAME_FN
113
);
114
return trilogy_callable_init(t, callable);
115
}
···
121
malloc_safe(sizeof(trilogy_callable_value));
122
trilogy_callable_value_init(
123
callable, CALLABLE_PROCEDURE, arity, NULL, NULL, NULL, NULL, NULL, NULL,
124
+
NULL, NULL, closure, p, CALLABLE_NAME_DO
125
);
126
return trilogy_callable_init(t, callable);
127
}
···
133
malloc_safe(sizeof(trilogy_callable_value));
134
trilogy_callable_value_init(
135
callable, CALLABLE_RULE, arity, NULL, NULL, NULL, NULL, NULL, NULL,
136
+
NULL, NULL, closure, p, CALLABLE_NAME_QY
137
);
138
return trilogy_callable_init(t, callable);
139
}
140
141
+
trilogy_callable_value* trilogy_callable_init_proc(
142
+
trilogy_value* t, uint32_t arity, void* p, const char* name
143
+
) {
144
+
trilogy_callable_value* callable =
145
+
malloc_safe(sizeof(trilogy_callable_value));
146
+
trilogy_callable_value_init(
147
+
callable, CALLABLE_PROCEDURE, arity, NULL, NULL, NULL, NULL, NULL, NULL,
148
+
NULL, NULL, NO_CLOSURE, p, name
149
+
);
150
+
return trilogy_callable_init(t, callable);
151
}
152
153
+
trilogy_callable_value*
154
+
trilogy_callable_init_func(trilogy_value* t, void* p, const char* name) {
155
+
trilogy_callable_value* callable =
156
+
malloc_safe(sizeof(trilogy_callable_value));
157
+
trilogy_callable_value_init(
158
+
callable, CALLABLE_FUNCTION, 1, NULL, NULL, NULL, NULL, NULL, NULL,
159
+
NULL, NULL, NO_CLOSURE, p, name
160
+
);
161
+
return trilogy_callable_init(t, callable);
162
}
163
164
+
trilogy_callable_value* trilogy_callable_init_rule(
165
+
trilogy_value* t, uint32_t arity, void* p, const char* name
166
+
) {
167
+
trilogy_callable_value* callable =
168
+
malloc_safe(sizeof(trilogy_callable_value));
169
+
trilogy_callable_value_init(
170
+
callable, CALLABLE_RULE, arity, NULL, NULL, NULL, NULL, NULL, NULL,
171
+
NULL, NULL, NO_CLOSURE, p, name
172
+
);
173
+
return trilogy_callable_init(t, callable);
174
}
175
176
trilogy_callable_value* trilogy_callable_init_cont(
177
trilogy_value* t, trilogy_value* return_to, trilogy_value* yield_to,
178
trilogy_value* cancel_to, trilogy_value* resume_to, trilogy_value* break_to,
179
trilogy_value* continue_to, trilogy_value* next_to, trilogy_value* done_to,
180
+
trilogy_value* closure, void* p, const char* name
181
) {
182
assert(closure != NO_CLOSURE);
183
assert(closure->tag == TAG_ARRAY);
···
185
malloc_safe(sizeof(trilogy_callable_value));
186
trilogy_callable_value_init(
187
callable, CALLABLE_CONTINUATION, 1, return_to, yield_to, cancel_to,
188
+
resume_to, break_to, continue_to, next_to, done_to, closure, p, name
189
);
190
return trilogy_callable_init(t, callable);
191
}
···
202
malloc_safe(sizeof(trilogy_callable_value));
203
trilogy_callable_value_init(
204
callable, CALLABLE_RESUME, 1, return_to, yield_to, cancel_to, resume_to,
205
+
break_to, continue_to, next_to, done_to, closure, p,
206
+
CALLABLE_NAME_RESUME
207
);
208
return trilogy_callable_init(t, callable);
209
}
···
220
malloc_safe(sizeof(trilogy_callable_value));
221
trilogy_callable_value_init(
222
callable, CALLABLE_CONTINUE, 1, return_to, yield_to, cancel_to,
223
+
resume_to, break_to, continue_to, next_to, done_to, closure, p,
224
+
CALLABLE_NAME_CONTINUE
225
);
226
return trilogy_callable_init(t, callable);
227
}
+8
-5
trilogy-llvm/core/trilogy_callable.h
+8
-5
trilogy-llvm/core/trilogy_callable.h
···
15
trilogy_value* t, uint32_t arity, trilogy_value* closure, void* p
16
);
17
18
-
trilogy_callable_value* trilogy_callable_init_func(trilogy_value* t, void* p);
19
trilogy_callable_value*
20
-
trilogy_callable_init_proc(trilogy_value* t, uint32_t arity, void* p);
21
-
trilogy_callable_value*
22
-
trilogy_callable_init_rule(trilogy_value* t, uint32_t arity, void* p);
23
trilogy_callable_value* trilogy_callable_init_cont(
24
trilogy_value* t, trilogy_value* return_to /* moved */,
25
trilogy_value* yield_to /* moved */, trilogy_value* cancel_to /* moved */,
26
trilogy_value* resume_to /* moved */, trilogy_value* break_to /* moved */,
27
trilogy_value* continue_to /* moved */, trilogy_value* next_to /* moved */,
28
trilogy_value* done_to /* moved */, trilogy_value* closure /* moved */,
29
-
void* p
30
);
31
trilogy_callable_value* trilogy_callable_init_resume(
32
trilogy_value* t, trilogy_value* return_to /* moved */,
···
15
trilogy_value* t, uint32_t arity, trilogy_value* closure, void* p
16
);
17
18
trilogy_callable_value*
19
+
trilogy_callable_init_func(trilogy_value* t, void* p, const char* name);
20
+
trilogy_callable_value* trilogy_callable_init_proc(
21
+
trilogy_value* t, uint32_t arity, void* p, const char* name
22
+
);
23
+
trilogy_callable_value* trilogy_callable_init_rule(
24
+
trilogy_value* t, uint32_t arity, void* p, const char* name
25
+
);
26
trilogy_callable_value* trilogy_callable_init_cont(
27
trilogy_value* t, trilogy_value* return_to /* moved */,
28
trilogy_value* yield_to /* moved */, trilogy_value* cancel_to /* moved */,
29
trilogy_value* resume_to /* moved */, trilogy_value* break_to /* moved */,
30
trilogy_value* continue_to /* moved */, trilogy_value* next_to /* moved */,
31
trilogy_value* done_to /* moved */, trilogy_value* closure /* moved */,
32
+
void* p, const char* name
33
);
34
trilogy_callable_value* trilogy_callable_init_resume(
35
trilogy_value* t, trilogy_value* return_to /* moved */,
+5
trilogy-llvm/core/types.h
+5
trilogy-llvm/core/types.h
+16
trilogy-llvm/src/bare.rs
+16
trilogy-llvm/src/bare.rs
···
1425
t: PointerValue<'ctx>,
1426
arity: usize,
1427
function: FunctionValue<'ctx>,
1428
) {
1429
let f = self.declare_bare(
1430
"trilogy_callable_init_proc",
1431
self.context.ptr_type(AddressSpace::default()).fn_type(
···
1433
self.context.ptr_type(AddressSpace::default()).into(),
1434
self.context.i64_type().into(),
1435
self.context.ptr_type(AddressSpace::default()).into(),
1436
],
1437
false,
1438
),
···
1447
.const_int(arity as u64, false)
1448
.into(),
1449
function.as_global_value().as_pointer_value().into(),
1450
],
1451
"",
1452
)
···
1457
&self,
1458
t: PointerValue<'ctx>,
1459
function: FunctionValue<'ctx>,
1460
) {
1461
let f = self.declare_bare(
1462
"trilogy_callable_init_func",
1463
self.context.ptr_type(AddressSpace::default()).fn_type(
1464
&[
1465
self.context.ptr_type(AddressSpace::default()).into(),
1466
self.context.ptr_type(AddressSpace::default()).into(),
1467
],
1468
false,
1469
),
···
1474
&[
1475
t.into(),
1476
function.as_global_value().as_pointer_value().into(),
1477
],
1478
"",
1479
)
···
1515
t: PointerValue<'ctx>,
1516
arity: usize,
1517
function: FunctionValue<'ctx>,
1518
) {
1519
let f = self.declare_bare(
1520
"trilogy_callable_init_rule",
1521
self.context.ptr_type(AddressSpace::default()).fn_type(
···
1523
self.context.ptr_type(AddressSpace::default()).into(),
1524
self.context.i64_type().into(),
1525
self.context.ptr_type(AddressSpace::default()).into(),
1526
],
1527
false,
1528
),
···
1537
.const_int(arity as u64, false)
1538
.into(),
1539
function.as_global_value().as_pointer_value().into(),
1540
],
1541
"",
1542
)
···
1746
done_to: PointerValue<'ctx>,
1747
closure: PointerValue<'ctx>,
1748
function: FunctionValue<'ctx>,
1749
) {
1750
let f = self.declare_bare(
1751
"trilogy_callable_init_cont",
1752
self.context.ptr_type(AddressSpace::default()).fn_type(
···
1762
self.context.ptr_type(AddressSpace::default()).into(),
1763
self.context.ptr_type(AddressSpace::default()).into(),
1764
self.context.ptr_type(AddressSpace::default()).into(),
1765
],
1766
false,
1767
),
···
1781
done_to.into(),
1782
closure.into(),
1783
function.as_global_value().as_pointer_value().into(),
1784
],
1785
"",
1786
)
···
1425
t: PointerValue<'ctx>,
1426
arity: usize,
1427
function: FunctionValue<'ctx>,
1428
+
name: &str,
1429
) {
1430
+
let name_const = self.c_str(name);
1431
let f = self.declare_bare(
1432
"trilogy_callable_init_proc",
1433
self.context.ptr_type(AddressSpace::default()).fn_type(
···
1435
self.context.ptr_type(AddressSpace::default()).into(),
1436
self.context.i64_type().into(),
1437
self.context.ptr_type(AddressSpace::default()).into(),
1438
+
self.context.ptr_type(AddressSpace::default()).into(),
1439
],
1440
false,
1441
),
···
1450
.const_int(arity as u64, false)
1451
.into(),
1452
function.as_global_value().as_pointer_value().into(),
1453
+
name_const.into(),
1454
],
1455
"",
1456
)
···
1461
&self,
1462
t: PointerValue<'ctx>,
1463
function: FunctionValue<'ctx>,
1464
+
name: &str,
1465
) {
1466
+
let name_const = self.c_str(name);
1467
let f = self.declare_bare(
1468
"trilogy_callable_init_func",
1469
self.context.ptr_type(AddressSpace::default()).fn_type(
1470
&[
1471
self.context.ptr_type(AddressSpace::default()).into(),
1472
self.context.ptr_type(AddressSpace::default()).into(),
1473
+
self.context.ptr_type(AddressSpace::default()).into(),
1474
],
1475
false,
1476
),
···
1481
&[
1482
t.into(),
1483
function.as_global_value().as_pointer_value().into(),
1484
+
name_const.into(),
1485
],
1486
"",
1487
)
···
1523
t: PointerValue<'ctx>,
1524
arity: usize,
1525
function: FunctionValue<'ctx>,
1526
+
name: &str,
1527
) {
1528
+
let name_const = self.c_str(name);
1529
let f = self.declare_bare(
1530
"trilogy_callable_init_rule",
1531
self.context.ptr_type(AddressSpace::default()).fn_type(
···
1533
self.context.ptr_type(AddressSpace::default()).into(),
1534
self.context.i64_type().into(),
1535
self.context.ptr_type(AddressSpace::default()).into(),
1536
+
self.context.ptr_type(AddressSpace::default()).into(),
1537
],
1538
false,
1539
),
···
1548
.const_int(arity as u64, false)
1549
.into(),
1550
function.as_global_value().as_pointer_value().into(),
1551
+
name_const.into(),
1552
],
1553
"",
1554
)
···
1758
done_to: PointerValue<'ctx>,
1759
closure: PointerValue<'ctx>,
1760
function: FunctionValue<'ctx>,
1761
+
name: &str,
1762
) {
1763
+
let name_const = self.c_str(name);
1764
let f = self.declare_bare(
1765
"trilogy_callable_init_cont",
1766
self.context.ptr_type(AddressSpace::default()).fn_type(
···
1776
self.context.ptr_type(AddressSpace::default()).into(),
1777
self.context.ptr_type(AddressSpace::default()).into(),
1778
self.context.ptr_type(AddressSpace::default()).into(),
1779
+
self.context.ptr_type(AddressSpace::default()).into(),
1780
],
1781
false,
1782
),
···
1796
done_to.into(),
1797
closure.into(),
1798
function.as_global_value().as_pointer_value().into(),
1799
+
name_const.into(),
1800
],
1801
"",
1802
)
+1
-1
trilogy-llvm/src/rule.rs
+1
-1
trilogy-llvm/src/rule.rs
+7
-1
trilogy-llvm/src/types.rs
+7
-1
trilogy-llvm/src/types.rs
···
1
use crate::codegen::Codegen;
2
use bitvec::field::BitField;
3
use inkwell::basic_block::BasicBlock;
···
239
}
240
241
pub(crate) fn string_const(&self, into: PointerValue<'ctx>, value: &str) {
242
let bytes = value.as_bytes();
243
let string = self.module.add_global(
244
self.context.i8_type().array_type(bytes.len() as u32),
···
247
);
248
string.set_initializer(&self.context.const_string(bytes, false));
249
string.set_constant(true);
250
-
self.trilogy_string_init_new(into, value.len(), string.as_pointer_value());
251
}
252
253
pub(crate) fn bits_const(&self, into: PointerValue<'ctx>, value: &Bits) {
···
1
+
use std::fmt::Pointer;
2
+
3
use crate::codegen::Codegen;
4
use bitvec::field::BitField;
5
use inkwell::basic_block::BasicBlock;
···
241
}
242
243
pub(crate) fn string_const(&self, into: PointerValue<'ctx>, value: &str) {
244
+
self.trilogy_string_init_new(into, value.len(), self.c_str(value));
245
+
}
246
+
247
+
pub(crate) fn c_str(&self, value: &str) -> PointerValue<'ctx> {
248
let bytes = value.as_bytes();
249
let string = self.module.add_global(
250
self.context.i8_type().array_type(bytes.len() as u32),
···
253
);
254
string.set_initializer(&self.context.const_string(bytes, false));
255
string.set_constant(true);
256
+
string.as_pointer_value()
257
}
258
259
pub(crate) fn bits_const(&self, into: PointerValue<'ctx>, value: &Bits) {