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