From 6d007fda037331e7761d2a9ed3a2e435131daf7e Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Fri, 11 Nov 2016 15:54:19 -0800 Subject: 3667 --- html/056shape_shifting_recipe.cc.html | 118 +++++++++++++++++++++------------- 1 file changed, 73 insertions(+), 45 deletions(-) (limited to 'html/056shape_shifting_recipe.cc.html') diff --git a/html/056shape_shifting_recipe.cc.html b/html/056shape_shifting_recipe.cc.html index 32aef874..6bb9c81e 100644 --- a/html/056shape_shifting_recipe.cc.html +++ b/html/056shape_shifting_recipe.cc.html @@ -157,7 +157,7 @@ vector<recipe_ordinal> strictly_matching_shape_shifting_variantsfor (int i = 0; i < min(SIZE(inst.products), SIZE(variant.ingredients)); ++i) { if (is_dummy(inst.products.at(i))) continue; if (!concrete_type_names_strictly_match(variant.products.at(i), inst.products.at(i))) { - trace(9993, "transform") << "strict match failed: product " << i << end(); + trace(9993, "transform") << "concrete-type match failed: product " << i << end(); return false; } } @@ -212,32 +212,11 @@ recipe_ordinal best_shape_shifting_variant(return concrete_type_names_strictly_match(to.type, from.type, from); } -int number_of_concrete_type_names(recipe_ordinal r) { - const recipe& caller = get(Recipe, r); - int result = 0; - for (int i = 0; i < SIZE(caller.ingredients); ++i) - result += number_of_concrete_type_names(caller.ingredients.at(i)); - for (int i = 0; i < SIZE(caller.products); ++i) - result += number_of_concrete_type_names(caller.products.at(i)); - return result; -} - -int number_of_concrete_type_names(const reagent& r) { - return number_of_concrete_type_names(r.type); -} - -int number_of_concrete_type_names(const type_tree* type) { - if (!type) return 0; - if (type->atom) - return is_type_ingredient_name(type->name) ? 0 : 1; - return number_of_concrete_type_names(type->left) - + number_of_concrete_type_names(type->right); -} - bool concrete_type_names_strictly_match(const type_tree* to, const type_tree* from, const reagent& rhs_reagent) { if (!to) return !from; if (!from) return !to; if (to->atom && is_type_ingredient_name(to->name)) return true; // type ingredient matches anything + if (!to->atom && to->right == NULL && to->left != NULL && to->left->atom && is_type_ingredient_name(to->left->name)) return true; if (from->atom && is_mu_address(to)) return from->name == "literal" && rhs_reagent.name == "0"; if (!from->atom && !to->atom) @@ -262,6 +241,28 @@ recipe_ordinal best_shape_shifting_variant(return contains_type_ingredient_name(type->left) || contains_type_ingredient_name(type->right); } +int number_of_concrete_type_names(recipe_ordinal r) { + const recipe& caller = get(Recipe, r); + int result = 0; + for (int i = 0; i < SIZE(caller.ingredients); ++i) + result += number_of_concrete_type_names(caller.ingredients.at(i)); + for (int i = 0; i < SIZE(caller.products); ++i) + result += number_of_concrete_type_names(caller.products.at(i)); + return result; +} + +int number_of_concrete_type_names(const reagent& r) { + return number_of_concrete_type_names(r.type); +} + +int number_of_concrete_type_names(const type_tree* type) { + if (!type) return 0; + if (type->atom) + return is_type_ingredient_name(type->name) ? 0 : 1; + return number_of_concrete_type_names(type->left) + + number_of_concrete_type_names(type->right); +} + recipe_ordinal new_variant(recipe_ordinal exemplar, const instruction& inst, const recipe& caller_recipe) { string new_name = next_unused_recipe_name(inst.name); assert(!contains_key(Recipe_ordinal, new_name)); @@ -367,36 +368,42 @@ recipe_ordinal new_variant(recipe_ordinal exempla raise << " (called from '" << to_original_string(call_instruction) << "')\n" << end(); return; } - if (is_type_ingredient_name(exemplar_type->name)) { - const type_tree* curr_refinement_type = NULL; // temporary heap allocation; must always be deleted before it goes out of scope - if (exemplar_type->atom) - curr_refinement_type = new type_tree(*refinement_type); - else { - assert(!refinement_type->atom); - curr_refinement_type = new type_tree(*refinement_type->left); - } - if (!contains_key(mappings, exemplar_type->name)) { - trace(9993, "transform") << "adding mapping from " << exemplar_type->name << " to " << to_string(curr_refinement_type) << end(); - put(mappings, exemplar_type->name, new type_tree(*curr_refinement_type)); - } - else { - if (!deeply_equal_type_names(get(mappings, exemplar_type->name), curr_refinement_type)) { - raise << maybe(caller_recipe.name) << "no call found for '" << to_original_string(call_instruction) << "'\n" << end(); - *error = true; - delete curr_refinement_type; - return; + if (!exemplar_type->atom && exemplar_type->right == NULL && !refinement_type->atom && refinement_type->right != NULL) { + exemplar_type = exemplar_type->left; + assert_for_now(exemplar_type->atom); + } + if (exemplar_type->atom) { + if (is_type_ingredient_name(exemplar_type->name)) { + const type_tree* curr_refinement_type = NULL; // temporary heap allocation; must always be deleted before it goes out of scope + if (exemplar_type->atom) + curr_refinement_type = new type_tree(*refinement_type); + else { + assert(!refinement_type->atom); + curr_refinement_type = new type_tree(*refinement_type->left); } - if (get(mappings, exemplar_type->name)->name == "literal") { - delete get(mappings, exemplar_type->name); + if (!contains_key(mappings, exemplar_type->name)) { + trace(9993, "transform") << "adding mapping from " << exemplar_type->name << " to " << to_string(curr_refinement_type) << end(); put(mappings, exemplar_type->name, new type_tree(*curr_refinement_type)); } + else { + if (!deeply_equal_type_names(get(mappings, exemplar_type->name), curr_refinement_type)) { + raise << maybe(caller_recipe.name) << "no call found for '" << to_original_string(call_instruction) << "'\n" << end(); + *error = true; + delete curr_refinement_type; + return; + } + if (get(mappings, exemplar_type->name)->name == "literal") { + delete get(mappings, exemplar_type->name); + put(mappings, exemplar_type->name, new type_tree(*curr_refinement_type)); + } + } + delete curr_refinement_type; } - delete curr_refinement_type; } else { accumulate_type_ingredients(exemplar_type->left, refinement_type->left, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error); + accumulate_type_ingredients(exemplar_type->right, refinement_type->right, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error); } - accumulate_type_ingredients(exemplar_type->right, refinement_type->right, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error); } void replace_type_ingredients(recipe& new_recipe, const map<string, const type_tree*>& mappings) { @@ -439,6 +446,10 @@ recipe_ordinal new_variant(recipe_ordinal exempla void replace_type_ingredients(type_tree* type, const map<string, const type_tree*>& mappings) { if (!type) return; if (!type->atom) { + if (type->right == NULL && type->left != NULL && type->left->atom && contains_key(mappings, type->left->name) && !get(mappings, type->left->name)->atom && get(mappings, type->left->name)->right != NULL) { + *type = *get(mappings, type->left->name); + return; + } replace_type_ingredients(type->left, mappings); replace_type_ingredients(type->right, mappings); return; @@ -693,6 +704,7 @@ $error: 0 CHECK(!element.type->right); } +//: specializing a type ingredient with a compound type :(scenario shape_shifting_recipe_supports_compound_types) def main [ 1:&:point <- new point:type @@ -707,6 +719,22 @@ $error: 0 ] +mem: storing 34 in location 5 +//: specializing a type ingredient with a compound type -- while *inside* another compound type +:(scenario shape_shifting_recipe_supports_compound_types_2) +container foo:_t [ + value:_t +] +def bar x:&:foo:_t -> result:_t [ + local-scope + load-ingredients + result <- get *x, value:offset +] +def main [ + 1:&:foo:&:point <- new {(foo address point): type} + 2:&:point <- bar 1:&:foo:&:point +] +# no errors; call to 'bar' successfully specialized + :(scenario shape_shifting_recipe_error) % Hide_errors = true; def main [ -- cgit 1.4.1-2-gfad0