From ac0e9db526dc15cf91f4c45c4586ddcc19e9708c Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Sun, 17 May 2015 02:22:41 -0700 Subject: 1391 - avoid unsigned integers --- 001help.cc | 36 +++++++++++++++++++++++++++----- 002test.cc | 6 +++--- 003trace.cc | 50 ++++++++++++++++++++++----------------------- 010vm.cc | 28 ++++++++++++------------- 011load.cc | 8 ++++---- 012transform.cc | 10 ++++----- 013literal_string.cc | 2 +- 014literal_noninteger.cc | 4 ++-- 020run.cc | 32 ++++++++++++++--------------- 021arithmetic.cc | 28 ++++++++++++++++--------- 022boolean.cc | 12 +++++------ 023jump.cc | 16 +++++++-------- 024compare.cc | 26 ++++++++++++------------ 026assert.cc | 4 ++-- 027debug.cc | 4 ++-- 030container.cc | 32 ++++++++++++++--------------- 031address.cc | 12 +++++------ 032array.cc | 16 +++++++-------- 034exclusive_container.cc | 20 +++++++++--------- 035call.cc | 8 ++++---- 036call_ingredient.cc | 16 +++++++-------- 037call_reply.cc | 8 ++++---- 038scheduler.cc | 52 +++++++++++++++++++++++------------------------ 039wait.cc | 20 +++++++++--------- 040brace.cc | 16 +++++++-------- 041name.cc | 34 +++++++++++++++---------------- 042new.cc | 28 ++++++++++++------------- 043space.cc | 10 ++++----- 044space_surround.cc | 14 ++++++------- 045closure_name.cc | 28 ++++++++++++------------- 046tangle.cc | 4 ++-- 047jump_label.cc | 12 +++++------ 048continuation.cc | 8 ++++---- 050scenario.cc | 28 ++++++++++++------------- 070display.cc | 20 +++++++++--------- 072scenario_screen.cc | 42 +++++++++++++++++++------------------- 075scenario_keyboard.cc | 2 +- 37 files changed, 365 insertions(+), 331 deletions(-) diff --git a/001help.cc b/001help.cc index de81fbcc..25150f92 100644 --- a/001help.cc +++ b/001help.cc @@ -29,6 +29,37 @@ bool is_equal(char* s, const char* lit) { return strncmp(s, lit, strlen(lit)) == 0; } +// I'll throw some style conventions here for want of a better place for them. +// As a rule I hate style guides. Do what you want, that's my motto. But since +// we're dealing with C/C++, the one big thing we want to avoid is undefined +// behavior. So, conventions: + +// 0. Initialize all primitive variables in methods and constructors. + +// 1. Avoid 'new' and 'delete' as far as possible. Rely on STL to perform +// memory management to avoid use-after-free issues (and memory leaks). + +// 2. Avoid arrays to avoid out-of-bounds access. Never use operator[] except +// with map. Use at() with STL vectors and so on. + +// 3. Valgrind all the things. + +// 4. Avoid unsigned numbers. Not strictly an undefined-behavior issue, but +// the extra range doesn't matter, and it's one less confusing category of +// interaction gotchas to worry about. +// +// We're screwed on overflow (undefined behavior). Use a decent compiler. But +// we're more likely to try to subtract unsigned 2 from 1 than we are to +// create integers that don't fit in 64 bits. +// +// Corollary: don't use the size() method on containers, since it returns an +// unsigned and that'll cause warnings about mixing signed and unsigned, +// yadda-yadda. Instead use this macro below to perform an unsafe cast to +// signed. (Implementation-defined behavior, so not as bad as undefined; +// should cause immediate failures on overflow by failing to enter loops.) +:(before "End Includes") +#define SIZE(X) static_cast(X.size()) + :(before "End Includes") #include @@ -43,8 +74,3 @@ using std::cerr; #include #include using std::string; -typedef size_t index_t; -const index_t NOT_FOUND = string::npos; -:(after "int main(int argc, char* argv[])") -assert(sizeof(string::size_type) == sizeof(size_t)); -assert(sizeof(index_t) == sizeof(size_t)); diff --git a/002test.cc b/002test.cc index 81bcba6d..76bf02cf 100644 --- a/002test.cc +++ b/002test.cc @@ -53,7 +53,7 @@ if (Run_tests) { // End Test Run Initialization time_t t; time(&t); cerr << "C tests: " << ctime(&t); - for (index_t i=0; i < sizeof(Tests)/sizeof(Tests[0]); ++i) { + for (size_t i=0; i < sizeof(Tests)/sizeof(Tests[0]); ++i) { run_test(i); } // End Tests @@ -68,7 +68,7 @@ if (Run_tests) { } :(code) -void run_test(index_t i) { +void run_test(size_t i) { if (i >= sizeof(Tests)/sizeof(Tests[0])) { cerr << "no test " << i << '\n'; return; @@ -81,7 +81,7 @@ void run_test(index_t i) { } bool is_integer(const string& s) { - return s.find_first_not_of("0123456789-") == NOT_FOUND; + return s.find_first_not_of("0123456789-") == string::npos; } long long int to_integer(string n) { diff --git a/003trace.cc b/003trace.cc index 6fb6dfa7..cdef3c0f 100644 --- a/003trace.cc +++ b/003trace.cc @@ -215,10 +215,10 @@ 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, ""); - index_t curr_expected_line = 0; - while (curr_expected_line < expected_lines.size() && expected_lines.at(curr_expected_line).empty()) + long long int curr_expected_line = 0; + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; Trace_stream->newline(); string layer, frame, contents; parse_layer_frame_contents(expected_lines.at(curr_expected_line), &layer, &frame, &contents); @@ -233,9 +233,9 @@ bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expecte continue; ++curr_expected_line; - while (curr_expected_line < expected_lines.size() && expected_lines.at(curr_expected_line).empty()) + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; parse_layer_frame_contents(expected_lines.at(curr_expected_line), &layer, &frame, &contents); } @@ -253,20 +253,20 @@ 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) { - index_t pos = s.find(delim); - if (pos == NOT_FOUND) { + size_t pos = s.find(delim); + if (pos == string::npos) { *prefix = ""; *contents = s; } else { *prefix = s.substr(0, pos); - *contents = s.substr(pos+delim.size()); + *contents = s.substr(pos+SIZE(delim)); } } void parse_layer_and_frame(const string& orig, string* layer, string* frame) { - index_t last_slash = orig.rfind('/'); - if (last_slash == NOT_FOUND + size_t last_slash = orig.rfind('/'); + if (last_slash == string::npos || orig.find_last_not_of("0123456789") != last_slash) { *layer = orig; *frame = ""; @@ -281,10 +281,10 @@ 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, ""); - index_t curr_expected_line = 0; - while (curr_expected_line < expected_lines.size() && expected_lines.at(curr_expected_line).empty()) + long long int curr_expected_line = 0; + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; Trace_stream->newline(); vector layers = split(layer, ","); for (vector > >::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { @@ -293,9 +293,9 @@ bool check_trace_contents(string FUNCTION, string FILE, int LINE, string layer, if (p->second.second != expected_lines.at(curr_expected_line)) continue; ++curr_expected_line; - while (curr_expected_line < expected_lines.size() && expected_lines.at(curr_expected_line).empty()) + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; } ++Num_failures; @@ -380,10 +380,10 @@ 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 - index_t curr_expected_line = 0; - while (curr_expected_line < expected_lines.size() && expected_lines.at(curr_expected_line).empty()) + long long int curr_expected_line = 0; + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; Trace_stream->newline(); vector layers = split(layer, ","); for (vector > >::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { @@ -394,9 +394,9 @@ bool check_trace_contents(string FUNCTION, string FILE, int LINE, string layer, if (p->second.second != expected_lines.at(curr_expected_line)) continue; ++curr_expected_line; - while (curr_expected_line < expected_lines.size() && expected_lines.at(curr_expected_line).empty()) + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; } ++Num_failures; @@ -412,14 +412,14 @@ bool check_trace_contents(string FUNCTION, string FILE, int LINE, string layer, vector split(string s, string delim) { vector result; - index_t begin=0, end=s.find(delim); + size_t begin=0, end=s.find(delim); while (true) { - if (end == NOT_FOUND) { - result.push_back(string(s, begin, NOT_FOUND)); + if (end == string::npos) { + result.push_back(string(s, begin, string::npos)); break; } result.push_back(string(s, begin, end-begin)); - begin = end+delim.size(); + begin = SIZE(end+delim); end = s.find(delim, begin); } return result; @@ -444,7 +444,7 @@ bool prefix_match(const string& pat, const string& needle) { } bool headmatch(const string& s, const string& pat) { - if (pat.size() > s.size()) return false; + if (SIZE(pat) > SIZE(s)) return false; return std::mismatch(pat.begin(), pat.end(), s.begin()).first == pat.end(); } diff --git a/010vm.cc b/010vm.cc index 6b94e4a3..3399a539 100644 --- a/010vm.cc +++ b/010vm.cc @@ -1,6 +1,6 @@ :(after "Types") // A program is a book of 'recipes' (functions) -typedef size_t recipe_number; +typedef long long int recipe_number; :(before "End Globals") map Recipe_number; map Recipe; @@ -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(); @@ -70,7 +70,7 @@ Memory.clear(); // Unlike most computers today, mu stores types in a single big table, shared // by all the mu programs on the computer. This is useful in providing a // seamless experience to help understand arbitrary mu programs. -typedef size_t type_number; +typedef long long int type_number; :(before "End Globals") map Type_number; map Type; @@ -119,7 +119,7 @@ enum kind_of_type { struct type_info { string name; kind_of_type kind; - size_t size; // only if type is not primitive; primitives and addresses have size 1 (except arrays are dynamic) + long long int size; // only if type is not primitive; primitives and addresses have size 1 (except arrays are dynamic) vector > elements; vector element_names; // End type_info Fields @@ -182,7 +182,7 @@ reagent::reagent(string s) :value(0), initialized(false) { } // structures for the first row of properties name = properties.at(0).first; - for (index_t i = 0; i < properties.at(0).second.size(); ++i) { + 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()) raise << "unknown type: " << type << '\n'; @@ -202,19 +202,19 @@ reagent::reagent() :value(0), initialized(false) { string reagent::to_string() const { ostringstream out; out << "{name: \"" << name << "\", value: " << value << ", type: "; - for (index_t i = 0; i < types.size(); ++i) { + for (long long int i = 0; i < SIZE(types); ++i) { + if (i > 0) out << '-'; out << types.at(i); - if (i < types.size()-1) out << "-"; } if (!properties.empty()) { out << ", properties: ["; - for (index_t i = 0; i < properties.size(); ++i) { + for (long long int i = 0; i < SIZE(properties); ++i) { out << "\"" << properties.at(i).first << "\": "; - for (index_t j = 0; j < properties.at(i).second.size(); ++j) { + 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 (j < properties.at(i).second.size()-1) out << ":"; } - if (i < properties.size()-1) out << ", "; + if (i < SIZE(properties)-1) out << ", "; else out << "]"; } } @@ -225,13 +225,13 @@ string reagent::to_string() const { string instruction::to_string() const { if (is_label) return label; ostringstream out; - for (index_t i = 0; i < products.size(); ++i) { + for (long long int i = 0; i < SIZE(products); ++i) { if (i > 0) out << ", "; out << products.at(i).to_string(); } if (!products.empty()) out << " <- "; out << name << '/' << operation << ' '; - for (index_t i = 0; i < ingredients.size(); ++i) { + for (long long int i = 0; i < SIZE(ingredients); ++i) { if (i > 0) out << ", "; out << ingredients.at(i).to_string(); } @@ -252,7 +252,7 @@ string slurp_until(istream& in, char delim) { } void dump_memory() { - for (map::iterator p = Memory.begin(); p != Memory.end(); ++p) { + for (map::iterator p = Memory.begin(); p != Memory.end(); ++p) { cout << p->first << ": " << p->second << '\n'; } } diff --git a/011load.cc b/011load.cc index 9644eda3..662089e2 100644 --- a/011load.cc +++ b/011load.cc @@ -82,13 +82,13 @@ bool next_instruction(istream& in, instruction* curr) { } skip_whitespace_and_comments(in); if (in.eof()) return false; -//? if (words.size() == 1) cout << words.at(0) << ' ' << words.at(0).size() << '\n'; //? 1 - if (words.size() == 1 && words.at(0) == "]") { +//? if (SIZE(words) == 1) cout << words.at(0) << ' ' << SIZE(words.at(0)) << '\n'; //? 1 + if (SIZE(words) == 1 && words.at(0) == "]") { //? cout << "AAA\n"; //? 1 return false; // end of recipe } - if (words.size() == 1 && !isalnum(words.at(0).at(0)) && words.at(0).at(0) != '$') { + if (SIZE(words) == 1 && !isalnum(words.at(0).at(0)) && words.at(0).at(0) != '$') { curr->is_label = true; curr->label = words.at(0); trace("parse") << "label: " << curr->label; @@ -203,7 +203,7 @@ void show_rest_of_stream(istream& in) { :(before "End Globals") vector recently_added_recipes; :(before "End Setup") -for (index_t i = 0; i < recently_added_recipes.size(); ++i) { +for (long long int i = 0; i < SIZE(recently_added_recipes); ++i) { //? cout << "AAA clearing " << Recipe[recently_added_recipes.at(i)].name << '\n'; //? 2 Recipe_number.erase(Recipe[recently_added_recipes.at(i)].name); Recipe.erase(recently_added_recipes.at(i)); diff --git a/012transform.cc b/012transform.cc index c7d9b313..731156a9 100644 --- a/012transform.cc +++ b/012transform.cc @@ -4,7 +4,7 @@ //: deconstructed alternative to conventional compilers. :(before "End recipe Fields") -index_t transformed_until; +long long int 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 (index_t t = 0; t < Transform.size(); ++t) { + for (long long int t = 0; t < SIZE(Transform); ++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 (index_t index = 0; index < r.steps.size(); ++index) { + for (long long int index = 0; index < SIZE(r.steps); ++index) { instruction& inst = r.steps.at(index); - for (index_t i = 0; i < inst.ingredients.size(); ++i) { + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { populate_value(inst.ingredients.at(i)); } - for (index_t i = 0; i < inst.products.size(); ++i) { + for (long long int i = 0; i < SIZE(inst.products); ++i) { populate_value(inst.products.at(i)); } } diff --git a/013literal_string.cc b/013literal_string.cc index 9e492fbb..44a94db2 100644 --- a/013literal_string.cc +++ b/013literal_string.cc @@ -53,7 +53,7 @@ string slurp_quoted(istream& in) { assert(*s.rbegin() == ']'); // delete [] delimiters s.erase(0, 1); - s.erase(s.size()-1, s.size()); + s.erase(SIZE(s)-1, SIZE(s)); name = s; types.push_back(0); properties.push_back(pair >(name, vector())); diff --git a/014literal_noninteger.cc b/014literal_noninteger.cc index 94242f41..a5e9cd12 100644 --- a/014literal_noninteger.cc +++ b/014literal_noninteger.cc @@ -20,8 +20,8 @@ recipe main [ :(code) bool is_noninteger(const string& s) { - return s.find_first_not_of("0123456789-.") == NOT_FOUND - && s.find('.') != NOT_FOUND; + return s.find_first_not_of("0123456789-.") == string::npos + && s.find('.') != string::npos; } double to_double(string n) { diff --git a/020run.cc b/020run.cc index 32981fa6..f0acfb86 100644 --- a/020run.cc +++ b/020run.cc @@ -41,7 +41,7 @@ recipe main [ //: Later layers will change this. struct routine { recipe_number running_recipe; - index_t running_step_index; + long long int running_step_index; routine(recipe_number r) :running_recipe(r), running_step_index(0) {} bool completed() const; }; @@ -69,13 +69,13 @@ void run_current_routine() // Each ingredient loads a vector of values rather than a single value; mu // permits operating on reagents spanning multiple locations. vector > ingredients; - for (index_t i = 0; i < current_instruction().ingredients.size(); ++i) { + for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i) { trace("run") << "ingredient " << i << " is " << current_instruction().ingredients.at(i).name; ingredients.push_back(read_memory(current_instruction().ingredients.at(i))); } // Instructions below will write to 'products' or to 'instruction_counter'. vector > products; - index_t instruction_counter = current_step_index(); + long long int instruction_counter = current_step_index(); //? cout << "AAA: " << current_instruction().to_string() << '\n'; //? 1 switch (current_instruction().operation) { // Primitive Recipe Implementations @@ -89,10 +89,10 @@ void run_current_routine() } } //? cout << "BBB: " << current_instruction().to_string() << '\n'; //? 1 - if (products.size() < current_instruction().products.size()) + if (SIZE(products) < SIZE(current_instruction().products)) raise << "failed to write to all products! " << current_instruction().to_string(); //? cout << "CCC: " << current_instruction().to_string() << '\n'; //? 1 - for (index_t i = 0; i < current_instruction().products.size(); ++i) { + for (long long int i = 0; i < SIZE(current_instruction().products); ++i) { trace("run") << "product " << i << " is " << current_instruction().products.at(i).name; write_memory(current_instruction().products.at(i), products.at(i)); } @@ -107,7 +107,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 index_t& current_step_index() { +inline long long int& current_step_index() { return Current_routine->running_step_index; } @@ -120,7 +120,7 @@ inline const instruction& current_instruction() { } inline bool routine::completed() const { - return running_step_index >= Recipe[running_recipe].steps.size(); + return running_step_index >= SIZE(Recipe[running_recipe].steps); } :(before "End Commandline Parsing") @@ -186,9 +186,9 @@ vector read_memory(reagent x) { result.push_back(x.value); return result; } - index_t base = x.value; - size_t size = size_of(x); - for (index_t offset = 0; offset < size; ++offset) { + long long int base = x.value; + long long int size = size_of(x); + for (long long int offset = 0; offset < size; ++offset) { double val = Memory[base+offset]; trace("mem") << "location " << base+offset << " is " << val; result.push_back(val); @@ -198,20 +198,20 @@ vector read_memory(reagent x) { void write_memory(reagent x, vector data) { if (is_dummy(x)) return; - index_t base = x.value; - if (size_of(x) != data.size()) + long long int base = x.value; + if (size_of(x) != SIZE(data)) raise << "size mismatch in storing to " << x.to_string() << '\n'; - for (index_t offset = 0; offset < data.size(); ++offset) { + for (long long int offset = 0; offset < SIZE(data); ++offset) { trace("mem") << "storing " << data.at(offset) << " in location " << base+offset; Memory[base+offset] = data.at(offset); } } :(code) -size_t size_of(const reagent& r) { +long long int size_of(const reagent& r) { return size_of(r.types); } -size_t size_of(const vector& types) { +long long int size_of(const vector& types) { // End size_of(types) Cases return 1; } @@ -221,7 +221,7 @@ bool is_dummy(const reagent& x) { } bool isa_literal(const reagent& r) { - return r.types.size() == 1 && r.types.at(0) == 0; + return SIZE(r.types) == 1 && r.types.at(0) == 0; } :(scenario run_label) diff --git a/021arithmetic.cc b/021arithmetic.cc index 2bb330a4..667fa541 100644 --- a/021arithmetic.cc +++ b/021arithmetic.cc @@ -7,8 +7,8 @@ Recipe_number["add"] = ADD; :(before "End Primitive Recipe Implementations") case ADD: { double result = 0; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); result += ingredients.at(i).at(0); } products.resize(1); @@ -52,10 +52,10 @@ SUBTRACT, Recipe_number["subtract"] = SUBTRACT; :(before "End Primitive Recipe Implementations") case SUBTRACT: { - assert(ingredients.at(0).size() == 1); // scalar + assert(scalar(ingredients.at(0))); double result = ingredients.at(0).at(0); - for (index_t i = 1; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 1; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); result -= ingredients.at(i).at(0); } products.resize(1); @@ -100,8 +100,8 @@ Recipe_number["multiply"] = MULTIPLY; :(before "End Primitive Recipe Implementations") case MULTIPLY: { double result = 1; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); result *= ingredients.at(i).at(0); } products.resize(1); @@ -145,10 +145,10 @@ DIVIDE, Recipe_number["divide"] = DIVIDE; :(before "End Primitive Recipe Implementations") case DIVIDE: { - assert(ingredients.at(0).size() == 1); // scalar + assert(scalar(ingredients.at(0))); double result = ingredients.at(0).at(0); - for (index_t i = 1; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 1; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); result /= ingredients.at(i).at(0); } products.resize(1); @@ -237,3 +237,11 @@ recipe main [ 1:number <- divide 5:literal, 2:literal ] +mem: storing 2.5 in location 1 + +:(code) +inline bool scalar(vector& x) { + return SIZE(x) == 1; +} +inline bool scalar(vector& x) { + return SIZE(x) == 1; +} diff --git a/022boolean.cc b/022boolean.cc index 9334ed6a..20571734 100644 --- a/022boolean.cc +++ b/022boolean.cc @@ -7,8 +7,8 @@ Recipe_number["and"] = AND; :(before "End Primitive Recipe Implementations") case AND: { bool result = true; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); result = result && ingredients.at(i).at(0); } products.resize(1); @@ -55,8 +55,8 @@ Recipe_number["or"] = OR; :(before "End Primitive Recipe Implementations") case OR: { bool result = false; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); result = result || ingredients.at(i).at(0); } products.resize(1); @@ -103,8 +103,8 @@ Recipe_number["not"] = NOT; :(before "End Primitive Recipe Implementations") case NOT: { products.resize(ingredients.size()); - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); products.at(i).push_back(!ingredients.at(i).at(0)); } break; diff --git a/023jump.cc b/023jump.cc index b847a66c..e0312269 100644 --- a/023jump.cc +++ b/023jump.cc @@ -17,8 +17,8 @@ Recipe_number["jump"] = JUMP; :(before "End Primitive Recipe Implementations") case JUMP: { assert(current_instruction().ingredients.at(0).initialized); - assert(ingredients.size() == 1); - assert(ingredients.at(0).size() == 1); // scalar + assert(SIZE(ingredients) == 1); + assert(scalar(ingredients.at(0))); instruction_counter += ingredients.at(0).at(0); trace("run") << "jumping to instruction " << instruction_counter+1; break; @@ -46,13 +46,13 @@ Recipe_number["jump-if"] = JUMP_IF; :(before "End Primitive Recipe Implementations") case JUMP_IF: { assert(current_instruction().ingredients.at(1).initialized); - assert(ingredients.size() == 2); - assert(ingredients.at(0).size() == 1); // scalar + assert(SIZE(ingredients) == 2); + assert(scalar(ingredients.at(0))); if (!ingredients.at(0).at(0)) { trace("run") << "jump-if fell through"; break; } - assert(ingredients.at(1).size() == 1); // scalar + assert(scalar(ingredients.at(1))); instruction_counter += ingredients.at(1).at(0); trace("run") << "jumping to instruction " << instruction_counter+1; break; @@ -86,13 +86,13 @@ Recipe_number["jump-unless"] = JUMP_UNLESS; :(before "End Primitive Recipe Implementations") case JUMP_UNLESS: { assert(current_instruction().ingredients.at(1).initialized); - assert(ingredients.size() == 2); - assert(ingredients.at(0).size() == 1); // scalar + assert(SIZE(ingredients) == 2); + assert(scalar(ingredients.at(0))); if (ingredients.at(0).at(0)) { trace("run") << "jump-unless fell through"; break; } - assert(ingredients.at(1).size() == 1); // scalar + assert(scalar(ingredients.at(1))); instruction_counter += ingredients.at(1).at(0); trace("run") << "jumping to instruction " << instruction_counter+1; break; diff --git a/024compare.cc b/024compare.cc index 13732980..d840b2ba 100644 --- a/024compare.cc +++ b/024compare.cc @@ -8,7 +8,7 @@ Recipe_number["equal"] = EQUAL; case EQUAL: { vector& exemplar = ingredients.at(0); bool result = true; - for (index_t i = 1; i < ingredients.size(); ++i) { + for (long long int i = 1; i < SIZE(ingredients); ++i) { if (!equal(ingredients.at(i).begin(), ingredients.at(i).end(), exemplar.begin())) { result = false; break; @@ -66,10 +66,10 @@ Recipe_number["greater-than"] = GREATER_THAN; :(before "End Primitive Recipe Implementations") case GREATER_THAN: { bool result = true; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); } - for (index_t i = /**/1; i < ingredients.size(); ++i) { + for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) <= ingredients.at(i).at(0)) { result = false; } @@ -126,10 +126,10 @@ Recipe_number["lesser-than"] = LESSER_THAN; :(before "End Primitive Recipe Implementations") case LESSER_THAN: { bool result = true; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); } - for (index_t i = /**/1; i < ingredients.size(); ++i) { + for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) >= ingredients.at(i).at(0)) { result = false; } @@ -186,10 +186,10 @@ Recipe_number["greater-or-equal"] = GREATER_OR_EQUAL; :(before "End Primitive Recipe Implementations") case GREATER_OR_EQUAL: { bool result = true; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); } - for (index_t i = /**/1; i < ingredients.size(); ++i) { + for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) < ingredients.at(i).at(0)) { result = false; } @@ -260,10 +260,10 @@ Recipe_number["lesser-or-equal"] = LESSER_OR_EQUAL; :(before "End Primitive Recipe Implementations") case LESSER_OR_EQUAL: { bool result = true; - for (index_t i = 0; i < ingredients.size(); ++i) { - assert(ingredients.at(i).size() == 1); // scalar + for (long long int i = 0; i < SIZE(ingredients); ++i) { + assert(scalar(ingredients.at(i))); } - for (index_t i = /**/1; i < ingredients.size(); ++i) { + for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) > ingredients.at(i).at(0)) { result = false; } diff --git a/026assert.cc b/026assert.cc index 5b03e318..9e4e79df 100644 --- a/026assert.cc +++ b/026assert.cc @@ -11,8 +11,8 @@ ASSERT, Recipe_number["assert"] = ASSERT; :(before "End Primitive Recipe Implementations") case ASSERT: { - assert(ingredients.size() == 2); - assert(ingredients.at(0).size() == 1); // scalar + assert(SIZE(ingredients) == 2); + assert(scalar(ingredients.at(0))); if (!ingredients.at(0).at(0)) { assert(isa_literal(current_instruction().ingredients.at(1))); raise << current_instruction().ingredients.at(1).name << '\n' << die(); diff --git a/027debug.cc b/027debug.cc index d472a314..7b96e4e9 100644 --- a/027debug.cc +++ b/027debug.cc @@ -6,13 +6,13 @@ _PRINT, Recipe_number["$print"] = _PRINT; :(before "End Primitive Recipe Implementations") case _PRINT: { - for (index_t i = 0; i < ingredients.size(); ++i) { + for (long long int i = 0; i < SIZE(ingredients); ++i) { if (isa_literal(current_instruction().ingredients.at(i))) { trace("run") << "$print: " << current_instruction().ingredients.at(i).name; cout << current_instruction().ingredients.at(i).name; } else { - for (index_t j = 0; j < ingredients.at(i).size(); ++j) { + for (long long int j = 0; j < SIZE(ingredients.at(i)); ++j) { trace("run") << "$print: " << ingredients.at(i).at(j); if (j > 0) cout << " "; cout << ingredients.at(i).at(j); diff --git a/030container.cc b/030container.cc index 71ef229c..34382295 100644 --- a/030container.cc +++ b/030container.cc @@ -80,8 +80,8 @@ recipe main [ type_info t = Type[types.at(0)]; if (t.kind == container) { // size of a container is the sum of the sizes of its elements - size_t result = 0; - for (index_t i = 0; i < t.elements.size(); ++i) { + long long int result = 0; + for (long long int i = 0; i < SIZE(t.elements); ++i) { result += size_of(t.elements.at(i)); } return result; @@ -110,19 +110,19 @@ Recipe_number["get"] = GET; :(before "End Primitive Recipe Implementations") case GET: { reagent base = current_instruction().ingredients.at(0); - index_t base_address = base.value; + long long int base_address = base.value; type_number base_type = base.types.at(0); assert(Type[base_type].kind == container); assert(isa_literal(current_instruction().ingredients.at(1))); - assert(ingredients.at(1).size() == 1); // scalar - index_t offset = ingredients.at(1).at(0); - index_t src = base_address; - for (index_t i = 0; i < offset; ++i) { + assert(scalar(ingredients.at(1))); + long long int offset = ingredients.at(1).at(0); + long long int src = base_address; + for (long long int i = 0; i < offset; ++i) { src += size_of(Type[base_type].elements.at(i)); } trace("run") << "address to copy is " << src; assert(Type[base_type].kind == container); - assert(Type[base_type].elements.size() > offset); + assert(SIZE(Type[base_type].elements) > offset); type_number src_type = Type[base_type].elements.at(offset).at(0); trace("run") << "its type is " << src_type; reagent tmp; @@ -169,14 +169,14 @@ Recipe_number["get-address"] = GET_ADDRESS; :(before "End Primitive Recipe Implementations") case GET_ADDRESS: { reagent base = current_instruction().ingredients.at(0); - index_t base_address = base.value; + long long int base_address = base.value; type_number base_type = base.types.at(0); assert(Type[base_type].kind == container); assert(isa_literal(current_instruction().ingredients.at(1))); - assert(ingredients.at(1).size() == 1); // scalar - index_t offset = ingredients.at(1).at(0); - index_t result = base_address; - for (index_t i = 0; i < offset; ++i) { + assert(scalar(ingredients.at(1))); + long long int offset = ingredients.at(1).at(0); + long long int result = base_address; + for (long long int i = 0; i < offset; ++i) { result += size_of(Type[base_type].elements.at(i)); } trace("run") << "address to copy is " << result; @@ -239,8 +239,8 @@ void insert_container(const string& command, kind_of_type kind, istream& in) { } t.elements.push_back(types); } - assert(t.elements.size() == t.element_names.size()); - t.size = t.elements.size(); + assert(SIZE(t.elements) == SIZE(t.element_names)); + t.size = SIZE(t.elements); } //: ensure types created in one scenario don't leak outside it. @@ -249,7 +249,7 @@ vector recently_added_types; :(before "End load_permanently") //: for non-tests recently_added_types.clear(); :(before "End Setup") //: for tests -for (index_t i = 0; i < recently_added_types.size(); ++i) { +for (long long int i = 0; i < SIZE(recently_added_types); ++i) { //? cout << "erasing " << Type[recently_added_types.at(i)].name << '\n'; //? 1 Type_number.erase(Type[recently_added_types.at(i)].name); Type.erase(recently_added_types.at(i)); diff --git a/031address.cc b/031address.cc index 0ea74aa1..f38e96ba 100644 --- a/031address.cc +++ b/031address.cc @@ -13,7 +13,7 @@ recipe main [ +mem: location 2 is 34 +mem: storing 34 in location 3 -:(before "index_t base = x.value" following "vector read_memory(reagent x)") +:(before "long long int base = x.value" following "vector read_memory(reagent x)") x = canonize(x); //: similarly, write to addresses pointing at other locations using the @@ -27,7 +27,7 @@ recipe main [ +mem: location 1 is 2 +mem: storing 34 in location 2 -:(before "index_t base = x.value" following "void write_memory(reagent x, vector data)") +:(before "long long int base = x.value" following "void write_memory(reagent x, vector data)") x = canonize(x); :(code) @@ -55,8 +55,8 @@ reagent deref(reagent x) { copy(++x.types.begin(), x.types.end(), inserter(result.types, result.types.begin())); // drop-one 'deref' - index_t i = 0; - size_t len = x.properties.size(); + long long int i = 0; + long long int len = SIZE(x.properties); for (i = 0; i < len; ++i) { if (x.properties.at(i).first == "deref") break; result.properties.push_back(x.properties.at(i)); @@ -115,14 +115,14 @@ base = canonize(base); :(code) bool has_property(reagent x, string name) { - for (index_t i = 0; i < x.properties.size(); ++i) { + for (long long int i = 0; i < SIZE(x.properties); ++i) { if (x.properties.at(i).first == name) return true; } return false; } vector property(const reagent& r, const string& name) { - for (index_t p = 0; p != r.properties.size(); ++p) { + for (long long int p = 0; p != SIZE(r.properties); ++p) { if (r.properties.at(p).first == name) return r.properties.at(p).second; } diff --git a/032array.cc b/032array.cc index fd7f9baf..384b2106 100644 --- a/032array.cc +++ b/032array.cc @@ -47,11 +47,11 @@ recipe main [ +mem: storing 16 in location 9 //: disable the size mismatch check since the destination array need not be initialized -:(replace "if (size_of(x) != data.size())" following "void write_memory(reagent x, vector data)") -if (x.types.at(0) != Type_number["array"] && size_of(x) != data.size()) -:(after "size_t size_of(const reagent& r)") +:(replace "if (size_of(x) != SIZE(data))" following "void write_memory(reagent x, vector data)") +if (x.types.at(0) != Type_number["array"] && size_of(x) != SIZE(data)) +:(after "long long int size_of(const reagent& r)") if (r.types.at(0) == Type_number["array"]) { - assert(r.types.size() > 1); + assert(SIZE(r.types) > 1); // skip the 'array' type to get at the element type return 1 + Memory[r.value]*size_of(array_element(r.types)); } @@ -98,7 +98,7 @@ case INDEX: { //? if (Trace_stream) Trace_stream->dump_layer = "run"; //? 1 reagent base = canonize(current_instruction().ingredients.at(0)); //? trace("run") << "ingredient 0 after canonize: " << base.to_string(); //? 1 - index_t base_address = base.value; + long long int base_address = base.value; assert(base.types.at(0) == Type_number["array"]); reagent offset = canonize(current_instruction().ingredients.at(1)); //? trace("run") << "ingredient 1 after canonize: " << offset.to_string(); //? 1 @@ -106,7 +106,7 @@ case INDEX: { vector element_type = array_element(base.types); //? trace("run") << "offset: " << offset_val.at(0); //? 1 //? trace("run") << "size of elements: " << size_of(element_type); //? 1 - index_t src = base_address + 1 + offset_val.at(0)*size_of(element_type); + long long int src = base_address + 1 + offset_val.at(0)*size_of(element_type); trace("run") << "address to copy is " << src; trace("run") << "its type is " << element_type.at(0); reagent tmp; @@ -153,12 +153,12 @@ Recipe_number["index-address"] = INDEX_ADDRESS; :(before "End Primitive Recipe Implementations") case INDEX_ADDRESS: { reagent base = canonize(current_instruction().ingredients.at(0)); - index_t base_address = base.value; + long long int base_address = base.value; assert(base.types.at(0) == Type_number["array"]); reagent offset = canonize(current_instruction().ingredients.at(1)); vector offset_val(read_memory(offset)); vector element_type = array_element(base.types); - index_t result = base_address + 1 + offset_val.at(0)*size_of(element_type); + long long int result = base_address + 1 + offset_val.at(0)*size_of(element_type); products.resize(1); products.at(0).push_back(result); break; diff --git a/034exclusive_container.cc b/034exclusive_container.cc index 6dc7a82b..6d8e3932 100644 --- a/034exclusive_container.cc +++ b/034exclusive_container.cc @@ -11,15 +11,15 @@ type_number tmp = Type_number["number-or-point"] = Next_type_number++; Type[tmp].size = 2; Type[tmp].kind = exclusive_container; Type[tmp].name = "number-or-point"; -//? cout << tmp << ": " << Type[tmp].elements.size() << '\n'; //? 1 +//? cout << tmp << ": " << SIZE(Type[tmp].elements) << '\n'; //? 1 vector t1; t1.push_back(number); Type[tmp].elements.push_back(t1); -//? cout << Type[tmp].elements.size() << '\n'; //? 1 +//? cout << SIZE(Type[tmp].elements) << '\n'; //? 1 vector t2; t2.push_back(point); Type[tmp].elements.push_back(t2); -//? cout << Type[tmp].elements.size() << '\n'; //? 1 +//? cout << SIZE(Type[tmp].elements) << '\n'; //? 1 //? cout << "point: " << point << '\n'; //? 1 Type[tmp].element_names.push_back("i"); Type[tmp].element_names.push_back("p"); @@ -43,10 +43,10 @@ if (t.kind == exclusive_container) { // (So like containers, it can't contain arrays.) //? cout << "--- " << types.at(0) << ' ' << t.size << '\n'; //? 1 //? 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 (index_t i = 0; i < t.size; ++i) { - size_t tmp = size_of(t.elements.at(i)); +//? cout << t.name << ' ' << t.size << ' ' << SIZE(t.elements) << '\n'; //? 1 + long long int result = 0; + for (long long int i = 0; i < t.size; ++i) { + long long int tmp = size_of(t.elements.at(i)); //? cout << i << ": " << t.elements.at(i).at(0) << ' ' << tmp << ' ' << result << '\n'; //? 1 if (tmp > result) result = tmp; } @@ -89,13 +89,13 @@ Recipe_number["maybe-convert"] = MAYBE_CONVERT; :(before "End Primitive Recipe Implementations") case MAYBE_CONVERT: { reagent base = canonize(current_instruction().ingredients.at(0)); - index_t base_address = base.value; + long long int base_address = base.value; type_number base_type = base.types.at(0); assert(Type[base_type].kind == exclusive_container); assert(isa_literal(current_instruction().ingredients.at(1))); - index_t tag = current_instruction().ingredients.at(1).value; + long long int tag = current_instruction().ingredients.at(1).value; long long int result; - if (tag == static_cast(Memory[base_address])) { + if (tag == static_cast(Memory[base_address])) { result = base_address+1; } else { diff --git a/035call.cc b/035call.cc index c80331d2..e1d392e7 100644 --- a/035call.cc +++ b/035call.cc @@ -33,7 +33,7 @@ recipe f [ // This requires maintaining a 'stack' of interrupted recipes or 'calls'. struct call { recipe_number running_recipe; - index_t running_step_index; + long long int 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 index_t& current_step_index()") -inline index_t& current_step_index() { +:(replace{} "inline long long int& current_step_index()") +inline long long int& current_step_index() { assert(!Current_routine->calls.empty()); return Current_routine->calls.front().running_step_index; } @@ -97,7 +97,7 @@ inline const vector& routine::steps() const { :(before "Running One Instruction") // when we reach the end of one call, we may reach the end of the one below // it, and the one below that, and so on -while (current_step_index() >= Current_routine->steps().size()) { +while (current_step_index() >= SIZE(Current_routine->steps())) { Current_routine->calls.pop_front(); if (Current_routine->calls.empty()) return; // todo: no results returned warning diff --git a/036call_ingredient.cc b/036call_ingredient.cc index a6fbb181..090d86a8 100644 --- a/036call_ingredient.cc +++ b/036call_ingredient.cc @@ -24,13 +24,13 @@ recipe f [ :(before "End call Fields") vector > ingredient_atoms; -index_t next_ingredient_to_process; +long long int 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) {} :(replace "Current_routine->calls.push_front(call(current_instruction().operation))" following "End Primitive Recipe Implementations") call callee(current_instruction().operation); -for (size_t i = 0; i < ingredients.size(); ++i) { +for (long long int i = 0; i < SIZE(ingredients); ++i) { callee.ingredient_atoms.push_back(ingredients.at(i)); } Current_routine->calls.push_front(callee); @@ -42,10 +42,10 @@ Recipe_number["next-ingredient"] = NEXT_INGREDIENT; :(before "End Primitive Recipe Implementations") case NEXT_INGREDIENT: { assert(!Current_routine->calls.empty()); - if (Current_routine->calls.front().next_ingredient_to_process < Current_routine->calls.front().ingredient_atoms.size()) { + if (Current_routine->calls.front().next_ingredient_to_process < SIZE(Current_routine->calls.front().ingredient_atoms)) { products.push_back( Current_routine->calls.front().ingredient_atoms.at(Current_routine->calls.front().next_ingredient_to_process)); - assert(products.size() == 1); products.resize(2); // push a new vector + assert(SIZE(products) == 1); products.resize(2); // push a new vector products.at(1).push_back(1); ++Current_routine->calls.front().next_ingredient_to_process; } @@ -100,17 +100,17 @@ Recipe_number["ingredient"] = INGREDIENT; :(before "End Primitive Recipe Implementations") case INGREDIENT: { assert(isa_literal(current_instruction().ingredients.at(0))); - assert(ingredients.at(0).size() == 1); // scalar - if (static_cast(ingredients.at(0).at(0)) < Current_routine->calls.front().ingredient_atoms.size()) { + assert(scalar(ingredients.at(0))); + if (static_cast(ingredients.at(0).at(0)) < SIZE(Current_routine->calls.front().ingredient_atoms)) { Current_routine->calls.front().next_ingredient_to_process = ingredients.at(0).at(0); products.push_back( Current_routine->calls.front().ingredient_atoms.at(Current_routine->calls.front().next_ingredient_to_process)); - assert(products.size() == 1); products.resize(2); // push a new vector + assert(SIZE(products) == 1); products.resize(2); // push a new vector products.at(1).push_back(1); ++Current_routine->calls.front().next_ingredient_to_process; } else { - if (current_instruction().products.size() > 1) { + if (SIZE(current_instruction().products) > 1) { products.resize(2); products.at(0).push_back(0); // todo: will fail noisily if we try to read a compound value products.at(1).push_back(0); diff --git a/037call_reply.cc b/037call_reply.cc index 4eaea444..c6045d9c 100644 --- a/037call_reply.cc +++ b/037call_reply.cc @@ -28,11 +28,11 @@ case REPLY: { copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin())); // check that any reply ingredients with /same-as-ingredient connect up // the corresponding ingredient and product in the caller. - for (index_t i = 0; i < caller_instruction.products.size(); ++i) { + for (long long int i = 0; i < SIZE(caller_instruction.products); ++i) { trace("run") << "result " << i << " is " << to_string(ingredients.at(i)); if (has_property(reply_inst.ingredients.at(i), "same-as-ingredient")) { vector tmp = property(reply_inst.ingredients.at(i), "same-as-ingredient"); - assert(tmp.size() == 1); + assert(SIZE(tmp) == 1); long long int ingredient_index = to_integer(tmp.at(0)); if (caller_instruction.products.at(i).value != caller_instruction.ingredients.at(ingredient_index).value) raise << "'same-as-ingredient' result " << caller_instruction.products.at(i).value << " must be location " << caller_instruction.ingredients.at(ingredient_index).value << '\n'; @@ -79,12 +79,12 @@ recipe test1 [ string to_string(const vector& in) { if (in.empty()) return "[]"; ostringstream out; - if (in.size() == 1) { + if (SIZE(in) == 1) { out << in.at(0); return out.str(); } out << "["; - for (index_t i = 0; i < in.size(); ++i) { + for (long long int i = 0; i < SIZE(in); ++i) { if (i > 0) out << ", "; out << in.at(i); } diff --git a/038scheduler.cc b/038scheduler.cc index 101d1960..593aad7f 100644 --- a/038scheduler.cc +++ b/038scheduler.cc @@ -18,9 +18,9 @@ recipe f2 [ //: first, add a deadline to run(routine) //: these changes are ugly and brittle; just close your nose and get through the next few lines :(replace "void run_current_routine()") -void run_current_routine(size_t time_slice) -:(replace "while (!Current_routine->completed())" following "void run_current_routine(size_t time_slice)") -size_t ninstrs = 0; +void run_current_routine(long long int time_slice) +:(replace "while (!Current_routine->completed())" following "void run_current_routine(long long int time_slice)") +long long int ninstrs = 0; while (Current_routine->state == RUNNING && ninstrs < time_slice) :(after "Running One Instruction") ninstrs++; @@ -40,8 +40,8 @@ state = RUNNING; :(before "End Globals") vector Routines; -index_t Current_routine_index = 0; -size_t Scheduling_interval = 500; +long long int Current_routine_index = 0; +long long int Scheduling_interval = 500; :(before "End Setup") Scheduling_interval = 500; :(replace{} "void run(recipe_number r)") @@ -70,7 +70,7 @@ void run(recipe_number r) { :(code) bool all_routines_done() { - for (index_t i = 0; i < Routines.size(); ++i) { + for (long long int i = 0; i < SIZE(Routines); ++i) { //? cout << "routine " << i << ' ' << Routines.at(i)->state << '\n'; //? 1 if (Routines.at(i)->state == RUNNING) { return false; @@ -82,8 +82,8 @@ bool all_routines_done() { // skip Current_routine_index past non-RUNNING routines void skip_to_next_routine() { assert(!Routines.empty()); - assert(Current_routine_index < Routines.size()); - for (index_t i = (Current_routine_index+1)%Routines.size(); i != Current_routine_index; i = (i+1)%Routines.size()) { + assert(Current_routine_index < SIZE(Routines)); + for (long long int i = (Current_routine_index+1)%SIZE(Routines); i != Current_routine_index; i = (i+1)%SIZE(Routines)) { if (Routines.at(i)->state == RUNNING) { //? cout << "switching to " << i << '\n'; //? 1 Current_routine_index = i; @@ -105,7 +105,7 @@ string current_routine_label() { } :(before "End Teardown") -for (index_t i = 0; i < Routines.size(); ++i) +for (long long int i = 0; i < SIZE(Routines); ++i) delete Routines.at(i); Routines.clear(); @@ -114,9 +114,9 @@ Routines.clear(); //: 'start-running' will return a unique id for the routine that was created. //: routine id is a number, but don't do any arithmetic on it :(before "End routine Fields") -index_t id; +long long int id; :(before "End Globals") -index_t Next_routine_id = 1; +long long int Next_routine_id = 1; :(before "End Setup") Next_routine_id = 1; :(before "End routine Constructor") @@ -146,7 +146,7 @@ case START_RUNNING: { //? cerr << new_routine->id << " -> " << Current_routine->id << '\n'; //? 1 new_routine->parent_index = Current_routine_index; // populate ingredients - for (index_t i = 1; i < current_instruction().ingredients.size(); ++i) + for (long long int i = 1; i < SIZE(current_instruction().ingredients); ++i) new_routine->calls.front().ingredient_atoms.push_back(ingredients.at(i)); Routines.push_back(new_routine); products.resize(1); @@ -255,10 +255,10 @@ recipe f1 [ :(before "End Scheduler Cleanup") //? trace("schedule") << "Before cleanup"; //? 1 -//? for (index_t i = 0; i < Routines.size(); ++i) { //? 1 +//? for (long long int i = 0; i < SIZE(Routines); ++i) { //? 1 //? trace("schedule") << i << ": " << Routines.at(i)->id << ' ' << Routines.at(i)->state << ' ' << Routines.at(i)->parent_index << ' ' << Routines.at(i)->state; //? 1 //? } //? 1 -for (index_t i = 0; i < Routines.size(); ++i) { +for (long long int i = 0; i < SIZE(Routines); ++i) { if (Routines.at(i)->state == COMPLETED) continue; if (Routines.at(i)->parent_index < 0) continue; // root thread //? trace("schedule") << "AAA " << i; //? 1 @@ -268,12 +268,12 @@ for (index_t i = 0; i < Routines.size(); ++i) { } } //? trace("schedule") << "After cleanup"; //? 1 -//? for (index_t i = 0; i < Routines.size(); ++i) { //? 1 +//? for (long long int i = 0; i < SIZE(Routines); ++i) { //? 1 //? trace("schedule") << i << ": " << Routines.at(i)->id << ' ' << Routines.at(i)->state << ' ' << Routines.at(i)->parent_index << ' ' << Routines.at(i)->state; //? 1 //? } //? 1 :(code) -bool has_completed_parent(index_t routine_index) { +bool has_completed_parent(long long int routine_index) { //? trace("schedule") << "CCC " << routine_index << '\n'; //? 2 for (long long int j = routine_index; j >= 0; j = Routines.at(j)->parent_index) { //? trace("schedule") << "DDD " << j << '\n'; //? 2 @@ -306,10 +306,10 @@ ROUTINE_STATE, Recipe_number["routine-state"] = ROUTINE_STATE; :(before "End Primitive Recipe Implementations") case ROUTINE_STATE: { - assert(ingredients.at(0).size() == 1); // routine id must be scalar - index_t id = ingredients.at(0).at(0); + assert(scalar(ingredients.at(0))); + long long int id = ingredients.at(0).at(0); long long int result = -1; - for (index_t i = 0; i < Routines.size(); ++i) { + for (long long int i = 0; i < SIZE(Routines); ++i) { if (Routines.at(i)->id == id) { result = Routines.at(i)->state; break; @@ -328,9 +328,9 @@ RESTART, Recipe_number["restart"] = RESTART; :(before "End Primitive Recipe Implementations") case RESTART: { - assert(ingredients.at(0).size() == 1); // routine id must be scalar - index_t id = ingredients.at(0).at(0); - for (index_t i = 0; i < Routines.size(); ++i) { + assert(scalar(ingredients.at(0))); + long long int id = ingredients.at(0).at(0); + for (long long int i = 0; i < SIZE(Routines); ++i) { if (Routines.at(i)->id == id) { Routines.at(i)->state = RUNNING; break; @@ -345,9 +345,9 @@ STOP, Recipe_number["stop"] = STOP; :(before "End Primitive Recipe Implementations") case STOP: { - assert(ingredients.at(0).size() == 1); // routine id must be scalar - index_t id = ingredients.at(0).at(0); - for (index_t i = 0; i < Routines.size(); ++i) { + assert(scalar(ingredients.at(0))); + long long int id = ingredients.at(0).at(0); + for (long long int i = 0; i < SIZE(Routines); ++i) { if (Routines.at(i)->id == id) { Routines.at(i)->state = COMPLETED; break; @@ -362,7 +362,7 @@ _DUMP_ROUTINES, Recipe_number["$dump-routines"] = _DUMP_ROUTINES; :(before "End Primitive Recipe Implementations") case _DUMP_ROUTINES: { - for (index_t i = 0; i < Routines.size(); ++i) { + for (long long int i = 0; i < SIZE(Routines); ++i) { cerr << i << ": " << Routines.at(i)->id << ' ' << Routines.at(i)->state << ' ' << Routines.at(i)->parent_index << '\n'; } break; diff --git a/039wait.cc b/039wait.cc index c7743785..14a9ee18 100644 --- a/039wait.cc +++ b/039wait.cc @@ -23,7 +23,7 @@ recipe f2 [ WAITING, :(before "End routine Fields") // only if state == WAITING -index_t waiting_on_location; +long long int waiting_on_location; int old_value_of_waiting_location; :(before "End routine Constructor") waiting_on_location = old_value_of_waiting_location = 0; @@ -48,7 +48,7 @@ case WAIT_FOR_LOCATION: { //: scheduler tweak to get routines out of that state :(before "End Scheduler State Transitions") -for (index_t i = 0; i < Routines.size(); ++i) { +for (long long int i = 0; i < SIZE(Routines); ++i) { //? trace("schedule") << "wake up loop 1: routine " << Routines.at(i)->id << " has state " << Routines.at(i)->state; //? 1 if (Routines.at(i)->state != WAITING) continue; //? trace("schedule") << "waiting on location: " << Routines.at(i)->waiting_on_location; //? 1 @@ -86,7 +86,7 @@ recipe f2 [ :(before "End routine Fields") // only if state == WAITING -index_t waiting_on_routine; +long long int waiting_on_routine; :(before "End routine Constructor") waiting_on_routine = 0; @@ -97,7 +97,7 @@ Recipe_number["wait-for-routine"] = WAIT_FOR_ROUTINE; :(before "End Primitive Recipe Implementations") case WAIT_FOR_ROUTINE: { Current_routine->state = WAITING; - assert(ingredients.at(0).size() == 1); // scalar + assert(scalar(ingredients.at(0))); Current_routine->waiting_on_routine = ingredients.at(0).at(0); trace("run") << "waiting for routine " << ingredients.at(0).at(0); break; @@ -107,12 +107,12 @@ case WAIT_FOR_ROUTINE: { // Wake up any routines waiting for other routines to go to sleep. // Important: this must come after the scheduler loop above giving routines // waiting for locations to change a chance to wake up. -for (index_t i = 0; i < Routines.size(); ++i) { +for (long long int i = 0; i < SIZE(Routines); ++i) { if (Routines.at(i)->state != WAITING) continue; if (!Routines.at(i)->waiting_on_routine) continue; - index_t id = Routines.at(i)->waiting_on_routine; + long long int id = Routines.at(i)->waiting_on_routine; assert(id != Routines.at(i)->id); - for (index_t j = 0; j < Routines.size(); ++j) { + for (long long int j = 0; j < SIZE(Routines); ++j) { if (Routines.at(j)->id == id && Routines.at(j)->state != RUNNING) { trace("schedule") << "waking up routine " << Routines.at(i)->id; Routines.at(i)->state = RUNNING; @@ -127,7 +127,7 @@ SWITCH, Recipe_number["switch"] = SWITCH; :(before "End Primitive Recipe Implementations") case SWITCH: { - index_t id = some_other_running_routine(); + long long int id = some_other_running_routine(); if (id) { assert(id != Current_routine->id); //? cerr << "waiting on " << id << " from " << Current_routine->id << '\n'; //? 1 @@ -138,8 +138,8 @@ case SWITCH: { } :(code) -index_t some_other_running_routine() { - for (index_t i = 0; i < Routines.size(); ++i) { +long long int some_other_running_routine() { + for (long long int i = 0; i < SIZE(Routines); ++i) { if (i == Current_routine_index) continue; assert(Routines.at(i) != Current_routine); assert(Routines.at(i)->id != Current_routine->id); diff --git a/040brace.cc b/040brace.cc index ec9c6a4d..8a1b4512 100644 --- a/040brace.cc +++ b/040brace.cc @@ -42,7 +42,7 @@ void transform_braces(const recipe_number r) { const int OPEN = 0, CLOSE = 1; // use signed integer for step index because we'll be doing arithmetic on it list > braces; - for (long long int index = 0; index < static_cast(Recipe[r].steps.size()); ++index) { + for (long long int index = 0; index < SIZE(Recipe[r].steps); ++index) { const instruction& inst = Recipe[r].steps.at(index); if (inst.label == "{") { trace("brace") << r << ": push (open, " << index << ")"; @@ -55,7 +55,7 @@ void transform_braces(const recipe_number r) { } stack open_braces; trace("after-brace") << "recipe " << Recipe[r].name; - for (long long int index = 0; index < static_cast(Recipe[r].steps.size()); ++index) { + for (long long int index = 0; index < SIZE(Recipe[r].steps); ++index) { //? cerr << index << '\n'; //? 1 instruction& inst = Recipe[r].steps.at(index); //? cout << "AAA " << inst.name << ": " << inst.operation << '\n'; //? 1 @@ -65,7 +65,7 @@ void transform_braces(const recipe_number r) { ; // do nothing else if (inst.operation == Recipe_number["loop"]) { inst.operation = Recipe_number["jump"]; - if (inst.ingredients.size() > 0 && isa_literal(inst.ingredients.at(0))) { + if (SIZE(inst.ingredients) > 0 && isa_literal(inst.ingredients.at(0))) { // explicit target; a later phase will handle it trace("after-brace") << "jump " << inst.ingredients.at(0).name << ":offset"; } @@ -81,7 +81,7 @@ void transform_braces(const recipe_number r) { } else if (inst.operation == Recipe_number["break"]) { inst.operation = Recipe_number["jump"]; - if (inst.ingredients.size() > 0 && isa_literal(inst.ingredients.at(0))) { + if (SIZE(inst.ingredients) > 0 && isa_literal(inst.ingredients.at(0))) { // explicit target; a later phase will handle it trace("after-brace") << "jump " << inst.ingredients.at(0).name << ":offset"; } @@ -95,7 +95,7 @@ void transform_braces(const recipe_number r) { } else if (inst.operation == Recipe_number["loop-if"]) { inst.operation = Recipe_number["jump-if"]; - if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients.at(1))) { + if (SIZE(inst.ingredients) > 1 && isa_literal(inst.ingredients.at(1))) { // explicit target; a later phase will handle it trace("after-brace") << "jump " << inst.ingredients.at(1).name << ":offset"; } @@ -109,7 +109,7 @@ void transform_braces(const recipe_number r) { } else if (inst.operation == Recipe_number["break-if"]) { inst.operation = Recipe_number["jump-if"]; - if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients.at(1))) { + if (SIZE(inst.ingredients) > 1 && isa_literal(inst.ingredients.at(1))) { // explicit target; a later phase will handle it trace("after-brace") << "jump " << inst.ingredients.at(1).name << ":offset"; } @@ -123,7 +123,7 @@ void transform_braces(const recipe_number r) { } else if (inst.operation == Recipe_number["loop-unless"]) { inst.operation = Recipe_number["jump-unless"]; - if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients.at(1))) { + if (SIZE(inst.ingredients) > 1 && isa_literal(inst.ingredients.at(1))) { // explicit target; a later phase will handle it trace("after-brace") << "jump " << inst.ingredients.at(1).name << ":offset"; } @@ -138,7 +138,7 @@ void transform_braces(const recipe_number r) { else if (inst.operation == Recipe_number["break-unless"]) { //? cout << "AAA break-unless\n"; //? 1 inst.operation = Recipe_number["jump-unless"]; - if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients.at(1))) { + if (SIZE(inst.ingredients) > 1 && isa_literal(inst.ingredients.at(1))) { // explicit target; a later phase will handle it trace("after-brace") << "jump " << inst.ingredients.at(1).name << ":offset"; } diff --git a/041name.cc b/041name.cc index 1f8a17bd..cf337ffc 100644 --- a/041name.cc +++ b/041name.cc @@ -21,9 +21,9 @@ recipe main [ Transform.push_back(transform_names); :(before "End Globals") -map > Name; +map > Name; :(after "Clear Other State For recently_added_recipes") -for (index_t i = 0; i < recently_added_recipes.size(); ++i) { +for (long long int i = 0; i < SIZE(recently_added_recipes); ++i) { Name.erase(recently_added_recipes.at(i)); } @@ -31,15 +31,15 @@ for (index_t i = 0; i < recently_added_recipes.size(); ++i) { void transform_names(const recipe_number r) { bool names_used = false; bool numeric_locations_used = false; - map& names = Name[r]; + map& names = Name[r]; // store the indices 'used' so far in the map - index_t& curr_idx = names[""]; + long long int& curr_idx = names[""]; ++curr_idx; // avoid using index 0, benign skip in some other cases - for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { + for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { instruction& inst = Recipe[r].steps.at(i); // Per-recipe Transforms // map names to addresses - for (index_t in = 0; in < inst.ingredients.size(); ++in) { + for (long long int in = 0; in < SIZE(inst.ingredients); ++in) { if (is_numeric_location(inst.ingredients.at(in))) numeric_locations_used = true; if (is_named_location(inst.ingredients.at(in))) names_used = true; if (disqualified(inst.ingredients.at(in))) continue; @@ -48,7 +48,7 @@ void transform_names(const recipe_number r) { } inst.ingredients.at(in).set_value(lookup_name(inst.ingredients.at(in), r)); } - for (index_t out = 0; out < inst.products.size(); ++out) { + for (long long int out = 0; out < SIZE(inst.products); ++out) { if (is_numeric_location(inst.products.at(out))) numeric_locations_used = true; if (is_named_location(inst.products.at(out))) names_used = true; if (disqualified(inst.products.at(out))) continue; @@ -77,16 +77,16 @@ bool disqualified(/*mutable*/ reagent& x) { return false; } -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(); } -index_t lookup_name(const reagent& r, const recipe_number default_recipe) { +long long int lookup_name(const reagent& r, const recipe_number default_recipe) { return Name[default_recipe][r.name]; } type_number skip_addresses(const vector& types) { - for (index_t i = 0; i < types.size(); ++i) { + for (long long int i = 0; i < SIZE(types); ++i) { if (types.at(i) != Type_number["address"]) return types.at(i); } raise << "expected a container" << '\n' << die(); @@ -95,8 +95,8 @@ 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 (index_t i = 0; i < container.element_names.size(); ++i) { +//? cout << "looking for element " << name << " in type " << container.name << " with " << SIZE(container.element_names) << " elements\n"; //? 1 + for (long long int i = 0; i < SIZE(container.element_names); ++i) { if (container.element_names.at(i) == name) return i; } raise << "unknown element " << name << " in container " << t << '\n' << die(); @@ -118,7 +118,7 @@ bool is_named_location(const reagent& x) { } bool is_raw(const reagent& r) { - for (index_t i = /*skip value+type*/1; i < r.properties.size(); ++i) { + for (long long int i = /*skip value+type*/1; i < SIZE(r.properties); ++i) { if (r.properties.at(i).first == "raw") return true; } return false; @@ -214,10 +214,10 @@ recipe main [ if (inst.operation == Recipe_number["get"] || inst.operation == Recipe_number["get-address"]) { // at least 2 args, and second arg is offset - assert(inst.ingredients.size() >= 2); + assert(SIZE(inst.ingredients) >= 2); //? cout << inst.ingredients.at(1).to_string() << '\n'; //? 1 assert(isa_literal(inst.ingredients.at(1))); - if (inst.ingredients.at(1).name.find_first_not_of("0123456789") == NOT_FOUND) continue; + if (inst.ingredients.at(1).name.find_first_not_of("0123456789") == string::npos) continue; // since first non-address in base type must be a container, we don't have to canonize type_number base_type = skip_addresses(inst.ingredients.at(0).types); inst.ingredients.at(1).set_value(find_element_name(base_type, inst.ingredients.at(1).name)); @@ -251,9 +251,9 @@ recipe main [ // convert variant names of exclusive containers if (inst.operation == Recipe_number["maybe-convert"]) { // at least 2 args, and second arg is offset - assert(inst.ingredients.size() >= 2); + assert(SIZE(inst.ingredients) >= 2); assert(isa_literal(inst.ingredients.at(1))); - if (inst.ingredients.at(1).name.find_first_not_of("0123456789") == NOT_FOUND) continue; + if (inst.ingredients.at(1).name.find_first_not_of("0123456789") == string::npos) continue; // since first non-address in base type must be an exclusive container, we don't have to canonize type_number base_type = skip_addresses(inst.ingredients.at(0).types); inst.ingredients.at(1).set_value(find_element_name(base_type, inst.ingredients.at(1).name)); diff --git a/042new.cc b/042new.cc index 8d90c3e7..7e173b36 100644 --- a/042new.cc +++ b/042new.cc @@ -11,14 +11,14 @@ recipe main [ +mem: storing 0 in location 3 :(before "End Globals") -size_t Reserved_for_tests = 1000; -index_t Memory_allocated_until = Reserved_for_tests; -size_t Initial_memory_per_routine = 100000; +long long int Reserved_for_tests = 1000; +long long int Memory_allocated_until = Reserved_for_tests; +long long int Initial_memory_per_routine = 100000; :(before "End Setup") Memory_allocated_until = Reserved_for_tests; Initial_memory_per_routine = 100000; :(before "End routine Fields") -index_t alloc, alloc_max; +long long int alloc, alloc_max; :(before "End routine Constructor") alloc = Memory_allocated_until; Memory_allocated_until += Initial_memory_per_routine; @@ -33,7 +33,7 @@ Type_number["type"] = 0; // replace type names with type_numbers if (inst.operation == Recipe_number["new"]) { // first arg must be of type 'type' - assert(inst.ingredients.size() >= 1); + assert(SIZE(inst.ingredients) >= 1); //? cout << inst.ingredients.at(0).to_string() << '\n'; //? 1 assert(isa_literal(inst.ingredients.at(0))); if (inst.ingredients.at(0).properties.at(0).second.at(0) == "type") { @@ -52,13 +52,13 @@ Recipe_number["new"] = NEW; :(before "End Primitive Recipe Implementations") case NEW: { // compute the space we need - size_t size = 0; - size_t array_length = 0; + long long int size = 0; + long long int array_length = 0; { vector type; assert(isa_literal(current_instruction().ingredients.at(0))); type.push_back(current_instruction().ingredients.at(0).value); - if (current_instruction().ingredients.size() > 1) { + if (SIZE(current_instruction().ingredients) > 1) { // array array_length = ingredients.at(1).at(0); trace("mem") << "array size is " << array_length; @@ -72,16 +72,16 @@ case NEW: { // compute the region of memory to return // really crappy at the moment ensure_space(size); - const index_t result = Current_routine->alloc; + const long long int result = Current_routine->alloc; trace("mem") << "new alloc: " << result; // save result products.resize(1); products.at(0).push_back(result); // initialize allocated space - for (index_t address = result; address < result+size; ++address) { + for (long long int address = result; address < result+size; ++address) { Memory[address] = 0; } - if (current_instruction().ingredients.size() > 1) { + if (SIZE(current_instruction().ingredients) > 1) { Memory[result] = array_length; } // bump @@ -92,7 +92,7 @@ case NEW: { } :(code) -void ensure_space(size_t size) { +void ensure_space(long long int size) { assert(size <= Initial_memory_per_routine); //? cout << Current_routine->alloc << " " << Current_routine->alloc_max << " " << size << '\n'; //? 1 if (Current_routine->alloc + size > Current_routine->alloc_max) { @@ -169,7 +169,7 @@ recipe main [ if (isa_literal(current_instruction().ingredients.at(0)) && current_instruction().ingredients.at(0).properties.at(0).second.at(0) == "literal-string") { // allocate an array just large enough for it - size_t string_length = current_instruction().ingredients.at(0).name.size(); + long long int string_length = SIZE(current_instruction().ingredients.at(0).name); //? cout << "string_length is " << string_length << '\n'; //? 1 ensure_space(string_length+1); // don't forget the extra location for array size products.resize(1); @@ -177,7 +177,7 @@ if (isa_literal(current_instruction().ingredients.at(0)) // initialize string //? cout << "new string literal: " << current_instruction().ingredients.at(0).name << '\n'; //? 1 Memory[Current_routine->alloc++] = string_length; - for (index_t i = 0; i < string_length; ++i) { + for (long long int i = 0; i < string_length; ++i) { Memory[Current_routine->alloc++] = current_instruction().ingredients.at(0).name.at(i); } // mu strings are not null-terminated in memory diff --git a/043space.cc b/043space.cc index ec63e19a..494e8215 100644 --- a/043space.cc +++ b/043space.cc @@ -26,7 +26,7 @@ recipe main [ +mem: storing 34 in location 8 :(before "End call Fields") -index_t default_space; +long long int 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) {} @@ -93,14 +93,14 @@ tmp.properties.push_back(pair >("raw", vector())) //:: helpers :(code) -index_t space_base(const reagent& x) { +long long int space_base(const reagent& x) { return Current_routine->calls.front().default_space; } -index_t address(index_t offset, index_t base) { +long long int address(long long int offset, long long int base) { if (base == 0) return offset; // raw //? cout << base << '\n'; //? 2 - if (offset >= static_cast(Memory[base])) { + if (offset >= static_cast(Memory[base])) { // todo: test raise << "location " << offset << " is out of bounds " << Memory[base] << '\n'; } @@ -109,7 +109,7 @@ index_t address(index_t offset, index_t base) { :(after "void write_memory(reagent x, vector data)") if (x.name == "default-space") { - assert(data.size() == 1); + assert(scalar(data)); Current_routine->calls.front().default_space = data.at(0); //? cout << "AAA " << Current_routine->calls.front().default_space << '\n'; //? 1 return; diff --git a/044space_surround.cc b/044space_surround.cc index 445be78c..5464c968 100644 --- a/044space_surround.cc +++ b/044space_surround.cc @@ -25,26 +25,26 @@ recipe main [ //: lifetime, surrounding allows managing shorter lifetimes inside a longer //: one. -:(replace{} "index_t space_base(const reagent& x)") -index_t space_base(const reagent& x) { +:(replace{} "long long int space_base(const reagent& x)") +long long int space_base(const reagent& x) { return space_base(x, space_index(x), Current_routine->calls.front().default_space); } -index_t space_base(const reagent& x, index_t space_index, index_t base) { +long long int space_base(const reagent& x, long long int space_index, long long int base) { //? trace("foo") << "base of space " << space_index << '\n'; //? 1 if (space_index == 0) { //? trace("foo") << "base of space " << space_index << " is " << base << '\n'; //? 1 return base; } //? trace("foo") << "base of space " << space_index << " is " << Memory[base+1] << '\n'; //? 1 - index_t result = space_base(x, space_index-1, Memory[base+1]); + long long int result = space_base(x, space_index-1, Memory[base+1]); return result; } -index_t space_index(const reagent& x) { - for (index_t i = 0; i < x.properties.size(); ++i) { +long long int space_index(const reagent& x) { + for (long long int i = 0; i < SIZE(x.properties); ++i) { if (x.properties.at(i).first == "space") { - assert(x.properties.at(i).second.size() == 1); + assert(SIZE(x.properties.at(i).second) == 1); return to_integer(x.properties.at(i).second.at(0)); } } diff --git a/045closure_name.cc b/045closure_name.cc index 5af737d0..237eee3c 100644 --- a/045closure_name.cc +++ b/045closure_name.cc @@ -42,13 +42,13 @@ map Surrounding_space; :(code) void collect_surrounding_spaces(const recipe_number r) { - for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { + for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { const instruction& inst = Recipe[r].steps.at(i); if (inst.is_label) continue; - for (index_t j = 0; j < inst.products.size(); ++j) { + for (long long int j = 0; j < SIZE(inst.products); ++j) { if (isa_literal(inst.products.at(j))) continue; if (inst.products.at(j).name != "0") continue; - if (inst.products.at(j).types.size() != 3 + if (SIZE(inst.products.at(j).types) != 3 || inst.products.at(j).types.at(0) != Type_number["address"] || inst.products.at(j).types.at(1) != Type_number["array"] || inst.products.at(j).types.at(2) != Type_number["location"]) { @@ -58,7 +58,7 @@ void collect_surrounding_spaces(const recipe_number r) { vector s = property(inst.products.at(j), "names"); if (s.empty()) raise << "slot 0 requires a /names property in recipe " << Recipe[r].name << die(); - if (s.size() > 1) raise << "slot 0 should have a single value in /names, got " << inst.products.at(j).to_string() << '\n'; + if (SIZE(s) > 1) raise << "slot 0 should have a single value in /names, got " << inst.products.at(j).to_string() << '\n'; string surrounding_recipe_name = s.at(0); if (Surrounding_space.find(r) != Surrounding_space.end() && Surrounding_space[r] != Recipe_number[surrounding_recipe_name]) { @@ -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{} "index_t lookup_name(const reagent& r, const recipe_number default_recipe)") -index_t lookup_name(const reagent& x, const recipe_number default_recipe) { +:(replace{} "long long int lookup_name(const reagent& r, const recipe_number default_recipe)") +long long int 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")) { @@ -83,7 +83,7 @@ index_t lookup_name(const reagent& x, const recipe_number default_recipe) { return Name[default_recipe][x.name]; } vector p = property(x, "space"); - if (p.size() != 1) raise << "/space property should have exactly one (non-negative integer) value\n"; + if (SIZE(p) != 1) raise << "/space property should have exactly one (non-negative integer) value\n"; long long int n = to_integer(p.at(0)); assert(n >= 0); recipe_number surrounding_recipe = lookup_surrounding_recipe(default_recipe, n); @@ -94,14 +94,14 @@ index_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. -index_t lookup_name(const reagent& x, const recipe_number r, set& done, vector& path) { +long long int 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 (index_t i = 1; i < path.size(); ++i) { + for (long long int i = 1; i < SIZE(path); ++i) { raise << path.at(i-1) << " requires computing names of " << path.at(i) << '\n'; } - raise << path.at(path.size()-1) << " requires computing names of " << r << "..ad infinitum\n" << die(); + raise << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << die(); return 0; } done.insert(r); @@ -111,7 +111,7 @@ index_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, index_t n) { +recipe_number lookup_surrounding_recipe(const recipe_number r, long long int 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,11 +122,11 @@ recipe_number lookup_surrounding_recipe(const recipe_number r, index_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); + assert(SIZE(p) == 1); if (p.at(0) != "0") return true; } return names.find(r.name) != names.end(); diff --git a/046tangle.cc b/046tangle.cc index d77eecf1..2b650e3d 100644 --- a/046tangle.cc +++ b/046tangle.cc @@ -48,7 +48,7 @@ void insert_fragments(const recipe_number r) { // Copy into a new vector because insertions invalidate iterators. // But this way we can't insert into labels created inside before/after. vector result; - for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { + for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { const instruction inst = Recipe[r].steps.at(i); if (!inst.is_label) { result.push_back(inst); @@ -62,7 +62,7 @@ void insert_fragments(const recipe_number r) { result.insert(result.end(), After_fragments[inst.label].steps.begin(), After_fragments[inst.label].steps.end()); } } -//? for (index_t i = 0; i < result.size(); ++i) { //? 1 +//? for (long long int i = 0; i < SIZE(result); ++i) { //? 1 //? cout << result.at(i).to_string() << '\n'; //? 1 //? } //? 1 Recipe[r].steps.swap(result); diff --git a/047jump_label.cc b/047jump_label.cc index 81a9d123..4ec31341 100644 --- a/047jump_label.cc +++ b/047jump_label.cc @@ -18,12 +18,12 @@ Type_number["label"] = 0; :(code) void transform_labels(const recipe_number r) { - map offset; - for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { + map offset; + for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { const instruction& inst = Recipe[r].steps.at(i); if (!inst.label.empty()) offset[inst.label] = i; } - for (index_t i = 0; i < Recipe[r].steps.size(); ++i) { + for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { instruction& inst = Recipe[r].steps.at(i); if (inst.operation == Recipe_number["jump"]) { //? cerr << inst.to_string() << '\n'; //? 1 @@ -33,19 +33,19 @@ void transform_labels(const recipe_number r) { replace_offset(inst.ingredients.at(1), offset, i, r); } if ((inst.operation == Recipe_number["loop"] || inst.operation == Recipe_number["break"]) - && inst.ingredients.size() == 1) { + && SIZE(inst.ingredients) == 1) { replace_offset(inst.ingredients.at(0), offset, i, r); } if ((inst.operation == Recipe_number["loop-if"] || inst.operation == Recipe_number["loop-unless"] || inst.operation == Recipe_number["break-if"] || inst.operation == Recipe_number["break-unless"]) - && inst.ingredients.size() == 2) { + && SIZE(inst.ingredients) == 2) { replace_offset(inst.ingredients.at(1), offset, i, r); } } } :(code) -void replace_offset(reagent& x, /*const*/ map& offset, const index_t current_offset, const recipe_number r) { +void replace_offset(reagent& x, /*const*/ map& offset, const long long int current_offset, const recipe_number r) { //? cerr << "AAA " << x.to_string() << '\n'; //? 1 assert(isa_literal(x)); //? cerr << "BBB " << x.to_string() << '\n'; //? 1 diff --git a/048continuation.cc b/048continuation.cc index 80c9293d..87cf12e3 100644 --- a/048continuation.cc +++ b/048continuation.cc @@ -7,8 +7,8 @@ //: todo: implement continuations in mu's memory :(before "End Globals") -map Continuation; -index_t Next_continuation_id = 0; +map Continuation; +long long int Next_continuation_id = 0; :(before "End Setup") Continuation.clear(); Next_continuation_id = 0; @@ -36,8 +36,8 @@ CONTINUE_FROM, Recipe_number["continue-from"] = CONTINUE_FROM; :(before "End Primitive Recipe Implementations") case CONTINUE_FROM: { - assert(ingredients.at(0).size() == 1); // scalar - index_t c = ingredients.at(0).at(0); + assert(scalar(ingredients.at(0))); + long long int c = ingredients.at(0).at(0); Current_routine->calls = Continuation[c]; // deep copy because calls have no pointers // refresh instruction_counter to next instruction after current-continuation instruction_counter = current_step_index()+1; diff --git a/050scenario.cc b/050scenario.cc index b43aea57..ee6485a9 100644 --- a/050scenario.cc +++ b/050scenario.cc @@ -86,7 +86,7 @@ scenario parse_scenario(istream& in) { :(before "End Tests") time_t mu_time; time(&mu_time); cerr << "\nMu tests: " << ctime(&mu_time); -for (index_t i = 0; i < Scenarios.size(); ++i) { +for (long long int i = 0; i < SIZE(Scenarios); ++i) { //? cerr << Passed << '\n'; //? 1 //? cerr << i << ": " << Scenarios.at(i).name << '\n'; //? 3 run_mu_scenario(Scenarios.at(i)); @@ -96,7 +96,7 @@ for (index_t i = 0; i < Scenarios.size(); ++i) { //: Convenience: run a single named scenario. :(before "Loading Commandline Files") if (argc == 2 && Run_tests) { - for (index_t i = 0; i < Scenarios.size(); ++i) { + for (long long int i = 0; i < SIZE(Scenarios); ++i) { if (Scenarios.at(i).name == argv[1]) { run_mu_scenario(Scenarios.at(i)); return 0; @@ -202,7 +202,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; @@ -240,7 +240,7 @@ void check_type(const string& lhs, istream& in) { assert(_assign == "<-"); skip_whitespace_and_comments(in); string literal = next_word(in); - index_t address = x.value; + long long int address = x.value; // exclude quoting brackets assert(*literal.begin() == '['); literal.erase(literal.begin()); assert(*--literal.end() == ']'); literal.erase(--literal.end()); @@ -250,12 +250,12 @@ void check_type(const string& lhs, istream& in) { raise << "don't know how to check memory for " << lhs << '\n'; } -void check_string(index_t address, const string& literal) { +void check_string(long long int 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'; + if (Memory[address] != SIZE(literal)) + raise << "expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << Memory[address] << '\n'; ++address; // now skip length - for (index_t i = 0; i < literal.size(); ++i) { + for (long long int i = 0; i < SIZE(literal); ++i) { trace("run") << "checking location " << address+i; if (Memory[address+i] != literal.at(i)) raise << "expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << Memory[address+i] << '\n'; @@ -337,15 +337,15 @@ bool check_trace(const string& expected) { //? cerr << "AAA " << expected << '\n'; //? 1 Trace_stream->newline(); vector > expected_lines = parse_trace(expected); -//? cerr << "BBB " << expected_lines.size() << '\n'; //? 1 +//? cerr << "BBB " << SIZE(expected_lines) << '\n'; //? 1 if (expected_lines.empty()) return true; - index_t curr_expected_line = 0; + long long int curr_expected_line = 0; for (vector > >::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { if (expected_lines.at(curr_expected_line).first != p->first) continue; if (expected_lines.at(curr_expected_line).second != p->second.second) continue; // match ++curr_expected_line; - if (curr_expected_line == expected_lines.size()) { + if (curr_expected_line == SIZE(expected_lines)) { //? cerr << "ZZZ\n"; //? 1 return true; } @@ -360,10 +360,10 @@ bool check_trace(const string& expected) { vector > parse_trace(const string& expected) { vector buf = split(expected, "\n"); vector > result; - for (index_t i = 0; i < buf.size(); ++i) { + for (long long int i = 0; i < SIZE(buf); ++i) { buf.at(i) = trim(buf.at(i)); if (buf.at(i).empty()) continue; - index_t delim = buf.at(i).find(": "); + long long int delim = buf.at(i).find(": "); result.push_back(pair(buf.at(i).substr(0, delim), buf.at(i).substr(delim+2))); } return result; @@ -426,7 +426,7 @@ case TRACE_SHOULD_NOT_CONTAIN: { bool check_trace_missing(const string& in) { Trace_stream->newline(); vector > lines = parse_trace(in); - for (index_t i = 0; i < lines.size(); ++i) { + for (long long int i = 0; i < SIZE(lines); ++i) { if (trace_count(lines.at(i).first, lines.at(i).second) != 0) { raise << "unexpected [" << lines.at(i).second << "] in trace layer " << lines.at(i).first << '\n'; Passed = false; diff --git a/070display.cc b/070display.cc index b93731ab..2a2c51a7 100644 --- a/070display.cc +++ b/070display.cc @@ -7,7 +7,7 @@ //:: Display management :(before "End Globals") -index_t Display_row = 0, Display_column = 0; +long long int Display_row = 0, Display_column = 0; :(before "End Primitive Recipe Declarations") SWITCH_TO_DISPLAY, @@ -51,8 +51,8 @@ CLEAR_LINE_ON_DISPLAY, 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 (index_t x = Display_column; x < width; ++x) { + long long int width = tb_width(); + for (long long int x = Display_column; x < width; ++x) { tb_change_cell(x, Display_row, ' ', TB_WHITE, TB_DEFAULT); } tb_set_cursor(Display_column, Display_row); @@ -67,9 +67,9 @@ Recipe_number["print-character-to-display"] = PRINT_CHARACTER_TO_DISPLAY; :(before "End Primitive Recipe Implementations") case PRINT_CHARACTER_TO_DISPLAY: { int h=tb_height(), w=tb_width(); - size_t height = (h >= 0) ? h : 0; - size_t width = (w >= 0) ? w : 0; - assert(ingredients.at(0).size() == 1); // scalar + long long int height = (h >= 0) ? h : 0; + long long int width = (w >= 0) ? w : 0; + assert(scalar(ingredients.at(0))); long long int c = ingredients.at(0).at(0); if (c == '\n' || c == '\r') { if (Display_row < height-1) { @@ -116,9 +116,9 @@ MOVE_CURSOR_ON_DISPLAY, Recipe_number["move-cursor-on-display"] = MOVE_CURSOR_ON_DISPLAY; :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_ON_DISPLAY: { - assert(ingredients.at(0).size() == 1); // scalar + assert(scalar(ingredients.at(0))); Display_row = ingredients.at(0).at(0); - assert(ingredients.at(1).size() == 1); // scalar + assert(scalar(ingredients.at(1))); Display_column = ingredients.at(1).at(0); tb_set_cursor(Display_column, Display_row); tb_present(); @@ -132,7 +132,7 @@ Recipe_number["move-cursor-down-on-display"] = MOVE_CURSOR_DOWN_ON_DISPLAY; :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_DOWN_ON_DISPLAY: { int h=tb_height(); - size_t height = (h >= 0) ? h : 0; + long long int height = (h >= 0) ? h : 0; if (Display_row < height-1) { Display_row++; tb_set_cursor(Display_column, Display_row); @@ -162,7 +162,7 @@ Recipe_number["move-cursor-right-on-display"] = MOVE_CURSOR_RIGHT_ON_DISPLAY; :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_RIGHT_ON_DISPLAY: { int w=tb_width(); - size_t width = (w >= 0) ? w : 0; + long long int width = (w >= 0) ? w : 0; if (Display_column < width-1) { Display_column++; tb_set_cursor(Display_column, Display_row); diff --git a/072scenario_screen.cc b/072scenario_screen.cc index 4f2cfd0a..72b9bad3 100644 --- a/072scenario_screen.cc +++ b/072scenario_screen.cc @@ -41,8 +41,8 @@ scenario screen-in-scenario-error [ // Scenarios may not define default-space, so they should fit within the // initial area of memory reserved for tests. We'll put the predefined // variables available to them at the end of that region. -const size_t Max_variables_in_scenarios = Reserved_for_tests-100; -size_t Next_predefined_global_for_scenarios = Max_variables_in_scenarios; +const long long int Max_variables_in_scenarios = Reserved_for_tests-100; +long long int Next_predefined_global_for_scenarios = Max_variables_in_scenarios; :(before "End Setup") assert(Next_predefined_global_for_scenarios < Reserved_for_tests); :(after "transform_all()" following "case RUN:") @@ -53,7 +53,7 @@ assert(Name[tmp_recipe.at(0)][""] < Max_variables_in_scenarios); :(before "End Globals") // Scenario Globals. -const size_t SCREEN = Next_predefined_global_for_scenarios++; +const long long int SCREEN = Next_predefined_global_for_scenarios++; // End Scenario Globals. :(before "End Predefined Scenario Locals In Run") Name[tmp_recipe.at(0)]["screen"] = SCREEN; @@ -87,23 +87,23 @@ case SCREEN_SHOULD_CONTAIN: { void check_screen(const string& contents) { //? cerr << "Checking screen\n"; //? 1 assert(!Current_routine->calls.front().default_space); // not supported - index_t screen_location = Memory[SCREEN]; + long long int screen_location = Memory[SCREEN]; int data_offset = find_element_name(Type_number["screen"], "data"); assert(data_offset >= 0); - 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 + long long int screen_data_location = screen_location+data_offset; // type: address:array:character + long long int 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]; + long long int screen_width = Memory[screen_location+width_offset]; int height_offset = find_element_name(Type_number["screen"], "num-rows"); - size_t screen_height = Memory[screen_location+height_offset]; + long long int screen_height = Memory[screen_location+height_offset]; string expected_contents; istringstream in(contents); in >> std::noskipws; - for (index_t row = 0; row < screen_height; ++row) { + for (long long int row = 0; row < screen_height; ++row) { skip_whitespace_and_comments(in); assert(!in.eof()); assert(in.get() == '.'); - for (index_t column = 0; column < screen_width; ++column) { + for (long long int column = 0; column < screen_width; ++column) { assert(!in.eof()); expected_contents += in.get(); } @@ -112,11 +112,11 @@ void check_screen(const string& contents) { skip_whitespace_and_comments(in); //? assert(in.get() == ']'); trace("run") << "checking screen size at " << screen_data_start; -//? cout << expected_contents.size() << '\n'; //? 1 - if (Memory[screen_data_start] > static_cast(expected_contents.size())) +//? cout << SIZE(expected_contents) << '\n'; //? 1 + if (Memory[screen_data_start] > SIZE(expected_contents)) raise << "expected contents are larger than screen size " << Memory[screen_data_start] << '\n'; ++screen_data_start; // now skip length - for (index_t i = 0; i < expected_contents.size(); ++i) { + for (long long int i = 0; i < SIZE(expected_contents); ++i) { trace("run") << "checking location " << screen_data_start+i; //? cerr << "comparing " << i/screen_width << ", " << i%screen_width << ": " << Memory[screen_data_start+i] << " vs " << (int)expected_contents.at(i) << '\n'; //? 1 if ((!Memory[screen_data_start+i] && !isspace(expected_contents.at(i))) // uninitialized memory => spaces @@ -153,21 +153,21 @@ case _DUMP_SCREEN: { :(code) void dump_screen() { assert(!Current_routine->calls.front().default_space); // not supported - index_t screen_location = Memory[SCREEN]; + long long int screen_location = Memory[SCREEN]; int width_offset = find_element_name(Type_number["screen"], "num-columns"); - size_t screen_width = Memory[screen_location+width_offset]; + long long int screen_width = Memory[screen_location+width_offset]; int height_offset = find_element_name(Type_number["screen"], "num-rows"); - size_t screen_height = Memory[screen_location+height_offset]; + long long int screen_height = Memory[screen_location+height_offset]; int data_offset = find_element_name(Type_number["screen"], "data"); assert(data_offset >= 0); - 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 + long long int screen_data_location = screen_location+data_offset; // type: address:array:character + long long int screen_data_start = Memory[screen_data_location]; // type: array:character //? cerr << "data start: " << screen_data_start << '\n'; //? 1 assert(Memory[screen_data_start] == screen_width*screen_height); - index_t curr = screen_data_start+1; // skip length - for (index_t row = 0; row < screen_height; ++row) { + long long int curr = screen_data_start+1; // skip length + for (long long int row = 0; row < screen_height; ++row) { //? cerr << curr << ":\n"; //? 1 - for (index_t col = 0; col < screen_width; ++col) { + for (long long int col = 0; col < screen_width; ++col) { cerr << static_cast(Memory[curr]); ++curr; } diff --git a/075scenario_keyboard.cc b/075scenario_keyboard.cc index 039f10c8..ceea12c9 100644 --- a/075scenario_keyboard.cc +++ b/075scenario_keyboard.cc @@ -26,7 +26,7 @@ scenario keyboard-in-scenario [ ] :(before "End Scenario Globals") -const size_t KEYBOARD = Next_predefined_global_for_scenarios++; +const long long int KEYBOARD = Next_predefined_global_for_scenarios++; :(before "End Predefined Scenario Locals In Run") Name[tmp_recipe.at(0)]["keyboard"] = KEYBOARD; -- cgit 1.4.1-2-gfad0