From 6e1eeeebfb453fa7c871869c19375ce60fbd7413 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Sat, 27 Jul 2019 16:01:55 -0700 Subject: 5485 - promote SubX to top-level --- html/019type_abbreviations.cc.html | 262 ------------------------------------- 1 file changed, 262 deletions(-) delete mode 100644 html/019type_abbreviations.cc.html (limited to 'html/019type_abbreviations.cc.html') diff --git a/html/019type_abbreviations.cc.html b/html/019type_abbreviations.cc.html deleted file mode 100644 index 58200f13..00000000 --- a/html/019type_abbreviations.cc.html +++ /dev/null @@ -1,262 +0,0 @@ - - - - -Mu - 019type_abbreviations.cc - - - - - - - - - - -https://github.com/akkartik/mu/blob/master/019type_abbreviations.cc -
-  1 //: For convenience, allow Mu types to be abbreviated.
-  2 
-  3 :(scenarios transform)
-  4 :(scenario type_abbreviations)
-  5 type foo = number
-  6 def main [
-  7   a:foo <- copy 34
-  8 ]
-  9 +transform: product type after expanding abbreviations: "number"
- 10 
- 11 :(before "End Globals")
- 12 map<string, type_tree*> Type_abbreviations, Type_abbreviations_snapshot;
- 13 
- 14 //:: Defining type abbreviations.
- 15 
- 16 :(before "End Command Handlers")
- 17 else if (command == "type") {
- 18   load_type_abbreviations(in);
- 19 }
- 20 
- 21 :(code)
- 22 void load_type_abbreviations(istream& in) {
- 23   string new_type_name = next_word(in);
- 24   assert(has_data(in) || !new_type_name.empty());
- 25   if (!has_data(in) || new_type_name.empty()) {
- 26     raise << "incomplete 'type' statement; must be of the form 'type <new type name> = <type expression>'\n" << end();
- 27     return;
- 28   }
- 29   string arrow = next_word(in);
- 30   assert(has_data(in) || !arrow.empty());
- 31   if (arrow.empty()) {
- 32     raise << "incomplete 'type' statement 'type " << new_type_name << "'\n" << end();
- 33     return;
- 34   }
- 35   if (arrow != "=") {
- 36     raise << "'type' statements must be of the form 'type <new type name> = <type expression>' but got 'type " << new_type_name << ' ' << arrow << "'\n" << end();
- 37     return;
- 38   }
- 39   if (!has_data(in)) {
- 40     raise << "incomplete 'type' statement 'type " << new_type_name << " ='\n" << end();
- 41     return;
- 42   }
- 43   string old = next_word(in);
- 44   if (old.empty()) {
- 45     raise << "incomplete 'type' statement 'type " << new_type_name << " ='\n" << end();
- 46     raise << "'type' statements must be of the form 'type <new type name> = <type expression>' but got 'type " << new_type_name << ' ' << arrow << "'\n" << end();
- 47     return;
- 48   }
- 49   if (contains_key(Type_abbreviations, new_type_name)) {
- 50     raise << "'type' conflict: '" << new_type_name << "' defined as both '" << names_to_string_without_quotes(get(Type_abbreviations, new_type_name)) << "' and '" << old << "'\n" << end();
- 51     return;
- 52   }
- 53   trace(9990, "type") << "alias " << new_type_name << " = " << old << end();
- 54   type_tree* old_type = new_type_tree(old);
- 55   put(Type_abbreviations, new_type_name, old_type);
- 56 }
- 57 
- 58 type_tree* new_type_tree(const string& x) {
- 59   string_tree* type_names = starts_with(x, "(") ? parse_string_tree(x) : parse_string_list(x);
- 60   type_tree* result = new_type_tree(type_names);
- 61   delete type_names;
- 62   expand_type_abbreviations(result);
- 63   return result;
- 64 }
- 65 
- 66 string_tree* parse_string_list(const string& s) {
- 67   istringstream in(s);
- 68   in >> std::noskipws;
- 69   return parse_property_list(in);
- 70 }
- 71 
- 72 :(scenario type_error1)
- 73 % Hide_errors = true;
- 74 type foo
- 75 +error: incomplete 'type' statement 'type foo'
- 76 
- 77 :(scenario type_error2)
- 78 % Hide_errors = true;
- 79 type foo =
- 80 +error: incomplete 'type' statement 'type foo ='
- 81 
- 82 :(scenario type_error3)
- 83 % Hide_errors = true;
- 84 type foo bar baz
- 85 +error: 'type' statements must be of the form 'type <new type name> = <type expression>' but got 'type foo bar'
- 86 
- 87 :(scenario type_conflict_error)
- 88 % Hide_errors = true;
- 89 type foo = bar
- 90 type foo = baz
- 91 +error: 'type' conflict: 'foo' defined as both 'bar' and 'baz'
- 92 
- 93 :(scenario type_abbreviation_for_compound)
- 94 type foo = address:number
- 95 def main [
- 96   1:foo <- copy null
- 97 ]
- 98 +transform: product type after expanding abbreviations: ("address" "number")
- 99 
-100 //: cleaning up type abbreviations between tests and before exiting
-101 
-102 :(before "End save_snapshots")
-103 Type_abbreviations_snapshot = Type_abbreviations;
-104 :(before "End restore_snapshots")
-105 restore_type_abbreviations();
-106 :(before "End One-time Setup")
-107 atexit(clear_type_abbreviations);
-108 :(code)
-109 void restore_type_abbreviations() {
-110   for (map<string, type_tree*>::iterator p = Type_abbreviations.begin();  p != Type_abbreviations.end();  ++p) {
-111     if (!contains_key(Type_abbreviations_snapshot, p->first))
-112       delete p->second;
-113   }
-114   Type_abbreviations.clear();
-115   Type_abbreviations = Type_abbreviations_snapshot;
-116 }
-117 void clear_type_abbreviations() {
-118   for (map<string, type_tree*>::iterator p = Type_abbreviations.begin();  p != Type_abbreviations.end();  ++p)
-119     delete p->second;
-120   Type_abbreviations.clear();
-121 }
-122 
-123 //:: A few default abbreviations.
-124 
-125 :(before "End Mu Types Initialization")
-126 put(Type_abbreviations, "&", new_type_tree("address"));
-127 put(Type_abbreviations, "@", new_type_tree("array"));
-128 put(Type_abbreviations, "num", new_type_tree("number"));
-129 put(Type_abbreviations, "bool", new_type_tree("boolean"));
-130 put(Type_abbreviations, "char", new_type_tree("character"));
-131 
-132 :(scenario use_type_abbreviations_when_declaring_type_abbreviations)
-133 type foo = &:num
-134 def main [
-135   1:foo <- copy null
-136 ]
-137 +transform: product type after expanding abbreviations: ("address" "number")
-138 
-139 //:: Expand type aliases before running.
-140 //: We'll do this in a transform so that we don't need to define abbreviations
-141 //: before we use them.
-142 
-143 :(scenario abbreviations_for_address_and_array)
-144 def main [
-145   f 1:&:num  # abbreviation for 'address:number'
-146   f 2:@:num  # abbreviation for 'array:number'
-147   f 3:&:@:num  # combining '&' and '@'
-148   f 4:&:&:@:&:@:num  # ..any number of times
-149   f {5: (array (& num) 3)}  # support for dilated reagents and more complex parse trees
-150 ]
-151 def f [
-152 ]
-153 +transform: --- expand type abbreviations in recipe 'main'
-154 +transform: ingredient type after expanding abbreviations: ("address" "number")
-155 +transform: ingredient type after expanding abbreviations: ("array" "number")
-156 +transform: ingredient type after expanding abbreviations: ("address" "array" "number")
-157 +transform: ingredient type after expanding abbreviations: ("address" "address" "array" "address" "array" "number")
-158 +transform: ingredient type after expanding abbreviations: ("array" ("address" "number") "3")
-159 
-160 :(before "Transform.push_back(update_instruction_operations)")
-161 Transform.push_back(expand_type_abbreviations);  // idempotent
-162 // Begin Type Modifying Transforms
-163 // End Type Modifying Transforms
-164 
-165 :(code)
-166 void expand_type_abbreviations(const recipe_ordinal r) {
-167   expand_type_abbreviations(get(Recipe, r));
-168 }
-169 
-170 void expand_type_abbreviations(const recipe& caller) {
-171   trace(9991, "transform") << "--- expand type abbreviations in recipe '" << caller.name << "'" << end();
-172   for (int i = 0;  i < SIZE(caller.steps);  ++i) {
-173     const instruction& inst = caller.steps.at(i);
-174     trace(9991, "transform") << "instruction '" << to_original_string(inst) << end();
-175     for (long int i = 0;  i < SIZE(inst.ingredients);  ++i) {
-176       expand_type_abbreviations(inst.ingredients.at(i).type);
-177       trace(9992, "transform") << "ingredient type after expanding abbreviations: " << names_to_string(inst.ingredients.at(i).type) << end();
-178     }
-179     for (long int i = 0;  i < SIZE(inst.products);  ++i) {
-180       expand_type_abbreviations(inst.products.at(i).type);
-181       trace(9992, "transform") << "product type after expanding abbreviations: " << names_to_string(inst.products.at(i).type) << end();
-182     }
-183   }
-184   // End Expand Type Abbreviations(caller)
-185 }
-186 
-187 void expand_type_abbreviations(type_tree* type) {
-188   if (!type) return;
-189   if (!type->atom) {
-190     expand_type_abbreviations(type->left);
-191     expand_type_abbreviations(type->right);
-192     return;
-193   }
-194   if (contains_key(Type_abbreviations, type->name))
-195     *type = type_tree(*get(Type_abbreviations, type->name));
-196 }
-
- - - -- cgit 1.4.1-2-gfad0