about summary refs log blame commit diff stats
path: root/vimrc.vim
blob: 2e11238ba6bd652a217337f576cf580e6232d5e7 (plain) (tree)
="w"> array = Type_number["array"] = Next_type_number++; Type[array].name = "array"; // End Mu Types Initialization } :(before "End One-time Setup") setup_types(); :(before "End Types") // You can construct arbitrary new types. New types are either 'containers' // with multiple 'elements' of other types, or 'exclusive containers' containing // one of multiple 'variants'. (These are similar to C structs and unions, // respectively, though exclusive containers implicitly include a tag element // recording which variant they should be interpreted as.) // // For example, storing bank balance and name for an account might require a // container, but if bank accounts may be either for individuals or groups, // with different properties for each, that may require an exclusive container // whose variants are individual-account and joint-account containers. enum kind_of_type { primitive, container, exclusive_container }; struct type_info { string name; kind_of_type kind; long long int size; // only if type is not primitive; primitives and addresses have size 1 (except arrays are dynamic) vector<vector<type_number> > elements; vector<string> element_names; // End type_info Fields type_info() :kind(primitive), size(0) {} }; enum primitive_recipes { IDLE = 0, COPY, // End Primitive Recipe Declarations MAX_PRIMITIVE_RECIPES, }; :(code) //: It's all very well to construct recipes out of other recipes, but we need //: to know how to do *something* out of the box. For the following //: recipes there are only codes, no entries in the book, because mu just knows //: what to do for them. void setup_recipes() { Recipe.clear(); Recipe_number.clear(); Recipe_number["idle"] = IDLE; // Primitive Recipe Numbers Recipe_number["copy"] = COPY; // End Primitive Recipe Numbers } //: We could just reset the recipe table after every test, but that gets slow //: all too quickly. Instead, initialize the common stuff just once at //: startup. Later layers will carefully undo each test's additions after //: itself. :(before "End One-time Setup") setup_recipes(); assert(MAX_PRIMITIVE_RECIPES < 100); // level 0 is primitives; until 99 Next_recipe_number = 100; // End Load Recipes :(before "End Test Run Initialization") assert(Next_recipe_number < 1000); // recipes being tested didn't overflow into test space :(before "End Setup") Next_recipe_number = 1000; // consistent new numbers for each test //:: Helpers :(code) instruction::instruction() :is_label(false), operation(IDLE) {} void instruction::clear() { is_label=false; label.clear(); operation=IDLE; ingredients.clear(); products.clear(); } // Reagents have the form <name>:<type>:<type>:.../<property>/<property>/... reagent::reagent(string s) :original_string(s), value(0), initialized(false) { istringstream in(s); in >> std::noskipws; // properties while (!in.eof()) { istringstream row(slurp_until(in, '/')); row >> std::noskipws; string name = slurp_until(row, ':'); vector<string> values; while (!row.eof()) values.push_back(slurp_until(row, ':')); properties.push_back(pair<string, vector<string> >(name, values)); } // structures for the first row of properties name = properties.at(0).first; for (long long int i = 0; i < SIZE(properties.at(0).second); ++i) { string type = properties.at(0).second.at(i); if (Type_number.find(type) == Type_number.end()) { //? cerr << type << " is " << Next_type_number << '\n'; //? 1 Type_number[type] = Next_type_number++; } types.push_back(Type_number[type]); } if (name == "_" && types.empty()) { types.push_back(0); properties.at(0).second.push_back("dummy"); } } reagent::reagent() :value(0), initialized(false) { // The first property is special, so ensure we always have it. // Other properties can be pushed back, but the first must always be // assigned to. properties.push_back(pair<string, vector<string> >("", vector<string>())); } string reagent::to_string() const { ostringstream out; out << "{name: \"" << name << "\""; if (!properties.empty()) { out << ", properties: ["; for (long long int i = 0; i < SIZE(properties); ++i) { out << "\"" << properties.at(i).first << "\": "; for (long long int j = 0; j < SIZE(properties.at(i).second); ++j) { if (j > 0) out << ':'; out << "\"" << properties.at(i).second.at(j) << "\""; } if (i < SIZE(properties)-1) out << ", "; else out << "]"; } } out << "}"; return out.str(); } string instruction::to_string() const { if (is_label) return label; ostringstream out; for (long long int i = 0; i < SIZE(products); ++i) { if (i > 0) out << ", "; out << products.at(i).original_string; } if (!products.empty()) out << " <- "; out << name << ' '; for (long long int i = 0; i < SIZE(ingredients); ++i) { if (i > 0) out << ", "; out << ingredients.at(i).original_string; } return out.str(); } string slurp_until(istream& in, char delim) { ostringstream out; char c; while (in >> c) { if (c == delim) { // drop the delim break; } out << c; } return out.str(); } void dump_memory() { for (map<long long int, double>::iterator p = Memory.begin(); p != Memory.end(); ++p) { cout << p->first << ": " << p->second << '\n'; } } :(before "End Includes") #include <map> using std::map; #include<utility> using std::pair;