149 lines
3.7 KiB
Plaintext
149 lines
3.7 KiB
Plaintext
:(scenarios run)
|
|
:(scenario copy_literal)
|
|
recipe main [
|
|
1:integer <- copy 23:literal
|
|
]
|
|
+run: instruction main/0
|
|
+run: ingredient 0 is 23
|
|
+mem: storing in location 1
|
|
|
|
:(scenario copy)
|
|
recipe main [
|
|
1:integer <- copy 23:literal
|
|
2:integer <- copy 1:integer
|
|
]
|
|
+run: instruction main/1
|
|
+run: ingredient 0 is 1
|
|
+mem: location 1 is 23
|
|
+mem: storing in location 2
|
|
|
|
:(before "End Types")
|
|
// Book-keeping while running a recipe.
|
|
//: Later layers will change this.
|
|
struct routine {
|
|
recipe_number running_recipe;
|
|
size_t running_at;
|
|
routine(recipe_number r) :running_recipe(r), running_at(0) {}
|
|
};
|
|
|
|
:(code)
|
|
void run(recipe_number r) {
|
|
run(routine(r));
|
|
}
|
|
|
|
void run(routine rr) {
|
|
while (!done(rr)) {
|
|
vector<instruction>& instructions = steps(rr);
|
|
size_t& pc = running_at(rr);
|
|
// Running one instruction.
|
|
trace("run") << "instruction " << recipe_name(rr) << '/' << pc;
|
|
switch (instructions[pc].operation) {
|
|
// Primitive Recipe Implementations.
|
|
case COPY: {
|
|
trace("run") << "ingredient 0 is " << instructions[pc].ingredients[0].name;
|
|
vector<int> data = read_memory(instructions[pc].ingredients[0]);
|
|
write_memory(instructions[pc].products[0], data);
|
|
break;
|
|
}
|
|
// End Primitive Recipe Implementations.
|
|
default: {
|
|
cout << "not a primitive op: " << instructions[pc].operation << '\n';
|
|
}
|
|
}
|
|
++pc;
|
|
}
|
|
}
|
|
|
|
//: Some helpers.
|
|
//: We'll need to override these later as we change the definition of routine.
|
|
//: Important that they return referrences into the routine.
|
|
inline size_t& running_at(routine& rr) {
|
|
return rr.running_at;
|
|
}
|
|
|
|
inline string recipe_name(routine& rr) {
|
|
return Recipe[rr.running_recipe].name;
|
|
}
|
|
|
|
inline vector<instruction>& steps(routine& rr) {
|
|
return Recipe[rr.running_recipe].steps;
|
|
}
|
|
|
|
inline bool done(routine& rr) {
|
|
return running_at(rr) >= steps(rr).size();
|
|
}
|
|
|
|
:(before "End Main")
|
|
if (argc > 1) {
|
|
setup();
|
|
for (int i = 1; i < argc; ++i) {
|
|
ifstream fin(argv[i]);
|
|
while (!fin.eof()) add_recipe(fin);
|
|
fin.close();
|
|
}
|
|
|
|
recipe_number r = Recipe_number[string("main")];
|
|
if (r) run(r);
|
|
dump_memory();
|
|
}
|
|
|
|
//: helper for tests
|
|
|
|
:(before "End Globals")
|
|
vector<recipe_number> recipes_added_by_test;
|
|
|
|
:(code)
|
|
void run(string form) {
|
|
vector<recipe_number> tmp = add_recipes(form);
|
|
recipes_added_by_test.insert(recipes_added_by_test.end(), tmp.begin(), tmp.end());
|
|
run(recipes_added_by_test.front());
|
|
}
|
|
|
|
:(before "End Setup")
|
|
for (size_t i = 0; i < recipes_added_by_test.size(); ++i) {
|
|
Recipe_number.erase(Recipe[recipes_added_by_test[i]].name);
|
|
Recipe.erase(recipes_added_by_test[i]);
|
|
}
|
|
recipes_added_by_test.clear();
|
|
|
|
:(code)
|
|
vector<int> read_memory(reagent x) {
|
|
//? cout << "read_memory: " << x.to_string() << '\n'; //? 1
|
|
vector<int> result;
|
|
if (x.types[0] == 0) { // literal
|
|
result.push_back(to_int(x.name));
|
|
return result;
|
|
}
|
|
int base = to_int(x.name);
|
|
for (size_t offset = 0; offset < Type[x.types[0]].size; ++offset) {
|
|
int val = Memory[base+offset];
|
|
trace("mem") << "location " << base+offset << " is " << val;
|
|
result.push_back(val);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void write_memory(reagent x, vector<int> data) {
|
|
int base = to_int(x.name);
|
|
size_t size = size_of(x);
|
|
if (size != data.size()) raise << "size mismatch in storing to " << x.to_string();
|
|
for (size_t offset = 0; offset < size; ++offset) {
|
|
trace("mem") << "storing in location " << base+offset;
|
|
Memory[base+offset] = data[offset];
|
|
}
|
|
}
|
|
|
|
:(code)
|
|
int to_int(string n) {
|
|
char* end = NULL;
|
|
int result = strtol(n.c_str(), &end, /*any base*/0);
|
|
assert(*end == '\0');
|
|
return result;
|
|
}
|
|
|
|
size_t size_of(reagent r) {
|
|
type_info t = Type[r.types[0]];
|
|
if (!t.is_record && !t.is_array) return t.size;
|
|
return t.size; // TODO
|
|
}
|