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-07-04 16:40:50 +00:00
|
|
|
type_ordinal point = Type_ordinal["point"] = Next_type_ordinal++;
|
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-07-04 16:40:50 +00:00
|
|
|
vector<type_ordinal> 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-05-26 22:48:35 +00:00
|
|
|
//: Tests in this layer often explicitly setup memory before reading it as a
|
|
|
|
//: container. Don't do this in general. I'm tagging exceptions with /raw to
|
|
|
|
//: avoid warnings.
|
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-05-26 22:48:35 +00:00
|
|
|
3:point <- copy 1:point/raw # unsafe
|
2015-02-20 07:49:13 +00:00
|
|
|
]
|
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-07-04 16:40:50 +00:00
|
|
|
type_ordinal point_number = Type_ordinal["point-number"] = Next_type_ordinal++;
|
2015-05-13 17:03:26 +00:00
|
|
|
Type[point_number].size = 2;
|
|
|
|
Type[point_number].kind = container;
|
|
|
|
Type[point_number].name = "point-number";
|
2015-07-04 16:40:50 +00:00
|
|
|
vector<type_ordinal> p2;
|
2015-03-27 04:06:14 +00:00
|
|
|
p2.push_back(point);
|
2015-05-13 17:03:26 +00:00
|
|
|
Type[point_number].elements.push_back(p2);
|
2015-07-04 16:40:50 +00:00
|
|
|
vector<type_ordinal> 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
|
2015-05-26 22:48:35 +00:00
|
|
|
15:point-number <- copy 12:point-number/raw # unsafe
|
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
|
2015-05-26 22:48:35 +00:00
|
|
|
7:boolean <- equal 1:point-number/raw, 4:point-number/raw # unsafe
|
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
|
2015-05-26 22:48:35 +00:00
|
|
|
7:boolean <- equal 1:point-number/raw, 4:point-number/raw # unsafe
|
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-05-17 09:22:41 +00:00
|
|
|
long long int result = 0;
|
|
|
|
for (long long int i = 0; i < SIZE(t.elements); ++i) {
|
2015-05-19 01:40:58 +00:00
|
|
|
// todo: strengthen assertion to disallow mutual type recursion
|
|
|
|
assert(types.at(0) != t.elements.at(i).at(0));
|
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
|
2015-05-26 22:48:35 +00:00
|
|
|
15:number <- get 12:point/raw, 1:offset # unsafe
|
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")
|
2015-07-04 16:40:50 +00:00
|
|
|
Recipe_ordinal["get"] = GET;
|
2015-02-20 08:03:47 +00:00
|
|
|
:(before "End Primitive Recipe Implementations")
|
|
|
|
case GET: {
|
2015-05-07 22:06:53 +00:00
|
|
|
reagent base = current_instruction().ingredients.at(0);
|
2015-05-17 09:22:41 +00:00
|
|
|
long long int base_address = base.value;
|
2015-07-04 16:40:50 +00:00
|
|
|
type_ordinal base_type = base.types.at(0);
|
2015-06-18 18:16:37 +00:00
|
|
|
if (Type[base_type].kind != container)
|
|
|
|
raise << "'get' on a non-container in " << current_recipe_name () << ": " << current_instruction().to_string() << '\n' << die();
|
2015-06-17 19:39:09 +00:00
|
|
|
assert(is_literal(current_instruction().ingredients.at(1)));
|
2015-05-17 09:22:41 +00:00
|
|
|
assert(scalar(ingredients.at(1)));
|
|
|
|
long long int offset = ingredients.at(1).at(0);
|
2015-07-10 03:32:23 +00:00
|
|
|
assert(offset >= 0);
|
|
|
|
assert(offset < size_of(base));
|
2015-05-17 09:22:41 +00:00
|
|
|
long long int src = base_address;
|
|
|
|
for (long long int 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-05-22 01:57:25 +00:00
|
|
|
trace(Primitive_recipe_depth, "run") << "address to copy is " << src;
|
2015-04-16 17:35:49 +00:00
|
|
|
assert(Type[base_type].kind == container);
|
2015-05-17 09:22:41 +00:00
|
|
|
assert(SIZE(Type[base_type].elements) > offset);
|
2015-07-04 16:40:50 +00:00
|
|
|
type_ordinal src_type = Type[base_type].elements.at(offset).at(0);
|
2015-06-17 19:40:55 +00:00
|
|
|
trace(Primitive_recipe_depth, "run") << "its type is " << Type[src_type].name;
|
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-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
|
2015-05-26 22:48:35 +00:00
|
|
|
15:number <- get 12:point-number/raw, 1:offset # unsafe
|
2015-02-22 08:15:14 +00:00
|
|
|
]
|
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
|
2015-05-26 22:48:35 +00:00
|
|
|
15:address:number <- get-address 12:point/raw, 1:offset # unsafe
|
2015-04-17 17:31:17 +00:00
|
|
|
]
|
|
|
|
+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")
|
2015-07-04 16:40:50 +00:00
|
|
|
Recipe_ordinal["get-address"] = GET_ADDRESS;
|
2015-02-21 04:25:45 +00:00
|
|
|
:(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-17 09:22:41 +00:00
|
|
|
long long int base_address = base.value;
|
2015-07-04 16:40:50 +00:00
|
|
|
type_ordinal base_type = base.types.at(0);
|
2015-06-20 22:17:23 +00:00
|
|
|
if (Type[base_type].kind != container)
|
|
|
|
raise << "'get' on a non-container in " << current_recipe_name () << ": " << current_instruction().to_string() << '\n' << die();
|
2015-06-17 19:39:09 +00:00
|
|
|
assert(is_literal(current_instruction().ingredients.at(1)));
|
2015-05-17 09:22:41 +00:00
|
|
|
assert(scalar(ingredients.at(1)));
|
|
|
|
long long int offset = ingredients.at(1).at(0);
|
2015-07-10 03:32:23 +00:00
|
|
|
assert(offset >= 0);
|
|
|
|
assert(offset < size_of(base));
|
2015-05-17 09:22:41 +00:00
|
|
|
long long int result = base_address;
|
|
|
|
for (long long int 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-22 01:57:25 +00:00
|
|
|
trace(Primitive_recipe_depth, "run") << "address to copy is " << result;
|
2015-05-07 22:06:53 +00:00
|
|
|
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;
|
|
|
|
}
|
2015-05-14 17:30:01 +00:00
|
|
|
|
|
|
|
//:: Allow containers to be defined in mu code.
|
|
|
|
|
|
|
|
:(scenarios load)
|
|
|
|
:(scenario container)
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
y:number
|
|
|
|
]
|
|
|
|
+parse: reading container foo
|
|
|
|
+parse: element name: x
|
|
|
|
+parse: type: 1
|
|
|
|
+parse: element name: y
|
|
|
|
+parse: type: 1
|
|
|
|
|
2015-05-18 23:09:09 +00:00
|
|
|
:(scenario container_use_before_definition)
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
y:bar
|
|
|
|
]
|
|
|
|
|
|
|
|
container bar [
|
|
|
|
x:number
|
|
|
|
y:number
|
|
|
|
]
|
|
|
|
+parse: reading container foo
|
|
|
|
+parse: type number: 1000
|
|
|
|
+parse: element name: x
|
|
|
|
+parse: type: 1
|
|
|
|
+parse: element name: y
|
|
|
|
+parse: type: 1001
|
|
|
|
+parse: reading container bar
|
|
|
|
+parse: type number: 1001
|
|
|
|
|
2015-05-14 17:30:01 +00:00
|
|
|
:(before "End Command Handlers")
|
|
|
|
else if (command == "container") {
|
|
|
|
insert_container(command, container, in);
|
|
|
|
}
|
|
|
|
|
|
|
|
:(code)
|
|
|
|
void insert_container(const string& command, kind_of_type kind, istream& in) {
|
|
|
|
skip_whitespace(in);
|
|
|
|
string name = next_word(in);
|
|
|
|
trace("parse") << "reading " << command << ' ' << name;
|
|
|
|
//? cout << name << '\n'; //? 2
|
2015-07-04 16:40:50 +00:00
|
|
|
//? if (Type_ordinal.find(name) != Type_ordinal.end()) //? 1
|
|
|
|
//? cerr << Type_ordinal[name] << '\n'; //? 1
|
|
|
|
if (Type_ordinal.find(name) == Type_ordinal.end()
|
|
|
|
|| Type_ordinal[name] == 0) {
|
|
|
|
Type_ordinal[name] = Next_type_ordinal++;
|
2015-05-14 17:30:01 +00:00
|
|
|
}
|
2015-07-04 16:40:50 +00:00
|
|
|
trace("parse") << "type number: " << Type_ordinal[name];
|
2015-05-14 17:30:01 +00:00
|
|
|
skip_bracket(in, "'container' must begin with '['");
|
2015-07-04 16:40:50 +00:00
|
|
|
type_info& t = Type[Type_ordinal[name]];
|
|
|
|
recently_added_types.push_back(Type_ordinal[name]);
|
2015-05-14 17:30:01 +00:00
|
|
|
t.name = name;
|
|
|
|
t.kind = kind;
|
|
|
|
while (!in.eof()) {
|
|
|
|
skip_whitespace_and_comments(in);
|
|
|
|
string element = next_word(in);
|
|
|
|
if (element == "]") break;
|
|
|
|
istringstream inner(element);
|
|
|
|
t.element_names.push_back(slurp_until(inner, ':'));
|
|
|
|
trace("parse") << " element name: " << t.element_names.back();
|
2015-07-04 16:40:50 +00:00
|
|
|
vector<type_ordinal> types;
|
2015-05-14 17:30:01 +00:00
|
|
|
while (!inner.eof()) {
|
|
|
|
string type_name = slurp_until(inner, ':');
|
2015-07-04 16:40:50 +00:00
|
|
|
if (Type_ordinal.find(type_name) == Type_ordinal.end()) {
|
|
|
|
//? cerr << type_name << " is " << Next_type_ordinal << '\n'; //? 1
|
|
|
|
Type_ordinal[type_name] = Next_type_ordinal++;
|
2015-05-19 01:40:58 +00:00
|
|
|
}
|
2015-07-04 16:40:50 +00:00
|
|
|
types.push_back(Type_ordinal[type_name]);
|
2015-05-14 17:30:01 +00:00
|
|
|
trace("parse") << " type: " << types.back();
|
|
|
|
}
|
|
|
|
t.elements.push_back(types);
|
|
|
|
}
|
2015-05-17 09:22:41 +00:00
|
|
|
assert(SIZE(t.elements) == SIZE(t.element_names));
|
|
|
|
t.size = SIZE(t.elements);
|
2015-05-14 17:30:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//: ensure types created in one scenario don't leak outside it.
|
|
|
|
:(before "End Globals")
|
2015-07-04 16:40:50 +00:00
|
|
|
vector<type_ordinal> recently_added_types;
|
2015-05-14 17:30:01 +00:00
|
|
|
:(before "End load_permanently") //: for non-tests
|
|
|
|
recently_added_types.clear();
|
|
|
|
:(before "End Setup") //: for tests
|
2015-05-17 09:22:41 +00:00
|
|
|
for (long long int i = 0; i < SIZE(recently_added_types); ++i) {
|
2015-05-14 17:30:01 +00:00
|
|
|
//? cout << "erasing " << Type[recently_added_types.at(i)].name << '\n'; //? 1
|
2015-07-04 16:40:50 +00:00
|
|
|
Type_ordinal.erase(Type[recently_added_types.at(i)].name);
|
2015-05-14 17:30:01 +00:00
|
|
|
Type.erase(recently_added_types.at(i));
|
|
|
|
}
|
|
|
|
recently_added_types.clear();
|
2015-05-19 01:40:58 +00:00
|
|
|
// delete recent type references
|
2015-07-04 16:40:50 +00:00
|
|
|
// can't rely on recently_added_types to cleanup Type_ordinal, because of deliberately misbehaving tests with references to undefined types
|
|
|
|
map<string, type_ordinal>::iterator p = Type_ordinal.begin();
|
|
|
|
while(p != Type_ordinal.end()) {
|
2015-05-19 01:40:58 +00:00
|
|
|
// save current item
|
|
|
|
string name = p->first;
|
2015-07-04 16:40:50 +00:00
|
|
|
type_ordinal t = p->second;
|
2015-05-19 01:40:58 +00:00
|
|
|
// increment iterator
|
|
|
|
++p;
|
|
|
|
// now delete current item if necessary
|
|
|
|
if (t >= 1000) {
|
|
|
|
//? cerr << "AAA " << name << " " << t << '\n'; //? 1
|
2015-07-04 16:40:50 +00:00
|
|
|
Type_ordinal.erase(name);
|
2015-05-19 01:40:58 +00:00
|
|
|
}
|
|
|
|
}
|
2015-05-14 17:30:01 +00:00
|
|
|
//: lastly, ensure scenarios are consistent by always starting them at the
|
|
|
|
//: same type number.
|
2015-07-04 16:40:50 +00:00
|
|
|
Next_type_ordinal = 1000;
|
2015-05-14 17:30:01 +00:00
|
|
|
:(before "End Test Run Initialization")
|
2015-07-04 16:40:50 +00:00
|
|
|
assert(Next_type_ordinal < 1000);
|
2015-05-14 17:30:01 +00:00
|
|
|
:(before "End Setup")
|
2015-07-04 16:40:50 +00:00
|
|
|
Next_type_ordinal = 1000;
|
2015-05-14 17:30:01 +00:00
|
|
|
|
2015-05-19 01:40:58 +00:00
|
|
|
//:: Allow container definitions anywhere in the codebase, but warn if you
|
|
|
|
//:: can't find a definition.
|
|
|
|
|
|
|
|
:(scenarios run)
|
|
|
|
:(scenario run_warns_on_unknown_types)
|
|
|
|
% Hide_warnings = true;
|
|
|
|
#? % Trace_stream->dump_layer = "run";
|
|
|
|
recipe main [
|
|
|
|
# integer is not a type
|
|
|
|
1:integer <- copy 0:literal
|
|
|
|
]
|
|
|
|
+warn: unknown type: integer
|
|
|
|
|
|
|
|
:(scenario run_allows_type_definition_after_use)
|
|
|
|
% Hide_warnings = true;
|
|
|
|
recipe main [
|
|
|
|
1:bar <- copy 0:literal
|
|
|
|
]
|
|
|
|
|
|
|
|
container bar [
|
|
|
|
x:number
|
|
|
|
]
|
|
|
|
-warn: unknown type: bar
|
2015-06-28 00:53:18 +00:00
|
|
|
$warn: 0
|
2015-05-19 01:40:58 +00:00
|
|
|
|
|
|
|
:(after "int main")
|
|
|
|
Transform.push_back(check_invalid_types);
|
|
|
|
|
|
|
|
:(code)
|
2015-07-04 16:40:50 +00:00
|
|
|
void check_invalid_types(const recipe_ordinal r) {
|
2015-05-19 01:40:58 +00:00
|
|
|
for (long long int index = 0; index < SIZE(Recipe[r].steps); ++index) {
|
|
|
|
const instruction& inst = Recipe[r].steps.at(index);
|
|
|
|
for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
|
|
|
|
check_invalid_types(inst.ingredients.at(i));
|
|
|
|
}
|
|
|
|
for (long long int i = 0; i < SIZE(inst.products); ++i) {
|
|
|
|
check_invalid_types(inst.products.at(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void check_invalid_types(const reagent& r) {
|
|
|
|
for (long long int i = 0; i < SIZE(r.types); ++i) {
|
|
|
|
if (r.types.at(i) == 0) continue;
|
|
|
|
if (Type.find(r.types.at(i)) == Type.end())
|
|
|
|
raise << "unknown type: " << r.properties.at(0).second.at(i) << '\n';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
:(scenario container_unknown_field)
|
|
|
|
% Hide_warnings = true;
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
y:bar
|
|
|
|
]
|
|
|
|
+warn: unknown type for field y in foo
|
|
|
|
|
2015-05-28 18:28:15 +00:00
|
|
|
:(scenario read_container_with_bracket_in_comment)
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
# ']' in comment
|
|
|
|
y:number
|
|
|
|
]
|
|
|
|
+parse: reading container foo
|
|
|
|
+parse: element name: x
|
|
|
|
+parse: type: 1
|
|
|
|
+parse: element name: y
|
|
|
|
+parse: type: 1
|
|
|
|
|
2015-05-19 01:40:58 +00:00
|
|
|
:(before "End Load Sanity Checks")
|
|
|
|
check_container_field_types();
|
|
|
|
|
|
|
|
:(code)
|
|
|
|
void check_container_field_types() {
|
2015-07-04 16:40:50 +00:00
|
|
|
for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) {
|
2015-05-19 01:40:58 +00:00
|
|
|
const type_info& info = p->second;
|
|
|
|
//? cerr << "checking " << p->first << '\n'; //? 1
|
|
|
|
for (long long int i = 0; i < SIZE(info.elements); ++i) {
|
|
|
|
for (long long int j = 0; j < SIZE(info.elements.at(i)); ++j) {
|
|
|
|
if (info.elements.at(i).at(j) == 0) continue;
|
|
|
|
if (Type.find(info.elements.at(i).at(j)) == Type.end())
|
|
|
|
raise << "unknown type for field " << info.element_names.at(i) << " in " << info.name << '\n';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-23 19:05:18 +00:00
|
|
|
//:: Construct types out of their constituent fields. Doesn't currently do
|
|
|
|
//:: type-checking but *does* match sizes.
|
|
|
|
:(before "End Primitive Recipe Declarations")
|
|
|
|
MERGE,
|
|
|
|
:(before "End Primitive Recipe Numbers")
|
2015-07-04 16:40:50 +00:00
|
|
|
Recipe_ordinal["merge"] = MERGE;
|
2015-06-23 19:05:18 +00:00
|
|
|
:(before "End Primitive Recipe Implementations")
|
|
|
|
case MERGE: {
|
|
|
|
products.resize(1);
|
|
|
|
for (long long int i = 0; i < SIZE(ingredients); ++i)
|
|
|
|
for (long long int j = 0; j < SIZE(ingredients.at(i)); ++j)
|
|
|
|
products.at(0).push_back(ingredients.at(i).at(j));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
:(scenario merge)
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
y:number
|
|
|
|
]
|
|
|
|
|
|
|
|
recipe main [
|
|
|
|
1:foo <- merge 3:literal, 4:literal
|
|
|
|
]
|
|
|
|
+mem: storing 3 in location 1
|
|
|
|
+mem: storing 4 in location 2
|
|
|
|
|
2015-05-14 17:30:01 +00:00
|
|
|
//:: helpers
|
|
|
|
|
|
|
|
:(code)
|
|
|
|
void skip_bracket(istream& in, string message) {
|
|
|
|
skip_whitespace_and_comments(in);
|
|
|
|
if (in.get() != '[')
|
|
|
|
raise << message << '\n';
|
|
|
|
}
|