akkartik
/
mu
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

1391 - avoid unsigned integers

This commit is contained in:
Kartik K. Agaram 2015-05-17 02:22:41 -07:00
parent 6f8f9fb53b
commit ac0e9db526
37 changed files with 365 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
001help.cc
View File

@ -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<long long int>(X.size())
:(before "End Includes")
#include<assert.h>
@ -43,8 +74,3 @@ using std::cerr;
#include<cstring>
#include<string>
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));

6
002test.cc
View File

@ -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) {

50
003trace.cc
View File

@ -215,10 +215,10 @@ void trace_all(const string& label, const list<string>& in) {
bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) { // missing layer == anywhere, frame, hierarchical layers
vector<string> 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<string> 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<string> layers = split(layer, ",");
for (vector<pair<string, pair<int, string> > >::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<string> 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<string> layers = split(layer, ",");
for (vector<pair<string, pair<int, string> > >::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<string> split(string s, string delim) {
vector<string> 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();
}

28
010vm.cc
View File

@ -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<string, recipe_number> Recipe_number;
map<recipe_number, recipe> Recipe;
@ -57,7 +57,7 @@ struct property {
:(before "End Globals")
// Locations refer to a common 'memory'. Each location can store a number.
map<index_t, double> Memory;
map<long long int, double> 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<string, type_number> Type_number;
map<type_number, type_info> 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<vector<type_number> > elements;
vector<string> 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<index_t, double>::iterator p = Memory.begin(); p != Memory.end(); ++p) {
for (map<long long int, double>::iterator p = Memory.begin(); p != Memory.end(); ++p) {
cout << p->first << ": " << p->second << '\n';
}
}

8
011load.cc
View File

@ -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<recipe_number> 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));

10
012transform.cc
View File

@ -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_fn> 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<recipe_number, recipe>::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<recipe_number, recipe>::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));
}
}

2
013literal_string.cc
View File

@ -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<string, vector<string> >(name, vector<string>()));

4
014literal_noninteger.cc
View File

@ -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) {

32
020run.cc
View File

@ -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<vector<double> > 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<vector<double> > 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<double> 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<double> read_memory(reagent x) {
void write_memory(reagent x, vector<double> 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<type_number>& types) {
long long int size_of(const vector<type_number>& 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)

28
021arithmetic.cc
View File

@ -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<long long int>& x) {
return SIZE(x) == 1;
}
inline bool scalar(vector<double>& x) {
return SIZE(x) == 1;
}

12
022boolean.cc
View File

@ -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;

16
023jump.cc
View File

@ -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;

26
024compare.cc
View File

@ -8,7 +8,7 @@ Recipe_number["equal"] = EQUAL;
case EQUAL: {
vector<double>& 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;
}

4
026assert.cc
View File

@ -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();

4
027debug.cc
View File

@ -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);

32
030container.cc
View File

@ -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<type_number> 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));

12
031address.cc
View File

@ -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<double> read_memory(reagent x)")
:(before "long long int base = x.value" following "vector<double> 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<double> data)")
:(before "long long int base = x.value" following "void write_memory(reagent x, vector<double> 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<string> 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;
}

16
032array.cc
View File

@ -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<double> 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<double> 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<type_number> 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<double> offset_val(read_memory(offset));
vector<type_number> 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;

20
034exclusive_container.cc
View File

@ -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<type_number> 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<type_number> 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<index_t>(Memory[base_address])) {
if (tag == static_cast<long long int>(Memory[base_address])) {
result = base_address+1;
}
else {

8
035call.cc
View File

@ -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<instruction>& 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

16
036call_ingredient.cc
View File

@ -24,13 +24,13 @@ recipe f [
:(before "End call Fields")
vector<vector<double> > 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<index_t>(ingredients.at(0).at(0)) < Current_routine->calls.front().ingredient_atoms.size()) {
assert(scalar(ingredients.at(0)));
if (static_cast<long long int>(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);

8
037call_reply.cc
View File

@ -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<string> 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<double>& 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);
}

52
038scheduler.cc
View File

@ -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<routine*> 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;

20
039wait.cc
View File

@ -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);

16
040brace.cc
View File

@ -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<pair<int/*OPEN/CLOSE*/, /*step*/long long int> > braces;
for (long long int index = 0; index < static_cast<long long int>(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</*step*/long long int> open_braces;
trace("after-brace") << "recipe " << Recipe[r].name;
for (long long int index = 0; index < static_cast<long long int>(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";
}

34
041name.cc
View File

@ -21,9 +21,9 @@ recipe main [
Transform.push_back(transform_names);
:(before "End Globals")
map<recipe_number, map<string, index_t> > Name;
map<recipe_number, map<string, long long int> > 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<string, index_t>& names = Name[r];
map<string, long long int>& 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<string, index_t>& names) {
bool already_transformed(const reagent& r, const map<string, long long int>& 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<type_number>& 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<type_number>& 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));

28
042new.cc
View File

@ -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_number> 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

10
043space.cc
View File

@ -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<string, vector<string> >("raw", vector<string>()))
//:: 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<index_t>(Memory[base])) {
if (offset >= static_cast<long long int>(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<double> 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;

14
044space_surround.cc
View File

@ -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));
}
}

28
045closure_name.cc
View File

@ -42,13 +42,13 @@ map<recipe_number, recipe_number> 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<string> 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<string> 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<recipe_number>& done, vector<recipe_number>& path) {
long long int lookup_name(const reagent& x, const recipe_number r, set<recipe_number>& done, vector<recipe_number>& 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<recipe_number>&
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<string, index_t>& names)")
bool already_transformed(const reagent& r, const map<string, index_t>& names) {
:(replace{} "bool already_transformed(const reagent& r, const map<string, long long int>& names)")
bool already_transformed(const reagent& r, const map<string, long long int>& names) {
if (has_property(r, "space")) {
vector<string> 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();

4
046tangle.cc
View File

@ -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<instruction> 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);

12
047jump_label.cc
View File

@ -18,12 +18,12 @@ Type_number["label"] = 0;
:(code)
void transform_labels(const recipe_number r) {
map<string, index_t> offset;
for (index_t i = 0; i < Recipe[r].steps.size(); ++i) {
map<string, long long int> 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<string, index_t>& offset, const index_t current_offset, const recipe_number r) {
void replace_offset(reagent& x, /*const*/ map<string, long long int>& 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

8
048continuation.cc
View File

@ -7,8 +7,8 @@
//: todo: implement continuations in mu's memory
:(before "End Globals")
map<index_t, call_stack> Continuation;
index_t Next_continuation_id = 0;
map<long long int, call_stack> 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;

28
050scenario.cc
View File

@ -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<index_t> locations_checked;
set<long long int> 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<signed>(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<pair<string, string> > 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<pair<string, pair<int, string> > >::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<pair<string, string> > parse_trace(const string& expected) {
vector<string> buf = split(expected, "\n");
vector<pair<string, string> > 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<string, string>(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<pair<string, string> > 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;

20
070display.cc
View File

@ -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);

42
072scenario_screen.cc
View File

@ -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<signed>(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<char>(Memory[curr]);
++curr;
}

2
075scenario_keyboard.cc
View File

@ -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;