From 44c1aeef226542d692f0002b5cca5a3c30935d18 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Sat, 10 Sep 2016 10:43:19 -0700 Subject: 3315 --- html/033exclusive_container.cc.html | 45 ++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 16 deletions(-) (limited to 'html/033exclusive_container.cc.html') diff --git a/html/033exclusive_container.cc.html b/html/033exclusive_container.cc.html index 9b31c886..5068a365 100644 --- a/html/033exclusive_container.cc.html +++ b/html/033exclusive_container.cc.html @@ -70,22 +70,27 @@ def main [ // Compute size_of Exclusive Container return get(Container_metadata, type).size; } -:(before "End compute_container_sizes Cases") +:(before "End compute_container_sizes Atom Cases") if (info.kind == EXCLUSIVE_CONTAINER) { - container_metadata metadata; + compute_exclusive_container_sizes(info, type, pending_metadata); +} + +:(code) +void compute_exclusive_container_sizes(const type_info& exclusive_container_info, const type_tree* full_type, set<type_tree>& pending_metadata) { // size of an exclusive container is the size of its largest variant - // (So like containers, it can't contain arrays.) - int size = 0; - for (int i = 0; i < SIZE(info.elements); ++i) { - reagent/*copy*/ element = info.elements.at(i); - // Compute Exclusive Container Size(element) + // (So, like containers, it can only contain arrays if they're static and + // include their length in the type.) + container_metadata metadata; + for (int i = 0; i < SIZE(exclusive_container_info.elements); ++i) { + reagent/*copy*/ element = exclusive_container_info.elements.at(i); + // Compute Exclusive Container Size(element, full_type) compute_container_sizes(element.type, pending_metadata); int variant_size = size_of(element); - if (variant_size > size) size = variant_size; + if (variant_size > metadata.size) metadata.size = variant_size; } // ...+1 for its tag. - metadata.size = size+1; - Container_metadata.push_back(pair<type_tree*, container_metadata>(new type_tree(*type), metadata)); + ++metadata.size; + Container_metadata.push_back(pair<type_tree*, container_metadata>(new type_tree(*full_type), metadata)); } //:: To access variants of an exclusive container, use 'maybe-convert'. @@ -135,7 +140,12 @@ put(Recipe_ordinal,} reagent/*copy*/ base = inst.ingredients.at(0); // Update MAYBE_CONVERT base in Check - if (!base.type || !base.type->value || get(Type, base.type->value).kind != EXCLUSIVE_CONTAINER) { + if (!base.type) { + raise << maybe(caller.name) << "first ingredient of 'maybe-convert' should be an exclusive-container, but got '" << base.original_string << "'\n" << end(); + break; + } + const type_tree* root_type = base.type->atom ? base.type : base.type->left; + if (!root_type->atom || root_type->value == 0 || !contains_key(Type, root_type->value) || get(Type, root_type->value).kind != EXCLUSIVE_CONTAINER) { raise << maybe(caller.name) << "first ingredient of 'maybe-convert' should be an exclusive-container, but got '" << base.original_string << "'\n" << end(); break; } @@ -152,7 +162,7 @@ put(Recipe_ordinal,// Update MAYBE_CONVERT product in Check reagent& offset = inst.ingredients.at(1); populate_value(offset); - if (offset.value >= SIZE(get(Type, base.type->value).elements)) { + if (offset.value >= SIZE(get(Type, root_type->value).elements)) { raise << maybe(caller.name) << "invalid tag " << offset.value << " in '" << inst.original_string << '\n' << end(); break; } @@ -211,9 +221,10 @@ put(Recipe_ordinal,const reagent variant_type(const type_tree* type, int tag) { assert(tag >= 0); - assert(contains_key(Type, type->value)); - assert(!get(Type, type->value).name.empty()); - const type_info& info = get(Type, type->value); + const type_tree* root_type = type->atom ? type : type->left; + assert(contains_key(Type, root_type->value)); + assert(!get(Type, root_type->value).name.empty()); + const type_info& info = get(Type, root_type->value); assert(info.kind == EXCLUSIVE_CONTAINER); reagent/*copy*/ element = info.elements.at(tag); // End variant_type Special-cases @@ -465,7 +476,9 @@ $error: 0 && current_instruction().products.at(0).type) { reagent/*copy*/ x = current_instruction().products.at(0); // Update size_mismatch Check for MERGE(x) - if (get(Type, x.type->value).kind == EXCLUSIVE_CONTAINER) + const type_tree* root_type = x.type->atom ? x.type : x.type->left; + assert(root_type->atom); + if (get(Type, root_type->value).kind == EXCLUSIVE_CONTAINER) return size_of(x) < SIZE(data); } -- cgit 1.4.1-2-gfad0