blob: 5e53a8ceabc435949070ec5710e3da7644f8a3a1 (
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
|
:(scenario "copy_indirect")
# Instructions can read from addresses pointing at other locations using the 'deref' property.
recipe main [
1:address:integer <- copy 2:literal
2:integer <- copy 34:literal
# This loads location 1 as an address and looks up *that* location.
3:integer <- copy 1:address:integer/deref
]
+run: instruction 2
+mem: location 1 is 2
+mem: location 2 is 34
+mem: storing in location 3
:(replace{} "vector<int> read_memory(reagent x)")
vector<int> read_memory(reagent x) {
vector<int> result;
if (x.types[0] == 0) { // literal
result.push_back(to_int(x.name));
return result;
}
x = canonize(x);
int base = to_int(x.name);
size_t size = size_of(x);
for (size_t offset = 0; offset < size; ++offset) {
int val = Memory[base+offset];
trace("mem") << "location " << base+offset << " is " << val;
result.push_back(val);
}
return result;
}
:(scenario "store_indirect")
# similarly, write to addresses pointing at other locations using the 'deref' property
recipe main [
1:address:integer <- copy 2:literal
1:address:integer/deref <- copy 34:literal
]
+run: instruction 1
+mem: location 1 is 2
+mem: storing in location 2
:(replace{} "void write_memory(reagent x, vector<int> data)")
void write_memory(reagent x, vector<int> data) {
x = canonize(x);
int base = to_int(x.name);
if (!Type[x.types[0]].is_array && size_of(x) != data.size())
raise << "size mismatch in storing to " << x.to_string();
for (size_t offset = 0; offset < data.size(); ++offset) {
trace("mem") << "storing in location " << base+offset;
Memory[base+offset] = data[offset];
}
}
:(code)
reagent canonize(reagent x) {
reagent r = x;
while (has_property(r, "deref"))
r = deref(r);
return r;
}
bool has_property(reagent x, string name) {
for (size_t i = 0; i < x.properties.size(); ++i) {
if (x.properties[i].first == name) return true;
}
return false;
}
reagent deref(reagent x) {
reagent result("");
assert(x.types[0] == 2); // address
// compute name
ostringstream out;
out << Memory[to_int(x.name)];
result.name = out.str();
trace("mem") << "location " << x.name << " is " << result.name;
// populate types
copy(++x.types.begin(), x.types.end(), inserter(result.types, result.types.begin()));
// drop-one 'deref'
int i = 0;
int len = x.properties.size();
while (true) {
assert(i < len);
if (x.properties[i].first == "deref") break;
result.properties.push_back(x.properties[i]);
++i;
}
++i; // skip first deref
while (i < len) {
result.properties.push_back(x.properties[i]);
}
return result;
}
|