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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
//: Allow code for recipes to be pulled in from multiple places.
//:
//: TODO: switch recipe.steps to a more efficient data structure.
:(scenario tangle_before)
recipe main [
1:number <- copy 0
+label1
3:number <- copy 0
]
before +label1 [
2:number <- copy 0
]
+mem: storing 0 in location 1
+mem: storing 0 in location 2
+mem: storing 0 in location 3
# nothing else
$mem: 3
//: while loading recipes, load before/after fragments
:(before "End Globals")
map<string /*label*/, recipe> Before_fragments, After_fragments;
:(before "End Setup")
Before_fragments.clear();
After_fragments.clear();
:(before "End Command Handlers")
else if (command == "before") {
string label = next_word(in);
recipe tmp = slurp_recipe(in);
Before_fragments[label].steps.insert(Before_fragments[label].steps.end(), tmp.steps.begin(), tmp.steps.end());
}
else if (command == "after") {
string label = next_word(in);
recipe tmp = slurp_recipe(in);
After_fragments[label].steps.insert(After_fragments[label].steps.begin(), tmp.steps.begin(), tmp.steps.end());
}
//: after all recipes are loaded, insert fragments at appropriate labels
:(after "int main")
Transform.push_back(insert_fragments);
:(code)
void insert_fragments(const recipe_ordinal r) {
// Copy into a new vector because insertions invalidate iterators.
// But this way we can't insert into labels created inside before/after.
vector<instruction> result;
for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) {
const instruction inst = Recipe[r].steps.at(i);
if (!inst.is_label) {
result.push_back(inst);
continue;
}
if (Before_fragments.find(inst.label) != Before_fragments.end()) {
result.insert(result.end(), Before_fragments[inst.label].steps.begin(), Before_fragments[inst.label].steps.end());
}
result.push_back(inst);
if (After_fragments.find(inst.label) != After_fragments.end()) {
result.insert(result.end(), After_fragments[inst.label].steps.begin(), After_fragments[inst.label].steps.end());
}
}
//? for (long long int i = 0; i < SIZE(result); ++i) { //? 1
//? cout << result.at(i).to_string() << '\n'; //? 1
//? } //? 1
Recipe[r].steps.swap(result);
}
:(scenario tangle_before_and_after)
recipe main [
1:number <- copy 0
+label1
4:number <- copy 0
]
before +label1 [
2:number <- copy 0
]
after +label1 [
3:number <- copy 0
]
+mem: storing 0 in location 1
+mem: storing 0 in location 2
# label1
+mem: storing 0 in location 3
+mem: storing 0 in location 4
# nothing else
$mem: 4
:(scenario tangle_keeps_labels_separate)
recipe main [
1:number <- copy 0
+label1
+label2
6:number <- copy 0
]
before +label1 [
2:number <- copy 0
]
after +label1 [
3:number <- copy 0
]
before +label2 [
4:number <- copy 0
]
after +label2 [
5:number <- copy 0
]
+mem: storing 0 in location 1
+mem: storing 0 in location 2
# label1
+mem: storing 0 in location 3
# 'after' fragments for earlier label always go before 'before' fragments for later label
+mem: storing 0 in location 4
# label2
+mem: storing 0 in location 5
+mem: storing 0 in location 6
# nothing else
$mem: 6
:(scenario tangle_stacks_multiple_fragments)
recipe main [
1:number <- copy 0
+label1
6:number <- copy 0
]
before +label1 [
2:number <- copy 0
]
after +label1 [
3:number <- copy 0
]
before +label1 [
4:number <- copy 0
]
after +label1 [
5:number <- copy 0
]
+mem: storing 0 in location 1
# 'before' fragments stack in order
+mem: storing 0 in location 2
+mem: storing 0 in location 4
# label1
# 'after' fragments stack in reverse order
+mem: storing 0 in location 5
+mem: storing 0 in location 3
+mem: storing 0 in location 6
# nothing else
$mem: 6
:(scenario tangle_supports_fragments_with_multiple_instructions)
recipe main [
1:number <- copy 0
+label1
6:number <- copy 0
]
before +label1 [
2:number <- copy 0
3:number <- copy 0
]
after +label1 [
4:number <- copy 0
5:number <- copy 0
]
+mem: storing 0 in location 1
+mem: storing 0 in location 2
+mem: storing 0 in location 3
# label1
+mem: storing 0 in location 4
+mem: storing 0 in location 5
+mem: storing 0 in location 6
# nothing else
$mem: 6
:(scenario tangle_tangles_into_all_labels_with_same_name)
recipe main [
1:number <- copy 0
+label1
+label1
4:number <- copy 0
]
before +label1 [
2:number <- copy 0
]
after +label1 [
3:number <- copy 0
]
+mem: storing 0 in location 1
+mem: storing 0 in location 2
# label1
+mem: storing 0 in location 3
+mem: storing 0 in location 2
# label1
+mem: storing 0 in location 3
+mem: storing 0 in location 4
# nothing else
$mem: 6
|