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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
//: Instructions can read from addresses pointing at other locations using the
//: 'lookup' property.
:(scenario copy_indirect)
def main [
1:address:number <- copy 2/unsafe
2:number <- copy 34
# This loads location 1 as an address and looks up *that* location.
3:number <- copy 1:address:number/lookup
]
+mem: storing 34 in location 3
:(before "End Preprocess read_memory(x)")
canonize(x);
//: similarly, write to addresses pointing at other locations using the
//: 'lookup' property
:(scenario store_indirect)
def main [
1:address:number <- copy 2/unsafe
1:address:number/lookup <- copy 34
]
+mem: storing 34 in location 2
:(before "End Preprocess write_memory(x)")
canonize(x);
if (x.value == 0) {
raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
return;
}
//: writes to address 0 always loudly fail
:(scenario store_to_0_fails)
% Hide_errors = true;
def main [
1:address:number <- copy 0
1:address:number/lookup <- copy 34
]
-mem: storing 34 in location 0
+error: can't write to location 0 in '1:address:number/lookup <- copy 34'
:(code)
void canonize(reagent& x) {
if (is_literal(x)) return;
// End canonize(x) Special-cases
while (has_property(x, "lookup"))
lookup_memory(x);
}
void lookup_memory(reagent& x) {
if (!x.type || x.type->value != get(Type_ordinal, "address")) {
raise << maybe(current_recipe_name()) << "tried to /lookup " << x.original_string << " but it isn't an address\n" << end();
return;
}
// compute value
if (x.value == 0) {
raise << maybe(current_recipe_name()) << "tried to /lookup 0\n" << end();
return;
}
trace(9999, "mem") << "location " << x.value << " is " << no_scientific(get_or_insert(Memory, x.value)) << end();
x.set_value(get_or_insert(Memory, x.value));
drop_from_type(x, "address");
// End Drop Address In lookup_memory(x)
drop_one_lookup(x);
}
:(after "bool types_strictly_match(reagent to, reagent from)")
if (!canonize_type(to)) return false;
if (!canonize_type(from)) return false;
:(after "bool is_mu_array(reagent r)")
if (!canonize_type(r)) return false;
:(after "bool is_mu_address(reagent r)")
if (!canonize_type(r)) return false;
:(after "bool is_mu_number(reagent r)")
if (!canonize_type(r)) return false;
:(after "bool is_mu_boolean(reagent r)")
if (!canonize_type(r)) return false;
:(code)
bool canonize_type(reagent& r) {
while (has_property(r, "lookup")) {
if (!r.type || r.type->value != get(Type_ordinal, "address")) {
raise << "can't lookup non-address: " << to_string(r) << ": " << to_string(r.type) << '\n' << end();
return false;
}
drop_from_type(r, "address");
// End Drop Address In canonize_type(r)
drop_one_lookup(r);
}
return true;
}
void drop_from_type(reagent& r, string expected_type) {
if (r.type->name != expected_type) {
raise << "can't drop2 " << expected_type << " from " << to_string(r) << '\n' << end();
return;
}
type_tree* tmp = r.type;
r.type = tmp->right;
tmp->right = NULL;
delete tmp;
}
void drop_one_lookup(reagent& r) {
for (vector<pair<string, string_tree*> >::iterator p = r.properties.begin(); p != r.properties.end(); ++p) {
if (p->first == "lookup") {
r.properties.erase(p);
return;
}
}
assert(false);
}
//:: abbreviation for '/lookup': a prefix '*'
:(scenario lookup_abbreviation)
def main [
1:address:number <- copy 2/unsafe
2:number <- copy 34
3:number <- copy *1:address:number
]
+parse: ingredient: {1: ("address" "number"), "lookup": ()}
+mem: storing 34 in location 3
:(before "End Parsing reagent")
{
while (!name.empty() && name.at(0) == '*') {
name.erase(0, 1);
properties.push_back(pair<string, string_tree*>("lookup", NULL));
}
if (name.empty())
raise << "illegal name " << original_string << '\n' << end();
}
//:: helpers for debugging
:(before "End Primitive Recipe Declarations")
_DUMP,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$dump", _DUMP);
:(before "End Primitive Recipe Implementations")
case _DUMP: {
reagent after_canonize = current_instruction().ingredients.at(0);
canonize(after_canonize);
cerr << maybe(current_recipe_name()) << current_instruction().ingredients.at(0).name << ' ' << no_scientific(current_instruction().ingredients.at(0).value) << " => " << no_scientific(after_canonize.value) << " => " << no_scientific(get_or_insert(Memory, after_canonize.value)) << '\n';
break;
}
//: grab an address, and then dump its value at intervals
//: useful for tracking down memory corruption (writing to an out-of-bounds address)
:(before "End Globals")
int Bar = -1;
:(before "End Primitive Recipe Declarations")
_BAR,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$bar", _BAR);
:(before "End Primitive Recipe Implementations")
case _BAR: {
if (current_instruction().ingredients.empty()) {
if (Bar != -1) cerr << Bar << ": " << no_scientific(get_or_insert(Memory, Bar)) << '\n';
else cerr << '\n';
}
else {
reagent tmp = current_instruction().ingredients.at(0);
canonize(tmp);
Bar = tmp.value;
}
break;
}
|