diff options
Diffstat (limited to '010vm.cc')
| -rw-r--r-- | 010vm.cc | 900 |
1 files changed, 0 insertions, 900 deletions
diff --git a/010vm.cc b/010vm.cc deleted file mode 100644 index 42b867fc..00000000 --- a/010vm.cc +++ /dev/null @@ -1,900 +0,0 @@ -//: A Mu program is a book of 'recipes' (functions) -:(before "End Globals") -//: Each recipe is stored at a specific page number, or ordinal. -map<recipe_ordinal, recipe> Recipe; -//: You can also refer to each recipe by its name. -map<string, recipe_ordinal> Recipe_ordinal; -recipe_ordinal Next_recipe_ordinal = 1; - -//: Ordinals are like numbers, except you can't do arithmetic on them. Ordinal -//: 1 is not less than 2, it's just different. Phone numbers are ordinals; -//: adding two phone numbers is meaningless. Here each recipe does something -//: incommensurable with any other recipe. -:(after "Types") -typedef int recipe_ordinal; - -:(before "End Types") -// Recipes are lists of instructions. To perform or 'run' a recipe, the -// computer runs its instructions. -struct recipe { - recipe_ordinal ordinal; - string name; - vector<instruction> steps; - // End recipe Fields - recipe(); -}; - -:(before "struct recipe") -// Each instruction is either of the form: -// product1, product2, product3, ... <- operation ingredient1, ingredient2, ingredient3, ... -// or just a single 'label' starting with a non-alphanumeric character -// +label -// Labels don't do anything, they're just named locations in a recipe. -struct instruction { - bool is_label; - string label; // only if is_label - string name; // only if !is_label - string original_string; // for error messages - recipe_ordinal operation; // get(Recipe_ordinal, name) - vector<reagent> ingredients; // only if !is_label - vector<reagent> products; // only if !is_label - // End instruction Fields - instruction(); - void clear(); - bool is_empty(); -}; - -:(before "struct instruction") -// Ingredients and products are a single species -- a reagent. Reagents refer -// either to numbers or to locations in memory along with 'type' tags telling -// us how to interpret them. They also can contain arbitrary other lists of -// properties besides types, but we're getting ahead of ourselves. -struct reagent { - string original_string; - string name; - type_tree* type; - vector<pair<string, string_tree*> > properties; // can't be a map because the string_tree sometimes needs to be NULL, which can be confusing - double value; - bool initialized; - // End reagent Fields - reagent(const string& s); - reagent() :type(NULL), value(0), initialized(false) {} - reagent(type_tree* t) :type(t), value(0), initialized(false) {} - ~reagent(); - void clear(); - reagent(const reagent& original); - reagent& operator=(const reagent& original); - void set_value(double v) { value = v; initialized = true; } -}; - -:(before "struct reagent") -// Types can range from a simple type ordinal, to arbitrarily complex trees of -// type parameters, like (map (address array character) (list number)) -struct type_tree { - bool atom; - string name; // only if atom - type_ordinal value; // only if atom - type_tree* left; // only if !atom - type_tree* right; // only if !atom - ~type_tree(); - type_tree(const type_tree& original); - // atomic type ordinal - explicit type_tree(string name); - type_tree(string name, type_ordinal v) :atom(true), name(name), value(v), left(NULL), right(NULL) {} - // tree of type ordinals - type_tree(type_tree* l, type_tree* r) :atom(false), value(0), left(l), right(r) {} - type_tree& operator=(const type_tree& original); - bool operator==(const type_tree& other) const; - bool operator!=(const type_tree& other) const { return !operator==(other); } - bool operator<(const type_tree& other) const; - bool operator>(const type_tree& other) const { return other.operator<(*this); } -}; - -struct string_tree { - bool atom; - string value; // only if atom - string_tree* left; // only if !atom - string_tree* right; // only if !atom - ~string_tree(); - string_tree(const string_tree& original); - // atomic string - explicit string_tree(string v) :atom(true), value(v), left(NULL), right(NULL) {} - // tree of strings - string_tree(string_tree* l, string_tree* r) :atom(false), left(l), right(r) {} -}; - -// End type_tree Definition -:(code) -type_tree::type_tree(string name) :atom(true), name(name), value(get(Type_ordinal, name)), left(NULL), right(NULL) {} - -:(before "End Globals") -// Locations refer to a common 'memory'. Each location can store a number. -map<int, double> Memory; -:(before "End Reset") -Memory.clear(); - -:(after "Types") -// Mu types encode how the numbers stored in different parts of memory are -// interpreted. A location tagged as a 'character' type will interpret the -// value 97 as the letter 'a', while a different location of type 'number' -// would not. -// -// 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 int type_ordinal; -:(before "End Globals") -map<string, type_ordinal> Type_ordinal; -map<type_ordinal, type_info> Type; -type_ordinal Next_type_ordinal = 1; -type_ordinal Number_type_ordinal = 0; -type_ordinal Boolean_type_ordinal = 0; -type_ordinal Character_type_ordinal = 0; -type_ordinal Address_type_ordinal = 0; -type_ordinal Array_type_ordinal = 0; -:(code) -void setup_types() { - Type.clear(); Type_ordinal.clear(); - put(Type_ordinal, "literal", 0); - Next_type_ordinal = 1; - // Mu Types Initialization - Number_type_ordinal = put(Type_ordinal, "number", Next_type_ordinal++); - get_or_insert(Type, Number_type_ordinal).name = "number"; - put(Type_ordinal, "location", Number_type_ordinal); // synonym of number for addresses we'll never look up - Address_type_ordinal = put(Type_ordinal, "address", Next_type_ordinal++); - get_or_insert(Type, Address_type_ordinal).name = "address"; - Boolean_type_ordinal = put(Type_ordinal, "boolean", Next_type_ordinal++); - get_or_insert(Type, Boolean_type_ordinal).name = "boolean"; - Character_type_ordinal = put(Type_ordinal, "character", Next_type_ordinal++); - get_or_insert(Type, Character_type_ordinal).name = "character"; - // Array types are a special modifier to any other type. For example, - // array:number or array:address:boolean. - Array_type_ordinal = put(Type_ordinal, "array", Next_type_ordinal++); - get_or_insert(Type, Array_type_ordinal).name = "array"; - // End Mu Types Initialization -} -void teardown_types() { - for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) { - for (int i = 0; i < SIZE(p->second.elements); ++i) - p->second.elements.clear(); - } - Type_ordinal.clear(); -} -:(before "End One-time Setup") -setup_types(); -atexit(teardown_types); - -:(before "End Types") -// You can construct arbitrary new types. New types are either 'containers' -// with multiple 'elements' of other types, or 'exclusive containers' containing -// one of multiple 'variants'. (These are similar to C structs and unions, -// respectively, though exclusive containers implicitly include a tag element -// recording which variant they should be interpreted as.) -// -// For example, storing bank balance and name for an account might require a -// container, but if bank accounts may be either for individuals or groups, -// with different properties for each, that may require an exclusive container -// whose variants are individual-account and joint-account containers. -enum kind_of_type { - PRIMITIVE, - CONTAINER, - EXCLUSIVE_CONTAINER -}; - -struct type_info { - string name; - kind_of_type kind; - vector<reagent> elements; - // End type_info Fields - type_info() :kind(PRIMITIVE) { - // End type_info Constructor - } -}; - -enum primitive_recipes { - IDLE = 0, - COPY, - // End Primitive Recipe Declarations - MAX_PRIMITIVE_RECIPES, -}; -:(code) -//: It's all very well to construct recipes out of other recipes, but we need -//: to know how to do *something* out of the box. For the following -//: recipes there are only codes, no entries in the book, because Mu just knows -//: what to do for them. -void setup_recipes() { - Recipe.clear(); Recipe_ordinal.clear(); - put(Recipe_ordinal, "idle", IDLE); - // Primitive Recipe Numbers - put(Recipe_ordinal, "copy", COPY); - // End Primitive Recipe Numbers -} -//: We could just reset the recipe table after every test, but that gets slow -//: all too quickly. Instead, initialize the common stuff just once at -//: startup. Later layers will carefully undo each test's additions after -//: itself. -:(before "End One-time Setup") -setup_recipes(); -assert(MAX_PRIMITIVE_RECIPES < 200); // level 0 is primitives; until 199 -Next_recipe_ordinal = 200; -put(Recipe_ordinal, "main", Next_recipe_ordinal++); -// Load Mu Prelude -// End Mu Prelude -:(before "End Commandline Parsing") -assert(Next_recipe_ordinal < 1000); // recipes being tested didn't overflow into test space -:(before "End Reset") -Next_recipe_ordinal = 1000; // consistent new numbers for each test - -//: One final detail: tests can modify our global tables of recipes and types, -//: so we need some way to clean up after each test is done so it doesn't -//: influence later ones. -:(before "End Globals") -map<string, recipe_ordinal> Recipe_ordinal_snapshot; -map<recipe_ordinal, recipe> Recipe_snapshot; -map<string, type_ordinal> Type_ordinal_snapshot; -map<type_ordinal, type_info> Type_snapshot; -:(before "End One-time Setup") -save_snapshots(); -:(before "End Reset") -restore_snapshots(); - -:(code) -void save_snapshots() { - Recipe_ordinal_snapshot = Recipe_ordinal; - Recipe_snapshot = Recipe; - Type_ordinal_snapshot = Type_ordinal; - Type_snapshot = Type; - // End save_snapshots -} - -void restore_snapshots() { - Recipe = Recipe_snapshot; - Recipe_ordinal = Recipe_ordinal_snapshot; - restore_non_recipe_snapshots(); -} -// when running sandboxes in the edit/ app we'll want to restore everything except recipes defined in the app -void restore_non_recipe_snapshots() { - Type_ordinal = Type_ordinal_snapshot; - Type = Type_snapshot; - // End restore_snapshots -} - -//:: Helpers - -:(code) -recipe::recipe() { - ordinal = -1; - // End recipe Constructor -} - -instruction::instruction() :is_label(false), operation(IDLE) { - // End instruction Constructor -} -void instruction::clear() { - is_label=false; - label.clear(); - name.clear(); - operation=IDLE; - ingredients.clear(); - products.clear(); - original_string.clear(); - // End instruction Clear -} -bool instruction::is_empty() { return !is_label && name.empty(); } - -// Reagents have the form <name>:<type>:<type>:.../<property>/<property>/... -reagent::reagent(const string& s) :original_string(s), type(NULL), value(0), initialized(false) { - // Parsing reagent(string s) - istringstream in(s); - in >> std::noskipws; - // name and type - istringstream first_row(slurp_until(in, '/')); - first_row >> std::noskipws; - name = slurp_until(first_row, ':'); - string_tree* type_names = parse_property_list(first_row); - // End Parsing Reagent Type Property(type_names) - type = new_type_tree(type_names); - delete type_names; - // special cases - if (is_integer(name) && type == NULL) - type = new type_tree("literal"); - if (name == "_" && type == NULL) - type = new type_tree("literal"); - // other properties - slurp_properties(in, properties); - // End Parsing reagent -} - -void slurp_properties(istream& in, vector<pair<string, string_tree*> >& out) { - while (has_data(in)) { - istringstream row(slurp_until(in, '/')); - row >> std::noskipws; - string key = slurp_until(row, ':'); - string_tree* value = parse_property_list(row); - out.push_back(pair<string, string_tree*>(key, value)); - } -} - -string_tree* parse_property_list(istream& in) { - skip_whitespace_but_not_newline(in); - if (!has_data(in)) return NULL; - string_tree* first = new string_tree(slurp_until(in, ':')); - if (!has_data(in)) return first; - string_tree* rest = parse_property_list(in); - if (!has_data(in) && rest->atom) - return new string_tree(first, new string_tree(rest, NULL)); - return new string_tree(first, rest); -} -:(before "End Unit Tests") -void test_parse_property_list_atom() { - istringstream in("a"); - string_tree* x = parse_property_list(in); - CHECK(x->atom); - delete x; -} -void test_parse_property_list_list() { - istringstream in("a:b"); - string_tree* x = parse_property_list(in); - CHECK(!x->atom); - CHECK(x->left->atom); - CHECK_EQ(x->left->value, "a"); - CHECK(!x->right->atom); - CHECK(x->right->left->atom); - CHECK_EQ(x->right->left->value, "b"); - CHECK(x->right->right == NULL); - delete x; -} - -:(code) -type_tree* new_type_tree(const string_tree* properties) { - if (!properties) return NULL; - if (properties->atom) { - const string& type_name = properties->value; - int value = 0; - if (contains_key(Type_ordinal, type_name)) - value = get(Type_ordinal, type_name); - else if (is_integer(type_name)) // sometimes types will contain literal integers, like for the size of an array - value = 0; - else if (properties->value == "->") // used in recipe types - value = 0; - else - value = -1; // should never happen; will trigger errors later - return new type_tree(type_name, value); - } - return new type_tree(new_type_tree(properties->left), - new_type_tree(properties->right)); -} - -//: avoid memory leaks for the type tree - -reagent::reagent(const reagent& other) { - original_string = other.original_string; - name = other.name; - value = other.value; - initialized = other.initialized; - for (int i = 0; i < SIZE(other.properties); ++i) { - properties.push_back(pair<string, string_tree*>(other.properties.at(i).first, copy(other.properties.at(i).second))); - } - type = copy(other.type); - // End reagent Copy Constructor -} - -type_tree::type_tree(const type_tree& original) { - atom = original.atom; - name = original.name; - value = original.value; - left = copy(original.left); - right = copy(original.right); -} - -type_tree& type_tree::operator=(const type_tree& original) { - atom = original.atom; - name = original.name; - value = original.value; - if (left) delete left; - left = copy(original.left); - if (right) delete right; - right = copy(original.right); - return *this; -} - -bool type_tree::operator==(const type_tree& other) const { - if (atom != other.atom) return false; - if (atom) - return name == other.name && value == other.value; - return (left == other.left || *left == *other.left) - && (right == other.right || *right == *other.right); -} - -// only constraint we care about: if a < b then !(b < a) -bool type_tree::operator<(const type_tree& other) const { - if (atom != other.atom) return atom > other.atom; // atoms before non-atoms - if (atom) return value < other.value; - // first location in one that's missing in the other makes that side 'smaller' - if (left && !other.left) return false; - if (!left && other.left) return true; - if (right && !other.right) return false; - if (!right && other.right) return true; - // now if either pointer is unequal neither side can be null - // if one side is equal that's easy - if (left == other.left || *left == *other.left) return right && *right < *other.right; - if (right == other.right || *right == *other.right) return left && *left < *other.left; - // if the two sides criss-cross, pick the side with the smaller lhs - if ((left == other.right || *left == *other.right) - && (right == other.left || *right == *other.left)) - return *left < *other.left; - // now the hard case: both sides are not equal - // make sure we stay consistent between (a < b) and (b < a) - // just return the side with the smallest of the 4 branches - if (*left < *other.left && *left < *other.right) return true; - if (*right < *other.left && *right < *other.right) return true; - return false; -} -:(before "End Unit Tests") -// These unit tests don't always use valid types. -void test_compare_atom_types() { - reagent a("a:address"), b("b:boolean"); - CHECK(*a.type < *b.type); - CHECK(!(*b.type < *a.type)); -} -void test_compare_equal_atom_types() { - reagent a("a:address"), b("b:address"); - CHECK(!(*a.type < *b.type)); - CHECK(!(*b.type < *a.type)); -} -void test_compare_atom_with_non_atom() { - reagent a("a:address:number"), b("b:boolean"); - CHECK(!(*a.type < *b.type)); - CHECK(*b.type < *a.type); -} -void test_compare_lists_with_identical_structure() { - reagent a("a:address:address"), b("b:address:boolean"); - CHECK(*a.type < *b.type); - CHECK(!(*b.type < *a.type)); -} -void test_compare_identical_lists() { - reagent a("a:address:boolean"), b("b:address:boolean"); - CHECK(!(*a.type < *b.type)); - CHECK(!(*b.type < *a.type)); -} -void test_compare_list_with_extra_element() { - reagent a("a:address:address"), b("b:address:address:number"); - CHECK(*a.type < *b.type); - CHECK(!(*b.type < *a.type)); -} -void test_compare_list_with_smaller_left_but_larger_right() { - reagent a("a:number:character"), b("b:boolean:array"); - CHECK(*a.type < *b.type); - CHECK(!(*b.type < *a.type)); -} -void test_compare_list_with_smaller_left_but_larger_right_identical_types() { - reagent a("a:address:boolean"), b("b:boolean:address"); - CHECK(*a.type < *b.type); - CHECK(!(*b.type < *a.type)); -} - -:(code) -string_tree::string_tree(const string_tree& original) { - atom = original.atom; - value = original.value; - left = copy(original.left); - right = copy(original.right); -} - -reagent& reagent::operator=(const reagent& other) { - original_string = other.original_string; - for (int i = 0; i < SIZE(properties); ++i) - if (properties.at(i).second) delete properties.at(i).second; - properties.clear(); - for (int i = 0; i < SIZE(other.properties); ++i) - properties.push_back(pair<string, string_tree*>(other.properties.at(i).first, copy(other.properties.at(i).second))); - name = other.name; - value = other.value; - initialized = other.initialized; - if (type) delete type; - type = copy(other.type); - // End reagent Copy Operator - return *this; -} - -reagent::~reagent() { - clear(); -} - -void reagent::clear() { - for (int i = 0; i < SIZE(properties); ++i) { - if (properties.at(i).second) { - delete properties.at(i).second; - properties.at(i).second = NULL; - } - } - delete type; - type = NULL; -} -type_tree::~type_tree() { - delete left; - delete right; -} -string_tree::~string_tree() { - delete left; - delete right; -} - -void append(type_tree*& base, type_tree* extra) { - if (!base) { - base = extra; - return; - } - type_tree* curr = base; - while (curr->right) curr = curr->right; - curr->right = extra; -} - -void append(string_tree*& base, string_tree* extra) { - if (!base) { - base = extra; - return; - } - string_tree* curr = base; - while (curr->right) curr = curr->right; - curr->right = extra; -} - -string slurp_until(istream& in, char delim) { - ostringstream out; - char c; - while (in >> c) { - if (c == delim) { - // drop the delim - break; - } - out << c; - } - return out.str(); -} - -bool has_property(const reagent& x, const string& name) { - for (int i = 0; i < SIZE(x.properties); ++i) { - if (x.properties.at(i).first == name) return true; - } - return false; -} - -string_tree* property(const reagent& r, const string& name) { - for (int p = 0; p != SIZE(r.properties); ++p) { - if (r.properties.at(p).first == name) - return r.properties.at(p).second; - } - return NULL; -} - -string_tree* copy(const string_tree* x) { - if (x == NULL) return NULL; - return new string_tree(*x); -} - -type_tree* copy(const type_tree* x) { - if (x == NULL) return NULL; - return new type_tree(*x); -} - -:(before "End Globals") -extern const string Ignore(","); // commas are ignored in Mu except within [] strings -:(code) -void skip_whitespace_but_not_newline(istream& in) { - while (true) { - if (!has_data(in)) break; - else if (in.peek() == '\n') break; - else if (isspace(in.peek())) in.get(); - else if (Ignore.find(in.peek()) != string::npos) in.get(); - else break; - } -} - -void dump_memory() { - for (map<int, double>::iterator p = Memory.begin(); p != Memory.end(); ++p) { - cerr << p->first << ": " << no_scientific(p->second) << '\n'; - } -} - -//:: Helpers for converting various values to string -//: Use to_string() in trace(), and try to keep it stable from run to run. -//: Use debug_string() while debugging, and throw everything into it. -//: Use inspect() only for emitting a canonical format that can be parsed back -//: into the value. - -string to_string(const recipe& r) { - ostringstream out; - out << "recipe " << r.name << " [\n"; - for (int i = 0; i < SIZE(r.steps); ++i) - out << " " << to_string(r.steps.at(i)) << '\n'; - out << "]\n"; - return out.str(); -} - -string to_original_string(const recipe& r) { - ostringstream out; - out << "recipe " << r.name << " [\n"; - for (int i = 0; i < SIZE(r.steps); ++i) - out << " " << to_original_string(r.steps.at(i)) << '\n'; - out << "]\n"; - return out.str(); -} - -string debug_string(const recipe& x) { - ostringstream out; - out << "- recipe " << x.name << '\n'; - // Begin debug_string(recipe x) - for (int index = 0; index < SIZE(x.steps); ++index) { - const instruction& inst = x.steps.at(index); - out << "inst: " << to_string(inst) << '\n'; - out << " ingredients\n"; - for (int i = 0; i < SIZE(inst.ingredients); ++i) - out << " " << debug_string(inst.ingredients.at(i)) << '\n'; - out << " products\n"; - for (int i = 0; i < SIZE(inst.products); ++i) - out << " " << debug_string(inst.products.at(i)) << '\n'; - } - return out.str(); -} - -string to_original_string(const instruction& inst) { - if (inst.is_label) return inst.label; - if (!inst.original_string.empty()) return inst.original_string; - ostringstream out; - for (int i = 0; i < SIZE(inst.products); ++i) { - if (i > 0) out << ", "; - out << inst.products.at(i).original_string; - } - if (!inst.products.empty()) out << " <- "; - out << inst.name; - if (!inst.ingredients.empty()) out << ' '; - for (int i = 0; i < SIZE(inst.ingredients); ++i) { - if (i > 0) out << ", "; - out << inst.ingredients.at(i).original_string; - } - return out.str(); -} - -string to_string(const instruction& inst) { - if (inst.is_label) return inst.label; - ostringstream out; - for (int i = 0; i < SIZE(inst.products); ++i) { - if (i > 0) out << ", "; - out << to_string(inst.products.at(i)); - } - if (!inst.products.empty()) out << " <- "; - out << inst.name << ' '; - for (int i = 0; i < SIZE(inst.ingredients); ++i) { - if (i > 0) out << ", "; - out << to_string(inst.ingredients.at(i)); - } - return out.str(); -} - -string to_string(const reagent& r) { - if (is_dummy(r)) return "_"; - ostringstream out; - out << "{"; - out << r.name << ": " << names_to_string(r.type); - if (!r.properties.empty()) { - for (int i = 0; i < SIZE(r.properties); ++i) - out << ", \"" << r.properties.at(i).first << "\": " << to_string(r.properties.at(i).second); - } - out << "}"; - return out.str(); -} - -// special name for ignoring some products -bool is_dummy(const reagent& x) { - return x.name == "_"; -} - -string debug_string(const reagent& x) { - ostringstream out; - out << x.name << ": " << x.value << ' ' << to_string(x.type) << " -- " << to_string(x); - return out.str(); -} - -string to_string(const string_tree* property) { - if (!property) return "()"; - ostringstream out; - dump(property, out); - return out.str(); -} - -void dump(const string_tree* x, ostream& out) { - if (!x) return; - if (x->atom) { - out << '"' << x->value << '"'; - return; - } - out << '('; - const string_tree* curr = x; - while (curr && !curr->atom) { - dump(curr->left, out); - if (curr->right) out << ' '; - curr = curr->right; - } - // check for dotted list; should never happen - if (curr) { - out << ". "; - dump(curr, out); - } - out << ')'; -} - -string to_string(const type_tree* type) { - if (type == NULL) return "()"; - ostringstream out; - dump(type, out); - return out.str(); -} - -void dump(const type_tree* x, ostream& out) { - if (!x) return; - if (x->atom) { - dump(x->value, out); - return; - } - out << '('; - const type_tree* curr = x; - while (curr && !curr->atom) { - dump(curr->left, out); - if (curr->right) out << ' '; - curr = curr->right; - } - // check for dotted list; should never happen - if (curr) { - out << ". "; - dump(curr, out); - } - out << ')'; -} - -void dump(type_ordinal type, ostream& out) { - if (contains_key(Type, type)) - out << get(Type, type).name; - else - out << "?" << type; -} - -string names_to_string(const type_tree* type) { - if (type == NULL) return "()"; // should never happen - ostringstream out; - dump_names(type, out); - return out.str(); -} - -void dump_names(const type_tree* x, ostream& out) { - if (!x) return; - if (x->atom) { - out << '"' << x->name << '"'; - return; - } - out << '('; - const type_tree* curr = x; - while (curr && !curr->atom) { - dump_names(curr->left, out); - if (curr->right) out << ' '; - curr = curr->right; - } - // check for dotted list; should never happen - if (curr) { - out << ". "; - dump_names(curr, out); - } - out << ')'; -} - -string names_to_string_without_quotes(const type_tree* type) { - if (type == NULL) return "()"; - ostringstream out; - dump_names_without_quotes(type, out); - return out.str(); -} - -void dump_names_without_quotes(const type_tree* x, ostream& out) { - if (!x) return; - if (x->atom) { - out << x->name; - return; - } - out << '('; - const type_tree* curr = x; - while (curr && !curr->atom) { - dump_names_without_quotes(curr->left, out); - if (curr->right) out << ' '; - curr = curr->right; - } - // check for dotted list; should never happen - if (curr) { - out << ". "; - dump_names_without_quotes(curr, out); - } - out << ')'; -} - -bool is_integer(const string& s) { - return s.find_first_not_of("0123456789-") == string::npos // no other characters - && s.find_first_of("0123456789") != string::npos // at least one digit - && s.find('-', 1) == string::npos; // '-' only at first position -} - -int to_integer(string n) { - char* end = NULL; - // safe because string.c_str() is guaranteed to be null-terminated - int result = strtoll(n.c_str(), &end, /*any base*/0); - if (*end != '\0') cerr << "tried to convert " << n << " to number\n"; - assert(*end == '\0'); - return result; -} - -void test_is_integer() { - CHECK(is_integer("1234")); - CHECK(is_integer("-1")); - CHECK(!is_integer("234.0")); - CHECK(is_integer("-567")); - CHECK(!is_integer("89-0")); - CHECK(!is_integer("-")); - CHECK(!is_integer("1e3")); // not supported -} - -//: helper to print numbers without excessive precision - -:(before "End Types") -struct no_scientific { - double x; - explicit no_scientific(double y) :x(y) {} -}; - -:(code) -ostream& operator<<(ostream& os, no_scientific x) { - if (!isfinite(x.x)) { - // Infinity or NaN - os << x.x; - return os; - } - ostringstream tmp; - // more accurate, but too slow -//? tmp.precision(308); // for 64-bit numbers - tmp << std::fixed << x.x; - os << trim_floating_point(tmp.str()); - return os; -} - -string trim_floating_point(const string& in) { - if (in.empty()) return ""; - if (in.find('.') == string::npos) return in; - int length = SIZE(in); - while (length > 1) { - if (in.at(length-1) != '0') break; - --length; - } - if (in.at(length-1) == '.') --length; - if (length == 0) return "0"; - return in.substr(0, length); -} - -void test_trim_floating_point() { - CHECK_EQ(trim_floating_point(""), ""); - CHECK_EQ(trim_floating_point(".0"), "0"); - CHECK_EQ(trim_floating_point("1.5000"), "1.5"); - CHECK_EQ(trim_floating_point("1.000001"), "1.000001"); - CHECK_EQ(trim_floating_point("23.000000"), "23"); - CHECK_EQ(trim_floating_point("23.0"), "23"); - CHECK_EQ(trim_floating_point("23."), "23"); - CHECK_EQ(trim_floating_point("23"), "23"); - CHECK_EQ(trim_floating_point("230"), "230"); - CHECK_EQ(trim_floating_point("3.000000"), "3"); - CHECK_EQ(trim_floating_point("3.0"), "3"); - CHECK_EQ(trim_floating_point("3."), "3"); - CHECK_EQ(trim_floating_point("3"), "3"); -} - -:(before "End Includes") -#include <map> -using std::map; -#include <utility> -using std::pair; -#include <math.h> |