2015-04-16 17:35:49 +00:00
|
|
|
//: Containers contain a fixed number of elements of different types.
|
2015-04-17 18:22:59 +00:00
|
|
|
|
2015-03-17 03:26:59 +00:00
|
|
|
:(before "End Mu Types Initialization")
|
2015-05-13 17:03:26 +00:00
|
|
|
//: We'll use this container as a running example, with two number elements.
|
2015-05-06 00:17:43 +00:00
|
|
|
type_number point = Type_number["point"] = Next_type_number++;
|
2015-02-22 08:08:25 +00:00
|
|
|
Type[point].size = 2;
|
2015-04-16 17:35:49 +00:00
|
|
|
Type[point].kind = container;
|
2015-03-21 04:12:51 +00:00
|
|
|
Type[point].name = "point";
|
2015-02-20 07:49:13 +00:00
|
|
|
vector<type_number> i;
|
2015-05-13 17:03:26 +00:00
|
|
|
i.push_back(number);
|
2015-02-22 08:08:25 +00:00
|
|
|
Type[point].elements.push_back(i);
|
|
|
|
Type[point].elements.push_back(i);
|
2015-02-20 07:49:13 +00:00
|
|
|
|
2015-05-07 22:06:53 +00:00
|
|
|
//: Containers can be copied around with a single instruction just like
|
2015-05-13 17:03:26 +00:00
|
|
|
//: numbers, no matter how large they are.
|
2015-05-07 22:06:53 +00:00
|
|
|
|
2015-02-20 07:49:13 +00:00
|
|
|
:(scenario copy_multiple_locations)
|
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
1:number <- copy 34:literal
|
|
|
|
2:number <- copy 35:literal
|
2015-02-22 08:08:25 +00:00
|
|
|
3:point <- copy 1:point
|
2015-02-20 07:49:13 +00:00
|
|
|
]
|
|
|
|
+run: ingredient 0 is 1
|
|
|
|
+mem: location 1 is 34
|
2015-02-22 08:08:25 +00:00
|
|
|
+mem: location 2 is 35
|
2015-03-24 06:59:59 +00:00
|
|
|
+mem: storing 34 in location 3
|
|
|
|
+mem: storing 35 in location 4
|
2015-02-20 08:03:47 +00:00
|
|
|
|
2015-03-27 04:06:14 +00:00
|
|
|
:(before "End Mu Types Initialization")
|
2015-04-16 17:35:49 +00:00
|
|
|
// A more complex container, containing another container as one of its
|
|
|
|
// elements.
|
2015-05-13 17:03:26 +00:00
|
|
|
type_number point_number = Type_number["point-number"] = Next_type_number++;
|
|
|
|
Type[point_number].size = 2;
|
|
|
|
Type[point_number].kind = container;
|
|
|
|
Type[point_number].name = "point-number";
|
2015-03-27 04:06:14 +00:00
|
|
|
vector<type_number> p2;
|
|
|
|
p2.push_back(point);
|
2015-05-13 17:03:26 +00:00
|
|
|
Type[point_number].elements.push_back(p2);
|
2015-03-27 04:06:14 +00:00
|
|
|
vector<type_number> i2;
|
2015-05-13 17:03:26 +00:00
|
|
|
i2.push_back(number);
|
|
|
|
Type[point_number].elements.push_back(i2);
|
2015-03-27 04:06:14 +00:00
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario copy_handles_nested_container_elements)
|
2015-03-27 04:06:14 +00:00
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
12:number <- copy 34:literal
|
|
|
|
13:number <- copy 35:literal
|
|
|
|
14:number <- copy 36:literal
|
|
|
|
15:point-number <- copy 12:point-number
|
2015-03-27 04:06:14 +00:00
|
|
|
]
|
|
|
|
+mem: storing 36 in location 17
|
|
|
|
|
2015-05-07 22:06:53 +00:00
|
|
|
//: Containers can be checked for equality with a single instruction just like
|
2015-05-13 17:03:26 +00:00
|
|
|
//: numbers, no matter how large they are.
|
2015-05-07 22:06:53 +00:00
|
|
|
|
|
|
|
:(scenario compare_multiple_locations)
|
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
1:number <- copy 34:literal # first
|
|
|
|
2:number <- copy 35:literal
|
|
|
|
3:number <- copy 36:literal
|
|
|
|
4:number <- copy 34:literal # second
|
|
|
|
5:number <- copy 35:literal
|
|
|
|
6:number <- copy 36:literal
|
|
|
|
7:boolean <- equal 1:point-number, 4:point-number
|
2015-05-07 22:06:53 +00:00
|
|
|
]
|
|
|
|
+mem: storing 1 in location 7
|
|
|
|
|
|
|
|
:(scenario compare_multiple_locations2)
|
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
1:number <- copy 34:literal # first
|
|
|
|
2:number <- copy 35:literal
|
|
|
|
3:number <- copy 36:literal
|
|
|
|
4:number <- copy 34:literal # second
|
|
|
|
5:number <- copy 35:literal
|
|
|
|
6:number <- copy 37:literal # different
|
|
|
|
7:boolean <- equal 1:point-number, 4:point-number
|
2015-05-07 22:06:53 +00:00
|
|
|
]
|
|
|
|
+mem: storing 0 in location 7
|
|
|
|
|
2015-03-27 04:47:29 +00:00
|
|
|
:(before "End size_of(types) Cases")
|
2015-05-07 22:06:53 +00:00
|
|
|
type_info t = Type[types.at(0)];
|
2015-04-16 17:35:49 +00:00
|
|
|
if (t.kind == container) {
|
2015-04-18 01:16:08 +00:00
|
|
|
// size of a container is the sum of the sizes of its elements
|
2015-03-27 04:06:14 +00:00
|
|
|
size_t result = 0;
|
2015-05-04 18:02:56 +00:00
|
|
|
for (index_t i = 0; i < t.elements.size(); ++i) {
|
2015-05-07 22:06:53 +00:00
|
|
|
result += size_of(t.elements.at(i));
|
2015-03-27 04:06:14 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: To access elements of a container, use 'get'
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario get)
|
2015-03-27 04:06:14 +00:00
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
12:number <- copy 34:literal
|
|
|
|
13:number <- copy 35:literal
|
|
|
|
15:number <- get 12:point, 1:offset
|
2015-03-27 04:06:14 +00:00
|
|
|
]
|
|
|
|
+run: instruction main/2
|
|
|
|
+run: ingredient 0 is 12
|
|
|
|
+run: ingredient 1 is 1
|
|
|
|
+run: address to copy is 13
|
|
|
|
+run: its type is 1
|
|
|
|
+mem: location 13 is 35
|
2015-05-07 22:06:53 +00:00
|
|
|
+run: product 0 is 15
|
2015-03-27 04:06:14 +00:00
|
|
|
+mem: storing 35 in location 15
|
|
|
|
|
2015-04-17 17:31:17 +00:00
|
|
|
:(before "End Primitive Recipe Declarations")
|
|
|
|
GET,
|
2015-02-20 08:03:47 +00:00
|
|
|
:(before "End Primitive Recipe Numbers")
|
|
|
|
Recipe_number["get"] = GET;
|
|
|
|
:(before "End Primitive Recipe Implementations")
|
|
|
|
case GET: {
|
2015-05-07 22:06:53 +00:00
|
|
|
reagent base = current_instruction().ingredients.at(0);
|
2015-05-13 00:00:56 +00:00
|
|
|
index_t base_address = base.value;
|
2015-05-07 22:06:53 +00:00
|
|
|
type_number base_type = base.types.at(0);
|
2015-04-16 17:35:49 +00:00
|
|
|
assert(Type[base_type].kind == container);
|
2015-05-07 22:06:53 +00:00
|
|
|
assert(isa_literal(current_instruction().ingredients.at(1)));
|
|
|
|
assert(ingredients.at(1).size() == 1); // scalar
|
|
|
|
index_t offset = ingredients.at(1).at(0);
|
2015-05-06 00:20:11 +00:00
|
|
|
index_t src = base_address;
|
2015-05-04 18:02:56 +00:00
|
|
|
for (index_t i = 0; i < offset; ++i) {
|
2015-05-07 22:06:53 +00:00
|
|
|
src += size_of(Type[base_type].elements.at(i));
|
2015-02-22 08:15:14 +00:00
|
|
|
}
|
2015-02-20 08:03:47 +00:00
|
|
|
trace("run") << "address to copy is " << src;
|
2015-04-16 17:35:49 +00:00
|
|
|
assert(Type[base_type].kind == container);
|
2015-02-20 08:03:47 +00:00
|
|
|
assert(Type[base_type].elements.size() > offset);
|
2015-05-07 22:49:40 +00:00
|
|
|
type_number src_type = Type[base_type].elements.at(offset).at(0);
|
2015-02-20 08:03:47 +00:00
|
|
|
trace("run") << "its type is " << src_type;
|
2015-03-26 02:06:32 +00:00
|
|
|
reagent tmp;
|
2015-05-13 00:00:56 +00:00
|
|
|
tmp.set_value(src);
|
2015-03-26 02:06:32 +00:00
|
|
|
tmp.types.push_back(src_type);
|
2015-05-07 22:06:53 +00:00
|
|
|
products.push_back(read_memory(tmp));
|
2015-02-20 08:03:47 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-03-27 04:06:14 +00:00
|
|
|
//: 'get' requires a literal in ingredient 1. We'll use a synonym called
|
2015-04-18 01:32:39 +00:00
|
|
|
//: 'offset'.
|
2015-03-17 03:26:59 +00:00
|
|
|
:(before "End Mu Types Initialization")
|
2015-03-27 04:06:14 +00:00
|
|
|
Type_number["offset"] = 0;
|
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario get_handles_nested_container_elements)
|
2015-02-22 08:15:14 +00:00
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
12:number <- copy 34:literal
|
|
|
|
13:number <- copy 35:literal
|
|
|
|
14:number <- copy 36:literal
|
|
|
|
15:number <- get 12:point-number, 1:offset
|
2015-02-22 08:15:14 +00:00
|
|
|
]
|
2015-02-25 09:24:11 +00:00
|
|
|
+run: instruction main/2
|
2015-02-22 08:15:14 +00:00
|
|
|
+run: ingredient 0 is 12
|
|
|
|
+run: ingredient 1 is 1
|
|
|
|
+run: address to copy is 14
|
|
|
|
+run: its type is 1
|
|
|
|
+mem: location 14 is 36
|
2015-05-07 22:06:53 +00:00
|
|
|
+run: product 0 is 15
|
2015-03-24 06:59:59 +00:00
|
|
|
+mem: storing 36 in location 15
|
2015-02-22 08:15:14 +00:00
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: To write to elements of containers, you need their address.
|
2015-04-17 17:31:17 +00:00
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario get_address)
|
2015-04-17 17:31:17 +00:00
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
12:number <- copy 34:literal
|
|
|
|
13:number <- copy 35:literal
|
|
|
|
15:address:number <- get-address 12:point, 1:offset
|
2015-04-17 17:31:17 +00:00
|
|
|
]
|
|
|
|
+run: instruction main/2
|
|
|
|
+run: ingredient 0 is 12
|
|
|
|
+run: ingredient 1 is 1
|
|
|
|
+run: address to copy is 13
|
|
|
|
+mem: storing 13 in location 15
|
|
|
|
|
|
|
|
:(before "End Primitive Recipe Declarations")
|
|
|
|
GET_ADDRESS,
|
2015-02-21 04:25:45 +00:00
|
|
|
:(before "End Primitive Recipe Numbers")
|
|
|
|
Recipe_number["get-address"] = GET_ADDRESS;
|
|
|
|
:(before "End Primitive Recipe Implementations")
|
|
|
|
case GET_ADDRESS: {
|
2015-05-07 22:06:53 +00:00
|
|
|
reagent base = current_instruction().ingredients.at(0);
|
2015-05-13 00:00:56 +00:00
|
|
|
index_t base_address = base.value;
|
2015-05-07 22:06:53 +00:00
|
|
|
type_number base_type = base.types.at(0);
|
2015-04-16 17:35:49 +00:00
|
|
|
assert(Type[base_type].kind == container);
|
2015-05-07 22:06:53 +00:00
|
|
|
assert(isa_literal(current_instruction().ingredients.at(1)));
|
|
|
|
assert(ingredients.at(1).size() == 1); // scalar
|
|
|
|
index_t offset = ingredients.at(1).at(0);
|
|
|
|
index_t result = base_address;
|
2015-05-04 18:02:56 +00:00
|
|
|
for (index_t i = 0; i < offset; ++i) {
|
2015-05-07 22:06:53 +00:00
|
|
|
result += size_of(Type[base_type].elements.at(i));
|
2015-02-22 08:44:30 +00:00
|
|
|
}
|
2015-05-07 22:06:53 +00:00
|
|
|
trace("run") << "address to copy is " << result;
|
|
|
|
products.resize(1);
|
2015-05-13 00:00:56 +00:00
|
|
|
products.at(0).push_back(result);
|
2015-02-21 04:25:45 +00:00
|
|
|
break;
|
|
|
|
}
|