From a66c9ae68122e04637d65c7f3aedcd96012c8cb6 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Mon, 4 May 2015 11:02:56 -0700 Subject: 1249 - new type: index_t It will always be identical to size_t, just more readable, like recipe_number, etc. The various unsigned types are sizes, indices (which often compare with sizes for bounds checking), numbers which are canonical elements of a specific space (like recipes or mu types), and ids which I haven't introduced yet. --- cpp/001help.cc | 3 ++- cpp/002test.cc | 4 ++-- cpp/003trace.cc | 12 ++++++------ cpp/010vm.cc | 14 +++++++------- cpp/011load.cc | 2 +- cpp/012transform.cc | 10 +++++----- cpp/014types.cc | 2 +- cpp/020run.cc | 8 ++++---- cpp/027debug.cc | 2 +- cpp/030container.cc | 10 +++++----- cpp/031address.cc | 4 ++-- cpp/034exclusive_container.cc | 6 +++--- cpp/035call.cc | 6 +++--- cpp/036call_ingredient.cc | 4 ++-- cpp/037call_reply.cc | 6 +++--- cpp/038scheduler.cc | 8 ++++---- cpp/039wait.cc | 4 ++-- cpp/040brace.cc | 16 ++++++++-------- cpp/041name.cc | 24 ++++++++++++------------ cpp/042new.cc | 8 ++++---- cpp/043space.cc | 2 +- cpp/044space_surround.cc | 2 +- cpp/045closure_name.cc | 18 +++++++++--------- cpp/049scenario_helpers.cc | 16 ++++++++-------- cpp/050scenario.cc | 2 +- cpp/070display.cc | 4 ++-- cpp/072scenario_screen.cc | 12 ++++++------ 27 files changed, 105 insertions(+), 104 deletions(-) (limited to 'cpp') diff --git a/cpp/001help.cc b/cpp/001help.cc index 2c48d297..8f2c65d4 100644 --- a/cpp/001help.cc +++ b/cpp/001help.cc @@ -41,4 +41,5 @@ using std::cerr; #include #include using std::string; -const size_t NOT_FOUND = string::npos; +typedef size_t index_t; +const index_t NOT_FOUND = string::npos; diff --git a/cpp/002test.cc b/cpp/002test.cc index 3daa1aed..af56ae97 100644 --- a/cpp/002test.cc +++ b/cpp/002test.cc @@ -53,7 +53,7 @@ if (Run_tests) { // End Test Run Initialization time_t t; time(&t); cerr << "C tests: " << ctime(&t); - for (size_t i=0; i < sizeof(Tests)/sizeof(Tests[0]); ++i) { + for (index_t i=0; i < sizeof(Tests)/sizeof(Tests[0]); ++i) { run_test(i); } // End Tests @@ -66,7 +66,7 @@ if (Run_tests) { } :(code) -void run_test(size_t i) { +void run_test(index_t i) { if (i >= sizeof(Tests)/sizeof(Tests[0])) { cerr << "no test " << i << '\n'; return; diff --git a/cpp/003trace.cc b/cpp/003trace.cc index 5a275154..77d51fc4 100644 --- a/cpp/003trace.cc +++ b/cpp/003trace.cc @@ -214,7 +214,7 @@ void trace_all(const string& label, const list& in) { bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) { // missing layer == anywhere, frame, hierarchical layers vector expected_lines = split(expected, ""); - size_t curr_expected_line = 0; + index_t curr_expected_line = 0; while (curr_expected_line < expected_lines.size() && expected_lines[curr_expected_line].empty()) ++curr_expected_line; if (curr_expected_line == expected_lines.size()) return true; @@ -252,7 +252,7 @@ void parse_layer_frame_contents(const string& orig, string* layer, string* frame } void parse_contents(const string& s, const string& delim, string* prefix, string* contents) { - string::size_type pos = s.find(delim); + index_t pos = s.find(delim); if (pos == NOT_FOUND) { *prefix = ""; *contents = s; @@ -264,7 +264,7 @@ void parse_contents(const string& s, const string& delim, string* prefix, string } void parse_layer_and_frame(const string& orig, string* layer, string* frame) { - size_t last_slash = orig.rfind('/'); + index_t last_slash = orig.rfind('/'); if (last_slash == NOT_FOUND || orig.find_last_not_of("0123456789") != last_slash) { *layer = orig; @@ -280,7 +280,7 @@ void parse_layer_and_frame(const string& orig, string* layer, string* frame) { bool check_trace_contents(string FUNCTION, string FILE, int LINE, string layer, string expected) { // empty layer == everything, multiple layers, hierarchical layers vector expected_lines = split(expected, ""); - size_t curr_expected_line = 0; + index_t curr_expected_line = 0; while (curr_expected_line < expected_lines.size() && expected_lines[curr_expected_line].empty()) ++curr_expected_line; if (curr_expected_line == expected_lines.size()) return true; @@ -379,7 +379,7 @@ struct lease_trace_frame { bool check_trace_contents(string FUNCTION, string FILE, int LINE, string layer, int frame, string expected) { // multiple layers, hierarchical layers vector expected_lines = split(expected, ""); // hack: doesn't handle newlines in embedded in lines - size_t curr_expected_line = 0; + index_t curr_expected_line = 0; while (curr_expected_line < expected_lines.size() && expected_lines[curr_expected_line].empty()) ++curr_expected_line; if (curr_expected_line == expected_lines.size()) return true; @@ -411,7 +411,7 @@ bool check_trace_contents(string FUNCTION, string FILE, int LINE, string layer, vector split(string s, string delim) { vector result; - string::size_type begin=0, end=s.find(delim); + index_t begin=0, end=s.find(delim); while (true) { if (end == NOT_FOUND) { result.push_back(string(s, begin, NOT_FOUND)); diff --git a/cpp/010vm.cc b/cpp/010vm.cc index b24bcfad..2d1ce2ba 100644 --- a/cpp/010vm.cc +++ b/cpp/010vm.cc @@ -57,7 +57,7 @@ struct property { :(before "End Globals") // Locations refer to a common 'memory'. Each location can store a number. -map Memory; +map Memory; :(before "End Setup") Memory.clear(); @@ -182,7 +182,7 @@ reagent::reagent(string s) :value(0), initialized(false) { } // structures for the first row of properties name = properties[0].first; - for (size_t i = 0; i < properties[0].second.size(); ++i) { + for (index_t i = 0; i < properties[0].second.size(); ++i) { types.push_back(Type_number[properties[0].second[i]]); } if (name == "_" && types.empty()) { @@ -199,15 +199,15 @@ reagent::reagent() :value(0), initialized(false) { string reagent::to_string() const { ostringstream out; out << "{name: \"" << name << "\", value: " << value << ", type: "; - for (size_t i = 0; i < types.size(); ++i) { + for (index_t i = 0; i < types.size(); ++i) { out << types[i]; if (i < types.size()-1) out << "-"; } if (!properties.empty()) { out << ", properties: ["; - for (size_t i = 0; i < properties.size(); ++i) { + for (index_t i = 0; i < properties.size(); ++i) { out << "\"" << properties[i].first << "\": "; - for (size_t j = 0; j < properties[i].second.size(); ++j) { + for (index_t j = 0; j < properties[i].second.size(); ++j) { out << "\"" << properties[i].second[j] << "\""; if (j < properties[i].second.size()-1) out << ":"; } @@ -222,13 +222,13 @@ string reagent::to_string() const { string instruction::to_string() const { if (is_label) return label; ostringstream out; - for (size_t i = 0; i < products.size(); ++i) { + for (index_t i = 0; i < products.size(); ++i) { if (i > 0) out << ", "; out << products[i].to_string(); } if (!products.empty()) out << " <- "; out << name << '/' << operation << ' '; - for (size_t i = 0; i < ingredients.size(); ++i) { + for (index_t i = 0; i < ingredients.size(); ++i) { if (i > 0) out << ", "; out << ingredients[i].to_string(); } diff --git a/cpp/011load.cc b/cpp/011load.cc index cee2c493..3f0f8e1e 100644 --- a/cpp/011load.cc +++ b/cpp/011load.cc @@ -213,7 +213,7 @@ void show_rest_of_stream(istream& in) { :(before "End Globals") vector recently_added_recipes; :(before "End Setup") -for (size_t i = 0; i < recently_added_recipes.size(); ++i) { +for (index_t i = 0; i < recently_added_recipes.size(); ++i) { //? cout << "AAA clearing " << Recipe[recently_added_recipes[i]].name << '\n'; //? 2 Recipe_number.erase(Recipe[recently_added_recipes[i]].name); Recipe.erase(recently_added_recipes[i]); diff --git a/cpp/012transform.cc b/cpp/012transform.cc index 888c7585..2c1e4610 100644 --- a/cpp/012transform.cc +++ b/cpp/012transform.cc @@ -4,7 +4,7 @@ //: deconstructed alternative to conventional compilers. :(before "End recipe Fields") -size_t transformed_until; +index_t transformed_until; recipe() :transformed_until(-1) {} :(before "End Types") @@ -16,7 +16,7 @@ vector Transform; :(code) void transform_all() { //? cout << "AAA transform_all\n"; //? 1 - for (size_t t = 0; t < Transform.size(); ++t) { + for (index_t t = 0; t < Transform.size(); ++t) { for (map::iterator p = Recipe.begin(); p != Recipe.end(); ++p) { recipe& r = p->second; if (r.steps.empty()) continue; @@ -33,12 +33,12 @@ void parse_int_reagents() { for (map::iterator p = Recipe.begin(); p != Recipe.end(); ++p) { recipe& r = p->second; if (r.steps.empty()) continue; - for (size_t index = 0; index < r.steps.size(); ++index) { + for (index_t index = 0; index < r.steps.size(); ++index) { instruction& inst = r.steps[index]; - for (size_t i = 0; i < inst.ingredients.size(); ++i) { + for (index_t i = 0; i < inst.ingredients.size(); ++i) { populate_value(inst.ingredients[i]); } - for (size_t i = 0; i < inst.products.size(); ++i) { + for (index_t i = 0; i < inst.products.size(); ++i) { populate_value(inst.products[i]); } } diff --git a/cpp/014types.cc b/cpp/014types.cc index ffbd8b63..4ff0f545 100644 --- a/cpp/014types.cc +++ b/cpp/014types.cc @@ -74,7 +74,7 @@ else if (command == "exclusive-container") { :(before "End Globals") vector recently_added_types; :(before "End Setup") -for (size_t i = 0; i < recently_added_types.size(); ++i) { +for (index_t i = 0; i < recently_added_types.size(); ++i) { //? cout << "erasing " << Type[recently_added_types[i]].name << '\n'; //? 1 Type_number.erase(Type[recently_added_types[i]].name); Type.erase(recently_added_types[i]); diff --git a/cpp/020run.cc b/cpp/020run.cc index 963fcd78..9fc1f624 100644 --- a/cpp/020run.cc +++ b/cpp/020run.cc @@ -32,7 +32,7 @@ recipe main [ //: Later layers will change this. struct routine { recipe_number running_recipe; - size_t running_step_index; + index_t running_step_index; routine(recipe_number r) :running_recipe(r), running_step_index(0) {} bool completed() const; }; @@ -77,7 +77,7 @@ void run_current_routine() //: We'll need to override these later as we change the definition of routine. //: Important that they return referrences into the routine. -inline size_t& current_step_index() { +inline index_t& current_step_index() { return Current_routine->running_step_index; } @@ -153,7 +153,7 @@ vector read_memory(reagent x) { } int base = x.value; size_t size = size_of(x); - for (size_t offset = 0; offset < size; ++offset) { + for (index_t offset = 0; offset < size; ++offset) { int val = Memory[base+offset]; trace("mem") << "location " << base+offset << " is " << val; result.push_back(val); @@ -166,7 +166,7 @@ void write_memory(reagent x, vector data) { int base = x.value; if (size_of(x) != data.size()) raise << "size mismatch in storing to " << x.to_string() << '\n'; - for (size_t offset = 0; offset < data.size(); ++offset) { + for (index_t offset = 0; offset < data.size(); ++offset) { trace("mem") << "storing " << data[offset] << " in location " << base+offset; Memory[base+offset] = data[offset]; } diff --git a/cpp/027debug.cc b/cpp/027debug.cc index d5de1072..167e896b 100644 --- a/cpp/027debug.cc +++ b/cpp/027debug.cc @@ -12,7 +12,7 @@ case _PRINT: { break; } vector result(read_memory(current_instruction().ingredients[0])); - for (size_t i = 0; i < result.size(); ++i) { + for (index_t i = 0; i < result.size(); ++i) { trace("run") << "$print: " << result[i]; if (i > 0) cout << " "; cout << result[i]; diff --git a/cpp/030container.cc b/cpp/030container.cc index 1741af1b..51d2fdde 100644 --- a/cpp/030container.cc +++ b/cpp/030container.cc @@ -53,7 +53,7 @@ type_info t = Type[types[0]]; if (t.kind == container) { // size of a container is the sum of the sizes of its elements size_t result = 0; - for (size_t i = 0; i < t.elements.size(); ++i) { + for (index_t i = 0; i < t.elements.size(); ++i) { result += size_of(t.elements[i]); } return result; @@ -88,9 +88,9 @@ case GET: { assert(Type[base_type].kind == container); trace("run") << "ingredient 1 is " << current_instruction().ingredients[1].name; assert(isa_literal(current_instruction().ingredients[1])); - size_t offset = current_instruction().ingredients[1].value; + index_t offset = current_instruction().ingredients[1].value; int src = base_address; - for (size_t i = 0; i < offset; ++i) { + for (index_t i = 0; i < offset; ++i) { src += size_of(Type[base_type].elements[i]); } trace("run") << "address to copy is " << src; @@ -155,9 +155,9 @@ case GET_ADDRESS: { assert(Type[base_type].kind == container); trace("run") << "ingredient 1 is " << current_instruction().ingredients[1].name; assert(isa_literal(current_instruction().ingredients[1])); - size_t offset = current_instruction().ingredients[1].value; + index_t offset = current_instruction().ingredients[1].value; int src = base_address; - for (size_t i = 0; i < offset; ++i) { + for (index_t i = 0; i < offset; ++i) { src += size_of(Type[base_type].elements[i]); } trace("run") << "address to copy is " << src; diff --git a/cpp/031address.cc b/cpp/031address.cc index fd9037b1..f84af8d7 100644 --- a/cpp/031address.cc +++ b/cpp/031address.cc @@ -115,14 +115,14 @@ base = canonize(base); :(code) bool has_property(reagent x, string name) { - for (size_t i = 0; i < x.properties.size(); ++i) { + for (index_t i = 0; i < x.properties.size(); ++i) { if (x.properties[i].first == name) return true; } return false; } vector property(const reagent& r, const string& name) { - for (size_t p = 0; p != r.properties.size(); ++p) { + for (index_t p = 0; p != r.properties.size(); ++p) { if (r.properties[p].first == name) return r.properties[p].second; } diff --git a/cpp/034exclusive_container.cc b/cpp/034exclusive_container.cc index 89a4f921..b0edebfa 100644 --- a/cpp/034exclusive_container.cc +++ b/cpp/034exclusive_container.cc @@ -45,7 +45,7 @@ if (t.kind == exclusive_container) { //? cout << "point: " << Type_number["point"] << " " << Type[Type_number["point"]].name << " " << Type[Type_number["point"]].size << '\n'; //? 1 //? cout << t.name << ' ' << t.size << ' ' << t.elements.size() << '\n'; //? 1 size_t result = 0; - for (size_t i = 0; i < t.size; ++i) { + for (index_t i = 0; i < t.size; ++i) { size_t tmp = size_of(t.elements[i]); //? cout << i << ": " << t.elements[i][0] << ' ' << tmp << ' ' << result << '\n'; //? 1 if (tmp > result) result = tmp; @@ -95,9 +95,9 @@ case MAYBE_CONVERT: { assert(Type[base_type].kind == exclusive_container); trace("run") << "ingredient 1 is " << current_instruction().ingredients[1].name; assert(isa_literal(current_instruction().ingredients[1])); - size_t tag = current_instruction().ingredients[1].value; + index_t tag = current_instruction().ingredients[1].value; vector result; - if (tag == static_cast(Memory[base_address])) { + if (tag == static_cast(Memory[base_address])) { result.push_back(base_address+1); } else { diff --git a/cpp/035call.cc b/cpp/035call.cc index 75c617a6..2cb40af8 100644 --- a/cpp/035call.cc +++ b/cpp/035call.cc @@ -33,7 +33,7 @@ recipe f [ // This requires maintaining a 'stack' of interrupted recipes or 'calls'. struct call { recipe_number running_recipe; - size_t running_step_index; + index_t running_step_index; // End call Fields call(recipe_number r) :running_recipe(r), running_step_index(0) {} }; @@ -55,8 +55,8 @@ routine::routine(recipe_number r) { //:: now update routine's helpers -:(replace{} "inline size_t& current_step_index()") -inline size_t& current_step_index() { +:(replace{} "inline index_t& current_step_index()") +inline index_t& current_step_index() { return Current_routine->calls.top().running_step_index; } :(replace{} "inline const string& current_recipe_name()") diff --git a/cpp/036call_ingredient.cc b/cpp/036call_ingredient.cc index d928f286..87abe5ef 100644 --- a/cpp/036call_ingredient.cc +++ b/cpp/036call_ingredient.cc @@ -24,7 +24,7 @@ recipe f [ :(before "End call Fields") vector > ingredient_atoms; -size_t next_ingredient_to_process; +index_t next_ingredient_to_process; :(replace{} "call(recipe_number r)") call(recipe_number r) :running_recipe(r), running_step_index(0), next_ingredient_to_process(0) {} @@ -105,7 +105,7 @@ INGREDIENT, Recipe_number["ingredient"] = INGREDIENT; :(before "End Primitive Recipe Implementations") case INGREDIENT: { - if (static_cast(current_instruction().ingredients[0].value) < Current_routine->calls.top().ingredient_atoms.size()) { + if (static_cast(current_instruction().ingredients[0].value) < Current_routine->calls.top().ingredient_atoms.size()) { Current_routine->calls.top().next_ingredient_to_process = current_instruction().ingredients[0].value; trace("run") << "product 0 is " << Current_routine->calls.top().ingredient_atoms[Current_routine->calls.top().next_ingredient_to_process][0]; diff --git a/cpp/037call_reply.cc b/cpp/037call_reply.cc index a0dfa2ea..39fb1606 100644 --- a/cpp/037call_reply.cc +++ b/cpp/037call_reply.cc @@ -22,7 +22,7 @@ Recipe_number["reply"] = REPLY; :(before "End Primitive Recipe Implementations") case REPLY: { vector > callee_results; - for (size_t i = 0; i < current_instruction().ingredients.size(); ++i) { + for (index_t i = 0; i < current_instruction().ingredients.size(); ++i) { callee_results.push_back(read_memory(current_instruction().ingredients[i])); } const instruction& reply_inst = current_instruction(); // save pointer into recipe before pop @@ -30,7 +30,7 @@ case REPLY: { assert(!Current_routine->calls.empty()); const instruction& caller_instruction = current_instruction(); assert(caller_instruction.products.size() <= callee_results.size()); - for (size_t i = 0; i < caller_instruction.products.size(); ++i) { + for (index_t i = 0; i < caller_instruction.products.size(); ++i) { trace("run") << "result " << i << " is " << to_string(callee_results[i]); // check that any reply ingredients with /same-as-ingredient connect up // the corresponding ingredient and product in the caller. @@ -86,7 +86,7 @@ string to_string(const vector& in) { return out.str(); } out << "["; - for (size_t i = 0; i < in.size(); ++i) { + for (index_t i = 0; i < in.size(); ++i) { if (i > 0) out << ", "; out << in[i]; } diff --git a/cpp/038scheduler.cc b/cpp/038scheduler.cc index 6e3f74b8..f750e4a3 100644 --- a/cpp/038scheduler.cc +++ b/cpp/038scheduler.cc @@ -37,7 +37,7 @@ state = RUNNING; :(before "End Globals") vector Routines; -size_t Current_routine_index = 0; +index_t Current_routine_index = 0; size_t Scheduling_interval = 500; :(before "End Setup") Scheduling_interval = 500; @@ -61,7 +61,7 @@ void run(recipe_number r) { :(code) bool all_routines_done() { - for (size_t i = 0; i < Routines.size(); ++i) { + for (index_t i = 0; i < Routines.size(); ++i) { //? cout << "routine " << i << ' ' << Routines[i]->state << '\n'; //? 1 if (Routines[i]->state == RUNNING) { return false; @@ -74,7 +74,7 @@ bool all_routines_done() { void skip_to_next_routine() { assert(!Routines.empty()); assert(Current_routine_index < Routines.size()); - for (size_t i = (Current_routine_index+1)%Routines.size(); i != Current_routine_index; i = (i+1)%Routines.size()) { + for (index_t i = (Current_routine_index+1)%Routines.size(); i != Current_routine_index; i = (i+1)%Routines.size()) { if (Routines[i]->state == RUNNING) { //? cout << "switching to " << i << '\n'; //? 1 Current_routine_index = i; @@ -86,7 +86,7 @@ void skip_to_next_routine() { } :(before "End Teardown") -for (size_t i = 0; i < Routines.size(); ++i) +for (index_t i = 0; i < Routines.size(); ++i) delete Routines[i]; Routines.clear(); diff --git a/cpp/039wait.cc b/cpp/039wait.cc index b273c737..b9208590 100644 --- a/cpp/039wait.cc +++ b/cpp/039wait.cc @@ -23,7 +23,7 @@ recipe f2 [ WAITING, :(before "End routine Fields") // only if state == WAITING -size_t waiting_on_location; +index_t waiting_on_location; int old_value_of_wating_location; :(before "End routine Constructor") waiting_on_location = old_value_of_wating_location = 0; @@ -47,7 +47,7 @@ case WAIT_FOR_LOCATION: { //: scheduler tweak to get routines out of that state :(before "End Scheduler State Transitions") -for (size_t i = 0; i < Routines.size(); ++i) { +for (index_t i = 0; i < Routines.size(); ++i) { if (Routines[i]->state != WAITING) continue; if (Memory[Routines[i]->waiting_on_location] != Routines[i]->old_value_of_wating_location) { trace("schedule") << "waking up routine\n"; diff --git a/cpp/040brace.cc b/cpp/040brace.cc index fa9efab5..0b3f6f1b 100644 --- a/cpp/040brace.cc +++ b/cpp/040brace.cc @@ -40,21 +40,21 @@ void transform_braces(const recipe_number r) { //? cout << "AAA transform_braces\n"; //? 1 //? exit(0); //? 1 const int OPEN = 0, CLOSE = 1; - list > braces; - for (size_t index = 0; index < Recipe[r].steps.size(); ++index) { + list > braces; + for (index_t index = 0; index < Recipe[r].steps.size(); ++index) { const instruction& inst = Recipe[r].steps[index]; if (inst.label == "{") { trace("brace") << r << ": push (open, " << index << ")"; - braces.push_back(pair(OPEN, index)); + braces.push_back(pair(OPEN, index)); } if (inst.label == "}") { trace("brace") << "push (close, " << index << ")"; - braces.push_back(pair(CLOSE, index)); + braces.push_back(pair(CLOSE, index)); } } - stack open_braces; + stack open_braces; trace("after-brace") << "recipe " << Recipe[r].name; - for (size_t index = 0; index < Recipe[r].steps.size(); ++index) { + for (index_t index = 0; index < Recipe[r].steps.size(); ++index) { instruction& inst = Recipe[r].steps[index]; //? cout << "AAA " << inst.name << ": " << inst.operation << '\n'; //? 1 if (inst.label == "{") open_braces.push(index); @@ -148,9 +148,9 @@ void transform_braces(const recipe_number r) { } } -size_t matching_brace(size_t index, const list >& braces) { +int matching_brace(index_t index, const list >& braces) { int stacksize = 0; - for (list >::const_iterator p = braces.begin(); p != braces.end(); ++p) { + for (list >::const_iterator p = braces.begin(); p != braces.end(); ++p) { if (p->second < index) continue; stacksize += (p->first ? 1 : -1); if (stacksize == 0) return p->second; diff --git a/cpp/041name.cc b/cpp/041name.cc index 23972393..5f37fb6b 100644 --- a/cpp/041name.cc +++ b/cpp/041name.cc @@ -21,26 +21,26 @@ recipe main [ Transform.push_back(transform_names); :(before "End Globals") -map > Name; +map > Name; :(after "Clear Other State For recently_added_recipes") -for (size_t i = 0; i < recently_added_recipes.size(); ++i) { +for (index_t i = 0; i < recently_added_recipes.size(); ++i) { Name.erase(recently_added_recipes[i]); } :(code) void transform_names(const recipe_number r) { - map& names = Name[r]; + map& names = Name[r]; // store the indices 'used' so far in the map - int& curr_idx = names[""]; + index_t& curr_idx = names[""]; ++curr_idx; // avoid using index 0, benign skip in some other cases //? cout << "Recipe " << r << ": " << Recipe[r].name << '\n'; //? 3 //? cout << Recipe[r].steps.size() << '\n'; //? 2 - for (size_t i = 0; i < Recipe[r].steps.size(); ++i) { + for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { //? cout << "instruction " << i << '\n'; //? 2 instruction& inst = Recipe[r].steps[i]; // Per-recipe Transforms // map names to addresses - for (size_t in = 0; in < inst.ingredients.size(); ++in) { + for (index_t in = 0; in < inst.ingredients.size(); ++in) { //? cout << "ingredients\n"; //? 2 if (is_raw(inst.ingredients[in])) continue; //? cout << "ingredient " << inst.ingredients[in].name << '\n'; //? 3 @@ -60,7 +60,7 @@ void transform_names(const recipe_number r) { //? cout << "lookup ingredient " << Recipe[r].name << "/" << i << ": " << inst.ingredients[in].to_string() << '\n'; //? 1 } } - for (size_t out = 0; out < inst.products.size(); ++out) { + for (index_t out = 0; out < inst.products.size(); ++out) { //? cout << "products\n"; //? 1 if (is_raw(inst.products[out])) continue; //? cout << "product " << out << '/' << inst.products.size() << " " << inst.products[out].name << '\n'; //? 4 @@ -82,16 +82,16 @@ void transform_names(const recipe_number r) { } } -bool already_transformed(const reagent& r, const map& names) { +bool already_transformed(const reagent& r, const map& names) { return names.find(r.name) != names.end(); } -size_t lookup_name(const reagent& r, const recipe_number default_recipe) { +index_t lookup_name(const reagent& r, const recipe_number default_recipe) { return Name[default_recipe][r.name]; } type_number skip_addresses(const vector& types) { - for (size_t i = 0; i < types.size(); ++i) { + for (index_t i = 0; i < types.size(); ++i) { if (types[i] != Type_number["address"]) return types[i]; } raise << "expected a container" << '\n' << die(); @@ -101,7 +101,7 @@ type_number skip_addresses(const vector& types) { int find_element_name(const type_number t, const string& name) { const type_info& container = Type[t]; //? cout << "looking for element " << name << " in type " << container.name << " with " << container.element_names.size() << " elements\n"; //? 1 - for (size_t i = 0; i < container.element_names.size(); ++i) { + for (index_t i = 0; i < container.element_names.size(); ++i) { if (container.element_names[i] == name) return i; } raise << "unknown element " << name << " in container " << t << '\n' << die(); @@ -109,7 +109,7 @@ int find_element_name(const type_number t, const string& name) { } bool is_raw(const reagent& r) { - for (size_t i = /*skip value+type*/1; i < r.properties.size(); ++i) { + for (index_t i = /*skip value+type*/1; i < r.properties.size(); ++i) { if (r.properties[i].first == "raw") return true; } return false; diff --git a/cpp/042new.cc b/cpp/042new.cc index e901b2a9..ea05a3ed 100644 --- a/cpp/042new.cc +++ b/cpp/042new.cc @@ -12,13 +12,13 @@ recipe main [ :(before "End Globals") size_t Reserved_for_tests = 1000; -size_t Memory_allocated_until = Reserved_for_tests; +index_t Memory_allocated_until = Reserved_for_tests; size_t Initial_memory_per_routine = 100000; :(before "End Setup") Memory_allocated_until = Reserved_for_tests; Initial_memory_per_routine = 100000; :(before "End routine Fields") -size_t alloc, alloc_max; +index_t alloc, alloc_max; :(before "End routine Constructor") alloc = Memory_allocated_until; Memory_allocated_until += Initial_memory_per_routine; @@ -78,7 +78,7 @@ case NEW: { Current_routine->alloc_max = Memory_allocated_until; trace("new") << "routine allocated memory from " << Current_routine->alloc << " to " << Current_routine->alloc_max; } - const size_t result = Current_routine->alloc; + const index_t result = Current_routine->alloc; trace("mem") << "new alloc: " << result; if (current_instruction().ingredients.size() > 1) { // initialize array @@ -149,7 +149,7 @@ if (current_instruction().ingredients[0].properties[0].second[0] == "literal-str // assume that all characters fit in a single location //? cout << "new string literal: " << current_instruction().ingredients[0].name << '\n'; //? 1 Memory[Current_routine->alloc++] = current_instruction().ingredients[0].name.size(); - for (size_t i = 0; i < current_instruction().ingredients[0].name.size(); ++i) { + for (index_t i = 0; i < current_instruction().ingredients[0].name.size(); ++i) { Memory[Current_routine->alloc++] = current_instruction().ingredients[0].name[i]; } // mu strings are not null-terminated in memory diff --git a/cpp/043space.cc b/cpp/043space.cc index e94cf023..82b9115a 100644 --- a/cpp/043space.cc +++ b/cpp/043space.cc @@ -26,7 +26,7 @@ recipe main [ +mem: storing 34 in location 8 :(before "End call Fields") -size_t default_space; +index_t default_space; :(replace "call(recipe_number r) :running_recipe(r)") call(recipe_number r) :running_recipe(r), running_step_index(0), next_ingredient_to_process(0), default_space(0) {} diff --git a/cpp/044space_surround.cc b/cpp/044space_surround.cc index c5a03176..bfc73eee 100644 --- a/cpp/044space_surround.cc +++ b/cpp/044space_surround.cc @@ -42,7 +42,7 @@ int space_base(const reagent& x, int space_index, int base) { } int space_index(const reagent& x) { - for (size_t i = 0; i < x.properties.size(); ++i) { + for (index_t i = 0; i < x.properties.size(); ++i) { if (x.properties[i].first == "space") return to_int(x.properties[i].second[0]); } diff --git a/cpp/045closure_name.cc b/cpp/045closure_name.cc index b13b4c21..3f90f308 100644 --- a/cpp/045closure_name.cc +++ b/cpp/045closure_name.cc @@ -42,10 +42,10 @@ map Surrounding_space; :(code) void collect_surrounding_spaces(const recipe_number r) { - for (size_t i = 0; i < Recipe[r].steps.size(); ++i) { + for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { const instruction& inst = Recipe[r].steps[i]; if (inst.is_label) continue; - for (size_t j = 0; j < inst.products.size(); ++j) { + for (index_t j = 0; j < inst.products.size(); ++j) { if (isa_literal(inst.products[j])) continue; if (inst.products[j].name != "0") continue; if (inst.products[j].types.size() != 3 @@ -74,8 +74,8 @@ void collect_surrounding_spaces(const recipe_number r) { //: Once surrounding spaces are available, transform_names uses them to handle //: /space properties. -:(replace{} "size_t lookup_name(const reagent& r, const recipe_number default_recipe)") -size_t lookup_name(const reagent& x, const recipe_number default_recipe) { +:(replace{} "index_t lookup_name(const reagent& r, const recipe_number default_recipe)") +index_t lookup_name(const reagent& x, const recipe_number default_recipe) { //? cout << "AAA " << default_recipe << " " << Recipe[default_recipe].name << '\n'; //? 2 //? cout << "AAA " << x.to_string() << '\n'; //? 1 if (!has_property(x, "space")) { @@ -94,11 +94,11 @@ size_t lookup_name(const reagent& x, const recipe_number default_recipe) { // If the recipe we need to lookup this name in doesn't have names done yet, // recursively call transform_names on it. -size_t lookup_name(const reagent& x, const recipe_number r, set& done, vector& path) { +index_t lookup_name(const reagent& x, const recipe_number r, set& done, vector& path) { if (!Name[r].empty()) return Name[r][x.name]; if (done.find(r) != done.end()) { raise << "can't compute address of " << x.to_string() << " because "; - for (size_t i = 1; i < path.size(); ++i) { + for (index_t i = 1; i < path.size(); ++i) { raise << path[i-1] << " requires computing names of " << path[i] << '\n'; } raise << path[path.size()-1] << " requires computing names of " << r << "..ad infinitum\n" << die(); @@ -111,7 +111,7 @@ size_t lookup_name(const reagent& x, const recipe_number r, set& return Name[r][x.name]; } -recipe_number lookup_surrounding_recipe(const recipe_number r, size_t n) { +recipe_number lookup_surrounding_recipe(const recipe_number r, index_t n) { if (n == 0) return r; if (Surrounding_space.find(r) == Surrounding_space.end()) { raise << "don't know surrounding recipe of " << Recipe[r].name << '\n'; @@ -122,8 +122,8 @@ recipe_number lookup_surrounding_recipe(const recipe_number r, size_t n) { } //: weaken use-before-set warnings just a tad -:(replace{} "bool already_transformed(const reagent& r, const map& names)") -bool already_transformed(const reagent& r, const map& names) { +:(replace{} "bool already_transformed(const reagent& r, const map& names)") +bool already_transformed(const reagent& r, const map& names) { if (has_property(r, "space")) { vector p = property(r, "space"); assert(p.size() == 1); diff --git a/cpp/049scenario_helpers.cc b/cpp/049scenario_helpers.cc index 8e125a8f..3e1dd25a 100644 --- a/cpp/049scenario_helpers.cc +++ b/cpp/049scenario_helpers.cc @@ -77,7 +77,7 @@ case MEMORY_SHOULD_CONTAIN: { void check_memory(const string& s) { istringstream in(s); in >> std::noskipws; - set locations_checked; + set locations_checked; while (true) { skip_whitespace_and_comments(in); if (in.eof()) break; @@ -109,7 +109,7 @@ void check_type(const string& lhs, istream& in) { assert(_assign == "<-"); skip_whitespace_and_comments(in); string literal = next_word(in); - size_t address = x.value; + index_t address = x.value; // exclude quoting brackets assert(literal[0] == '['); literal.erase(0, 1); assert(literal[literal.size()-1] == ']'); literal.erase(literal.size()-1); @@ -119,12 +119,12 @@ void check_type(const string& lhs, istream& in) { raise << "don't know how to check memory for " << lhs << '\n'; } -void check_string(size_t address, const string& literal) { +void check_string(index_t address, const string& literal) { trace("run") << "checking string length at " << address; if (Memory[address] != static_cast(literal.size())) raise << "expected location " << address << " to contain length " << literal.size() << " of string [" << literal << "] but saw " << Memory[address] << '\n'; ++address; // now skip length - for (size_t i = 0; i < literal.size(); ++i) { + for (index_t i = 0; i < literal.size(); ++i) { trace("run") << "checking location " << address+i; if (Memory[address+i] != literal[i]) raise << "expected location " << (address+i) << " to contain " << literal[i] << " but saw " << Memory[address+i] << '\n'; @@ -199,7 +199,7 @@ bool check_trace(const string& expected) { Trace_stream->newline(); vector > expected_lines = parse_trace(expected); if (expected_lines.empty()) return true; - size_t curr_expected_line = 0; + index_t curr_expected_line = 0; for (vector > >::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { if (expected_lines[curr_expected_line].first != p->first) continue; if (expected_lines[curr_expected_line].second != p->second.second) continue; @@ -217,10 +217,10 @@ bool check_trace(const string& expected) { vector > parse_trace(const string& expected) { vector buf = split(expected, "\n"); vector > result; - for (size_t i = 0; i < buf.size(); ++i) { + for (index_t i = 0; i < buf.size(); ++i) { buf[i] = trim(buf[i]); if (buf[i].empty()) continue; - size_t delim = buf[i].find(": "); + index_t delim = buf[i].find(": "); result.push_back(pair(buf[i].substr(0, delim), buf[i].substr(delim+2))); } return result; @@ -293,7 +293,7 @@ case TRACE_SHOULD_NOT_CONTAIN: { bool check_trace_missing(const string& in) { Trace_stream->newline(); vector > lines = parse_trace(in); - for (size_t i = 0; i < lines.size(); ++i) { + for (index_t i = 0; i < lines.size(); ++i) { if (trace_count(lines[i].first, lines[i].second) != 0) { raise << "unexpected [" << lines[i].second << "] in trace layer " << lines[i].first << '\n'; Passed = false; diff --git a/cpp/050scenario.cc b/cpp/050scenario.cc index bc60fcbc..b1baa1a5 100644 --- a/cpp/050scenario.cc +++ b/cpp/050scenario.cc @@ -105,7 +105,7 @@ else if (command == "scenario") { :(before "End Tests") time_t mu_time; time(&mu_time); cerr << "\nMu tests: " << ctime(&mu_time); -for (size_t i = 0; i < Scenarios.size(); ++i) { +for (index_t i = 0; i < Scenarios.size(); ++i) { //? cerr << Passed << '\n'; //? 1 run_mu_scenario(Scenarios[i]); if (Passed) cerr << "."; diff --git a/cpp/070display.cc b/cpp/070display.cc index 6a94cec9..b2bb8d06 100644 --- a/cpp/070display.cc +++ b/cpp/070display.cc @@ -3,7 +3,7 @@ //:: Display management :(before "End Globals") -size_t Display_row = 0, Display_column = 0; +index_t Display_row = 0, Display_column = 0; :(before "End Primitive Recipe Declarations") SWITCH_TO_DISPLAY, @@ -44,7 +44,7 @@ Recipe_number["clear-line-on-display"] = CLEAR_LINE_ON_DISPLAY; :(before "End Primitive Recipe Implementations") case CLEAR_LINE_ON_DISPLAY: { size_t width = tb_width(); - for (size_t x = Display_column; x < width; ++x) { + for (index_t x = Display_column; x < width; ++x) { tb_change_cell(x, Display_row, ' ', TB_WHITE, TB_DEFAULT); } tb_set_cursor(Display_column, Display_row); diff --git a/cpp/072scenario_screen.cc b/cpp/072scenario_screen.cc index a0f9c78e..e928f867 100644 --- a/cpp/072scenario_screen.cc +++ b/cpp/072scenario_screen.cc @@ -63,11 +63,11 @@ case SCREEN_SHOULD_CONTAIN: { void check_screen(const string& contents) { static const int screen_variable = Reserved_for_tests-1; assert(!Current_routine->calls.top().default_space); // not supported - size_t screen_location = Memory[screen_variable]; + index_t screen_location = Memory[screen_variable]; int data_offset = find_element_name(Type_number["screen"], "data"); assert(data_offset >= 0); - size_t screen_data_location = screen_location+data_offset; // type: address:array:character - size_t screen_data_start = Memory[screen_data_location]; // type: array:character + index_t screen_data_location = screen_location+data_offset; // type: address:array:character + index_t screen_data_start = Memory[screen_data_location]; // type: array:character int width_offset = find_element_name(Type_number["screen"], "num-columns"); size_t screen_width = Memory[screen_location+width_offset]; int height_offset = find_element_name(Type_number["screen"], "num-rows"); @@ -75,11 +75,11 @@ void check_screen(const string& contents) { string expected_contents; istringstream in(contents); in >> std::noskipws; - for (size_t row = 0; row < screen_height; ++row) { + for (index_t row = 0; row < screen_height; ++row) { skip_whitespace_and_comments(in); assert(!in.eof()); assert(in.get() == '.'); - for (size_t column = 0; column < screen_width; ++column) { + for (index_t column = 0; column < screen_width; ++column) { assert(!in.eof()); expected_contents += in.get(); } @@ -92,7 +92,7 @@ void check_screen(const string& contents) { if (Memory[screen_data_start] > static_cast(expected_contents.size())) raise << "expected contents are larger than screen size " << Memory[screen_data_start] << '\n'; ++screen_data_start; // now skip length - for (size_t i = 0; i < expected_contents.size(); ++i) { + for (index_t i = 0; i < expected_contents.size(); ++i) { trace("run") << "checking location " << screen_data_start+i; if ((!Memory[screen_data_start+i] && !isspace(expected_contents[i])) // uninitialized memory => spaces || (Memory[screen_data_start+i] && Memory[screen_data_start+i] != expected_contents[i])) { -- cgit 1.4.1-2-gfad0