blob: 7244cca28d68d3493108c84f870d67cbf4dc5a81 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
//: A simple memory allocator to create space for new variables at runtime.
:(scenarios run)
:(scenario "new")
# call new two times with identical arguments; you should get back different results
recipe main [
1:address:integer/raw <- new integer:type
2:address:integer/raw <- new integer:type
3:boolean/raw <- equal 1:address:integer/raw, 2:address:integer/raw
]
+mem: storing 0 in location 3
:(before "End Globals")
const size_t Alloc_init = 1000;
:(before "End routine Fields")
size_t alloc;
:(replace{} "routine::routine(recipe_number r)")
routine::routine(recipe_number r) :alloc(Alloc_init) {
calls.push(call(r));
}
//:: First handle 'type' operands.
:(before "End Mu Types Initialization")
Type_number["type"] = 0;
:(after "Per-recipe Transforms")
// replace type names with type_numbers
if (inst.operation == Recipe_number["new"]) {
// first arg must be of type 'type'
assert(inst.ingredients.size() >= 1);
//? cout << inst.ingredients[0].to_string() << '\n'; //? 1
assert(isa_literal(inst.ingredients[0]));
if (inst.ingredients[0].properties[0].second[0] == "type") {
inst.ingredients[0].set_value(Type_number[inst.ingredients[0].name]);
}
trace("new") << inst.ingredients[0].name << " -> " << inst.ingredients[0].value;
}
//:: Now implement the primitive recipe.
:(before "End Primitive Recipe Declarations")
NEW,
:(before "End Primitive Recipe Numbers")
Recipe_number["new"] = NEW;
:(before "End Primitive Recipe Implementations")
case NEW: {
vector<int> result;
trace("mem") << "new alloc: " << Current_routine->alloc;
result.push_back(Current_routine->alloc);
write_memory(instructions[pc].products[0], result);
vector<int> types;
types.push_back(instructions[pc].ingredients[0].value);
if (instructions[pc].ingredients.size() > 1) {
// array
vector<int> capacity = read_memory(instructions[pc].ingredients[1]);
trace("mem") << "array size is " << capacity[0];
Memory[Current_routine->alloc] = capacity[0];
Current_routine->alloc += capacity[0]*size_of(types);
}
else {
// scalar
Current_routine->alloc += size_of(types);
}
break;
}
:(scenario "new_array")
recipe main [
1:address:array:integer/raw <- new integer:type, 5:literal
2:address:integer/raw <- new integer:type
3:integer/raw <- subtract 2:address:integer/raw, 1:address:array:integer/raw
]
+run: instruction main/0
+mem: array size is 5
+run: instruction main/1
+run: instruction main/2
+mem: storing 5 in location 3
//:: Next, extend 'new' to handle a string literal argument.
:(scenario "new_string")
recipe main [
1:address:array:character <- new [abc def]
2:character <- index 1:address:array:character/deref, 5:literal
]
# integer code for 'e'
+mem: storing 101 in location 2
:(after "case NEW" following "Primitive Recipe Implementations")
if (instructions[pc].ingredients[0].properties[0].second[0] == "literal-string") {
// allocate an array just large enough for it
vector<int> result;
result.push_back(Current_routine->alloc);
write_memory(instructions[pc].products[0], result);
// assume that all characters fit in a single location
//? cout << "new string literal: " << instructions[pc].ingredients[0].name << '\n'; //? 1
Memory[Current_routine->alloc++] = instructions[pc].ingredients[0].name.size();
for (size_t i = 0; i < instructions[pc].ingredients[0].name.size(); ++i) {
Memory[Current_routine->alloc++] = instructions[pc].ingredients[0].name[i];
}
// mu strings are not null-terminated in memory
break;
}
//: vim: ft=cpp
|